diff --git a/docs/environment.yaml b/docs/environment.yaml index 6c221e121..80bc95e54 100644 --- a/docs/environment.yaml +++ b/docs/environment.yaml @@ -33,6 +33,8 @@ dependencies: - git+https://github.com/OpenFreeEnergy/kartograf@main - git+https://github.com/OpenFreeEnergy/konnektor@main - git+https://github.com/OpenFreeEnergy/lomap@main + - git+https://github.com/OpenFreeEnergy/exorcist@main + # These are added automatically by RTD, so we include them here # for a consistent environment. diff --git a/environment.yml b/environment.yml index e788eab3c..e6736a22b 100644 --- a/environment.yml +++ b/environment.yml @@ -56,6 +56,7 @@ dependencies: - git+https://github.com/OpenFreeEnergy/kartograf@main # needs gufe which pins to pydantic < 2.13. update this once gufe v1.13 is released on conda-forge - git+https://github.com/OpenFreeEnergy/konnektor@main - git+https://github.com/OpenFreeEnergy/gufe@main + - git+https://github.com/OpenFreeEnergy/exorcist@main - run_constrained: # drop this pin when handled upstream in espaloma-feedstock - smirnoff99frosst>=1.1.0.1 #https://github.com/openforcefield/smirnoff99Frosst/issues/109 diff --git a/news/cli_headers.rst b/news/cli_headers.rst new file mode 100644 index 000000000..661046bf8 --- /dev/null +++ b/news/cli_headers.rst @@ -0,0 +1,23 @@ +**Added:** + +* + +**Changed:** + +* Changed CLI sections from "Network Planning", "Quickrun Exectutor" and "Miscellaneous" to "Planning & Setup", "Execution", "Results Gathering", and "Miscellaneous". + +**Deprecated:** + +* + +**Removed:** + +* + +**Fixed:** + +* + +**Security:** + +* diff --git a/news/cli_status.rst b/news/cli_status.rst new file mode 100644 index 000000000..51630d1e1 --- /dev/null +++ b/news/cli_status.rst @@ -0,0 +1,23 @@ +**Added:** + +* Added ``openfe status`` command (`PR #2156 `_) that shows the status of all tasks in a worker task database. + +**Changed:** + +* + +**Deprecated:** + +* + +**Removed:** + +* + +**Fixed:** + +* + +**Security:** + +* diff --git a/news/warehouse.rst b/news/warehouse.rst new file mode 100644 index 000000000..8e7d5dc20 --- /dev/null +++ b/news/warehouse.rst @@ -0,0 +1,23 @@ +**Added:** + +* Added ``openfe.storage.warehouse``, which includes ``WarehouseBaseClass`` and the example implementation ``FileSystemWarehouse``. + +**Changed:** + +* + +**Deprecated:** + +* + +**Removed:** + +* Removed the unused methods ``metadatastore``, ``resultclient``, and ``resultserver`` from ``openfe.storage``. + +**Fixed:** + +* + +**Security:** + +* diff --git a/src/openfe/orchestration/__init__.py b/src/openfe/orchestration/__init__.py index e69de29bb..1cf41033f 100644 --- a/src/openfe/orchestration/__init__.py +++ b/src/openfe/orchestration/__init__.py @@ -0,0 +1,8 @@ +from exorcist.taskdb import TaskStatusDB + +from .exorcist_utils import ( + build_task_db_from_alchemical_network, + get_dependency_df, + get_task_df, +) +from .worker import Worker diff --git a/src/openfe/orchestration/exorcist_utils.py b/src/openfe/orchestration/exorcist_utils.py new file mode 100644 index 000000000..a7516c6ce --- /dev/null +++ b/src/openfe/orchestration/exorcist_utils.py @@ -0,0 +1,144 @@ +"""Utilities for building Exorcist task graphs and task databases. + +This module translates an :class:`gufe.AlchemicalNetwork` into Exorcist task +structures and can initialize an Exorcist task database from that graph. +""" + +from pathlib import Path + +import exorcist +import networkx as nx +import pandas as pd +from gufe import AlchemicalNetwork, ProtocolDAG + +from ..storage.warehouse import FileSystemWarehouse, WarehouseBaseClass + + +def _alchemical_network_to_task_graph( + alchemical_network: AlchemicalNetwork, + warehouse: WarehouseBaseClass, +) -> nx.DiGraph: + """Build a global task DAG from `alchemical_network` and store its relevant data + in `warehouse` the following warehouse stores: + - 'setup': The AlchemicalNetwork, deduplicated on disk + - 'tasks': The ProtocolUnits to be executed as tasks + - 'protocol_dags': The ProtocolDAGs that the ProtocolUnits belong to. + Used to gather results after execution. + + Parameters + ---------- + alchemical_network : AlchemicalNetwork + Network containing alchemical Transformations to be executed. + warehouse : WarehouseBaseClass + Warehouse used to store data used by the execution and simulation engines. + + Returns + ------- + nx.DiGraph + A directed acyclic graph where each node is a task ID with the ProtocolUnit key as a name + and edges encode protocol-unit dependencies. + + Raises + ------ + ValueError + If the assembled task graph is not acyclic. + If the input `alchemical_network` is not a valid openfe.AlchemicalNetwork + """ + + if not isinstance(alchemical_network, AlchemicalNetwork): + raise ValueError( + f"alchemical_network must be an AlchemicalNetwork, not {type(alchemical_network)}." + ) + + warehouse.store_setup_tokenizable(alchemical_network) + + global_task_dag = nx.DiGraph() + for transformation in alchemical_network.edges: + dag: ProtocolDAG = transformation.create() # TODO: skip edges that already have units? + for unit in dag.protocol_units: + global_task_dag.add_node(str(unit.key)) + warehouse.store_task(unit) + for dependent_unit, dependency_unit in dag.graph.edges: + upstream_id = str(dependency_unit.key) + downstream_id = str(dependent_unit.key) + global_task_dag.add_edge(upstream_id, downstream_id) + + # at this point, stored as a shallow dict since all its units are already stored + warehouse.store_protocol_dag(dag) + + if not nx.is_directed_acyclic_graph(global_task_dag): + raise ValueError("AlchemicalNetwork produced a task graph that is not a DAG.") + + return global_task_dag + + +def build_task_db_from_alchemical_network( + alchemical_network: AlchemicalNetwork, + warehouse_dir: Path, # TODO: make optional? + db_path: Path, # TODO: make optional? + max_tries: int = 1, +) -> tuple[exorcist.TaskStatusDB, FileSystemWarehouse]: + """Create a task database and FileSystemWarehouse from an alchemical network. + + Parameters + ---------- + alchemical_network : AlchemicalNetwork + ``AlchemicalNetwork`` containing transformations to convert into task records. + warehouse_dir : pathlib.Path + Root directory at which to create a FileSystemWarehouse (e.g. ``campaign_name/``). + db_path : pathlib.Path + Location to store the SQLite-backed Exorcist database (e.g. ``campaign_name.db``). + max_tries : int, default=1 + Maximum number of times a task will attempt to be submitted before it + is labelled ``TOO_MANY_RETRIES``. + + Returns + ------- + exorcist.TaskStatusDB + Initialized task database populated with graph nodes and dependency + edges derived from ``alchemical_network``. + """ + # require starting clean each time for now - guardrails around modifying existing state can come later + if Path(db_path).exists(): + raise FileExistsError(f"Error: {db_path} cannot already exist.") + warehouse = FileSystemWarehouse(warehouse_dir, exist_ok=False) + global_task_dag: nx.DiGraph = _alchemical_network_to_task_graph(alchemical_network, warehouse) + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(global_task_dag, max_tries) + return db, warehouse + + +def get_task_df(task_db: exorcist.TaskStatusDB) -> pd.DataFrame: + """Create a pandas Dataframe from task_db. + + Parameters + ---------- + task_db : exorcist.TaskStatusDB + A task database. + + Returns + ------- + pd.DataFrame + A dataframe of the tasks and their statuses + """ + status_name_encoding = {e.value: e.name for e in exorcist.TaskStatus} + task_table = pd.read_sql_table("tasks", task_db.engine) + task_table.replace({"status": status_name_encoding}, inplace=True) + return task_table + + +def get_dependency_df(task_db: exorcist.TaskStatusDB) -> pd.DataFrame: + """Create a pandas Dataframe from task_db. + + Parameters + ---------- + task_db : exorcist.TaskStatusDB + A task database. + + Returns + ------- + pd.DataFrame + A dataframe of the tasks and their dependencies. + + """ + return pd.read_sql_table("dependencies", task_db.engine) diff --git a/src/openfe/orchestration/worker.py b/src/openfe/orchestration/worker.py new file mode 100644 index 000000000..3e1110cd0 --- /dev/null +++ b/src/openfe/orchestration/worker.py @@ -0,0 +1,240 @@ +from collections.abc import Iterable +from dataclasses import dataclass +from pathlib import Path + +from exorcist.taskdb import TaskStatusDB +from gufe.protocols.protocoldag import _pu_to_pur +from gufe.protocols.protocolunit import ( + Context, + ProtocolUnit, + ProtocolUnitResult, +) +from gufe.storage.externalresource.base import ExternalStorage +from gufe.storage.externalresource.filestorage import FileStorage +from gufe.tokenization import GufeKey + +from ..storage.warehouse import FileSystemWarehouse + + +@dataclass +class Worker: + """Execute protocol units from a task database. + + Parameters + ---------- + warehouse : FileSystemWarehouse + FileSystemWarehouse used to load queued tasks and store execution results. + task_db_path : pathlib.Path, default=Path("./warehouse/tasks.db") + Path to the Exorcist SQLite task database. + """ + + warehouse: FileSystemWarehouse + task_db_path: Path = Path("./warehouse/tasks.db") + + _RESULT_INDEX_PREFIX = "protocol_unit_results" + _TASK_WORKDIR_PREFIX = "task_workdirs" + + @staticmethod + def _collect_protocol_unit_keys(value: object) -> set[GufeKey]: + """Collect `ProtocolUnit` keys from nested unit inputs.""" + + if isinstance(value, ProtocolUnit): + return {value.key} + + found: set[GufeKey] = set() + items: Iterable # TODO: update this to dict_values | list after python 3.13 min? + if isinstance(value, dict): + items = value.values() + elif isinstance(value, list): + items = value + else: + return found + + for item in items: + found.update(Worker._collect_protocol_unit_keys(item)) + return found + + @classmethod + def _result_index_location(cls, source_key: GufeKey) -> str: + return f"{cls._RESULT_INDEX_PREFIX}/{source_key}" + + @classmethod + def _task_workdir_name(cls, taskid: str) -> str: + return taskid.replace(":", "__") + + def _task_workspace_paths( + self, taskid: str, scratch_root: Path, shared_root: Path + ) -> tuple[Path, Path]: + workdir_name = self._task_workdir_name(taskid) + task_scratch = scratch_root / self._TASK_WORKDIR_PREFIX / workdir_name + task_shared = shared_root / self._TASK_WORKDIR_PREFIX / workdir_name + return task_scratch, task_shared + + def _store_result_index(self, result: ProtocolUnitResult) -> None: + shared_store: ExternalStorage = self.warehouse.stores["shared"] + location = self._result_index_location(result.source_key) + shared_store.store_bytes(location, str(result.key).encode("utf-8")) + + def _load_result_from_index(self, source_key: GufeKey) -> ProtocolUnitResult | None: + shared_store: ExternalStorage = self.warehouse.stores["shared"] + location = self._result_index_location(source_key) + + if not shared_store.exists(location): + return None + + with shared_store.load_stream(location) as stream: + result_key = stream.read().decode("utf-8").strip() + + loaded = self.warehouse.load_results_tokenizable(GufeKey(result_key)) + if isinstance(loaded, ProtocolUnitResult): + return loaded + + return None + + def _scan_result_store_for_sources( + self, source_keys: set[GufeKey] + ) -> dict[GufeKey, ProtocolUnitResult]: + found: dict[GufeKey, ProtocolUnitResult] = {} + + for location in self.warehouse.result_store.iter_contents(): + if len(found) == len(source_keys): + break + + loaded = self.warehouse.load_results_tokenizable(GufeKey(location)) + if not isinstance(loaded, ProtocolUnitResult): + continue + + source_key = loaded.source_key + if source_key in source_keys and source_key not in found: + found[source_key] = loaded + + return found + + def _build_input_result_mapping(self, unit: ProtocolUnit) -> dict[GufeKey, ProtocolUnitResult]: + # TODO: use unit.dependencies instead of _collect_protocol_unit_keys? + required_keys = self._collect_protocol_unit_keys(unit.inputs) + if not required_keys: + return {} + + results: dict[GufeKey, ProtocolUnitResult] = {} + unresolved = set(required_keys) + + for source_key in required_keys: + loaded = self._load_result_from_index(source_key) + if loaded is not None: + results[source_key] = loaded + unresolved.discard(source_key) + + if unresolved: + scanned = self._scan_result_store_for_sources(unresolved) + for source_key, loaded in scanned.items(): + results[source_key] = loaded + self._store_result_index(loaded) + unresolved.discard(source_key) + + if unresolved: + missing_keys = ", ".join(sorted(str(k) for k in unresolved)) + raise RuntimeError( + "Missing ProtocolUnitResult(s) for dependency key(s): " + f"{missing_keys}. Ensure upstream tasks completed successfully." + ) + + return results + + def _checkout_task(self) -> tuple[TaskStatusDB, str, ProtocolUnit] | None: + """Check out one available task and load its protocol unit. + + Returns + ------- + tuple[TaskStatusDB, str, ProtocolUnit] or None + The open database connection, checked-out task ID, and corresponding + protocol unit, or ``None`` if no task is currently available. + The caller is responsible for calling ``mark_task_completed`` on the + returned database using the returned task ID. + """ + + db: TaskStatusDB = TaskStatusDB.from_filename(self.task_db_path) + # The format for the taskid is "ProtocolUnit-" + taskid = db.check_out_task() + if taskid is None: + return None + + protocol_unit_key = taskid + unit = self.warehouse.load_task(GufeKey(protocol_unit_key)) + return db, taskid, unit + + def _get_task(self) -> tuple[str, ProtocolUnit]: + """Return the next available task ID and protocol unit. + + Returns + ------- + tuple[str, ProtocolUnit] + The checked-out task ID and corresponding protocol unit. + + Raises + ------ + RuntimeError + Raised when no task is available in the task database. + """ + + task = self._checkout_task() + if task is None: + raise RuntimeError("No AVAILABLE tasks found in the task database.") + db, taskid, unit = task + return taskid, unit + + def execute_unit(self, scratch: Path | str) -> tuple[str, ProtocolUnitResult] | None: + """Execute one checked-out ProtocolUnit and persist its result. + + Parameters + ---------- + scratch : pathlib.Path | str + Scratch directory passed to the protocol execution context. + + Returns + ------- + tuple[str, ProtocolUnitResult] | None + The task ID and execution result for the processed task, or + ``None`` if no task is currently available. + + Raises + ------ + Exception + Re-raises any exception thrown during protocol unit execution after + marking the task as failed. + """ + # TODO: split per-execution work into a helper function and add an "n" option here? + scratch = Path(scratch) + # 1. Get task/unit + task = self._checkout_task() + if task is None: + return None + db, taskid, unit = task + # 2. Construct the context + # NOTE: On changes to context (gufe PR #753), this can easily be replaced with external storage objects + # However, to satisfy the current work, we will use this implementation where we + # force the use of a FileSystemWarehouse and in turn can assert that an object is FileStorage. + shared_store = self.warehouse.stores["shared"] + if not isinstance(shared_store, FileStorage): + raise TypeError("Expected a FileStorage backend for the shared store") + shared_root_dir = shared_store.root_dir + task_scratch, task_shared = self._task_workspace_paths(taskid, scratch, shared_root_dir) + task_scratch.mkdir(parents=True, exist_ok=True) + task_shared.mkdir(parents=True, exist_ok=True) + ctx = Context(task_scratch, shared=task_shared) + # 3. Execute unit + try: + # TODO: this var naming is confusing + results: dict[GufeKey, ProtocolUnitResult] = self._build_input_result_mapping(unit) + inputs: dict[GufeKey, ProtocolUnitResult] = _pu_to_pur(unit.inputs, results) + result = unit.execute(context=ctx, **inputs) + except Exception: + db.mark_task_completed(taskid, success=False) + raise + + db.mark_task_completed(taskid, success=result.ok()) + # 4. output result to warehouse + # TODO: we may need to end up handling namespacing on the warehouse side for tokenizables + self.warehouse.store_results_tokenizable(result) + self._store_result_index(result) + return taskid, result diff --git a/src/openfe/storage/utils.py b/src/openfe/storage/utils.py new file mode 100644 index 000000000..5d4da96db --- /dev/null +++ b/src/openfe/storage/utils.py @@ -0,0 +1,56 @@ +# This code is part of OpenFE and is licensed under the MIT license. +# For details, see https://github.com/OpenFreeEnergy/gufe +import json +import pathlib + +from gufe.protocols import ProtocolResult +from gufe.protocols.protocoldag import ProtocolDAGResult +from gufe.tokenization import JSON_HANDLER + + +def convert_to_quickrun_output( + result_edges: list[tuple[ProtocolResult, ProtocolDAGResult]], + out_dir: pathlib.Path | str, +) -> None: + """Given pairs of ProtocolResult/ProtocolDAGResult, write results to JSON + file in the same output format as ``openfe quickrun``. + + Results will be written to ``out_dir`` in files named by Transformation key. + + Notice: this is a helper function meant to aid analysis of results + alongside quickrun output, and is not meant for production use! + + Parameters + ---------- + result_edges : list[tuple[ProtocolResult, ProtocolDAGResult]] + Results to write in ``openfe quickrun`` results format + out_dir : pathlib.Path | str + Directory in which to write output. + + Raises + ------ + FileExistsError + If a JSON output file already exists. + """ + # TODO: this is copied from quickrun, refactor to avoid duplication + for prot_result, dagresult in result_edges: + if dagresult.ok(): + estimate = prot_result.get_estimate() + uncertainty = prot_result.get_uncertainty() + else: + estimate = uncertainty = None # for output file + + out_dict = { + "estimate": estimate, + "uncertainty": uncertainty, + "protocol_result": prot_result.to_dict(), + "unit_results": { + unit.key: unit.to_keyed_dict() for unit in dagresult.protocol_unit_results + }, + } + pathlib.Path(out_dir).mkdir(exist_ok=True) + output = pathlib.Path(out_dir) / f"{dagresult.transformation_key}_results.json" + if output.exists(): + raise FileExistsError("output file already exists!") + with open(output, mode="w") as outf: + json.dump(out_dict, outf, cls=JSON_HANDLER.encoder) diff --git a/src/openfe/storage/warehouse.py b/src/openfe/storage/warehouse.py new file mode 100644 index 000000000..fa3ebb536 --- /dev/null +++ b/src/openfe/storage/warehouse.py @@ -0,0 +1,554 @@ +# This code is part of OpenFE and is licensed under the MIT license. +# For details, see https://github.com/OpenFreeEnergy/gufe +from __future__ import annotations + +import json +import pathlib +import re +from typing import Generator, Iterable, Literal, TypedDict + +from gufe.protocols import ProtocolResult +from gufe.protocols.protocoldag import ProtocolDAG, ProtocolDAGResult +from gufe.protocols.protocolunit import ProtocolUnit, ProtocolUnitResult +from gufe.storage.externalresource import ExternalStorage, FileStorage +from gufe.tokenization import ( + JSON_HANDLER, + GufeKey, + GufeTokenizable, + key_decode_dependencies, +) + +GUFEKEY_JSON_REGEX = re.compile('":gufe-key:": "(?P[A-Za-z0-9_]+-[0-9a-f]+)"') + + +class WarehouseStores(TypedDict): + """Typed dictionary for accessing warehouse storage locations. + + Parameters + ---------- + setup : ExternalStorage + Storage location for setup-related objects and configurations. + results : ExternalStorage + Storage location for result-related object. + shared : ExternalStorage + Storage location for non-permanent shared data. + tasks: ExternalStorage + Storage location for execution tasks. + protocol_dags: ExternalStorage + Storage location for ProtocolDAGs that correspond to the ProtocolUnits stored in 'tasks'. + + Notes + ----- + Additional stores for results and tasks may be added in future versions. + """ + + setup: ExternalStorage + results: ExternalStorage + shared: ExternalStorage + tasks: ExternalStorage + protocol_dags: ExternalStorage + + +class WarehouseBaseClass: + """Base class for warehouse storage management. + + Provides functionality to store, load, and manage GufeTokenizable objects + across different storage backends. + + Parameters + ---------- + stores : WarehouseStores + Typed dictionary containing the storage locations for different + types of objects. + + Attributes + ---------- + stores : WarehouseStores + The storage locations managed by this warehouse instance. + """ + + def __init__(self, stores: WarehouseStores, name: str): + self.stores = stores + if not isinstance(name, str) or len(name) == 0: + raise ValueError("Warehouse name must be a string.") + self.name = name + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.stores == other.stores + + def __repr__(self): + # probably should include repr of external store, too + return f"{self.__class__.__name__}({self.stores})" + + def delete(self, store_name: Literal["setup", "results"], location: str): + """Delete an object from a specific store. + + Parameters + ---------- + store_name : Literal["setup", "results"] + Name of the store to delete from. + location : str + Location/path of the object to delete. + + Raises + ------- + MissingExternalResourceError + Thrown if the object you are trying to delete, can't delete from the store + """ + # TODO: how to guard deleting an object that is needed by another GufeTokenizable? + store: ExternalStorage = self.stores[store_name] + store.delete(location) + + def store_task(self, obj: ProtocolUnit): + self._store_gufe_tokenizable("tasks", obj) + + def load_task(self, obj: GufeKey) -> ProtocolUnit: + unit = self._load_gufe_tokenizable(obj) + if not isinstance(unit, ProtocolUnit): + raise TypeError(f"Unable to load {unit} as ProtocolUnit.") + return unit + + def store_setup_tokenizable(self, obj: GufeTokenizable): + """Store a GufeTokenizable object in the setup store. + + Parameters + ---------- + obj : GufeTokenizable + The object to store. + """ + self._store_gufe_tokenizable("setup", obj) + + def load_setup_tokenizable(self, obj: GufeKey) -> GufeTokenizable: + # TODO: this doesn't actually look specifically in the setup store, which is misleading + """Load a GufeTokenizable object from the setup store. + + Parameters + ---------- + obj : GufeKey + The key of the object to load. + + Returns + ------- + GufeTokenizable + The loaded object. + """ + return self._load_gufe_tokenizable(gufe_key=obj) + + def store_results_tokenizable(self, obj: GufeTokenizable): + """Store a GufeTokenizable object to the results store. + + Parameters + ---------- + obj : GufeKey + The key of the object to store. + """ + return self._store_gufe_tokenizable("results", obj) + + def load_results_tokenizable(self, obj: GufeKey) -> GufeTokenizable: + # TODO: this doesn't actually look specifically in the result store, which is misleading + """Load a GufeTokenizable object from the result store. + + Parameters + ---------- + obj : GufeKey + The key of the object to load. + + Returns + ------- + GufeTokenizable + The loaded object. + """ + return self._load_gufe_tokenizable(gufe_key=obj) + + def store_protocol_dag(self, dag: ProtocolDAG): + """Store a ProtocolDAG in the "protocol_dags" store of this warehouse. + Parameters + ---------- + dag : ProtocolDAG + The ProtocolDAG object to store. + + Raises + ------ + TypeError + If `dag` is not a ProtocolDAG instance. + """ + if not isinstance(dag, ProtocolDAG): + raise TypeError( + f"Unable to write {dag}. Only ProtocolDAGs may be written to the 'protocol_dags' store." + ) + self._store_gufe_tokenizable("protocol_dags", dag) + + def load_protocol_dag(self, gufe_key=GufeKey) -> GufeTokenizable: + """Load a GufeTokenizable object from the protocol_dag store. + + Parameters + ---------- + obj : GufeKey + The key of the protocoldag to load. + + Returns + ------- + GufeTokenizable + The loaded object. + + Raises + ------ + TypeError + If `gufe_key` does not corresponds to an object that is not a ProtocolDAG instance. + """ + obj = self._load_gufe_tokenizable(gufe_key=gufe_key) + if not isinstance(obj, ProtocolDAG): + raise TypeError(f"Unable to load {obj} as ProtocolDAG.") + return obj + + def exists(self, key: GufeKey) -> bool: + """Check if an object with the given key exists in any store that holds tokenizables. + + Parameters + ---------- + key : GufeKey + The key to check for existence. + + Returns + ------- + bool + True if the object exists, False otherwise. + """ + # TODO: resolve type checking + return any(key in store for store in self.stores.values()) # type: ignore + + def _get_store_for_key(self, key: GufeKey) -> ExternalStorage: + """Function to find the store in which a gufe key is stored in. + + Parameters + ---------- + key : GufeKey + The key to locate. + + Returns + ------- + ExternalStorage + The store containing the key. + + Raises + ------ + ValueError + If the key is not found in any store. + """ + # TODO: resolve mypy Literal/str conflict here + # https://mypy.readthedocs.io/en/stable/literal_types.html + for name in self.stores: + if key in self.stores[name]: # type: ignore + return self.stores[name] # type: ignore + raise ValueError(f"GufeKey {key} is not stored") + + def _store_gufe_tokenizable( + self, + store_name: Literal["setup", "results", "tasks", "protocol_dags"], + obj: GufeTokenizable, + name: str | None = None, + ): + """Store a GufeTokenizable object with deduplication. + + Parameters + ---------- + store_name : Literal["setup"] + Name of the store to store the object in. + obj : GufeTokenizable + The object to store. + + Notes + ----- + This function performs deduplication by checking if the object + already exists in any store before storing. + """ + # Try and get the key for the given store + target: ExternalStorage = self.stores[store_name] + # Get all of the sub-objects + chain = obj.to_keyed_chain() + for item in chain: + gufe_key = GufeKey(item[0]) + keyed_dict = item[1] + if not self.exists(gufe_key): + data = json.dumps(keyed_dict, cls=JSON_HANDLER.encoder, sort_keys=True).encode( + "utf-8" + ) + if name: + target.store_bytes(name, data) + else: + target.store_bytes(gufe_key, data) + + # TODO: we should also be able to load from JSON, without knowing the gufe key in advance. + def _load_gufe_tokenizable(self, gufe_key: GufeKey) -> GufeTokenizable: + """Load a deduplicated object from a GufeKey. + + Parameters + ---------- + gufe_key : GufeKey + The key of the object to load. + + Returns + ------- + GufeTokenizable + The loaded object with all dependencies resolved. + + Notes + ----- + Uses depth-first search to rebuild object hierarchy and ensure + proper deduplication in memory. + """ + registry: dict[GufeKey, GufeTokenizable] = {} + + def recursive_build_object_cache(key: GufeKey) -> GufeTokenizable: + """DFS to rebuild object hierarchy. + + Parameters + ---------- + key : GufeKey + The key of the object to build. + + Returns + ------- + GufeTokenizable + The reconstructed object. + """ + # This implementation is a bit fragile, because ensuring that we + # don't duplicate objects in memory depends on the fact that + # `key_decode_dependencies` gets keyencoded objects from a cache + # (they are cached on creation). + store = self._get_store_for_key(key=key) + + with store.load_stream(key) as f: + keyencoded_json = f.read().decode("utf-8") + + dct = json.loads(keyencoded_json, cls=JSON_HANDLER.decoder) + # this implementation may seem strange, but it will be a + # faster than traversing the dict + key_encoded = set(GUFEKEY_JSON_REGEX.findall(keyencoded_json)) + + # this approach takes the dct instead of the json str + # found = [] + # modify_dependencies(dct, found.append, is_gufe_key_dict) + # key_encoded = {d[":gufe-key:"] for d in found} + + for key in key_encoded: + # obj = GufeTokenizable.from_dict(dct) + recursive_build_object_cache(key) + # obj = GufeTokenizable.from_json(content=keyencoded_json) + + if len(key_encoded) == 0: + # fast path for objects that don't contain other gufe + # objects (these tend to be larger dicts; avoid walking + # them) + obj = GufeTokenizable.from_dict(dct) + # objects that contain other gufe objects need be walked to + # replace everything + else: + obj = key_decode_dependencies(dct, registry) + # + registry[obj.key] = obj + return obj + + return recursive_build_object_cache(gufe_key) + + def get_protocol_dags(self) -> Generator[ProtocolDAG, None, None]: + """Yield the protocol dags present in the Warehouse's 'protocol_dags' store. + + Note that this requires the name of the item to start with 'ProtocolDAG'. + + Yields + ------ + Generator[ProtocolDAG] + The ProtocolDAGs found in this Warehouse's 'protocol_dags' store. + """ + for item in self.stores["protocol_dags"]: + dag = self.load_protocol_dag(item) + yield dag + + def get_unit_results(self) -> Generator[ProtocolUnitResult]: + """Yield all ProtocolUnitResult(s) stored in the Warehouse's 'result' store. + + Yields + ------ + Generator[ProtocolUnitResult] + The ProtocolUnitResults found in this Warehouse's 'result' store + + Raises + ------ + RuntimeError + If any object in the result store is not a ProtocolUnitResult + """ + for i in self.stores["results"]: + obj = self.load_results_tokenizable(i) + if isinstance(obj, ProtocolUnitResult): + yield obj + else: + raise RuntimeError( + f"gufe tokenizable {obj} found in result store, but is not a ProtocolUnitResult." + ) + + def gather_all_results(self) -> list[tuple[ProtocolResult, ProtocolDAGResult]]: + """From this warehouse, gather all ProtocolDAGResults corresponding to the recorded + ProtocolDAGs, and return all (ProtocolResult, ProtocolDAGResult) pairs. + + Note: this requires the Warehouse to explicitly have stored the ProtocolDAGs and + their ProtocolUnits when constructing the task graph. + + Returns + ------- + list[tuple[ProtocolResult, ProtocolDAGResult]] + ProtocolResults and their corresponding ProtocolDAGResults + """ + + def construct_results_edge( + protocol_dag: ProtocolDAG, + dags_to_unit_results: dict[str, list[ProtocolUnitResult]], + ) -> ProtocolDAGResult: + + # TODO: should we store the transformation as well for completeness? + transformation = self.load_setup_tokenizable(protocol_dag.transformation_key) + unit_results = dags_to_unit_results[str(protocol_dag.key)] + dag_result = ProtocolDAGResult( + protocol_units=protocol_dag.protocol_units, + protocol_unit_results=unit_results, + transformation_key=protocol_dag.transformation_key, + extends_key=protocol_dag.extends_key, + ) + protocol_result = transformation.gather([dag_result]) + return protocol_result, dag_result + + # construct a map of all the ProtocolDAGs and their corresponding ProtocolUnitResults + dags_to_unit_results = self._construct_dags_to_unit_results( + dags=self.get_protocol_dags(), + unit_results=self.get_unit_results(), + ) + # load all dags that we have results for + dags_with_results = [ + self.load_protocol_dag(d) for d in dags_to_unit_results if dags_to_unit_results[d] != [] + ] + + result_edges: list[tuple[ProtocolResult, ProtocolDAGResult]] = [] + for dag in dags_with_results: + result_edge = construct_results_edge( + protocol_dag=dag, dags_to_unit_results=dags_to_unit_results + ) + result_edges.append(result_edge) + + return result_edges + + @staticmethod + def _construct_dags_to_unit_results( + dags: Iterable[ProtocolDAG], unit_results: Iterable[ProtocolUnitResult] + ): + """Given a set of ProtocolDAGs and a set of ProtocolUnitResults, + create a mapping of protocolDAGs to their corresponding ProtocolUnitResults + """ + # protocol unit source key mapped to unit results + pur_pu_keys = {str(pur.source_key): pur for pur in unit_results} + dag_map = {} + for dag in dags: + dag_unit_results = [] + for unit in dag.protocol_units: + if unit.key in pur_pu_keys: + dag_unit_results.append(pur_pu_keys[unit.key]) + dag_map[str(dag.key)] = dag_unit_results + return dag_map + + @property + def setup_store(self): + """Get the setup store + + Returns + ------- + ExternalStorage + The setup storage location + """ + return self.stores["setup"] + + @property + def result_store(self): + """Get the result store. + + Returns + ------- + ExternalStorage + The result storage location + """ + return self.stores["results"] + + @property + def shared_store(self): + """Get the shared store. + + Returns + ------- + ExternalStorage + The shared storage location + """ + return self.stores["shared"] + + +class FileSystemWarehouse(WarehouseBaseClass): + """Warehouse implementation using local filesystem storage. + + Provides a file-based storage backend for GufeTokenizable objects + organized in a directory structure. + + Parameters + ---------- + root_dir : pathlib.Path, optional + Root directory in which to create the warehouse storage. + + Notes + ----- + Creates a "setup" subdirectory within the root directory for storing + setup-related objects. Future versions may include additional stores + for results and other data types. + """ + + def __init__(self, root_dir: pathlib.Path, exist_ok=False): + self.root_dir = pathlib.Path(root_dir) + if self.root_dir.is_dir() and not exist_ok: + raise FileExistsError( + f"Warehouse directory '{self.root_dir}' already exists. To load an existing Warehouse, use FileSystemWarehouse.from_dir(`root_dir`)" + ) + self.root_dir.mkdir(exist_ok=exist_ok) # make parents? + setup_store = FileStorage(f"{self.root_dir}/setup", exist_ok=exist_ok) + result_store = FileStorage(f"{self.root_dir}/results", exist_ok=exist_ok) + shared_store = FileStorage(f"{self.root_dir}/shared", exist_ok=exist_ok) + tasks_store = FileStorage(f"{self.root_dir}/tasks", exist_ok=exist_ok) + protocol_dag_store = FileStorage(f"{self.root_dir}/protocol_dags", exist_ok=exist_ok) + stores = WarehouseStores( + setup=setup_store, + results=result_store, + shared=shared_store, + tasks=tasks_store, + protocol_dags=protocol_dag_store, + ) + name = self.root_dir.resolve().name + super().__init__(stores=stores, name=name) + + @classmethod + def from_dir(cls, root_dir: pathlib.Path) -> FileSystemWarehouse: + """Initialize a FileSystemWarehouse from an existing directory. + + Parameters + ---------- + root_dir : pathlib.Path + Root directory of the Warehouse. + + Returns + ------- + FileSystemWarehouse + + Raises + ------ + FileNotFoundError + If `root_dir` is not an existing directory. + """ + root_dir = pathlib.Path(root_dir) + if not root_dir.is_dir(): + raise FileNotFoundError( + "`root_dir` must be an existing filepath. To create a new Warehouse, use FileSystemWarehouse(`root_dir`)" + ) + return cls(root_dir=root_dir, exist_ok=True) diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-32c19e7ec6864e13658a8d3ca48e582d b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-32c19e7ec6864e13658a8d3ca48e582d new file mode 100644 index 000000000..e063d041c --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-32c19e7ec6864e13658a8d3ca48e582d @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocoldag", "__qualname__": "ProtocolDAG", "extends_key": null, "name": null, "protocol_units": [{":gufe-key:": "HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0"}, {":gufe-key:": "HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101"}, {":gufe-key:": "HybridTopologyMultiStateAnalysisUnit-a7252f67bcd541378e9846b01ad21a5e"}], "transformation_key": "Transformation-a8ccb7f841aafdc860143dad3f2bd82a"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-616ec7a89d894b5f430007cd3a3b5d49 b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-616ec7a89d894b5f430007cd3a3b5d49 new file mode 100644 index 000000000..ceed63a21 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-616ec7a89d894b5f430007cd3a3b5d49 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocoldag", "__qualname__": "ProtocolDAG", "extends_key": null, "name": null, "protocol_units": [{":gufe-key:": "HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da"}, {":gufe-key:": "HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a"}, {":gufe-key:": "HybridTopologyMultiStateAnalysisUnit-7e9620845eff4575a757b1993e88d517"}], "transformation_key": "Transformation-d51c5a0397bfe45865a78edd1935e3b0"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-72133e3079ecad750b71ca7994237228 b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-72133e3079ecad750b71ca7994237228 new file mode 100644 index 000000000..57ce69805 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-72133e3079ecad750b71ca7994237228 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocoldag", "__qualname__": "ProtocolDAG", "extends_key": null, "name": null, "protocol_units": [{":gufe-key:": "HybridTopologySetupUnit-0238f65b55044b1ea751447537a28f2b"}, {":gufe-key:": "HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8"}, {":gufe-key:": "HybridTopologyMultiStateAnalysisUnit-72c71598dc75432a90aed831a4e4cb24"}], "transformation_key": "Transformation-622f1d19bea91cd47a7e478e42376305"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-b51ae0bc4944b776b4fe63f17158bac1 b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-b51ae0bc4944b776b4fe63f17158bac1 new file mode 100644 index 000000000..f6914815d --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/protocol_dags/ProtocolDAG-b51ae0bc4944b776b4fe63f17158bac1 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocoldag", "__qualname__": "ProtocolDAG", "extends_key": null, "name": null, "protocol_units": [{":gufe-key:": "HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd"}, {":gufe-key:": "HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc"}, {":gufe-key:": "HybridTopologyMultiStateAnalysisUnit-e44e96bb39c947ed9d68f5c1ada6defc"}], "transformation_key": "Transformation-ae340a619b2794a9a3da4e72ef977885"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-64e7d042322d4495a096d379660dbfeb b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-64e7d042322d4495a096d379660dbfeb new file mode 100644 index 000000000..c747393c9 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-64e7d042322d4495a096d379660dbfeb @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitFailure", "_key": "ProtocolUnitFailure-64e7d042322d4495a096d379660dbfeb", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:53.636128"}, "exception": ["SimulationNaNError", ["Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs"]], "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 284817259896887492684538463771894716234, "setup_results": {":gufe-key:": "ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2"}}, "name": "HybridTopology Simulation: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {}, "source_key": "HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:34.771776"}, "stderr": {}, "stdout": {}, "traceback": "Traceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1323, in _propagate_replica\n mcmc_move.apply(thermodynamic_state, sampler_state, context_cache=self.sampler_context_cache)\n ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 1151, in apply\n super().apply(thermodynamic_state, sampler_state,\n ~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n context_cache=context_cache)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 755, in apply\n raise IntegratorMoveError(err_msg, self, context)\nopenmmtools.mcmc.IntegratorMoveError: Potential energy is NaN after 20 attempts of integration with move LangevinDynamicsMove\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/gufe/protocols/protocolunit.py\", line 367, in execute\n outputs = self._execute(context, **inputs)\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1444, in _execute\n outputs = self.run(\n system=system,\n ...<3 lines>...\n shared_basepath=ctx.shared,\n )\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1380, in run\n self._run_simulation(\n ~~~~~~~~~~~~~~~~~~~~^\n sampler=sampler,\n ^^^^^^^^^^^^^^^^\n ...<4 lines>...\n dry=dry,\n ^^^^^^^^\n )\n ^\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1248, in _run_simulation\n sampler.equilibrate(int(equil_steps / mc_steps))\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 693, in equilibrate\n self._propagate_replicas()\n ~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/utils/utils.py\", line 95, in _wrapper\n return func(*args, **kwargs)\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1296, in _propagate_replicas\n propagated_states, replica_ids = mpiplus.distribute(self._propagate_replica, range(self.n_replicas),\n ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n send_results_to=0)\n ^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/mpiplus/mpiplus.py\", line 523, in distribute\n all_results = [task(job_args, *other_args, **kwargs) for job_args in distributed_args]\n ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1334, in _propagate_replica\n raise SimulationNaNError(message)\nopenmmtools.multistate.utils.SimulationNaNError: Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs\n"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-75091d6b95ba407e82bdc58baf08f6e7 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-75091d6b95ba407e82bdc58baf08f6e7 new file mode 100644 index 000000000..7b44cda2f --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-75091d6b95ba407e82bdc58baf08f6e7 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitFailure", "_key": "ProtocolUnitFailure-75091d6b95ba407e82bdc58baf08f6e7", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:24.404849"}, "exception": ["SimulationNaNError", ["Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs"]], "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 284817259896887492684538463771894716234, "setup_results": {":gufe-key:": "ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2"}}, "name": "HybridTopology Simulation: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {}, "source_key": "HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:08.770736"}, "stderr": {}, "stdout": {}, "traceback": "Traceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1323, in _propagate_replica\n mcmc_move.apply(thermodynamic_state, sampler_state, context_cache=self.sampler_context_cache)\n ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 1151, in apply\n super().apply(thermodynamic_state, sampler_state,\n ~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n context_cache=context_cache)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 755, in apply\n raise IntegratorMoveError(err_msg, self, context)\nopenmmtools.mcmc.IntegratorMoveError: Potential energy is NaN after 20 attempts of integration with move LangevinDynamicsMove\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/gufe/protocols/protocolunit.py\", line 367, in execute\n outputs = self._execute(context, **inputs)\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1444, in _execute\n outputs = self.run(\n system=system,\n ...<3 lines>...\n shared_basepath=ctx.shared,\n )\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1380, in run\n self._run_simulation(\n ~~~~~~~~~~~~~~~~~~~~^\n sampler=sampler,\n ^^^^^^^^^^^^^^^^\n ...<4 lines>...\n dry=dry,\n ^^^^^^^^\n )\n ^\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1248, in _run_simulation\n sampler.equilibrate(int(equil_steps / mc_steps))\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 693, in equilibrate\n self._propagate_replicas()\n ~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/utils/utils.py\", line 95, in _wrapper\n return func(*args, **kwargs)\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1296, in _propagate_replicas\n propagated_states, replica_ids = mpiplus.distribute(self._propagate_replica, range(self.n_replicas),\n ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n send_results_to=0)\n ^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/mpiplus/mpiplus.py\", line 523, in distribute\n all_results = [task(job_args, *other_args, **kwargs) for job_args in distributed_args]\n ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1334, in _propagate_replica\n raise SimulationNaNError(message)\nopenmmtools.multistate.utils.SimulationNaNError: Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs\n"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-fe2e15e4888c44e6825abf8be840bd30 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-fe2e15e4888c44e6825abf8be840bd30 new file mode 100644 index 000000000..24393b363 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitFailure-fe2e15e4888c44e6825abf8be840bd30 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitFailure", "_key": "ProtocolUnitFailure-fe2e15e4888c44e6825abf8be840bd30", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:08.727990"}, "exception": ["SimulationNaNError", ["Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs"]], "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 284817259896887492684538463771894716234, "setup_results": {":gufe-key:": "ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2"}}, "name": "HybridTopology Simulation: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {}, "source_key": "HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:53.680247"}, "stderr": {}, "stdout": {}, "traceback": "Traceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1323, in _propagate_replica\n mcmc_move.apply(thermodynamic_state, sampler_state, context_cache=self.sampler_context_cache)\n ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 1151, in apply\n super().apply(thermodynamic_state, sampler_state,\n ~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n context_cache=context_cache)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/mcmc.py\", line 755, in apply\n raise IntegratorMoveError(err_msg, self, context)\nopenmmtools.mcmc.IntegratorMoveError: Potential energy is NaN after 20 attempts of integration with move LangevinDynamicsMove\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/gufe/protocols/protocolunit.py\", line 367, in execute\n outputs = self._execute(context, **inputs)\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1444, in _execute\n outputs = self.run(\n system=system,\n ...<3 lines>...\n shared_basepath=ctx.shared,\n )\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1380, in run\n self._run_simulation(\n ~~~~~~~~~~~~~~~~~~~~^\n sampler=sampler,\n ^^^^^^^^^^^^^^^^\n ...<4 lines>...\n dry=dry,\n ^^^^^^^^\n )\n ^\n File \"/Users/atravitz/software/openfe/src/openfe/protocols/openmm_rfe/hybridtop_units.py\", line 1248, in _run_simulation\n sampler.equilibrate(int(equil_steps / mc_steps))\n ~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 693, in equilibrate\n self._propagate_replicas()\n ~~~~~~~~~~~~~~~~~~~~~~~~^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/utils/utils.py\", line 95, in _wrapper\n return func(*args, **kwargs)\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1296, in _propagate_replicas\n propagated_states, replica_ids = mpiplus.distribute(self._propagate_replica, range(self.n_replicas),\n ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n send_results_to=0)\n ^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/mpiplus/mpiplus.py\", line 523, in distribute\n all_results = [task(job_args, *other_args, **kwargs) for job_args in distributed_args]\n ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/Users/atravitz/micromamba/envs/openfe-exorcist/lib/python3.14/site-packages/openmmtools/multistate/multistatesampler.py\", line 1334, in _propagate_replica\n raise SimulationNaNError(message)\nopenmmtools.multistate.utils.SimulationNaNError: Propagating replica 0 at state 0 resulted in a NaN!\nThe state of the system and integrator before the error were saved in mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-cf34ef156b844592b4e860d9f47197a8/nan-error-logs\n"} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406 new file mode 100644 index 000000000..ce1996b17 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:22.058604"}, "inputs": {"alchemical_components": {"stateA": [{":gufe-key:": "SmallMoleculeComponent-e5a4596e9d800367c6832564a93877f3"}], "stateB": [{":gufe-key:": "SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab"}]}, "generation": 0, "ligandmapping": {":gufe-key:": "LigandAtomMapping-f41553d7a14794ba0032735151e13492"}, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 169760174163788586857416122335155600493, "stateA": {":gufe-key:": "ChemicalSystem-042fade29db8a39616f5a902e2da7ae3"}, "stateB": {":gufe-key:": "ChemicalSystem-d348563501aa206907231309a902cb32"}}, "name": "HybridTopology Setup: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"alchemical_resnames": ["LIG"], "generation": 0, "gufe_version": "1.12.1.dev15+g0b0edd955", "openfe_version": "1.12.1.dev34+g25c448160.d20260814", "openmm_version": "8.4", "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da/hybrid_system.pdb"}, "positions": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da/hybrid_positions.npy"}, "repeat_id": 169760174163788586857416122335155600493, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u00b8\r\u0003\u0000$\u0003\u0000\u0000\u0001\u0000\u0002\u0000\u0003\u0000\u0004\u0000\u0005\u0000\u0006\u0000\u0007\u0000\b\u0000\t\u0000\n\u0000\u000b\u0000\f\u0000\r\u0000\u000e\u0000\u000f\u0000\u0010\u0000\u00fb\u0006\u00fc\u0006\u00fd\u0006\u00fe\u0006\u00ff\u0006\u0000\u0000\u0000\u0000\u0000\u0000\u0016\u0000``00\u0018\u0018\u0006R!\u0007\u00901\u0018\u0018\f\f\u0006\u0006\u0003\u0083\u0081\u00c1\u00c0``00\u0018\u0018\f\f\u0006\u0006\u0003\u0083\u0081\u00c1\u00c0`\u00e0\u0001`\u0001"}, "dtype": "int64", "shape": [23]}, "system": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da/hybrid_system.xml.bz2"}}, "source_key": "HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:21.184064"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf new file mode 100644 index 000000000..402fd7ed8 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:16.238196"}, "inputs": {"alchemical_components": {"stateA": [{":gufe-key:": "SmallMoleculeComponent-e5a4596e9d800367c6832564a93877f3"}], "stateB": [{":gufe-key:": "SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab"}]}, "generation": 0, "ligandmapping": {":gufe-key:": "LigandAtomMapping-f41553d7a14794ba0032735151e13492"}, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223213012988507154361364807974423595914, "stateA": {":gufe-key:": "ChemicalSystem-092349f47625178f21bc28888fc27d6a"}, "stateB": {":gufe-key:": "ChemicalSystem-c16bf392cc055620e6c0177fbca350c5"}}, "name": "HybridTopology Setup: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"alchemical_resnames": ["LIG"], "generation": 0, "gufe_version": "1.12.1.dev15+g0b0edd955", "openfe_version": "1.12.1.dev34+g25c448160.d20260814", "openmm_version": "8.4", "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0/hybrid_system.pdb"}, "positions": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0/hybrid_positions.npy"}, "repeat_id": 223213012988507154361364807974423595914, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd`\u0018N\u00ad\u0087\u0000j9iA\u001c\u0010\u0018<\f\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u00000\u0000\u0000\u0000P\u0002\u0000\u00004\u0093R\u00a6\u0094RJ)\u00ef\u0003\u00f6\u0003\u0004\u0004sV\u00ce\u00c6Y8\u00fbf\u00ddl\u009be\u00b3kV\u00cd\u00ee6\u00cd\u00a2\u00d93kf\u00cb,\u0099\u001d\u00b3b6\u00cc\u0082\u00d9/\u00ebe\u00bb,\u0097\u00dd\u00b2Z6\u00cbb\u00d9+ke\u00ab,\u0095\u009d\u00b2R6\u00caB\u00d9'\u00ebd\u009b,\u0093]\u00b2J6\u00c9\"\u00d9#kd\u008b,\u0091\u001d\u00b2B6\u00c8\u0002\u00d9\u001f\u00ebc{,\u008f\u00dd\u00b1:6\u00c7\u00e2\u00d8\u001bkck,\u008d\u009d\u00b126\u00c6\u00c2\u00d8\u0017\u00ebb[,\u008b]\u00b1*6\u00c5\u00a2\u00d8\u0013kbK,\u0089\u001d\u00b1\"6\u00c4\u0082\u00d8\u000f\u00eba;,\u0087\u00dd\u00b0\u001a6\u00c3b\u00d8\u000bka+,\u0085\u009d\u00b0\u00126\u00c2B\u00d8\u0007\u00eb`\u001b,\u0083]\u00b0\n6\u00c1\u00c6\u0085\u00fb\u00f6\u00d7\u00b7\u0097wW#P\b\u00f4\u0001u@\u001bP\u0006t\u0001U@\u0013P\u0004\u00f4\u00005@\u000bP\u0002t\u0000\u0015@\u0003P\u0000t\u009d\u00aa\u00d3t\u008aN\u00cf\u00a99-\u00a7\u00e4t\u009c\u008a\u00d3p\nN\u00bf\u00a97\u00ed\u00a6\u00dct\u009bj\u00d3l\u008aM\u00af\u00a95\u00ad\u00a6\u00d4t\u009aJ\u00d3h\nM\u009f\u00a93m\u00a6\u00cct\u0099*\u00d3d\u008aL\u008f\u00a91-\u00a6\u00c4t\u0098\n\u00d3`\nL\u007f\u00a9/\u00ed\u00a5\u00bct\u0097\u00ea\u00d2\\\u008aKo\u00a9-\u00ad\u00a5\u00b4t\u0096\u00ca\u00d2X\nK_\u00a9+m\u00a5\u00act\u0095\u00aa\u00d2T\u008aJO\u00a9)-\u00a5\u00a4t\u0094\u008a\u00d2P\nJ?\u00a9'\u00ed\u00a4\u009ct\u0093j\u00d2L\u008aI/\u00a9%\u00ad\u00a4\u0094t\u0092J\u00d2H\nI\u001f\u00a9#m\u00a4\u008ct\u0091*\u00d2D\u008aH\u000f\u00a9!-\u00a4\u0084t\u0090\n\u00d2@\nH\u00ff\u00a8\u001f\u00ed\u00a3|t\u008f\u00ea\u00d1<\u008aG\u00ef\u00a8\u001d\u00ad\u00a3tt\u008e\u00ca\u00d18\nG\u00df\u00a8\u001bm\u00a3lt\u008d\u00aa\u00d1\u009d\u00a6Q4zF\u00cdh\u0019%\u00a3cT\u008c\u0086Q0\u00faE\u00bdh\u0017\u00e5\u00a2[T\u008bfQ,zE\u00adh\u0015\u00a5\u00a2ST\u008aFQ(\u00faD\u009dh\u0013e\u00a2KT\u0089&Q$zD\u008dh\u0011%\u00a2CT\u0088\u0006Q \u00faC}h\u000f\u00e5\u00a1;T\u0087\u00e6P\u001czCmh\r\u00a5\u00a13T\u0086\u00c6P\u0018\u00faB]h\u000be\u00a1+T\u0085\u00a6P\u0014zBMh\t%\u00a1#T\u0084\u0086P\u0010\u00faA=h\u0007\u00e5\u00a0\u001bT\u0083fP\fzA-h\u0005\u00a5\u00a0\u0013T\u0082FP\b\u00fa@\u001dh\u0003e\u00a0\u000bT\u0081&\u00d0\u00a8P\u009f\u00be\u00ba\u00b6\u00b2\u00aejF\u0090\u0010\u00e4\u0003\u00e9@6\u0090\f\u00e4\u0002\u00a9@&\u0090\b\u00e4\u0001i@\u0016\u0090\u0004\u00e4\u0000)@\u0006\u0090\u0000\u00e4\u00baT\u0097\u00e9\u0012]\u009eKsY.\u00c9\u00e5\u00b8\u0014\u0097\u00e1\u0012\\~Ko\u00d9-\u00b9\u00e5\u00b6\u00d4\u0096\u00d9\u0012[^KkY-\u00a9\u00e5\u00b4\u0094\u0096\u00d1\u0012Z>Kg\u00d9,\u0099\u00e5\u00b2T\u0096\u00c9\u0012Y\u001eKcY,\u0089\u00e5\u00b0\u0014\u0096\u00c1\u0012X\u00feJ_\u00d9+y\u00e5\u00ae\u00d4\u0095\u00b9\u0012W\u00deJ[Y+i\u00e5\u00ac\u0094\u0095\u00b1\u0012V\u00beJW\u00d9*Y\u00e5\u00aaT\u0095\u00a9\u0012U\u009eJSY*I\u00e5\u00a8\u0014\u0095\u00a1\u0012T~JO\u00d9)9\u00e5\u00a6\u00d4\u0094\u0099\u0012S^JKY))\u00e5\u00a4\u0094\u0094\u0091\u0012R>JG\u00d9(\u0019\u00e5\u00a2T\u0094\u0089\u0012Q\u001eJCY(\t\u00e5\u00a0\u0014\u0094\u0081\u0012P\u00feI?\u00d9'\u00f9\u00e4\u009e\u00d4\u0093y\u0012O\u00deI;Y'\u00e9\u00e4\u009c\u0094\u0093q\u0012N\u00beI7\u00d9&\u00d9\u00e4\u009aT\u0093\u00bbL\u0093h\u00f2L\u009a\u00c92I&\u00c7\u00a4\u0098\f\u0093`\u00f2Kz\u00c9.\u00c9%\u00b7\u00a4\u0096\u00cc\u0092X\u00f2JZ\u00c9*I%\u00a7\u00a4\u0094\u008c\u0092P\u00f2I:\u00c9&\u00c9$\u0097\u00a4\u0092L\u0092H\u00f2H\u001a\u00c9\"I$\u0087\u00a4\u0090\f\u0092@\u00f2G\u00fa\u00c8\u001e\u00c9#w\u00a4\u008e\u00cc\u00918\u00f2F\u00da\u00c8\u001aI#g\u00a4\u008c\u008c\u00910\u00f2E\u00ba\u00c8\u0016\u00c9\"W\u00a4\u008aL\u0091(\u00f2D\u009a\u00c8\u0012I\"G\u00a4\u0088\f\u0091 \u00f2Cz\u00c8\u000e\u00c9!7\u00a4\u0086\u00cc\u0090\u0018\u00f2BZ\u00c8\nI!'\u00a4\u0084\u008c\u0090\u0010\u00f2A:\u00c8\u0006\u00c9 \u0017\u00a4\u0082L\u00901a\u00be\u00fc\u00f4\u00ec\u00e4\u00dc\u00d4\u00cc\u00ad\u00ae\u00d35\u00ba>\u00d7\u00e6\u00ba\\\u0093\u00ebq-\u00ae\u00c35\u00b8\u00fe\u00d6\u00de\u00ba[s\u00ebm\u00ad\u00ad\u00b35\u00b6\u00be\u00d6\u00d6\u00baZS\u00ebi-\u00ad\u00a35\u00b4~\u00d6\u00ce\u00baY3\u00ebe\u00ad\u00ac\u00935\u00b2>\u00d6\u00c6\u00baX\u0013\u00eba-\u00ac\u00835\u00b0\u00fe\u00d5\u00be\u00baW\u00f3\u00ea]\u00ad\u00abs5\u00ae\u00be\u00d5\u00b6\u00baV\u00d3\u00eaY-\u00abc5\u00ac~\u00d5\u00ae\u00baU\u00b3\u00eaU\u00ad\u00aaS5\u00aa>\u00d5\u00a6\u00baT\u0093\u00eaQ-\u00aaC5\u00a8\u00fe\u00d4\u009e\u00baSs\u00eaM\u00ad\u00a935\u00a6\u00be\u00d4\u0096\u00baRS\u00eaI-\u00a9#5\u00a4~\u00d4\u008e\u00baQ3\u00eaE\u00ad\u00a8\u00135\u00a2>\u00d4\u0086\u00baP\u0013\u00eaA-\u00a8\u00035\u00a0\u00fe\u00d3~\u00baO\u00f3\u00e9=\u00ad\u00a7\u00f34\u009e\u00be\u00d3v\u00baN\u00d3\u00e99-\u00a7\u00e34\u009c~\u00d3n\u00baM\u00b3\u00e95\u00ad\u00a6w\u009d\u00a6\u00d1\u00f4\u00996\u00d3e\u009aL\u008fi1\u001d\u00a6\u00c1\u00f4\u0097\u00f6\u00d2]\u009aKoi-\u009d\u00a5\u00b1\u00f4\u0095\u00b6\u00d2U\u009aJOi)\u001d\u00a5\u00a1\u00f4\u0093v\u00d2M\u009aI/i%\u009d\u00a4\u0091\u00f4\u00916\u00d2E\u009aH\u000fi!\u001d\u00a4\u0081\u00f4\u008f\u00f6\u00d1=\u009aG\u00efh\u001d\u009d\u00a3q\u00f4\u008d\u00b6\u00d15\u009aF\u00cfh\u0019\u001d\u00a3a\u00f4\u008bv\u00d1-\u009aE\u00afh\u0015\u009d\u00a2Q\u00f4\u00896\u00d1%\u009aD\u008fh\u0011\u001d\u00a2A\u00f4\u0087\u00f6\u00d0\u001d\u009aCoh\r\u009d\u00a11\u00f4\u0085\u00b6\u00d0\u0015\u009aBOh\t\u001d\u00a1!\u00f4\u0083v\u00d0\r\u009aA/h\u0005\u009d\u00a0c\u00c3~\u00fd\u00ed\u00dd\u00cd\u00bd\u00ad\u0011@\u00f0\u0000;\u00c0\r0\u0003\u00bc\u0000+\u00c0\t0\u0002|\u0000\u001b\u00c0\u00050\u0001<\u0000\u000b\u00c0\u00010\u0000\u00bc\u008e\u00d5q:F\u00c7\u00e7\u00d8\u001c\u0097cr<\u008e\u00c5q8\u0006\u00c7\u00df\u00d8\u001bwcn\u00bc\u008d\u00b5q6\u00c6\u00c6\u00d7\u00d8\u001aWcj<\u008d\u00a5q4\u0086\u00c6\u00cf\u00d8\u00197cf\u00bc\u008c\u0095q2F\u00c6\u00c7\u00d8\u0018\u0017cb<\u008c\u0085q0\u0006\u00c6\u00bf\u00d8\u0017\u00f7b^\u00bc\u008buq.\u00c6\u00c5\u00b7\u00d8\u0016\u00d7bZ<\u008beq,\u0086\u00c5\u00af\u00d8\u0015\u00b7bV\u00bc\u008aUq*F\u00c5\u00a7\u00d8\u0014\u0097bR<\u008aEq(\u0006\u00c5\u009f\u00d8\u0013wbN\u00bc\u00895q&\u00c6\u00c4\u0097\u00d8\u0012WbJ<\u0089%q$\u0086\u00c4\u008f\u00d8\u00117bF\u00bc\u0088\u0015q\"F\u00c4\u0087\u00d8\u0010\u0017bB<\u0088\u0005q \u0006\u00c4\u007f\u00d8\u000f\u00f7a>\u00bc\u0087\u00f5p\u001e\u00c6\u00c3w\u00d8\u000e\u00d7a:<\u0087\u00e5p\u001c\u0086\u00c3o\u00d8\r\u00b7a6\u00bc\u0086\u00d5\u00f0\u008e\u00d30\u001a>\u00c3f\u00b8\f\u0093\u00e11,\u0086\u00c30\u0018\u00fe\u00c2^\u00b8\u000bs\u00e1-\u00ac\u0085\u00b30\u0016\u00be\u00c2V\u00b8\nS\u00e1),\u0085\u00a30\u0014~\u00c2N\u00b8\t3\u00e1%\u00ac\u0084\u00930\u0012>\u00c2F\u00b8\b\u0013\u00e1!,\u0084\u00830\u0010\u00fe\u00c1>\u00b8\u0007\u00f3\u00e0\u001d\u00ac\u0083s0\u000e\u00be\u00c16\u00b8\u0006\u00d3\u00e0\u0019,\u0083c0\f~\u00c1.\u00b8\u0005\u00b3\u00e0\u0015\u00ac\u0082S0\n>\u00c1&\u00b8\u0004\u0093\u00e0\u0011,\u0082C0\b\u00fe\u00c0\u001e\u00b8\u0003s\u00e0\r\u00ac\u008130\u0006\u00be\u00c0\u0016\u00b8\u0002S\u00e0\t,\u0081#0\u0004~\u00c0\u000e\u00b8\u00013\u00e0\u0005\u00ac\u0080\u0013pd\u00c8\u008f\u009f\u009d\u009b\u0099\u00975\u0002\b\u00f6\u0081u`\u001bX\u0006v\u0081U`\u0013X\u0004\u00f6\u00805`\u000bX\u0002v\u0080\u0015`\u0003X\u0000v\u00dd\u00aa\u00dbt\u008bn\u00cf\u00ad\u00b9-\u00b7\u00e4v\u00dc\u008a\u00dbp\u000bn\u00bf\u00ad\u00b7\u00ed\u00b6\u00dcv\u00dbj\u00dbl\u008bm\u00af\u00ad\u00b5\u00ad\u00b6\u00d4v\u00daJ\u00dbh\u000bm\u009f\u00ad\u00b3m\u00b6\u00ccv\u00d9*\u00dbd\u008bl\u008f\u00ad\u00b1-\u00b6\u00c4v\u00d8\n\u00db`\u000bl\u007f\u00ad\u00af\u00ed\u00b5\u00bcv\u00d7\u00ea\u00da\\\u008bko\u00ad\u00ad\u00ad\u00b5\u00b4v\u00d6\u00ca\u00daX\u000bk_\u00ad\u00abm\u00b5\u00acv\u00d5\u00aa\u00daT\u008bjO\u00ad\u00a9-\u00b5\u00a4v\u00d4\u008a\u00daP\u000bj?\u00ad\u00a7\u00ed\u00b4\u009cv\u00d3j\u00daL\u008bi/\u00ad\u00a5\u00ad\u00b4\u0094v\u00d2J\u00daH\u000bi\u001f\u00ad\u00a3m\u00b4\u008cv\u00d1*\u00daD\u008bh\u000f\u00ad\u00a1-\u00b4\u0084v\u00d0\n\u00da@\u000bh\u00ff\u00ac\u009f\u00ed\u00b3|v\u00cf\u00ea\u00d9<\u008bg\u00ef\u00ac\u009d\u00ad\u00b3t6i\u001e\u009aw\u00e6\u0099ye\u001e\u00997\u00e6\u0089ya\u001e\u0098\u00f7\u00e5yy]\u001e\u0097\u00b7\u00e5iyY\u001e\u0096w\u00e5YyU\u001e\u00957\u00e5IyQ\u001e\u0094\u00f7\u00e49yM\u001e\u0093\u00b7\u00e4)yI\u001e\u0092w\u00e4\u0019yE\u001e\u00917\u00e4\tyA\u001e\u0090\u00f7\u00e3\u00f9x=\u001e\u008f\u00b7\u00e3\u00e9x9\u001e\u008ew\u00e3\u00d9x5\u001e\u008d7\u00e3\u00c9x1\u001e\u008c\u00f7\u00e2\u00b9x-\u001e\u008b\u00b7\u00e2\u00a9x)\u001e\u008aw\u00e2\u0099x%\u001e\u00897\u00e2\u0089x!\u001e\u0088\u00f7\u00e1yx\u001d\u001e\u0087\u00b7\u00e1ix\u0019\u001e\u0086w\u00e1Yx\u0015\u001e\u00857\u00e1Ix\u0011\u001e\u0084\u00f7\u00e09x\r\u001e\u0083\u00b7\u00e0)x\t^|\u00f0\u00bd\u00f7\u00cf_?~\u00fb4\u0002\b\u001ep\u00a0\u0001\u0006~\u0081W\u00e0\u0013x\u0004\u00fe\u00807\u00e0\u000bx\u0002~\u0080\u0017\u00e0\u0003x\u0000~\u00dd\u00ab\u00fbt\u008f\u00ee\u00cf\u00bd\u00b9/\u00f7\u00e4~\u00dc\u008b\u00fbp\u000f\u00ee\u00bf\u00bd\u00b7\u00ef\u00f6\u00dc~\u00dbk\u00fbl\u008f\u00ed\u00af\u00bd\u00b5\u00af\u00f6\u00d4~\u00daK\u00fbh\u000f\u00ed\u009f\u00bd\u00b3o\u00f6\u00cc~\u00d9+\u00fbd\u008f\u00ec\u008f\u00bd\u00b1/\u00f6\u00c4~\u00d8\u000b\u00fb`\u000f\u00ec\u007f\u00bd\u00af\u00ef\u00f5\u00bc~\u00d7\u00eb\u00fa\\\u008f\u00ebo\u00bd\u00ad\u00af\u00f5\u00b4~\u00d6\u00cb\u00faX\u000f\u00eb_\u00bd\u00abo\u00f5\u00ac~\u00d5\u00ab\u00faT\u008f\u00eaO\u00bd\u00a9/\u00f5\u00a4~\u00d4\u008b\u00faP\u000f\u00ea?\u00bd\u00a7\u00ef\u00f4\u009c~\u00d3k\u00faL\u008f\u00e9/\u00bd\u00a5\u00af\u00f4\u0094~\u00d2K\u00faH\u000f\u00e9\u001f\u00bd\u00a3o\u00f4\u008c~\u00d1+\u00faD\u008f\u00e8\u000f\u00bd\u00a1/\u00f4\u0084~\u00d0\u000b\u00fa@\u000f\u00e8\u00ff\u00bc\u009f\u00ef\u00f3|~\u00cf\u00eb\u00f9<\u008f\u00e7\u00ef\u00bc\u009d\u00af\u00f3t~\u00ce\u00cb\u00f98\u000f\u00e7\u00df\u00bc\u009bo\u00f3l~\u00cd\u00ab\u00f9\u00dd\u00a7y4\u007f\u00e6\u00cd|\u0099'\u00f3c^\u00cc\u0087y0\u00ff\u00e5\u00bd|\u0097\u00e7\u00f2[^\u00cbgy,\u007f\u00e5\u00ad|\u0095\u00a7\u00f2S^\u00caGy(\u00ff\u00e4\u009d|\u0093g\u00f2K^\u00c9'y$\u007f\u00e4\u008d|\u0091'\u00f2C^\u00c8\u0007y \u00ff\u00e3}|\u008f\u00e7\u00f1;^\u00c7\u00e7x\u001c\u007f\u00e3m|\u008d\u00a7\u00f13^\u00c6\u00c7x\u0018\u00ff\u00e2]|\u008bg\u00f1+^\u00c5\u00a7x\u0014\u007f\u00e2M|\u0089'\u00f1#^\u00c4\u0087x\u0010\u00ff\u00e1=|\u0087\u00e7\u00f0\u001b^\u00c3gx\f\u007f\u00e1-|\u0085\u00a7\u00f0\u0013^\u00c2Gx\b\u00ff\u00e0\u001d|\u0083g\u00f0\u000b^\u00c1'\u00f8\u00f8\u00f0\u00df\u00ff\u00fb\u00f7\u00f3\u00efk\u0004\u0010<\u00e0@\u0003\u00ce\u0080/\u00e0\nx\u0002\u008e\u0080\u001f\u00e0\u0006x\u0001N\u0080\u000f\u00e0\u0002x\u0000\u000e\u0080\u00afsu\u009e\u00ce\u00d1\u00f997\u00e7\u00e5\u009c\u009c\u008fsq\u001e\u00ce\u00c1\u00f97\u00f7\u00e6\u00dd\u009c\u009bosm\u009e\u00cd\u00b1\u00f95\u00b7\u00e6\u00d5\u009c\u009aOsi\u001e\u00cd\u00a1\u00f93w\u00e6\u00cd\u009c\u0099/se\u009e\u00cc\u0091\u00f917\u00e6\u00c5\u009c\u0098\u000fsa\u001e\u00cc\u0081\u00f9/\u00f7\u00e5\u00bd\u009c\u0097\u00efr]\u009e\u00cbq\u00f9-\u00b7\u00e5\u00b5\u009c\u0096\u00cfrY\u001e\u00cba\u00f9+w\u00e5\u00ad\u009c\u0095\u00afrU\u009e\u00caQ\u00f9)7\u00e5\u00a5\u009c\u0094\u008frQ\u001e\u00caA\u00f9'\u00f7\u00e4\u009d\u009c\u0093orM\u009e\u00c91\u00f9%\u00b7\u00e4\u0095\u009c\u0092OrI\u001e\u00c9!\u00f9#w\u00e4\u008d\u009c\u0091/rE\u009e\u00c8\u0011\u00f9!7\u00e4\u0085\u009c\u0090\u000frA\u001e\u00c8\u0001\u00f9\u001f\u00f7\u00e3}\u009c\u008f\u00efq=\u009e\u00c7\u00f1\u00f8\u001d\u00b7\u00e3u\u009c\u008e\u00cfq9\u001e\u00c7\u00e1\u00f8\u001bw\u00e3m\u009c\u008d\u00afq5\u00be\u00f34\u008e\u00c6\u00cf\u00b8\u0019/\u00e3d|\u008c\u008b\u00f10\u000e\u00c6\u00bf\u00b8\u0017\u00ef\u00e2\\|\u008bk\u00f1,\u008e\u00c5\u00af\u00b8\u0015\u00af\u00e2T|\u008aK\u00f1(\u000e\u00c5\u009f\u00b8\u0013o\u00e2L|\u0089+\u00f1$\u008e\u00c4\u008f\u00b8\u0011/\u00e2D|\u0088\u000b\u00f1 \u000e\u00c4\u007f\u00b8\u000f\u00ef\u00e1<|\u0087\u00eb\u00f0\u001c\u008e\u00c3o\u00b8\r\u00af\u00e14|\u0086\u00cb\u00f0\u0018\u000e\u00c3_\u00b8\u000bo\u00e1,|\u0085\u00ab\u00f0\u0014\u008e\u00c2O\u00b8\t/\u00e1$|\u0084\u008b\u00f0\u0010\u000e\u00c2?\u00b8\u0007\u00ef\u00e0\u001c|\u0083k\u00f0\f\u008e\u00c1/\u00b8\u0005\u00af\u00e0\u0014|\u0082K\u00f0\b\u000e\u00c1\u001f\u00b8\u0003o\u00e0\f|\u0081+\u00f0\u0004\u001e\u001d\u00fa\u00f3w\u00f7v\u00f6u\u008d\u0000\u0082\u0007\u001c\u00e8\u0006\u009a\u0081^\u00a0\u0015\u00e8\u0004\u001a\u0081>\u00a0\r\u00e8\u0002\u009a\u0080\u001e\u00a0\u0005\u00e8\u0000\u001a\u0080^\u0017\u0099\u0099\u0099;@\u00bb?;?\u00bb>;>\u00bb=;=\u00bb<;<\u00bb;;;\u00bb:;:\u00bb9;9\u00bb8;8\u00bb7;7\u00bb6;6\u00bb5;5\u00bb\u00dd.\u00cd\u000e\u00cd\u00ee\u00cc\u00ce\u00cc\u00ae\u00cc\u008e\u00ccn\u00ccN\u00cc.\u00cc\u000e\u00cc\u00ee\u00cb\u00ce\u00cb\u00ae\u00cb\u008e\u00cbn\u00cbN\u00cb.\u00cb\u000e\u00cb\u00ee\u00ca\u00ce\u00ca\u00ae\u00ca\u008e\u00can\u00ca.P\u0084\u0015_EW\u00b1Ud\u0015WEU1UD\u0015OES\u00b1T$\u0015GEQ1T\u0004\u0015?EO\u00b1S\u00e4\u00147EM1S\u00c4\u0014/EK\u00b1R\u00a4\u0014'EI1R\u0084\u0014\u001fEG\u00b1Qd\u0014\u0017EE1QD\u0014\u000fEC\u00b1P$\u0014\u0007EA1P\u0004\u0014\u00ffD?\u00b1O\u00e4\u0013\u00f7D=1O\u00c4\u0013\u00efD;\u00b1N\u00a4\u0013\u00e7D91N\u0084\u0013\u00dfD7\u00b1Md\u0013\u00d7D5q\u0017\u00d3D4\u00f1L4\u0013\u00cbD2qL\u0014\u0013\u00c3D0\u00f1K\u00f4\u0012\u00bbD.qK\u00d4\u0012\u00b3D,\u00f1J\u00b4\u0012\u00abD*qJ\u0094\u0012\u00a3D(\u00f1It\u0012\u009bD&qIT\u0012\u0093D$\u00f1H4\u0012\u008bD\"qH\u0014\u0012\u0083D \u00f1G\u00f4\u0011{D\u001eqG\u00d4\u0011sD\u001c\u00f1F\u00b4\u0011kD\u001aqF\u0094\u0011cD\u0018\u00f1Et\u0011[D\u0016qET\u0011SD\u0014\u00f1D4\u0011KD\u0012qD\u0014\u0011CD\u0010\u00f1C\u00f4\u0010;D\u000eqC\u00d4\u00103D\f\u00f1B\u00b4\u0010+D\nqB\u0094\u0010#D\b\u00f1At\u0010\u001bD\u0006qAT\u0010\u0013\u00c4\u0018a|\u00f1\u00a3\u00c7\u008e\u001c7j\u0004\u0010<\u00e0@\u0003\f,\u00a0\u0000L\u0000\"\u0000\u000f\u0080\u0006\u00c0\u0002 \u0001p\u0000(\u0000\f\u0000\u0002\u0000\u00d7Au0\u001dD\u0007\u00cfAs\u00b0\u001c$\u0007\u00c7Aq0\u001c\u0004\u0007\u00bfAo\u00b0\u001b\u00e4\u0006\u00b7Am0\u001b\u00c4\u0006\u00afAk\u00b0\u001a\u00a4\u0006\u00a7Ai0\u001a\u0084\u0006\u009fAg\u00b0\u0019d\u0006\u0097Ae0\u0019D\u0006\u008fAc\u00b0\u0018$\u0006\u0087Aa0\u0018\u0004\u0006\u007fA_\u00b0\u0017\u00e4\u0005wA]0\u0017\u00c4\u0005oA[\u00b0\u0016\u00a4\u0005gAY0\u0016\u0084\u0005_AW\u00b0\u0015d\u0005WAU0\u0015D\u0005OAS\u00b0\u0014$\u0005GAQ0\u0014\u0004\u0005?AO\u00b0\u0013\u00e4\u00047AM0\u0013\u00c4\u0004/AK\u00b0\u0012\u00a4\u0004'AI0\u0012\u0084\u0004\u001fAG\u00b0\u0011d\u0004\u0017AE0\u0011D\u0004\u000fAC\u00b0\u0010$\u0004\u0007AA0\u0010\u0004\u0004\u00ff@?\u00b0\u000f\u00e4\u0003\u00f7@=0\u000f\u00c4\u0003\u00ef@;\u00b0\u000e\u00a4\u0003\u00e7@90\u000e\u0084\u0003\u00df@7\u00b0\rd\u0003\u00d7@5p\u0007\u00d3@4\u00f0\f4\u0003\u00cb@2p\f\u0014\u0003\u00c3@0\u00f0\u000b\u00f4\u0002\u00bb@.p\u000b\u00d4\u0002\u00b3@,\u00f0\n\u00b4\u0002\u00ab@*p\n\u0094\u0002\u00a3@(\u00f0\tt\u0002\u009b@&p\tT\u0002\u0093@$\u00f0\b4\u0002\u008b@\"p\b\u0014\u0002\u0083@ \u00f0\u0007\u00f4\u0001{@\u001ep\u0007\u00d4\u0001s@\u001c\u00f0\u0006\u00b4\u0001k@\u001ap\u0006\u0094\u0001c@\u0018\u00f0\u0005t\u0001[@\u0016p\u0005T\u0001S@\u0014\u00f0\u00044\u0001K@\u0012p\u0004\u0014\u0001C@\u0010\u00f0\u0003\u00f4\u0000;@\u000ep\u0003\u00d4\u00003@\f\u00f0\u0002\u00b4\u0000+@\np\u0002\u0094\u0000#@\b\u00f0\u0001t\u0000\u001b@\u0006p\u0001T\u0000\u0013\u00c0\b!|\u00f0\u00a1\u00c3\u0086\f\u0017j\u0004\u0010<\u00e0@\u0003\f,\u00f0\u0014x\t<\u0004\u00de\u0001\u00cf\u0080W\u00c0#\u00e0\r\u00f0\u0004x\u0001<\u0000\u00de\u00ba\u00a7\u00ee\u00a5{\u00e8\u00de\u00b9g\u00ee\u0095{\u00e4\u00de\u00b8'\u00ee\u0085{\u00e0\u00de\u00b7\u00e7\u00edu{\u00dc\u00de\u00b6\u00a7\u00ede{\u00d8\u00de\u00b5g\u00edU{\u00d4\u00de\u00b4'\u00edE{\u00d0\u00de\u00b3\u00e7\u00ec5{\u00cc\u00de\u00b2\u00a7\u00ec%{\u00c8\u00de\u00b1g\u00ec\u0015{\u00c4\u00de\u00b0'\u00ec\u0005{\u00c0\u00de\u00af\u00e7\u00eb\u00f5z\u00bc\u00de\u00ae\u00a7\u00eb\u00e5z\u00b8\u00de\u00adg\u00eb\u00d5z\u00b4\u00de\u00ac'\u00eb\u00c5z\u00b0\u00de\u00ab\u00e7\u00ea\u00b5z\u00ac\u00de\u00aa\u00a7\u00ea\u00a5z\u00a8\u00de\u00a9g\u00ea\u0095z\u00a4\u00de\u00a8'\u00ea\u0085z\u00a0\u00de\u00a7\u00e7\u00e9uz\u009c\u00de\u00a6\u00a7\u00e9ez\u0098\u00de\u00a5g\u00e9Uz\u0094\u00de\u00a4'\u00e9Ez\u0090\u00de\u00a3\u00e7\u00e85z\u008c\u00de\u00a2\u00a7\u00e8%z\u0088\u00de\u00a1g\u00e8\u0015z\u0084\u00de\u00a0'\u00e8\u0005z\u0080\u00de\u009f\u00e7\u00e7\u00f5y|\u00de\u009e\u00a7\u00e7\u00e5yx\u00de\u009dg\u00e7\u00d5yt\u00de\u009c'\u00e7\u00c5yp\u00de\u009b\u00e7\u00e6\u00b5yl\u00de\u009a\u00a7\u00e6\u00ed^\u0089\u00e1\u00a84\u0000\u00c1\u007f\u00b3\u009f\u0090\u0005\u0000\u0014@\u00fcm\u000b\u00f5}U\u00a4lx\u000f=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u00e8\u00d8\t\u00fa\u00d9\u00a6\u00f5\u00beQ\u0080\u0010\u00ff=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u0084\u00e8\u00d86\u00b5*\u00f7~\u00cf|\u00f7\u00c3\u009a\u008ca\u00f7\u00e3\u001a\u001bt\u00b5\u00dc\u00d3\u00ac\u0007\u0086\u00a5~{`}b\u00c6]U\u00b8\u00ccV\u00ec\u001eO\u00b0\u0086\u00fb\u00ec\u00875\u0019\u00c3\u001e\u00eeg\u00bb\u0096\u00bbO\u00c4D\u00fez`}\u0014b\u00c6\u0012\u00e5> \u000b*\u00fb\u00e9\u0001\u0082\u00f5Y\u00ef\u00e6\u001e\u00dc'\u00e9\u007f\u00f6\u00bb\u001bZ8\u00fe\u00b9\u008cyG\u009aQ "}, "dtype": "int64", "shape": [2531]}, "system": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0/hybrid_system.xml.bz2"}}, "source_key": "HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:09.784076"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2 new file mode 100644 index 000000000..aa82f182c --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-4388526f592f4586a4f0cb62c6a71ef2", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:22.539031"}, "inputs": {"alchemical_components": {"stateA": [{":gufe-key:": "SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab"}], "stateB": [{":gufe-key:": "SmallMoleculeComponent-e42f2d6e8715f91ce1dd6dd3a3b62fe9"}]}, "generation": 0, "ligandmapping": {":gufe-key:": "LigandAtomMapping-0cdd365bd42a6a6dcc223a297aeba078"}, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 284817259896887492684538463771894716234, "stateA": {":gufe-key:": "ChemicalSystem-d348563501aa206907231309a902cb32"}, "stateB": {":gufe-key:": "ChemicalSystem-5308ba234089fbedba66a79cdc314ef0"}}, "name": "HybridTopology Setup: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {"alchemical_resnames": ["LIG"], "generation": 0, "gufe_version": "1.12.1.dev15+g0b0edd955", "openfe_version": "1.12.1.dev34+g25c448160.d20260814", "openmm_version": "8.4", "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-0238f65b55044b1ea751447537a28f2b/hybrid_system.pdb"}, "positions": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-0238f65b55044b1ea751447537a28f2b/hybrid_positions.npy"}, "repeat_id": 284817259896887492684538463771894716234, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u00b8\u0015\u0003\u00004\u0003\u0000\u0000\u0001\u0000\u0002\u0000\u0003\u0000\u0004\u0000\u0005\u0000\u0006\u0000\u0007\u0000\b\u0000\t\u0000\n\u0000\u000b\u0000\f\u0000\r\u0000\u000e\u0000\u000f\u0000\u0010\u0000\u00fd\u00f8\u0006\u00f9\u0006\u00fa\u0006\u00fb\u0006\u00fc\u0006\u0000\u0000\u0000\u0000\u0000\u0000\u0016\u0000``00\u0018\u0018\u0006r!30\u001a\u0018\r\u008c\u0006F\u0003\u00a3\u0081\u00d1\u00c0h`40\u001a\u0018\r\u008c\u0006F\u0003\u00a3\u0081\u00d1\u00c0h`\u00b4\u0001\u00b4\u0001"}, "dtype": "int64", "shape": [23]}, "system": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-0238f65b55044b1ea751447537a28f2b/hybrid_system.xml.bz2"}}, "source_key": "HybridTopologySetupUnit-0238f65b55044b1ea751447537a28f2b", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:22.079782"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0 new file mode 100644 index 000000000..a69aa869e --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:21.132475"}, "inputs": {"alchemical_components": {"stateA": [{":gufe-key:": "SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab"}], "stateB": [{":gufe-key:": "SmallMoleculeComponent-e42f2d6e8715f91ce1dd6dd3a3b62fe9"}]}, "generation": 0, "ligandmapping": {":gufe-key:": "LigandAtomMapping-0cdd365bd42a6a6dcc223a297aeba078"}, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223150426984276242809719357896568479063, "stateA": {":gufe-key:": "ChemicalSystem-c16bf392cc055620e6c0177fbca350c5"}, "stateB": {":gufe-key:": "ChemicalSystem-762ce73233b2ccd593c52026afef907a"}}, "name": "HybridTopology Setup: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {"alchemical_resnames": ["LIG"], "generation": 0, "gufe_version": "1.12.1.dev15+g0b0edd955", "openfe_version": "1.12.1.dev34+g25c448160.d20260814", "openmm_version": "8.4", "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd/hybrid_system.pdb"}, "positions": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd/hybrid_positions.npy"}, "repeat_id": 223150426984276242809719357896568479063, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd`\u0018N\u00ad\u0087\u0000j9iA\u001c\u0010\u0018<\f\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u00000\u0000\u0000\u0000P\u0002\u0000\u00004\u0093R\u00a6\u0094RJ)\u00ef\u0003\u00f6\u0003\u0004\u0004sV\u00ce\u00c6Y8\u00fbf\u00ddl\u009be\u00b3kV\u00cd\u00ee6\u00cd\u00a2\u00d93kf\u00cb,\u0099\u001d\u00b3b6\u00cc\u0082\u00d9/\u00ebe\u00bb,\u0097\u00dd\u00b2Z6\u00cbb\u00d9+ke\u00ab,\u0095\u009d\u00b2R6\u00caB\u00d9'\u00ebd\u009b,\u0093]\u00b2J6\u00c9\"\u00d9#kd\u008b,\u0091\u001d\u00b2B6\u00c8\u0002\u00d9\u001f\u00ebc{,\u008f\u00dd\u00b1:6\u00c7\u00e2\u00d8\u001bkck,\u008d\u009d\u00b126\u00c6\u00c2\u00d8\u0017\u00ebb[,\u008b]\u00b1*6\u00c5\u00a2\u00d8\u0013kbK,\u0089\u001d\u00b1\"6\u00c4\u0082\u00d8\u000f\u00eba;,\u0087\u00dd\u00b0\u001a6\u00c3b\u00d8\u000bka+,\u0085\u009d\u00b0\u00126\u00c2B\u00d8\u0007\u00eb`\u001b,\u0083]\u00b0\n6\u00c1\u00c6\u0085\u00fb\u00f6\u00d7\u00b7\u0097wW#P\b\u00f4\u0001u@\u001bP\u0006t\u0001U@\u0013P\u0004\u00f4\u00005@\u000bP\u0002t\u0000\u0015@\u0003P\u0000t\u009d\u00aa\u00d3t\u008aN\u00cf\u00a99-\u00a7\u00e4t\u009c\u008a\u00d3p\nN\u00bf\u00a97\u00ed\u00a6\u00dct\u009bj\u00d3l\u008aM\u00af\u00a95\u00ad\u00a6\u00d4t\u009aJ\u00d3h\nM\u009f\u00a93m\u00a6\u00cct\u0099*\u00d3d\u008aL\u008f\u00a91-\u00a6\u00c4t\u0098\n\u00d3`\nL\u007f\u00a9/\u00ed\u00a5\u00bct\u0097\u00ea\u00d2\\\u008aKo\u00a9-\u00ad\u00a5\u00b4t\u0096\u00ca\u00d2X\nK_\u00a9+m\u00a5\u00act\u0095\u00aa\u00d2T\u008aJO\u00a9)-\u00a5\u00a4t\u0094\u008a\u00d2P\nJ?\u00a9'\u00ed\u00a4\u009ct\u0093j\u00d2L\u008aI/\u00a9%\u00ad\u00a4\u0094t\u0092J\u00d2H\nI\u001f\u00a9#m\u00a4\u008ct\u0091*\u00d2D\u008aH\u000f\u00a9!-\u00a4\u0084t\u0090\n\u00d2@\nH\u00ff\u00a8\u001f\u00ed\u00a3|t\u008f\u00ea\u00d1<\u008aG\u00ef\u00a8\u001d\u00ad\u00a3tt\u008e\u00ca\u00d18\nG\u00df\u00a8\u001bm\u00a3lt\u008d\u00aa\u00d1\u009d\u00a6Q4zF\u00cdh\u0019%\u00a3cT\u008c\u0086Q0\u00faE\u00bdh\u0017\u00e5\u00a2[T\u008bfQ,zE\u00adh\u0015\u00a5\u00a2ST\u008aFQ(\u00faD\u009dh\u0013e\u00a2KT\u0089&Q$zD\u008dh\u0011%\u00a2CT\u0088\u0006Q \u00faC}h\u000f\u00e5\u00a1;T\u0087\u00e6P\u001czCmh\r\u00a5\u00a13T\u0086\u00c6P\u0018\u00faB]h\u000be\u00a1+T\u0085\u00a6P\u0014zBMh\t%\u00a1#T\u0084\u0086P\u0010\u00faA=h\u0007\u00e5\u00a0\u001bT\u0083fP\fzA-h\u0005\u00a5\u00a0\u0013T\u0082FP\b\u00fa@\u001dh\u0003e\u00a0\u000bT\u0081&\u00d0\u00a8P\u009f\u00be\u00ba\u00b6\u00b2\u00aejF\u0090\u0010\u00e4\u0003\u00e9@6\u0090\f\u00e4\u0002\u00a9@&\u0090\b\u00e4\u0001i@\u0016\u0090\u0004\u00e4\u0000)@\u0006\u0090\u0000\u00e4\u00baT\u0097\u00e9\u0012]\u009eKsY.\u00c9\u00e5\u00b8\u0014\u0097\u00e1\u0012\\~Ko\u00d9-\u00b9\u00e5\u00b6\u00d4\u0096\u00d9\u0012[^KkY-\u00a9\u00e5\u00b4\u0094\u0096\u00d1\u0012Z>Kg\u00d9,\u0099\u00e5\u00b2T\u0096\u00c9\u0012Y\u001eKcY,\u0089\u00e5\u00b0\u0014\u0096\u00c1\u0012X\u00feJ_\u00d9+y\u00e5\u00ae\u00d4\u0095\u00b9\u0012W\u00deJ[Y+i\u00e5\u00ac\u0094\u0095\u00b1\u0012V\u00beJW\u00d9*Y\u00e5\u00aaT\u0095\u00a9\u0012U\u009eJSY*I\u00e5\u00a8\u0014\u0095\u00a1\u0012T~JO\u00d9)9\u00e5\u00a6\u00d4\u0094\u0099\u0012S^JKY))\u00e5\u00a4\u0094\u0094\u0091\u0012R>JG\u00d9(\u0019\u00e5\u00a2T\u0094\u0089\u0012Q\u001eJCY(\t\u00e5\u00a0\u0014\u0094\u0081\u0012P\u00feI?\u00d9'\u00f9\u00e4\u009e\u00d4\u0093y\u0012O\u00deI;Y'\u00e9\u00e4\u009c\u0094\u0093q\u0012N\u00beI7\u00d9&\u00d9\u00e4\u009aT\u0093\u00bbL\u0093h\u00f2L\u009a\u00c92I&\u00c7\u00a4\u0098\f\u0093`\u00f2Kz\u00c9.\u00c9%\u00b7\u00a4\u0096\u00cc\u0092X\u00f2JZ\u00c9*I%\u00a7\u00a4\u0094\u008c\u0092P\u00f2I:\u00c9&\u00c9$\u0097\u00a4\u0092L\u0092H\u00f2H\u001a\u00c9\"I$\u0087\u00a4\u0090\f\u0092@\u00f2G\u00fa\u00c8\u001e\u00c9#w\u00a4\u008e\u00cc\u00918\u00f2F\u00da\u00c8\u001aI#g\u00a4\u008c\u008c\u00910\u00f2E\u00ba\u00c8\u0016\u00c9\"W\u00a4\u008aL\u0091(\u00f2D\u009a\u00c8\u0012I\"G\u00a4\u0088\f\u0091 \u00f2Cz\u00c8\u000e\u00c9!7\u00a4\u0086\u00cc\u0090\u0018\u00f2BZ\u00c8\nI!'\u00a4\u0084\u008c\u0090\u0010\u00f2A:\u00c8\u0006\u00c9 \u0017\u00a4\u0082L\u00901a\u00be\u00fc\u00f4\u00ec\u00e4\u00dc\u00d4\u00cc\u00ad\u00ae\u00d35\u00ba>\u00d7\u00e6\u00ba\\\u0093\u00ebq-\u00ae\u00c35\u00b8\u00fe\u00d6\u00de\u00ba[s\u00ebm\u00ad\u00ad\u00b35\u00b6\u00be\u00d6\u00d6\u00baZS\u00ebi-\u00ad\u00a35\u00b4~\u00d6\u00ce\u00baY3\u00ebe\u00ad\u00ac\u00935\u00b2>\u00d6\u00c6\u00baX\u0013\u00eba-\u00ac\u00835\u00b0\u00fe\u00d5\u00be\u00baW\u00f3\u00ea]\u00ad\u00abs5\u00ae\u00be\u00d5\u00b6\u00baV\u00d3\u00eaY-\u00abc5\u00ac~\u00d5\u00ae\u00baU\u00b3\u00eaU\u00ad\u00aaS5\u00aa>\u00d5\u00a6\u00baT\u0093\u00eaQ-\u00aaC5\u00a8\u00fe\u00d4\u009e\u00baSs\u00eaM\u00ad\u00a935\u00a6\u00be\u00d4\u0096\u00baRS\u00eaI-\u00a9#5\u00a4~\u00d4\u008e\u00baQ3\u00eaE\u00ad\u00a8\u00135\u00a2>\u00d4\u0086\u00baP\u0013\u00eaA-\u00a8\u00035\u00a0\u00fe\u00d3~\u00baO\u00f3\u00e9=\u00ad\u00a7\u00f34\u009e\u00be\u00d3v\u00baN\u00d3\u00e99-\u00a7\u00e34\u009c~\u00d3n\u00baM\u00b3\u00e95\u00ad\u00a6w\u009d\u00a6\u00d1\u00f4\u00996\u00d3e\u009aL\u008fi1\u001d\u00a6\u00c1\u00f4\u0097\u00f6\u00d2]\u009aKoi-\u009d\u00a5\u00b1\u00f4\u0095\u00b6\u00d2U\u009aJOi)\u001d\u00a5\u00a1\u00f4\u0093v\u00d2M\u009aI/i%\u009d\u00a4\u0091\u00f4\u00916\u00d2E\u009aH\u000fi!\u001d\u00a4\u0081\u00f4\u008f\u00f6\u00d1=\u009aG\u00efh\u001d\u009d\u00a3q\u00f4\u008d\u00b6\u00d15\u009aF\u00cfh\u0019\u001d\u00a3a\u00f4\u008bv\u00d1-\u009aE\u00afh\u0015\u009d\u00a2Q\u00f4\u00896\u00d1%\u009aD\u008fh\u0011\u001d\u00a2A\u00f4\u0087\u00f6\u00d0\u001d\u009aCoh\r\u009d\u00a11\u00f4\u0085\u00b6\u00d0\u0015\u009aBOh\t\u001d\u00a1!\u00f4\u0083v\u00d0\r\u009aA/h\u0005\u009d\u00a0c\u00c3~\u00fd\u00ed\u00dd\u00cd\u00bd\u00ad\u0011@\u00f0\u0000;\u00c0\r0\u0003\u00bc\u0000+\u00c0\t0\u0002|\u0000\u001b\u00c0\u00050\u0001<\u0000\u000b\u00c0\u00010\u0000\u00bc\u008e\u00d5q:F\u00c7\u00e7\u00d8\u001c\u0097cr<\u008e\u00c5q8\u0006\u00c7\u00df\u00d8\u001bwcn\u00bc\u008d\u00b5q6\u00c6\u00c6\u00d7\u00d8\u001aWcj<\u008d\u00a5q4\u0086\u00c6\u00cf\u00d8\u00197cf\u00bc\u008c\u0095q2F\u00c6\u00c7\u00d8\u0018\u0017cb<\u008c\u0085q0\u0006\u00c6\u00bf\u00d8\u0017\u00f7b^\u00bc\u008buq.\u00c6\u00c5\u00b7\u00d8\u0016\u00d7bZ<\u008beq,\u0086\u00c5\u00af\u00d8\u0015\u00b7bV\u00bc\u008aUq*F\u00c5\u00a7\u00d8\u0014\u0097bR<\u008aEq(\u0006\u00c5\u009f\u00d8\u0013wbN\u00bc\u00895q&\u00c6\u00c4\u0097\u00d8\u0012WbJ<\u0089%q$\u0086\u00c4\u008f\u00d8\u00117bF\u00bc\u0088\u0015q\"F\u00c4\u0087\u00d8\u0010\u0017bB<\u0088\u0005q \u0006\u00c4\u007f\u00d8\u000f\u00f7a>\u00bc\u0087\u00f5p\u001e\u00c6\u00c3w\u00d8\u000e\u00d7a:<\u0087\u00e5p\u001c\u0086\u00c3o\u00d8\r\u00b7a6\u00bc\u0086\u00d5\u00f0\u008e\u00d30\u001a>\u00c3f\u00b8\f\u0093\u00e11,\u0086\u00c30\u0018\u00fe\u00c2^\u00b8\u000bs\u00e1-\u00ac\u0085\u00b30\u0016\u00be\u00c2V\u00b8\nS\u00e1),\u0085\u00a30\u0014~\u00c2N\u00b8\t3\u00e1%\u00ac\u0084\u00930\u0012>\u00c2F\u00b8\b\u0013\u00e1!,\u0084\u00830\u0010\u00fe\u00c1>\u00b8\u0007\u00f3\u00e0\u001d\u00ac\u0083s0\u000e\u00be\u00c16\u00b8\u0006\u00d3\u00e0\u0019,\u0083c0\f~\u00c1.\u00b8\u0005\u00b3\u00e0\u0015\u00ac\u0082S0\n>\u00c1&\u00b8\u0004\u0093\u00e0\u0011,\u0082C0\b\u00fe\u00c0\u001e\u00b8\u0003s\u00e0\r\u00ac\u008130\u0006\u00be\u00c0\u0016\u00b8\u0002S\u00e0\t,\u0081#0\u0004~\u00c0\u000e\u00b8\u00013\u00e0\u0005\u00ac\u0080\u0013pd\u00c8\u008f\u009f\u009d\u009b\u0099\u00975\u0002\b\u00f6\u0081u`\u001bX\u0006v\u0081U`\u0013X\u0004\u00f6\u00805`\u000bX\u0002v\u0080\u0015`\u0003X\u0000v\u00dd\u00aa\u00dbt\u008bn\u00cf\u00ad\u00b9-\u00b7\u00e4v\u00dc\u008a\u00dbp\u000bn\u00bf\u00ad\u00b7\u00ed\u00b6\u00dcv\u00dbj\u00dbl\u008bm\u00af\u00ad\u00b5\u00ad\u00b6\u00d4v\u00daJ\u00dbh\u000bm\u009f\u00ad\u00b3m\u00b6\u00ccv\u00d9*\u00dbd\u008bl\u008f\u00ad\u00b1-\u00b6\u00c4v\u00d8\n\u00db`\u000bl\u007f\u00ad\u00af\u00ed\u00b5\u00bcv\u00d7\u00ea\u00da\\\u008bko\u00ad\u00ad\u00ad\u00b5\u00b4v\u00d6\u00ca\u00daX\u000bk_\u00ad\u00abm\u00b5\u00acv\u00d5\u00aa\u00daT\u008bjO\u00ad\u00a9-\u00b5\u00a4v\u00d4\u008a\u00daP\u000bj?\u00ad\u00a7\u00ed\u00b4\u009cv\u00d3j\u00daL\u008bi/\u00ad\u00a5\u00ad\u00b4\u0094v\u00d2J\u00daH\u000bi\u001f\u00ad\u00a3m\u00b4\u008cv\u00d1*\u00daD\u008bh\u000f\u00ad\u00a1-\u00b4\u0084v\u00d0\n\u00da@\u000bh\u00ff\u00ac\u009f\u00ed\u00b3|v\u00cf\u00ea\u00d9<\u008bg\u00ef\u00ac\u009d\u00ad\u00b3t6i\u001e\u009aw\u00e6\u0099ye\u001e\u00997\u00e6\u0089ya\u001e\u0098\u00f7\u00e5yy]\u001e\u0097\u00b7\u00e5iyY\u001e\u0096w\u00e5YyU\u001e\u00957\u00e5IyQ\u001e\u0094\u00f7\u00e49yM\u001e\u0093\u00b7\u00e4)yI\u001e\u0092w\u00e4\u0019yE\u001e\u00917\u00e4\tyA\u001e\u0090\u00f7\u00e3\u00f9x=\u001e\u008f\u00b7\u00e3\u00e9x9\u001e\u008ew\u00e3\u00d9x5\u001e\u008d7\u00e3\u00c9x1\u001e\u008c\u00f7\u00e2\u00b9x-\u001e\u008b\u00b7\u00e2\u00a9x)\u001e\u008aw\u00e2\u0099x%\u001e\u00897\u00e2\u0089x!\u001e\u0088\u00f7\u00e1yx\u001d\u001e\u0087\u00b7\u00e1ix\u0019\u001e\u0086w\u00e1Yx\u0015\u001e\u00857\u00e1Ix\u0011\u001e\u0084\u00f7\u00e09x\r\u001e\u0083\u00b7\u00e0)x\t^|\u00f0\u00bd\u00f7\u00cf_?~\u00fb4\u0002\b\u001ep\u00a0\u0001\u0006~\u0081W\u00e0\u0013x\u0004\u00fe\u00807\u00e0\u000bx\u0002~\u0080\u0017\u00e0\u0003x\u0000~\u00dd\u00ab\u00fbt\u008f\u00ee\u00cf\u00bd\u00b9/\u00f7\u00e4~\u00dc\u008b\u00fbp\u000f\u00ee\u00bf\u00bd\u00b7\u00ef\u00f6\u00dc~\u00dbk\u00fbl\u008f\u00ed\u00af\u00bd\u00b5\u00af\u00f6\u00d4~\u00daK\u00fbh\u000f\u00ed\u009f\u00bd\u00b3o\u00f6\u00cc~\u00d9+\u00fbd\u008f\u00ec\u008f\u00bd\u00b1/\u00f6\u00c4~\u00d8\u000b\u00fb`\u000f\u00ec\u007f\u00bd\u00af\u00ef\u00f5\u00bc~\u00d7\u00eb\u00fa\\\u008f\u00ebo\u00bd\u00ad\u00af\u00f5\u00b4~\u00d6\u00cb\u00faX\u000f\u00eb_\u00bd\u00abo\u00f5\u00ac~\u00d5\u00ab\u00faT\u008f\u00eaO\u00bd\u00a9/\u00f5\u00a4~\u00d4\u008b\u00faP\u000f\u00ea?\u00bd\u00a7\u00ef\u00f4\u009c~\u00d3k\u00faL\u008f\u00e9/\u00bd\u00a5\u00af\u00f4\u0094~\u00d2K\u00faH\u000f\u00e9\u001f\u00bd\u00a3o\u00f4\u008c~\u00d1+\u00faD\u008f\u00e8\u000f\u00bd\u00a1/\u00f4\u0084~\u00d0\u000b\u00fa@\u000f\u00e8\u00ff\u00bc\u009f\u00ef\u00f3|~\u00cf\u00eb\u00f9<\u008f\u00e7\u00ef\u00bc\u009d\u00af\u00f3t~\u00ce\u00cb\u00f98\u000f\u00e7\u00df\u00bc\u009bo\u00f3l~\u00cd\u00ab\u00f9\u00dd\u00a7y4\u007f\u00e6\u00cd|\u0099'\u00f3c^\u00cc\u0087y0\u00ff\u00e5\u00bd|\u0097\u00e7\u00f2[^\u00cbgy,\u007f\u00e5\u00ad|\u0095\u00a7\u00f2S^\u00caGy(\u00ff\u00e4\u009d|\u0093g\u00f2K^\u00c9'y$\u007f\u00e4\u008d|\u0091'\u00f2C^\u00c8\u0007y \u00ff\u00e3}|\u008f\u00e7\u00f1;^\u00c7\u00e7x\u001c\u007f\u00e3m|\u008d\u00a7\u00f13^\u00c6\u00c7x\u0018\u00ff\u00e2]|\u008bg\u00f1+^\u00c5\u00a7x\u0014\u007f\u00e2M|\u0089'\u00f1#^\u00c4\u0087x\u0010\u00ff\u00e1=|\u0087\u00e7\u00f0\u001b^\u00c3gx\f\u007f\u00e1-|\u0085\u00a7\u00f0\u0013^\u00c2Gx\b\u00ff\u00e0\u001d|\u0083g\u00f0\u000b^\u00c1'\u00f8\u00f8\u00f0\u00df\u00ff\u00fb\u00f7\u00f3\u00efk\u0004\u0010<\u00e0@\u0003\u00ce\u0080/\u00e0\nx\u0002\u008e\u0080\u001f\u00e0\u0006x\u0001N\u0080\u000f\u00e0\u0002x\u0000\u000e\u0080\u00afsu\u009e\u00ce\u00d1\u00f997\u00e7\u00e5\u009c\u009c\u008fsq\u001e\u00ce\u00c1\u00f97\u00f7\u00e6\u00dd\u009c\u009bosm\u009e\u00cd\u00b1\u00f95\u00b7\u00e6\u00d5\u009c\u009aOsi\u001e\u00cd\u00a1\u00f93w\u00e6\u00cd\u009c\u0099/se\u009e\u00cc\u0091\u00f917\u00e6\u00c5\u009c\u0098\u000fsa\u001e\u00cc\u0081\u00f9/\u00f7\u00e5\u00bd\u009c\u0097\u00efr]\u009e\u00cbq\u00f9-\u00b7\u00e5\u00b5\u009c\u0096\u00cfrY\u001e\u00cba\u00f9+w\u00e5\u00ad\u009c\u0095\u00afrU\u009e\u00caQ\u00f9)7\u00e5\u00a5\u009c\u0094\u008frQ\u001e\u00caA\u00f9'\u00f7\u00e4\u009d\u009c\u0093orM\u009e\u00c91\u00f9%\u00b7\u00e4\u0095\u009c\u0092OrI\u001e\u00c9!\u00f9#w\u00e4\u008d\u009c\u0091/rE\u009e\u00c8\u0011\u00f9!7\u00e4\u0085\u009c\u0090\u000frA\u001e\u00c8\u0001\u00f9\u001f\u00f7\u00e3}\u009c\u008f\u00efq=\u009e\u00c7\u00f1\u00f8\u001d\u00b7\u00e3u\u009c\u008e\u00cfq9\u001e\u00c7\u00e1\u00f8\u001bw\u00e3m\u009c\u008d\u00afq5\u00be\u00f34\u008e\u00c6\u00cf\u00b8\u0019/\u00e3d|\u008c\u008b\u00f10\u000e\u00c6\u00bf\u00b8\u0017\u00ef\u00e2\\|\u008bk\u00f1,\u008e\u00c5\u00af\u00b8\u0015\u00af\u00e2T|\u008aK\u00f1(\u000e\u00c5\u009f\u00b8\u0013o\u00e2L|\u0089+\u00f1$\u008e\u00c4\u008f\u00b8\u0011/\u00e2D|\u0088\u000b\u00f1 \u000e\u00c4\u007f\u00b8\u000f\u00ef\u00e1<|\u0087\u00eb\u00f0\u001c\u008e\u00c3o\u00b8\r\u00af\u00e14|\u0086\u00cb\u00f0\u0018\u000e\u00c3_\u00b8\u000bo\u00e1,|\u0085\u00ab\u00f0\u0014\u008e\u00c2O\u00b8\t/\u00e1$|\u0084\u008b\u00f0\u0010\u000e\u00c2?\u00b8\u0007\u00ef\u00e0\u001c|\u0083k\u00f0\f\u008e\u00c1/\u00b8\u0005\u00af\u00e0\u0014|\u0082K\u00f0\b\u000e\u00c1\u001f\u00b8\u0003o\u00e0\f|\u0081+\u00f0\u0004\u001e\u001d\u00fa\u00f3w\u00f7v\u00f6u\u008d\u0000\u0082\u0007\u001c\u00e8\u0006\u009a\u0081^\u00a0\u0015\u00e8\u0004\u001a\u0081>\u00a0\r\u00e8\u0002\u009a\u0080\u001e\u00a0\u0005\u00e8\u0000\u001a\u0080^\u0017\u0099\u0099\u0099;@\u00bb?;?\u00bb>;>\u00bb=;=\u00bb<;<\u00bb;;;\u00bb:;:\u00bb9;9\u00bb8;8\u00bb7;7\u00bb6;6\u00bb5;5\u00bb\u00dd.\u00cd\u000e\u00cd\u00ee\u00cc\u00ce\u00cc\u00ae\u00cc\u008e\u00ccn\u00ccN\u00cc.\u00cc\u000e\u00cc\u00ee\u00cb\u00ce\u00cb\u00ae\u00cb\u008e\u00cbn\u00cbN\u00cb.\u00cb\u000e\u00cb\u00ee\u00ca\u00ce\u00ca\u00ae\u00ca\u008e\u00can\u00ca.P\u0084\u0015_EW\u00b1Ud\u0015WEU1UD\u0015OES\u00b1T$\u0015GEQ1T\u0004\u0015?EO\u00b1S\u00e4\u00147EM1S\u00c4\u0014/EK\u00b1R\u00a4\u0014'EI1R\u0084\u0014\u001fEG\u00b1Qd\u0014\u0017EE1QD\u0014\u000fEC\u00b1P$\u0014\u0007EA1P\u0004\u0014\u00ffD?\u00b1O\u00e4\u0013\u00f7D=1O\u00c4\u0013\u00efD;\u00b1N\u00a4\u0013\u00e7D91N\u0084\u0013\u00dfD7\u00b1Md\u0013\u00d7D5q\u0017\u00d3D4\u00f1L4\u0013\u00cbD2qL\u0014\u0013\u00c3D0\u00f1K\u00f4\u0012\u00bbD.qK\u00d4\u0012\u00b3D,\u00f1J\u00b4\u0012\u00abD*qJ\u0094\u0012\u00a3D(\u00f1It\u0012\u009bD&qIT\u0012\u0093D$\u00f1H4\u0012\u008bD\"qH\u0014\u0012\u0083D \u00f1G\u00f4\u0011{D\u001eqG\u00d4\u0011sD\u001c\u00f1F\u00b4\u0011kD\u001aqF\u0094\u0011cD\u0018\u00f1Et\u0011[D\u0016qET\u0011SD\u0014\u00f1D4\u0011KD\u0012qD\u0014\u0011CD\u0010\u00f1C\u00f4\u0010;D\u000eqC\u00d4\u00103D\f\u00f1B\u00b4\u0010+D\nqB\u0094\u0010#D\b\u00f1At\u0010\u001bD\u0006qAT\u0010\u0013\u00c4\u0018a|\u00f1\u00a3\u00c7\u008e\u001c7j\u0004\u0010<\u00e0@\u0003\f,\u00a0\u0000L\u0000\"\u0000\u000f\u0080\u0006\u00c0\u0002 \u0001p\u0000(\u0000\f\u0000\u0002\u0000\u00d7Au0\u001dD\u0007\u00cfAs\u00b0\u001c$\u0007\u00c7Aq0\u001c\u0004\u0007\u00bfAo\u00b0\u001b\u00e4\u0006\u00b7Am0\u001b\u00c4\u0006\u00afAk\u00b0\u001a\u00a4\u0006\u00a7Ai0\u001a\u0084\u0006\u009fAg\u00b0\u0019d\u0006\u0097Ae0\u0019D\u0006\u008fAc\u00b0\u0018$\u0006\u0087Aa0\u0018\u0004\u0006\u007fA_\u00b0\u0017\u00e4\u0005wA]0\u0017\u00c4\u0005oA[\u00b0\u0016\u00a4\u0005gAY0\u0016\u0084\u0005_AW\u00b0\u0015d\u0005WAU0\u0015D\u0005OAS\u00b0\u0014$\u0005GAQ0\u0014\u0004\u0005?AO\u00b0\u0013\u00e4\u00047AM0\u0013\u00c4\u0004/AK\u00b0\u0012\u00a4\u0004'AI0\u0012\u0084\u0004\u001fAG\u00b0\u0011d\u0004\u0017AE0\u0011D\u0004\u000fAC\u00b0\u0010$\u0004\u0007AA0\u0010\u0004\u0004\u00ff@?\u00b0\u000f\u00e4\u0003\u00f7@=0\u000f\u00c4\u0003\u00ef@;\u00b0\u000e\u00a4\u0003\u00e7@90\u000e\u0084\u0003\u00df@7\u00b0\rd\u0003\u00d7@5p\u0007\u00d3@4\u00f0\f4\u0003\u00cb@2p\f\u0014\u0003\u00c3@0\u00f0\u000b\u00f4\u0002\u00bb@.p\u000b\u00d4\u0002\u00b3@,\u00f0\n\u00b4\u0002\u00ab@*p\n\u0094\u0002\u00a3@(\u00f0\tt\u0002\u009b@&p\tT\u0002\u0093@$\u00f0\b4\u0002\u008b@\"p\b\u0014\u0002\u0083@ \u00f0\u0007\u00f4\u0001{@\u001ep\u0007\u00d4\u0001s@\u001c\u00f0\u0006\u00b4\u0001k@\u001ap\u0006\u0094\u0001c@\u0018\u00f0\u0005t\u0001[@\u0016p\u0005T\u0001S@\u0014\u00f0\u00044\u0001K@\u0012p\u0004\u0014\u0001C@\u0010\u00f0\u0003\u00f4\u0000;@\u000ep\u0003\u00d4\u00003@\f\u00f0\u0002\u00b4\u0000+@\np\u0002\u0094\u0000#@\b\u00f0\u0001t\u0000\u001b@\u0006p\u0001T\u0000\u0013\u00c0\b!|\u00f0\u00a1\u00c3\u0086\f\u0017j\u0004\u0010<\u00e0@\u0003\f,\u00f0\u0014x\t<\u0004\u00de\u0001\u00cf\u0080W\u00c0#\u00e0\r\u00f0\u0004x\u0001<\u0000\u00de\u00ba\u00a7\u00ee\u00a5{\u00e8\u00de\u00b9g\u00ee\u0095{\u00e4\u00de\u00b8'\u00ee\u0085{\u00e0\u00de\u00b7\u00e7\u00edu{\u00dc\u00de\u00b6\u00a7\u00ede{\u00d8\u00de\u00b5g\u00edU{\u00d4\u00de\u00b4'\u00edE{\u00d0\u00de\u00b3\u00e7\u00ec5{\u00cc\u00de\u00b2\u00a7\u00ec%{\u00c8\u00de\u00b1g\u00ec\u0015{\u00c4\u00de\u00b0'\u00ec\u0005{\u00c0\u00de\u00af\u00e7\u00eb\u00f5z\u00bc\u00de\u00ae\u00a7\u00eb\u00e5z\u00b8\u00de\u00adg\u00eb\u00d5z\u00b4\u00de\u00ac'\u00eb\u00c5z\u00b0\u00de\u00ab\u00e7\u00ea\u00b5z\u00ac\u00de\u00aa\u00a7\u00ea\u00a5z\u00a8\u00de\u00a9g\u00ea\u0095z\u00a4\u00de\u00a8'\u00ea\u0085z\u00a0\u00de\u00a7\u00e7\u00e9uz\u009c\u00de\u00a6\u00a7\u00e9ez\u0098\u00de\u00a5g\u00e9Uz\u0094\u00de\u00a4'\u00e9Ez\u0090\u00de\u00a3\u00e7\u00e85z\u008c\u00de\u00a2\u00a7\u00e8%z\u0088\u00de\u00a1g\u00e8\u0015z\u0084\u00de\u00a0'\u00e8\u0005z\u0080\u00de\u009f\u00e7\u00e7\u00f5y|\u00de\u009e\u00a7\u00e7\u00e5yx\u00de\u009dg\u00e7\u00d5yt\u00de\u009c'\u00e7\u00c5yp\u00de\u009b\u00e7\u00e6\u00b5yl\u00de\u009a\u00a7\u00e6\u00ed^\u0089\u00e1\u00a84\u0000\u00c1\u007f\u00b3\u009f\u0090\u0005\u0000\u0014@\u00fcm\u000b\u00f5}U\u00a4lx\u000f=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u00e8\u00d8\t\u00fa\u00d9\u00a6\u00f5\u00beQ\u0080\u0010\u00ff=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u0084\u00e8\u00d86\u00b5*\u00f7~\u00cf|\u00f7\u00c3\u009a\u008ca\u00f7\u00e3\u001a\u001bt\u00b5\u00dc\u00d3\u00ac\u0007\u0086\u00a5~{`}b\u00c6]U\u00b8\u00ccV\u00ec\u001eO\u00b0\u0086\u00fb\u00ec\u00875\u0019\u00c3\u001e\u00eeg\u00bb\u0096\u00bbO\u00c4D\u00fez`}\u0014b\u00c6\u0012\u00e5> \u000b*\u00fb\u00e9\u0001\u0082\u00f5Y\u00ef\u00e6\u001e\u00dc'\u00e9\u007f\u00f6\u00bb\u001bZ8\u00fe\u00b9\u008cyG\u009aQ "}, "dtype": "int64", "shape": [2531]}, "system": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd/hybrid_system.xml.bz2"}}, "source_key": "HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:16.362136"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-78baa9b66d104c5882c27fcb151b8d81 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-78baa9b66d104c5882c27fcb151b8d81 new file mode 100644 index 000000000..1bc5c7c1d --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-78baa9b66d104c5882c27fcb151b8d81 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-78baa9b66d104c5882c27fcb151b8d81", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:10.128848"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223213012988507154361364807974423595914, "setup_results": {":gufe-key:": "ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf"}}, "name": "HybridTopology Simulation: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101/checkpoint.chk"}, "generation": 0, "nc": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101/simulation.nc"}, "repeat_id": 223213012988507154361364807974423595914}, "source_key": "HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:19:40.819098"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-91ea5c49ccef4a40a84baca8efe7e4c0 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-91ea5c49ccef4a40a84baca8efe7e4c0 new file mode 100644 index 000000000..465e31359 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-91ea5c49ccef4a40a84baca8efe7e4c0 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-91ea5c49ccef4a40a84baca8efe7e4c0", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:22.120109"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 169760174163788586857416122335155600493, "setup_results": {":gufe-key:": "ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406"}}, "name": "HybridTopology Simulation: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a/checkpoint.chk"}, "generation": 0, "nc": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a/simulation.nc"}, "repeat_id": 169760174163788586857416122335155600493}, "source_key": "HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:10.212971"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-ac48c86b69b04a159e530c42c8008a95 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-ac48c86b69b04a159e530c42c8008a95 new file mode 100644 index 000000000..f243b0f7c --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-ac48c86b69b04a159e530c42c8008a95 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-ac48c86b69b04a159e530c42c8008a95", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:25:34.691915"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223150426984276242809719357896568479063, "setup_results": {":gufe-key:": "ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0"}}, "name": "HybridTopology Simulation: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc/checkpoint.chk"}, "generation": 0, "nc": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc/simulation.nc"}, "repeat_id": 223150426984276242809719357896568479063}, "source_key": "HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:20:00.082606"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-b86312cf436949138a4fa959cea6bee9 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-b86312cf436949138a4fa959cea6bee9 new file mode 100644 index 000000000..b848c9503 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-b86312cf436949138a4fa959cea6bee9 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-b86312cf436949138a4fa959cea6bee9", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:29:07.623725"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 169760174163788586857416122335155600493, "setup_results": {":gufe-key:": "ProtocolUnitResult-0f16c1cb13c44d6c8ff4ffd3fe9f6406"}, "simulation_results": {":gufe-key:": "ProtocolUnitResult-91ea5c49ccef4a40a84baca8efe7e4c0"}}, "name": "HybridTopology Analysis: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a/checkpoint.chk"}, "equilibration_iterations": 5.0, "forward_and_reverse_energies": {"forward_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00c5\u0001\u0000\u00d4\u0002\u0082\u0093\u0086%>e\u001f@em\u00c84\u00d3K @\u0004\u00b9\u00e0>2o\u0016\u008eA\u0082-YL&K%JF\u00cb\u0016@\u00bc\u0006 \u00fc\u00e4\u0013\u0017@\u0003\u0000`\u0017\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "forward_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00c5\u0001\u0000\u00d4\u00024\nk\u00cbc\u008cp@\u0080\u0092\u00ad\u00fa\f\u00d4h@\u009d\u00eeM\u00e0\u00ed\u00ba\"s\u0002+\u00e6G\u0094\u00d8\u0003\u00cb.\u0012\u00b0!@\u009a\u00c5mKDY!@\u0003\u0000`\u0017\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "fractions": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P=\u0001\u0000\u0088UU\u00c5?U\u00d5?\u0000\u00e0\u00e5\u00e5?\u00ab\u00aa\u00ea\u00f0?\t\u0000C\u00a5\u00c0Y\u0002\u00f9\u0086\u001a\u00b1R\u0017w\u00cd\n\u0002p\u00c3\u0002X"}, "dtype": "float64", "shape": [10]}, "reverse_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00cd\u0001\u0000\u00e4\u00029*\u00c9$\u00ad\u00df6@\u00cc?Nk$\u00ed0@\u00c5W\u0016=J\u00ab6\u0098\u00da\u00b7\u00d1\u00f2o\u0017\u0085~Nn\u0014=\u0017@\u00bc\u0006 \u00fc\u00e4\u0013\u0017@\u0003\u0000\u00a0\u0018\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "reverse_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00d5\u0001\u0000\u00f4\u0002l\u00e9\u00d4\u00df,\u00a2\u00d5?\u00abW\u00a94o\u0005\u00cd?*\u008e,\r\u00dbM\u00c6\u009b\u00c0\u00fc8`=\"@\u00c9\u00a8\u0015`\u00e7\u009d!@\u009a\u00c5mKDY!@\u0003\u0000\u0080p\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}}, "generation": 0, "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-78321eda905c4c2c9f75eb69c36496da/hybrid_system.pdb"}, "production_iterations": 7.0, "repeat_id": 169760174163788586857416122335155600493, "replica_exchange_statistics": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u008d\u0000\u00008\u0000\u0000\u00f0?\u0000\u00e0?\u0003\u0000+\u0004\u00c0\r\u000b`\u0001"}, "dtype": "float64", "shape": [3]}, "matrix": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd H\u00c5\u0000\u0000P\u0000\u0000\u00f0?\u0000\u00e8\u00d0?\u00e8?\u0005\u00003\t\u0000$\u000e\u00e52p\u008e\u0005m"}, "dtype": "float64", "shape": [3, 3]}}, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u00b8\r\u0003\u0000$\u0003\u0000\u0000\u0001\u0000\u0002\u0000\u0003\u0000\u0004\u0000\u0005\u0000\u0006\u0000\u0007\u0000\b\u0000\t\u0000\n\u0000\u000b\u0000\f\u0000\r\u0000\u000e\u0000\u000f\u0000\u0010\u0000\u00fb\u0006\u00fc\u0006\u00fd\u0006\u00fe\u0006\u00ff\u0006\u0000\u0000\u0000\u0000\u0000\u0000\u0016\u0000``00\u0018\u0018\u0006R!\u0007\u00901\u0018\u0018\f\f\u0006\u0006\u0003\u0083\u0081\u00c1\u00c0``00\u0018\u0018\f\f\u0006\u0006\u0003\u0083\u0081\u00c1\u00c0`\u00e0\u0001`\u0001"}, "dtype": "int64", "shape": [23]}, "structural_analysis_error": "index 0 is out of bounds for axis 0 with size 0", "trajectory": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-f94c4264ca8f483095da93f626892c1a/simulation.nc"}, "unit_estimate": {":is_custom:": true, "magnitude": 5.76942819543336, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_estimate_error": {":is_custom:": true, "magnitude": 3.759906514128199, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_mbar_overlap": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u00c1\u0000\u0000\u000e\u00fa\u00ff\u00ff\u00ff\u00ff\u00ef?\u0099B\u0083\u00a6r\u00f6\u00ef?@\u00f0\t\u001a\u008bO\u00d2?"}, "dtype": "float64", "shape": [3]}, "matrix": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd H\u00d5\u0001\u0000\u00e4\u0002\u0004`\"V\u00a1\u00f9\u00ef?\fa\u00c900\u009aE?F\u00d9X.\u00ba\u0003\u001f\u00f6\u0094\u00957\u0014\u0090\u00e4?)o\u00bcx\n\u00d5\u00d6\u00d0?\u00d0\u00a5\u0082\u0094\u00e4?\u0003\u0000\u0080\u0000C\u0095z\u008a)\u0006"}, "dtype": "float64", "shape": [3, 3]}, "scalar": 0.0011660335348268047}}, "source_key": "HybridTopologyMultiStateAnalysisUnit-7e9620845eff4575a757b1993e88d517", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:26.853220"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-c7bd47185d5549f39bfb53d4385328a5 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-c7bd47185d5549f39bfb53d4385328a5 new file mode 100644 index 000000000..9ec79edb2 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-c7bd47185d5549f39bfb53d4385328a5 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-c7bd47185d5549f39bfb53d4385328a5", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:51.521492"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223213012988507154361364807974423595914, "setup_results": {":gufe-key:": "ProtocolUnitResult-33e1f8b9d34146baab84734e3a16cadf"}, "simulation_results": {":gufe-key:": "ProtocolUnitResult-78baa9b66d104c5882c27fcb151b8d81"}}, "name": "HybridTopology Analysis: ligand_1 to ligand_2 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101/checkpoint.chk"}, "equilibration_iterations": 2.0, "forward_and_reverse_energies": {"forward_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u0081\u0002\u0000\u001f\u00e0\"(~},@\u001f\u00e0\"(~},@:\u001ep\u0017\u00ff\u00fb(@,\u00d0\u00d1,hV\"@\u00ac\u00edX\u009a\u009e90@\u00e0f\b\u00d7\u001c\u00a7\u0014@\u0006\u00d0\u00b9\u00e2\u00e3\u00ac\u0014@\u00de,\u00acg\u00ee4\u0015@\u000b\u00ea\u00c6\u00b2\u00ecG\u0016@\u0090w.\u00d250\u0016@"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "forward_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd Pe\u0002\u00004\u0004\u0085B\u00a9x\u008d\u00c6\u0083?\u00a6`\u00c4s\"\u00a3\u00bb?\u0000\u00f8\u007f;\u0097\u00bb\t\u00d3\u00b0\u00b4?\u0002\u00b9\u001d\u008bAPY@\u00f0d@\u00b2m,X@\u00e3?\u00a9R/oV@V\u00de\u00fe\u00fab\u0002S@z0\u001dd\u0001\u00b4R@\u0002\u00008qF\u0014."}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "fractions": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00b5\u0001\u00004\u0002\u001c\u00c7q\u001c\u00c7q\u00bc?\u00cc?U\u00d5\u00dc?r\u00e1\u00e5?9\u008e\u00e38\u008e\u00e3\u00e8\u00ec?\u0000\u0000\u0000\u0000\u0000\u0000\u00f0?\u0006\u0000C\u00e5\u00db\u0099\u0097\u00a86;\u00dd\u00c5\tcr\u00e1\u0002"}, "dtype": "float64", "shape": [10]}, "reverse_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u0081\u0002\u0000\u00fbG>@9-3@\u00fbG>@9-3@\u00cd\u00d4\u00e6s\u007f: @\u0096\u00e0\u00b1Y\u00d8o @$\u00b1\n\u00d2$D @\u00e7dp\u008c\u00d5\u0016\u0016@\u0086F\u00e8\u00d0\u00de\u00f2\u0015@l+\u00fcD\u00c7?\u0016@\u0013zJ\u00ac\u0096\u000f\u0016@\u0090w.\u00d250\u0016@"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "reverse_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u0081\u0002\u0000\u00dfj\u0086\u00d8\u00b8\u0091\u00cb?\u00dfj\u0086\u00d8\u00b8\u0091\u00cb?W\u00cb\u00db?\u00f0,\u008a@\u0012\u00ad7\u00e0U\u00cb\u0088@c-\u000e\u00017&\u0088@9\re}:7T@H\u00a23d`\u0006T@\u00d1Tz\u008db\u00e5S@\u009aV\u001c\u00ff\u0019\u001cS@z0\u001dd\u0001\u00b4R@"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}}, "generation": 0, "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-d568ebe569b445c7875d9b6d5ce04cd0/hybrid_system.pdb"}, "production_iterations": 10.0, "repeat_id": 223213012988507154361364807974423595914, "replica_exchange_statistics": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u00c1\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u00f0?\u00ff\u00ff\u00ff\u00ff\u00ff\u00ff\u00ef?\u00b6m\u00db\u00b6m\u00db\u00e6?"}, "dtype": "float64", "shape": [3]}, "matrix": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd HM\u0001\u0000\u00e0\u0000\u0000\u00f0?\u0000\u00db\u00b6m\u00db\u00b6m\u00eb?\u0092$I\u0092$I\u00c2\u00db\u00b6m\u00db\u00b6m\u00eb?\u0004\u00003\t\u00b0TQA9\u0016\u00b4\u0001"}, "dtype": "float64", "shape": [3, 3]}}, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd`\u0018N\u00ad\u0087\u0000j9iA\u001c\u0010\u0018<\f\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u00000\u0000\u0000\u0000P\u0002\u0000\u00004\u0093R\u00a6\u0094RJ)\u00ef\u0003\u00f6\u0003\u0004\u0004sV\u00ce\u00c6Y8\u00fbf\u00ddl\u009be\u00b3kV\u00cd\u00ee6\u00cd\u00a2\u00d93kf\u00cb,\u0099\u001d\u00b3b6\u00cc\u0082\u00d9/\u00ebe\u00bb,\u0097\u00dd\u00b2Z6\u00cbb\u00d9+ke\u00ab,\u0095\u009d\u00b2R6\u00caB\u00d9'\u00ebd\u009b,\u0093]\u00b2J6\u00c9\"\u00d9#kd\u008b,\u0091\u001d\u00b2B6\u00c8\u0002\u00d9\u001f\u00ebc{,\u008f\u00dd\u00b1:6\u00c7\u00e2\u00d8\u001bkck,\u008d\u009d\u00b126\u00c6\u00c2\u00d8\u0017\u00ebb[,\u008b]\u00b1*6\u00c5\u00a2\u00d8\u0013kbK,\u0089\u001d\u00b1\"6\u00c4\u0082\u00d8\u000f\u00eba;,\u0087\u00dd\u00b0\u001a6\u00c3b\u00d8\u000bka+,\u0085\u009d\u00b0\u00126\u00c2B\u00d8\u0007\u00eb`\u001b,\u0083]\u00b0\n6\u00c1\u00c6\u0085\u00fb\u00f6\u00d7\u00b7\u0097wW#P\b\u00f4\u0001u@\u001bP\u0006t\u0001U@\u0013P\u0004\u00f4\u00005@\u000bP\u0002t\u0000\u0015@\u0003P\u0000t\u009d\u00aa\u00d3t\u008aN\u00cf\u00a99-\u00a7\u00e4t\u009c\u008a\u00d3p\nN\u00bf\u00a97\u00ed\u00a6\u00dct\u009bj\u00d3l\u008aM\u00af\u00a95\u00ad\u00a6\u00d4t\u009aJ\u00d3h\nM\u009f\u00a93m\u00a6\u00cct\u0099*\u00d3d\u008aL\u008f\u00a91-\u00a6\u00c4t\u0098\n\u00d3`\nL\u007f\u00a9/\u00ed\u00a5\u00bct\u0097\u00ea\u00d2\\\u008aKo\u00a9-\u00ad\u00a5\u00b4t\u0096\u00ca\u00d2X\nK_\u00a9+m\u00a5\u00act\u0095\u00aa\u00d2T\u008aJO\u00a9)-\u00a5\u00a4t\u0094\u008a\u00d2P\nJ?\u00a9'\u00ed\u00a4\u009ct\u0093j\u00d2L\u008aI/\u00a9%\u00ad\u00a4\u0094t\u0092J\u00d2H\nI\u001f\u00a9#m\u00a4\u008ct\u0091*\u00d2D\u008aH\u000f\u00a9!-\u00a4\u0084t\u0090\n\u00d2@\nH\u00ff\u00a8\u001f\u00ed\u00a3|t\u008f\u00ea\u00d1<\u008aG\u00ef\u00a8\u001d\u00ad\u00a3tt\u008e\u00ca\u00d18\nG\u00df\u00a8\u001bm\u00a3lt\u008d\u00aa\u00d1\u009d\u00a6Q4zF\u00cdh\u0019%\u00a3cT\u008c\u0086Q0\u00faE\u00bdh\u0017\u00e5\u00a2[T\u008bfQ,zE\u00adh\u0015\u00a5\u00a2ST\u008aFQ(\u00faD\u009dh\u0013e\u00a2KT\u0089&Q$zD\u008dh\u0011%\u00a2CT\u0088\u0006Q \u00faC}h\u000f\u00e5\u00a1;T\u0087\u00e6P\u001czCmh\r\u00a5\u00a13T\u0086\u00c6P\u0018\u00faB]h\u000be\u00a1+T\u0085\u00a6P\u0014zBMh\t%\u00a1#T\u0084\u0086P\u0010\u00faA=h\u0007\u00e5\u00a0\u001bT\u0083fP\fzA-h\u0005\u00a5\u00a0\u0013T\u0082FP\b\u00fa@\u001dh\u0003e\u00a0\u000bT\u0081&\u00d0\u00a8P\u009f\u00be\u00ba\u00b6\u00b2\u00aejF\u0090\u0010\u00e4\u0003\u00e9@6\u0090\f\u00e4\u0002\u00a9@&\u0090\b\u00e4\u0001i@\u0016\u0090\u0004\u00e4\u0000)@\u0006\u0090\u0000\u00e4\u00baT\u0097\u00e9\u0012]\u009eKsY.\u00c9\u00e5\u00b8\u0014\u0097\u00e1\u0012\\~Ko\u00d9-\u00b9\u00e5\u00b6\u00d4\u0096\u00d9\u0012[^KkY-\u00a9\u00e5\u00b4\u0094\u0096\u00d1\u0012Z>Kg\u00d9,\u0099\u00e5\u00b2T\u0096\u00c9\u0012Y\u001eKcY,\u0089\u00e5\u00b0\u0014\u0096\u00c1\u0012X\u00feJ_\u00d9+y\u00e5\u00ae\u00d4\u0095\u00b9\u0012W\u00deJ[Y+i\u00e5\u00ac\u0094\u0095\u00b1\u0012V\u00beJW\u00d9*Y\u00e5\u00aaT\u0095\u00a9\u0012U\u009eJSY*I\u00e5\u00a8\u0014\u0095\u00a1\u0012T~JO\u00d9)9\u00e5\u00a6\u00d4\u0094\u0099\u0012S^JKY))\u00e5\u00a4\u0094\u0094\u0091\u0012R>JG\u00d9(\u0019\u00e5\u00a2T\u0094\u0089\u0012Q\u001eJCY(\t\u00e5\u00a0\u0014\u0094\u0081\u0012P\u00feI?\u00d9'\u00f9\u00e4\u009e\u00d4\u0093y\u0012O\u00deI;Y'\u00e9\u00e4\u009c\u0094\u0093q\u0012N\u00beI7\u00d9&\u00d9\u00e4\u009aT\u0093\u00bbL\u0093h\u00f2L\u009a\u00c92I&\u00c7\u00a4\u0098\f\u0093`\u00f2Kz\u00c9.\u00c9%\u00b7\u00a4\u0096\u00cc\u0092X\u00f2JZ\u00c9*I%\u00a7\u00a4\u0094\u008c\u0092P\u00f2I:\u00c9&\u00c9$\u0097\u00a4\u0092L\u0092H\u00f2H\u001a\u00c9\"I$\u0087\u00a4\u0090\f\u0092@\u00f2G\u00fa\u00c8\u001e\u00c9#w\u00a4\u008e\u00cc\u00918\u00f2F\u00da\u00c8\u001aI#g\u00a4\u008c\u008c\u00910\u00f2E\u00ba\u00c8\u0016\u00c9\"W\u00a4\u008aL\u0091(\u00f2D\u009a\u00c8\u0012I\"G\u00a4\u0088\f\u0091 \u00f2Cz\u00c8\u000e\u00c9!7\u00a4\u0086\u00cc\u0090\u0018\u00f2BZ\u00c8\nI!'\u00a4\u0084\u008c\u0090\u0010\u00f2A:\u00c8\u0006\u00c9 \u0017\u00a4\u0082L\u00901a\u00be\u00fc\u00f4\u00ec\u00e4\u00dc\u00d4\u00cc\u00ad\u00ae\u00d35\u00ba>\u00d7\u00e6\u00ba\\\u0093\u00ebq-\u00ae\u00c35\u00b8\u00fe\u00d6\u00de\u00ba[s\u00ebm\u00ad\u00ad\u00b35\u00b6\u00be\u00d6\u00d6\u00baZS\u00ebi-\u00ad\u00a35\u00b4~\u00d6\u00ce\u00baY3\u00ebe\u00ad\u00ac\u00935\u00b2>\u00d6\u00c6\u00baX\u0013\u00eba-\u00ac\u00835\u00b0\u00fe\u00d5\u00be\u00baW\u00f3\u00ea]\u00ad\u00abs5\u00ae\u00be\u00d5\u00b6\u00baV\u00d3\u00eaY-\u00abc5\u00ac~\u00d5\u00ae\u00baU\u00b3\u00eaU\u00ad\u00aaS5\u00aa>\u00d5\u00a6\u00baT\u0093\u00eaQ-\u00aaC5\u00a8\u00fe\u00d4\u009e\u00baSs\u00eaM\u00ad\u00a935\u00a6\u00be\u00d4\u0096\u00baRS\u00eaI-\u00a9#5\u00a4~\u00d4\u008e\u00baQ3\u00eaE\u00ad\u00a8\u00135\u00a2>\u00d4\u0086\u00baP\u0013\u00eaA-\u00a8\u00035\u00a0\u00fe\u00d3~\u00baO\u00f3\u00e9=\u00ad\u00a7\u00f34\u009e\u00be\u00d3v\u00baN\u00d3\u00e99-\u00a7\u00e34\u009c~\u00d3n\u00baM\u00b3\u00e95\u00ad\u00a6w\u009d\u00a6\u00d1\u00f4\u00996\u00d3e\u009aL\u008fi1\u001d\u00a6\u00c1\u00f4\u0097\u00f6\u00d2]\u009aKoi-\u009d\u00a5\u00b1\u00f4\u0095\u00b6\u00d2U\u009aJOi)\u001d\u00a5\u00a1\u00f4\u0093v\u00d2M\u009aI/i%\u009d\u00a4\u0091\u00f4\u00916\u00d2E\u009aH\u000fi!\u001d\u00a4\u0081\u00f4\u008f\u00f6\u00d1=\u009aG\u00efh\u001d\u009d\u00a3q\u00f4\u008d\u00b6\u00d15\u009aF\u00cfh\u0019\u001d\u00a3a\u00f4\u008bv\u00d1-\u009aE\u00afh\u0015\u009d\u00a2Q\u00f4\u00896\u00d1%\u009aD\u008fh\u0011\u001d\u00a2A\u00f4\u0087\u00f6\u00d0\u001d\u009aCoh\r\u009d\u00a11\u00f4\u0085\u00b6\u00d0\u0015\u009aBOh\t\u001d\u00a1!\u00f4\u0083v\u00d0\r\u009aA/h\u0005\u009d\u00a0c\u00c3~\u00fd\u00ed\u00dd\u00cd\u00bd\u00ad\u0011@\u00f0\u0000;\u00c0\r0\u0003\u00bc\u0000+\u00c0\t0\u0002|\u0000\u001b\u00c0\u00050\u0001<\u0000\u000b\u00c0\u00010\u0000\u00bc\u008e\u00d5q:F\u00c7\u00e7\u00d8\u001c\u0097cr<\u008e\u00c5q8\u0006\u00c7\u00df\u00d8\u001bwcn\u00bc\u008d\u00b5q6\u00c6\u00c6\u00d7\u00d8\u001aWcj<\u008d\u00a5q4\u0086\u00c6\u00cf\u00d8\u00197cf\u00bc\u008c\u0095q2F\u00c6\u00c7\u00d8\u0018\u0017cb<\u008c\u0085q0\u0006\u00c6\u00bf\u00d8\u0017\u00f7b^\u00bc\u008buq.\u00c6\u00c5\u00b7\u00d8\u0016\u00d7bZ<\u008beq,\u0086\u00c5\u00af\u00d8\u0015\u00b7bV\u00bc\u008aUq*F\u00c5\u00a7\u00d8\u0014\u0097bR<\u008aEq(\u0006\u00c5\u009f\u00d8\u0013wbN\u00bc\u00895q&\u00c6\u00c4\u0097\u00d8\u0012WbJ<\u0089%q$\u0086\u00c4\u008f\u00d8\u00117bF\u00bc\u0088\u0015q\"F\u00c4\u0087\u00d8\u0010\u0017bB<\u0088\u0005q \u0006\u00c4\u007f\u00d8\u000f\u00f7a>\u00bc\u0087\u00f5p\u001e\u00c6\u00c3w\u00d8\u000e\u00d7a:<\u0087\u00e5p\u001c\u0086\u00c3o\u00d8\r\u00b7a6\u00bc\u0086\u00d5\u00f0\u008e\u00d30\u001a>\u00c3f\u00b8\f\u0093\u00e11,\u0086\u00c30\u0018\u00fe\u00c2^\u00b8\u000bs\u00e1-\u00ac\u0085\u00b30\u0016\u00be\u00c2V\u00b8\nS\u00e1),\u0085\u00a30\u0014~\u00c2N\u00b8\t3\u00e1%\u00ac\u0084\u00930\u0012>\u00c2F\u00b8\b\u0013\u00e1!,\u0084\u00830\u0010\u00fe\u00c1>\u00b8\u0007\u00f3\u00e0\u001d\u00ac\u0083s0\u000e\u00be\u00c16\u00b8\u0006\u00d3\u00e0\u0019,\u0083c0\f~\u00c1.\u00b8\u0005\u00b3\u00e0\u0015\u00ac\u0082S0\n>\u00c1&\u00b8\u0004\u0093\u00e0\u0011,\u0082C0\b\u00fe\u00c0\u001e\u00b8\u0003s\u00e0\r\u00ac\u008130\u0006\u00be\u00c0\u0016\u00b8\u0002S\u00e0\t,\u0081#0\u0004~\u00c0\u000e\u00b8\u00013\u00e0\u0005\u00ac\u0080\u0013pd\u00c8\u008f\u009f\u009d\u009b\u0099\u00975\u0002\b\u00f6\u0081u`\u001bX\u0006v\u0081U`\u0013X\u0004\u00f6\u00805`\u000bX\u0002v\u0080\u0015`\u0003X\u0000v\u00dd\u00aa\u00dbt\u008bn\u00cf\u00ad\u00b9-\u00b7\u00e4v\u00dc\u008a\u00dbp\u000bn\u00bf\u00ad\u00b7\u00ed\u00b6\u00dcv\u00dbj\u00dbl\u008bm\u00af\u00ad\u00b5\u00ad\u00b6\u00d4v\u00daJ\u00dbh\u000bm\u009f\u00ad\u00b3m\u00b6\u00ccv\u00d9*\u00dbd\u008bl\u008f\u00ad\u00b1-\u00b6\u00c4v\u00d8\n\u00db`\u000bl\u007f\u00ad\u00af\u00ed\u00b5\u00bcv\u00d7\u00ea\u00da\\\u008bko\u00ad\u00ad\u00ad\u00b5\u00b4v\u00d6\u00ca\u00daX\u000bk_\u00ad\u00abm\u00b5\u00acv\u00d5\u00aa\u00daT\u008bjO\u00ad\u00a9-\u00b5\u00a4v\u00d4\u008a\u00daP\u000bj?\u00ad\u00a7\u00ed\u00b4\u009cv\u00d3j\u00daL\u008bi/\u00ad\u00a5\u00ad\u00b4\u0094v\u00d2J\u00daH\u000bi\u001f\u00ad\u00a3m\u00b4\u008cv\u00d1*\u00daD\u008bh\u000f\u00ad\u00a1-\u00b4\u0084v\u00d0\n\u00da@\u000bh\u00ff\u00ac\u009f\u00ed\u00b3|v\u00cf\u00ea\u00d9<\u008bg\u00ef\u00ac\u009d\u00ad\u00b3t6i\u001e\u009aw\u00e6\u0099ye\u001e\u00997\u00e6\u0089ya\u001e\u0098\u00f7\u00e5yy]\u001e\u0097\u00b7\u00e5iyY\u001e\u0096w\u00e5YyU\u001e\u00957\u00e5IyQ\u001e\u0094\u00f7\u00e49yM\u001e\u0093\u00b7\u00e4)yI\u001e\u0092w\u00e4\u0019yE\u001e\u00917\u00e4\tyA\u001e\u0090\u00f7\u00e3\u00f9x=\u001e\u008f\u00b7\u00e3\u00e9x9\u001e\u008ew\u00e3\u00d9x5\u001e\u008d7\u00e3\u00c9x1\u001e\u008c\u00f7\u00e2\u00b9x-\u001e\u008b\u00b7\u00e2\u00a9x)\u001e\u008aw\u00e2\u0099x%\u001e\u00897\u00e2\u0089x!\u001e\u0088\u00f7\u00e1yx\u001d\u001e\u0087\u00b7\u00e1ix\u0019\u001e\u0086w\u00e1Yx\u0015\u001e\u00857\u00e1Ix\u0011\u001e\u0084\u00f7\u00e09x\r\u001e\u0083\u00b7\u00e0)x\t^|\u00f0\u00bd\u00f7\u00cf_?~\u00fb4\u0002\b\u001ep\u00a0\u0001\u0006~\u0081W\u00e0\u0013x\u0004\u00fe\u00807\u00e0\u000bx\u0002~\u0080\u0017\u00e0\u0003x\u0000~\u00dd\u00ab\u00fbt\u008f\u00ee\u00cf\u00bd\u00b9/\u00f7\u00e4~\u00dc\u008b\u00fbp\u000f\u00ee\u00bf\u00bd\u00b7\u00ef\u00f6\u00dc~\u00dbk\u00fbl\u008f\u00ed\u00af\u00bd\u00b5\u00af\u00f6\u00d4~\u00daK\u00fbh\u000f\u00ed\u009f\u00bd\u00b3o\u00f6\u00cc~\u00d9+\u00fbd\u008f\u00ec\u008f\u00bd\u00b1/\u00f6\u00c4~\u00d8\u000b\u00fb`\u000f\u00ec\u007f\u00bd\u00af\u00ef\u00f5\u00bc~\u00d7\u00eb\u00fa\\\u008f\u00ebo\u00bd\u00ad\u00af\u00f5\u00b4~\u00d6\u00cb\u00faX\u000f\u00eb_\u00bd\u00abo\u00f5\u00ac~\u00d5\u00ab\u00faT\u008f\u00eaO\u00bd\u00a9/\u00f5\u00a4~\u00d4\u008b\u00faP\u000f\u00ea?\u00bd\u00a7\u00ef\u00f4\u009c~\u00d3k\u00faL\u008f\u00e9/\u00bd\u00a5\u00af\u00f4\u0094~\u00d2K\u00faH\u000f\u00e9\u001f\u00bd\u00a3o\u00f4\u008c~\u00d1+\u00faD\u008f\u00e8\u000f\u00bd\u00a1/\u00f4\u0084~\u00d0\u000b\u00fa@\u000f\u00e8\u00ff\u00bc\u009f\u00ef\u00f3|~\u00cf\u00eb\u00f9<\u008f\u00e7\u00ef\u00bc\u009d\u00af\u00f3t~\u00ce\u00cb\u00f98\u000f\u00e7\u00df\u00bc\u009bo\u00f3l~\u00cd\u00ab\u00f9\u00dd\u00a7y4\u007f\u00e6\u00cd|\u0099'\u00f3c^\u00cc\u0087y0\u00ff\u00e5\u00bd|\u0097\u00e7\u00f2[^\u00cbgy,\u007f\u00e5\u00ad|\u0095\u00a7\u00f2S^\u00caGy(\u00ff\u00e4\u009d|\u0093g\u00f2K^\u00c9'y$\u007f\u00e4\u008d|\u0091'\u00f2C^\u00c8\u0007y \u00ff\u00e3}|\u008f\u00e7\u00f1;^\u00c7\u00e7x\u001c\u007f\u00e3m|\u008d\u00a7\u00f13^\u00c6\u00c7x\u0018\u00ff\u00e2]|\u008bg\u00f1+^\u00c5\u00a7x\u0014\u007f\u00e2M|\u0089'\u00f1#^\u00c4\u0087x\u0010\u00ff\u00e1=|\u0087\u00e7\u00f0\u001b^\u00c3gx\f\u007f\u00e1-|\u0085\u00a7\u00f0\u0013^\u00c2Gx\b\u00ff\u00e0\u001d|\u0083g\u00f0\u000b^\u00c1'\u00f8\u00f8\u00f0\u00df\u00ff\u00fb\u00f7\u00f3\u00efk\u0004\u0010<\u00e0@\u0003\u00ce\u0080/\u00e0\nx\u0002\u008e\u0080\u001f\u00e0\u0006x\u0001N\u0080\u000f\u00e0\u0002x\u0000\u000e\u0080\u00afsu\u009e\u00ce\u00d1\u00f997\u00e7\u00e5\u009c\u009c\u008fsq\u001e\u00ce\u00c1\u00f97\u00f7\u00e6\u00dd\u009c\u009bosm\u009e\u00cd\u00b1\u00f95\u00b7\u00e6\u00d5\u009c\u009aOsi\u001e\u00cd\u00a1\u00f93w\u00e6\u00cd\u009c\u0099/se\u009e\u00cc\u0091\u00f917\u00e6\u00c5\u009c\u0098\u000fsa\u001e\u00cc\u0081\u00f9/\u00f7\u00e5\u00bd\u009c\u0097\u00efr]\u009e\u00cbq\u00f9-\u00b7\u00e5\u00b5\u009c\u0096\u00cfrY\u001e\u00cba\u00f9+w\u00e5\u00ad\u009c\u0095\u00afrU\u009e\u00caQ\u00f9)7\u00e5\u00a5\u009c\u0094\u008frQ\u001e\u00caA\u00f9'\u00f7\u00e4\u009d\u009c\u0093orM\u009e\u00c91\u00f9%\u00b7\u00e4\u0095\u009c\u0092OrI\u001e\u00c9!\u00f9#w\u00e4\u008d\u009c\u0091/rE\u009e\u00c8\u0011\u00f9!7\u00e4\u0085\u009c\u0090\u000frA\u001e\u00c8\u0001\u00f9\u001f\u00f7\u00e3}\u009c\u008f\u00efq=\u009e\u00c7\u00f1\u00f8\u001d\u00b7\u00e3u\u009c\u008e\u00cfq9\u001e\u00c7\u00e1\u00f8\u001bw\u00e3m\u009c\u008d\u00afq5\u00be\u00f34\u008e\u00c6\u00cf\u00b8\u0019/\u00e3d|\u008c\u008b\u00f10\u000e\u00c6\u00bf\u00b8\u0017\u00ef\u00e2\\|\u008bk\u00f1,\u008e\u00c5\u00af\u00b8\u0015\u00af\u00e2T|\u008aK\u00f1(\u000e\u00c5\u009f\u00b8\u0013o\u00e2L|\u0089+\u00f1$\u008e\u00c4\u008f\u00b8\u0011/\u00e2D|\u0088\u000b\u00f1 \u000e\u00c4\u007f\u00b8\u000f\u00ef\u00e1<|\u0087\u00eb\u00f0\u001c\u008e\u00c3o\u00b8\r\u00af\u00e14|\u0086\u00cb\u00f0\u0018\u000e\u00c3_\u00b8\u000bo\u00e1,|\u0085\u00ab\u00f0\u0014\u008e\u00c2O\u00b8\t/\u00e1$|\u0084\u008b\u00f0\u0010\u000e\u00c2?\u00b8\u0007\u00ef\u00e0\u001c|\u0083k\u00f0\f\u008e\u00c1/\u00b8\u0005\u00af\u00e0\u0014|\u0082K\u00f0\b\u000e\u00c1\u001f\u00b8\u0003o\u00e0\f|\u0081+\u00f0\u0004\u001e\u001d\u00fa\u00f3w\u00f7v\u00f6u\u008d\u0000\u0082\u0007\u001c\u00e8\u0006\u009a\u0081^\u00a0\u0015\u00e8\u0004\u001a\u0081>\u00a0\r\u00e8\u0002\u009a\u0080\u001e\u00a0\u0005\u00e8\u0000\u001a\u0080^\u0017\u0099\u0099\u0099;@\u00bb?;?\u00bb>;>\u00bb=;=\u00bb<;<\u00bb;;;\u00bb:;:\u00bb9;9\u00bb8;8\u00bb7;7\u00bb6;6\u00bb5;5\u00bb\u00dd.\u00cd\u000e\u00cd\u00ee\u00cc\u00ce\u00cc\u00ae\u00cc\u008e\u00ccn\u00ccN\u00cc.\u00cc\u000e\u00cc\u00ee\u00cb\u00ce\u00cb\u00ae\u00cb\u008e\u00cbn\u00cbN\u00cb.\u00cb\u000e\u00cb\u00ee\u00ca\u00ce\u00ca\u00ae\u00ca\u008e\u00can\u00ca.P\u0084\u0015_EW\u00b1Ud\u0015WEU1UD\u0015OES\u00b1T$\u0015GEQ1T\u0004\u0015?EO\u00b1S\u00e4\u00147EM1S\u00c4\u0014/EK\u00b1R\u00a4\u0014'EI1R\u0084\u0014\u001fEG\u00b1Qd\u0014\u0017EE1QD\u0014\u000fEC\u00b1P$\u0014\u0007EA1P\u0004\u0014\u00ffD?\u00b1O\u00e4\u0013\u00f7D=1O\u00c4\u0013\u00efD;\u00b1N\u00a4\u0013\u00e7D91N\u0084\u0013\u00dfD7\u00b1Md\u0013\u00d7D5q\u0017\u00d3D4\u00f1L4\u0013\u00cbD2qL\u0014\u0013\u00c3D0\u00f1K\u00f4\u0012\u00bbD.qK\u00d4\u0012\u00b3D,\u00f1J\u00b4\u0012\u00abD*qJ\u0094\u0012\u00a3D(\u00f1It\u0012\u009bD&qIT\u0012\u0093D$\u00f1H4\u0012\u008bD\"qH\u0014\u0012\u0083D \u00f1G\u00f4\u0011{D\u001eqG\u00d4\u0011sD\u001c\u00f1F\u00b4\u0011kD\u001aqF\u0094\u0011cD\u0018\u00f1Et\u0011[D\u0016qET\u0011SD\u0014\u00f1D4\u0011KD\u0012qD\u0014\u0011CD\u0010\u00f1C\u00f4\u0010;D\u000eqC\u00d4\u00103D\f\u00f1B\u00b4\u0010+D\nqB\u0094\u0010#D\b\u00f1At\u0010\u001bD\u0006qAT\u0010\u0013\u00c4\u0018a|\u00f1\u00a3\u00c7\u008e\u001c7j\u0004\u0010<\u00e0@\u0003\f,\u00a0\u0000L\u0000\"\u0000\u000f\u0080\u0006\u00c0\u0002 \u0001p\u0000(\u0000\f\u0000\u0002\u0000\u00d7Au0\u001dD\u0007\u00cfAs\u00b0\u001c$\u0007\u00c7Aq0\u001c\u0004\u0007\u00bfAo\u00b0\u001b\u00e4\u0006\u00b7Am0\u001b\u00c4\u0006\u00afAk\u00b0\u001a\u00a4\u0006\u00a7Ai0\u001a\u0084\u0006\u009fAg\u00b0\u0019d\u0006\u0097Ae0\u0019D\u0006\u008fAc\u00b0\u0018$\u0006\u0087Aa0\u0018\u0004\u0006\u007fA_\u00b0\u0017\u00e4\u0005wA]0\u0017\u00c4\u0005oA[\u00b0\u0016\u00a4\u0005gAY0\u0016\u0084\u0005_AW\u00b0\u0015d\u0005WAU0\u0015D\u0005OAS\u00b0\u0014$\u0005GAQ0\u0014\u0004\u0005?AO\u00b0\u0013\u00e4\u00047AM0\u0013\u00c4\u0004/AK\u00b0\u0012\u00a4\u0004'AI0\u0012\u0084\u0004\u001fAG\u00b0\u0011d\u0004\u0017AE0\u0011D\u0004\u000fAC\u00b0\u0010$\u0004\u0007AA0\u0010\u0004\u0004\u00ff@?\u00b0\u000f\u00e4\u0003\u00f7@=0\u000f\u00c4\u0003\u00ef@;\u00b0\u000e\u00a4\u0003\u00e7@90\u000e\u0084\u0003\u00df@7\u00b0\rd\u0003\u00d7@5p\u0007\u00d3@4\u00f0\f4\u0003\u00cb@2p\f\u0014\u0003\u00c3@0\u00f0\u000b\u00f4\u0002\u00bb@.p\u000b\u00d4\u0002\u00b3@,\u00f0\n\u00b4\u0002\u00ab@*p\n\u0094\u0002\u00a3@(\u00f0\tt\u0002\u009b@&p\tT\u0002\u0093@$\u00f0\b4\u0002\u008b@\"p\b\u0014\u0002\u0083@ \u00f0\u0007\u00f4\u0001{@\u001ep\u0007\u00d4\u0001s@\u001c\u00f0\u0006\u00b4\u0001k@\u001ap\u0006\u0094\u0001c@\u0018\u00f0\u0005t\u0001[@\u0016p\u0005T\u0001S@\u0014\u00f0\u00044\u0001K@\u0012p\u0004\u0014\u0001C@\u0010\u00f0\u0003\u00f4\u0000;@\u000ep\u0003\u00d4\u00003@\f\u00f0\u0002\u00b4\u0000+@\np\u0002\u0094\u0000#@\b\u00f0\u0001t\u0000\u001b@\u0006p\u0001T\u0000\u0013\u00c0\b!|\u00f0\u00a1\u00c3\u0086\f\u0017j\u0004\u0010<\u00e0@\u0003\f,\u00f0\u0014x\t<\u0004\u00de\u0001\u00cf\u0080W\u00c0#\u00e0\r\u00f0\u0004x\u0001<\u0000\u00de\u00ba\u00a7\u00ee\u00a5{\u00e8\u00de\u00b9g\u00ee\u0095{\u00e4\u00de\u00b8'\u00ee\u0085{\u00e0\u00de\u00b7\u00e7\u00edu{\u00dc\u00de\u00b6\u00a7\u00ede{\u00d8\u00de\u00b5g\u00edU{\u00d4\u00de\u00b4'\u00edE{\u00d0\u00de\u00b3\u00e7\u00ec5{\u00cc\u00de\u00b2\u00a7\u00ec%{\u00c8\u00de\u00b1g\u00ec\u0015{\u00c4\u00de\u00b0'\u00ec\u0005{\u00c0\u00de\u00af\u00e7\u00eb\u00f5z\u00bc\u00de\u00ae\u00a7\u00eb\u00e5z\u00b8\u00de\u00adg\u00eb\u00d5z\u00b4\u00de\u00ac'\u00eb\u00c5z\u00b0\u00de\u00ab\u00e7\u00ea\u00b5z\u00ac\u00de\u00aa\u00a7\u00ea\u00a5z\u00a8\u00de\u00a9g\u00ea\u0095z\u00a4\u00de\u00a8'\u00ea\u0085z\u00a0\u00de\u00a7\u00e7\u00e9uz\u009c\u00de\u00a6\u00a7\u00e9ez\u0098\u00de\u00a5g\u00e9Uz\u0094\u00de\u00a4'\u00e9Ez\u0090\u00de\u00a3\u00e7\u00e85z\u008c\u00de\u00a2\u00a7\u00e8%z\u0088\u00de\u00a1g\u00e8\u0015z\u0084\u00de\u00a0'\u00e8\u0005z\u0080\u00de\u009f\u00e7\u00e7\u00f5y|\u00de\u009e\u00a7\u00e7\u00e5yx\u00de\u009dg\u00e7\u00d5yt\u00de\u009c'\u00e7\u00c5yp\u00de\u009b\u00e7\u00e6\u00b5yl\u00de\u009a\u00a7\u00e6\u00ed^\u0089\u00e1\u00a84\u0000\u00c1\u007f\u00b3\u009f\u0090\u0005\u0000\u0014@\u00fcm\u000b\u00f5}U\u00a4lx\u000f=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u00e8\u00d8\t\u00fa\u00d9\u00a6\u00f5\u00beQ\u0080\u0010\u00ff=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u0084\u00e8\u00d86\u00b5*\u00f7~\u00cf|\u00f7\u00c3\u009a\u008ca\u00f7\u00e3\u001a\u001bt\u00b5\u00dc\u00d3\u00ac\u0007\u0086\u00a5~{`}b\u00c6]U\u00b8\u00ccV\u00ec\u001eO\u00b0\u0086\u00fb\u00ec\u00875\u0019\u00c3\u001e\u00eeg\u00bb\u0096\u00bbO\u00c4D\u00fez`}\u0014b\u00c6\u0012\u00e5> \u000b*\u00fb\u00e9\u0001\u0082\u00f5Y\u00ef\u00e6\u001e\u00dc'\u00e9\u007f\u00f6\u00bb\u001bZ8\u00fe\u00b9\u008cyG\u009aQ "}, "dtype": "int64", "shape": [2531]}, "structural_analysis_error": "index 0 is out of bounds for axis 0 with size 0", "trajectory": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-2821f959834844a79ff406338c9e4101/simulation.nc"}, "unit_estimate": {":is_custom:": true, "magnitude": 5.547080310903667, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_estimate_error": {":is_custom:": true, "magnitude": 2.1531827158735815, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_mbar_overlap": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u00c1\u0000\u0000z\u00af\u00ff\u00ff\u00ff\u00ff\u00ef?\u00b6G\u00f3\u0013\u00ea\u00ff\u00ef?^\u00dbL\u00c1\u0004`\u00c7?"}, "dtype": "float64", "shape": [3]}, "matrix": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd H\u00dd\u0001\u0000\u0004\u0003^W\u00a1b\u00f1\u00ff\u00ef?Z\u00fb\u009b\u00ad\u008e\u0090\u00d5>\u001f<\u00d6;\u00ba\u00a8\u00be>\u00e8\u00c2:w\u00f9\u00eb\u00e2?\u00d7\u00a3\u00fb\u0080\u00f7'\u00da?\u00be\u0013jj\u0000\u00ec\u00e2?\u0003\u0004\u0005\u0000\u0018j1s\f"}, "dtype": "float64", "shape": [3, 3]}, "scalar": 1.0453257126785687e-05}}, "source_key": "HybridTopologyMultiStateAnalysisUnit-a7252f67bcd541378e9846b01ad21a5e", "start_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:03.455126"}, "stderr": {}, "stdout": {}} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-d33eca8ebd87402985a14b4dba99da37 b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-d33eca8ebd87402985a14b4dba99da37 new file mode 100644 index 000000000..c9864168f --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/results/ProtocolUnitResult-d33eca8ebd87402985a14b4dba99da37 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.protocols.protocolunit", "__qualname__": "ProtocolUnitResult", "_key": "ProtocolUnitResult-d33eca8ebd87402985a14b4dba99da37", "end_time": {":is_custom:": true, "__class__": "datetime", "__module__": "datetime", "isotime": "2026-08-14T11:26:26.744717"}, "inputs": {"generation": 0, "protocol": {":gufe-key:": "RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616"}, "repeat_id": 223150426984276242809719357896568479063, "setup_results": {":gufe-key:": "ProtocolUnitResult-5b13b16ed9834a51ac7be4751e9e5dc0"}, "simulation_results": {":gufe-key:": "ProtocolUnitResult-ac48c86b69b04a159e530c42c8008a95"}}, "name": "HybridTopology Analysis: ligand_2 to ligand_3 repeat 0 generation 0", "outputs": {"checkpoint": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc/checkpoint.chk"}, "equilibration_iterations": 5.0, "forward_and_reverse_energies": {"forward_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00c5\u0001\u0000\u00d4\u0002\u00e4a]L\u00a7\u00f8\u00f2\u00bf]=\u00fcg\u0095\u0094\u00f4\u00bf[N\b\u00cd\u00f3O9l\u00ba\u000e\u0007\u00a2\u00e9k\u0001*\u0014\u00df\u008b\u00e9\u00bfS\u00f9\u009f\u00dfu\u000f\u00e5\u00bf\u0003\u0000\u00a0\u0018`SC\n\u0017"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "forward_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00cd\u0001\u0000\u00e4\u0002Q\u00cb\u00a7 \u00c5\u000b\u00e9?\u00e0\u00fe\u0086\u0084_\u00ba\u00d6?{]\u0088\u00f229\u00dcM6f\u0086\u001d\u00c0\u00da\t\u00d8a\u00b1\u0085\u0017\u00dc?|\u00879O\u00ef\u0082\u00db?\u0003\u0000\u00a0\u0018\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "fractions": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P=\u0001\u0000\u0088UU\u00c5?U\u00d5?\u0000\u00e0\u00e5\u00e5?\u00ab\u00aa\u00ea\u00f0?\t\u0000C\u00a5\u00c0Y\u0002\u00f9\u0086\u001a\u00b1R\u0017w\u00cd\n\u0002p\u00c3\u0002X"}, "dtype": "float64", "shape": [10]}, "reverse_DGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00d5\u0001\u0000\u00f4\u0002\u0003\u00a4H\u00c8\u009c\u00ff\u0001@~4<\u00b44\u00dc\u0001@+*\u00e5\r\u00eb\u00f7\u00f5?\u00b0\u00ea\u00b1a\u00e00\u00edq\u00fc\u00d4\u001dP\u00be\u00dd\u00bfS\u00f9\u009f\u00dfu\u000f\u00e5\u00bf\u0003\u0000\u00a0\u0018\u0080XC\n\u0017"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "reverse_dDGs": {":is_custom:": true, "magnitude": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd P\u00d5\u0001\u0000\u00f4\u0002\f\u00dd\u00a3\u0019\u00010 @a\u00e2\u009d\u008e\u00dbZ\u001f@u\u00b9\u001d\u00fa\u00c2\u00d4\u0000L\u0000n\u00fd\u000b0\u00f7?|\u00bc\u00e1y\u0096W\u00e2?|\u00879O\u00ef\u0082\u00db?\u0003\u0000\u0080p\u00a0\u00a8CJ\u001c"}, "dtype": "float64", "shape": [10]}, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}}, "generation": 0, "pdb_structure": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologySetupUnit-17dc05e0d79747e79d3e93e55383c9bd/hybrid_system.pdb"}, "production_iterations": 7.0, "repeat_id": 223150426984276242809719357896568479063, "replica_exchange_statistics": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u008d\u0000\u00008\u0000\u0000\u00f0?\u0000\u00e0?\u0003\u0000+\u0004\u00c0\r\u000b`\u0001"}, "dtype": "float64", "shape": [3]}, "matrix": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd H\u00c5\u0000\u0000P\u0000\u0000\u00f0?\u0000\u00e8\u00d0?\u00e8?\u0005\u00003\t\u0000$\u000e\u00e52p\u008e\u0005m"}, "dtype": "float64", "shape": [3, 3]}}, "selection_indices": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd`\u0018N\u00ad\u0087\u0000j9iA\u001c\u0010\u0018<\f\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u00000\u0000\u0000\u0000P\u0002\u0000\u00004\u0093R\u00a6\u0094RJ)\u00ef\u0003\u00f6\u0003\u0004\u0004sV\u00ce\u00c6Y8\u00fbf\u00ddl\u009be\u00b3kV\u00cd\u00ee6\u00cd\u00a2\u00d93kf\u00cb,\u0099\u001d\u00b3b6\u00cc\u0082\u00d9/\u00ebe\u00bb,\u0097\u00dd\u00b2Z6\u00cbb\u00d9+ke\u00ab,\u0095\u009d\u00b2R6\u00caB\u00d9'\u00ebd\u009b,\u0093]\u00b2J6\u00c9\"\u00d9#kd\u008b,\u0091\u001d\u00b2B6\u00c8\u0002\u00d9\u001f\u00ebc{,\u008f\u00dd\u00b1:6\u00c7\u00e2\u00d8\u001bkck,\u008d\u009d\u00b126\u00c6\u00c2\u00d8\u0017\u00ebb[,\u008b]\u00b1*6\u00c5\u00a2\u00d8\u0013kbK,\u0089\u001d\u00b1\"6\u00c4\u0082\u00d8\u000f\u00eba;,\u0087\u00dd\u00b0\u001a6\u00c3b\u00d8\u000bka+,\u0085\u009d\u00b0\u00126\u00c2B\u00d8\u0007\u00eb`\u001b,\u0083]\u00b0\n6\u00c1\u00c6\u0085\u00fb\u00f6\u00d7\u00b7\u0097wW#P\b\u00f4\u0001u@\u001bP\u0006t\u0001U@\u0013P\u0004\u00f4\u00005@\u000bP\u0002t\u0000\u0015@\u0003P\u0000t\u009d\u00aa\u00d3t\u008aN\u00cf\u00a99-\u00a7\u00e4t\u009c\u008a\u00d3p\nN\u00bf\u00a97\u00ed\u00a6\u00dct\u009bj\u00d3l\u008aM\u00af\u00a95\u00ad\u00a6\u00d4t\u009aJ\u00d3h\nM\u009f\u00a93m\u00a6\u00cct\u0099*\u00d3d\u008aL\u008f\u00a91-\u00a6\u00c4t\u0098\n\u00d3`\nL\u007f\u00a9/\u00ed\u00a5\u00bct\u0097\u00ea\u00d2\\\u008aKo\u00a9-\u00ad\u00a5\u00b4t\u0096\u00ca\u00d2X\nK_\u00a9+m\u00a5\u00act\u0095\u00aa\u00d2T\u008aJO\u00a9)-\u00a5\u00a4t\u0094\u008a\u00d2P\nJ?\u00a9'\u00ed\u00a4\u009ct\u0093j\u00d2L\u008aI/\u00a9%\u00ad\u00a4\u0094t\u0092J\u00d2H\nI\u001f\u00a9#m\u00a4\u008ct\u0091*\u00d2D\u008aH\u000f\u00a9!-\u00a4\u0084t\u0090\n\u00d2@\nH\u00ff\u00a8\u001f\u00ed\u00a3|t\u008f\u00ea\u00d1<\u008aG\u00ef\u00a8\u001d\u00ad\u00a3tt\u008e\u00ca\u00d18\nG\u00df\u00a8\u001bm\u00a3lt\u008d\u00aa\u00d1\u009d\u00a6Q4zF\u00cdh\u0019%\u00a3cT\u008c\u0086Q0\u00faE\u00bdh\u0017\u00e5\u00a2[T\u008bfQ,zE\u00adh\u0015\u00a5\u00a2ST\u008aFQ(\u00faD\u009dh\u0013e\u00a2KT\u0089&Q$zD\u008dh\u0011%\u00a2CT\u0088\u0006Q \u00faC}h\u000f\u00e5\u00a1;T\u0087\u00e6P\u001czCmh\r\u00a5\u00a13T\u0086\u00c6P\u0018\u00faB]h\u000be\u00a1+T\u0085\u00a6P\u0014zBMh\t%\u00a1#T\u0084\u0086P\u0010\u00faA=h\u0007\u00e5\u00a0\u001bT\u0083fP\fzA-h\u0005\u00a5\u00a0\u0013T\u0082FP\b\u00fa@\u001dh\u0003e\u00a0\u000bT\u0081&\u00d0\u00a8P\u009f\u00be\u00ba\u00b6\u00b2\u00aejF\u0090\u0010\u00e4\u0003\u00e9@6\u0090\f\u00e4\u0002\u00a9@&\u0090\b\u00e4\u0001i@\u0016\u0090\u0004\u00e4\u0000)@\u0006\u0090\u0000\u00e4\u00baT\u0097\u00e9\u0012]\u009eKsY.\u00c9\u00e5\u00b8\u0014\u0097\u00e1\u0012\\~Ko\u00d9-\u00b9\u00e5\u00b6\u00d4\u0096\u00d9\u0012[^KkY-\u00a9\u00e5\u00b4\u0094\u0096\u00d1\u0012Z>Kg\u00d9,\u0099\u00e5\u00b2T\u0096\u00c9\u0012Y\u001eKcY,\u0089\u00e5\u00b0\u0014\u0096\u00c1\u0012X\u00feJ_\u00d9+y\u00e5\u00ae\u00d4\u0095\u00b9\u0012W\u00deJ[Y+i\u00e5\u00ac\u0094\u0095\u00b1\u0012V\u00beJW\u00d9*Y\u00e5\u00aaT\u0095\u00a9\u0012U\u009eJSY*I\u00e5\u00a8\u0014\u0095\u00a1\u0012T~JO\u00d9)9\u00e5\u00a6\u00d4\u0094\u0099\u0012S^JKY))\u00e5\u00a4\u0094\u0094\u0091\u0012R>JG\u00d9(\u0019\u00e5\u00a2T\u0094\u0089\u0012Q\u001eJCY(\t\u00e5\u00a0\u0014\u0094\u0081\u0012P\u00feI?\u00d9'\u00f9\u00e4\u009e\u00d4\u0093y\u0012O\u00deI;Y'\u00e9\u00e4\u009c\u0094\u0093q\u0012N\u00beI7\u00d9&\u00d9\u00e4\u009aT\u0093\u00bbL\u0093h\u00f2L\u009a\u00c92I&\u00c7\u00a4\u0098\f\u0093`\u00f2Kz\u00c9.\u00c9%\u00b7\u00a4\u0096\u00cc\u0092X\u00f2JZ\u00c9*I%\u00a7\u00a4\u0094\u008c\u0092P\u00f2I:\u00c9&\u00c9$\u0097\u00a4\u0092L\u0092H\u00f2H\u001a\u00c9\"I$\u0087\u00a4\u0090\f\u0092@\u00f2G\u00fa\u00c8\u001e\u00c9#w\u00a4\u008e\u00cc\u00918\u00f2F\u00da\u00c8\u001aI#g\u00a4\u008c\u008c\u00910\u00f2E\u00ba\u00c8\u0016\u00c9\"W\u00a4\u008aL\u0091(\u00f2D\u009a\u00c8\u0012I\"G\u00a4\u0088\f\u0091 \u00f2Cz\u00c8\u000e\u00c9!7\u00a4\u0086\u00cc\u0090\u0018\u00f2BZ\u00c8\nI!'\u00a4\u0084\u008c\u0090\u0010\u00f2A:\u00c8\u0006\u00c9 \u0017\u00a4\u0082L\u00901a\u00be\u00fc\u00f4\u00ec\u00e4\u00dc\u00d4\u00cc\u00ad\u00ae\u00d35\u00ba>\u00d7\u00e6\u00ba\\\u0093\u00ebq-\u00ae\u00c35\u00b8\u00fe\u00d6\u00de\u00ba[s\u00ebm\u00ad\u00ad\u00b35\u00b6\u00be\u00d6\u00d6\u00baZS\u00ebi-\u00ad\u00a35\u00b4~\u00d6\u00ce\u00baY3\u00ebe\u00ad\u00ac\u00935\u00b2>\u00d6\u00c6\u00baX\u0013\u00eba-\u00ac\u00835\u00b0\u00fe\u00d5\u00be\u00baW\u00f3\u00ea]\u00ad\u00abs5\u00ae\u00be\u00d5\u00b6\u00baV\u00d3\u00eaY-\u00abc5\u00ac~\u00d5\u00ae\u00baU\u00b3\u00eaU\u00ad\u00aaS5\u00aa>\u00d5\u00a6\u00baT\u0093\u00eaQ-\u00aaC5\u00a8\u00fe\u00d4\u009e\u00baSs\u00eaM\u00ad\u00a935\u00a6\u00be\u00d4\u0096\u00baRS\u00eaI-\u00a9#5\u00a4~\u00d4\u008e\u00baQ3\u00eaE\u00ad\u00a8\u00135\u00a2>\u00d4\u0086\u00baP\u0013\u00eaA-\u00a8\u00035\u00a0\u00fe\u00d3~\u00baO\u00f3\u00e9=\u00ad\u00a7\u00f34\u009e\u00be\u00d3v\u00baN\u00d3\u00e99-\u00a7\u00e34\u009c~\u00d3n\u00baM\u00b3\u00e95\u00ad\u00a6w\u009d\u00a6\u00d1\u00f4\u00996\u00d3e\u009aL\u008fi1\u001d\u00a6\u00c1\u00f4\u0097\u00f6\u00d2]\u009aKoi-\u009d\u00a5\u00b1\u00f4\u0095\u00b6\u00d2U\u009aJOi)\u001d\u00a5\u00a1\u00f4\u0093v\u00d2M\u009aI/i%\u009d\u00a4\u0091\u00f4\u00916\u00d2E\u009aH\u000fi!\u001d\u00a4\u0081\u00f4\u008f\u00f6\u00d1=\u009aG\u00efh\u001d\u009d\u00a3q\u00f4\u008d\u00b6\u00d15\u009aF\u00cfh\u0019\u001d\u00a3a\u00f4\u008bv\u00d1-\u009aE\u00afh\u0015\u009d\u00a2Q\u00f4\u00896\u00d1%\u009aD\u008fh\u0011\u001d\u00a2A\u00f4\u0087\u00f6\u00d0\u001d\u009aCoh\r\u009d\u00a11\u00f4\u0085\u00b6\u00d0\u0015\u009aBOh\t\u001d\u00a1!\u00f4\u0083v\u00d0\r\u009aA/h\u0005\u009d\u00a0c\u00c3~\u00fd\u00ed\u00dd\u00cd\u00bd\u00ad\u0011@\u00f0\u0000;\u00c0\r0\u0003\u00bc\u0000+\u00c0\t0\u0002|\u0000\u001b\u00c0\u00050\u0001<\u0000\u000b\u00c0\u00010\u0000\u00bc\u008e\u00d5q:F\u00c7\u00e7\u00d8\u001c\u0097cr<\u008e\u00c5q8\u0006\u00c7\u00df\u00d8\u001bwcn\u00bc\u008d\u00b5q6\u00c6\u00c6\u00d7\u00d8\u001aWcj<\u008d\u00a5q4\u0086\u00c6\u00cf\u00d8\u00197cf\u00bc\u008c\u0095q2F\u00c6\u00c7\u00d8\u0018\u0017cb<\u008c\u0085q0\u0006\u00c6\u00bf\u00d8\u0017\u00f7b^\u00bc\u008buq.\u00c6\u00c5\u00b7\u00d8\u0016\u00d7bZ<\u008beq,\u0086\u00c5\u00af\u00d8\u0015\u00b7bV\u00bc\u008aUq*F\u00c5\u00a7\u00d8\u0014\u0097bR<\u008aEq(\u0006\u00c5\u009f\u00d8\u0013wbN\u00bc\u00895q&\u00c6\u00c4\u0097\u00d8\u0012WbJ<\u0089%q$\u0086\u00c4\u008f\u00d8\u00117bF\u00bc\u0088\u0015q\"F\u00c4\u0087\u00d8\u0010\u0017bB<\u0088\u0005q \u0006\u00c4\u007f\u00d8\u000f\u00f7a>\u00bc\u0087\u00f5p\u001e\u00c6\u00c3w\u00d8\u000e\u00d7a:<\u0087\u00e5p\u001c\u0086\u00c3o\u00d8\r\u00b7a6\u00bc\u0086\u00d5\u00f0\u008e\u00d30\u001a>\u00c3f\u00b8\f\u0093\u00e11,\u0086\u00c30\u0018\u00fe\u00c2^\u00b8\u000bs\u00e1-\u00ac\u0085\u00b30\u0016\u00be\u00c2V\u00b8\nS\u00e1),\u0085\u00a30\u0014~\u00c2N\u00b8\t3\u00e1%\u00ac\u0084\u00930\u0012>\u00c2F\u00b8\b\u0013\u00e1!,\u0084\u00830\u0010\u00fe\u00c1>\u00b8\u0007\u00f3\u00e0\u001d\u00ac\u0083s0\u000e\u00be\u00c16\u00b8\u0006\u00d3\u00e0\u0019,\u0083c0\f~\u00c1.\u00b8\u0005\u00b3\u00e0\u0015\u00ac\u0082S0\n>\u00c1&\u00b8\u0004\u0093\u00e0\u0011,\u0082C0\b\u00fe\u00c0\u001e\u00b8\u0003s\u00e0\r\u00ac\u008130\u0006\u00be\u00c0\u0016\u00b8\u0002S\u00e0\t,\u0081#0\u0004~\u00c0\u000e\u00b8\u00013\u00e0\u0005\u00ac\u0080\u0013pd\u00c8\u008f\u009f\u009d\u009b\u0099\u00975\u0002\b\u00f6\u0081u`\u001bX\u0006v\u0081U`\u0013X\u0004\u00f6\u00805`\u000bX\u0002v\u0080\u0015`\u0003X\u0000v\u00dd\u00aa\u00dbt\u008bn\u00cf\u00ad\u00b9-\u00b7\u00e4v\u00dc\u008a\u00dbp\u000bn\u00bf\u00ad\u00b7\u00ed\u00b6\u00dcv\u00dbj\u00dbl\u008bm\u00af\u00ad\u00b5\u00ad\u00b6\u00d4v\u00daJ\u00dbh\u000bm\u009f\u00ad\u00b3m\u00b6\u00ccv\u00d9*\u00dbd\u008bl\u008f\u00ad\u00b1-\u00b6\u00c4v\u00d8\n\u00db`\u000bl\u007f\u00ad\u00af\u00ed\u00b5\u00bcv\u00d7\u00ea\u00da\\\u008bko\u00ad\u00ad\u00ad\u00b5\u00b4v\u00d6\u00ca\u00daX\u000bk_\u00ad\u00abm\u00b5\u00acv\u00d5\u00aa\u00daT\u008bjO\u00ad\u00a9-\u00b5\u00a4v\u00d4\u008a\u00daP\u000bj?\u00ad\u00a7\u00ed\u00b4\u009cv\u00d3j\u00daL\u008bi/\u00ad\u00a5\u00ad\u00b4\u0094v\u00d2J\u00daH\u000bi\u001f\u00ad\u00a3m\u00b4\u008cv\u00d1*\u00daD\u008bh\u000f\u00ad\u00a1-\u00b4\u0084v\u00d0\n\u00da@\u000bh\u00ff\u00ac\u009f\u00ed\u00b3|v\u00cf\u00ea\u00d9<\u008bg\u00ef\u00ac\u009d\u00ad\u00b3t6i\u001e\u009aw\u00e6\u0099ye\u001e\u00997\u00e6\u0089ya\u001e\u0098\u00f7\u00e5yy]\u001e\u0097\u00b7\u00e5iyY\u001e\u0096w\u00e5YyU\u001e\u00957\u00e5IyQ\u001e\u0094\u00f7\u00e49yM\u001e\u0093\u00b7\u00e4)yI\u001e\u0092w\u00e4\u0019yE\u001e\u00917\u00e4\tyA\u001e\u0090\u00f7\u00e3\u00f9x=\u001e\u008f\u00b7\u00e3\u00e9x9\u001e\u008ew\u00e3\u00d9x5\u001e\u008d7\u00e3\u00c9x1\u001e\u008c\u00f7\u00e2\u00b9x-\u001e\u008b\u00b7\u00e2\u00a9x)\u001e\u008aw\u00e2\u0099x%\u001e\u00897\u00e2\u0089x!\u001e\u0088\u00f7\u00e1yx\u001d\u001e\u0087\u00b7\u00e1ix\u0019\u001e\u0086w\u00e1Yx\u0015\u001e\u00857\u00e1Ix\u0011\u001e\u0084\u00f7\u00e09x\r\u001e\u0083\u00b7\u00e0)x\t^|\u00f0\u00bd\u00f7\u00cf_?~\u00fb4\u0002\b\u001ep\u00a0\u0001\u0006~\u0081W\u00e0\u0013x\u0004\u00fe\u00807\u00e0\u000bx\u0002~\u0080\u0017\u00e0\u0003x\u0000~\u00dd\u00ab\u00fbt\u008f\u00ee\u00cf\u00bd\u00b9/\u00f7\u00e4~\u00dc\u008b\u00fbp\u000f\u00ee\u00bf\u00bd\u00b7\u00ef\u00f6\u00dc~\u00dbk\u00fbl\u008f\u00ed\u00af\u00bd\u00b5\u00af\u00f6\u00d4~\u00daK\u00fbh\u000f\u00ed\u009f\u00bd\u00b3o\u00f6\u00cc~\u00d9+\u00fbd\u008f\u00ec\u008f\u00bd\u00b1/\u00f6\u00c4~\u00d8\u000b\u00fb`\u000f\u00ec\u007f\u00bd\u00af\u00ef\u00f5\u00bc~\u00d7\u00eb\u00fa\\\u008f\u00ebo\u00bd\u00ad\u00af\u00f5\u00b4~\u00d6\u00cb\u00faX\u000f\u00eb_\u00bd\u00abo\u00f5\u00ac~\u00d5\u00ab\u00faT\u008f\u00eaO\u00bd\u00a9/\u00f5\u00a4~\u00d4\u008b\u00faP\u000f\u00ea?\u00bd\u00a7\u00ef\u00f4\u009c~\u00d3k\u00faL\u008f\u00e9/\u00bd\u00a5\u00af\u00f4\u0094~\u00d2K\u00faH\u000f\u00e9\u001f\u00bd\u00a3o\u00f4\u008c~\u00d1+\u00faD\u008f\u00e8\u000f\u00bd\u00a1/\u00f4\u0084~\u00d0\u000b\u00fa@\u000f\u00e8\u00ff\u00bc\u009f\u00ef\u00f3|~\u00cf\u00eb\u00f9<\u008f\u00e7\u00ef\u00bc\u009d\u00af\u00f3t~\u00ce\u00cb\u00f98\u000f\u00e7\u00df\u00bc\u009bo\u00f3l~\u00cd\u00ab\u00f9\u00dd\u00a7y4\u007f\u00e6\u00cd|\u0099'\u00f3c^\u00cc\u0087y0\u00ff\u00e5\u00bd|\u0097\u00e7\u00f2[^\u00cbgy,\u007f\u00e5\u00ad|\u0095\u00a7\u00f2S^\u00caGy(\u00ff\u00e4\u009d|\u0093g\u00f2K^\u00c9'y$\u007f\u00e4\u008d|\u0091'\u00f2C^\u00c8\u0007y \u00ff\u00e3}|\u008f\u00e7\u00f1;^\u00c7\u00e7x\u001c\u007f\u00e3m|\u008d\u00a7\u00f13^\u00c6\u00c7x\u0018\u00ff\u00e2]|\u008bg\u00f1+^\u00c5\u00a7x\u0014\u007f\u00e2M|\u0089'\u00f1#^\u00c4\u0087x\u0010\u00ff\u00e1=|\u0087\u00e7\u00f0\u001b^\u00c3gx\f\u007f\u00e1-|\u0085\u00a7\u00f0\u0013^\u00c2Gx\b\u00ff\u00e0\u001d|\u0083g\u00f0\u000b^\u00c1'\u00f8\u00f8\u00f0\u00df\u00ff\u00fb\u00f7\u00f3\u00efk\u0004\u0010<\u00e0@\u0003\u00ce\u0080/\u00e0\nx\u0002\u008e\u0080\u001f\u00e0\u0006x\u0001N\u0080\u000f\u00e0\u0002x\u0000\u000e\u0080\u00afsu\u009e\u00ce\u00d1\u00f997\u00e7\u00e5\u009c\u009c\u008fsq\u001e\u00ce\u00c1\u00f97\u00f7\u00e6\u00dd\u009c\u009bosm\u009e\u00cd\u00b1\u00f95\u00b7\u00e6\u00d5\u009c\u009aOsi\u001e\u00cd\u00a1\u00f93w\u00e6\u00cd\u009c\u0099/se\u009e\u00cc\u0091\u00f917\u00e6\u00c5\u009c\u0098\u000fsa\u001e\u00cc\u0081\u00f9/\u00f7\u00e5\u00bd\u009c\u0097\u00efr]\u009e\u00cbq\u00f9-\u00b7\u00e5\u00b5\u009c\u0096\u00cfrY\u001e\u00cba\u00f9+w\u00e5\u00ad\u009c\u0095\u00afrU\u009e\u00caQ\u00f9)7\u00e5\u00a5\u009c\u0094\u008frQ\u001e\u00caA\u00f9'\u00f7\u00e4\u009d\u009c\u0093orM\u009e\u00c91\u00f9%\u00b7\u00e4\u0095\u009c\u0092OrI\u001e\u00c9!\u00f9#w\u00e4\u008d\u009c\u0091/rE\u009e\u00c8\u0011\u00f9!7\u00e4\u0085\u009c\u0090\u000frA\u001e\u00c8\u0001\u00f9\u001f\u00f7\u00e3}\u009c\u008f\u00efq=\u009e\u00c7\u00f1\u00f8\u001d\u00b7\u00e3u\u009c\u008e\u00cfq9\u001e\u00c7\u00e1\u00f8\u001bw\u00e3m\u009c\u008d\u00afq5\u00be\u00f34\u008e\u00c6\u00cf\u00b8\u0019/\u00e3d|\u008c\u008b\u00f10\u000e\u00c6\u00bf\u00b8\u0017\u00ef\u00e2\\|\u008bk\u00f1,\u008e\u00c5\u00af\u00b8\u0015\u00af\u00e2T|\u008aK\u00f1(\u000e\u00c5\u009f\u00b8\u0013o\u00e2L|\u0089+\u00f1$\u008e\u00c4\u008f\u00b8\u0011/\u00e2D|\u0088\u000b\u00f1 \u000e\u00c4\u007f\u00b8\u000f\u00ef\u00e1<|\u0087\u00eb\u00f0\u001c\u008e\u00c3o\u00b8\r\u00af\u00e14|\u0086\u00cb\u00f0\u0018\u000e\u00c3_\u00b8\u000bo\u00e1,|\u0085\u00ab\u00f0\u0014\u008e\u00c2O\u00b8\t/\u00e1$|\u0084\u008b\u00f0\u0010\u000e\u00c2?\u00b8\u0007\u00ef\u00e0\u001c|\u0083k\u00f0\f\u008e\u00c1/\u00b8\u0005\u00af\u00e0\u0014|\u0082K\u00f0\b\u000e\u00c1\u001f\u00b8\u0003o\u00e0\f|\u0081+\u00f0\u0004\u001e\u001d\u00fa\u00f3w\u00f7v\u00f6u\u008d\u0000\u0082\u0007\u001c\u00e8\u0006\u009a\u0081^\u00a0\u0015\u00e8\u0004\u001a\u0081>\u00a0\r\u00e8\u0002\u009a\u0080\u001e\u00a0\u0005\u00e8\u0000\u001a\u0080^\u0017\u0099\u0099\u0099;@\u00bb?;?\u00bb>;>\u00bb=;=\u00bb<;<\u00bb;;;\u00bb:;:\u00bb9;9\u00bb8;8\u00bb7;7\u00bb6;6\u00bb5;5\u00bb\u00dd.\u00cd\u000e\u00cd\u00ee\u00cc\u00ce\u00cc\u00ae\u00cc\u008e\u00ccn\u00ccN\u00cc.\u00cc\u000e\u00cc\u00ee\u00cb\u00ce\u00cb\u00ae\u00cb\u008e\u00cbn\u00cbN\u00cb.\u00cb\u000e\u00cb\u00ee\u00ca\u00ce\u00ca\u00ae\u00ca\u008e\u00can\u00ca.P\u0084\u0015_EW\u00b1Ud\u0015WEU1UD\u0015OES\u00b1T$\u0015GEQ1T\u0004\u0015?EO\u00b1S\u00e4\u00147EM1S\u00c4\u0014/EK\u00b1R\u00a4\u0014'EI1R\u0084\u0014\u001fEG\u00b1Qd\u0014\u0017EE1QD\u0014\u000fEC\u00b1P$\u0014\u0007EA1P\u0004\u0014\u00ffD?\u00b1O\u00e4\u0013\u00f7D=1O\u00c4\u0013\u00efD;\u00b1N\u00a4\u0013\u00e7D91N\u0084\u0013\u00dfD7\u00b1Md\u0013\u00d7D5q\u0017\u00d3D4\u00f1L4\u0013\u00cbD2qL\u0014\u0013\u00c3D0\u00f1K\u00f4\u0012\u00bbD.qK\u00d4\u0012\u00b3D,\u00f1J\u00b4\u0012\u00abD*qJ\u0094\u0012\u00a3D(\u00f1It\u0012\u009bD&qIT\u0012\u0093D$\u00f1H4\u0012\u008bD\"qH\u0014\u0012\u0083D \u00f1G\u00f4\u0011{D\u001eqG\u00d4\u0011sD\u001c\u00f1F\u00b4\u0011kD\u001aqF\u0094\u0011cD\u0018\u00f1Et\u0011[D\u0016qET\u0011SD\u0014\u00f1D4\u0011KD\u0012qD\u0014\u0011CD\u0010\u00f1C\u00f4\u0010;D\u000eqC\u00d4\u00103D\f\u00f1B\u00b4\u0010+D\nqB\u0094\u0010#D\b\u00f1At\u0010\u001bD\u0006qAT\u0010\u0013\u00c4\u0018a|\u00f1\u00a3\u00c7\u008e\u001c7j\u0004\u0010<\u00e0@\u0003\f,\u00a0\u0000L\u0000\"\u0000\u000f\u0080\u0006\u00c0\u0002 \u0001p\u0000(\u0000\f\u0000\u0002\u0000\u00d7Au0\u001dD\u0007\u00cfAs\u00b0\u001c$\u0007\u00c7Aq0\u001c\u0004\u0007\u00bfAo\u00b0\u001b\u00e4\u0006\u00b7Am0\u001b\u00c4\u0006\u00afAk\u00b0\u001a\u00a4\u0006\u00a7Ai0\u001a\u0084\u0006\u009fAg\u00b0\u0019d\u0006\u0097Ae0\u0019D\u0006\u008fAc\u00b0\u0018$\u0006\u0087Aa0\u0018\u0004\u0006\u007fA_\u00b0\u0017\u00e4\u0005wA]0\u0017\u00c4\u0005oA[\u00b0\u0016\u00a4\u0005gAY0\u0016\u0084\u0005_AW\u00b0\u0015d\u0005WAU0\u0015D\u0005OAS\u00b0\u0014$\u0005GAQ0\u0014\u0004\u0005?AO\u00b0\u0013\u00e4\u00047AM0\u0013\u00c4\u0004/AK\u00b0\u0012\u00a4\u0004'AI0\u0012\u0084\u0004\u001fAG\u00b0\u0011d\u0004\u0017AE0\u0011D\u0004\u000fAC\u00b0\u0010$\u0004\u0007AA0\u0010\u0004\u0004\u00ff@?\u00b0\u000f\u00e4\u0003\u00f7@=0\u000f\u00c4\u0003\u00ef@;\u00b0\u000e\u00a4\u0003\u00e7@90\u000e\u0084\u0003\u00df@7\u00b0\rd\u0003\u00d7@5p\u0007\u00d3@4\u00f0\f4\u0003\u00cb@2p\f\u0014\u0003\u00c3@0\u00f0\u000b\u00f4\u0002\u00bb@.p\u000b\u00d4\u0002\u00b3@,\u00f0\n\u00b4\u0002\u00ab@*p\n\u0094\u0002\u00a3@(\u00f0\tt\u0002\u009b@&p\tT\u0002\u0093@$\u00f0\b4\u0002\u008b@\"p\b\u0014\u0002\u0083@ \u00f0\u0007\u00f4\u0001{@\u001ep\u0007\u00d4\u0001s@\u001c\u00f0\u0006\u00b4\u0001k@\u001ap\u0006\u0094\u0001c@\u0018\u00f0\u0005t\u0001[@\u0016p\u0005T\u0001S@\u0014\u00f0\u00044\u0001K@\u0012p\u0004\u0014\u0001C@\u0010\u00f0\u0003\u00f4\u0000;@\u000ep\u0003\u00d4\u00003@\f\u00f0\u0002\u00b4\u0000+@\np\u0002\u0094\u0000#@\b\u00f0\u0001t\u0000\u001b@\u0006p\u0001T\u0000\u0013\u00c0\b!|\u00f0\u00a1\u00c3\u0086\f\u0017j\u0004\u0010<\u00e0@\u0003\f,\u00f0\u0014x\t<\u0004\u00de\u0001\u00cf\u0080W\u00c0#\u00e0\r\u00f0\u0004x\u0001<\u0000\u00de\u00ba\u00a7\u00ee\u00a5{\u00e8\u00de\u00b9g\u00ee\u0095{\u00e4\u00de\u00b8'\u00ee\u0085{\u00e0\u00de\u00b7\u00e7\u00edu{\u00dc\u00de\u00b6\u00a7\u00ede{\u00d8\u00de\u00b5g\u00edU{\u00d4\u00de\u00b4'\u00edE{\u00d0\u00de\u00b3\u00e7\u00ec5{\u00cc\u00de\u00b2\u00a7\u00ec%{\u00c8\u00de\u00b1g\u00ec\u0015{\u00c4\u00de\u00b0'\u00ec\u0005{\u00c0\u00de\u00af\u00e7\u00eb\u00f5z\u00bc\u00de\u00ae\u00a7\u00eb\u00e5z\u00b8\u00de\u00adg\u00eb\u00d5z\u00b4\u00de\u00ac'\u00eb\u00c5z\u00b0\u00de\u00ab\u00e7\u00ea\u00b5z\u00ac\u00de\u00aa\u00a7\u00ea\u00a5z\u00a8\u00de\u00a9g\u00ea\u0095z\u00a4\u00de\u00a8'\u00ea\u0085z\u00a0\u00de\u00a7\u00e7\u00e9uz\u009c\u00de\u00a6\u00a7\u00e9ez\u0098\u00de\u00a5g\u00e9Uz\u0094\u00de\u00a4'\u00e9Ez\u0090\u00de\u00a3\u00e7\u00e85z\u008c\u00de\u00a2\u00a7\u00e8%z\u0088\u00de\u00a1g\u00e8\u0015z\u0084\u00de\u00a0'\u00e8\u0005z\u0080\u00de\u009f\u00e7\u00e7\u00f5y|\u00de\u009e\u00a7\u00e7\u00e5yx\u00de\u009dg\u00e7\u00d5yt\u00de\u009c'\u00e7\u00c5yp\u00de\u009b\u00e7\u00e6\u00b5yl\u00de\u009a\u00a7\u00e6\u00ed^\u0089\u00e1\u00a84\u0000\u00c1\u007f\u00b3\u009f\u0090\u0005\u0000\u0014@\u00fcm\u000b\u00f5}U\u00a4lx\u000f=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u00e8\u00d8\t\u00fa\u00d9\u00a6\u00f5\u00beQ\u0080\u0010\u00ff=\u00b0>1\u00e3\u00ae\\\u0086\u0096\u0084\u00e8\u00d86\u00b5*\u00f7~\u00cf|\u00f7\u00c3\u009a\u008ca\u00f7\u00e3\u001a\u001bt\u00b5\u00dc\u00d3\u00ac\u0007\u0086\u00a5~{`}b\u00c6]U\u00b8\u00ccV\u00ec\u001eO\u00b0\u0086\u00fb\u00ec\u00875\u0019\u00c3\u001e\u00eeg\u00bb\u0096\u00bbO\u00c4D\u00fez`}\u0014b\u00c6\u0012\u00e5> \u000b*\u00fb\u00e9\u0001\u0082\u00f5Y\u00ef\u00e6\u001e\u00dc'\u00e9\u007f\u00f6\u00bb\u001bZ8\u00fe\u00b9\u008cyG\u009aQ "}, "dtype": "int64", "shape": [2531]}, "structural_analysis_error": "index 0 is out of bounds for axis 0 with size 0", "trajectory": {":is_custom:": true, "__class__": "PosixPath", "__module__": "pathlib", "path": "mc1_campaign/shared/task_workdirs/HybridTopologyMultiStateSimulationUnit-15972a17ad31428280da2cc53c8a6cdc/simulation.nc"}, "unit_estimate": {":is_custom:": true, "magnitude": -0.6581372611688415, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_estimate_error": {":is_custom:": true, "magnitude": 0.5347989282518214, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "unit_mbar_overlap": {"eigenvalues": {":is_custom:": true, "__class__": "ndarray", "__module__": "numpy", "bytes": {":is_custom:": true, "__class__": "bytes", "__module__": "builtins", "latin-1": "(\u00b5/\u00fd \u0018\u00c1\u0000\u0000\u009eQ\u0000\u0000\u0000\u0000\u00f0?\u00aaN\u0097\u00da,~\u00e5?\u0018VR\u0095\n\u00d7\u00a3p=\u00da\u00bf\u00a6\u009b\u00c4 \u00b0\u00f2\u0010\u00c0H\u00e1z\u0014\u00ae\u0007#\u00c0&\u0006\u0081\u0095C\u008b\u00fa\u00bf\u0003+\u0087\u0016\u00d9\u00ce\u00e7\u00bf&\u0006\u0081\u0095C\u008b$\u00c0\u0080j\u00bct\u0093\u0018\u00f4\u00bf\u009b\u0099\u0099\u0099\u0099\u0099\u00c9\u00bfR\u00b8\u001e\u0085\u00ebQ \u00c0\u00d4Mb\u0010X9\u00f4\u00bfy\u00e9&1\b\u00ac\u00d4\u00bf\u00a3E\u00b6\u00f3\u00fdT\u001e\u00c0L7\u0089A`\u00e5\u00f0\u00bf0\u00dd$\u0006\u0081\u0095\u00f3\u00bf\u0084\u00c0\u00ca\u00a1E6\u001d\u00c0=\n\u00d7\u00a3p=\u0002\u00c0sh\u0091\u00ed|?\u00d5?\u00be\u009f\u001a/\u00ddd \u00c0\u00fa~j\u00bct\u0093h\u00bfR\u00b8\u001e\u0085\u00ebQ\u00e0?\u00ee|?5^\u00ba\u001c\u00c0\u00a7\u009b\u00c4 \u00b0r\u00d8?\u00de$\u0006\u0081\u0095C\u00e3?\u00baI\f\u0002+\u0007!\u00c0\u00f7(\\\u008f\u00c2\u00f5\u00c8\u00bfP\u008d\u0097n\u0012\u0083\u00f8?\u00a8\u00c6K7\u0089\u00c1\u0018\u00c0\u00b5\u00c8v\u00be\u009f\u001a\u0004\u00c0\u00dfO\u008d\u0097n\u0012\u00c3\u00bf<\u00dfO\u008d\u0097.\"\u00c0\u00baI\f\u0002+\u0087\u00ee?j\u00bct\u0093\u0018\u0004\u00a6?\u00ecQ\u00b8\u001e\u0085\u00eb#\u00c0b\u0010X9\u00b4\u00c8\u00ea?\u008bl\u00e7\u00fb\u00a9\u00f1\u00da?\u00e8\u00fb\u00a9\u00f1\u00d2\u00cd\u001f\u00c0\u00c9v\u00be\u009f\u001a/\b\u00c07\u0089A`\u00e5\u00d0\u00f4?\u00a0\u001a/\u00dd$\u0086!\u00c0\u001a\u0004V\u000e-\u00b2\u0005\u00c0J\f\u0002+\u0087\u0016\u00fd?\u00b0rh\u0091\u00ed\u00fc\u001c\u00c0\u00f0\u00a7\u00c6K7\t\u0010\u00c0\u0018\u00d9\u00ce\u00f7S\u00e3\u00ff?n\u00e7\u00fb\u00a9\u00f1R\u0019\u00c0%\u0006\u0081\u0095C\u008b\f\u00c0\u0014\u00aeG\u00e1z\u0014\u0003@\u0094\u0018\u0004V\u000e-\u001b\u00c0P\u008d\u0097n\u0012\u0083\u0014\u00c0\u00db\u00f9~j\u00bct\u00f1?F\u00b6\u00f3\u00fd\u00d48 \u00c0,\u0087\u0016\u00d9\u00ce\u00f7\u0011\u00c0\u00b0rh\u0091\u00ed|\t@\u00b6\u00f3\u00fd\u00d4x)\"\u00c0\u00be\u009f\u001a/\u00dd\u00a4\u0013\u00c01\b\u00ac\u001cZd\u0007@\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd \u00c08\u0089A`\u00e5\u00d0\f\u00c0?5^\u00baI\f\u000e@\u008f\u00c2\u00f5(\\\u008f\u0016\u00c0\u0085\u00ebQ\u00b8\u001e\u0005\u0016\u00c0\u001dZd;\u00dfO\u00f3?R\u00b8\u001e\u0085\u00eb\u00d1\u001d\u00c0\u000b\u00d7\u00a3p=\n\u0016\u00c0\u00d5x\u00e9&1\u0088\u0010@\u00db\u00f9~j\u00bct\u001b\u00c0\u001c/\u00dd$\u0006\u0001\u0019\u00c08\u0089A`\u00e5\u00d0\f@\f\u0002+\u0087\u0016\u00d9\u0019\u00c0333333\u0013\u00c0\u00bct\u0093\u0018\u0004V\u0014@\u00fe\u00d4x\u00e9&1\u0018\u00c0\u00e2z\u0014\u00aeG\u00e1\u000e\u00c0w\u00be\u009f\u001a/\u00dd\u0012@\r\u0002+\u0087\u0016\u00d9\u0016\u00c0\u00c4\u00f5(\\\u008fB\u0016\u00c0\u00a0\u001a/\u00dd$\u0006\u0015@\u00ea&1\b\u00ac\u009c\u001c\u00c0Nb\u0010X9\u00b4\u0012\u00c0\u00fe\u00d4x\u00e9&\u00b1\u0017@\u0085\u00ebQ\u00b8\u001e\u0005!\u00c0\u00bf\u009f\u001a/\u00dd$\u0019\u00c0\u00d3Mb\u0010X\u00b9\u0013@\u0017\u00d9\u00ce\u00f7Sc\"\u00c0\u001f\u0085\u00ebQ\u00b8\u001e\u001b\u00c0\u00db\u00f9~j\u00bc\u00f4\u0010@1\b\u00ac\u001cZ$\"\u00c0w\u00be\u009f\u001a/]\u0016\u00c0=\n\u00d7\u00a3p=\u0016@\u00a8\u00c6K7\u0089\u0001 \u00c0\u00e3\u00a5\u009b\u00c4 0\u001c\u00c0\u00aa\u00f1\u00d2Mb\u0010\u0016@r=\n\u00d7\u00a3p\u001e\u00c0W\u000e-\u00b2\u009do\u0016\u00c0ffffff\u00c6?\u001dZd;\u00df\u000f!\u00c0\u0088\u0016\u00d9\u00ce\u00f7\u00d3\u0014\u00c0T\u00e3\u00a5\u009b\u00c4 \u00c0?\u00e4\u00a5\u009b\u00c4 0\u001d\u00c0L7\u0089A`e\u001a\u00c0\u0086\u00ebQ\u00b8\u001e\u0085\u00eb\u00bf\u0085\u00ebQ\u00b8\u001e\u0005\u001c\u00c0q=\n\u00d7\u00a3\u00f0\u001d\u00c0\u008cl\u00e7\u00fb\u00a9\u00f1\u00d2\u00bf\u0006\u0081\u0095C\u008b\u00ec\u0018\u00c0H\u00e1z\u0014\u00ae\u00c7\u0018\u00c0\u0090\u00c2\u00f5(\\\u008f\u00fe\u00bf\u00b2\u009d\u00ef\u00a7\u00c6K!\u00c0\u00f2\u00d2Mb\u0010\u00d8\u001b\u00c0\u00de$\u0006\u0081\u0095C\u00f9\u00bf\u00bct\u0093\u0018\u0004V\"\u00c0'1\b\u00ac\u001cZ\u0018\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u00ff\u00bfNb\u0010X9\u00b4\"\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5\u001d\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u00ec\u00bf-\u00b2\u009d\u00ef\u00a7\u00c6\u0014\u00c0j\u00bct\u0093\u0018\u0084\u001b\u00c0\u00d3Mb\u0010X9\u0001\u00c0\u00e3\u00a5\u009b\u00c4 \u00f0 \u00c0S\u00b8\u001e\u0085\u00eb\u00d1\u001f\u00c0\u001eZd;\u00dfO\u0006\u00c0\u0092\u00ed|?5\u00de\"\u00c0\u00a6\u009b\u00c4 \u00b0r\u001f\u00c0\t\u00ac\u001cZd;\n\u00c0\u00dc\u00f9~j\u00bct\u001e\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u00cd\u001e\u00c0R\u00b8\u001e\u0085\u00ebQ\u000b\u00c0\u0002+\u0087\u0016\u00d9\u008e \u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd\"\u00c0\u00ac\u001cZd;\u00df\u0001\u00c0\u00c1\u00ca\u00a1E\u00b6s!\u00c0\u00f0\u00a7\u00c6K7\u00c9$\u00c0\u0094\u0018\u0004V\u000e-\u0007\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u001e\u00c0n\u00e7\u00fb\u00a9\u00f1R#\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u00f2\u00bf_\u00baI\f\u0002\u00ab\u0019\u00c0/\u00dd$\u0006\u0081\u0015\u0014\u00c0\u0093\u0018\u0004V\u000e-\u0004\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u001c\u00c0\u00a8\u00c6K7\u0089\u00c1\u0011\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u0001\u00c0b\u0010X9\u00b4\u00c8\u0015\u00c09\u00b4\u00c8v\u00be\u009f\u0011\u00c0gfffff\u000b\u00c0sh\u0091\u00ed|?\u0015\u00c0\u009e\u00ef\u00a7\u00c6K7\u0014\u00c0^\u00baI\f\u0002+\u0011\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u000f\u00c0\u00ecQ\u00b8\u001e\u0085k\u0011\u00c0d;\u00dfO\u008d\u0097\u0006\u00c0F\u00b6\u00f3\u00fd\u00d4\u00f8\u0017\u00c0\u00bf\u009f\u001a/\u00dd$\b\u00c0C`\u00e5\u00d0\"\u00db\u000f\u00c0U\u00e3\u00a5\u009b\u00c4 \u0019\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\u0003\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\b\u00c0?5^\u00baI\f\b\u00c0Zd;\u00dfO\r\u0013\u00c0\u00a4p=\n\u00d7\u00a3\u000b\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\u001c\u00c09\u00b4\u00c8v\u00be\u009f\n\u00c0\f\u0002+\u0087\u0016\u00d9\u0013\u00c0w\u00be\u009f\u001a/]\u001b\u00c0h\u0091\u00ed|?5\u000f\u00c0\u00a2E\u00b6\u00f3\u00fdT\u0017\u00c0\u00db\u00f9~j\u00bct\u001f\u00c0H\u00e1z\u0014\u00aeG\u0010\u00c0\u00f6(\\\u008f\u00c2u\u0012\u00c0\u008f\u00c2\u00f5(\\\u008f\u0013\u00c0\u00e9&1\b\u00ac\u001c\u0002\u00c0\u0092\u00ed|?5\u00de\u0012\u00c0)\\\u008f\u00c2\u00f5\u00a8\u0011\u00c0\u00afG\u00e1z\u0014\u00ae\u0006\u00c0Zd;\u00dfO\r\u0016\u00c0h\u0091\u00ed|?\u00b5\u0014\u00c0\u0096C\u008bl\u00e7\u00fb\u00f3\u00bf\u00b0rh\u0091\u00ed\u00fc\u0013\u00c0\u00bct\u0093\u0018\u0004V\u0010\u00c0T\u00e3\u00a5\u009b\u00c4 \u0000\u00c0\u009a\u0099\u0099\u0099\u0099\u0019\u0010\u00c0\u009e\u00ef\u00a7\u00c6K7 \u00c0\u00fe\u00d4x\u00e9&1\u0001\u00c0L7\u0089A`e\u0015\u00c0U\u00e3\u00a5\u009b\u00c4 \u001e\u00c0H\u00e1z\u0014\u00aeG\u00f5\u00bf\u00d9\u00ce\u00f7S\u00e3%\u0017\u00c0\u009e\u00ef\u00a7\u00c6K\u00f7 \u00c0\u00afG\u00e1z\u0014\u00ae\u00fb\u00bf\u0093\u0018\u0004V\u000e\u00ad\u0011\u00c0\u00a2E\u00b6\u00f3\u00fd\u0094!\u00c0w\u00be\u009f\u001a/\u00dd\u0003\u00c0\u00d6x\u00e9&1\u0088\u0018\u00c0e;\u00dfO\u008d\u0097\u000e\u00c0\u00cav\u00be\u009f\u001a/\u000f\u00c0Zd;\u00dfO\u008d\u00f9\u00bfT\u00e3\u00a5\u009b\u00c4\u00a0\u0012\u00c0\u0088\u0016\u00d9\u00ce\u00f7S\r\u00c0H\u00e1z\u0014\u00aeG\u00f1\u00bfK\f\u0002+\u0087\u0016\u0004\u00c0\u0080j\u00bct\u0093\u0018\u000e\u00c0\u0099n\u0012\u0083\u00c0\u00ca\u00ed\u00bf%\u0006\u0081\u0095C\u008b\u00fc\u00bf\u00c8K7\u0089A`\u000b\u00c07\u0089A`\u00e5\u00d0\u00fa\u00bf\u00a2E\u00b6\u00f3\u00fd\u00d4\u0000\u00c0-\u00b2\u009d\u00ef\u00a7F\u0014\u00c0\u00a8\u00c6K7\u0089A\u00d8\u00bfY9\u00b4\u00c8v\u00be\u0004\u00c0\u001a\u0004V\u000e-\u00b2\u0005\u00c0\u00aeG\u00e1z\u0014\u00ae\u00c7?_\u00baI\f\u0002+\f\u00c0\n\u00d7\u00a3p=\n\u0007\u00c0\u0088\u0016\u00d9\u00ce\u00f7S\u00e7?(1\b\u00ac\u001cZ\u00ec\u00bf\u00aeG\u00e1z\u0014.\u0015\u00c0\u00d3Mb\u0010X9\u00dc\u00bf\u00c8K7\u0089A`\u0005\u00c05^\u00baI\f\u0002\u00f5\u00bf\u00b2\u009d\u00ef\u00a7\u00c6K\u00df\u00bf$\u00db\u00f9~j\u00bc\u00fa\u00bf\u00e0O\u008d\u0097n\u0012\u00ef\u00bf\u0003+\u0087\u0016\u00d9\u00ce\u00e7\u00bfD\u008bl\u00e7\u00fb\u00a9\t\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\u00f5\u00bfu\u0093\u0018\u0004V\u000e\u00f7\u00bf\u0014\u00aeG\u00e1z\u0014\u00f6\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u0005\u00c0j\u00bct\u0093\u0018\u0004\u00f2?\u00e2z\u0014\u00aeG\u00e1\u00f4\u00bf433333\f\u00c0\u00afG\u00e1z\u0014\u00ae\u00fb?\u007fj\u00bct\u0093\u0018\u00f6\u00bf*\\\u008f\u00c2\u00f5(\u00fc\u00bf%\u0006\u0081\u0095C\u008b\u00fc?\u00d9\u00ce\u00f7S\u00e3\u00a5\u00e3\u00bfh\u0091\u00ed|?5\u0005\u00c0\n\u00d7\u00a3p=\n\u00d7?\u00db\u00f9~j\u00bct\u000b\u00c0\u0014\u00aeG\u00e1z\u0014\u00ce\u00bf\u001dZd;\u00dfO\u00d5?\b\u00ac\u001cZd\u00bb\u0011\u00c0\t\u00ac\u001cZd;\u00df\u00bf\u00f4\u00fd\u00d4x\u00e9&\u00e5?\u0001\u0000\u0000\u0000\u0000\u0000\u0007\u00c0{\u0014\u00aeG\u00e1z\u0094?D\u008bl\u00e7\u00fb\u00a9\u00f3?\u00ecQ\u00b8\u001e\u0085\u00eb\f\u00c0\u0082\u0095C\u008bl\u00e7\u00e3?+\u0087\u0016\u00d9\u00ce\u00f7\u00d3\u00bfNb\u0010X9\u00b4\u0007\u00c0\u00b0rh\u0091\u00ed\u00fc\u0017\u00c09\u00b4\u00c8v\u00be\u009f\u00ba?<\u00dfO\u008d\u0097n\u000f\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2\u0016\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u00c6?\u00ac\u001cZd;\u00df\u0004\u00c0.\u00b2\u009d\u00ef\u00a7\u00c6\u001d\u00c0\u0090\u00c2\u00f5(\\\u008f\u00da?e;\u00dfO\u008d\u0097\u00fe\u00bf\u0093\u0018\u0004V\u000e-\u001e\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u00f4?th\u0091\u00ed|?\u00ff\u00bf\u00a8\u00c6K7\u0089A \u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\u00e8\u00bf\t\u00ac\u001cZd;\u000f\u00c0(1\b\u00ac\u001cZ \u00c0\u00e0O\u008d\u0097n\u0012\u00eb?d;\u00dfO\u008d\u0097\u0010\u00c0;\u00dfO\u008d\u0097\u00ee\u001e\u00c06^\u00baI\f\u0002\u00fd?\u00f0\u00a7\u00c6K7\u0089\u0012\u00c0H\u00e1z\u0014\u00ae\u0007 \u00c0z\u00e9&1\b\u00ac\u00ac?\u00b4\u00c8v\u00be\u009f\u001a\u00eb\u00bfo\u0012\u0083\u00c0\u00caa!\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u00e4\u00bf\u0094\u0018\u0004V\u000e-\f\u00c0\u009c\u00c4 \u00b0r(#\u00c0<\u00dfO\u008d\u0097n\u00ee?\u00cf\u00f7S\u00e3\u00a5\u009b\n\u00c0=\n\u00d7\u00a3p}#\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u00fe?\u0004V\u000e-\u00b2\u009d\u0004\u00c0fffff& \u00c0\u00f1\u00a7\u00c6K7\u0089\u00ff\u00bf2\b\u00ac\u001cZd\u000b\u00c0\u00a4p=\n\u00d7#\u001e\u00c0P\u008d\u0097n\u0012\u0083\u0000\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u0000\u00c0\u0019\u0004V\u000e-r!\u00c0h\u0091\u00ed|?5\t\u00c0\u00d2\"\u00db\u00f9~j\u00fe\u00bf\u00a0\u001a/\u00dd$\u0086#\u00c0\u0097C\u008bl\u00e7\u00fb\u0006\u00c0B`\u00e5\u00d0\"\u00db\u00e9\u00bf\u00b4\u00c8v\u00be\u009f\u001a \u00c0\u00b4\u00c8v\u00be\u009f\u001a\r\u00c0\u0003+\u0087\u0016\u00d9\u00ce\b\u00c0;\u00dfO\u008d\u0097.!\u00c0\u00f4\u00fd\u00d4x\u00e9&\u0011\u00c0\u00a4p=\n\u00d7\u00a3\u000b\u00c0\u00d4Mb\u0010X9\u001e\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u00d3\u0010\u00c0\u00db\u00f9~j\u00bct\u0005\u00c0\u00e5\u00d0\"\u00db\u00f9\u00be!\u00c0\u0085\u00ebQ\u00b8\u001e\u0005\u0015\u00c0\u00db\u00f9~j\u00bct\u00a3?\u00dd$\u0006\u0081\u0095\u0083!\u00c0X9\u00b4\u00c8v\u00be\u0010\u00c0333333\u0011\u00c0\u008f\u00c2\u00f5(\\\u000f#\u00c0F\u00b6\u00f3\u00fd\u00d4x\u000f\u00c0'1\b\u00ac\u001cZ\u0012\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\"\u00c0H\u00e1z\u0014\u00aeG\u0007\u00c0\u00d6x\u00e9&1\b\u000f\u00c0\u00ab\u00f1\u00d2Mb\u0010%\u00c0\u0089A`\u00e5\u00d0\"\u000f\u00c0\u008d\u0097n\u0012\u0083\u00c0\u0015\u00c0\u00b4\u00c8v\u00be\u009f\u00da\"\u00c0\u001eZd;\u00df\u00cf\u0013\u00c0 \u0085\u00ebQ\u00b8\u001e\u0017\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb \u00c0\u00c6 \u00b0rh\u0091\u0013\u00c0\u0085\u00ebQ\u00b8\u001e\u0085\u0014\u00c0\u009e\u00ef\u00a7\u00c6K\u00f7\"\u00c0\u00e5\u00d0\"\u00db\u00f9\u00fe\u0017\u00c0\u008f\u00c2\u00f5(\\\u000f\u001a\u00c0\u00e2z\u0014\u00aeG\u00e1$\u00c0\u0089A`\u00e5\u00d0\"\u0013\u00c0q=\n\u00d7\u00a3\u00f0\u001c\u00c0\u00b8\u001e\u0085\u00ebQ8$\u00c0\u0089A`\u00e5\u00d0\u00a2\u0010\u00c0\u0013\u0083\u00c0\u00ca\u00a1\u00c5\u0016\u00c0!\u00b0rh\u0091m(\u00c0%\u0006\u0081\u0095C\u008b\u0017\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\u0013\u00c0i\u0091\u00ed|?u'\u00c0\u00d2\"\u00db\u00f9~j\u0019\u00c0 \u0085\u00ebQ\u00b8\u001e\u0017\u00c0\u00f4\u00fd\u00d4x\u00e9f*\u00c0\u00b9\u001e\u0085\u00ebQ8\u0018\u00c0\u00c4\u00f5(\\\u008f\u00c2\u001e\u00c0\u008f\u00c2\u00f5(\\\u008f(\u00c0\u00dfO\u008d\u0097n\u0092\u0013\u00c0\u00d0\u00f7S\u00e3\u00a5\u001b\u001f\u00c0\u009e\u00ef\u00a7\u00c6Kw*\u00c0\u00dd$\u0006\u0081\u0095\u00c3\u0014\u00c0\u00c3\u00f5(\\\u008f\u0082 \u00c0\u00d5x\u00e9&1\b(\u00c0\u00c7K7\u0089A`\u0010\u00c0\u00f7(\\\u008f\u00c2u\u001a\u00c0\u0098n\u0012\u0083\u00c0J'\u00c0\u00b4\u00c8v\u00be\u009f\u009a\u0014\u00c0\u00f1\u00a7\u00c6K7\u0089\u00e5\u00bfj\u00bct\u0093\u0018\u0004\u001b\u00c0\u0092\u00ed|?5^\u000b\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u00f7\u00bf\u00c5 \u00b0rh\u0011\u0019\u00c0G\u00b6\u00f3\u00fd\u00d4x\b\u00c0\u0091\u00ed|?5^\u00e2?\u00bf\u009f\u001a/\u00dd$\u0018\u00c0:\u00b4\u00c8v\u00be\u009f\r\u00c0\u00bct\u0093\u0018\u0004V\u00ee?$\u00db\u00f9~j\u00bc\u0019\u00c0\u0014\u00aeG\u00e1z\u0094\u0012\u00c0\u0001\u0000\u0000\u0000\u0000\u0000\u00fc?\u0087\u0016\u00d9\u00ce\u00f7S\u0019\u00c0\u0094\u0018\u0004V\u000e-\u0006\u00c0\u00ef|?5^\u00ba\u00c9?\u00d7\u00a3p=\nW\u0012\u00c0\u009e\u00ef\u00a7\u00c6K7\u000e\u00c0V\u000e-\u00b2\u009d\u00ef\u00c7?\u00c1\u00ca\u00a1E\u00b6\u00f3\u0010\u00c0\u00f6(\\\u008f\u00c2\u00f5\u0005\u00c0\u00d2\"\u00db\u00f9~j\u00e8\u00bfZd;\u00dfO\r\u0012\u00c09\u00b4\u00c8v\u00be\u001f\u0011\u00c0\u001c/\u00dd$\u0006\u0081\u0006@\u00f4\u00fd\u00d4x\u00e9&\u001a\u00c0>\n\u00d7\u00a3p=\n\u00c0\"\u00b0rh\u0091\u00ed\u00f2?\u00ecQ\u00b8\u001e\u0085\u00eb\f\u00c0u\u0093\u0018\u0004V\u000e\u0012\u00c0\u00f4\u00fd\u00d4x\u00e9&\u00e9?\u00a0\u001a/\u00dd$\u0006\t\u00c0sh\u0091\u00ed|?\u0017\u00c0z\u00e9&1\b\u00ac\u00ac\u00bf\u00fe\u00d4x\u00e9&1\r\u00c05^\u00baI\f\u0002\u0019\u00c0\"\u00b0rh\u0091\u00ed\u0002@\u00ea&1\b\u00ac\u001c\t\u00c0\u00fb~j\u00bct\u0093\u000f\u00c0\u00a4p=\n\u00d7\u00a3\u0005@\u00f3\u00d2Mb\u0010X\f\u00c0\u0001\u0000\u0000\u0000\u0000\u0000\b\u00c0\u00fe\u00d4x\u00e9&1\u00fa?\u00b0rh\u0091\u00ed|\u0002\u00c0\u00c5 \u00b0rh\u0011\u001a\u00c0\u00e1z\u0014\u00aeG\u00e1\u00f6?[d;\u00dfO\u008d\u00ff\u00bf\u009a\u0099\u0099\u0099\u0099\u0019\u001e\u00c0~?5^\u00baI\t@/\u00dd$\u0006\u0081\u0095\u0001\u00c0\u0000\u0000\u0000\u0000\u0000\u0080\u0012\u00c0\u0081\u0095C\u008blg\u0010@\u0083\u00c0\u00ca\u00a1E\u00b6\u00fd\u00bf7\u0089A`\u00e5\u00d0\u0010\u00c0z\u00e9&1\b\u00ac\n@\u00a6\u009b\u00c4 \u00b0r\u00e4\u00bf\u00e2z\u0014\u00aeG\u00e1\u0019\u00c0B`\u00e5\u00d0\"\u00db\u0006@\u00c2\u00ca\u00a1E\u00b6\u00f3\u00e1\u00bf\u0084\u00c0\u00ca\u00a1E6\u001d\u00c0\u00ff\u00d4x\u00e9&1\u0006@\u00d8\u00a3p=\n\u00d7\u00fb\u00bf\u00f0\u00a7\u00c6K7\u0089\u0017\u00c0\u001b/\u00dd$\u0006\u0081\u00f9?^\u00baI\f\u0002+\u0019\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u00f6\u00bf\u009d\u00c4 \u00b0rh\u00e9?\u00b4\u00c8v\u00be\u009f\u009a\u0017\u00c0h\u0091\u00ed|?5\u00ee\u00bf\u007fj\u00bct\u0093\u0018\u0005@\u0092\u00ed|?5^\u001a\u00c0\t\u00ac\u001cZd;\u00df\u00bf`\u00e5\u00d0\"\u00db\u00f9\u000b@\u008e\u0097n\u0012\u0083@\u0018\u00c0#\u00db\u00f9~j\u00bc\u00ec\u00bf\u0085\u00ebQ\u00b8\u001e\u0085\b@V\u000e-\u00b2\u009d/ \u00c0q=\n\u00d7\u00a3p\u00e1\u00bf\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\u0002@\u00a2E\u00b6\u00f3\u00fdT\u0018\u00c0G\u00b6\u00f3\u00fd\u00d4x\u00ed?\u0004V\u000e-\u00b2\u009d\u00f7?[d;\u00dfO\u008d\u001a\u00c0{\u0014\u00aeG\u00e1z\u00f4?\u00dc\u00f9~j\u00bct\t@L7\u0089A`e\u0019\u00c0^\u00baI\f\u0002+\u00f9?^\u00baI\f\u0002+\u0011@\u00ac\u001cZd;\u009f \u00c0\u00c7K7\u0089A`\u00dd\u00bf-\u00b2\u009d\u00ef\u00a7\u00c6\u0000@)\\\u008f\u00c2\u00f5(\u0012\u00c0D\u008bl\u00e7\u00fb\u00a9\u00ed?\u009a\u0099\u0099\u0099\u0099\u0099\u00f5?\u00b4\u00c8v\u00be\u009f\u001a\u0011\u00c0\u0003+\u0087\u0016\u00d9\u00ce\u00c7?\u00e6\u00d0\"\u00db\u00f9~\u00f8?\u00ee|?5^:\u0010\u00c05^\u00baI\f\u0002\u0002@u\u0093\u0018\u0004V\u000e\u00ed?\\\u008f\u00c2\u00f5(\\\t\u00c0\u00be\u009f\u001a/\u00dd$\u0001@\u00aeG\u00e1z\u0014\u00ae\u00ef?\u00e9&1\b\u00ac\u009c\u0013\u00c0P\u008d\u0097n\u0012\u0083\u0005@th\u0091\u00ed|?\u0003@{\u0014\u00aeG\u00e1z\u000e\u00c0n\u00e7\u00fb\u00a9\u00f1\u00d2\u0006@\f\u0002+\u0087\u0016\u00d9\n@\u00e8\u00fb\u00a9\u00f1\u00d2M\r\u00c0=\n\u00d7\u00a3p=\u00e2?\u00aa\u00f1\u00d2Mb\u0010\r@\u0086\u00ebQ\u00b8\u001e\u0085\u000f\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u00dc\u00bf\b\u00ac\u001cZd\u00bb\u0010@\u009a\u0099\u0099\u0099\u0099\u0099\u000f\u00c00\u00dd$\u0006\u0081\u0095\u00f3?L7\u0089A`\u00e5\b@\u0098n\u0012\u0083\u00c0\u00ca\u0004\u00c0#\u00db\u00f9~j\u00bc\u00e0?\u00ee|?5^\u00ba\u0001@\u00f8S\u00e3\u00a5\u009b\u0004\"\u00c0\u00a8\u00c6K7\u0089A\u00ec\u00bf>\n\u00d7\u00a3p=\u00f4?\u0004V\u000e-\u00b2]!\u00c0V\u000e-\u00b2\u009d\u00ef\u00ef\u00bfv\u0093\u0018\u0004V\u000e\u0005@\u00baI\f\u0002+\u00c7$\u00c0\u00b7\u00f3\u00fd\u00d4x\u00e9\u00f4\u00bf433333\n@\u0002+\u0087\u0016\u00d9\u008e%\u00c0{\u0014\u00aeG\u00e1z\u00e0\u00bf\u00cc\u00a1E\u00b6\u00f3\u00fd\u000b@\u00ac\u001cZd;\u00df$\u00c0h\u0091\u00ed|?5\u0004\u00c0H\u00e1z\u0014\u00aeG\u00f7?\u00cb\u00a1E\u00b6\u00f3\u00bd&\u00c0u\u0093\u0018\u0004V\u000e\u00f7\u00bf\u0013\u0083\u00c0\u00ca\u00a1E\u00fe?;\u00dfO\u008d\u0097\u00ae(\u00c0x\u00be\u009f\u001a/\u00dd\u00fa\u00bf\u00e7\u00fb\u00a9\u00f1\u00d2M\u00e6?\u00ef|?5^\u00fa%\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u00c0\u00aa\u00f1\u00d2Mb\u0090\u0012@\u009c\u00c4 \u00b0r\u00e8%\u00c0\u00baI\f\u0002+\u0087\u0003\u00c0\u0090\u00c2\u00f5(\\\u008f\u00ea?\u00ecQ\u00b8\u001e\u0085+'\u00c0\u001c/\u00dd$\u0006\u0081\u00b5\u00bfj\u00bct\u0093\u0018\u0004\u00f6?sh\u0091\u00ed|\u007f(\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u00e3?j\u00bct\u0093\u0018\u0004\u00e6?\u00d1\"\u00db\u00f9~j%\u00c0J\f\u0002+\u0087\u0016\u00e1?\u00c2\u00ca\u00a1E\u00b6\u00f3\u00e1\u00bfNb\u0010X9t(\u00c0X9\u00b4\u00c8v\u00be\u00d7\u00bf#\u00db\u00f9~j\u00bc\u00e0\u00bf[d;\u00dfOM*\u00c0\u00bct\u0093\u0018\u0004V\u00ee\u00bf\u00bct\u0093\u0018\u0004V\u00f2\u00bf\u00bct\u0093\u0018\u0004\u00d6&\u00c0\u00edQ\u00b8\u001e\u0085\u00eb\u00e9\u00bf\u00d0\u00f7S\u00e3\u00a5\u009b\u00f2\u00bf\u008d\u0097n\u0012\u0083\u0000)\u00c0\u00f0\u00a7\u00c6K7\u0089\u00ed?\u0098n\u0012\u0083\u00c0\u00ca\u00e1\u00bf\u009a\u0099\u0099\u0099\u0099\u00d9(\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u00fb?2\b\u00ac\u001cZd\t\u00c0\u00c2\u00ca\u00a1E\u00b6\u00b3*\u00c0z\u00e9&1\b\u00ac\u00bc?\u0014\u00aeG\u00e1z\u0094\u0010\u00c0\u009f\u00ef\u00a7\u00c6K7+\u00c0*\\\u008f\u00c2\u00f5(\u00cc?\u00e9&1\b\u00ac\u001c\u0006\u00c0th\u0091\u00ed|\u00bf*\u00c0B`\u00e5\u00d0\"\u00db\u00e9\u00bf\u00da\u00ce\u00f7S\u00e3\u00a5\u0007\u00c0\u00d7\u00a3p=\n\u0017*\u00c0F\u00b6\u00f3\u00fd\u00d4x\u0002@sh\u0091\u00ed|?\u0002\u00c0$\u00db\u00f9~j\u00fc)\u00c0\u00a7\u009b\u00c4 \u00b0r\b@~?5^\u00baI\u000e\u00c0\u00dc\u00f9~j\u00bc4+\u00c0\u00bct\u0093\u0018\u0004V\u0003@\u00baI\f\u0002+\u0087\u0003\u00c0\u0006\u0081\u0095C\u008b\u00ec)\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u00f2?\u008f\u00c2\u00f5(\\\u008f\b@\u00fc\u00a9\u00f1\u00d2M\u00e2#\u00c0\u00b3\u009d\u00ef\u00a7\u00c6K\r\u00c0\u00e1z\u0014\u00aeG\u00e1\u0000@7\u0089A`\u00e5P#\u00c0\u00c8K7\u0089A`\u000e\u00c0\u009b\u0099\u0099\u0099\u0099\u0099\u000e@b\u0010X9\u00b4\u0088#\u00c0\u00d2\"\u00db\u00f9~j\u0013\u00c0\u00ee|?5^:\u0010@th\u0091\u00ed|\u007f%\u00c0\u00f0\u00a7\u00c6K7\t\u0015\u00c0\u0096C\u008bl\u00e7\u00fb\u0014@\u0094\u0018\u0004V\u000em\"\u00c0J\f\u0002+\u0087\u0096\u0012\u00c0\u009e\u00ef\u00a7\u00c6K7\b@\u00f8S\u00e3\u00a5\u009b\u0004\"\u00c0\u009f\u00ef\u00a7\u00c6K\u00b7\u0017\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u0000@%\u0006\u0081\u0095C\u000b#\u00c0<\u00dfO\u008d\u0097n\u0018\u00c0Zd;\u00dfO\u008d\u0006@\u0096C\u008bl\u00e7\u00fb\u001f\u00c0\u008e\u0097n\u0012\u0083@\u0016\u00c0 \u0085\u00ebQ\u00b8\u001e\u0019@\u00a6\u009b\u00c4 \u00b0r#\u00c0\u00baI\f\u0002+\u0087\u0014\u00c0\u00b5\u00c8v\u00be\u009f\u001a\u000e@\u001dZd;\u00df\u008f!\u00c0B`\u00e5\u00d0\"\u00db\u001c\u00c0X9\u00b4\u00c8v>\u0011@\f\u0002+\u0087\u0016Y#\u00c0\u00d5x\u00e9&1\b\u001e\u00c0y\u00e9&1\b,\u0012@d;\u00dfO\u008d\u0017 \u00c06^\u00baI\f\u0002\u001c\u00c0\u00a3E\u00b6\u00f3\u00fd\u00d4\u0006@\u00cb\u00a1E\u00b6\u00f3\u00bd \u00c0\u00be\u009f\u001a/\u00dd\u00a4 \u00c0\u000e-\u00b2\u009d\u00ef\u00a7\n@W\u000e-\u00b2\u009d\u00ef\u001d\u00c0\u001a\u0004V\u000e-2\"\u00c0\u00bct\u0093\u0018\u0004V\u00fa?\u008e\u0097n\u0012\u0083@!\u00c0\u00e9&1\b\u00ac\u00dc \u00c0(1\b\u00ac\u001cZ\u0015@\u00cd\u00cc\u00cc\u00cc\u00cc\f \u00c0\u008f\u00c2\u00f5(\\\u000f\u0010\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u0011@C`\u00e5\u00d0\"[\u001e\u00c0B`\u00e5\u00d0\"\u00db\u000e\u00c0433333\u001a@6^\u00baI\f\u0082\u001d\u00c0 \u0085\u00ebQ\u00b8\u001e\r\u00c0H\u00e1z\u0014\u00aeG\u001c@\u00ab\u00f1\u00d2Mb\u0090\u001c\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2M\u0012\u00c0sh\u0091\u00ed|\u00bf\u001d@\u0081\u0095C\u008blg \u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M\u0006\u00c0y\u00e9&1\b\u00ac\u0018@h\u0091\u00ed|?5\u0018\u00c0\u0097C\u008bl\u00e7\u00fb\u0006\u00c0\u0084\u00c0\u00ca\u00a1E6\u001c@\u00a8\u00c6K7\u0089A\u0016\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u0003\u00c0\u00e2z\u0014\u00aeG\u00e1\u0015@9\u00b4\u00c8v\u00be\u001f\u0019\u00c0/\u00dd$\u0006\u0081\u0095\u0000\u00c0T\u00e3\u00a5\u009b\u00c4`!@\u0098n\u0012\u0083\u00c0\n \u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u0007\u00c0L7\u0089A`\u00e5\u0015@\u00b8\u001e\u0085\u00ebQ8\u0014\u00c0$\u00db\u00f9~j\u00bc\u000e\u00c0\u0086\u00ebQ\u00b8\u001e\u0005\u0014@Zd;\u00dfO\r\u0011\u00c0\u00ab\u00f1\u00d2Mb\u0010\n\u00c0b\u0010X9\u00b4\u00c8\u0012@\u00d7\u00a3p=\nW\u0016\u00c0\u00fa~j\u00bct\u0093\u0011\u00c0e;\u00dfO\u008d\u0097\u0019@\u0081\u0095C\u008bl\u00e7\u0011\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u0013\u00c0\u0093\u0018\u0004V\u000e\u00ad\u0017@\u00ecQ\u00b8\u001e\u0085\u00eb\u0011\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u0018\u00c0\u008f\u00c2\u00f5(\\\u000f\u0014@\u00b4\u00c8v\u00be\u009f\u009a\u0013\u00c0&\u0006\u0081\u0095C\u008b\u0019\u00c0\u00d1\"\u00db\u00f9~\u00ea\u0019@\u00cb\u00a1E\u00b6\u00f3}\u0010\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u00d3\u001b\u00c0K\f\u0002+\u0087\u0016\u001e@y\u00e9&1\b,\u0010\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\u0012\u00c0\u0082\u0095C\u008blg\u001b@q=\n\u00d7\u00a30\"\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u00fe\u00bf\u0082\u0095C\u008blg\u0017@5^\u00baI\f\u0002\"\u00c0\u0018\u00d9\u00ce\u00f7S\u00e3\u00fd\u00bf\u00d8\u00a3p=\nW\u001e@\u00b2\u009d\u00ef\u00a7\u00c6\u000b$\u00c0H\u00e1z\u0014\u00aeG\u00f1\u00bf-\u00b2\u009d\u00ef\u00a7\u0006!@{\u0014\u00aeG\u00e1\u00fa\"\u00c0\u0089A`\u00e5\u00d0\"\u00eb\u00bf\u0013\u0083\u00c0\u00ca\u00a1E\u001f@\u0010X9\u00b4\u00c8\u00f6&\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\u00f9\u00bf!\u00b0rh\u0091\u00ed\u001b@`\u00e5\u00d0\"\u00db\u00f9#\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u00d2?\u001f\u0085\u00ebQ\u00b8\u001e\u001b@{\u0014\u00aeG\u00e1\u00fa!\u00c0\u00f2\u00d2Mb\u0010X\u00e5?\u00bf\u009f\u001a/\u00dd$\u0018@\u00c5 \u00b0rh\u0011%\u00c0\u00fe\u00d4x\u00e9&1\u00d8?\u00e6\u00d0\"\u00db\u00f9\u00fe\u001e@\u00e2z\u0014\u00aeG\u00a1$\u00c0\u00d8\u00a3p=\n\u00d7\u00ef?R\u00b8\u001e\u0085\u00ebQ @\u00f3\u00d2Mb\u0010\u00d8(\u00c0\u00ad\u001cZd;\u00df\u00eb\u00bf\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u001e@\u00c3\u00f5(\\\u008fB'\u00c0G\u00b6\u00f3\u00fd\u00d4x\u0007\u00c0\u000f-\u00b2\u009d\u00ef\u00a7\u001d@\u009d\u00c4 \u00b0r\u00a8%\u00c0\u00ad\u001cZd;\u00df\u000b\u00c0\u00be\u009f\u001a/\u00dd$\u001f@;\u00dfO\u008d\u0097\u00ee)\u00c0n\u00e7\u00fb\u00a9\u00f1\u00d2\f\u00c0d;\u00dfO\u008d\u00d7 @\u0015\u00aeG\u00e1zT+\u00c0ffffff\b\u00c0\u0014\u00aeG\u00e1z\u0094 @\u0094\u0018\u0004V\u000e\u00ad)\u00c0\u00cf\u00f7S\u00e3\u00a5\u001b\u0014\u00c0\u008aA`\u00e5\u00d0\u00a2\u0019@\u0000\u0000\u0000\u0000\u0000@+\u00c0\u00baI\f\u0002+\u0087\u000e\u00c0\u009d\u00c4 \u00b0rh\u0019@q=\n\u00d7\u00a3\u00f0,\u00c0\u00b0rh\u0091\u00ed\u00fc\u0011\u00c07\u0089A`\u00e5\u0090!@\u00f2\u00d2Mb\u0010\u0098+\u00c0^\u00baI\f\u0002\u00ab\u0016\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0016@\u00a7\u009b\u00c4 \u00b02,\u00c0\u0007\u0081\u0095C\u008bl\u0004\u00c0\u00ecQ\u00b8\u001e\u0085k\u0018@y\u00e9&1\b,+\u00c0b\u0010X9\u00b4\u00c8\u00fa\u00bfp\u0012\u0083\u00c0\u00ca\u00a1\u0017@e;\u00dfO\u008dW.\u00c0^\u00baI\f\u0002+\u0004\u00c0\u0085\u00ebQ\u00b8\u001e\u0085\u0012@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc+\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u0004\u00c0\u00d1\"\u00db\u00f9~j\u0016@\u00e8\u00fb\u00a9\u00f1\u00d2M)\u00c0H\u00e1z\u0014\u00ae\u00c7\u0011\u00c0\u0091\u00ed|?5\u00de\u0015@\u0080j\u00bct\u0093\u0018(\u00c0\u000f-\u00b2\u009d\u00ef\u00a7\r\u00c0\u0004V\u000e-\u00b2] @\u0085\u00ebQ\u00b8\u001eE'\u00c0+\u0087\u0016\u00d9\u00cew\u0016\u00c0\u00c6 \u00b0rh\u0091\u001e@\u009a\u0099\u0099\u0099\u0099\u00d9%\u00c0\u0004V\u000e-\u00b2\u009d\u0014\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\r!@\u00d9\u00ce\u00f7S\u00e3\u00e5&\u00c0\u000b\u00d7\u00a3p=\n\u001c\u00c09\u00b4\u00c8v\u00be\u00df\"@\u0092\u00ed|?5\u00de'\u00c0<\u00dfO\u008d\u0097n\u001d\u00c0\u00db\u00f9~j\u00bc\u00b4!@\u00d7\u00a3p=\n\u00d7$\u00c0\u00de$\u0006\u0081\u0095\u00c3\u001c\u00c08\u0089A`\u00e5\u00d0\u001d@\u008cl\u00e7\u00fb\u00a9\u00b1'\u00c0\u00c5 \u00b0rh\u0011 \u00c0\u0085\u00ebQ\u00b8\u001e\u0085\u001e@-\u00b2\u009d\u00ef\u00a7F'\u00c0Nb\u0010X9t\"\u00c0\u0014\u00aeG\u00e1z\u0014\u0019@B`\u00e5\u00d0\"\u009b(\u00c0\u001a\u0004V\u000e-2\u001e\u00c0\u00aeG\u00e1z\u0014\u00ae\u0018@\u00b8\u001e\u0085\u00ebQ\u00b8(\u00c0^\u00baI\f\u0002+\u001a\u00c0\u00e2z\u0014\u00aeG\u00e1\u0014@\u00cav\u00be\u009f\u001a\u00af)\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd \u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0014@\u00a8\u00c6K7\u0089\u0081(\u00c0\u00a4p=\n\u00d7\u00a3\"\u00c0&\u0006\u0081\u0095C\u008b\u000e@\u00db\u00f9~j\u00bc4)\u00c0\u009c\u00c4 \u00b0r\u00e8\u001e\u00c0F\u00b6\u00f3\u00fd\u00d4\u00f8\u0015@)\\\u008f\u00c2\u00f5\u00a8,\u00c0o\u0012\u0083\u00c0\u00caa!\u00c0\u00f6(\\\u008f\u00c2u\u0013@\u00be\u009f\u001a/\u00ddd-\u00c0\u0086\u00ebQ\u00b8\u001e\u0005#\u00c0{\u0014\u00aeG\u00e1z\u0015@\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd-\u00c0\u00d0\u00f7S\u00e3\u00a5\u001b\u001f\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2\u0019@\u00c3\u00f5(\\\u008f\u0002-\u00c0\u00dd$\u0006\u0081\u0095C\"\u00c0?5^\u00baI\f\r@\u00a4p=\n\u00d7#)\u00c0\t\u00ac\u001cZd;\u001a\u00c0%\u0006\u0081\u0095C\u008b\u0006@G\u00b6\u00f3\u00fd\u00d4\u00b8(\u00c0\u00e3\u00a5\u009b\u00c4 0!\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\b@\u00ce\u00cc\u00cc\u00cc\u00ccL)\u00c0\u0014\u00aeG\u00e1z\u0014#\u00c0L7\u0089A`\u00e5\u00f6?\u0085\u00ebQ\u00b8\u001eE(\u00c0d;\u00dfO\u008d\u0097 \u00c0!\u00b0rh\u0091\u00ed\u00f6?W\u000e-\u00b2\u009do&\u00c0c\u0010X9\u00b4\u00c8\u001e\u00c0\u00d3Mb\u0010X9\u00ec?-\u00b2\u009d\u00ef\u00a7\u0086*\u00c0\u00e6\u00d0\"\u00db\u00f9~\u001d\u00c0\u0014\u00aeG\u00e1z\u0014\u00e2?!\u00b0rh\u0091m(\u00c0m\u00e7\u00fb\u00a9\u00f1\u0012#\u00c0\u00d6x\u00e9&1\b\u00ec?\u0014\u00aeG\u00e1z\u00d4&\u00c0L7\u0089A`e$\u00c0#\u00db\u00f9~j\u00bc\u00dc\u00bf\u00f8S\u00e3\u00a5\u009b\u0004(\u00c0B`\u00e5\u00d0\"[\"\u00c0\\\u008f\u00c2\u00f5(\\\u00f3?\u00d8\u00a3p=\n\u00d7,\u00c0\u00f9S\u00e3\u00a5\u009b\u00c4\u001d\u00c01\b\u00ac\u001cZd\u00e3?\u007fj\u00bct\u0093\u0018+\u00c0\u00e2z\u0014\u00aeG\u00a1$\u00c0>\n\u00d7\u00a3p=\u00fa?\t\u00ac\u001cZd{+\u00c0|\u0014\u00aeG\u00e1:%\u00c0\u00bbI\f\u0002+\u0087\u00c6?\u0099n\u0012\u0083\u00c0\u00ca,\u00c0\u008f\u00c2\u00f5(\\\u008f#\u00c0\u008f\u00c2\u00f5(\\\u008f\u00c2\u00bf\u0017\u00d9\u00ce\u00f7S\u00a3*\u00c0L7\u0089A`%'\u00c0\u00f6(\\\u008f\u00c2\u00f5\u00f2\u00bf\u009a\u0099\u0099\u0099\u0099\u0019*\u00c0R\u00b8\u001e\u0085\u00eb\u00d1&\u00c0\u008e\u0097n\u0012\u0083\u00c0\u00da?\u0007\u0081\u0095C\u008b,)\u00c0\u00c6 \u00b0rhQ(\u00c0\u00d6x\u00e9&1\b\u00cc\u00bf\u0085\u00ebQ\u00b8\u001eE-\u00c0G\u00b6\u00f3\u00fd\u00d4\u00b8(\u00c0\u0010X9\u00b4\u00c8v\u00f0\u00bfh\u0091\u00ed|?\u00f5,\u00c0\u00e1z\u0014\u00aeG!*\u00c0sh\u0091\u00ed|?\u00e1\u00bf\u0015\u00aeG\u00e1z\u00d4.\u00c0\u00d7\u00a3p=\nW'\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u00f1?.\u00b2\u009d\u00ef\u00a7\u00c6-\u00c0\u008f\u00c2\u00f5(\\\u00cf)\u00c0y\u00e9&1\b\u00ac\u00f8?`\u00e5\u00d0\"\u00db9,\u00c0\u0085\u00ebQ\u00b8\u001e\u00c5*\u00c0\u00b2\u009d\u00ef\u00a7\u00c6K\u00f1?\u00b5\u00c8v\u00be\u009fZ/\u00c07\u0089A`\u00e5\u0010+\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\u00fb?\u00b4\u00c8v\u00be\u009fZ.\u00c0\u00bdt\u0093\u0018\u0004V(\u00c0\u00ecQ\u00b8\u001e\u0085\u00eb\u00a1\u00bfy\u00e9&1\b\u00ac)\u00c0\u00c7K7\u0089A\u00e0\u0019\u00c0r=\n\u00d7\u00a3p\u00bd\u00bf\u00b6\u00f3\u00fd\u00d4x\u00a9'\u00c0Zd;\u00dfO\r\u001a\u00c0y\u00e9&1\b\u00ac\u00e8\u00bf]\u008f\u00c2\u00f5(\\+\u00c0^\u00baI\f\u0002+\u0016\u00c09\u00b4\u00c8v\u00be\u009f\u009a\u00bfD\u008bl\u00e7\u00fbi,\u00c0\u00bct\u0093\u0018\u0004\u00d6\u0013\u00c0d;\u00dfO\u008d\u0097\u00fc\u00bf\u00c3\u00f5(\\\u008fB-\u00c0i\u0091\u00ed|?\u00b5\u0018\u00c0|\u0014\u00aeG\u00e1z\u00f8\u00bf\u000e-\u00b2\u009d\u00ef\u00a7)\u00c0\u00be\u009f\u001a/\u00dd$\u0012\u00c0\u0011X9\u00b4\u00c8v\u00ee\u00bf\u00cf\u00f7S\u00e3\u00a5\u00db'\u00c0sh\u0091\u00ed|?\u0011\u00c0\u00dfO\u008d\u0097n\u0012\u0003\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2(\u00c0\u0002+\u0087\u0016\u00d9N\u0014\u00c0=\n\u00d7\u00a3p=\u0006\u00c0\u00bdt\u0093\u0018\u0004V,\u00c0r=\n\u00d7\u00a3\u00f0\u001a\u00c0\u00aa\u00f1\u00d2Mb\u0010\u0001\u00c0\u0005V\u000e-\u00b2\u001d+\u00c0b\u0010X9\u00b4\u00c8\n\u00c0B`\u00e5\u00d0\"\u00db\u0006\u00c0Zd;\u00dfO\u00cd)\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u0004\u00c0\t\u00ac\u001cZd;\u00ff\u00bf\u00f3\u00d2Mb\u0010\u0098-\u00c0\u00d7\u00a3p=\n\u00d7\t\u00c0!\u00b0rh\u0091\u00ed\u00f6\u00bf$\u00db\u00f9~j\u00bc/\u00c0\u00ac\u001cZd;\u00df\u0017\u00c0\u00b5\u00c8v\u00be\u009f\u001a\u00df\u00bf\u00d6x\u00e9&1\b0\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\u0016\u00c0\u0014\u00aeG\u00e1z\u0014\u0001\u00c0\u00db\u00f9~j\u00bc\u00141\u00c0R\u00b8\u001e\u0085\u00eb\u00d1\u0018\u00c0\u00fa~j\u00bct\u0093\u0000\u00c0\u00e1z\u0014\u00aeGA1\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u001d\u00c0B`\u00e5\u00d0\"\u00db\f\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\f1\u00c0;\u00dfO\u008d\u0097n\u0017\u00c0\u00a8\u00c6K7\u0089A\u00f6\u00bf\u00d4Mb\u0010XY2\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0016\u00c0\u00a6\u009b\u00c4 \u00b0r\u00fa\u00bf\u00d4Mb\u0010XY2\u00c0%\u0006\u0081\u0095C\u008b\u0012\u00c0\f\u0002+\u0087\u0016Y\u0011\u00c0\u00baI\f\u0002+\u00c71\u00c0433333\u001a\u00c0\u0093\u0018\u0004V\u000e-\u00fe\u00bf\u00f0\u00a7\u00c6K7\u00a93\u00c0\u00de$\u0006\u0081\u0095C\u0019\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u00fc\u00bf\u0002+\u0087\u0016\u00d9\u008e3\u00c0\u0015\u00aeG\u00e1z\u0094\u001d\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5\u0006\u00c0\u00c7K7\u0089A\u00004\u00c0T\u00e3\u00a5\u009b\u00c4\u00a0\u0017\u00c0\u0081\u0095C\u008bl\u00e7\u00f1\u00bf\u00bf\u009f\u001a/\u00ddd4\u00c0\u00e4\u00a5\u009b\u00c4 0\u0018\u00c0*\\\u008f\u00c2\u00f5(\u00ac\u00bf\u00dd$\u0006\u0081\u0095C2\u00c0\u0082\u0095C\u008blg\u0017\u00c05^\u00baI\f\u0002\u00d3?\u00c1\u00ca\u00a1E\u00b6\u00132\u00c0\u0006\u0081\u0095C\u008b\u00ec\u0013\u00c01\b\u00ac\u001cZd\u0010\u00c0\u008bl\u00e7\u00fb\u00a9Q0\u00c0\u00d8\u00a3p=\nW\u0013\u00c0\u00d1\"\u00db\u00f9~j\u000b\u00c0\u00c9v\u00be\u009f\u001ao/\u00c0\u00c5 \u00b0rh\u0091\u0011\u00c0\u0081\u0095C\u008bl\u00e7\u0015\u00c0!\u00b0rh\u0091-0\u00c0\u00ecQ\u00b8\u001e\u0085k\u0011\u00c0\u009a\u0099\u0099\u0099\u0099\u0019\u0017\u00c0\u00e9&1\b\u00ac\u001c1\u00c0\u00f6(\\\u008f\u00c2\u00f5\u000e\u00c0|\u0014\u00aeG\u00e1\u00fa\u0019\u00c0z\u00e9&1\b\u00ac/\u00c0\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0015\u00c0J\f\u0002+\u0087\u0016\u0016\u00c05^\u00baI\f\u0002.\u00c0&\u0006\u0081\u0095C\u008b\n\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u0012\u00c0\u001dZd;\u00df\u000f.\u00c0B`\u00e5\u00d0\"\u00db\u0004\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2\u0014\u00c0c\u0010X9\u00b4H,\u00c02\b\u00ac\u001cZd\u000f\u00c0\u00f8S\u00e3\u00a5\u009bD\u0019\u00c0\u0000\u0000\u0000\u0000\u0000\u00c0-\u00c0\u0089A`\u00e5\u00d0\u00a2\u0018\u00c0\u00c4\u00f5(\\\u008fB\u001b\u00c0\u00f4\u00fd\u00d4x\u00e9\u00a6-\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u0004\u00c0\u00c2\u00ca\u00a1E\u00b6s\u001e\u00c0\u00cc\u00a1E\u00b6\u00f3=-\u00c0$\u00db\u00f9~j\u00bc\n\u00c0\u00ee|?5^\u00ba\u001c\u00c0{\u0014\u00aeG\u00e1z/\u00c0333333\u0001\u00c0Ob\u0010X9\u00b4\u001b\u00c0\u00f7(\\\u008f\u00c2u+\u00c0j\u00bct\u0093\u0018\u0004\u00fa\u00bf\u0087\u0016\u00d9\u00ce\u00f7S\u0019\u00c0\u009e\u00ef\u00a7\u00c6K\u00f7+\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u00e7\u00bf\u00a9\u00c6K7\u0089A\u001a\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u008d)\u00c0^\u00baI\f\u0002+\u0000\u00c07\u0089A`\u00e5\u00d0 \u00c0\u0005V\u000e-\u00b2\u001d+\u00c0\u00ea&1\b\u00ac\u001c\u00f4\u00bf\u0091\u00ed|?5\u001e\"\u00c0\u00b1rh\u0091\u00ed<+\u00c06^\u00baI\f\u0002\u0001\u00c0w\u00be\u009f\u001a/]!\u00c0K\f\u0002+\u0087\u00d6,\u00c0\u00a9\u00c6K7\u0089A\u00e4\u00bf^\u00baI\f\u0002+!\u00c07\u0089A`\u00e5\u0090(\u00c0\u009e\u00ef\u00a7\u00c6K7\u00e1\u00bf\u00a8\u00c6K7\u0089\u0001 \u00c0\u00cav\u00be\u009f\u001a\u00af(\u00c0\u00ee|?5^\u00ba\u00d1?\u00f0\u00a7\u00c6K7\u00c9 \u00c0\u009e\u00ef\u00a7\u00c6K\u00f7&\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u00f1\u00bf\u008d\u0097n\u0012\u0083\u0000#\u00c0J\f\u0002+\u0087V(\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u00c0\u00bf\u00f2\u00d2Mb\u0010X\u001e\u00c0\u00be\u009f\u001a/\u00dd\u00a40\u00c0v\u0093\u0018\u0004V\u008e\u0016\u00c0\u009c\u00c4 \u00b0rh!\u00c0\\\u008f\u00c2\u00f5(|0\u00c0\u00b0rh\u0091\u00ed|\u001a\u00c0\u001dZd;\u00df\u008f \u00c0L7\u0089A`\u00a50\u00c0\u00a7\u009b\u00c4 \u00b0r\u001e\u00c0\u0089A`\u00e5\u00d0\u00a2\"\u00c0\u00f2\u00d2Mb\u0010\u0018.\u00c0\u0018\u00d9\u00ce\u00f7S\u00e3\u001a\u00c0\u0014\u00aeG\u00e1z\u0094#\u00c0\u0006\u0081\u0095C\u008b\u008c1\u00c0\u00f1\u00a7\u00c6K7\t\u0019\u00c0\u009c\u00c4 \u00b0r\u00a8$\u00c0L7\u0089A`\u00e51\u00c0/\u00dd$\u0006\u0081\u0095\u001c\u00c0sh\u0091\u00ed|\u00ff$\u00c0sh\u0091\u00ed|\u001f1\u00c0\u00b8\u001e\u0085\u00ebQ8\u0016\u00c0\u0019\u0004V\u000e-r\"\u00c0\u0015\u00aeG\u00e1z\u0094,\u00c0\n\u00d7\u00a3p=\n\u0017\u00c0J\f\u0002+\u0087\u00d6!\u00c0H\u00e1z\u0014\u00ae\u00a72\u00c0Q\u008d\u0097n\u0012\u0083\u0016\u00c0Nb\u0010X9\u00f4\"\u00c0w\u00be\u009f\u001a/=3\u00c0u\u0093\u0018\u0004V\u008e\u0013\u00c0\f\u0002+\u0087\u0016\u00d9 \u00c0`\u00e5\u00d0\"\u00dbY3\u00c0#\u00db\u00f9~j<\u0019\u00c0F\u00b6\u00f3\u00fd\u00d4x\u001f\u00c0\u00d3Mb\u0010X\u00d91\u00c0\u007fj\u00bct\u0093\u0098\u0013\u00c0\u00cf\u00f7S\u00e3\u00a5[ \u00c0\u00f2\u00d2Mb\u0010\u00981\u00c0\u00f4\u00fd\u00d4x\u00e9&\u000f\u00c0F\u00b6\u00f3\u00fd\u00d4\u00f8\u001b\u00c0$\u00db\u00f9~j|2\u00c0L7\u0089A`e\u0013\u00c0\u00c9v\u00be\u009f\u001a\u00af#\u00c0S\u00b8\u001e\u0085\u00ebQ-\u00c00\u00dd$\u0006\u0081\u0095\u001f\u00c0\u00fe\u00d4x\u00e9&\u00f1#\u00c0\u0015\u00aeG\u00e1z\u00d4.\u00c0\u00e2z\u0014\u00aeG!!\u00c0\u00da\u00ce\u00f7S\u00e3%%\u00c0\u0091\u00ed|?5\u00de*\u00c0\u0089A`\u00e5\u00d0\" \u00c0;\u00dfO\u008d\u0097n&\u00c0b\u0010X9\u00b4\u0088*\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u001c\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\f'\u00c0\u009b\u0099\u0099\u0099\u0099\u0019+\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\"\u00c0\u00dfO\u008d\u0097nR#\u00c0\u008bl\u00e7\u00fb\u00a9q(\u00c0\u00b4\u00c8v\u00be\u009fZ \u00c0\u0000\u0000\u0000\u0000\u0000\u0080\"\u00c0P\u008d\u0097n\u0012C(\u00c0\u00d4Mb\u0010X\u00b9\u001c\u00c0T\u00e3\u00a5\u009b\u00c4\u00e0!\u00c0|\u0014\u00aeG\u00e1z(\u00c0X9\u00b4\u00c8v\u00fe!\u00c0\u0088\u0016\u00d9\u00ce\u00f7S&\u00c0\u00e9&1\b\u00ac\u001c,\u00c0\u001eZd;\u00df\u00cf$\u00c0\u008e\u0097n\u0012\u0083\u0000%\u00c0u\u0093\u0018\u0004V\u00ce%\u00c0\u00a4p=\n\u00d7\u00e3 \u00c0\u00fc\u00a9\u00f1\u00d2Mb&\u00c0gfffff%\u00c0u\u0093\u0018\u0004V\u008e\u001e\u00c0~?5^\u00ba\t&\u00c0\u00b8\u001e\u0085\u00ebQ\u00f8%\u00c0%\u0006\u0081\u0095C\u00cb\"\u00c0|\u0014\u00aeG\u00e1\u00ba\"\u00c0\u00f2\u00d2Mb\u0010\u00d8\"\u00c0\u0014\u00aeG\u00e1z\u00d4 \u00c0\u00fe\u00d4x\u00e9&q\"\u00c0\u00aeG\u00e1z\u0014n\"\u00c0\u008cl\u00e7\u00fb\u00a9q\u001a\u00c0\u00f0\u00a7\u00c6K7I#\u00c0\u0086\u00ebQ\u00b8\u001eE$\u00c0B`\u00e5\u00d0\"\u00db\u0018\u00c0J\f\u0002+\u0087V \u00c0\u00a6\u009b\u00c4 \u00b02\"\u00c0\u00f2\u00d2Mb\u0010X\u0019\u00c0\u00db\u00f9~j\u00bct#\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\u008d \u00c0\u00b6\u00f3\u00fd\u00d4xi\u0019\u00c0Y9\u00b4\u00c8v~)\u00c0\u000f-\u00b2\u009d\u00ef'*\u00c0y\u00e9&1\bl\"\u00c0\u001c/\u00dd$\u0006\u0001*\u00c0\u00de$\u0006\u0081\u0095C)\u00c0\u00c9v\u00be\u009f\u001a\u00af \u00c0\u00f2\u00d2Mb\u0010\u00d8+\u00c0\u008e\u0097n\u0012\u0083\u00c0*\u00c0\b\u00ac\u001cZd\u00fb#\u00c0z\u00e9&1\bl+\u00c0c\u0010X9\u00b4\u0088,\u00c0\u00b6\u00f3\u00fd\u00d4x)%\u00c0%\u0006\u0081\u0095C\u008b-\u00c0\u00a0\u001a/\u00dd$F+\u00c0#\u00db\u00f9~j\u00bc\"\u00c0\u00cav\u00be\u009f\u001a\u00af,\u00c0\u00aeG\u00e1z\u0014\u00ae(\u00c0Zd;\u00dfO\r&\u00c0\u0019\u0004V\u000e-r+\u00c0Zd;\u00dfO\u008d&\u00c0T\u00e3\u00a5\u009b\u00c4`&\u00c0y\u00e9&1\b\u00ec.\u00c0\u00a4p=\n\u00d7#)\u00c0\u00ecQ\u00b8\u001e\u0085k'\u00c0\u00f0\u00a7\u00c6K7\u00c9/\u00c0*\\\u008f\u00c2\u00f5\u00e8*\u00c0^\u00baI\f\u0002\u00eb&\u00c0\u00dfO\u008d\u0097n\u00d2/\u00c0ffffff'\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8)\u00c0\u00c9v\u00be\u009f\u001a/.\u00c0\u00f6(\\\u008f\u00c2\u00f5&\u00c0S\u00b8\u001e\u0085\u00eb\u0011+\u00c0\u0084\u00c0\u00ca\u00a1EV0\u00c0\u0002+\u0087\u0016\u00d9\u008e$\u00c0}?5^\u00ba\u00c9(\u00c0\b\u00ac\u001cZd\u001b1\u00c0\u00bbI\f\u0002+\u00c7(\u00c0`\u00e5\u00d0\"\u00db9+\u00c0\f\u0002+\u0087\u0016\u00f91\u00c0\u001c/\u00dd$\u0006\u0001)\u00c0\u00aeG\u00e1z\u0014\u00ee)\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a50\u00c033333\u00b3*\u00c0\u00db\u00f9~j\u00bc\u00b4+\u00c0/\u00dd$\u0006\u0081U0\u00c0\u00a0\u001a/\u00dd$\u00c6\"\u00c0\u0086\u00ebQ\u00b8\u001e\u0085*\u00c0fffff\u00a61\u00c0\u007fj\u00bct\u0093\u0098'\u00c0\u001f\u0085\u00ebQ\u00b8\u00de-\u00c0\u00b8\u001e\u0085\u00ebQ\u00d80\u00c0J\f\u0002+\u0087V'\u00c0[d;\u00dfOM/\u00c0\u00d2\"\u00db\u00f9~*2\u00c0!\u00b0rh\u0091\u00ad%\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5-\u00c0\u008f\u00c2\u00f5(\\\u008f2\u00c0\u00bdt\u0093\u0018\u0004\u0096)\u00c0\u00db\u00f9~j\u00bc4/\u00c0\u00be\u009f\u001a/\u00dd$3\u00c033333s*\u00c0S\u00b8\u001e\u0085\u00eb\u0091-\u00c0\u00b4\u00c8v\u00be\u009f\u00fa1\u00c0\u00dd$\u0006\u0081\u0095C+\u00c0P\u008d\u0097n\u0012\u00030\u00c0\u00d7\u00a3p=\nw3\u00c0\u00b0rh\u0091\u00ed<(\u00c0'1\b\u00ac\u001c\u009a0\u00c0j\u00bct\u0093\u0018$4\u00c0Zd;\u00dfO\r'\u00c0-\u00b2\u009d\u00ef\u00a7&0\u00c0\u0081\u0095C\u008bl\u00c72\u00c0\u0000\u0000\u0000\u0000\u0000\u00c0)\u00c0\u00ac\u001cZd;\u009f2\u00c0\u009a\u0099\u0099\u0099\u0099\u00f91\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5*\u00c0Nb\u0010X942\u00c0\u00ac\u001cZd;\u001f3\u00c0\u00b6\u00f3\u00fd\u00d4x)*\u00c0\u00ecQ\u00b8\u001e\u0085\u008b3\u00c0\f\u0002+\u0087\u0016y4\u00c0\u00fc\u00a9\u00f1\u00d2M\"'\u00c0\u001f\u0085\u00ebQ\u00b8~2\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u008d4\u00c0\u00fa~j\u00bctS'\u00c0sh\u0091\u00ed|\u007f3\u00c0\u0014\u00aeG\u00e1z45\u00c0\u00aa\u00f1\u00d2Mb\u0010&\u00c0\u0002+\u0087\u0016\u00d9\u000e2\u00c07\u0089A`\u00e5\u00903\u00c0o\u0012\u0083\u00c0\u00caa(\u00c0\u0000\u0000\u0000\u0000\u0000\u00e01\u00c0z\u00e9&1\b\u00ac0\u00c0\u00a4p=\n\u00d7#$\u00c0\u008e\u0097n\u0012\u0083@&\u00c0\u009a\u0099\u0099\u0099\u0099\u00d90\u00c0\u0090\u00c2\u00f5(\\\u00cf%\u00c0\u00da\u00ce\u00f7S\u00e3%%\u00c0fffff\u00061\u00c0\u0000\u0000\u0000\u0000\u0000\u0080!\u00c0\u009c\u00c4 \u00b0r(%\u00c043333s1\u00c0\u00e3\u00a5\u009b\u00c4 0 \u00c0\u00ecQ\u00b8\u001e\u0085\u00ab&\u00c0&\u0006\u0081\u0095C\u008b/\u00c0\u00ef|?5^\u00ba\u001f\u00c0B`\u00e5\u00d0\"[$\u00c0q=\n\u00d7\u00a3\u00f01\u00c0\u00fa~j\u00bct\u0093!\u00c0H\u00e1z\u0014\u00ae\u00c7\"\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\r2\u00c0th\u0091\u00ed|?\u001f\u00c0/\u00dd$\u0006\u0081\u00d5!\u00c0\u00c7K7\u0089A\u00e02\u00c0\u00a8\u00c6K7\u0089\u0081\"\u00c0\u008bl\u00e7\u00fb\u00a9q#\u00c0\u0017\u00d9\u00ce\u00f7S\u00a3/\u00c0\u00e2z\u0014\u00aeG\u00e1\u001a\u00c0\u00be\u009f\u001a/\u00dd$$\u00c0\u008d\u0097n\u0012\u0083\u00801\u00c0!\u00b0rh\u0091-#\u00c0\u00e5\u00d0\"\u00db\u00f9\u00be \u00c0h\u0091\u00ed|?\u00b51\u00c0q=\n\u00d7\u00a30\"\u00c0\u0087\u0016\u00d9\u00ce\u00f7S\u001e\u00c0\u00c2\u00ca\u00a1E\u00b63-\u00c0=\n\u00d7\u00a3p\u00fd \u00c0\u00d8\u00a3p=\nW$\u00c0333333-\u00c0j\u00bct\u0093\u0018\u0004#\u00c0R\u00b8\u001e\u0085\u00ebQ$\u00c0\u00ecQ\u00b8\u001e\u0085\u00ab*\u00c0\u0007\u0081\u0095C\u008bl\u001f\u00c0\u001a\u0004V\u000e-r#\u00c0\u0082\u0095C\u008bl\u00e7*\u00c0=\n\u00d7\u00a3p=\u001d\u00c0\u00e0O\u008d\u0097n\u0092!\u00c0\u008aA`\u00e5\u00d0b)\u00c0\u001f\u0085\u00ebQ\u00b8^!\u00c09\u00b4\u00c8v\u00be\u00df\"\u00c0\u001b/\u00dd$\u0006\u0081)\u00c0|\u0014\u00aeG\u00e1z\u001b\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u008c%\u00c0\u00f0\u00a7\u00c6K7I'\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u0019\u00c0\u0086\u00ebQ\u00b8\u001eE%\u00c0\u00d2\"\u00db\u00f9~\u00ea*\u00c0\u00d4Mb\u0010X9\u001a\u00c0y\u00e9&1\b\u00ac'\u00c0\u00bct\u0093\u0018\u0004\u00d6,\u00c0a\u00e5\u00d0\"\u00dby\u001b\u00c0\u00fa~j\u00bct\u00d3'\u00c0`\u00e5\u00d0\"\u00db\u00b9)\u00c0\u00e6\u00d0\"\u00db\u00f9~\u0017\u00c0)\\\u008f\u00c2\u00f5(*\u00c00\u00dd$\u0006\u0081U(\u00c0\r\u0002+\u0087\u0016Y\u001a\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u000b+\u00c0\u00fd\u00a9\u00f1\u00d2M\u00e2'\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0012\u00c0)\\\u008f\u00c2\u00f5()\u00c0\u009e\u00ef\u00a7\u00c6K\u00f7+\u00c0R\u00b8\u001e\u0085\u00ebQ\u0016\u00c0\u00e3\u00a5\u009b\u00c4 0,\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u008d-\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u0013\u00c0\u00fe\u00d4x\u00e9&q+\u00c0\u001c/\u00dd$\u0006\u00c1,\u00c07\u0089A`\u00e5\u00d0\u0019\u00c0\u00e5\u00d0\"\u00db\u00f9>-\u00c0\u00f0\u00a7\u00c6K7\t+\u00c0\n\u00d7\u00a3p=\n\u0014\u00c0\u008f\u00c2\u00f5(\\\u00cf-\u00c0\u00baI\f\u0002+\u0087%\u00c0{\u0014\u00aeG\u00e1z\u0012\u00c0\u001eZd;\u00df\u00cf)\u00c0\"\u00b0rh\u0091\u00ed(\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\r\u00c0\u00c1\u00ca\u00a1E\u00b6\u00b3'\u00c0\u0082\u0095C\u008bl\u00e7*\u00c0\u00a0\u001a/\u00dd$\u0006\u000e\u00c0\u001eZd;\u00dfO'\u00c0\u00e6\u00d0\"\u00db\u00f9~'\u00c0\n\u00d7\u00a3p=\n\u0004\u00c0\u0091\u00ed|?5\u00de&\u00c0\b\u00ac\u001cZd\u00bb&\u00c0d;\u00dfO\u008d\u0097\u0000\u00c0G\u00b6\u00f3\u00fd\u00d4\u00b8(\u00c0\u0010X9\u00b4\u00c8v%\u00c0x\u00be\u009f\u001a/\u00dd\u0005\u00c0{\u0014\u00aeG\u00e1\u00ba$\u00c0\u0000\u0000\u0000\u0000\u0000\u00c0)\u00c0ffffff\u00f8\u00bf\u0084\u00c0\u00ca\u00a1E\u00b6%\u00c0\u00bf\u009f\u001a/\u00dd\u00a4*\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u00ff\u00bf+\u0087\u0016\u00d9\u00ce\u00f7#\u00c0u\u0093\u0018\u0004VN#\u00c0`\u00e5\u00d0\"\u00db\u00f9\u0000\u00c06^\u00baI\f\u00c2$\u00c0x\u00be\u009f\u001a/](\u00c0S\u00b8\u001e\u0085\u00ebQ\u00c8\u00bf$\u00db\u00f9~j\u00fc$\u00c0'1\b\u00ac\u001cZ'\u00c0u\u0093\u0018\u0004V\u000e\u00cd?\u0083\u00c0\u00ca\u00a1E\u00b6&\u00c0d;\u00dfO\u008d\u0017*\u00c0\u0092\u00ed|?5^\u00da?\u00a4p=\n\u00d7c$\u00c0\u00cf\u00f7S\u00e3\u00a5\u001b'\u00c0%\u0006\u0081\u0095C\u008b\u00cc\u00bf\u00c2\u00ca\u00a1E\u00b63#\u00c0\u00f7(\\\u008f\u00c2\u00b5+\u00c0y\u00e9&1\b\u00ac\u00f4\u00bf\u00db\u00f9~j\u00bc\u00b4'\u00c0\u0012\u0083\u00c0\u00ca\u00a1\u0085,\u00c0=\n\u00d7\u00a3p=\u0001\u00c0\u0019\u0004V\u000e-\u00f2'\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3%\u00c0:\u00b4\u00c8v\u00be\u009f\r\u00c0T\u00e3\u00a5\u009b\u00c4\u00e0\"\u00c0\u0000\u0000\u0000\u0000\u0000\u0080'\u00c0\u008e\u0097n\u0012\u0083@\u0011\u00c0\u00e9&1\b\u00ac\u00dc\"\u00c0=\n\u00d7\u00a3p\u00fd#\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M\u0010\u00c0D\u008bl\u00e7\u00fb\u00a9 \u00c0^\u00baI\f\u0002k#\u00c0\u00ea&1\b\u00ac\u001c\t\u00c0\u0081\u0095C\u008blg\u001f\u00c0P\u008d\u0097n\u0012\u0083!\u00c0\u00cb\u00a1E\u00b6\u00f3}\u0012\u00c0\u0014\u00aeG\u00e1z\u0014\"\u00c0)\\\u008f\u00c2\u00f5h%\u00c0\\\u008f\u00c2\u00f5(\\\u0014\u00c06^\u00baI\f\u0082\u001d\u00c0L7\u0089A`%$\u00c0\u00d5x\u00e9&1\u0088\u0015\u00c0E\u008bl\u00e7\u00fb)\u001a\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc%\u00c0\u0001\u0000\u0000\u0000\u0000\u0000\u0018\u00c0\u008e\u0097n\u0012\u0083\u00c0\u001f\u00c0V\u000e-\u00b2\u009do\u001e\u00c0\u00c9v\u00be\u009f\u001a\u00af\u0010\u00c0\u00f8S\u00e3\u00a5\u009b\u0084!\u00c0\u009a\u0099\u0099\u0099\u0099\u00d9'\u00c0\u00b8\u001e\u0085\u00ebQ8\u0012\u00c0\u00e0O\u008d\u0097n\u0092\u001b\u00c0*\\\u008f\u00c2\u00f5h(\u00c0\u00b5\u00c8v\u00be\u009f\u001a\u0014\u00c0\u00dc\u00f9~j\u00bct\u0018\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2!\u00c0d;\u00dfO\u008d\u0017\u0016\u00c0\u00a8\u00c6K7\u0089\u0001$\u00c0\u00cb\u00a1E\u00b6\u00f3\u00bd#\u00c0{\u0014\u00aeG\u00e1\u00fa\u0016\u00c0\u0010X9\u00b4\u00c8v$\u00c0\r\u0002+\u0087\u0016Y\u001f\u00c0\u00d8\u00a3p=\nW\u0018\u00c0n\u00e7\u00fb\u00a9\u00f1\u0092%\u00c0Nb\u0010X94\u001c\u00c0\u00e6\u00d0\"\u00db\u00f9\u00fe\u0019\u00c0\u001dZd;\u00dfO$\u00c0\"\u00b0rh\u0091m\u001c\u00c0\u0086\u00ebQ\u00b8\u001e\u0005\u0014\u00c0\u001a\u0004V\u000e-2'\u00c0d;\u00dfO\u008d\u00d7 \u00c0\u00e5\u00d0\"\u00db\u00f9\u00fe\u001c\u00c0\b\u00ac\u001cZd;'\u00c0sh\u0091\u00ed|?\"\u00c0\u00f1\u00a7\u00c6K7\u0089\u001b\u00c0+\u0087\u0016\u00d9\u00ce\u00b7(\u00c0\u00fe\u00d4x\u00e9&\u00f1!\u00c0\u0086\u00ebQ\u00b8\u001e\u0085\u001f\u00c0\u00aa\u00f1\u00d2Mb\u00d0%\u00c0)\\\u008f\u00c2\u00f5\u00a8\u0017\u00c0=\n\u00d7\u00a3p\u00bd\u0013\u00c0@5^\u00baIL'\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u001d\u00c0T\u00e3\u00a5\u009b\u00c4 \u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u008c(\u00c0\u00f8S\u00e3\u00a5\u009bD\u001a\u00c0]\u008f\u00c2\u00f5(\u00dc\u001d\u00c0\u00dc\u00f9~j\u00bct)\u00c0}?5^\u00baI\u001b\u00c0\u00c7K7\u0089A`!\u00c0\u00d8\u00a3p=\n\u0017'\u00c0 \u0085\u00ebQ\u00b8\u009e\u001f\u00c0\u00e9&1\b\u00ac\u001c\"\u00c0*\\\u008f\u00c2\u00f5\u00a8*\u00c0\u00d3Mb\u0010X9\u001c\u00c0H\u00e1z\u0014\u00ae\u0007#\u00c0\"\u00b0rh\u0091\u00ad+\u00c0\u00ee|?5^\u00ba \u00c0\u00f0\u00a7\u00c6K7\t!\u00c0\u00fa~j\u00bctS,\u00c0^\u00baI\f\u0002\u00ab!\u00c0X9\u00b4\u00c8v\u00fe#\u00c0\u0011X9\u00b4\u00c8v)\u00c0H\u00e1z\u0014\u00ae\u0087#\u00c0\u00b0rh\u0091\u00ed|#\u00c0\u00da\u00ce\u00f7S\u00e3\u00e5(\u00c0\u00da\u00ce\u00f7S\u00e3%\u001e\u00c0\u0002+\u0087\u0016\u00d9\u008e'\u00c0v\u0093\u0018\u0004V\u008e(\u00c0\u00c6 \u00b0rh\u0091\u001d\u00c0\u001a\u0004V\u000e-2)\u00c0\u000e-\u00b2\u009d\u00efg'\u00c0J\f\u0002+\u0087\u0016\u001b\u00c0\u00d3Mb\u0010X\u00f9&\u00c0+\u0087\u0016\u00d9\u00ce\u00b7)\u00c0\u0012\u0083\u00c0\u00ca\u00a1E#\u00c0:\u00b4\u00c8v\u00be\u009f'\u00c0~?5^\u00baI'\u00c0>\n\u00d7\u00a3p\u00fd\"\u00c0o\u0012\u0083\u00c0\u00caa)\u00c0\f\u0002+\u0087\u0016Y&\u00c0$\u00db\u00f9~j\u00fc$\u00c0\u0014\u00aeG\u00e1z\u0094&\u00c0@5^\u00baIL'\u00c0\n\u00d7\u00a3p=J!\u00c0\u00aeG\u00e1z\u0014n&\u00c0H\u00e1z\u0014\u00ae\u0087(\u00c0.\u00b2\u009d\u00ef\u00a7F\u001f\u00c0}?5^\u00baI\u0010\u00c0\u00aeG\u00e1z\u0014n(\u00c0p\u0012\u0083\u00c0\u00ca\u00a1!\u00c0H\u00e1z\u0014\u00ae\u00c7\u0010\u00c0\u00e5\u00d0\"\u00db\u00f9>(\u00c0Ob\u0010X94\u001d\u00c0\u00aa\u00f1\u00d2Mb\u0010\u0007\u00c0\u0015\u00aeG\u00e1z\u00d4)\u00c0\u001eZd;\u00df\u00cf\u001a\u00c0\u001f\u0085\u00ebQ\u00b8\u001e\n\u00c0\u00d4Mb\u0010Xy+\u00c0\u001c/\u00dd$\u0006\u0001\u001a\u00c0\u00bct\u0093\u0018\u0004V\u0000\u00c0\u0083\u00c0\u00ca\u00a1E\u00f6'\u00c0\u009a\u0099\u0099\u0099\u0099\u0019!\u00c0\u0010X9\u00b4\u00c8v\u0000\u00c06^\u00baI\f\u0002+\u00c0d;\u00dfO\u008d\u0097\"\u00c0x\u00be\u009f\u001a/\u00dd\u0005\u00c09\u00b4\u00c8v\u00be\u00df+\u00c0+\u0087\u0016\u00d9\u00ce7\"\u00c0\u0099n\u0012\u0083\u00c0\u00ca\u00f7\u00bf\u00a1\u001a/\u00dd$\u0086)\u00c09\u00b4\u00c8v\u00be\u009f\u0015\u00c0\u0080j\u00bct\u0093\u0018\u00fa\u00bf]\u008f\u00c2\u00f5(\u009c(\u00c0\u00a2E\u00b6\u00f3\u00fdT \u00c0J\f\u0002+\u0087\u0016\u00f1\u00bf\u00cc\u00a1E\u00b6\u00f3=-\u00c0#\u00db\u00f9~j\u00fc!\u00c0\b\u00ac\u001cZd;\u00d7\u00bf+\u0087\u0016\u00d9\u00cew-\u00c0\u00b9\u001e\u0085\u00ebQ8\u001d\u00c0%\u0006\u0081\u0095C\u008b\u00dc\u00bf#\u00db\u00f9~j\u00bc,\u00c0\u0090\u00c2\u00f5(\\\u008f\u001f\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u00fd\u00bf\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc/\u00c0=\n\u00d7\u00a3p=!\u00c0)\\\u008f\u00c2\u00f5(\u0005\u00c0^\u00baI\f\u0002+0\u00c0R\u00b8\u001e\u0085\u00eb\u00d1\u001b\u00c0\u00c9v\u00be\u009f\u001a/\u0003\u00c0\u00b0rh\u0091\u00ed|/\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u001e\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u00f0\u00bf\u00ac\u001cZd;\u001f1\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5\u001c\u00c0\r\u0002+\u0087\u0016\u00d9\u00f6\u00bf\u00ee|?5^\u00fa1\u00c0%\u0006\u0081\u0095C\u008b\u001c\u00c0\u00ea&1\b\u00ac\u001c\u00ba\u00bf/\u00dd$\u0006\u0081\u00f50\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u000b\"\u00c0z\u00e9&1\b\u00ac\u00e0\u00bf\u008f\u00c2\u00f5(\\\u00af1\u00c0Nb\u0010X9t#\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u00f3\u00bf\u00aa\u00f1\u00d2Mb\u00d01\u00c0\u00cav\u00be\u009f\u001a\u00af\"\u00c0\u00f7(\\\u008f\u00c2\u00f5\u00c8?\u0098n\u0012\u0083\u00c0\n1\u00c0sh\u0091\u00ed|\u00bf!\u00c0K\f\u0002+\u0087\u0016\u00b9\u00bf/\u00dd$\u0006\u0081\u00952\u00c0Ob\u0010X9\u00b4\u001b\u00c0L7\u0089A`\u00e5\u00fc\u00bf\u00ce\u00cc\u00cc\u00cc\u00cc\u008c%\u00c0p\u0012\u0083\u00c0\u00ca!\u001f\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u0002\u00c0/\u00dd$\u0006\u0081\u0015%\u00c0\n\u00d7\u00a3p=\n\u0019\u00c0b\u0010X9\u00b4\u00c8\u00f0\u00bf\u00aa\u00f1\u00d2Mb\u0090#\u00c0\t\u00ac\u001cZd\u00bb\u0017\u00c0\u00db\u00f9~j\u00bct\u00b3\u00bf\u0014\u00aeG\u00e1zT$\u00c0h\u0091\u00ed|?\u00b5\u0013\u00c0\u00bct\u0093\u0018\u0004V\u00fa\u00bf\u00fe\u00d4x\u00e9&\u00b1\"\u00c0\u009c\u00c4 \u00b0rh\u001c\u00c0\u0004V\u000e-\u00b2\u009d\u00e7\u00bfr=\n\u00d7\u00a30!\u00c0\u00baI\f\u0002+\u0007 \u00c0F\u00b6\u00f3\u00fd\u00d4x\u00d1\u00bf\u00b6\u00f3\u00fd\u00d4x\u00e9!\u00c0\u00b8\u001e\u0085\u00ebQ8\u001a\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u00b3\u00bf\u00aeG\u00e1z\u0014\u00ae\u001f\u00c0\u00a5p=\n\u00d7\u00a3\u001d\u00c0\u008bl\u00e7\u00fb\u00a9\u00f1\u00fa\u00bf\u00e7\u00fb\u00a9\u00f1\u00d2M \u00c0\u009f\u00ef\u00a7\u00c6K7\u000f\u00c0R\u00b8\u001e\u0085\u00ebQ\u00f0\u00bf\u0017\u00d9\u00ce\u00f7S\u00e3\"\u00c0\u00a0\u001a/\u00dd$\u0086\u0013\u00c0\u00a5p=\n\u00d7\u00a3\u0007\u00c0J\f\u0002+\u0087V\"\u00c0>\n\u00d7\u00a3p\u00bd\u0016\u00c0,\u0087\u0016\u00d9\u00ce\u00f7\u000b\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\"\u00c0\u008d\u0097n\u0012\u0083\u00c0\f\u00c0333333\u000e\u00c0\u00c1\u00ca\u00a1E\u00b6\u00b3!\u00c0\u00f6(\\\u008f\u00c2\u00f5\t\u00c0G\u00b6\u00f3\u00fd\u00d4x\f\u00c0\r\u0002+\u0087\u0016Y\u001f\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0003\u00c0\u0097C\u008bl\u00e7\u00fb\f\u00c0\u00bct\u0093\u0018\u0004\u00d6#\u00c0+\u0087\u0016\u00d9\u00cew\u0010\u00c0\u0010X9\u00b4\u00c8\u00f6\u0014\u00c0\u00fa~j\u00bctS!\u00c0~?5^\u00baI\u0012\u00c0\u00b8\u001e\u0085\u00ebQ8\u0016\u00c0\u00c2\u00ca\u00a1E\u00b63#\u00c0\u0010X9\u00b4\u00c8\u00f6\u0013\u00c0\u0015\u00aeG\u00e1z\u0014\u0015\u00c0\n\u00d7\u00a3p=\n \u00c0!\u00b0rh\u0091\u00ed\u00f4\u00bfq=\n\u00d7\u00a3p\u000b\u00c0\u0080j\u00bct\u0093\u0018#\u00c0\u0099n\u0012\u0083\u00c0\u00ca\u0007\u00c0\u0014\u00aeG\u00e1z\u0014\u0019\u00c0\b\u00ac\u001cZd\u00bb \u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u0001\u00c0\u00c9v\u00be\u009f\u001a/\u0019\u00c0H\u00e1z\u0014\u00aeG\"\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u0001\u00c07\u0089A`\u00e5P\u0018\u00c0L7\u0089A`\u00e5\u001b\u00c0\u0001\u0000\u0000\u0000\u0000\u0000\u0007\u00c0?5^\u00baI\f\u0018\u00c0\u00e2z\u0014\u00aeGa\u0018\u00c0\u00aa\u00f1\u00d2Mb\u0010\u00f8\u00bf\u0082\u0095C\u008blg\u001b\u00c0U\u00e3\u00a5\u009b\u00c4\u00a0\u001a\u00c0\u0013\u0083\u00c0\u00ca\u00a1E\u00fa\u00bfe;\u00dfO\u008d\u0097\u0014\u00c0\u0090\u00c2\u00f5(\\\u000f\u001c\u00c0\u00dd$\u0006\u0081\u0095C\f\u00c0Y9\u00b4\u00c8v\u00be\u001e\u00c0H\u00e1z\u0014\u00ae\u00c7 \u00c0}?5^\u00baI\u0010\u00c0\u00b1rh\u0091\u00ed\u00fc\u001f\u00c0\u00fa~j\u00bct\u0093\"\u00c0+\u0087\u0016\u00d9\u00ce\u00f7\u0005\u00c0J\f\u0002+\u0087\u00d6 \u00c0\u00fa~j\u00bct\u0093 \u00c0V\u000e-\u00b2\u009d\u00ef\u0010\u00c0\u0099n\u0012\u0083\u00c0J\u001f\u00c0\u00ce\u00cc\u00cc\u00cc\u00ccL\u001e\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5\u0006\u00c08\u0089A`\u00e5\u00d0\f\u00c0\u00cav\u00be\u009f\u001ao&\u00c0\u00c8K7\u0089A`\u000e\u00c0\u0084\u00c0\u00ca\u00a1E\u00b6\u000e\u00c0\u00ea&1\b\u00ac\u00dc&\u00c0\u00b7\u00f3\u00fd\u00d4x\u00e9\u00fe\u00bf\u0012\u0083\u00c0\u00ca\u00a1E\u000b\u00c0c\u0010X9\u00b4\u00c8(\u00c0\u00be\u009f\u001a/\u00dd$\u00f0\u00bf\u009d\u00c4 \u00b0rh\u000f\u00c0Y9\u00b4\u00c8v>(\u00c0P\u008d\u0097n\u0012\u0083\u00f8\u00bfU\u00e3\u00a5\u009b\u00c4 \u00fe\u00bf\u00bf\u009f\u001a/\u00dd$)\u00c0\u0004V\u000e-\u00b2\u009d\u0004\u00c0\u00f6(\\\u008f\u00c2\u00f5\u000e\u00c0L7\u0089A`e+\u00c0\u00e4\u00a5\u009b\u00c4 \u00b0\f\u00c0\u00f1\u00a7\u00c6K7\u0089\u000b\u00c0\u001c/\u00dd$\u0006\u0081+\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M\u0006\u00c0h\u0091\u00ed|?\u00b5\u0013\u00c0;\u00dfO\u008d\u0097.+\u00c0*\\\u008f\u00c2\u00f5(\u00dc\u00bf\u00c9v\u00be\u009f\u001a/\u00f9\u00bf\u00a8\u00c6K7\u0089\u0001*\u00c0\u00bdt\u0093\u0018\u0004V\u00fc\u00bf\u00d3Mb\u0010X9\f\u00c0\u00fd\u00a9\u00f1\u00d2M\u00e2-\u00c0\u001a\u0004V\u000e-\u00b2\u00f9\u00bf\u000e-\u00b2\u009d\u00ef\u00a7\u0003\u00c0\u008aA`\u00e5\u00d0\".\u00c0~?5^\u00baI\u0002\u00c0\u00fb~j\u00bct\u0093\u000f\u00c0\u00f2\u00d2Mb\u0010\u0098/\u00c0\u001c/\u00dd$\u0006\u0081\u00d5\u00bfj\u00bct\u0093\u0018\u0084\u0010\u00c0\u00bbI\f\u0002+\u00c7-\u00c0Zd;\u00dfO\u008d\u00b7\u00bfffffff\u0014\u00c0\u008f\u00c2\u00f5(\\O,\u00c0\u001b/\u00dd$\u0006\u0081\u00dd?\u00e8\u00fb\u00a9\u00f1\u00d2M\r\u00c0\u00ecQ\u00b8\u001e\u0085k/\u00c0'1\b\u00ac\u001cZ\u0003\u00c0\u00c7K7\u0089A`\u00ed\u00bf\u008cl\u00e7\u00fb\u00a9\u00b1(\u00c0\u0092\u00ed|?5^\n\u00c09\u00b4\u00c8v\u00be\u009f\u00f4\u00bf\u00c3\u00f5(\\\u008f\u0002(\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u0000\u00c0\u00fa~j\u00bct\u0093\u00e0?z\u00e9&1\b\u00ec(\u00c0\u0085\u00ebQ\u00b8\u001e\u0085\u00f7\u00bf'1\b\u00ac\u001cZ\u00e8?\u009d\u00c4 \u00b0r\u00a8*\u00c0#\u00db\u00f9~j\u00bc\u00f2\u00bf\u00f7(\\\u008f\u00c2\u00f5\u00ec?\u00dd$\u0006\u0081\u0095\u0083&\u00c0d;\u00dfO\u008d\u0097\u000b\u00c0\u00f4\u00fd\u00d4x\u00e9&\u00f5?\u0015\u00aeG\u00e1z\u00d4(\u00c0C`\u00e5\u00d0\"\u00db\u000f\u00c0)\\\u008f\u00c2\u00f5(\u00f2?\u0010X9\u00b4\u00c8\u00f6&\u00c0\u0087\u0016\u00d9\u00ce\u00f7S\u00d3\u00bf\u00afG\u00e1z\u0014\u00ae\u00fb?\u009d\u00c4 \u00b0r\u00e8&\u00c0\f\u0002+\u0087\u0016\u00d9\b\u00c0\u00b0rh\u0091\u00ed|\u0006@\u00fe\u00d4x\u00e9&1)\u00c0d;\u00dfO\u008d\u0097\u0005\u00c0\u0096C\u008bl\u00e7\u00fb\b@\u001b/\u00dd$\u0006A'\u00c0\u00aeG\u00e1z\u0014\u00ae\u000f\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u000b@\u000b\u00d7\u00a3p=\u00ca)\u00c0\u00aa\u00f1\u00d2Mb\u0010\u0002\u00c0\u00aeG\u00e1z\u0014\u00ae\u0007@\u00c3\u00f5(\\\u008f\u0082*\u00c0\u0091\u00ed|?5\u00de\u0011\u00c0\u00afG\u00e1z\u0014\u00ae\u00eb?\u0011X9\u00b4\u00c8\u00b6*\u00c0\u00d9\u00ce\u00f7S\u00e3%\u0013\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u0090\u00bf\u00d5x\u00e9&1H*\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u00f4\u00bf\u00ecQ\u00b8\u001e\u0085\u00eb\u00d1?\u00da\u00ce\u00f7S\u00e3%$\u00c0\u00b2\u009d\u00ef\u00a7\u00c6K\u0000\u00c0\u00edQ\u00b8\u001e\u0085\u00eb\u00d9\u00bf\u00a4p=\n\u00d7#$\u00c0\u00a7\u009b\u00c4 \u00b0r\u00d8\u00bf(1\b\u00ac\u001cZ\u00e0?d;\u00dfO\u008d\u0017\"\u00c0\u00d1\"\u00db\u00f9~j\u00bc\u00bf\u00a0\u001a/\u00dd$\u0006\u00f9?h\u0091\u00ed|?\u00f5!\u00c0\u0007\u0081\u0095C\u008bl\u00ef?\u00cf\u00f7S\u00e3\u00a5\u009b\u00c4\u00bfNb\u0010X9\u00b4\"\u00c0\u00a8\u00c6K7\u0089A\u00ec\u00bf\u0089A`\u00e5\u00d0\"\u00ab\u00bf\u00d3Mb\u0010X\u00b9\u001e\u00c0\u00bbI\f\u0002+\u0087\u0096\u00bf\u00a8\u00c6K7\u0089A\u00d0\u00bf\u00aeG\u00e1z\u0014.\u001c\u00c0\u00c3\u00f5(\\\u008f\u00c2\u00f5\u00bf\u00fc\u00a9\u00f1\u00d2Mb\u00f0\u00bf\u00b8\u001e\u0085\u00ebQ8\u001f\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u00fe?-\u00b2\u009d\u00ef\u00a7\u00c6\u00cb?\u00c3\u00f5(\\\u008fB!\u00c0n\u00e7\u00fb\u00a9\u00f1\u00d2\u00fb\u00bfj\u00bct\u0093\u0018\u0004\u00ee?W\u000e-\u00b2\u009do\u001b\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\u0005\u00c0R\u00b8\u001e\u0085\u00ebQ\u00f0?U\u00e3\u00a5\u009b\u00c4 \u001d\u00c0K\f\u0002+\u0087\u0016\u00ff\u00bf5^\u00baI\f\u0002\u00d3?\u00a1\u001a/\u00dd$\u0006\u0016\u00c0\u008cl\u00e7\u00fb\u00a9\u00f1\u00ee\u00bf{\u0014\u00aeG\u00e1z\u0084\u00bf\u00f0\u00a7\u00c6K7\u0089\u0014\u00c0j\u00bct\u0093\u0018\u0004\u0003\u00c07\u0089A`\u00e5\u00d0\u00ee?\u00a0\u001a/\u00dd$\u0006\u0013\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\u0003\u00c0\u00a0\u001a/\u00dd$\u0006\u00e5\u00bfsh\u0091\u00ed|?\u0016\u00c0\u00d7\u00a3p=\n\u00d7\u00f1\u00bf\u009e\u00ef\u00a7\u00c6K7\u0002@\u0086\u00ebQ\u00b8\u001e\u0085\u001a\u00c0333333\u00b3\u00bfq=\n\u00d7\u00a3p\u0000@\u00e9&1\b\u00ac\u009c\u0019\u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\u00f2\u00bf\u009c\u00c4 \u00b0rh\u0007@5^\u00baI\f\u0002\u001e\u00c0\u00ee|?5^\u00ba\u00f7\u00bf\u00dd$\u0006\u0081\u0095C\u0006@\u008bl\u00e7\u00fb\u00a9\u00f1\u0016\u00c0\u00d3Mb\u0010X9\u00f2?\u00b6\u00f3\u00fd\u00d4x\u00e9\u00f2\u00bf6^\u00baI\f\u0082$\u00c0j\u00bct\u0093\u0018\u0004\u00d6?\u00f6(\\\u008f\u00c2\u00f5\u00fa\u00bfh\u0091\u00ed|?5%\u00c0\u0091\u00ed|?5^\u0004@\u00f0\u00a7\u00c6K7\u0089\u00f9\u00bf\u00a8\u00c6K7\u0089A%\u00c0\u00f7(\\\u008f\u00c2\u00f5\b@|\u0014\u00aeG\u00e1z\u00fc\u00bf\u00c9v\u00be\u009f\u001ao#\u00c0th\u0091\u00ed|?\t@5^\u00baI\f\u0002\u00e3\u00bfJ\f\u0002+\u0087\u0016'\u00c0\u00aeG\u00e1z\u0014\u00ae\u0003@=\n\u00d7\u00a3p=\u0007\u00c0\u0098n\u0012\u0083\u00c0\u00ca&\u00c0#\u00db\u00f9~j\u00bc\u00fc?7\u0089A`\u00e5\u00d0\u0005\u00c0\u00ef|?5^z(\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\u000b@\u00d4Mb\u0010X9\t\u00c0\u0015\u00aeG\u00e1z\u0094'\u00c0w\u00be\u009f\u001a/]\u0011@J\f\u0002+\u0087\u0016\u00d1\u00bf<\u00dfO\u008d\u0097\u00ee&\u00c0R\u00b8\u001e\u0085\u00ebQ\u0000@\u0004V\u000e-\u00b2\u009d\u0010\u00c01\b\u00ac\u001cZ$%\u00c0\u00b0rh\u0091\u00ed|\u00f1?\u009f\u00ef\u00a7\u00c6K7\u000f\u00c0\u0093\u0018\u0004V\u000e-$\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u0006@\u00d9\u00ce\u00f7S\u00e3%\u0011\u00c0\u00baI\f\u0002+\u0087#\u00c0Y9\u00b4\u00c8v\u00be\u00ff?\u0080j\u00bct\u0093\u0098\u0015\u00c0\u00e5\u00d0\"\u00db\u00f9\u00fe&\u00c0\u0080j\u00bct\u0093\u0018\b@%\u0006\u0081\u0095C\u008b\u0016\u00c07\u0089A`\u00e5\u0090'\u00c0\u0019\u0004V\u000e-\u00b2\u00f7?Nb\u0010X9\u00b4\u0014\u00c0p\u0012\u0083\u00c0\u00ca\u00e1(\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u00f6?\u00ce\u00cc\u00cc\u00cc\u00ccL\u001a\u00c0\u00fc\u00a9\u00f1\u00d2M\u00a2%\u00c07\u0089A`\u00e5\u00d0\u00fe?fffff\u00e6\u001b\u00c0\u00d7\u00a3p=\n\u0017$\u00c0\u0089A`\u00e5\u00d0\"\u00e3\u00bf\u00ab\u00f1\u00d2Mb\u0010\u001b\u00c0\u00e5\u00d0\"\u00db\u00f9\u00fe'\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u00f7\u00bfB`\u00e5\u00d0\"\u00db\u001c\u00c0\u0010X9\u00b4\u00c8\u00b6'\u00c0\u00d4Mb\u0010X9\u00d4\u00bf\u0005V\u000e-\u00b2\u009d\u0018\u00c0-\u00b2\u009d\u00ef\u00a7\u0086)\u00c0\u00f7(\\\u008f\u00c2\u00f5\u00c8\u00bf)\\\u008f\u00c2\u00f5h \u00c0\u00aeG\u00e1z\u0014\u00ee$\u00c0\u0081\u0095C\u008bl\u00e7\u00eb\u00bf\u00a2E\u00b6\u00f3\u00fd\u0094!\u00c0\u00e2z\u0014\u00aeG\u00e1%\u00c0433333\u00db?\u00b0rh\u0091\u00ed1\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\u00e2?\u008f\u00c2\u00f5(\\\u008f\u0001\u00c0`\u00e5\u00d0\"\u00db\u00b90\u00c0!\u00b0rh\u0091\u00ed\u00e0\u00bf\u00fc\u00a9\u00f1\u00d2Mb\u00e4\u00bf5^\u00baI\fB3\u00c0\u00db\u00f9~j\u00bct\u00f1\u00bf\u0086\u00ebQ\u00b8\u001e\u0085\u00eb\u00bf\u00fe\u00d4x\u00e9&\u00114\u00c0$\u00db\u00f9~j\u00bc\u00d4\u00bf\u00c3\u00f5(\\\u008f\u00c2\u00d5?\u0004V\u000e-\u00b2\u001d3\u00c0\\\u008f\u00c2\u00f5(\\\u00cf\u00bf@5^\u00baI\f\u0006\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d22\u00c0B`\u00e5\u00d0\"\u00db\u00c9?;\u00dfO\u008d\u0097n\f\u00c01\b\u00ac\u001cZd2\u00c0\u00ee|?5^\u00ba\u00e5\u00bf\u00bbI\f\u0002+\u0087\u0006\u00c0\u0096C\u008bl\u00e7\u00bb3\u00c0\u0019\u0004V\u000e-\u00b2\u00ad\u00bf5^\u00baI\f\u0002\u00f9\u00bf\u0087\u0016\u00d9\u00ce\u00f7s2\u00c0\u00baI\f\u0002+\u0087\u0001@<\u00dfO\u008d\u0097n\b@x\u00be\u009f\u001a/\u001d(\u00c0^\u00baI\f\u0002+\u00f5?ffffff\u0004@\f\u0002+\u0087\u0016\u00d9'\u00c0F\u00b6\u00f3\u00fd\u00d4x\u0003@\u00ecQ\u00b8\u001e\u0085\u00eb\u0010@43333s&\u00c0Nb\u0010X9\u00b4\u0007@V\u000e-\u00b2\u009d\u00ef\u0013@L7\u0089A`\u00a5'\u00c0Y9\u00b4\u00c8v\u00be\n@9\u00b4\u00c8v\u00be\u009f\u000f@p\u0012\u0083\u00c0\u00ca!$\u00c0\u00c5 \u00b0rh\u0091\u00f1?7\u0089A`\u00e5P\u0013@\u0003+\u0087\u0016\u00d9N%\u00c0\u00b2\u009d\u00ef\u00a7\u00c6K\u00e3?\u00e7\u00fb\u00a9\u00f1\u00d2M\u0010@\u00cf\u00f7S\u00e3\u00a5\u001b$\u00c0Y9\u00b4\u00c8v\u00be\u000f@\u001f\u0085\u00ebQ\u00b8\u009e\u0013@9\u00b4\u00c8v\u00be\u001f#\u00c0\u00a9\u00c6K7\u0089A\u00f4?\u0019\u0004V\u000e-\u00b2\u0018@\n\u00d7\u00a3p=\n$\u00c0\u00aa\u00f1\u00d2Mb\u0010\u00d8?}?5^\u00baI\u001b@\u00a0\u001a/\u00dd$\u0006$\u00c0\u008f\u00c2\u00f5(\\\u008f\u00fc?\u0083\u00c0\u00ca\u00a1E\u00b6\u0018@\u0004V\u000e-\u00b2\u001d\"\u00c0\u00bct\u0093\u0018\u0004V\u00fe?Zd;\u00dfO\r\u001b@\u001f\u0085\u00ebQ\u00b8^%\u00c0\u00b2\u009d\u00ef\u00a7\u00c6K\u00b7?P\u008d\u0097n\u0012\u0083\u0014@Nb\u0010X9t'\u00c0\u00edQ\u00b8\u001e\u0085\u00eb\u00e9\u00bf1\b\u00ac\u001cZd\u0016@\"\u00b0rh\u0091\u00ad&\u00c0\f\u0002+\u0087\u0016\u00d9\u00e2?\u00aa\u00f1\u00d2Mb\u0010\u0017@\u00f4\u00fd\u00d4x\u00e9\u00e6(\u00c0x\u00be\u009f\u001a/\u00dd\u00c4\u00bf\u00bct\u0093\u0018\u0004\u00d6\u0010@.\u00b2\u009d\u00ef\u00a7\u0086(\u00c0\u0092\u00ed|?5^\f@[d;\u00dfO\u008d\u0005@\u009e\u00ef\u00a7\u00c6K7#\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\u0007@\u00b2\u009d\u00ef\u00a7\u00c6K\u00ff?\u00a6\u009b\u00c4 \u00b0\u00f2#\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0012@P\u008d\u0097n\u0012\u0083\u0002@\u0019\u0004V\u000e-r!\u00c0\u00d7\u00a3p=\n\u00d7\u0012@%\u0006\u0081\u0095C\u008b\b@$\u00db\u00f9~j\u00bc\u001f\u00c033333\u00b3\u0011@D\u008bl\u00e7\u00fb\u00a9\u00f5?\u0002+\u0087\u0016\u00d9\u008e \u00c0\u00fc\u00a9\u00f1\u00d2Mb\u0018@\u0004V\u000e-\u00b2\u009d\u0002@)\\\u008f\u00c2\u00f5\u00a8\"\u00c0\u0084\u00c0\u00ca\u00a1E6\u001c@\u007fj\u00bct\u0093\u0018\u0000@h\u0091\u00ed|?5!\u00c00\u00dd$\u0006\u0081\u0095\u0019@+\u0087\u0016\u00d9\u00ce\u00f7\u0004@\u00a6\u009b\u00c4 \u00b02%\u00c0\u00ac\u001cZd;_\u0016@\u00c2\u00ca\u00a1E\u00b6\u00f3\u0006@Zd;\u00dfOM&\u00c0\u00c4\u00f5(\\\u008f\u00c2\u001e@2\b\u00ac\u001cZd\u0004@%\u0006\u0081\u0095C\u008b&\u00c033333\u00b3\u001f@\u0096C\u008bl\u00e7\u00fb\u00f7?o\u0012\u0083\u00c0\u00ca!&\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u008b!@\u00afG\u00e1z\u0014\u00ae\u000b@\u00bct\u0093\u0018\u0004V%\u00c0\u0003+\u0087\u0016\u00d9\u00ce\u001d@\u00aeG\u00e1z\u0014\u00ae\u0005@e;\u00dfO\u008d\u0097)\u00c0\u0019\u0004V\u000e-2\u001a@\u008bl\u00e7\u00fb\u00a9\u00f1\u0000@\u00e2z\u0014\u00aeG\u00e1)\u00c0\u00d3Mb\u0010X9\u001d@\u00fe\u00d4x\u00e9&1\u000e@\u00e2z\u0014\u00aeG\u00e1)\u00c0\u0012\u0083\u00c0\u00ca\u00a1E!@\u000e-\u00b2\u009d\u00ef\u00a7\u0012@\u00d4Mb\u0010X9%\u00c0-\u00b2\u009d\u00ef\u00a7F!@\u0088\u0016\u00d9\u00ce\u00f7S\u0001@\u00aeG\u00e1z\u0014.+\u00c0\u009a\u0099\u0099\u0099\u0099Y\"@\u00a5p=\n\u00d7\u00a3\u0007@\u009f\u00ef\u00a7\u00c6K\u00b7,\u00c0\u008bl\u00e7\u00fb\u00a9\u00f1!@\u000e-\u00b2\u009d\u00ef\u00a7\u00ee?\u00c7K7\u0089A\u00e0*\u00c0\u001b/\u00dd$\u0006\u00c1#@\b\u00ac\u001cZd;\u0007@\u00ea&1\b\u00ac\\$\u00c0\u00e9&1\b\u00ac\u00dc#@R\u00b8\u001e\u0085\u00ebQ\u00fe?L7\u0089A`%$\u00c0'1\b\u00ac\u001c\u001a&@\u00cb\u00a1E\u00b6\u00f3\u00fd\r@\u00d9\u00ce\u00f7S\u00e3\u00a5#\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4'@\u0083\u00c0\u00ca\u00a1E\u00b6\b@@5^\u00baI\u00cc#\u00c0\u00c4\u00f5(\\\u008fB&@!\u00b0rh\u0091m\u0012@\u0096C\u008bl\u00e7\u00fb$\u00c0R\u00b8\u001e\u0085\u00eb\u00d1%@h\u0091\u00ed|?5\u0011@\u00ee|?5^\u00ba \u00c0\u00fd\u00a9\u00f1\u00d2M\u00e2'@\u0019\u0004V\u000e-\u00b2\u0012@5^\u00baI\f\u0002\u001f\u00c0d;\u00dfO\u008dW#@\u0000\u0000\u0000\u0000\u0000\u0080\u0011@\u00ecQ\u00b8\u001e\u0085k\u001f\u00c0sh\u0091\u00ed|\u00bf!@7\u0089A`\u00e5\u00d0\u000f@\u00d1\"\u00db\u00f9~\u00aa \u00c0\u00b4\u00c8v\u00be\u009f\u00da\"@\u00d2\"\u00db\u00f9~j\u0014@2\b\u00ac\u001cZd\u001a\u00c0}?5^\u00ba\t#@43333\u00b3\u0018@%\u0006\u0081\u0095C\u000b\u001b\u00c0\u00a2E\u00b6\u00f3\u00fd\u0094$@\u00ac\u001cZd;_\u0012@C`\u00e5\u00d0\"\u00db\u0015\u00c033333\u00b3\u001f@\n\u00d7\u00a3p=\u008a\u0013@\u0082\u0095C\u008bl\u00e7\u0018\u00c0\u00a0\u001a/\u00dd$\u0006\u001f@\u009b\u0099\u0099\u0099\u0099\u0099\u000e@\u00b4\u00c8v\u00be\u009f\u001a\u0018\u00c0\u00b3\u009d\u00ef\u00a7\u00c6\u00cb%@b\u0010X9\u00b4\u00c8\u0015@\u00e4\u00a5\u009b\u00c4 0\u0013\u00c0*\\\u008f\u00c2\u00f5\u00a8\u001e@\u00a9\u00c6K7\u0089\u00c1\u0016@\u00e3\u00a5\u009b\u00c4 \u00b0\u0013\u00c0\u00c2\u00ca\u00a1E\u00b6s\u001a@<\u00dfO\u008d\u0097\u00ee\u0016@\u0000\u0000\u0000\u0000\u0000\u0080\u0012\u00c0\u00a0\u001a/\u00dd$\u0086\u001f@\u00ad\u001cZd;\u00df\u001a@\u0098n\u0012\u0083\u00c0\u00ca\u0014\u00c0\b\u00ac\u001cZd{ @\u00f8S\u00e3\u00a5\u009b\u00c4\u0015@\u009a\u0099\u0099\u0099\u0099\u0019\u0010\u00c0`\u00e5\u00d0\"\u00db\u00f9\u001b@\u00f4\u00fd\u00d4x\u00e9\u00a6\u0015@\u0094\u0018\u0004V\u000e-\u001d\u00c0}?5^\u00ba\u00c9\u001c@\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u0019@\u00ce\u00cc\u00cc\u00cc\u00ccL\u001e\u00c0\u00c4\u00f5(\\\u008fB\u001c@\u00b0rh\u0091\u00ed|\u0013@`\u00e5\u00d0\"\u00dby \u00c0\u00fe\u00d4x\u00e9&\u00b1\u0017@\u008d\u0097n\u0012\u0083@\u0015@\u00a0\u001a/\u00dd$\u0086\u001c\u00c0h\u0091\u00ed|?\u00b5$@\"\u00b0rh\u0091\u00ed\t@Zd;\u00dfO\r\u0015\u00c0\u00e2z\u0014\u00aeG\u00a1#@\u001dZd;\u00dfO\u0004@\u00a0\u001a/\u00dd$\u0006\u0017\u00c0H\u00e1z\u0014\u00aeG&@\u00d8\u00a3p=\n\u00d7\u0005@\u0019\u0004V\u000e-\u00b2\u0010\u00c0\u00d4Mb\u0010Xy%@\u008aA`\u00e5\u00d0\"\t@\u0000\u0000\u0000\u0000\u0000\u0000\n\u00c0\b\u00ac\u001cZd;)@P\u008d\u0097n\u0012\u0083\t@\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0010\u00c0~?5^\u00ba\t&@)\\\u008f\u00c2\u00f5(\u00f2?-\u00b2\u009d\u00ef\u00a7\u00c6\u0010\u00c0ffffff&@\u00a5p=\n\u00d7\u00a3\u00e8?\\\u008f\u00c2\u00f5(\u00dc\u0014\u00c0\u00f2\u00d2Mb\u0010X'@\u00f7(\\\u008f\u00c2\u00f5\u00e8?^\u00baI\f\u0002+\u000b\u00c0\u00a4p=\n\u00d7c*@\u0000\u0000\u0000\u0000\u0000\u0000\u000b@\u0093\u0018\u0004V\u000e-\t\u00c0\u0085\u00ebQ\u00b8\u001eE#@\u00b4\u00c8v\u00be\u009f\u001a\u00e3?8\u0089A`\u00e5\u00d0\r\u00c0\u008d\u0097n\u0012\u0083\u0000#@D\u008bl\u00e7\u00fb\u00a9\u00ed?\u0004V\u000e-\u00b2\u009d\u0005\u00c0\u0017\u00d9\u00ce\u00f7S\u00a3!@\u00a8\u00c6K7\u0089A\u00f0?\u00c3\u00f5(\\\u008fB\u0011\u00c0\u0010X9\u00b4\u00c8\u00b6\"@\u0084\u00c0\u00ca\u00a1E\u00b6\u00eb\u00bf\u0082\u0095C\u008bl\u00e7\u000f\u00c0\u00baI\f\u0002+\u0087 @\t\u00ac\u001cZd;\u00f5\u00bf\u00c5 \u00b0rh\u0011\u0012\u00c0\u00c8K7\u0089A\u00e0\u001d@8\u0089A`\u00e5\u00d0\u00e6\u00bf\u00e9&1\b\u00ac\u009c\u0012\u00c0\u008d\u0097n\u0012\u0083@ @/\u00dd$\u0006\u0081\u0095\u0002\u00c0\u001b/\u00dd$\u0006\u0001\u0012\u00c0\u0084\u00c0\u00ca\u00a1Ev$@\u00e2z\u0014\u00aeG\u00e1\u00fa\u00bf\"\u00b0rh\u0091\u00ed\r\u00c0\u00b5\u00c8v\u00be\u009fZ*@\u00d9\u00ce\u00f7S\u00e3\u00a5\n@ \u0085\u00ebQ\u00b8\u009e\u0015\u00c0gffff&)@)\\\u008f\u00c2\u00f5(\n@\u0018\u00d9\u00ce\u00f7S\u00e3\u0018\u00c0$\u00db\u00f9~j<-@V\u000e-\u00b2\u009d\u00ef\f@=\n\u00d7\u00a3p=\u0016\u00c0n\u00e7\u00fb\u00a9\u00f1R.@\u001b/\u00dd$\u0006\u0081\b@z\u00e9&1\b,\u0013\u00c0\"\u00b0rh\u0091\u00ed-@L7\u0089A`e\u0014@5^\u00baI\f\u0082\u0015\u00c0F\u00b6\u00f3\u00fd\u00d48.@\u00d7\u00a3p=\n\u00d7\b@\u00e4\u00a5\u009b\u00c4 \u00b0\u001b\u00c0\u0083\u00c0\u00ca\u00a1E\u00160@\u00c5 \u00b0rh\u0091\f@M7\u0089A`e\u001c\u00c0\u0099n\u0012\u0083\u00c0\u00ca,@x\u00be\u009f\u001a/\u00dd\n@H\u00e1z\u0014\u00ae\u00c7\u001e\u00c0i\u0091\u00ed|?\u00f5/@D\u008bl\u00e7\u00fb\u00a9\u0015@\u00e7\u00fb\u00a9\u00f1\u00d2M\u0013\u00c0\u009b\u0099\u0099\u0099\u0099\u0099.@th\u0091\u00ed|?\u00f9?\u0005V\u000e-\u00b2\u001d\u001c\u00c0^\u00baI\f\u0002+/@\u001dZd;\u00dfO\u00f3?\u00e4\u00a5\u009b\u00c4 0\u0018\u00c0\u0010X9\u00b4\u00c8\u00b6,@\u00e5\u00d0\"\u00db\u00f9~\u00f2?G\u00b6\u00f3\u00fd\u00d4x\u001d\u00c0\u00ac\u001cZd;_0@\u009a\u0099\u0099\u0099\u0099\u0099\u00f3?o\u0012\u0083\u00c0\u00ca! \u00c0-\u00b2\u009d\u00ef\u00a7\u00a60@\u00b6\u00f3\u00fd\u00d4x\u00e9\u00c6?\u00fe\u00d4x\u00e9&\u00b1\u001f\u00c0q=\n\u00d7\u00a3P1@\u00d3Mb\u0010X9\u00fc?\u0096C\u008bl\u00e7\u00fb\u001f\u00c0\u00cf\u00f7S\u00e3\u00a5\u009b/@\u00d1\"\u00db\u00f9~j\u00f6?Nb\u0010X9\u00f4\"\u00c0#\u00db\u00f9~j\u001c0@-\u00b2\u009d\u00ef\u00a7\u00c6\u0001@D\u008bl\u00e7\u00fb\u00e9#\u00c08\u0089A`\u00e5\u0090,@\u00cb\u00a1E\u00b6\u00f3\u00fd\u00d4\u00bf6^\u00baI\f\u0082#\u00c0x\u00be\u009f\u001a/\u001d+@\u00be\u009f\u001a/\u00dd$\u00e6\u00bf\u0011X9\u00b4\u00c8\u00b6$\u00c0#\u00db\u00f9~j\u00fc,@D\u008bl\u00e7\u00fb\u00a9\u00ed\u00bf\u00db\u00f9~j\u00bc\u00f4!\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9,@y\u00e9&1\b\u00ac\u00f2?>\n\u00d7\u00a3p}&\u00c0\u00d9\u00ce\u00f7S\u00e3\u00e5+@\u00fa~j\u00bct\u0093\u00e0?\u000f-\u00b2\u009d\u00ef\u00a7'\u00c0v\u0093\u0018\u0004V\u00ce-@\u001a\u0004V\u000e-\u00b2\u00ff?@5^\u00baIL'\u00c0Zd;\u00dfO\u00cd-@\u0003+\u0087\u0016\u00d9\u00ce\u00e7?\u0083\u00c0\u00ca\u00a1E6$\u00c0'1\b\u00ac\u001c\u001a,@gffff\u00e6\u0017@\u00d9\u00ce\u00f7S\u00e3%\u0017\u00c0\u00ecQ\u00b8\u001e\u0085k*@\f\u0002+\u0087\u0016Y\u0016@\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd\u0018\u00c0\u00b5\u00c8v\u00be\u009f\u009a,@\u00aeG\u00e1z\u0014\u00ae\u001d@v\u0093\u0018\u0004V\u008e\u0016\u00c0r=\n\u00d7\u00a3\u00b0.@P\u008d\u0097n\u0012\u0083\u001e@\u001b/\u00dd$\u0006\u0081\u0017\u00c0@5^\u00baI\f,@w\u00be\u009f\u001a/]\u001f@\u00dfO\u008d\u0097n\u0092\u0010\u00c0\u00a7\u009b\u00c4 \u00b0\u00b2*@F\u00b6\u00f3\u00fd\u00d4x @\u00b4\u00c8v\u00be\u009f\u009a\u001a\u00c0M7\u0089A`\u00a5(@33333\u00b3\u001f@\u008cl\u00e7\u00fb\u00a9\u00f1\u0019\u00c0r=\n\u00d7\u00a3\u00f0*@\u0091\u00ed|?5\u009e\"@\u001c/\u00dd$\u0006\u0001\u001a\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u008d-@R\u00b8\u001e\u0085\u00ebQ!@X9\u00b4\u00c8v\u00be\f\u00c0h\u0091\u00ed|?\u00b5+@\u00b4\u00c8v\u00be\u009f\u001a @1\b\u00ac\u001cZ$ \u00c0v\u0093\u0018\u0004V\u000e*@\u0083\u00c0\u00ca\u00a1E\u00b6\u001d@z\u00e9&1\b\u00ec!\u00c0n\u00e7\u00fb\u00a9\u00f1\u0092*@1\b\u00ac\u001cZd\u001d@\u00e1z\u0014\u00aeG\u00e1#\u00c0M7\u0089A`e(@\u001a\u0004V\u000e-2\u001c@\u001dZd;\u00df\u000f!\u00c05^\u00baI\f\u0002.@%\u0006\u0081\u0095C\u008b @\u00ee|?5^\u00ba \u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2)@<\u00dfO\u008d\u0097n\u001d@\u00a3E\u00b6\u00f3\u00fd\u00d4\f\u00c0\u0082\u0095C\u008bl\u00e7(@D\u008bl\u00e7\u00fb\u00a9\u001a@\u00f4\u00fd\u00d4x\u00e9\u00a6\u0010\u00c0\u001c/\u00dd$\u0006A)@\u001eZd;\u00df\u00cf\u001d@\u001f\u0085\u00ebQ\u00b8\u001e\u0001\u00c0i\u0091\u00ed|?\u00b5)@D\u008bl\u00e7\u00fb\u00e9 @\u00fa~j\u00bct\u0093\u00fc\u00bf\u0094\u0018\u0004V\u000e\u00ed*@\u00ff\u00d4x\u00e9&\u00b1\u0019@\u00b4\u00c8v\u00be\u009f\u001a\u00f5\u00bfP\u008d\u0097n\u0012C&@\n\u00d7\u00a3p=\n\u001d@\u00d5x\u00e9&1\b\u00fe\u00bfP\u008d\u0097n\u0012\u00c3%@\u00aa\u00f1\u00d2Mb\u0010\u001d@\u00edQ\u00b8\u001e\u0085\u00eb\u00e9\u00bf\u00dfO\u008d\u0097n\u0012&@\u00ea&1\b\u00ac\u001c\u0019@\u0019\u0004V\u000e-\u00b2\u0002\u00c0Q\u008d\u0097n\u0012C*@\u00c1\u00ca\u00a1E\u00b6s\u0018@K\f\u0002+\u0087\u0016\u00c9\u00bf\u0097C\u008bl\u00e7{$@}?5^\u00ba\u0089 @\u0090\u00c2\u00f5(\\\u008f\u0004\u00c0\u00a0\u001a/\u00dd$\u0006$@\u00e4\u00a5\u009b\u00c4 \u00b0 @\u00ea&1\b\u00ac\u001c\u000f\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2$@\u00b2\u009d\u00ef\u00a7\u00c6K\u001f@\u00db\u00f9~j\u00bc\u00f4\u0012\u00c0\u00d1\"\u00db\u00f9~\u00ea\"@'1\b\u00ac\u001cZ\"@\u00a9\u00c6K7\u0089A\u00fe\u00bf?5^\u00baI\u00cc\"@\u00db\u00f9~j\u00bc\u00b4\"@\u00fa~j\u00bct\u0093\u00ec\u00bf\u008e\u0097n\u0012\u0083@!@\b\u00ac\u001cZd;#@\u00afG\u00e1z\u0014\u00ae\u0006\u00c0\u0081\u0095C\u008blg\u001f@\u00f2\u00d2Mb\u0010\u0098$@\u00aa\u00f1\u00d2Mb\u0010\u0004\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2!@\u0096C\u008bl\u00e7{\"@\u00cd\u00cc\u00cc\u00cc\u00ccL\u0010\u00c0\u0011X9\u00b4\u00c86-@|\u0014\u00aeG\u00e1z\u0017@\u0012\u0083\u00c0\u00ca\u00a1E\u00fc\u00bf\u00a5p=\n\u00d7\u00e3-@\u009b\u0099\u0099\u0099\u0099\u0099\u0018@\u00db\u00f9~j\u00bct\u0005\u00c0`\u00e5\u00d0\"\u00dby.@\u00be\u009f\u001a/\u00dd$\u0013@\u00b5\u00c8v\u00be\u009f\u001a\u00ef\u00bf\u00d2\"\u00db\u00f9~*-@P\u008d\u0097n\u0012\u0083\u000f@\u00cb\u00a1E\u00b6\u00f3\u00fd\u00e8\u00bf\u00c9v\u00be\u009f\u001a\u00af/@\u00cav\u00be\u009f\u001a/\u0015@\u0080j\u00bct\u0093\u0018\u00d4?\u00c3\u00f5(\\\u008fb0@^\u00baI\f\u0002\u00ab\u0010@,\u0087\u0016\u00d9\u00ce\u00f7\u00fd\u00bf\u00c1\u00ca\u00a1E\u00b6\u00f3/@\u00cav\u00be\u009f\u001a/\u000f@\u00b8\u001e\u0085\u00ebQ\u00b8\u0006\u00c0\u0014\u00aeG\u00e1z\u00141@\u008bl\u00e7\u00fb\u00a9\u00f1\u0013@q=\n\u00d7\u00a3p\u0000\u00c0\u00afG\u00e1z\u0014./@X9\u00b4\u00c8v>\u0012@\u00dd$\u0006\u0081\u0095C\u00f5?p\u0012\u0083\u00c0\u00ca\u00011@\u00aeG\u00e1z\u0014\u00ae\u0007@\u00b6\u00f3\u00fd\u00d4x\u00e9\u00f2\u00bffffff&0@\u00b8\u001e\u0085\u00ebQ\u00b8\u0003@\b\u00ac\u001cZd;\u00e7\u00bf\u0081\u0095C\u008bl\u00a71@\u009d\u00c4 \u00b0rh\t@sh\u0091\u00ed|?\u00d5\u00bf\u00d7\u00a3p=\n\u00971@\u00f4\u00fd\u00d4x\u00e9&\u0000@y\u00e9&1\b\u00ac\u0001\u00c0F\u00b6\u00f3\u00fd\u00d4\u00f80@b\u0010X9\u00b4\u00c8\u00f0?\u0096C\u008bl\u00e7\u00fb\u0004\u00c0F\u00b6\u00f3\u00fd\u00d4\u00b82@\u00be\u009f\u001a/\u00dd$\u0002@\u0004V\u000e-\u00b2\u009d\u0005\u00c0\u000e-\u00b2\u009d\u00ef\u00870@\u009c\u00c4 \u00b0r\u00e8\u0019@\u00e8\u00fb\u00a9\u00f1\u00d2M\u00d2?-\u00b2\u009d\u00ef\u00a7\u00860@\u0088\u0016\u00d9\u00ce\u00f7S\u001c@(1\b\u00ac\u001cZ\u00e0\u00bf\u00ecQ\u00b8\u001e\u0085+1@\r\u0002+\u0087\u0016\u00d9\u001b@B`\u00e5\u00d0\"\u00db\u00f7?\u00d4Mb\u0010X\u00b91@7\u0089A`\u00e5P\u0018@\u00b6\u00f3\u00fd\u00d4x\u00e9\u00fc?B`\u00e5\u00d0\"\u001b0@\u00d5x\u00e9&1\b\u001e@!\u00b0rh\u0091\u00ed\u0003@\u0087\u0016\u00d9\u00ce\u00f7\u00132@\u00a0\u001a/\u00dd$F @u\u0093\u0018\u0004V\u000e\u00f1?\f\u0002+\u0087\u0016y1@\u00f4\u00fd\u00d4x\u00e9\u00e6!@\u00cav\u00be\u009f\u001a/\u00e5?\u007fj\u00bct\u0093X0@\u00d5x\u00e9&1\b\u001e@d;\u00dfO\u008d\u0097\r@\u0012\u0083\u00c0\u00ca\u00a1\u00e52@\u00a8\u00c6K7\u0089A!@\u00ecQ\u00b8\u001e\u0085\u00eb\u0001@\u00a6\u009b\u00c4 \u00b0\u00923@\u00a9\u00c6K7\u0089A\u001f@\b\u00ac\u001cZd;\u0004@\u00dd$\u0006\u0081\u0095#2@\u00be\u009f\u001a/\u00dd\u00e4!@/\u00dd$\u0006\u0081\u0095\u0007@\u00dd$\u0006\u0081\u0095\u00a33@.\u00b2\u009d\u00ef\u00a7\u00c6\"@\u00aeG\u00e1z\u0014\u00ae\u00ff?\n\u00d7\u00a3p=\n3@\u0000\u0000\u0000\u0000\u0000\u0000\u001f@Y9\u00b4\u00c8v\u00be\u00af?\u00f0\u00a7\u00c6K7\u00892@(1\b\u00ac\u001c\u00da\u001e@\u0003+\u0087\u0016\u00d9\u00ce\u00e7\u00bfgffff\u00e6-@\u00bdt\u0093\u0018\u0004\u00d6\u001f@\t\u00ac\u001cZd;\u00ff?T\u00e3\u00a5\u009b\u00c4\u00e0-@&\u0006\u0081\u0095C\u008b\u001f@\u00bf\u009f\u001a/\u00dd$\u00ee?\u00bct\u0093\u0018\u0004\u0096+@\u00a6\u009b\u00c4 \u00b0\u00b2 @\u0098n\u0012\u0083\u00c0\u00ca\u0005@\u00e8\u00fb\u00a9\u00f1\u00d2M,@Nb\u0010X94\"@\u009c\u00c4 \u00b0rh\u000b@th\u0091\u00ed|?*@\u0086\u00ebQ\u00b8\u001e\u0005\u001d@\u00a3E\u00b6\u00f3\u00fd\u00d4\f@Zd;\u00dfO\u00cd)@d;\u00dfO\u008d\u0017\"@\u001eZd;\u00dfO\u00fb?h\u0091\u00ed|?5)@\u001dZd;\u00df\u00cf @(1\b\u00ac\u001cZ\u00ec?q=\n\u00d7\u00a3\u00f0'@\u00d1\"\u00db\u00f9~\u00aa\"@p\u0012\u0083\u00c0\u00ca\u00a1\u0001@\u00b7\u00f3\u00fd\u00d4x\u00e9*@\u009e\u00ef\u00a7\u00c6K\u00b7#@\u00c1\u00ca\u00a1E\u00b6\u00f3\u00f3?x\u00be\u009f\u001a/\u009d)@\u000e-\u00b2\u009d\u00ef'\u001d@H\u00e1z\u0014\u00aeG\u0013@\u0096C\u008bl\u00e7\u00fb)@\u00e2z\u0014\u00aeGa\u0018@Nb\u0010X9\u00b4\u0007@\u009a\u0099\u0099\u0099\u0099Y*@D\u008bl\u00e7\u00fb)\u0018@[d;\u00dfO\u008d\u00ff?\"\u00b0rh\u0091\u00ed(@7\u0089A`\u00e5P\u0013@p\u0012\u0083\u00c0\u00ca\u00a1\u000b@ \u0085\u00ebQ\u00b8\u001e'@\u00b6\u00f3\u00fd\u00d4x\u00e9\u0013@433333\u0010@|\u0014\u00aeG\u00e1\u00fa*@\u008f\u00c2\u00f5(\\\u008f\u0010@\u00f6(\\\u008f\u00c2u\u0011@~?5^\u00baI(@\u0092\u00ed|?5^\u000f@m\u00e7\u00fb\u00a9\u00f1\u00d2\u0001@\u0019\u0004V\u000e-\u00f2)@\\\u008f\u00c2\u00f5(\\\u000e@<\u00dfO\u008d\u0097n\u00f8?\u00f7(\\\u008f\u00c2\u00f5'@/\u00dd$\u0006\u0081\u0095\u0007@\u00aeG\u00e1z\u0014\u00ae\u0005@\u00fa~j\u00bctS*@F\u00b6\u00f3\u00fd\u00d4x\u000e@\u00baI\f\u0002+\u0007\u0016@\u0006\u0081\u0095C\u008b\u00ec%@ffffff\u0011@\u0006\u0081\u0095C\u008bl\u00f5?\u0003+\u0087\u0016\u00d9\u000e$@{\u0014\u00aeG\u00e1z\u0015@\u0097C\u008bl\u00e7\u00fb\u00fb?P\u008d\u0097n\u0012C$@7\u0089A`\u00e5P\u0017@b\u0010X9\u00b4\u00c8\u0005@\u0017\u00d9\u00ce\u00f7Sc%@\u00c9v\u00be\u009f\u001a/\r@`\u00e5\u00d0\"\u00db\u00f9\u00be?\r\u0002+\u0087\u0016\u00d9&@\u00dfO\u008d\u0097n\u0012\u0007@\u00c3\u00f5(\\\u008f\u00c2\u00b5\u00bf\u00c9v\u00be\u009f\u001a\u00af!@X9\u00b4\u00c8v>\u0016@\u0011X9\u00b4\u00c8v\u00ee?\u0014\u00aeG\u00e1zT @\u00b9\u001e\u0085\u00ebQ8\u0019@[d;\u00dfO\u008d\u00f5??5^\u00baIL#@\u00c4\u00f5(\\\u008fB\u0010@/\u00dd$\u0006\u0081\u0095\u00e7\u00bf\u0000\u0000\u0000\u0000\u0000\u0000#@\u00a8\u00c6K7\u0089A\f@&\u0006\u0081\u0095C\u008b\u00fa\u00bf\u00e7\u00fb\u00a9\u00f1\u00d2\u008d!@\u00b2\u009d\u00ef\u00a7\u00c6K\u0014@\\\u008f\u00c2\u00f5(\\\u00d7\u00bf\u00ef|?5^\u00ba\u001f@\u009f\u00ef\u00a7\u00c6K7\u0015@+\u0087\u0016\u00d9\u00ce\u00f7\u00ef\u00bfH\u00e1z\u0014\u00ae\u0087-@\u00d5x\u00e9&1\u0088\u0010@\u0000\u0000\u0000\u0000\u0000\u0000\u0010@\u00d4Mb\u0010X\u00f9-@\u00bct\u0093\u0018\u0004V\u0011@\u00e8\u00fb\u00a9\u00f1\u00d2M\b@\u0001\u0000\u0000\u0000\u0000\u00c0/@\u00b8\u001e\u0085\u00ebQ\u00b8\r@$\u00db\u00f9~j\u00bc\u0013@K\f\u0002+\u0087V/@\u00baI\f\u0002+\u0087\u0005@\u00f6(\\\u008f\u00c2\u00f5\u0014@\u00b8\u001e\u0085\u00ebQ\u00f8/@\u00fc\u00a9\u00f1\u00d2M\u00e2\u0011@\u0090\u00c2\u00f5(\\\u000f\u0019@9\u00b4\u00c8v\u00be\u001f1@\u00f2\u00d2Mb\u0010X\r@\u0000\u0000\u0000\u0000\u0000\u0080\u0010@Zd;\u00dfO\u00ed0@\u00c7K7\u0089A`\b@\u00a0\u001a/\u00dd$\u0006\n@\u00a0\u001a/\u00dd$F1@V\u000e-\u00b2\u009d\u00ef\u0012@\u00e4\u00a5\u009b\u00c4 \u00b0\u000f@\u0091\u00ed|?5\u00de/@)\\\u008f\u00c2\u00f5(\u000e@\u00a4p=\n\u00d7#\u001d@\u00baI\f\u0002+G2@\u001b/\u00dd$\u0006\u0081\u0007@\u00b8\u001e\u0085\u00ebQ\u00b8\u0013@\u00dd$\u0006\u0081\u0095\u00e31@\u0006\u0081\u0095C\u008bl\u0001@\u00edQ\u00b8\u001e\u0085k\u0016@h\u0091\u00ed|?\u00f52@\u00c6 \u00b0rh\u0091\u0003@+\u0087\u0016\u00d9\u00ce\u00f7\u0010@!\u00b0rh\u0091-3@\u008e\u0097n\u0012\u0083\u00c0\u000e@\u00a3E\u00b6\u00f3\u00fd\u00d4\u0016@\u00d1\"\u00db\u00f9~*4@sh\u0091\u00ed|?\u000b@x\u00be\u009f\u001a/]\u0019@\u0093\u0018\u0004V\u000e\u00cd4@\u00d0\u00f7S\u00e3\u00a5\u001b\u0010@.\u00b2\u009d\u00ef\u00a7F\u001b@X9\u00b4\u00c8v^4@\u00bct\u0093\u0018\u0004V\u0003@\u00e6\u00d0\"\u00db\u00f9\u00fe\u0018@\u00f6(\\\u008f\u00c2\u00f52@T\u00e3\u00a5\u009b\u00c4 \u0014@\u00c6 \u00b0rh\u0011\u0017@\u008bl\u00e7\u00fb\u00a9\u00f1/@!\u00b0rh\u0091m\u0017@U\u00e3\u00a5\u009b\u00c4 \u0019@M7\u0089A`\u00e5/@\u00b4\u00c8v\u00be\u009f\u009a\u0019@X9\u00b4\u00c8v\u00be\u0015@\u00baI\f\u0002+\u00c7/@\u00b2\u009d\u00ef\u00a7\u00c6K\u001a@R\u00b8\u001e\u0085\u00ebQ\u001e@u\u0093\u0018\u0004V\u00ce0@\u00b5\u00c8v\u00be\u009f\u001a\u001a@\u00f2\u00d2Mb\u0010X @\u00c6 \u00b0rh\u0091/@\u00b0rh\u0091\u00ed|\u001e@\u001eZd;\u00dfO\u001d@Zd;\u00dfO\u008d-@\u00f0\u00a7\u00c6K7\u0089\u0018@1\b\u00ac\u001cZ\u00e4 @)\\\u008f\u00c2\u00f5(.@\u0014\u00aeG\u00e1z\u0014\u0017@V\u000e-\u00b2\u009d/#@]\u008f\u00c2\u00f5(\u001c+@\u0089A`\u00e5\u00d0\u00a2\u0017@\u00c9v\u00be\u009f\u001a\u00af\u001f@\u00c3\u00f5(\\\u008f\u00c2*@\b\u00ac\u001cZd;\u0018@>\n\u00d7\u00a3p\u00bd\u001b@\u00a8\u00c6K7\u0089\u00c1(@=\n\u00d7\u00a3p=\u0016@\u00f8S\u00e3\u00a5\u009b\u0084!@\u0007\u0081\u0095C\u008b,(@\u0004V\u000e-\u00b2\u001d\u0019@\u00baI\f\u0002+\u0007#@\"\u00b0rh\u0091-)@\u00c3\u00f5(\\\u008f\u00c2\u0010@!\u00b0rh\u0091\u00ad\"@\u00e6\u00d0\"\u00db\u00f9~&@\u0019\u0004V\u000e-\u00b2\u0016@\u00d4Mb\u0010X9\u001f@\u00fe\u00d4x\u00e9&\u00b1&@H\u00e1z\u0014\u00ae\u00c7\u0013@{\u0014\u00aeG\u00e1\u00fa\u001b@\u0003+\u0087\u0016\u00d9\u008e&@\u009a\u0099\u0099\u0099\u0099\u0099\u001a@\f\u0002+\u0087\u0016Y\u001d@\u008cl\u00e7\u00fb\u00a9\u00f1(@e;\u00dfO\u008d\u0097\u000f@\u00c4\u00f5(\\\u008f\u0002%@+\u0087\u0016\u00d9\u00ce\u00b7#@;\u00dfO\u008d\u0097n\u0015@\u00baI\f\u0002+\u00c7 @\u00e1z\u0014\u00aeG\u00e1#@\u00f6(\\\u008f\u00c2u\u0011@^\u00baI\f\u0002\u00ab!@\u00a8\u00c6K7\u0089A\"@P\u008d\u0097n\u0012\u0083\u0015@\u00d8\u00a3p=\nW\u001e@X9\u00b4\u00c8v\u00be\"@\u00a5p=\n\u00d7#\u001a@\u00a0\u001a/\u00dd$\u0086#@m\u00e7\u00fb\u00a9\u00f1\u0092!@\u0091\u00ed|?5\u00de\u001f@\u00cf\u00f7S\u00e3\u00a5\u009b!@;\u00dfO\u008d\u0097n!@\u0098n\u0012\u0083\u00c0\u008a!@\u008f\u00c2\u00f5(\\\u000f#@-\u00b2\u009d\u00ef\u00a7\u0006#@\u00a4p=\n\u00d7c @%\u0006\u0081\u0095C\u000b @Zd;\u00dfO\r\u001f@\u009a\u0099\u0099\u0099\u0099\u0019\u001f@33333\u00f3 @\u00f4\u00fd\u00d4x\u00e9\u00e6)@\u001a\u0004V\u000e-\u00b2\t@\u00e9&1\b\u00ac\u001c!@\u001dZd;\u00dfO*@\u00e7\u00fb\u00a9\u00f1\u00d2M\u000b@\u00c8K7\u0089A`\u001e@\u00c8K7\u0089A\u00a0*@u\u0093\u0018\u0004V\u000e\u00fd?b\u0010X9\u00b4\b\"@\u00c2\u00ca\u00a1E\u00b6\u00f3(@\u000e-\u00b2\u009d\u00ef\u00a7\u00f6?V\u000e-\u00b2\u009d/#@<\u00dfO\u008d\u0097\u00ee,@C`\u00e5\u00d0\"\u00db\u00fb?9\u00b4\u00c8v\u00be\u001f$@\u0011X9\u00b4\u00c8\u00f6*@\u00b8\u001e\u0085\u00ebQ\u00b8\u00ee?\u00bdt\u0093\u0018\u0004\u00d6\u001e@~?5^\u00baI)@,\u0087\u0016\u00d9\u00ce\u00f7\u00eb?\u00c6 \u00b0rh\u0011\u001c@\u00cav\u00be\u009f\u001a\u00af,@\u00d9\u00ce\u00f7S\u00e3\u00a5\u00f5?\u0004V\u000e-\u00b2\u009d\u001c@Nb\u0010X9\u00b4,@)\\\u008f\u00c2\u00f5(\u00f2?\u00b2\u009d\u00ef\u00a7\u00c6K&@\u00fb~j\u00bct\u00d3+@\u00fc\u00a9\u00f1\u00d2Mb\u00e0\u00bfP\u008d\u0097n\u0012\u0003 @\u0088\u0016\u00d9\u00ce\u00f7\u0093-@\u00e0O\u008d\u0097n\u0012\u00db\u00bfZd;\u00dfOM!@\u000e-\u00b2\u009d\u00ef\u00a7)@433333\u00f5\u00bf\u0098n\u0012\u0083\u00c0J!@\u00ecQ\u00b8\u001e\u0085k)@\u0004V\u000e-\u00b2\u009d\u00ef\u00bf \u0085\u00ebQ\u00b8^#@k\u00bct\u0093\u0018\u0084*@\u00baI\f\u0002+\u0087\u0002\u00c05^\u00baI\f\u0082!@\u00c5 \u00b0rh\u00d1'@\u00d9\u00ce\u00f7S\u00e3\u00a5\u00f3\u00bf\u0089A`\u00e5\u00d0\" @b\u0010X9\u00b4\u00c8,@R\u00b8\u001e\u0085\u00ebQ\u00f2\u00bf\u00b4\u00c8v\u00be\u009f\u009a\u001a@i\u0091\u00ed|?u-@\u001eZd;\u00dfO\u0001\u00c0\u00db\u00f9~j\u00bct\u001b@\u0083\u00c0\u00ca\u00a1E6+@\u00a4p=\n\u00d7\u00a3\u00f2\u00bf\u0004V\u000e-\u00b2\u009d\u0017@\u00ecQ\u00b8\u001e\u0085+.@\u0011X9\u00b4\u00c8v\u00de\u00bfd;\u00dfO\u008d\u0097\u0018@h\u0091\u00ed|?5/@9\u00b4\u00c8v\u00be\u009f\u0003@\u00cb\u00a1E\u00b6\u00f3\u00bd#@\u00cb\u00a1E\u00b6\u00f3=/@\u00ecQ\u00b8\u001e\u0085\u00eb\u0007@\u00b2\u009d\u00ef\u00a7\u00c6\u000b\"@\u00db\u00f9~j\u00bc\u00b40@\u00cb\u00a1E\u00b6\u00f3\u00fd\u0003@\u009e\u00ef\u00a7\u00c6K\u00b7%@\u0087\u0016\u00d9\u00ce\u00f7\u00f30@\u0001\u0000\u0000\u0000\u0000\u0000\u00f8?\u008cl\u00e7\u00fb\u00a9q&@}?5^\u00baI0@\u00ef|?5^\u00ba\t@\u0097C\u008bl\u00e7;(@}?5^\u00ba\u00e91@.\u00b2\u009d\u00ef\u00a7\u00c6\b@2\b\u00ac\u001cZd$@}?5^\u00ba\u00c92@\u0093\u0018\u0004V\u000e-\n@\u0017\u00d9\u00ce\u00f7S\u00a3%@\u00bct\u0093\u0018\u0004\u00961@\u0098n\u0012\u0083\u00c0\u00ca\u000f@b\u0010X9\u00b4H#@\u0084\u00c0\u00ca\u00a1E\u00f60@\u001b/\u00dd$\u0006\u0081\u0007@\u00d5x\u00e9&1H*@\u00bct\u0093\u0018\u0004V2@\u00a8\u00c6K7\u0089A\u0001@\u00d8\u00a3p=\n\u0017\"@\u0012\u0083\u00c0\u00ca\u00a1\u00851@\u009c\u00c4 \u00b0rh\u0000@\u00f4\u00fd\u00d4x\u00e9\u00a6 @\u00ac\u001cZd;\u001f3@V\u000e-\u00b2\u009d\u00ef\u0005@\u0081\u0095C\u008bl'!@\u00c1\u00ca\u00a1E\u00b6\u00d32@\u0089A`\u00e5\u00d0\"\u00eb?8\u0089A`\u00e5\u0010#@\u00b4\u00c8v\u00be\u009f\u00fa1@\\\u008f\u00c2\u00f5(\\\u00cf?`\u00e5\u00d0\"\u00db\u00b9#@\u00dfO\u008d\u0097n\u00923@\u008f\u00c2\u00f5(\\\u008f\u00f0?\u0091\u00ed|?5\u009e$@~?5^\u00ba\u00893@\u00a8\u00c6K7\u0089A\u00c0?7\u0089A`\u00e5\u00d0 @<\u00dfO\u008d\u0097n4@j\u00bct\u0093\u0018\u0004\u00de?\u00aeG\u00e1z\u0014. @X9\u00b4\u00c8v\u00de1@/\u00dd$\u0006\u0081\u0095\u00f5\u00bffffff& @.\u00b2\u009d\u00ef\u00a7\u00861@`\u00e5\u00d0\"\u00db\u00f9\u0000\u00c0\u0004V\u000e-\u00b2\u001d\u001e@Zd;\u00dfOm1@L7\u0089A`\u00e5\u00f0\u00bfT\u00e3\u00a5\u009b\u00c4\u00e0!@+\u0087\u0016\u00d9\u00ce\u00b73@\u0012\u0083\u00c0\u00ca\u00a1E\u00f8\u00bf\u00e7\u00fb\u00a9\u00f1\u00d2M\u001b@\u00e6\u00d0\"\u00db\u00f9\u009e4@\u00fc\u00a9\u00f1\u00d2Mb\u00f2\u00bfNb\u0010X94\u001a@\u00e5\u00d0\"\u00db\u00f9~3@\u0002+\u0087\u0016\u00d9\u00ce\u0003\u00c0\u0003+\u0087\u0016\u00d9N\u001a@\u00b6\u00f3\u00fd\u00d4x\t3@\u00d1\"\u00db\u00f9~j\u00ec\u00bf\u00d0\u00f7S\u00e3\u00a5\u001b\u001f@0\u00dd$\u0006\u0081\u0095.@\u00a2E\u00b6\u00f3\u00fdT\u0010@\u00fc\u00a9\u00f1\u00d2M\"(@Zd;\u00dfO\u008d-@\u00a8\u00c6K7\u0089\u00c1\u0010@\u00f4\u00fd\u00d4x\u00e9f&@=\n\u00d7\u00a3p}-@`\u00e5\u00d0\"\u00db\u00f9\u0012@\u00a4p=\n\u00d7c*@>\n\u00d7\u00a3p\u00fd.@`\u00e5\u00d0\"\u00dby\u0014@\u00baI\f\u0002+\u00c7+@5^\u00baI\f\u0082+@\u00b2\u009d\u00ef\u00a7\u00c6K\u000f@\u0085\u00ebQ\u00b8\u001e\u0005,@\u001a\u0004V\u000e-2,@\u00b3\u009d\u00ef\u00a7\u00c6K\u0018@\u00aa\u00f1\u00d2Mb\u0090)@\u00fe\u00d4x\u00e9&\u00b1*@\u009a\u0099\u0099\u0099\u0099\u0099\u0017@\u0098n\u0012\u0083\u00c0\n(@8\u0089A`\u00e5\u00d0-@\u00f8S\u00e3\u00a5\u009b\u00c4\u001a@\u00f0\u00a7\u00c6K7\u00c9(@\u00a9\u00c6K7\u0089\u0081+@`\u00e5\u00d0\"\u00db\u00f9\u000f@6^\u00baI\f\u0082.@\u0012\u0083\u00c0\u00ca\u00a1\u00c5*@\u00ea&1\b\u00ac\u009c\u001b@th\u0091\u00ed|\u00bf+@8\u0089A`\u00e5P)@8\u0089A`\u00e5P\u0019@9\u00b4\u00c8v\u00be\u00df,@@5^\u00baIL,@\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u001c@r=\n\u00d7\u00a30-@\u00ecQ\u00b8\u001e\u0085\u00ab)@\u00e9&1\b\u00ac\\ @\u001a\u0004V\u000e-r*@ \u0085\u00ebQ\u00b8\u001e(@\u00ecQ\u00b8\u001e\u0085k\u001f@8\u0089A`\u00e5\u0010)@\u0094\u0018\u0004V\u000e-+@P\u008d\u0097n\u0012C!@\u00d2\"\u00db\u00f9~*)@G\u00b6\u00f3\u00fd\u00d4x(@\u00c1\u00ca\u00a1E\u00b63\"@G\u00b6\u00f3\u00fd\u00d4x,@\u009d\u00c4 \u00b0r\u00e8&@D\u008bl\u00e7\u00fb)!@\u007fj\u00bct\u0093\u0098-@\u007fj\u00bct\u0093X'@\u00ee|?5^\u00ba#@^\u00baI\f\u0002k+@\u00f1\u00a7\u00c6K7\u0089*@\u00c3\u00f5(\\\u008f\u0082#@\u00bct\u0093\u0018\u0004\u0016.@\u0005V\u000e-\u00b2\u009d)@*\\\u008f\u00c2\u00f5\u00e8$@\u00cb\u00a1E\u00b6\u00f3=/@\u00fa~j\u00bct\u0093+@\u00a8\u00c6K7\u0089A\"@&\u0006\u0081\u0095CK/@\u00b9\u001e\u0085\u00ebQ\u00b8+@9\u00b4\u00c8v\u00be\u009f$@L7\u0089A`\u00e5,@\u00d2\"\u00db\u00f9~\u00aa)@0\u00dd$\u0006\u0081\u0095\n@\u00baI\f\u0002+\u0087*@=\n\u00d7\u00a3p\u00bd)@\u00fc\u00a9\u00f1\u00d2Mb\f@\u00e8\u00fb\u00a9\u00f1\u00d2\u008d(@\u0019\u0004V\u000e-r'@\n\u00d7\u00a3p=\n\u0004@gffff\u00a6+@\u0007\u0081\u0095C\u008b\u00ec&@\u00b2\u009d\u00ef\u00a7\u00c6K\u0007@\u00b4\u00c8v\u00be\u009f\u009a-@\u0006\u0081\u0095C\u008b\u00ec'@\u00fe\u00d4x\u00e9&1\u00f0?S\u00b8\u001e\u0085\u00ebQ,@*\\\u008f\u00c2\u00f5\u00e8$@\u00cf\u00f7S\u00e3\u00a5\u009b\u0004@\u0083\u00c0\u00ca\u00a1E\u00f6)@\u00aeG\u00e1z\u0014.%@\u00aeG\u00e1z\u0014\u00ae\u0001@\u00c9v\u00be\u009f\u001a\u00ef'@\u00ecQ\u00b8\u001e\u0085k#@\u00cav\u00be\u009f\u001a/\u00ff?_\u00baI\f\u0002\u00eb*@\f\u0002+\u0087\u0016\u0099&@\u000e-\u00b2\u009d\u00ef\u00a7\u00de?Nb\u0010X9\u00f4-@H\u00e1z\u0014\u00ae\u00c7#@Y9\u00b4\u00c8v\u00be\u000f@\u0006\u0081\u0095C\u008b\u00ac)@\u0093\u0018\u0004V\u000e-%@\u0017\u00d9\u00ce\u00f7Sc\u0012@\u00c6 \u00b0rh\u0091(@{\u0014\u00aeG\u00e1\u00fa @v\u0093\u0018\u0004V\u000e\u000e@\u0006\u0081\u0095C\u008bl(@\u0098n\u0012\u0083\u00c0J @\u001c/\u00dd$\u0006\u0001\u0013@8\u0089A`\u00e5\u00d0'@\u0000\u0000\u0000\u0000\u0000\u0000\u001f@\u00a2E\u00b6\u00f3\u00fd\u00d4\n@\u00a2E\u00b6\u00f3\u00fd\u00d4)@-\u00b2\u009d\u00ef\u00a7\u0006!@\u00e6\u00d0\"\u00db\u00f9~\b@\u00a9\u00c6K7\u0089\u00c1&@\u0000\u0000\u0000\u0000\u0000\u0080#@;\u00dfO\u008d\u0097n\u0012@\u001c/\u00dd$\u0006\u0081,@\u00b8\u001e\u0085\u00ebQx%@sh\u0091\u00ed|\u00bf\u0012@\u00ecQ\u00b8\u001e\u0085k-@\u0017\u00d9\u00ce\u00f7Sc\"@!\u00b0rh\u0091\u00ed\u000f@\u000f-\u00b2\u009d\u00ef\u00e7-@o\u0012\u0083\u00c0\u00ca\u00a1\"@\u009c\u00c4 \u00b0rh\u0016@i\u0091\u00ed|?u,@\u00f9S\u00e3\u00a5\u009b\u0004*@ \u0085\u00ebQ\u00b8\u001e\u00dd?1\b\u00ac\u001cZ$+@$\u00db\u00f9~j\u00fc*@\u00e2z\u0014\u00aeG\u00e1\u00ee?<\u00dfO\u008d\u0097\u00ae)@\u00dd$\u0006\u0081\u0095C+@433333\u00eb\u00bfP\u008d\u0097n\u0012\u00c3+@\u00f8S\u00e3\u00a5\u009b\u00c4,@}?5^\u00baI\u00f0\u00bf,\u0087\u0016\u00d9\u00ce7*@\u0093\u0018\u0004V\u000e-)@1\b\u00ac\u001cZd\u0000\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2+@\u00fa~j\u00bct\u00d3,@\u0081\u0095C\u008bl\u00e7\u00e7\u00bf'1\b\u00ac\u001cZ.@@5^\u00baI\u00cc-@\u0019\u0004V\u000e-\u00b2\u00cd?&\u0006\u0081\u0095C\u008b.@\u0087\u0016\u00d9\u00ce\u00f7\u0093+@\u00d8\u00a3p=\n\u00d7\u00eb\u00bf\u001eZd;\u00df\u000f0@_\u00baI\f\u0002+(@\u00d7\u00a3p=\n\u00d7\u0003\u00c0\u0083\u00c0\u00ca\u00a1E\u00f6-@\u00b2\u009d\u00ef\u00a7\u00c6\u000b/@\u00a0\u001a/\u00dd$\u0006\u00fd\u00bf\u00ef|?5^\u00ba.@-\u00b2\u009d\u00ef\u00a7\u0086/@\u00a6\u009b\u00c4 \u00b0r\u0005\u00c0\u00cf\u00f7S\u00e3\u00a5\u001b-@Zd;\u00dfO\r0@d;\u00dfO\u008d\u0097\u00fc\u00bfm\u00e7\u00fb\u00a9\u00f1r0@I\u00e1z\u0014\u00aeG(@%\u0006\u0081\u0095C\u008b\u0003\u00c0\u0081\u0095C\u008blg)@[d;\u00dfOM)@j\u00bct\u0093\u0018\u0004\u0001\u00c0b\u0010X9\u00b4\u00c8'@+\u0087\u0016\u00d9\u00ce7&@\u00e9&1\b\u00ac\u001c\f\u00c0V\u000e-\u00b2\u009d/)@|\u0014\u00aeG\u00e1\u00fa$@\u00fa~j\u00bct\u0093\u000b\u00c0\u0096C\u008bl\u00e7\u00fb*@\u00e7\u00fb\u00a9\u00f1\u00d2\u008d'@%\u0006\u0081\u0095C\u008b\u0013\u00c0-\u00b2\u009d\u00ef\u00a7F)@\u0084\u00c0\u00ca\u00a1Ev$@th\u0091\u00ed|?\n\u00c0w\u00be\u009f\u001a/\u009d&@\u00aa\u00f1\u00d2Mb\u00d0%@\u000e-\u00b2\u009d\u00ef\u00a7\t\u00c0^\u00baI\f\u0002\u00eb$@\u0002+\u0087\u0016\u00d9N)@\u00ecQ\u00b8\u001e\u0085k\u0014\u00c01\b\u00ac\u001cZ\u00a4'@1\b\u00ac\u001cZ\u00e4\"@\u001f\u0085\u00ebQ\u00b8\u001e\u0000\u00c0^\u00baI\f\u0002\u00ab&@\u00fc\u00a9\u00f1\u00d2M\"\"@333333\u00fd\u00bfr=\n\u00d7\u00a3\u00b0(@\u00be\u009f\u001a/\u00dd$!@w\u00be\u009f\u001a/\u00dd\u0001\u00c0^\u00baI\f\u0002k%@u\u0093\u0018\u0004V\u008e\"@\u00a4p=\n\u00d7#\u0012\u00c0\u00db\u00f9~j\u00bct&@\u00be\u009f\u001a/\u00dd$!@\u009a\u0099\u0099\u0099\u0099\u0019\u0012\u00c0\u00ad\u001cZd;\u001f(@\u0000\u0000\u0000\u0000\u0000\u0080!@y\u00e9&1\b,\u0011\u00c0\u00c7K7\u0089A\u00a0$@\u00cd\u00cc\u00cc\u00cc\u00cc\u008c#@P\u008d\u0097n\u0012\u0003\u0016\u00c0v\u0093\u0018\u0004VN&@Nb\u0010X94$@\u0017\u00d9\u00ce\u00f7S\u00e3\u00e5\u00bf\u001dZd;\u00df\u00cf%@\u00cav\u00be\u009f\u001a\u00ef$@S\u00b8\u001e\u0085\u00ebQ\u00e8\u00bfj\u00bct\u0093\u0018\u00c4#@\u0006\u0081\u0095C\u008b\u00ac\"@\u001c/\u00dd$\u0006\u0081\u00b5?\u00a8\u00c6K7\u0089\u0001&@\u00cc\u00a1E\u00b6\u00f3\u00bd%@\u001f\u0085\u00ebQ\u00b8\u001e\u00d5\u00bf!\u00b0rh\u0091-'@\u00baI\f\u0002+\u00c7&@\u00cc\u00a1E\u00b6\u00f3\u00fd\u0016\u00c0\u0005V\u000e-\u00b2\u001d+@\u009d\u00c4 \u00b0r\u00a8%@\u008cl\u00e7\u00fb\u00a9q\u0015\u00c0\u0092\u00ed|?5\u009e,@\u00f5\u00fd\u00d4x\u00e9&'@\u00ac\u001cZd;\u00df\u001c\u00c0\u009c\u00c4 \u00b0r\u00e8*@`\u00e5\u00d0\"\u00db\u00b9'@\u00d0\u00f7S\u00e3\u00a5\u009b\u001d\u00c0\u00bct\u0093\u0018\u0004\u00d6(@\u00d2\"\u00db\u00f9~\u00aa$@`\u00e5\u00d0\"\u00db9 \u00c0\t\u00ac\u001cZd{+@\u00fb~j\u00bct\u0093)@\u0006\u0081\u0095C\u008b\u00ec\u001e\u00c0\u0010X9\u00b4\u00c8\u00b6,@\u0002+\u0087\u0016\u00d9\u00ce)@\u00fc\u00a9\u00f1\u00d2M\u00a2!\u00c0\u0089A`\u00e5\u00d0\u00a2,@Nb\u0010X9\u00f4(@;\u00dfO\u008d\u0097\u00ee\u001d\u00c0sh\u0091\u00ed|\u00bf.@H\u00e1z\u0014\u00ae\u00c7$@\u0019\u0004V\u000e-\u00b2\"\u00c0T\u00e3\u00a5\u009b\u00c4`+@M7\u0089A`e,@1\b\u00ac\u001cZd\u001c\u00c0\u00b0rh\u0091\u00ed\u00fc+@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc,@\\\u008f\u00c2\u00f5(\\\u001d\u00c0\u00f4\u00fd\u00d4x\u00e9\u00e6)@\u00d9\u00ce\u00f7S\u00e3%,@\u00a0\u001a/\u00dd$\u0006\u0018\u00c0\u00ad\u001cZd;\u001f,@\u00d3Mb\u0010Xy.@\u00ecQ\u00b8\u001e\u0085k\u001e\u00c0\u00b0rh\u0091\u00ed\u00fc-@5^\u00baI\f\u00c2-@ffffff\u001e\u00c0\u00d9\u00ce\u00f7S\u00e3\u00050@\u00d0\u00f7S\u00e3\u00a5\u001b/@`\u00e5\u00d0\"\u00db9!\u00c0G\u00b6\u00f3\u00fd\u00d4x-@\u00d1\"\u00db\u00f9~\u008a0@\u0011X9\u00b4\u00c8\u00f6\u001a\u00c043333\u00f3-@h\u0091\u00ed|?51@\u0081\u0095C\u008bl\u00e7\u001c\u00c0\u00e1z\u0014\u00aeGa/@;\u00dfO\u008d\u0097\u000e1@1\b\u00ac\u001cZ\u00e4\u001a\u00c0\u008e\u0097n\u0012\u0083\u0000,@\u0012\u0083\u00c0\u00ca\u00a1E0@;\u00dfO\u008d\u0097n\u0015\u00c0M7\u0089A`\u00e5.@\u0087\u0016\u00d9\u00ce\u00f7S/@\u00da\u00ce\u00f7S\u00e3%\u0015\u00c0o\u0012\u0083\u00c0\u00caA0@\u0083\u00c0\u00ca\u00a1E\u00161@`\u00e5\u00d0\"\u00db\u00f9\u0013\u00c0n\u00e7\u00fb\u00a9\u00f1\u00d2/@\u00f2\u00d2Mb\u0010\u00180@\u0096C\u008bl\u00e7{\u0012\u00c0\u00e0O\u008d\u0097n\u0092-@\u00dc\u00f9~j\u00bct\"@Q\u008d\u0097n\u0012\u0003\u001e\u00c0\u0082\u0095C\u008blg,@\u00baI\f\u0002+\u0087\"@\n\u00d7\u00a3p=\n\u001a\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6,@\u0011X9\u00b4\u00c8\u00f6\u001f@#\u00db\u00f9~j< \u00c0\u00f5\u00fd\u00d4x\u00e9&-@\u00f1\u00a7\u00c6K7\u0089\u001f@j\u00bct\u0093\u0018\u00c4!\u00c0\u0092\u00ed|?5\u009e+@\u00ecQ\u00b8\u001e\u0085\u00eb\u001a@\u00c6 \u00b0rh\u0011\u001d\u00c0\u0099n\u0012\u0083\u00c0\u00ca,@\u00a2E\u00b6\u00f3\u00fd\u0014 @\u0089A`\u00e5\u00d0\u00a2!\u00c0\u00e3\u00a5\u009b\u00c4 \u00f0/@\u00c5 \u00b0rh\u0011\"@\u0093\u0018\u0004V\u000e-\"\u00c0\u00db\u00f9~j\u00bcT0@\u00b9\u001e\u0085\u00ebQ8\u001e@\u0014\u00aeG\u00e1z\u0094#\u00c0\u0085\u00ebQ\u00b8\u001e\u00c5/@\u00b8\u001e\u0085\u00ebQ8\u001b@,\u0087\u0016\u00d9\u00ce\u00f7\u0017\u00c0\u00d4Mb\u0010Xy,@(1\b\u00ac\u001c\u00da\u001d@X9\u00b4\u00c8v> \u00c0\u00cb\u00a1E\u00b6\u00f3\u001d1@\u00e8\u00fb\u00a9\u00f1\u00d2\u00cd\u001f@\u00fc\u00a9\u00f1\u00d2M\u00e2\u001b\u00c0sh\u0091\u00ed|\u007f1@T\u00e3\u00a5\u009b\u00c4 !@\"\u00b0rh\u0091\u00ed\u0019\u00c0\u00ee|?5^\u00da0@\u00f0\u00a7\u00c6K7\t\u001f@M7\u0089A`\u00e5\u001a\u00c0\u00c1\u00ca\u00a1E\u00b6s2@\u008d\u0097n\u0012\u0083@\u001a@\u00c7K7\u0089A !\u00c0\n\u00d7\u00a3p=\u00ca1@\u001b/\u00dd$\u0006\u0001\u0016@X9\u00b4\u00c8v>\u001f\u00c0!\u00b0rh\u0091--@\u008bl\u00e7\u00fb\u00a9\u00f1\u0015@T\u00e3\u00a5\u009b\u00c4\u00a0!\u00c0\u00e9&1\b\u00ac\\-@h\u0091\u00ed|?\u00b5\u0010@\u00d0\u00f7S\u00e3\u00a5\u009b\u001c\u00c0\u0086\u00ebQ\u00b8\u001e\u00c5,@\u00a0\u001a/\u00dd$\u0006\u0011@\u0010X9\u00b4\u00c8v\u001a\u00c0\u00c7K7\u0089A\u00e0*@(1\b\u00ac\u001cZ\u000f@o\u0012\u0083\u00c0\u00ca!\u0018\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2.@\u0099n\u0012\u0083\u00c0\u00ca\b@\u00d1\"\u00db\u00f9~j \u00c0\u008d\u0097n\u0012\u0083\u00c0,@\u00db\u00f9~j\u00bct\u0001@\u00c4\u00f5(\\\u008f\u00c2\u001e\u00c0\u00aeG\u00e1z\u0014.,@)\\\u008f\u00c2\u00f5(\t@\u00c5 \u00b0rh\u00d1!\u00c0\u0088\u0016\u00d9\u00ce\u00f7\u0013+@P\u008d\u0097n\u0012\u0083\t@,\u0087\u0016\u00d9\u00cew\u0014\u00c0\u00f1\u00a7\u00c6K7\t.@!\u00b0rh\u0091\u00ed\u0006@X9\u00b4\u00c8v\u00be!\u00c0X9\u00b4\u00c8v~/@U\u00e3\u00a5\u009b\u00c4 \u000e@\u00f4\u00fd\u00d4x\u00e9f\"\u00c0\u008aA`\u00e5\u00d0B0@/\u00dd$\u0006\u0081\u0095\u0002@\u0098n\u0012\u0083\u00c0J \u00c0\u00b4\u00c8v\u00be\u009fZ0@\u0082\u0095C\u008bl\u00e7\u00ff?\n\u00d7\u00a3p=J$\u00c0\u009a\u0099\u0099\u0099\u0099Y/@\u00e5\u00d0\"\u00db\u00f9~\u0004@sh\u0091\u00ed|\u007f&\u00c0c\u0010X9\u00b4\b/@\u00b1rh\u0091\u00ed|\u00e7?\u00d1\"\u00db\u00f9~*$\u00c0\u00a6\u009b\u00c4 \u00b0r/@;\u00dfO\u008d\u0097\u00ee\u0011@\u00e2z\u0014\u00aeGa\u0018\u00c0\u008e\u0097n\u0012\u0083\u00a00@\u009e\u00ef\u00a7\u00c6K7\u0014@\u00f1\u00a7\u00c6K7\u0089\u001b\u00c0\u00f0\u00a7\u00c6K7\u00e90@\u00a8\u00c6K7\u0089A\u0011@F\u00b6\u00f3\u00fd\u00d4\u00f8\u0013\u00c0\u00ac\u001cZd;\u009f1@5^\u00baI\f\u0002\n@\u00ea&1\b\u00ac\u001c\u0013\u00c0\u009e\u00ef\u00a7\u00c6K\u00b71@Zd;\u00dfO\r\u0014@\u0005V\u000e-\u00b2\u009d\r\u00c0\u00baI\f\u0002+'1@\u000e-\u00b2\u009d\u00ef\u00a7\u0013@\u00e9&1\b\u00ac\u001c\u0015\u00c0\u00aa\u00f1\u00d2Mb\u00f02@\u00c9v\u00be\u009f\u001a/\u0013@\u00ecQ\u00b8\u001e\u0085k\u0011\u00c0\u001f\u0085\u00ebQ\u00b8~3@\u00ac\u001cZd;\u00df\u0017@\u00a1\u001a/\u00dd$\u0006\u0016\u00c0!\u00b0rh\u0091\u00cd2@sh\u0091\u00ed|\u00bf\u0011@\u000e-\u00b2\u009d\u00ef\u00a7\u0004\u00c0\u00ac\u001cZd;?1@\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0010@\\\u008f\u00c2\u00f5(\\\u0019\u00c0V\u000e-\u00b2\u009d\u00af3@T\u00e3\u00a5\u009b\u00c4\u00a0\u0012@\u00f7(\\\u008f\u00c2u\u001a\u00c0Nb\u0010X9\u00d44@\u00fc\u00a9\u00f1\u00d2Mb\t@\u00c8K7\u0089A`\u001b\u00c0d;\u00dfO\u008d73@G\u00b6\u00f3\u00fd\u00d4x\u0018@\u00a2E\u00b6\u00f3\u00fd\u00d4\u000e\u00c0L7\u0089A`e0@\u00a0\u001a/\u00dd$\u0006\u001a@j\u00bct\u0093\u0018\u0004\u0013\u00c0\u0098n\u0012\u0083\u00c0*0@\u00b6\u00f3\u00fd\u00d4xi\u001b@\u00f3\u00d2Mb\u0010X\u0006\u00c0\u00da\u00ce\u00f7S\u00e3e/@\u00b4\u00c8v\u00be\u009f\u001a\u001c@\u00f2\u00d2Mb\u0010X\u00ff\u00bfT\u00e3\u00a5\u009b\u00c4`0@\u00dd$\u0006\u0081\u0095\u00c3\u0018@\u008bl\u00e7\u00fb\u00a9\u00f1\u0001\u00c0\u00c8K7\u0089A\u00e0,@\u008cl\u00e7\u00fb\u00a9q @$\u00db\u00f9~j\u00bc\n\u00c0\n\u00d7\u00a3p=J.@T\u00e3\u00a5\u009b\u00c4`!@%\u0006\u0081\u0095C\u008b\u0003\u00c06^\u00baI\f\u0082-@\u008e\u0097n\u0012\u0083\u0000 @\u00d6x\u00e9&1\b\u0010\u00c0\u00ac\u001cZd;\u009f,@\u000e-\u00b2\u009d\u00ef\u00a7\u0019@\u0088\u0016\u00d9\u00ce\u00f7S\u00f1\u00bf\u000e-\u00b2\u009d\u00ef',@\u00d3Mb\u0010X9\"@;\u00dfO\u008d\u0097n\u0010\u00c0\u008d\u0097n\u0012\u0083 0@\u00db\u00f9~j\u00bc4#@\u000e-\u00b2\u009d\u00ef\u00a7\u0014\u00c0~?5^\u00ba\u0089/@\u0000\u0000\u0000\u0000\u0000@\"@\u00e6\u00d0\"\u00db\u00f9~\r\u00c0\u00a0\u001a/\u00dd$F1@U\u00e3\u00a5\u009b\u00c4\u00a0\u0015@h\u0091\u00ed|?5\t\u00c0\u00bbI\f\u0002+\u0087+@\"\u00b0rh\u0091m\u0015@^\u00baI\f\u0002+\u0010\u00c0G\u00b6\u00f3\u00fd\u00d4x,@\u00bct\u0093\u0018\u0004\u00d6\u0011@\u00fc\u00a9\u00f1\u00d2Mb\u0006\u00c0\u00f1\u00a7\u00c6K7I)@\u00b8\u001e\u0085\u00ebQ\u00b8\u0013@J\f\u0002+\u0087\u0016\u0000\u00c0\u00f2\u00d2Mb\u0010\u0018(@\u00aeG\u00e1z\u0014\u00ae\t@\u00d3Mb\u0010X9\u0000\u00c0,\u0087\u0016\u00d9\u00cew*@1\b\u00ac\u001cZd\u0010@\u00fa~j\u00bct\u0013\u0010\u00c0\u0002+\u0087\u0016\u00d9\u008e'@\u009e\u00ef\u00a7\u00c6K7\u000e@\u00ea&1\b\u00ac\u001c\u0013\u00c0\u0010X9\u00b4\u00c8\u00f6(@\u0092\u00ed|?5^\u0006@333333\u00f1\u00bf\u00a3E\u00b6\u00f3\u00fdT)@b\u0010X9\u00b4\u00c8\u0007@B`\u00e5\u00d0\"\u00db\u000e\u00c0)\\\u008f\u00c2\u00f5h%@\u008f\u00c2\u00f5(\\\u008f\u0007@w\u00be\u009f\u001a/\u00dd\u0012\u00c0/\u00dd$\u0006\u0081\u0015$@\u00f1\u00a7\u00c6K7\u0089\u00ff?\u0080j\u00bct\u0093\u0018\r\u00c0x\u00be\u009f\u001a/\u001d&@\u0007\u0081\u0095C\u008bl\t@\u009c\u00c4 \u00b0rh\b\u00c0#\u00db\u00f9~j\u00fc#@\u00fa~j\u00bct\u0013\u0015@d;\u00dfO\u008d\u0017\u0012\u00c0~?5^\u00ba\t&@\u00a2E\u00b6\u00f3\u00fdT\u0017@\u00de$\u0006\u0081\u0095C\r\u00c0\u001f\u0085\u00ebQ\u00b8^%@B`\u00e5\u00d0\"[\u0014@M7\u0089A`\u00e5\u0014\u00c0\u00b6\u00f3\u00fd\u00d4xi$@%\u0006\u0081\u0095C\u008b\u0017@;\u00dfO\u008d\u0097\u00ee\u0013\u00c0\u0015\u00aeG\u00e1z\u0094'@V\u000e-\u00b2\u009d\u00ef\u0005@\n\u00d7\u00a3p=\n\u0003\u00c0\u00fd\u00a9\u00f1\u00d2M\u00e2,@\u0003+\u0087\u0016\u00d9\u00ce\b@333333\t\u00c0|\u0014\u00aeG\u00e1\u00fa-@6^\u00baI\f\u0002\u00fb?\u00b9\u001e\u0085\u00ebQ\u00b8\u00fa\u00bfz\u00e9&1\b,.@\u00e0O\u008d\u0097n\u0012\u00ef?\u0000\u0000\u0000\u0000\u0000\u0000\u00f6\u00bfT\u00e3\u00a5\u009b\u00c4\u00a0,@\u0002+\u0087\u0016\u00d9\u00ce\u0001@\u0093\u0018\u0004V\u000e-\u00d2\u00bf\u0000\u0000\u0000\u0000\u0000\u0000/@\u00d3Mb\u0010X9\u00f2?Nb\u0010X9\u00b4\u0004\u00c0\u00d3Mb\u0010X90@\u00e9&1\b\u00ac\u001c\u00e6?\u00d6x\u00e9&1\b\f\u00c0_\u00baI\f\u0002\u00ab/@\u00f2\u00d2Mb\u0010X\u0000@1\b\u00ac\u001cZd\u0006\u00c0y\u00e9&1\b\u00cc0@\u0099n\u0012\u0083\u00c0\u00ca\u00f7?ffffff\u00e6?43333\u00b3.@Zd;\u00dfO\u008d\u00b7?\u0006\u0081\u0095C\u008bl\u00fd\u00bf\u0089A`\u00e5\u00d0\"1@\u00b8\u001e\u0085\u00ebQ\u00b8\u00e2?\u00e1z\u0014\u00aeG\u00e1\u00f0\u00bfR\u00b8\u001e\u0085\u00eb\u00b11@\u00db\u00f9~j\u00bct\u00d3\u00bf\u00e3\u00a5\u009b\u00c4 \u00b0\u0004\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u00d31@\u00f8S\u00e3\u00a5\u009b\u00c4\u00f0\u00bf\n\u00d7\u00a3p=\n\u00f5\u00bf\u00c7K7\u0089A`0@\u00fe\u00d4x\u00e9&1\u00e8\u00bf\u00bct\u0093\u0018\u0004V\u00de\u00bf{\u0014\u00aeG\u00e1z/@<\u00dfO\u008d\u0097n\u00fa\u00bf\u0014\u00aeG\u00e1z\u0014\u00ee\u00bf\u00c1\u00ca\u00a1E\u00b631@\n\u00d7\u00a3p=\n\u00fd\u00bf\u00f4\u00fd\u00d4x\u00e9&\u0003\u00c0\u0018\u00d9\u00ce\u00f7S#/@\u000e-\u00b2\u009d\u00ef\u00a7\u00f2\u00bf\u00dd$\u0006\u0081\u0095C\u0006\u00c0\u00e0O\u008d\u0097n\u0092-@Nb\u0010X9\u00b4\u00fe\u00bf\u00a9\u00c6K7\u0089A\t\u00c0J\f\u0002+\u0087V0@\u008e\u0097n\u0012\u0083\u00c0\b\u00c0\u00e2z\u0014\u00aeG\u00e1\u00fe\u00bf\u00cav\u00be\u009f\u001a\u00ef-@8\u0089A`\u00e5\u00d0\u0007\u00c0 \u0085\u00ebQ\u00b8\u001e\u00f7\u00bf!\u00b0rh\u0091-,@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\f\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u00f4\u00bf\u0092\u00ed|?5\u001e/@8\u0089A`\u00e5\u00d0\r\u00c0Ob\u0010X9\u00b4\u0005\u00c0\u0094\u0018\u0004V\u000e\u00ad-@\u008aA`\u00e5\u00d0\"\f@\u00cb\u00a1E\u00b6\u00f3\u00fd\u00c4\u00bf\u0007\u0081\u0095C\u008b\u00ac/@\u0081\u0095C\u008blg\u0010@`\u00e5\u00d0\"\u00db\u00f9\u00ee\u00bf=\n\u00d7\u00a3p\u00fd/@\u0004V\u000e-\u00b2\u009d\u0010@\u0010X9\u00b4\u00c8v\u00f2?R\u00b8\u001e\u0085\u00eb\u00110@.\u00b2\u009d\u00ef\u00a7\u00c6\f@\u00a5p=\n\u00d7\u00a3\u00fc?\u001b/\u00dd$\u0006\u00c10@\u00f6(\\\u008f\u00c2u\u0011@$\u00db\u00f9~j\u00bc\u00fe?\u00ef|?5^z-@\u00e7\u00fb\u00a9\u00f1\u00d2M\u0016@B`\u00e5\u00d0\"\u00db\u00ed?\u00a2E\u00b6\u00f3\u00fd\u00b40@\u0085\u00ebQ\u00b8\u001e\u0085\u0018@\u0086\u00ebQ\u00b8\u001e\u0085\u00cb?{\u0014\u00aeG\u00e1\u001a0@\u00b4\u00c8v\u00be\u009f\u009a\u0015@ffffff\u00e2?{\u0014\u00aeG\u00e1\u00ba1@/\u00dd$\u0006\u0081\u0015\u0010@\u00b1rh\u0091\u00ed|\b@\u00ad\u001cZd;_-@333333\u0019@\u008bl\u00e7\u00fb\u00a9\u00f1\u0000@-\u00b2\u009d\u00ef\u00a7\u00c60@Zd;\u00dfO\u008d\u001c@\\\u008f\u00c2\u00f5(\\\u00ff?\u00d7\u00a3p=\nW0@b\u0010X9\u00b4H\u0013@\u0093\u0018\u0004V\u000e-\u00f4?\u0089A`\u00e5\u00d0b+@\u00dd$\u0006\u0081\u0095\u00c3\u0013@J\f\u0002+\u0087\u0016\u00d1?h\u0091\u00ed|?\u00b5+@\u000e-\u00b2\u009d\u00ef\u00a7\u0013@\u00b8\u001e\u0085\u00ebQ\u00b8\u00fe?\u0094\u0018\u0004V\u000e\u00ad(@\u00c9v\u00be\u009f\u001a\u00af\u0016@\u0004V\u000e-\u00b2\u009d\u0005@m\u00e7\u00fb\u00a9\u00f1\u00d2(@Nb\u0010X9\u00b4\f@\u00be\u009f\u001a/\u00dd$\u0004@\u0012\u0083\u00c0\u00ca\u00a1\u00c5'@\u00fc\u00a9\u00f1\u00d2M\u00e2\u0015@[d;\u00dfO\u008d\u00eb?\u00d8\u00a3p=\n\u00d7&@\u0094\u0018\u0004V\u000e\u00ad\u0013@\u00db\u00f9~j\u00bct\u00b3\u00bf\u001a\u0004V\u000e-\u00f2&@%\u0006\u0081\u0095C\u000b\u001a@\r\u0002+\u0087\u0016\u00d9\u00e6?\u00e3\u00a5\u009b\u00c4 p'@\u00ad\u001cZd;\u00df\u000b@\u000f-\u00b2\u009d\u00ef\u00a7\r@\u00b2\u009d\u00ef\u00a7\u00c6K'@m\u00e7\u00fb\u00a9\u00f1R\u0016@\u0098n\u0012\u0083\u00c0\u00ca\u00f3?\n\u00d7\u00a3p=\u00ca#@\u00c3\u00f5(\\\u008fB\u0018@Nb\u0010X9\u00b4\u0001@\u0098n\u0012\u0083\u00c0\u00ca#@\u00d6x\u00e9&1\b\u001a@\u001f\u0085\u00ebQ\u00b8\u001e\u00c5?\u00fc\u00a9\u00f1\u00d2Mb\"@\u008e\u0097n\u0012\u0083\u00c0\u001d@\u0000\u0000\u0000\u0000\u0000\u0000\u00c0?\u00baI\f\u0002+\u0087#@\u00c6 \u00b0rh\u0011\u001b@\u00cc\u00a1E\u00b6\u00f3\u00fd\u00e0?y\u00e9&1\bl @\u00d3Mb\u0010X9\u0018@\u00be\u009f\u001a/\u00dd$\u00ea\u00bfu\u0093\u0018\u0004V\u000e\"@\u00e9&1\b\u00ac\u001c\u0011@\u00b7\u00f3\u00fd\u00d4x\u00e9\u00f4?\f\u0002+\u0087\u0016\u0019\"@\u00e8\u00fb\u00a9\u00f1\u00d2M\u0012@\u00fc\u00a9\u00f1\u00d2Mb\u00f6?\u00baI\f\u0002+\u0007 @\u0083\u00c0\u00ca\u00a1E\u00b6\r@\u00b0rh\u0091\u00ed|\u0001@\u00cav\u00be\u009f\u001a\u00af\"@\u008e\u0097n\u0012\u0083\u00c0\r@Nb\u0010X9\u00b4\u00d8?!\u00b0rh\u0091m\"@D\u008bl\u00e7\u00fb\u00a9\u0003@X9\u00b4\u00c8v\u00be\u00fb?\"\u00b0rh\u0091\u00ed'@^\u00baI\f\u0002+\u0005@\"\u00b0rh\u0091\u00ed\u00e8?\u00d3Mb\u0010Xy(@6^\u00baI\f\u0002\u00f1?\u0012\u0083\u00c0\u00ca\u00a1E\u0001@}?5^\u00ba\u00c9'@\u0089A`\u00e5\u00d0\"\u00eb?B`\u00e5\u00d0\"\u00db\u0001@fffff\u00a6%@*\\\u008f\u00c2\u00f5(\u00e8?\u00cf\u00f7S\u00e3\u00a5\u009b\u000b@,\u0087\u0016\u00d9\u00ce\u00f7(@\u00b8\u001e\u0085\u00ebQ\u00b8\u009e?\u00dd$\u0006\u0081\u0095C\u00f1?;\u00dfO\u008d\u0097\u00ae(@\u0098n\u0012\u0083\u00c0\u00ca\u00c1?]\u008f\u00c2\u00f5(\\\u00eb?Zd;\u00dfO\u00cd*@;\u00dfO\u008d\u0097n\u00d2?\u009c\u00c4 \u00b0rh\u00c1?F\u00b6\u00f3\u00fd\u00d4\u00b8'@\u00c9v\u00be\u009f\u001a/\u00ad?\u00f8S\u00e3\u00a5\u009bD\u0011@gffff\u00e6'@<\u00dfO\u008d\u0097n\u00f4\u00bf\u00b8\u001e\u0085\u00ebQ\u00b8\u00f6?Nb\u0010X9\u00f4'@R\u00b8\u001e\u0085\u00ebQ\u00fe\u00bf\u00e9&1\b\u00ac\u001c\u00e6?\u0081\u0095C\u008bl'(@\u00db\u00f9~j\u00bct\u00f3?\u00e6\u00d0\"\u00db\u00f9~\f@\u00fe\u00d4x\u00e9&q+@B`\u00e5\u00d0\"\u00db\u00f9?\u00d6x\u00e9&1\b\u0006@d;\u00dfO\u008dW,@\u00cc\u00a1E\u00b6\u00f3\u00fd\u00f0?\u00d9\u00ce\u00f7S\u00e3%\u0013@,\u0087\u0016\u00d9\u00ce\u00f7,@333333\u00b3?\u00e8\u00fb\u00a9\u00f1\u00d2\u00cd\u0014@\u00bbI\f\u0002+\u0087,@\u0087\u0016\u00d9\u00ce\u00f7S\u00ff?\u00b0rh\u0091\u00ed\u00fc\u0017@\\\u008f\u00c2\u00f5(\u001c,@\u00f4\u00fd\u00d4x\u00e9&\u00f3?\u00d1\"\u00db\u00f9~j\u0011@o\u0012\u0083\u00c0\u00ca\u00010@\u00a3E\u00b6\u00f3\u00fd\u00d4\u00f6?\u008f\u00c2\u00f5(\\\u000f\u0015@R\u00b8\u001e\u0085\u00eb\u00910@\u0012\u0083\u00c0\u00ca\u00a1E\u0000@\u00d3Mb\u0010X9\r@\u00d6x\u00e9&1\b0@\u0012\u0083\u00c0\u00ca\u00a1E\u00f6?]\u008f\u00c2\u00f5(\\\u001c@\u00bbI\f\u0002+\u0087+@\u00fa~j\u00bct\u0093x\u00bfG\u00b6\u00f3\u00fd\u00d4x\r@\u00a0\u001a/\u00dd$\u00860@\u00db\u00f9~j\u00bct\u00eb\u00bf\u00c1\u00ca\u00a1E\u00b6s\u0011@\u00b6\u00f3\u00fd\u00d4x\u00a90@F\u00b6\u00f3\u00fd\u00d4x\u00d1\u00bf\u00a3E\u00b6\u00f3\u00fd\u00d4\u0006@\u00b0rh\u0091\u00ed\u00bc/@\u00cb\u00a1E\u00b6\u00f3\u00fd\u00d4?\u00f2\u00d2Mb\u0010X\b@o\u0012\u0083\u00c0\u00ca\u00e11@h\u0091\u00ed|?5\u00f0?Nb\u0010X9\u00b4\u0001@\u00fe\u00d4x\u00e9&\u00b11@\u00fc\u00a9\u00f1\u00d2Mb\u00e8?\u00ac\u001cZd;\u00df\r@{\u0014\u00aeG\u00e1\u009a2@\u008bl\u00e7\u00fb\u00a9\u00f1\u00ea\u00bf\u00e0O\u008d\u0097n\u0012\u0004@\u008bl\u00e7\u00fb\u00a9\u00912@\u00afG\u00e1z\u0014\u00ae\u00fb\u00bfG\u00b6\u00f3\u00fd\u00d4x\u0007@0\u00dd$\u0006\u0081U2@;\u00dfO\u008d\u0097n\u00a2?\u001a\u0004V\u000e-\u00b2\u00e5?\u001c/\u00dd$\u0006\u00a13@\u0090\u00c2\u00f5(\\\u008f\u00ee?\u00c5 \u00b0rh\u0091\u00f1?}?5^\u00ba\u00a93@\u00da\u00ce\u00f7S\u00e3\u00a5\u00bb\u00bfH\u00e1z\u0014\u00aeG\u00c1\u00bf\u0019\u0004V\u000e-24@ffffff\u0001\u00c05^\u00baI\f\u0002\u00ef?fffff\u00863@R\u00b8\u001e\u0085\u00ebQ\u0002\u00c06^\u00baI\f\u0002\u00cb?\u00ecQ\u00b8\u001e\u0085+4@\u0088\u0016\u00d9\u00ce\u00f7S\u0007\u00c0Zd;\u00dfO\u008d\u00f9?:\u00b4\u00c8v\u00be?3@\u00fe\u00d4x\u00e9&1\u00f0\u00bfX9\u00b4\u00c8v\u00be\u00f5?=\n\u00d7\u00a3p=3@\u0018\u00d9\u00ce\u00f7S\u00e3\t@\u00fe\u00d4x\u00e9&\u00b1\u0016@\u008e\u0097n\u0012\u0083\u0000,@\u000e-\u00b2\u009d\u00ef\u00a7\u000b@}?5^\u00ba\u00c9\u0012@G\u00b6\u00f3\u00fd\u00d48,@{\u0014\u00aeG\u00e1\u00fa\u0010@\u00a8\u00c6K7\u0089\u00c1\u001a@\u00be\u009f\u001a/\u00ddd+@\u0006\u0081\u0095C\u008bl\u0010@\u00bf\u009f\u001a/\u00dd$\u001e@X9\u00b4\u00c8v\u00be,@`\u00e5\u00d0\"\u00db\u00f9\u000f@r=\n\u00d7\u00a3p\u001d@r=\n\u00d7\u00a3\u00b0(@)\\\u008f\u00c2\u00f5\u00a8\u0016@\u008f\u00c2\u00f5(\\\u008f\u0018@I\u00e1z\u0014\u00ae\u00c7+@*\\\u008f\u00c2\u00f5(\u0017@fffff\u00e6\u0014@\u00ea&1\b\u00ac\u009c*@\u0006\u0081\u0095C\u008bl\u0010@{\u0014\u00aeG\u00e1:!@\u00d9\u00ce\u00f7S\u00e3e(@P\u008d\u0097n\u0012\u0003\u001b@\u00fc\u00a9\u00f1\u00d2Mb\u001c@\u001f\u0085\u00ebQ\u00b8\u001e+@\u009b\u0099\u0099\u0099\u0099\u0099\u001e@\u00b7\u00f3\u00fd\u00d4x\u00e9\u0019@.\u00b2\u009d\u00ef\u00a7\u0006+@\u00e4\u00a5\u009b\u00c4 \u00b0\u001b@\u009f\u00ef\u00a7\u00c6K7\u001f@#\u00db\u00f9~j\u00bc,@\u00baI\f\u0002+\u0087\u001a@\u0091\u00ed|?5^\u001e@\u00fe\u00d4x\u00e9&1)@\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u0017@\u0083\u00c0\u00ca\u00a1E\u00b6\u0016@V\u000e-\u00b2\u009d\u00af.@2\b\u00ac\u001cZ\u00e4\u0017@#\u00db\u00f9~j<\u001a@\u00d3Mb\u0010X\u00f9/@Nb\u0010X94\u0014@\u0001\u0000\u0000\u0000\u0000\u0080\u0014@\u0086\u00ebQ\u00b8\u001eE/@\b\u00ac\u001cZd\u00bb\u001b@\f\u0002+\u0087\u0016\u00d9\u0014@1\b\u00ac\u001cZ\u00e4.@\u00ac\u001cZd;\u00df\f@)\\\u008f\u00c2\u00f5(\u001a@{\u0014\u00aeG\u00e1\u00ba&@\u008f\u00c2\u00f5(\\\u008f\f@\u00cav\u00be\u009f\u001a/\u0016@\u009c\u00c4 \u00b0r('@T\u00e3\u00a5\u009b\u00c4 \n@\u00c6 \u00b0rh\u0011\u001c@\n\u00d7\u00a3p=\n$@9\u00b4\u00c8v\u00be\u009f\u0010@\u00ee|?5^:\u001e@\u00ac\u001cZd;_#@J\f\u0002+\u0087\u0016\u0000@\u00c9v\u00be\u009f\u001a\u00af\u001f@w\u00be\u009f\u001a/\u00dd#@w\u00be\u009f\u001a/\u00dd\b@b\u0010X9\u00b4H\u0017@u\u0093\u0018\u0004V\u000e\"@\u0017\u00d9\u00ce\u00f7S\u00e3\u0001@B`\u00e5\u00d0\"\u00db\u0014@u\u0093\u0018\u0004V\u008e\"@\u00aeG\u00e1z\u0014\u00ae\u000f@o\u0012\u0083\u00c0\u00ca\u00a1\u0014@\u00ac\u001cZd;_\"@\u0014\u00aeG\u00e1z\u0014\u00fe?P\u008d\u0097n\u0012\u0083!@\u0010X9\u00b4\u00c8\u00f6!@\u00fa~j\u00bct\u0093\b@\u00c6 \u00b0rh\u0091\u0018@\u00c9v\u00be\u009f\u001a/\u001e@\u0096C\u008bl\u00e7\u00fb\u0000@\n\u00d7\u00a3p=\u008a\u001a@\u0002+\u0087\u0016\u00d9N\u001d@\u00c9v\u00be\u009f\u001a/\b@x\u00be\u009f\u001a/\u00dd\u0014@C`\u00e5\u00d0\"\u00db\u001b@\u00e3\u00a5\u009b\u00c4 \u00b0\u0011@\u0007\u0081\u0095C\u008b\u00ec\u001c@\u009a\u0099\u0099\u0099\u0099\u0099\u001b@\u00a6\u009b\u00c4 \u00b0r\u0017@\u0089A`\u00e5\u00d0\u00a2\u0018@S\u00b8\u001e\u0085\u00ebQ\u001c@\u00c3\u00f5(\\\u008f\u00c2\u0016@\u009c\u00c4 \u00b0r\u00e8\u0014@E\u008bl\u00e7\u00fb)\u001a@\u001b/\u00dd$\u0006\u0081\u0018@\n\u00d7\u00a3p=\n\u0018@\u00a8\u00c6K7\u0089A @\f\u0002+\u0087\u0016\u00d9\u001a@{\u0014\u00aeG\u00e1z\u001a@.\u00b2\u009d\u00ef\u00a7F\u001a@\u00e5\u00d0\"\u00db\u00f9~\u00f0?}?5^\u00baI\u001f@\u00db\u00f9~j\u00bc\u00b4%@\u0002+\u0087\u0016\u00d9\u00ce\u00f1?\u00b1rh\u0091\u00ed|\u001c@\u0081\u0095C\u008bl''@z\u00e9&1\b\u00ac\u009c?\f\u0002+\u0087\u0016\u00d9!@J\f\u0002+\u0087\u00d6%@\u000e-\u00b2\u009d\u00ef\u00a7\u00de\u00bf\u00f0\u00a7\u00c6K7\u00c9!@\u00d9\u00ce\u00f7S\u00e3\u00e5#@\u00e1z\u0014\u00aeG\u00e1\u00e2?{\u0014\u00aeG\u00e1\u00ba$@\u0082\u0095C\u008blg&@0\u00dd$\u0006\u0081\u0095\u00ef\u00bf1\b\u00ac\u001cZd!@?5^\u00baI\f(@\u00da\u00ce\u00f7S\u00e3\u00a5\u00db\u00bf:\u00b4\u00c8v\u00be_!@\u0006\u0081\u0095C\u008b\u00ec)@x\u00be\u009f\u001a/\u00dd\u00c4?\u0012\u0083\u00c0\u00ca\u00a1\u0085&@\u0094\u0018\u0004V\u000e\u00ed$@\u0010X9\u00b4\u00c8v\u00fa\u00bfth\u0091\u00ed|?\u001d@D\u008bl\u00e7\u00fb\u00a9'@\u001eZd;\u00dfO\u00ed\u00bf\u0080j\u00bct\u0093\u0018\u001a@\u009c\u00c4 \u00b0rh'@Nb\u0010X9\u00b4\u0001\u00c0\u00c6 \u00b0rh\u0011\u001d@\u0012\u0083\u00c0\u00ca\u00a1\u0085)@\u00cf\u00f7S\u00e3\u00a5\u009b\u0000\u00c0\u00dfO\u008d\u0097n\u0092#@\u00d0\u00f7S\u00e3\u00a5[(@7\u0089A`\u00e5\u00d0\u00fa\u00bf\u00afG\u00e1z\u0014n%@gffff&)@b\u0010X9\u00b4\u00c8\u0003\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\r$@\u0089A`\u00e5\u00d0b&@#\u00db\u00f9~j\u00bc\u0006\u00c0\u00a8\u00c6K7\u0089\u00c1\"@\u000e-\u00b2\u009d\u00ef\u00a7)@sh\u0091\u00ed|?\u0005\u00c0'1\b\u00ac\u001cZ\u001d@\u0081\u0095C\u008blg%@R\u00b8\u001e\u0085\u00ebQ\u000b\u00c0`\u00e5\u00d0\"\u00db9 @d;\u00dfO\u008d\u0097%@\u00c5 \u00b0rh\u0091\u0000\u00c08\u0089A`\u00e5\u00d0\u001d@J\f\u0002+\u0087\u0096#@\u001a\u0004V\u000e-\u00b2\t\u00c0\u0014\u00aeG\u00e1z\u0094\u0019@\u00ecQ\u00b8\u001e\u0085k%@\u00ea&1\b\u00ac\u001c\u00fa?|\u0014\u00aeG\u00e1\u00fa$@\u00c9v\u00be\u009f\u001a\u00ef'@\u00a0\u001a/\u00dd$\u0006\u0000@\u00a8\u00c6K7\u0089A#@\u00aeG\u00e1z\u0014\u00ae(@\u00a4p=\n\u00d7\u00a3\u0001@q=\n\u00d7\u00a3\u00b0'@\u0088\u0016\u00d9\u00ce\u00f7\u0093(@\u00ecQ\u00b8\u001e\u0085\u00eb\u00f5?d;\u00dfO\u008d\u0017)@\u00a2E\u00b6\u00f3\u00fd\u00d4(@\u00cb\u00a1E\u00b6\u00f3\u00fd\u0007@H\u00e1z\u0014\u00ae\u0007)@=\n\u00d7\u00a3p=&@\u008aA`\u00e5\u00d0\"\b@\u0082\u0095C\u008blg'@1\b\u00ac\u001cZ$+@\"\u00b0rh\u0091\u00ed\u000e@@5^\u00baI\f&@\u00f4\u00fd\u00d4x\u00e9&+@#\u00db\u00f9~j\u00bc\u000b@'1\b\u00ac\u001cZ)@\u0099n\u0012\u0083\u00c0\u008a+@=\n\u00d7\u00a3p=\r@H\u00e1z\u0014\u00ae\u0007+@q=\n\u00d7\u00a3\u00b0&@\u00cb\u00a1E\u00b6\u00f3\u00fd\u0001@\u00bct\u0093\u0018\u0004\u0096&@\u00baI\f\u0002+\u0087-@\u00ecQ\u00b8\u001e\u0085\u00eb\u0000@\u00e3\u00a5\u009b\u00c4 \u00f0#@\u0091\u00ed|?5^.@\u00c8K7\u0089A`\u0004@\u00c7K7\u0089A \"@S\u00b8\u001e\u0085\u00eb\u0091-@\u0005V\u000e-\u00b2\u009d\u00f9?\u00b3\u009d\u00ef\u00a7\u00c6\u000b(@\u00bf\u009f\u001a/\u00ddd/@\u00be\u009f\u001a/\u00dd$\u00fa?\u00ab\u00f1\u00d2Mb\u0010*@J\f\u0002+\u0087\u0096/@ffffff\u00f2?\u00b8\u001e\u0085\u00ebQx&@\u00ecQ\u00b8\u001e\u0085\u00ab0@\u0004V\u000e-\u00b2\u009d\u00e7?\u0010X9\u00b4\u00c8\u00f6&@p\u0012\u0083\u00c0\u00ca\u00a11@T\u00e3\u00a5\u009b\u00c4 \u00f6?h\u0091\u00ed|?\u00f5#@\u00c7K7\u0089A`0@\u00d3Mb\u0010X9\b@\u00de$\u0006\u0081\u0095\u0003(@\u0085\u00ebQ\u00b8\u001e\u00c5#@\u00a4p=\n\u00d7\u00a3\u0004@\u0083\u00c0\u00ca\u00a1E6&@\u00e2z\u0014\u00aeG\u00a1#@333333\r@th\u0091\u00ed|\u00ff(@\u0002+\u0087\u0016\u00d9N!@\u0002+\u0087\u0016\u00d9\u00ce\u000f@c\u0010X9\u00b4\b+@\u00a0\u001a/\u00dd$\u00c6!@\u001c/\u00dd$\u0006\u0081\u0005@\u00f4\u00fd\u00d4x\u00e9&)@\u001c/\u00dd$\u0006\u0001\u001e@\u00c3\u00f5(\\\u008fB\u0013@T\u00e3\u00a5\u009b\u00c4 '@\u00d1\"\u00db\u00f9~j @\u0010X9\u00b4\u00c8\u00f6\u0011@\u0096C\u008bl\u00e7;%@\u00be\u009f\u001a/\u00dd$\u001f@\u009f\u00ef\u00a7\u00c6K7\u0005@\u00da\u00ce\u00f7S\u00e3%+@\u00c6 \u00b0rh\u0011\u001b@>\n\u00d7\u00a3p\u00bd\u0016@^\u00baI\f\u0002\u00eb(@\u0002+\u0087\u0016\u00d9N\u001d@=\n\u00d7\u00a3p\u00bd\u0014@v\u0093\u0018\u0004VN*@\u00aa\u00f1\u00d2Mb\u0090\u001a@9\u00b4\u00c8v\u00be\u001f\u0019@z\u00e9&1\b,*@<\u00dfO\u008d\u0097\u00ee\u001f@\u0093\u0018\u0004V\u000e-\u0019@Q\u008d\u0097n\u0012\u00c3'@\u00cc\u00a1E\u00b6\u00f3}\u001a@\u009a\u0099\u0099\u0099\u0099\u0019\u0017@\u00a2E\u00b6\u00f3\u00fdT&@(1\b\u00ac\u001c\u00da\"@\u0091\u00ed|?5\u00de\u0014@\u0014\u00aeG\u00e1zT%@\u00c2\u00ca\u00a1E\u00b6s$@th\u0091\u00ed|?\u0018@0\u00dd$\u0006\u0081\u0015(@\u0086\u00ebQ\u00b8\u001e\u0005$@\u00aa\u00f1\u00d2Mb\u0090\u001a@\u0006\u0081\u0095C\u008b,%@\u00c9v\u00be\u009f\u001a/\"@Nb\u0010X9\u00b4\u00fc?9\u00b4\u00c8v\u00be\u001f'@o\u0012\u0083\u00c0\u00ca!\u001d@\u00ea&1\b\u00ac\u001c\u00fe?\u00d8\u00a3p=\n\u0097%@\u00b9\u001e\u0085\u00ebQ\u00b8\u001f@\u00d6x\u00e9&1\b\u00ec?)\\\u008f\u00c2\u00f5\u00e8&@:\u00b4\u00c8v\u00be\u009f\u0018@\u0092\u00ed|?5^\u00f6?\u0088\u0016\u00d9\u00ce\u00f7\u0093'@\u00baI\f\u0002+\u0007\u0015@d;\u00dfO\u008d\u0097\u00d6\u00bf\u00cav\u00be\u009f\u001a\u00af(@\u00d8\u00a3p=\nW\u0019@V\u000e-\u00b2\u009d\u00ef\u00e3?o\u0012\u0083\u00c0\u00ca\u00e1#@2\b\u00ac\u001cZ\u00e4\u0017@\u001c/\u00dd$\u0006\u0081\u0095\u00bf\u00ee|?5^\u00fa\"@<\u00dfO\u008d\u0097\u00ee\u001a@Y9\u00b4\u00c8v\u00be\u00f9?sh\u0091\u00ed|\u00ff\"@\u00aa\u00f1\u00d2Mb\u0010\u0018@\\\u008f\u00c2\u00f5(\\\u00ef\u00bf\u0012\u0083\u00c0\u00ca\u00a1\u0085)@\u00e1z\u0014\u00aeGa\u0015@L7\u0089A`\u00e5\u00b0\u00bf\u0085\u00ebQ\u00b8\u001eE#@\u00d9\u00ce\u00f7S\u00e3\u00a5\u0012@\u00f8S\u00e3\u00a5\u009b\u00c4\u00f6\u00bf\\\u008f\u00c2\u00f5(\u00dc\"@\u00a6\u009b\u00c4 \u00b0r\u0012@Zd;\u00dfO\u008d\u0000\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\r#@\u00c7K7\u0089A\u00e0\u0015@\u0092\u00ed|?5^\u00e6?\u00c5 \u00b0rh\u00d1\"@\u00afG\u00e1z\u0014\u00ae\f@,\u0087\u0016\u00d9\u00ce\u00f7\u00fb?J\f\u0002+\u0087V#@U\u00e3\u00a5\u009b\u00c4 \r@-\u00b2\u009d\u00ef\u00a7\u00c6\u00ff\u00bf}?5^\u00ba\t\"@\u00cc\u00a1E\u00b6\u00f3\u00fd\n@\u00fc\u00a9\u00f1\u00d2Mb\b\u00c0sh\u0091\u00ed|\u00bf!@\u00a9\u00c6K7\u0089A\n@b\u0010X9\u00b4\u00c8\u00c6?\u0087\u0016\u00d9\u00ce\u00f7\u00d3!@m\u00e7\u00fb\u00a9\u00f1\u00d2\u0002@,\u0087\u0016\u00d9\u00ce\u00f7\u00eb?d;\u00dfO\u008d\u0097!@\u008f\u00c2\u00f5(\\\u008f\u00f8?\u008d\u0097n\u0012\u0083\u00c0\u00f2\u00bf\u00cd\u00cc\u00cc\u00cc\u00cc\u008c!@\u00d5x\u00e9&1\b\u0002@\u009f\u00ef\u00a7\u00c6K7\u00fb\u00bf\u00dfO\u008d\u0097n\u0012!@o\u0012\u0083\u00c0\u00ca\u00a1\u00f5?\u0015\u00aeG\u00e1z\u0014\u00ea\u00bf\u0080j\u00bct\u0093\u0018)@'1\b\u00ac\u001cZ\u001e@\u0093\u0018\u0004V\u000e-\u00d2\u00bf\u009e\u00ef\u00a7\u00c6Kw(@P\u008d\u0097n\u0012\u00c3 @\u00b6\u00f3\u00fd\u00d4x\u00e9\u0000\u00c0X9\u00b4\u00c8v>*@\u00a4p=\n\u00d7\u00a3\u001f@Nb\u0010X9\u00b4\u0006\u00c0\u00d8\u00a3p=\n\u0017)@\u0018\u00d9\u00ce\u00f7Sc\u001d@/\u00dd$\u0006\u0081\u0095\u0001\u00c0Ob\u0010X94-@[d;\u00dfO\r\u001e@\u00d2\"\u00db\u00f9~j\u0003\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb)@\u00baI\f\u0002+\u00c7\"@\u00a2E\u00b6\u00f3\u00fd\u00d4\u0001\u00c0\u00a8\u00c6K7\u0089\u00c1'@\u0093\u0018\u0004V\u000em#@/\u00dd$\u0006\u0081\u0095\u00fb\u00bf\u00f5\u00fd\u00d4x\u00e9\u00e6*@\u0012\u0083\u00c0\u00ca\u00a1\u0005$@b\u0010X9\u00b4\u00c8\n\u00c0\u008d\u0097n\u0012\u0083\u0000.@\u0013\u0083\u00c0\u00ca\u00a1\u00c5\u001c@^\u00baI\f\u0002+\u000e\u00c0\u00cf\u00f7S\u00e3\u00a5\u009b*@\u00e7\u00fb\u00a9\u00f1\u00d2M#@D\u008bl\u00e7\u00fb\u00a9\u000e\u00c0\u00c4\u00f5(\\\u008f\u0082,@\u00c1\u00ca\u00a1E\u00b6s#@\u00fa~j\u00bct\u0093\u00f2\u00bf\u00bdt\u0093\u0018\u0004\u00d6.@&\u0006\u0081\u0095C\u008b\u001e@\u000e-\u00b2\u009d\u00ef\u00a7\u00d6\u00bf\u0089A`\u00e5\u00d0\u00e2-@5^\u00baI\f\u0002 @\\\u008f\u00c2\u00f5(\\\u00f3\u00bf#\u00db\u00f9~j\u00dc0@\u001eZd;\u00df\u00cf\u001d@\u00a0\u001a/\u00dd$\u0006\u0002\u00c05^\u00baI\f\"1@#\u00db\u00f9~j<\u001e@\u008d\u0097n\u0012\u0083\u00c0\u00e6\u00bf\u00be\u009f\u001a/\u00dd$1@\u00a4p=\n\u00d7#\u0018@\u0098n\u0012\u0083\u00c0\u00ca\u00d1\u00bf\u00b2\u009d\u00ef\u00a7\u00c6\u008b1@Nb\u0010X9\u00f4 @:\u00b4\u00c8v\u00be\u009f\u00d2\u00bf\\\u008f\u00c2\u00f5(\u009c2@\u00ee|?5^z @\u00aa\u00f1\u00d2Mb\u0010\u00e8?sh\u0091\u00ed|?1@\u00d7\u00a3p=\n\u0097 @\u0014\u00aeG\u00e1z\u0014\u00ce?fffff\u00860@\u0014\u00aeG\u00e1z\u0014\u0016@\u00bct\u0093\u0018\u0004V\u00de\u00bf\u009c\u00c4 \u00b0rh1@\b\u00ac\u001cZd\u00fb#@F\u00b6\u00f3\u00fd\u00d4x\u00f5\u00bf=\n\u00d7\u00a3p\u009d0@^\u00baI\f\u0002\u00eb$@\u00a0\u001a/\u00dd$\u0006\u00d1?\u00b0rh\u0091\u00ed\u001c2@F\u00b6\u00f3\u00fd\u00d4x%@\u00fa~j\u00bct\u0093\u00f6\u00bf\u0087\u0016\u00d9\u00ce\u00f7\u00132@\u00a4p=\n\u00d7\u00a3\u0015@^\u00baI\f\u0002+\u0001\u00c0fffff\u00862@\u00dd$\u0006\u0081\u0095\u00c3\u0017@\u00db\u00f9~j\u00bct\u00ef\u00bf\u00b8\u001e\u0085\u00ebQ\u00b82@33333\u00b3\u0010@\u00f2\u00d2Mb\u0010X\u00b9?\u00cf\u00f7S\u00e3\u00a5\u00bb2@433333\u0010@P\u008d\u0097n\u0012\u0083\u00f4\u00bfj\u00bct\u0093\u0018\u00c43@\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u0010@5^\u00baI\f\u0002\u00f9\u00bfh\u0091\u00ed|?\u00152@\u00f2\u00d2Mb\u0010X\u0007@h\u0091\u00ed|?5\u0003\u00c0\u00d5x\u00e9&1(1@\u0014\u00aeG\u00e1z\u0014\b@\"\u00b0rh\u0091\u00ed\u00f2\u00bf\u00d5x\u00e9&1\u00a82@\u00c2\u00ca\u00a1E\u00b6\u00f3\u00fb?\u0018\u00d9\u00ce\u00f7S\u00e3\u00dd\u00bf`\u00e5\u00d0\"\u00dbY3@\u0080j\u00bct\u0093\u0018\u00fe?\u0019\u0004V\u000e-\u00b2\u00fd\u00bf\u009e\u00ef\u00a7\u00c6Kw2@\u008e\u0097n\u0012\u0083\u00c0\u00da?\u00b4\u00c8v\u00be\u009f\u001a\u0007\u00c0\u001a\u0004V\u000e-\u00d22@D\u008bl\u00e7\u00fb\u00a9\u00d9?J\f\u0002+\u0087\u0016\u00fb\u00bfD\u008bl\u00e7\u00fb\u00e90@\u001c/\u00dd$\u0006\u0081\u00a5?\u00aeG\u00e1z\u0014\u00ae\u00f3\u00bfj\u00bct\u0093\u0018d3@\u009f\u00ef\u00a7\u00c6K7\u00e5\u00bf\u00aeG\u00e1z\u0014\u00ae\u00c7\u00bf\u00a6\u009b\u00c4 \u00b0\u00123@@5^\u00baI\f\u00e6\u00bf\u000e-\u00b2\u009d\u00ef\u00a7\u00e2\u00bf\u009a\u0099\u0099\u0099\u0099Y0@\u0092\u00ed|?5^\u00ca?$\u00db\u00f9~j\u00bc\u00fe\u00bf\u0019\u0004V\u000e-23@Nb\u0010X9\u00b4\u0000\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2M\u00f8\u00bf\u0019\u0004V\u000e-R2@\u00e3\u00a5\u009b\u00c4 \u00b0\u0004\u00c0q=\n\u00d7\u00a3p\u00fb\u00bf\u0011X9\u00b4\u00c8\u00164@(1\b\u00ac\u001cZ\u0005\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\u0007\u00c0\u00c5 \u00b0rh\u00113@\u00e3\u00a5\u009b\u00c4 \u00b0\u00fe\u00bf\u0098n\u0012\u0083\u00c0\u00ca\u00f5\u00bf\u00cav\u00be\u009f\u001a\u00ef4@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u00cc\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u00f0\u00bf=\n\u00d7\u00a3p\u001d5@\u00f2\u00d2Mb\u0010X\u00e9?ffffff\u00e6\u00bf\u00d8\u00a3p=\n\u00975@\u00f7(\\\u008f\u00c2\u00f5\u00e8\u00bf.\u00b2\u009d\u00ef\u00a7\u00c6\u0002\u00c0\\\u008f\u00c2\u00f5(\\5@\u00f9S\u00e3\u00a5\u009b\u00c4\u00d8\u00bf\u000b\u00d7\u00a3p=\n\u0006\u00c0\u0019\u0004V\u000e-20@\u00edQ\u00b8\u001e\u0085\u00eb\u00d9\u00bf\u009a\u0099\u0099\u0099\u0099\u0099\f\u00c0\u00b4\u00c8v\u00be\u009f\u00ba0@\u009c\u00c4 \u00b0rh\u00e5\u00bf\u0098n\u0012\u0083\u00c0\u00ca\u0005\u00c0\u001f\u0085\u00ebQ\u00b8\u009e-@\u00e2z\u0014\u00aeG\u00e1\u00ee\u00bf\u00e8\u00fb\u00a9\u00f1\u00d2M\u00fe\u00bf$\u00db\u00f9~j|,@\u00c3\u00f5(\\\u008f\u00c2\u00e1\u00bf#\u00db\u00f9~j\u00bc\u0005\u00c0v\u0093\u0018\u0004V\u008e-@{\u0014\u00aeG\u00e1z\u0003\u00c0\u00ad\u001cZd;\u00df\u000f\u00c0V\u000e-\u00b2\u009d\u00ef+@5^\u00baI\f\u0002\u00e3\u00bf\u00b2\u009d\u00ef\u00a7\u00c6K\u0013\u00c0\u009f\u00ef\u00a7\u00c6K\u00b7,@\u00e3\u00a5\u009b\u00c4 \u00b0\u00f2\u00bf\u009a\u0099\u0099\u0099\u0099\u0099\f\u00c0j\u00bct\u0093\u0018\u00c4.@\u0099n\u0012\u0083\u00c0\u00ca\b\u00c0\u00bct\u0093\u0018\u0004V\u000f\u00c0\u0089A`\u00e5\u00d0\u00e2(@@5^\u00baI\f\u00ea\u00bf\u0098n\u0012\u0083\u00c0J\u0013\u00c0\u0096C\u008bl\u00e7\u00fb'@\u00da\u00ce\u00f7S\u00e3\u00a5\u00db\u00bf\u000f-\u00b2\u009d\u00ef\u00a7\b\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u0013(@\u0000\u0000\u0000\u0000\u0000\u0000\u00d0\u00bf\u00b8\u001e\u0085\u00ebQ\u00b8\r\u00c0\u00baI\f\u0002+\u0087(@\u00ac\u001cZd;\u00df\u00fd\u00bf\u0018\u00d9\u00ce\u00f7Sc\u0011\u00c0:\u00b4\u00c8v\u00be_,@/\u00dd$\u0006\u0081\u0095\u00e7?\u00db\u00f9~j\u00bct\u0013\u00c0>\n\u00d7\u00a3p\u00fd-@\u00dd$\u0006\u0081\u0095C\u00e7?\b\u00ac\u001cZd;\u00fd\u00bf\u00e2z\u0014\u00aeG\u00e1+@\"\u00b0rh\u0091\u00ed\u0007\u00c0:\u00b4\u00c8v\u00be\u009f\u00f2\u00bfS\u00b8\u001e\u0085\u00eb\u0011+@#\u00db\u00f9~j\u00bc\u0002\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u00fe\u00bf\u00f0\u00a7\u00c6K7\t+@q=\n\u00d7\u00a3p\u0011\u00c0T\u00e3\u00a5\u009b\u00c4 \u0007\u00c0\u00de$\u0006\u0081\u0095\u0083+@o\u0012\u0083\u00c0\u00ca!\u0013\u00c0\u009e\u00ef\u00a7\u00c6K7\u00fd\u00bfX9\u00b4\u00c8v\u00fe'@\u00cd\u00cc\u00cc\u00cc\u00ccL\u0011\u00c0j\u00bct\u0093\u0018\u0004\u00ea\u00bf\u0096C\u008bl\u00e7{,@\u00dc\u00f9~j\u00bc\u00f4\u0014\u00c02\b\u00ac\u001cZd\u00ef\u00bfV\u000e-\u00b2\u009d\u00ef+@\u009a\u0099\u0099\u0099\u0099\u0019\u0019\u00c0<\u00dfO\u008d\u0097n\u00ee\u00bf\u007fj\u00bct\u0093\u0098.@\n\u00d7\u00a3p=\n\u0014\u00c0\u0004V\u000e-\u00b2\u009d\u00f7\u00bf\u00e4\u00a5\u009b\u00c4 \u00b0&@Y9\u00b4\u00c8v\u00be\n\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u00e2?9\u00b4\u00c8v\u00be\u00df+@\u00f8S\u00e3\u00a5\u009bD\u0013\u00c0\f\u0002+\u0087\u0016\u00d9\u00f4?\r\u0002+\u0087\u0016Y*@w\u00be\u009f\u001a/]\u0016\u00c0\u00e5\u00d0\"\u00db\u00f9~\u00ee?\u00afG\u00e1z\u0014.*@\u001f\u0085\u00ebQ\u00b8\u001e\u001a\u00c0333333\u0002@\u00a2E\u00b6\u00f3\u00fd\u0014*@.\u00b2\u009d\u00ef\u00a7F\u0015\u00c0\u00a4p=\n\u00d7\u00a3\u00f0?\u00fd\u00a9\u00f1\u00d2M\u00a2,@\u00c2\u00ca\u00a1E\u00b6\u00f3\r\u00c0\u00fa~j\u00bct\u0093\u0001\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb&@\u00e5\u00d0\"\u00db\u00f9\u00fe\u0015\u00c0\u0091\u00ed|?5^\u0003\u00c0)\\\u008f\u00c2\u00f5\u00e8'@h\u0091\u00ed|?5\u0019\u00c0+\u0087\u0016\u00d9\u00ce\u00f7\u0000\u00c0d;\u00dfO\u008d\u00d7#@\u008d\u0097n\u0012\u0083\u00c0\u0016\u00c0\u0092\u00ed|?5^\u0006\u00c0?5^\u00baI\f#@\u0094\u0018\u0004V\u000e\u00ad\u0013\u00c0M7\u0089A`\u00e5\u00e4\u00bf\b\u00ac\u001cZd\u00bb\"@Zd;\u00dfO\r\u0016\u00c0\u00d1\"\u00db\u00f9~j\u0006\u00c0\u00f6(\\\u008f\u00c2\u00f5\"@<\u00dfO\u008d\u0097\u00ee\u001b\u00c0\b\u00ac\u001cZd;\u0003\u00c0\u0000\u0000\u0000\u0000\u0000@$@\u0080j\u00bct\u0093\u0018\u001f\u00c0P\u008d\u0097n\u0012\u0083\u0003\u00c0\u0093\u0018\u0004V\u000e\u00ed @j\u00bct\u0093\u0018\u0084\u001c\u00c0\u00cf\u00f7S\u00e3\u00a5\u009b\u00d4\u00bfZd;\u00dfO\u008d @-\u00b2\u009d\u00ef\u00a7\u00c6\u0013\u00c0\u00c9v\u00be\u009f\u001a/\u0011\u00c0\u00b4\u00c8v\u00be\u009f\u00da\"@\u00b4\u00c8v\u00be\u009f\u001a\u001c\u00c0\u00e4\u00a5\u009b\u00c4 0\u0014\u00c0\u00fe\u00d4x\u00e9&\u00f1#@\u00f0\u00a7\u00c6K7\t \u00c0\u001c/\u00dd$\u0006\u0001\u0013\u00c0W\u000e-\u00b2\u009d/%@\u00c1\u00ca\u00a1E\u00b6\u00b3!\u00c0:\u00b4\u00c8v\u00be\u001f\u0015\u00c0R\u00b8\u001e\u0085\u00ebQ!@\u008cl\u00e7\u00fb\u00a9\u00f1\u0018\u00c0E\u008bl\u00e7\u00fb)\u001a\u00c0/\u00dd$\u0006\u0081\u00d5!@\u0089A`\u00e5\u00d0\"\u001b\u00c0\u00a4p=\n\u00d7\u00a3\u0014\u00c0\u00c4\u00f5(\\\u008f\u00c2\u001e@/\u00dd$\u0006\u0081\u0015\u0015\u00c0\u00de$\u0006\u0081\u0095\u00c3\u0010\u00c0\u00ee|?5^\u00ba\u001d@\u00fa~j\u00bct\u0093\u0013\u00c0Zd;\u00dfO\u008d\u0019\u00c0\u008bl\u00e7\u00fb\u00a9\u00b1#@:\u00b4\u00c8v\u00be\u001f\u001f\u00c0$\u00db\u00f9~j<\u001c\u00c0\u0081\u0095C\u008bl'$@sh\u0091\u00ed|\u00ff \u00c0\u009c\u00c4 \u00b0r\u00e8\u001d\u00c0\u00c9v\u00be\u009f\u001a/\u001d@\n\u00d7\u00a3p=\u008a\u0014\u00c0\u0014\u00aeG\u00e1z\u0094 \u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\u001b@5^\u00baI\f\u0002\u0012\u00c0\u00aa\u00f1\u00d2Mb\u0090\u001e\u00c0\u00aa\u00f1\u00d2Mb\u0090 @^\u00baI\f\u0002\u00ab\u0018\u00c0R\u00b8\u001e\u0085\u00eb\u0011!\u00c0\u00ac\u001cZd;_!@L7\u0089A`e\u001a\u00c0L7\u0089A`\u00e5\u0018\u00c0L7\u0089A`\u00e5\u001b@\u00a6\u009b\u00c4 \u00b0\u00f2\u0012\u00c0~?5^\u00baI\u0018\u00c0\u00da\u00ce\u00f7S\u00e3%\u0019@\u00d2\"\u00db\u00f9~j\u000f\u00c0\u00a8\u00c6K7\u0089A\u00d0?\u0086\u00ebQ\u00b8\u001eE$@\u009e\u00ef\u00a7\u00c6K7\u0018\u00c0;\u00dfO\u008d\u0097n\u0092\u00bf\u00baI\f\u0002+\u0007&@\u001eZd;\u00df\u00cf\u0019\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M\u00fa?\u0096C\u008bl\u00e7\u00bb#@V\u000e-\u00b2\u009do\u0017\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u0001@j\u00bct\u0093\u0018D%@\u00b0rh\u0091\u00ed|\u0019\u00c0\u001c/\u00dd$\u0006\u0081\u00ff?\u00ea&1\b\u00ac\u00dc!@\u00fe\u00d4x\u00e9&1\u0019\u00c0\u00baI\f\u0002+\u0087\u0001@D\u008bl\u00e7\u00fb\u00a9#@\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0011\u00c0\u00d3Mb\u0010X9\b@\u00de$\u0006\u0081\u0095\u0003\"@Zd;\u00dfO\u008d\u0010\u00c0\n\u00d7\u00a3p=\n\u00f9?}?5^\u00ba\t%@n\u00e7\u00fb\u00a9\u00f1\u00d2\u000b\u00c0\u001b/\u00dd$\u0006\u0081\u00e9?\u00be\u009f\u001a/\u00dd$&@\u00c4\u00f5(\\\u008f\u00c2\u000e\u00c0#\u00db\u00f9~j\u00bc\u00fc?H\u00e1z\u0014\u00ae\u0007%@\n\u00d7\u00a3p=\n\u0000\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\u0006@433333%@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u00fc\u00bf\u001f\u0085\u00ebQ\u00b8\u001e\u00f5?\u00cd\u00cc\u00cc\u00cc\u00ccL\"@\u00dc\u00f9~j\u00bct\u00f7\u00bf\u0012\u0083\u00c0\u00ca\u00a1E\u00f2?i\u0091\u00ed|?u'@Nb\u0010X9\u00b4\u00f4\u00bf\t\u00ac\u001cZd;\u00af?^\u00baI\f\u0002k'@\u00b6\u00f3\u00fd\u00d4x\u00e9\u00f2\u00bf\\\u008f\u00c2\u00f5(\\\u00f5?q=\n\u00d7\u00a30)@\u00a2E\u00b6\u00f3\u00fd\u00d4\u00fe\u00bf\u00b4\u00c8v\u00be\u009f\u001a\u0000@\u0090\u00c2\u00f5(\\\u00cf @\u001b/\u00dd$\u0006\u0081\u00e9\u00bf\u00aa\u00f1\u00d2Mb\u0010\u00fc?\u00d5x\u00e9&1\b(@\u0083\u00c0\u00ca\u00a1E\u00b6\u00b3?\u0012\u0083\u00c0\u00ca\u00a1E\u00fc?433333&@\u00f4\u00fd\u00d4x\u00e9&\u00e5?\u000b\u00d7\u00a3p=\n\u0006@\u0089A`\u00e5\u00d0\u00e2(@Zd;\u00dfO\u008d\u0097\u00bf\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u00ec?433333*@\u00bct\u0093\u0018\u0004V\u00e6?\u00aa\u00f1\u00d2Mb\u0010\u00e4?n\u00e7\u00fb\u00a9\u00f1\u00d2+@\u00db\u00f9~j\u00bct\u00a3?\u00fc\u00a9\u00f1\u00d2Mb\u00a0\u00bf~?5^\u00baI)@ffffff\u00f0?ffffff\u00f8?Zd;\u00dfO\r+@\u001dZd;\u00dfO\u00ff?1\b\u00ac\u001cZd\u0003@^\u00baI\f\u0002+*@\u00b6\u00f3\u00fd\u00d4x\u00e9\u0000@\u00db\u00f9~j\u00bct\u00b3?~?5^\u00baI.@\u00e0O\u008d\u0097n\u0012\u0005@$\u00db\u00f9~j\u00bc\u00d4\u00bf \u0085\u00ebQ\u00b8^.@H\u00e1z\u0014\u00aeG\u00fb?\u00f9S\u00e3\u00a5\u009b\u00c4\u00d8\u00bf\u0004V\u000e-\u00b2]/@7\u0089A`\u00e5\u00d0\n@Zd;\u00dfO\u008d\u00f9?\u008d\u0097n\u0012\u0083\u0000-@n\u00e7\u00fb\u00a9\u00f1\u00d2\u000f@\u001f\u0085\u00ebQ\u00b8\u001e\u00f3?\u00f2\u00d2Mb\u0010\u0018.@\u00b6\u00f3\u00fd\u00d4x\u00e9\u0012@\u00a6\u009b\u00c4 \u00b0r\u0001@\u00a9\u00c6K7\u0089\u0081+@\u00a8\u00c6K7\u0089A\u0011@d;\u00dfO\u008d\u0097\u00f0?h\u0091\u00ed|?\u00b5,@\u00cc\u00a1E\u00b6\u00f3\u00fd\u0006@\u00fa~j\u00bct\u0093\u00b8?\u0096C\u008bl\u00e7{!@r=\n\u00d7\u00a3p\u00fd\u00bfP\u008d\u0097n\u0012\u0083\u00d8\u00bfNb\u0010X9t\"@\u00ef|?5^\u00ba\u0004\u00c0\u00d3Mb\u0010X9\u00dc\u00bf\u00cav\u00be\u009f\u001a\u00af\u001d@\u00b5\u00c8v\u00be\u009f\u001a\u00f9\u00bf(1\b\u00ac\u001cZ\u00dc\u00bf\u001f\u0085\u00ebQ\u00b8\u009e\u001d@c\u0010X9\u00b4\u00c8\u00de\u00bfY9\u00b4\u00c8v\u00be\u00df?\r\u0002+\u0087\u0016Y\u0019@\u007fj\u00bct\u0093\u0018\u0001\u00c0\u00baI\f\u0002+\u0087\u00fe\u00bf\u00bct\u0093\u0018\u0004\u00d6\u001c@\u0092\u00ed|?5^\u0000\u00c0\u0096C\u008bl\u00e7\u00fb\u00ff\u00bf\u00b3\u009d\u00ef\u00a7\u00c6K\u001e@\u00f0\u00a7\u00c6K7\u0089\b\u00c0\u00e1z\u0014\u00aeG\u00e1\u00e6?\u00b2\u009d\u00ef\u00a7\u00c6K\u0015@\u00f5\u00fd\u00d4x\u00e9&\u00f7\u00bf\u00baI\f\u0002+\u0087\u0005\u00c09\u00b4\u00c8v\u00be_ @5^\u00baI\f\u0002\u00f3\u00bf?5^\u00baI\f\u0001\u00c0\u0096C\u008bl\u00e7;\"@\u001f\u0085\u00ebQ\u00b8\u001e\u00f1\u00bf333333\u0007\u00c0\u0092\u00ed|?5\u00de\u001e@\u001eZd;\u00dfO\u00cd\u00bf{\u0014\u00aeG\u00e1z\u0003\u00c0V\u000e-\u00b2\u009d\u00ef\u0016@+\u0087\u0016\u00d9\u00ce\u00f7\u00ff\u00bf\u00d6x\u00e9&1\b\u0000\u00c0Nb\u0010X94\u0015@\u00be\u009f\u001a/\u00dd$\u0007\u00c0\u00e9&1\b\u00ac\u001c\f\u00c0Y9\u00b4\u00c8v>\u0017@\u00bct\u0093\u0018\u0004V\u0001\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u0001\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M\u0015@\u00a8\u00c6K7\u0089A\u00f0\u00bf\u00e5\u00d0\"\u00db\u00f9~\u0010\u00c0y\u00e9&1\b\u00ec @T\u00e3\u00a5\u009b\u00c4 \u00fc\u00bf\b\u00ac\u001cZd;\u0012\u00c0\u00f0\u00a7\u00c6K7\u0089\"@#\u00db\u00f9~j\u00bc\u00f2\u00bfV\u000e-\u00b2\u009do\u0010\u00c0m\u00e7\u00fb\u00a9\u00f1\u0092!@1\b\u00ac\u001cZd\u0006\u00c0;\u00dfO\u008d\u0097\u00ee\u0012\u00c0-\u00b2\u009d\u00ef\u00a7F\u001e@\u00e7\u00fb\u00a9\u00f1\u00d2M\u00fa\u00bf\u00de$\u0006\u0081\u0095C\u00ef?\u00e2z\u0014\u00aeG\u00e1\u0019@C`\u00e5\u00d0\"\u00db\n\u00c0\u00cf\u00f7S\u00e3\u00a5\u009b\u00e4?B`\u00e5\u00d0\"\u00db\u001c@\u0090\u00c2\u00f5(\\\u008f\u000f\u00c0ffffff\u00fc?P\u008d\u0097n\u0012\u0083\u0015@5^\u00baI\f\u0002\u0010\u00c05^\u00baI\f\u0002\u00f5?)\\\u008f\u00c2\u00f5\u00a8\u0011@\u00f2\u00d2Mb\u0010X\u000e\u00c0\u00c9v\u00be\u009f\u001a/\t@\u0093\u0018\u0004V\u000e-\u0015@\u0093\u0018\u0004V\u000e-\n\u00c0c\u0010X9\u00b4\u00c8\u00fe?\u00fb~j\u00bct\u0013\u0017@\u00aa\u00f1\u00d2Mb\u0010\u0016\u00c0\u00ac\u001cZd;\u00df\u0000@B`\u00e5\u00d0\"[\u001b@\u00bct\u0093\u0018\u0004V\u0016\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2M\r@L7\u0089A`\u00e5\u0010@h\u0091\u00ed|?5\u0007\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2\u0007@\u00a2E\u00b6\u00f3\u00fd\u00d4\u0013@\u00f6(\\\u008f\u00c2u\u0018\u00c0\u00db\u00f9~j\u00bct\u0006@\t\u00ac\u001cZd;\u000f@\u00e9&1\b\u00ac\u009c\u0017\u00c0\u0011X9\u00b4\u00c8v\b@\u000e-\u00b2\u009d\u00ef'\u0014@\u00f8S\u00e3\u00a5\u009b\u00c4\u001c\u00c0Y9\u00b4\u00c8v\u00be\u000f@\u001eZd;\u00df\u00cf\u0014@\u00b6\u00f3\u00fd\u00d4x\u00e9\u0016\u00c0R\u00b8\u001e\u0085\u00ebQ\u00e0?V\u000e-\u00b2\u009do\u0015@\u001b/\u00dd$\u0006\u0081\u0018\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\u00e0?d;\u00dfO\u008d\u0017\u0011@\u00e1z\u0014\u00aeG\u00e1\u0018\u00c0\u00a8\u00c6K7\u0089A\u00d0\u00bf333333\u0017@!\u00b0rh\u0091\u00ed\u0015\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u00d0?\u00c3\u00f5(\\\u008fB\u0017@\u001eZd;\u00dfO\u001c\u00c0\u0018\u00d9\u00ce\u00f7S\u00e3\r@\u001eZd;\u00df\u00cf\u0019@/\u00dd$\u0006\u0081\u0095\u0006\u00c0&\u0006\u0081\u0095C\u008b\n@\u00b9\u001e\u0085\u00ebQ8\u001d@<\u00dfO\u008d\u0097n\t\u00c0\u00a4p=\n\u00d7#\u0013@\r\u0002+\u0087\u0016Y\u001a@\u0012\u0083\u00c0\u00ca\u00a1E\u00fc\u00bf\u00a4p=\n\u00d7\u00a3\u0016@|\u0014\u00aeG\u00e1z\u0018@-\u00b2\u009d\u00ef\u00a7\u00c6\u0001\u00c0\u00aa\u00f1\u00d2Mb\u0010\u0012@\u00baI\f\u0002+\u0087\u0017@\u00c9v\u00be\u009f\u001a/\u00dd\u00bf\u0018\u00d9\u00ce\u00f7S\u00e3\u0014@\u00a6\u009b\u00c4 \u00b02 @\u00b5\u00c8v\u00be\u009f\u001a\u00f9\u00bfw\u00be\u009f\u001a/]\u0011@\u00d0\u00f7S\u00e3\u00a5[!@\u0090\u00c2\u00f5(\\\u008f\u00f4\u00bf=\n\u00d7\u00a3p\u00bd\u0014@L7\u0089A`\u00e5\u0013@h\u0091\u00ed|?5\u00be\u00bf\u00bf\u009f\u001a/\u00dd$\u0019@\u00f4\u00fd\u00d4x\u00e9\u00a6 @\u00a4p=\n\u00d7\u00a3\u00e0\u00bf\u00bf\u009f\u001a/\u00dd\u00a4\u001b@\u00d4Mb\u0010X\u00b9\u001d@\u009c\u00c4 \u00b0rh\u00e1\u00bf\u00a0\u001a/\u00dd$\u0086\u001b@\u000e-\u00b2\u009d\u00efg\"@D\u008bl\u00e7\u00fb\u00a9\u00e9\u00bf@5^\u00baI\u008c\u0017@\u00c5 \u00b0rh\u00d1 @\u00b2\u009d\u00ef\u00a7\u00c6K\u00df?\u0002+\u0087\u0016\u00d9\u00ce\u0016@\u00b6\u00f3\u00fd\u00d4xi!@R\u00b8\u001e\u0085\u00ebQ\u0006\u00c0j\u00bct\u0093\u0018\u0084\u0013@43333s!@\u00e7\u00fb\u00a9\u00f1\u00d2M\n\u00c0\u007fj\u00bct\u0093\u0018\u000b@\u001b/\u00dd$\u0006\u0081\u0018@\u00e9&1\b\u00ac\u001c\u00d2?\u00c7K7\u0089A`\u0006@\u00f4\u00fd\u00d4x\u00e9\u00a6\u001b@Zd;\u00dfO\u008d\u00a7?\u008cl\u00e7\u00fb\u00a9\u00f1\u0007@\u0010X9\u00b4\u00c8\u00f6\u0014@L7\u0089A`\u00e5\u00f6?S\u00b8\u001e\u0085\u00ebQ\r@\u0014\u00aeG\u00e1z\u0094\u0015@h\u0091\u00ed|?5\u0002@\u00e1z\u0014\u00aeG\u00e1\b@\n\u00d7\u00a3p=\n\u000e@\u00bct\u0093\u0018\u0004V\u00f2?\u001b/\u00dd$\u0006\u0081\u00f9?\u00aa\u00f1\u00d2Mb\u0090\u0016@q=\n\u00d7\u00a3p\u00ff?\u00a3E\u00b6\u00f3\u00fd\u00d4\u00fc?k\u00bct\u0093\u0018\u0084\u001a@\"\u00b0rh\u0091\u00ed\u0002@z\u00e9&1\b\u00ac\u00ec?\u00e3\u00a5\u009b\u00c4 0\u0017@\u00e9&1\b\u00ac\u001c\u00f2?U\u00e3\u00a5\u009b\u00c4 \r@\u00b8\u001e\u0085\u00ebQ\u00b8\u0007@\n\u00d7\u00a3p=\n\u00ff?\u00db\u00f9~j\u00bct\u00ef?\u00ecQ\u00b8\u001e\u0085\u00eb\u0012@0\u00dd$\u0006\u0081\u0095\b@\u00ee|?5^\u00ba\u00ed?~?5^\u00baI\r@\u00c2\u00ca\u00a1E\u00b6\u00f3\u0006@\u00b4\u00c8v\u00be\u009f\u001a\u00fd?\u00f6(\\\u008f\u00c2u\u0013@\u0098n\u0012\u0083\u00c0J\u0011@\u001f\u0085\u00ebQ\u00b8\u001e\u0006@\u0012\u0083\u00c0\u00ca\u00a1E\u0011@\u00d3Mb\u0010X9\u0011@\u00d9\u00ce\u00f7S\u00e3\u00a5\u00f5?h\u0091\u00ed|?\u00b5\u0011@\u00a2E\u00b6\u00f3\u00fd\u00d4\u0014@\u001dZd;\u00dfO\u0000@\u0089A`\u00e5\u00d0\u00a2\u0017@\u00cd\u00cc\u00cc\u00cc\u00ccL\u0012@\u00f2\u00d2Mb\u0010X\u00d9\u00bfT\u00e3\u00a5\u009b\u00c4 \u0015@\u0015\u00aeG\u00e1z\u0014\u000b@\u00d1\"\u00db\u00f9~j\u00cc\u00bf\u00b3\u009d\u00ef\u00a7\u00c6K\u0019@\u00bf\u009f\u001a/\u00dd$\r@\u00f0\u00a7\u00c6K7\u0089\u00e9\u00bf\u00e1z\u0014\u00aeG\u00e1\u0012@\u00b6\u00f3\u00fd\u00d4x\u00e9\u0010@{\u0014\u00aeG\u00e1z\u00f2\u00bf\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0014@\u00f6(\\\u008f\u00c2\u00f5\u0004@\u00db\u00f9~j\u00bct\u0003@\u00b9\u001e\u0085\u00ebQ\u00b8\n@\u00c3\u00f5(\\\u008f\u00c2\u00b5?\u0082\u0095C\u008bl\u00e7\u00fd?\u00c3\u00f5(\\\u008f\u00c2\u000f@\u0018\u00d9\u00ce\u00f7S\u00e3\u00dd\u00bf\u0096C\u008bl\u00e7\u00fb\u0002@&\u0006\u0081\u0095C\u008b\u00fe?\u00e5\u00d0\"\u00db\u00f9~\u00d2\u00bf\u0084\u00c0\u00ca\u00a1E\u00b6\u00ff?\u00db\u00f9~j\u00bct\u00f5?B`\u00e5\u00d0\"\u00db\u00e1?\u00c6 \u00b0rh\u0091\u000e@z\u00e9&1\b\u00ac\u00f6?\u00d7\u00a3p=\n\u00d7\u00e3\u00bf\u00dd$\u0006\u0081\u0095C\u00f5?\u00fa~j\u00bct\u0093\u00fc?L7\u0089A`\u00e5\u00f6\u00bf\u00be\u009f\u001a/\u00dd$\u00fa?\u00a9\u00c6K7\u0089A\u0004@}?5^\u00baI\u0001\u00c0b\u0010X9\u00b4H\u0010@\u009c\u00c4 \u00b0rh\u00d1?\u00cav\u00be\u009f\u001a/\u00d5\u00bf\u00d1\"\u00db\u00f9~j\u00bc\u00bf\u00e1z\u0014\u00aeG\u00e1\u0000@e;\u00dfO\u008d\u0097\u00ee\u00bfH\u00e1z\u0014\u00aeG\u00c1\u00bf\u00dc\u00f9~j\u00bct\b@6^\u00baI\f\u0002\u00db\u00bf\u00e5\u00d0\"\u00db\u00f9~\u00da\u00bf\u00fa~j\u00bct\u0093\u00f6?\u00b6\u00f3\u00fd\u00d4x\u00e9\u00c6\u00bf\u000e-\u00b2\u009d\u00ef\u00a7\u00f6?\u0098n\u0012\u0083\u00c0\u00ca\u00d9?q=\n\u00d7\u00a3p\u0001\u00c0\u00ad\u001cZd;\u00df\u00ef?r=\n\u00d7\u00a3p\u00dd?\u00baI\f\u0002+\u0087\t\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u00eb?y\u00e9&1\b\u00ac\u00d4\u00bf\u001dZd;\u00dfO\u00f9\u00bfd;\u00dfO\u008d\u0097\u0003@b\u0010X9\u00b4\u00c8\u00b6?r=\n\u00d7\u00a3p\u0002\u00c0\u00a8\u00c6K7\u0089A\u00f2\u00bfB`\u00e5\u00d0\"\u00db\u0000@\u00a2E\u00b6\u00f3\u00fd\u00d4\u0000\u00c0\n\u00d7\u00a3p=\n\u00e7\u00bf\u0081\u0095C\u008bl\u00e7\u0005@J\f\u0002+\u0087\u0016\u0007\u00c0=\n\u00d7\u00a3p=\u0000\u00c0\u00d7\u00a3p=\n\u00d7\u0004@[d;\u00dfO\u008d\u00fb\u00bf\u00cb\u00a1E\u00b6\u00f3\u00fd\u00f4\u00bf\u0006\u0081\u0095C\u008bl\u00f1?\u00c7K7\u0089A`\u0003\u00c0\u008f\u00c2\u00f5(\\\u008f\u0012@Zd;\u00dfO\u008d\u0002@\u00f4\u00fd\u00d4x\u00e9&\u00f3\u00bf\u008bl\u00e7\u00fb\u00a9\u00f1\u0010@\u00ef|?5^\u00ba\t@\u00e6\u00d0\"\u00db\u00f9~\u00f6\u00bf43333\u00b3\u0017@\u00c6 \u00b0rh\u0091\u00fd?h\u0091\u00ed|?5\u00fa\u00bf\u00e8\u00fb\u00a9\u00f1\u00d2M\u0017@\u00d3Mb\u0010X9\u00ec?\n\u00d7\u00a3p=\n\u0001\u00c0gfffff\u001b@\u0084\u00c0\u00ca\u00a1E\u00b6\u00fb?\u00dd$\u0006\u0081\u0095C\u00db\u00bfj\u00bct\u0093\u0018\u0004\u001a@\u00a6\u009b\u00c4 \u00b0r\u0006@\u009a\u0099\u0099\u0099\u0099\u0099\u0005\u00c0+\u0087\u0016\u00d9\u00ce\u00f7\u001a@\"\u00b0rh\u0091\u00ed\r@P\u008d\u0097n\u0012\u0083\u0001\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u001d@y\u00e9&1\b\u00ac\u0003@\u0003+\u0087\u0016\u00d9\u00ce\b\u00c0\u00b8\u001e\u0085\u00ebQ8\u001f@-\u00b2\u009d\u00ef\u00a7\u00c6\u00ef?\u00edQ\u00b8\u001e\u0085\u00eb\u00d9\u00bfH\u00e1z\u0014\u00aeG\u0017@?5^\u00baI\f\b@\u00a9\u00c6K7\u0089A\u000f\u00c0j\u00bct\u0093\u0018\u0004\u0014@\u00f8S\u00e3\u00a5\u009b\u00c4\u000b@\u0005V\u000e-\u00b2\u009d\r\u00c0;\u00dfO\u008d\u0097\u00ee\u0019@\u00be\u009f\u001a/\u00dd$\u0003@C`\u00e5\u00d0\"\u00db\u00e5?\u00ee|?5^\u00ba\u0016@\u0096C\u008bl\u00e7\u00fb\u0007@\u0091\u00ed|?5^\u00e2?v\u0093\u0018\u0004V\u008e\u001c@\u00d5x\u00e9&1\b\u0001@433333\u0000@V\u000e-\u00b2\u009do @=\n\u00d7\u00a3p=\u0001@\u00cav\u00be\u009f\u001a/\u00ff?\u001a\u0004V\u000e-\u00b2\u001a@\u0006\u0081\u0095C\u008bl\u00e7?\u00e1z\u0014\u00aeG\u00e1\u0003@\u00f9S\u00e3\u00a5\u009bD\u001b@\u00fb~j\u00bct\u0093\t@\u00f0\u00a7\u00c6K7\u0089\b@\n\u00d7\u00a3p=\u008a\u001c@\u00dfO\u008d\u0097n\u0092\u0010@T\u00e3\u00a5\u009b\u00c4 \u0005@\u007fj\u00bct\u0093\u0018\u0017@\u00e0O\u008d\u0097n\u0012\u000b@\u001a\u0004V\u000e-\u00b2\n@B`\u00e5\u00d0\"\u00db\u001d@\u00a4p=\n\u00d7\u00a3\u00c0\u00bf\u00db\u00f9~j\u00bct\u0006@\u00aa\u00f1\u00d2Mb\u0090\u001e@\u00be\u009f\u001a/\u00dd$\u0007@\u00a8\u00c6K7\u0089A\u0011@&\u0006\u0081\u0095C\u000b\u001c@~?5^\u00baI\u0007@\u0019\u0004V\u000e-2\u0016@B`\u00e5\u00d0\"\u00db\u0017@R\u00b8\u001e\u0085\u00ebQ\t@i\u0091\u00ed|?5\u0016@\u00a2E\u00b6\u00f3\u00fd\u0014\"@(1\b\u00ac\u001cZ\u0005@\u0083\u00c0\u00ca\u00a1E6\u0011@\u00bct\u0093\u0018\u0004\u0016#@\u0000\u0000\u0000\u0000\u0000\u0000\u0006@\u0002+\u0087\u0016\u00d9\u00ce\n@\u00f5\u00fd\u00d4x\u00e9\u00a6\u001e@\u00d4Mb\u0010X9\u0005@6^\u00baI\f\u0002\u001b@\u00f9S\u00e3\u00a5\u009bD\u001c@V\u000e-\u00b2\u009d\u00ef\u0005@\u007fj\u00bct\u0093\u0098\u001e@\b\u00ac\u001cZd{#@X9\u00b4\u00c8v\u00be\u0002@\u00cc\u00a1E\u00b6\u00f3\u00fd\u0015@\u00aa\u00f1\u00d2Mb\u0090%@\f\u0002+\u0087\u0016\u00d9\u0000@ \u0085\u00ebQ\u00b8\u009e\u0015@7\u0089A`\u00e5\u0010\"@\u008aA`\u00e5\u00d0\"\u0002@\u00e2z\u0014\u00aeG\u00e1\u001a@\u00cf\u00f7S\u00e3\u00a5\u001b#@d;\u00dfO\u008d\u0097\u0000@\u00aa\u00f1\u00d2Mb\u0090\u001e@;\u00dfO\u008d\u0097n\u0015@\u0093\u0018\u0004V\u000e-\u00da?\u00fb~j\u00bct\u0093\u0004@\u001dZd;\u00df\u00cf\u0012@~?5^\u00baI\u00f2?\u0000\u0000\u0000\u0000\u0000\u0000\u0003@\u0085\u00ebQ\u00b8\u001e\u0085\u0013@\u00de$\u0006\u0081\u0095C\u00ef\u00bf+\u0087\u0016\u00d9\u00ce\u00f7\u0005@\u00db\u00f9~j\u00bct\u0014@\u00fc\u00a9\u00f1\u00d2Mb\u00f4\u00bf\u00c9v\u00be\u009f\u001a/\u000e@\u0098n\u0012\u0083\u00c0\u00ca\u000e@(1\b\u00ac\u001cZ\u00ec\u00bf\u0006\u0081\u0095C\u008bl\u0003@\u001dZd;\u00df\u00cf\u0016@\u00f4\u00fd\u00d4x\u00e9&\u00ff\u00bf\u00fb~j\u00bct\u0093\u00fe?\u0093\u0018\u0004V\u000e-\u0019@\u000e-\u00b2\u009d\u00ef\u00a7\u0006\u00c0L7\u0089A`\u00e5\u0003@m\u00e7\u00fb\u00a9\u00f1\u00d2\u0017@\u0013\u0083\u00c0\u00ca\u00a1E\u00fa\u00bf$\u00db\u00f9~j\u00bc\u00e4?\u00f1\u00a7\u00c6K7\u0089\u0015@j\u00bct\u0093\u0018\u0004\u00ee\u00bf\u008e\u0097n\u0012\u0083\u00c0\u00ca?\u001eZd;\u00dfO\u001b@9\u00b4\u00c8v\u00be\u009f\u0003\u00c0u\u0093\u0018\u0004V\u000e\u00cd\u00bf43333\u00b3\u0019@Ob\u0010X9\u00b4\u000b\u00c0~?5^\u00baI\u00cc\u00bf\u00cb\u00a1E\u00b6\u00f3} @\u0018\u00d9\u00ce\u00f7S\u00e3\u0004\u00c0\u00ad\u001cZd;\u00df\u00cf?\u00f6(\\\u008f\u00c2\u00f5\u001a@q=\n\u00d7\u00a3p\u00ff\u00bf\u008e\u0097n\u0012\u0083\u00c0\u00fa\u00bf\u00f6(\\\u008f\u00c2u\u001d@\u00ea&1\b\u00ac\u001c\u0004\u00c0\u0096C\u008bl\u00e7\u00fb\u0002\u00c0\u00a3E\u00b6\u00f3\u00fd\u00d4\u0016@\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u00c0\u00d3Mb\u0010X9\u0000\u00c0W\u000e-\u00b2\u009do\u001c@\u0013\u0083\u00c0\u00ca\u00a1E\u00ee\u00bfZd;\u00dfO\u008d\u00f9\u00bf\u0089A`\u00e5\u00d0b!@\u00f9S\u00e3\u00a5\u009b\u00c4\r\u00c0}?5^\u00baI\u00e0?\u00a4p=\n\u00d7\u00e3!@5^\u00baI\f\u0002\u00f9\u00bf\u00cc\u00a1E\u00b6\u00f3\u00fd\u00e0?\u001f\u0085\u00ebQ\u00b8\u001e!@\u00a0\u001a/\u00dd$\u0006\u00e5\u00bf\u0091\u00ed|?5^\u00d2?\u00e5\u00d0\"\u00db\u00f9~$@d;\u00dfO\u008d\u0097\u00f8\u00bf\u0081\u0095C\u008bl\u00e7\u00f1?\u00cf\u00f7S\u00e3\u00a5\u00db%@e;\u00dfO\u008d\u0097\u00fe\u00bf_\u00baI\f\u0002+\u00d7?\\\u008f\u00c2\u00f5(\u009c$@\u000e-\u00b2\u009d\u00ef\u00a7\u0002\u00c0{\u0014\u00aeG\u00e1z\u0003@\u0083\u00c0\u00ca\u00a1E6%@*\\\u008f\u00c2\u00f5(\u00ac\u00bfNb\u0010X9\u00b4\u00f4?c\u0010X9\u00b4\b%@`\u00e5\u00d0\"\u00db\u00f9\u00de?`\u00e5\u00d0\"\u00db\u00f9\u00d6?\\\u008f\u00c2\u00f5(\u00dc#@\u00b2\u009d\u00ef\u00a7\u00c6K\u00d7?}?5^\u00baI\u0000@\u00f0\u00a7\u00c6K7\u0089&@\u0091\u00ed|?5^\b\u00c0/\u00dd$\u0006\u0081\u0095\u0005@d;\u00dfO\u008d\u00d7'@H\u00e1z\u0014\u00aeG\u00d1?\u00f0\u00a7\u00c6K7\u0089\u00fd?\u00bbI\f\u0002+\u0007*@u\u0093\u0018\u0004V\u000e\u00e1?\u0000\u0000\u0000\u0000\u0000\u0000\u00f0?H\u00e1z\u0014\u00ae\u00c7)@\u00d6x\u00e9&1\b\u00dc?\u0093\u0018\u0004V\u000e-\u00b2\u00bfJ\f\u0002+\u0087V(@ \u0085\u00ebQ\u00b8\u001e\u00dd?\u00d7\u00a3p=\n\u00d7\t@\u0017\u00d9\u00ce\u00f7S\u00a3&@_\u00baI\f\u0002+\u00d7?\u0089A`\u00e5\u00d0\"\u000f@\u00ff\u00d4x\u00e9&q,@\u00f2\u00d2Mb\u0010X\u00ed?\\\u008f\u00c2\u00f5(\\\u00f9?\u009a\u0099\u0099\u0099\u0099\u0019.@\u00c1\u00ca\u00a1E\u00b6\u00f3\u00f3?\u00d9\u00ce\u00f7S\u00e3\u00a5\u00ef?\u00f6(\\\u008f\u00c2\u00b5*@\u001b/\u00dd$\u0006\u0081\u00e9?<\u00dfO\u008d\u0097n\u000e@\u0088\u0016\u00d9\u00ce\u00f7\u00d3*@\u00d9\u00ce\u00f7S\u00e3\u00a5\u00ef?<\u00dfO\u008d\u0097n\u0013@\u00d8\u00a3p=\n\u00d7,@d;\u00dfO\u008d\u0097\u00f0?\u00d0\u00f7S\u00e3\u00a5\u009b\u0007@@5^\u00baI\u00cc.@\u0013\u0083\u00c0\u00ca\u00a1E\u00f4?\u00c3\u00f5(\\\u008f\u00c2\n@\u008e\u0097n\u0012\u0083\u0080\"@b\u0010X9\u00b4\u00c8\u0001\u00c0\"\u00b0rh\u0091\u00ed\t@\u00c7K7\u0089A\u00e0 @\u00ad\u001cZd;\u00df\u00fb\u00bf\u00a0\u001a/\u00dd$\u0006\u0007@\u00fc\u00a9\u00f1\u00d2Mb\"@sh\u0091\u00ed|?\u0006\u00c0\u0084\u00c0\u00ca\u00a1E6\u0012@\u000e-\u00b2\u009d\u00efg$@D\u008bl\u00e7\u00fb\u00a9\u0004\u00c0\u00e9&1\b\u00ac\u009c\u0013@\u0087\u0016\u00d9\u00ce\u00f7\u00d3!@-\u00b2\u009d\u00ef\u00a7F\u0011\u00c0\u00aeG\u00e1z\u0014\u00ae\u0011@Zd;\u00dfO\u008d @\u00d1\"\u00db\u00f9~j\u0000\u00c0\u007fj\u00bct\u0093\u0018\u0016@\u001eZd;\u00dfO\u001d@H\u00e1z\u0014\u00aeG\u0000\u00c0\u008bl\u00e7\u00fb\u00a9\u00f1\u0013@L7\u0089A`%#@\u00fb~j\u00bct\u0093\u0014\u00c0\u0097C\u008bl\u00e7{\u0014@R\u00b8\u001e\u0085\u00ebQ @\u009e\u00ef\u00a7\u00c6K7\u0006\u00c0\u00ea&1\b\u00ac\u009c\u001b@~?5^\u00ba\u00c9\u001e@\u00c9v\u00be\u009f\u001a/\u0001\u00c0\u00aeG\u00e1z\u0014\u00ae\u001e@H\u00e1z\u0014\u00aeG\"@1\b\u00ac\u001cZd\b\u00c0\u00e4\u00a5\u009b\u00c4 0\u001d@a\u00e5\u00d0\"\u00db\u00f9\u001d@6^\u00baI\f\u0002\r\u00c0<\u00dfO\u008d\u0097\u00ee\u001b@R\u00b8\u001e\u0085\u00eb\u0011!@\u00fe\u00d4x\u00e9&1\u00e4\u00bf\u00e5\u00d0\"\u00db\u00f9\u00fe\u0016@|\u0014\u00aeG\u00e1\u00ba\"@\u0093\u0018\u0004V\u000e-\u00da\u00bfNb\u0010X9\u00b4\u0019@\u0097C\u008bl\u00e7{\u001e@\u0014\u00aeG\u00e1z\u0014\u00ce\u00bf\u00dd$\u0006\u0081\u0095\u00c3\u0018@o\u0012\u0083\u00c0\u00caa!@\u00fa~j\u00bct\u0093\u0098\u00bfffffff\u0013@\u00f0\u00a7\u00c6K7\t @}?5^\u00ba\u00c9\u0012\u00c0\u00dd$\u0006\u0081\u0095C\f@\u0002+\u0087\u0016\u00d9N\u001e@\u0004V\u000e-\u00b2\u009d\u000f\u00c0333333\b@\u0018\u00d9\u00ce\u00f7S\u00e3\u001e@n\u00e7\u00fb\u00a9\u00f1R\u0018\u00c0\u0082\u0095C\u008bl\u00e7\t@\u008f\u00c2\u00f5(\\\u008f\u001d@\r\u0002+\u0087\u0016Y\u001a\u00c0\u00fa~j\u00bct\u0093\u0010@D\u008bl\u00e7\u00fb\u00e9!@\u00fd\u00a9\u00f1\u00d2Mb\u001b\u00c0\u00f1\u00a7\u00c6K7\u0089\u0005@\u00c5 \u00b0rh\u0011\u001a@x\u00be\u009f\u001a/]\u0018\u00c0o\u0012\u0083\u00c0\u00ca\u00a1\u0002@w\u00be\u009f\u001a/\u00dd\u0016@\u00fc\u00a9\u00f1\u00d2M\u00e2\u0015\u00c0!\u00b0rh\u0091\u00ed\u0005@R\u00b8\u001e\u0085\u00eb\u00d1\u0018@ffffff\u001c\u00c0\u0006\u0081\u0095C\u008bl\u0000@X9\u00b4\u00c8v>\u001b@\u0006\u0081\u0095C\u008bl\u0016\u00c0ffffff\u00f6?\u00db\u00f9~j\u00bc4\"@T\u00e3\u00a5\u009b\u00c4 \u00c0\u0092\u00ed|?5^\u0006@T\u00e3\u00a5\u009b\u00c4\u00a0#@\u00f0\u00a7\u00c6K7\u0089\u0018\u00c0\u0089A`\u00e5\u00d0\"\u00ff?H\u00e1z\u0014\u00ae\u0007#@sh\u0091\u00ed|\u00bf\u0014\u00c0:\u00b4\u00c8v\u00be\u009f\u00fc?\u00f9S\u00e3\u00a5\u009bD&@o\u0012\u0083\u00c0\u00ca\u00a1\u001a\u00c0\u008d\u0097n\u0012\u0083\u00c0\u00f6?M7\u0089A`%&@\u0002+\u0087\u0016\u00d9\u00ce\u001e\u00c0\u00ac\u001cZd;\u00df\u00f1?\u00c1\u00ca\u00a1E\u00b6s(@\\\u008f\u00c2\u00f5(\u00dc\u001a\u00c0\u00f4\u00fd\u00d4x\u00e9&\u0004@\u00cc\u00a1E\u00b6\u00f3\u00fd&@\u00e5\u00d0\"\u00db\u00f9\u00fe\u0016\u00c0\u0089A`\u00e5\u00d0\"\u00cb?\u00f7(\\\u008f\u00c2\u00b5&@\u00ac\u001cZd;\u00df\u0012\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u00e0?2\b\u00ac\u001cZ$)@>\n\u00d7\u00a3p\u00bd\u0017\u00c0\u00d1\"\u00db\u00f9~j\u00bc?\u00e3\u00a5\u009b\u00c4 \u00f0)@\u00a4p=\n\u00d7\u00a3\u001e\u00c0\u00aeG\u00e1z\u0014\u00ae\u0004@\u0098n\u0012\u0083\u00c0\u008a%@0\u00dd$\u0006\u0081\u0015\u0018\u00c01\b\u00ac\u001cZd\u00f1\u00bf\u00a4p=\n\u00d7c#@w\u00be\u009f\u001a/\u00dd\u0017\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\u00ec\u00bf\u00bct\u0093\u0018\u0004\u00d6%@i\u0091\u00ed|?5\u001c\u00c0}?5^\u00baI\u00f6\u00bf\u0002+\u0087\u0016\u00d9N&@\u00c9v\u00be\u009f\u001a/\u0014\u00c0;\u00dfO\u008d\u0097n\u0001\u00c0\u0091\u00ed|?5\u00de%@\u008f\u00c2\u00f5(\\\u000f\u0010\u00c0\u00fb~j\u00bct\u0093\u00fe\u00bf\u00aa\u00f1\u00d2MbP(@&\u0006\u0081\u0095C\u008b\u0014\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0004\u00c0\u00ee|?5^z$@\u00ecQ\u00b8\u001e\u0085k\u0015\u00c0\u00e0O\u008d\u0097n\u0012\u000b\u00c0T\u00e3\u00a5\u009b\u00c4`\"@R\u00b8\u001e\u0085\u00ebQ\u0015\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\t\u00c0\u009b\u0099\u0099\u0099\u0099\u00d9$@\u00dfO\u008d\u0097n\u0092\u0019\u00c0\u00bdt\u0093\u0018\u0004V\r\u00c0\u0091\u00ed|?5\u00de$@\\\u008f\u00c2\u00f5(\u00dc\u0011\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u0012\u00c0P\u008d\u0097n\u0012\u0083#@\u00d0\u00f7S\u00e3\u00a5\u009b\u0012\u00c0H\u00e1z\u0014\u00aeG\u0015\u00c0^\u00baI\f\u0002\u00ab&@u\u0093\u0018\u0004V\u000e\u0012\u00c0\u00afG\u00e1z\u0014.\u0014\u00c0\b\u00ac\u001cZd\u00bb$@\u00c2\u00ca\u00a1E\u00b6\u00f3\u000b\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u0011\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u008d(@\n\u00d7\u00a3p=\n\u0017\u00c0p\u0012\u0083\u00c0\u00ca\u00a1\u000b@\u0085\u00ebQ\u00b8\u001e\u0085'@d;\u00dfO\u008d\u0097\u0013\u00c0\u0004V\u000e-\u00b2\u009d\n@\u0000\u0000\u0000\u0000\u0000@*@S\u00b8\u001e\u0085\u00ebQ\u0017\u00c0\u00dd$\u0006\u0081\u0095\u00c3\u0012@\u00e2z\u0014\u00aeGa,@\u00fd\u00a9\u00f1\u00d2M\u00e2\u0017\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u0012@\u001dZd;\u00dfO)@\u00d3Mb\u0010X9\u001c\u00c0\u001dZd;\u00df\u00cf\u0015@$\u00db\u00f9~j\u00fc)@d;\u00dfO\u008d\u0017\u0012\u00c0\u0019\u0004V\u000e-2\u0016@\u009e\u00ef\u00a7\u00c6K\u00f7*@\u00b3\u009d\u00ef\u00a7\u00c6K\r\u00c0\u00bct\u0093\u0018\u0004V\u0014@2\b\u00ac\u001cZ\u00e4'@\u00d8\u00a3p=\n\u00d7\u0010\u00c0\u00a1\u001a/\u00dd$\u0006\u0016@\u0006\u0081\u0095C\u008b\u00ec*@\u0090\u00c2\u00f5(\\\u008f\u001f\u00c0h\u0091\u00ed|?5\u0017@\u00b2\u009d\u00ef\u00a7\u00c6\u000b+@(1\b\u00ac\u001c\u00da\u0012\u00c033333\u00b3\u001b@\\\u008f\u00c2\u00f5(\\)@*\\\u008f\u00c2\u00f5\u00a8\u0013\u00c0\u0002+\u0087\u0016\u00d9\u000e @\u00dd$\u0006\u0081\u0095C'@\u00e5\u00d0\"\u00db\u00f9~\u0014\u00c0\u008e\u0097n\u0012\u0083\u00c0\u001f@\u009c\u00c4 \u00b0r\u00a8-@{\u0014\u00aeG\u00e1z\u0012\u00c0\u009f\u00ef\u00a7\u00c6K\u00b7\u001d@i\u0091\u00ed|?u-@?5^\u00baI\f\u0013\u00c0Zd;\u00dfO\u008d!@Q\u008d\u0097n\u0012\u0003/@j\u00bct\u0093\u0018\u0084\u0012\u00c0\n\u00d7\u00a3p=\n#@\u0006\u0081\u0095C\u008b\u00ec*@\u00baI\f\u0002+\u0087\u0013\u00c0~?5^\u00baI\"@\f\u0002+\u0087\u0016\u0019*@w\u00be\u009f\u001a/\u00dd\u0013\u00c0T\u00e3\u00a5\u009b\u00c4 $@\u00cb\u00a1E\u00b6\u00f3\u00bd&@\u00f6(\\\u008f\u00c2u\u001c\u00c0\u0091\u00ed|?5\u00de\u0016@\u00f6(\\\u008f\u00c2\u00b5%@\u00ecQ\u00b8\u001e\u0085k\u0019\u00c0D\u008bl\u00e7\u00fb)\u0015@\u0087\u0016\u00d9\u00ce\u00f7S%@H\u00e1z\u0014\u00ae\u0087 \u00c0V\u000e-\u00b2\u009do\u0019@b\u0010X9\u00b4\b&@\u009e\u00ef\u00a7\u00c6Kw \u00c0\u008f\u00c2\u00f5(\\\u008f\u001d@\u00d3Mb\u0010X\u00f9%@o\u0012\u0083\u00c0\u00caa#\u00c0\u00dfO\u008d\u0097n\u0012\u0017@\u00b0rh\u0091\u00ed<\"@\u00dc\u00f9~j\u00bc\u00f4\u001f\u00c0\u00d4Mb\u0010X9\u001a@\u007fj\u00bct\u0093X!@\u00a2E\u00b6\u00f3\u00fd\u00d4\u001e\u00c0\u00b6\u00f3\u00fd\u00d4xi\u0016@)\\\u008f\u00c2\u00f5h!@h\u0091\u00ed|?\u00f5!\u00c0\u00d6x\u00e9&1\b\u001b@\u0098n\u0012\u0083\u00c0\u00ca&@q=\n\u00d7\u00a30%\u00c0\u00c5 \u00b0rh\u0011\u001a@j\u00bct\u0093\u0018D!@\u0017\u00d9\u00ce\u00f7S\u00e3\u001b\u00c0\u0084\u00c0\u00ca\u00a1E\u00b6\u001e@\u0094\u0018\u0004V\u000em\"@\u00fe\u00d4x\u00e9&1\u0018\u00c0\u00aa\u00f1\u00d2Mb\u0090\u001e@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u001c@\u0007\u0081\u0095C\u008bl\u001a\u00c0\u0082\u0095C\u008bl\u00e7\u001d@\u00cav\u00be\u009f\u001a/\u001c@\u00a4p=\n\u00d7#\u0018\u00c0#\u00db\u00f9~j<\u001a@h\u0091\u00ed|?5\u001a@2\b\u00ac\u001cZ\u00e4\u001d\u00c0\f\u0002+\u0087\u0016\u00d9\u001d@\u00de$\u0006\u0081\u0095\u00c3\u001b@b\u0010X9\u00b4\u00c8\u0017\u00c0\u00cf\u00f7S\u00e3\u00a5\u009b @+\u0087\u0016\u00d9\u00ce\u00b7!@\u00fc\u00a9\u00f1\u00d2Mb\u001e\u00c0\u00c9v\u00be\u009f\u001a/\"@\u00fe\u00d4x\u00e9&\u00b1 @&\u0006\u0081\u0095C\u000b\u001c\u00c0h\u0091\u00ed|?\u00b5#@43333s!@\u00f2\u00d2Mb\u0010X!\u00c0\f\u0002+\u0087\u0016Y\"@d;\u00dfO\u008d\u00d7#@G\u00b6\u00f3\u00fd\u00d4x\u001d\u00c0=\n\u00d7\u00a3p}\"@\u009a\u0099\u0099\u0099\u0099\u00d9%@\u00e2z\u0014\u00aeG\u00a1#\u00c0\u00c9v\u00be\u009f\u001a\u00af\u0011@43333\u00f3$@\u00bct\u0093\u0018\u0004\u0016\"\u00c0\u00a4p=\n\u00d7\u00a3\u000f@)\\\u008f\u00c2\u00f5\u00a8&@\u0098n\u0012\u0083\u00c0\n&\u00c0Nb\u0010X9\u00b4\r@33333s%@H\u00e1z\u0014\u00ae\u00c7'\u00c0$\u00db\u00f9~j\u00bc\u000f@D\u008bl\u00e7\u00fb\u00a9)@?5^\u00baI\u00cc&\u00c0\u00f2\u00d2Mb\u0010X\u000f@1\b\u00ac\u001cZd&@\u000e-\u00b2\u009d\u00efg%\u00c0\u00ac\u001cZd;\u00df\u0001@\u00c2\u00ca\u00a1E\u00b6\u00f3'@\u0012\u0083\u00c0\u00ca\u00a1\u0005$\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\u00fe?\u001a\u0004V\u000e-\u00b2$@(1\b\u00ac\u001c\u001a$\u00c0\u00a0\u001a/\u00dd$\u0006\u0000@\u00d4Mb\u0010X9*@\u00b6\u00f3\u00fd\u00d4x))\u00c0\u0092\u00ed|?5^\u0010@\u00ee|?5^:&@\u0014\u00aeG\u00e1z\u00d4'\u00c0\u00c8K7\u0089A`\u00f5?>\n\u00d7\u00a3p\u00bd'@\u0090\u00c2\u00f5(\\O)\u00c00\u00dd$\u0006\u0081\u0095\u00f9??5^\u00baIL$@m\u00e7\u00fb\u00a9\u00f1\u00d2(\u00c0\u008bl\u00e7\u00fb\u00a9\u00f1\u00f6?%\u0006\u0081\u0095C\u008b&@\u00cf\u00f7S\u00e3\u00a5\u001b'\u00c0\u00c9v\u00be\u009f\u001a/\u00bd\u00bf\f\u0002+\u0087\u0016Y(@\u00be\u009f\u001a/\u00dd\u00e4%\u00c0\u00c3\u00f5(\\\u008f\u00c2\u00c5\u00bf\u00be\u009f\u001a/\u00dd\u00e4$@h\u0091\u00ed|?\u00f5%\u00c0w\u00be\u009f\u001a/\u00dd\u00e0\u00bf\b\u00ac\u001cZd;'@\u00f0\u00a7\u00c6K7\u00c9)\u00c0\u00f2\u00d2Mb\u0010X\u00ed\u00bfi\u0091\u00ed|?u'@V\u000e-\u00b2\u009d/)\u00c02\b\u00ac\u001cZd\u00ff\u00bf#\u00db\u00f9~j\u00fc(@\u008bl\u00e7\u00fb\u00a9\u00b1*\u00c0ffffff\u00de\u00bf\u0082\u0095C\u008bl'%@?5^\u00baI\u00cc+\u00c0333333\u00e7\u00bfy\u00e9&1\b,%@\\\u008f\u00c2\u00f5(\\-\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u00f5\u00bf\u00d8\u00a3p=\nW#@\u00b7\u00f3\u00fd\u00d4x\u00e9*\u00c0\u008aA`\u00e5\u00d0\"\u00e7\u00bf\u00a6\u009b\u00c4 \u00b02%@[d;\u00dfO\u00cd,\u00c0\u008cl\u00e7\u00fb\u00a9\u00f1\u00c2?\u001c/\u00dd$\u0006\u0081+@\u0014\u00aeG\u00e1z\u00d4$\u00c0\u001b/\u00dd$\u0006\u0001\u0010@\f\u0002+\u0087\u0016\u00d9*@\u00b6\u00f3\u00fd\u00d4x\u00e9\"\u00c0h\u0091\u00ed|?5\u0010@\u00b9\u001e\u0085\u00ebQx.@E\u008bl\u00e7\u00fbi%\u00c0#\u00db\u00f9~j\u00bc\u0010@\u00e6\u00d0\"\u00db\u00f9\u00fe.@\u008bl\u00e7\u00fb\u00a91'\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\f@\u00d6x\u00e9&1\b/@43333s&\u00c0\u001c/\u00dd$\u0006\u0081\u0016@\u00e7\u00fb\u00a9\u00f1\u00d2-0@R\u00b8\u001e\u0085\u00eb\u0011#\u00c0$\u00db\u00f9~j\u00bc\u000e@\u0091\u00ed|?5\u00de/@-\u00b2\u009d\u00ef\u00a7F!\u00c0\u0093\u0018\u0004V\u000e\u00ad\u0011@\u007fj\u00bct\u0093X0@h\u0091\u00ed|?5(\u00c0\u00c1\u00ca\u00a1E\u00b6s\u0017@~?5^\u00ba\u00a91@h\u0091\u00ed|?\u00b5#\u00c0\u00dfO\u008d\u0097n\u0092\u0010@\u00a8\u00c6K7\u0089\u00e11@\u0019\u0004V\u000e-\u00b2\"\u00c0\u0091\u00ed|?5^\u0014@\u00baI\f\u0002+\u00e71@n\u00e7\u00fb\u00a9\u00f1\u00d2%\u00c0433333\u0010@sh\u0091\u00ed|?2@D\u008bl\u00e7\u00fb\u00a9\"\u00c0\u00cc\u00a1E\u00b6\u00f3\u00fd\n@fffff\u00060@\u00cav\u00be\u009f\u001a\u00af\"\u00c0$\u00db\u00f9~j\u00bc\u0003@\u00de$\u0006\u0081\u0095#0@th\u0091\u00ed|?$\u00c0y\u00e9&1\b\u00ac\u00fe?\u00f3\u00d2Mb\u0010\u00d8-@\u00ab\u00f1\u00d2Mb\u0010%\u00c0k\u00bct\u0093\u0018\u0084\u001a@ \u0085\u00ebQ\u00b8\u00de,@R\u00b8\u001e\u0085\u00ebQ#\u00c0\u00d7\u00a3p=\n\u00d7\u0019@\u00ce\u00cc\u00cc\u00cc\u00cc\f.@\u0089A`\u00e5\u00d0\"&\u00c0B`\u00e5\u00d0\"\u001b @H\u00e1z\u0014\u00ae\u00070@\\\u008f\u00c2\u00f5(\u00dc&\u00c0{\u0014\u00aeG\u00e1z @}?5^\u00ba\u0089,@}?5^\u00ba\u00c9(\u00c0d;\u00dfO\u008d\u0097 @\u0086\u00ebQ\u00b8\u001e\u00c5-@\u00ee|?5^\u00ba#\u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd!@\u0001\u0000\u0000\u0000\u0000\u0080.@L7\u0089A`e$\u00c0!\u00b0rh\u0091\u00ed#@gffff\u00a6,@\u00e0O\u008d\u0097n\u00d2)\u00c0}?5^\u00ba\u00c9\"@\u008aA`\u00e5\u00d0\u00e2*@b\u0010X9\u00b4\u00c8\"\u00c0X9\u00b4\u00c8v>\"@d;\u00dfO\u008dW*@\u0014\u00aeG\u00e1z\u00d4!\u00c0w\u00be\u009f\u001a/] @\u0082\u0095C\u008bl\u00a7)@0\u00dd$\u0006\u0081\u0095$\u00c0-\u00b2\u009d\u00ef\u00a7\u0086\"@<\u00dfO\u008d\u0097\u00ae/@\u00d3Mb\u0010Xy!\u00c0'1\b\u00ac\u001c\u001a!@\u0085\u00ebQ\u00b8\u001e\u00050@/\u00dd$\u0006\u0081U \u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\"@\u00f3\u00d2Mb\u0010\u00d8.@\u00e3\u00a5\u009b\u00c4 0 \u00c0\u00ea&1\b\u00ac\u001c\u001f@\u00de$\u0006\u0081\u0095\u00c30@\u00d7\u00a3p=\nW\"\u00c0\u00e0O\u008d\u0097nR @\"\u00b0rh\u0091-*@o\u0012\u0083\u00c0\u00ca!!\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0$@V\u000e-\u00b2\u009do(@\u00c3\u00f5(\\\u008f\u00c2\u001f\u00c0\u00fe\u00d4x\u00e9&q$@\u00a7\u009b\u00c4 \u00b0\u00f2+@\u00b7\u00f3\u00fd\u00d4x\u00e9\u001f\u00c0W\u000e-\u00b2\u009d/%@\u0085\u00ebQ\u00b8\u001e\u00c5)@\u00dc\u00f9~j\u00bct\"\u00c0\u00e1z\u0014\u00aeGa&@y\u00e9&1\b,+@\u00a6\u009b\u00c4 \u00b0\u00f2)\u00c0\u00d3Mb\u0010X9\u001d@p\u0012\u0083\u00c0\u00caa+@p\u0012\u0083\u00c0\u00ca!)\u00c0@5^\u00baI\u008c\u0019@\u00a2E\u00b6\u00f3\u00fd\u0094)@\u00a5p=\n\u00d7c,\u00c0@5^\u00baI\u008c\u001d@\"\u00b0rh\u0091\u00ed(@\u00afG\u00e1z\u0014\u00ae,\u00c0\u008bl\u00e7\u00fb\u00a9q\u0019@\u00dc\u00f9~j\u00bc4'@\u00ef|?5^:,\u00c0\u00e9&1\b\u00ac\u00dc @\u00be\u009f\u001a/\u00ddd+@\u00fa~j\u00bct\u00d3.\u00c0(1\b\u00ac\u001c\u00da\u001d@\u008e\u0097n\u0012\u0083\u0080,@6^\u00baI\f\u00c2.\u00c0u\u0093\u0018\u0004V\u00ce @\u00a0\u001a/\u00dd$\u0006*@\u00c4\u00f5(\\\u008fB0\u00c0\u00d7\u00a3p=\n\u00d7\u001d@y\u00e9&1\bl&@\u00fd\u00a9\u00f1\u00d2M\".\u00c0Zd;\u00dfOM\"@!\u00b0rh\u0091m-@<\u00dfO\u008d\u0097n/\u00c0\u0007\u0081\u0095C\u008bl\u0019@\u0000\u0000\u0000\u0000\u0000\u00c0,@L7\u0089A`\u00a5/\u00c0\u0081\u0095C\u008blg\u0014@\u00b3\u009d\u00ef\u00a7\u00c6\u00cb*@{\u0014\u00aeG\u00e1z/\u00c0\u00ecQ\u00b8\u001e\u0085k\u0013@\u0081\u0095C\u008bl'.@\u001a\u0004V\u000e-\u00f2/\u00c0/\u00dd$\u0006\u0081\u0095\u0011@\u00ad\u001cZd;\u00df/@2\b\u00ac\u001cZ\u00a4/\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2\u0019@Zd;\u00dfO\r&@\u008f\u00c2\u00f5(\\\u00cf)\u00c0\u0019\u0004V\u000e-2!@\u0015\u00aeG\u00e1zT&@\u0088\u0016\u00d9\u00ce\u00f7\u0093(\u00c0\u00b8\u001e\u0085\u00ebQ8\u001f@m\u00e7\u00fb\u00a9\u00f1\u00d2#@q=\n\u00d7\u00a30)\u00c0\u00fe\u00d4x\u00e9&\u00f1\"@\u00baI\f\u0002+G#@]\u008f\u00c2\u00f5(\u001c+\u00c0\u0014\u00aeG\u00e1z\u00d4#@\u0012\u0083\u00c0\u00ca\u00a1E!@\u00cd\u00cc\u00cc\u00cc\u00ccL(\u00c0w\u00be\u009f\u001a/\u009d!@\u0081\u0095C\u008bl\u00a7$@r=\n\u00d7\u00a3p'\u00c0\u00f2\u00d2Mb\u0010X%@\u00ecQ\u00b8\u001e\u0085\u00eb\"@\u0017\u00d9\u00ce\u00f7S\u00a3&\u00c0\u0082\u0095C\u008blg&@ \u0085\u00ebQ\u00b8\u00de%@o\u0012\u0083\u00c0\u00ca\u00e1%\u00c0\u0081\u0095C\u008blg$@\u008aA`\u00e5\u00d0\u00a2\u001f@\u00b5\u00c8v\u00be\u009f\u009a&\u00c0\u00a6\u009b\u00c4 \u00b0r\"@\u00d4Mb\u0010Xy&@\u00d1\"\u00db\u00f9~\u00aa(\u00c0\u008e\u0097n\u0012\u0083\u0080'@b\u0010X9\u00b4\b(@\u00bbI\f\u0002+\u0007*\u00c0\u0091\u00ed|?5\u00de&@\u00c7K7\u0089A\u00a0'@D\u008bl\u00e7\u00fb)'\u00c0\u00bdt\u0093\u0018\u0004\u0096(@\u0018\u00d9\u00ce\u00f7S\u00e3$@>\n\u00d7\u00a3p\u00fd)\u00c0\u00f9S\u00e3\u00a5\u009b\u00c4)@\u00e7\u00fb\u00a9\u00f1\u00d2\r$@\u009b\u0099\u0099\u0099\u0099\u0099(\u00c0\u009d\u00c4 \u00b0r\u00e8+@(1\b\u00ac\u001c\u001a$@\u00a2E\u00b6\u00f3\u00fd\u0094&\u00c0\u00d5x\u00e9&1\u00c8+@\u0012\u0083\u00c0\u00ca\u00a1\u0005#@{\u0014\u00aeG\u00e1z)\u00c0\u008aA`\u00e5\u00d0b-@Ob\u0010X9t$@\u00b1rh\u0091\u00ed|,\u00c0i\u0091\u00ed|?\u00f5)@\u00de$\u0006\u0081\u0095\u00c3 @$\u00db\u00f9~j\u00bc)\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\u001e@\u00a8\u00c6K7\u0089\u00c1!@^\u00baI\f\u0002k+\u00c043333\u00b3\u001d@d;\u00dfO\u008d\u0097\u001c@a\u00e5\u00d0\"\u00db9)\u00c0\u00f3\u00d2Mb\u0010X\u001b@\u0090\u00c2\u00f5(\\\u000f\u001d@\u00e2z\u0014\u00aeG!'\u00c0Nb\u0010X94\u001a@{\u0014\u00aeG\u00e1\u00fa\u0016@S\u00b8\u001e\u0085\u00eb\u0091)\u00c05^\u00baI\f\u0002\u001e@h\u0091\u00ed|?\u00b5\u001c@\u00ecQ\u00b8\u001e\u0085\u00eb*\u00c0\u00cav\u00be\u009f\u001a/\u0016@\u0007\u0081\u0095C\u008bl\u0019@\u0089A`\u00e5\u00d0\"*\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u00cb\u0013@\u0015\u00aeG\u00e1z\u0094\u001c@\u0001\u0000\u0000\u0000\u0000\u0000-\u00c0\u00cb\u00a1E\u00b6\u00f3}\u0017@\u000e-\u00b2\u009d\u00ef'\u0013@\u00a5p=\n\u00d7\u00e3(\u00c0W\u000e-\u00b2\u009do\u001b@=\n\u00d7\u00a3p\u00fd @v\u0093\u0018\u0004VN*\u00c0\u00c9v\u00be\u009f\u001a/\u0013@\u009e\u00ef\u00a7\u00c6Kw @J\f\u0002+\u0087\u0096*\u00c0\u00edQ\u00b8\u001e\u0085\u00eb\r@\u0091\u00ed|?5^!@\u0094\u0018\u0004V\u000e-(\u00c0+\u0087\u0016\u00d9\u00cew\u0013@\u000e-\u00b2\u009d\u00efg#@\u0011X9\u00b4\u00c86,\u00c0^\u00baI\f\u0002+\u0014@\u0018\u00d9\u00ce\u00f7S\u00e3$@\u000e-\u00b2\u009d\u00ef\u00e7,\u00c0\u00a0\u001a/\u00dd$\u0086\u0010@\u00b4\u00c8v\u00be\u009f\u009a#@I\u00e1z\u0014\u00aeG-\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0018@\"\u00b0rh\u0091m\u0016@\u0097C\u008bl\u00e7\u00bb*\u00c0\u001f\u0085\u00ebQ\u00b8^!@\u001eZd;\u00df\u00cf\u0019@\u00d3Mb\u0010X\u00f9*\u00c0`\u00e5\u00d0\"\u00dby\"@\n\u00d7\u00a3p=\n\u0011@\u00e4\u00a5\u009b\u00c4 p*\u00c0\u008bl\u00e7\u00fb\u00a9\u00b1\"@\u00f0\u00a7\u00c6K7\u0089\f@\u0004V\u000e-\u00b2\u009d+\u00c0\u00a8\u00c6K7\u0089\u0081!@y\u00e9&1\b\u00ac\u000e@\u0098n\u0012\u0083\u00c0\u008a'\u00c0>\n\u00d7\u00a3p\u00fd\"@\u00f4\u00fd\u00d4x\u00e9&\u0011@u\u0093\u0018\u0004V\u00ce+\u00c0E\u008bl\u00e7\u00fbi%@\u00fd\u00a9\u00f1\u00d2Mb\n@\u00d8\u00a3p=\n\u00d7+\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M&@P\u008d\u0097n\u0012\u0083\u0011@\u00f7(\\\u008f\u00c2\u00f5-\u00c0`\u00e5\u00d0\"\u00db9%@m\u00e7\u00fb\u00a9\u00f1\u00d2\u0004@D\u008bl\u00e7\u00fb)'\u00c0333333#@\u00f6(\\\u008f\u00c2u\u0014@\u00e2z\u0014\u00aeG\u00a1*\u00c0\u0011X9\u00b4\u00c86'@\u00d1\"\u00db\u00f9~\u00ea\u0017@\u00a2E\u00b6\u00f3\u00fdT+\u00c0R\u00b8\u001e\u0085\u00eb\u00d1&@\u00a4p=\n\u00d7#\u0013@<\u00dfO\u008d\u0097\u00ae%\u00c0\u00d7\u00a3p=\n\u0017#@0\u00dd$\u0006\u0081\u0015\u0017@\u00fc\u00a9\u00f1\u00d2M\"&\u00c0sh\u0091\u00ed|\u00ff\"@!\u00b0rh\u0091\u00ed\u0011@\u009a\u0099\u0099\u0099\u0099\u00d9\"\u00c0\u00ac\u001cZd;_#@\u00f9S\u00e3\u00a5\u009b\u00c4\u000e@\u00be\u009f\u001a/\u00dd\u00a4\"\u00c0\u00be\u009f\u001a/\u00dd$%@y\u00e9&1\b\u00ac\u000e@}?5^\u00ba\u0089!\u00c0\u008aA`\u00e5\u00d0\u00e2 @\u00f8S\u00e3\u00a5\u009b\u00c4\u0016@\u001eZd;\u00dfO!\u00c0\u00cf\u00f7S\u00e3\u00a5\u001b$@\u00f8S\u00e3\u00a5\u009b\u00c4\u0015@\u00aa\u00f1\u00d2Mb\u0090\u001e\u00c0\u00dc\u00f9~j\u00bc\u00b4$@\u00f0\u00a7\u00c6K7\u0089\u0019@\u0089A`\u00e5\u00d0\"!\u00c0D\u008bl\u00e7\u00fbi\"@\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc\n@43333\u00b3\u001e\u00c0\u007fj\u00bct\u0093\u0018!@\u009d\u00c4 \u00b0rh\u001a@\u007fj\u00bct\u0093\u00d8\"\u00c0\u00fa~j\u00bct\u00d3&@:\u00b4\u00c8v\u00be\u001f\u001c@\u00b6\u00f3\u00fd\u00d4x\u00a9$\u00c0\u00bct\u0093\u0018\u0004\u0016%@>\n\u00d7\u00a3p=\u000f@L7\u0089A`\u00e5\"\u00c0\n\u00d7\u00a3p=\n\u001d@\u0096C\u008bl\u00e7\u00fb\u0010@\u00d6x\u00e9&1\u00c8$\u00c0h\u0091\u00ed|?\u00b5\u001c@\u00e0O\u008d\u0097n\u0012\u000b@\u00ac\u001cZd;\u009f!\u00c0z\u00e9&1\b,\u0018@\u0000\u0000\u0000\u0000\u0000\u0000\u000e@\u00cav\u00be\u009f\u001a/\u001f\u00c0\u00b1rh\u0091\u00ed|\u0017@r=\n\u00d7\u00a3p\u00fd?b\u0010X9\u00b4\u0088!\u00c0\n\u00d7\u00a3p=\n\u0018@\u00d1\"\u00db\u00f9~j\u0010@\u00e1z\u0014\u00aeG!#\u00c0\u00db\u00f9~j\u00bct\u0013@\u001c/\u00dd$\u0006\u0081\u0010@b\u0010X9\u00b4H%\u00c0X9\u00b4\u00c8v>\u0014@\u00baI\f\u0002+\u0087\u00f4?\u0092\u00ed|?5^\u001f\u00c0\u0014\u00aeG\u00e1z\u0014\u0016@\u00cb\u00a1E\u00b6\u00f3}\u0016@h\u0091\u00ed|?5\"\u00c0\u00d3Mb\u0010X9\u0013@\u0000\u0000\u0000\u0000\u0000\u0080\u0016@\u0004V\u000e-\u00b2\u001d \u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\u0011@\u0018\u00d9\u00ce\u00f7Sc\u0018@\u00c7K7\u0089A`\"\u00c0\u0094\u0018\u0004V\u000e-\u0017@M7\u0089A`\u00e5\n@^\u00baI\f\u0002\u00ab\"\u00c0S\u00b8\u001e\u0085\u00ebQ\f@\u00f6(\\\u008f\u00c2\u00f5\u0002@-\u00b2\u009d\u00ef\u00a7\u0086#\u00c0\u00a7\u009b\u00c4 \u00b0r\r@\u00dc\u00f9~j\u00bct\b@'1\b\u00ac\u001c\u009a \u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\n@j\u00bct\u0093\u0018\u0004\u000f@\u00fc\u00a9\u00f1\u00d2M\u00a2#\u00c0z\u00e9&1\b\u00ac\u0005@\u00fa~j\u00bct\u0013\u001a@\u00d1\"\u00db\u00f9~\u00ea#\u00c0P\u008d\u0097n\u0012\u0083\u000f@ \u0085\u00ebQ\u00b8\u009e\u0019@S\u00b8\u001e\u0085\u00eb\u0011&\u00c0R\u00b8\u001e\u0085\u00ebQ\u0010@\u00ce\u00cc\u00cc\u00cc\u00ccL\u0019@0\u00dd$\u0006\u0081\u0095#\u00c0,\u0087\u0016\u00d9\u00ce\u00f7\u0006@Ob\u0010X94\u001e@\u00fe\u00d4x\u00e9&q#\u00c0R\u00b8\u001e\u0085\u00eb\u00d1\u0010@\u00c1\u00ca\u00a1E\u00b6\u00f3\u00f3?d;\u00dfO\u008dW#\u00c0\u00da\u00ce\u00f7S\u00e3%\u001b@\b\u00ac\u001cZd;\u00fd?~?5^\u00ba\u00c9$\u00c0}?5^\u00ba\u00c9\u001c@\u0011X9\u00b4\u00c8v\u00ce\u00bf\u0093\u0018\u0004V\u000em#\u00c0\u00a7\u009b\u00c4 \u00b0\u00f2\u001b@sh\u0091\u00ed|?\u00e5\u00bf\u00f6(\\\u008f\u00c2\u00f5\"\u00c0\u0014\u00aeG\u00e1z\u0014\u0018@\u00dfO\u008d\u0097n\u0012\u00e7\u00bffffff\u00e6 \u00c0\u001dZd;\u00dfO\u001f@\u00aeG\u00e1z\u0014\u00ae\u00e7\u00bfH\u00e1z\u0014\u00aeG&\u00c0z\u00e9&1\b,\u001d@\u00de$\u0006\u0081\u0095C\u00fd\u00bf\u00d0\u00f7S\u00e3\u00a5\u001b&\u00c0v\u0093\u0018\u0004V\u008e\u001d@\u00e8\u00fb\u00a9\u00f1\u00d2M\u00d2\u00bf\u00d9\u00ce\u00f7S\u00e3\u00e5&\u00c0h\u0091\u00ed|?u @k\u00bct\u0093\u0018\u0004\u00f8\u00bf\u0081\u0095C\u008blg\u001e\u00c0~?5^\u00baI\u001d@~?5^\u00baI\u00dc\u00bf\u00a8\u00c6K7\u0089\u0081(\u00c0\u00f4\u00fd\u00d4x\u00e9&\u0019@P\u008d\u0097n\u0012\u0083\u00e4?+\u0087\u0016\u00d9\u00ce\u00b7(\u00c0\u00a9\u00c6K7\u0089A\u0019@_\u00baI\f\u0002+\u00e7\u00bf33333s*\u00c0\u00de$\u0006\u0081\u0095\u00c3\u001a@`\u00e5\u00d0\"\u00db\u00f9\u00f0\u00bf\u001b/\u00dd$\u0006A(\u00c0\u008bl\u00e7\u00fb\u00a9q\u0013@\u00db\u00f9~j\u00bct\u0000\u00c0\u00ecQ\u00b8\u001e\u0085\u00ab&\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u0012@\u00b0rh\u0091\u00ed|\u00e3\u00bf\u0082\u0095C\u008bl\u00a7)\u00c0\u00fd\u00a9\u00f1\u00d2Mb\u000f@o\u0012\u0083\u00c0\u00ca\u00a1\u00d5\u00bf\u00bct\u0093\u0018\u0004\u0096 \u00c0\u00c9v\u00be\u009f\u001a/\"@q=\n\u00d7\u00a3p\u00e5\u00bf\u000b\u00d7\u00a3p=\n\u001c\u00c0\u00d2\"\u00db\u00f9~j#@\u00c5 \u00b0rh\u0091\u00fb\u00bf<\u00dfO\u008d\u0097\u00ee\u001a\u00c0\u00fc\u00a9\u00f1\u00d2Mb#@\u0019\u0004V\u000e-\u00b2\u00ad\u00bf\u007fj\u00bct\u0093\u0018\u0017\u00c033333\u00f3!@J\f\u0002+\u0087\u0016\u00d1\u00bfX9\u00b4\u00c8v\u00be\u001c\u00c0\u00c7K7\u0089A`&@Nb\u0010X9\u00b4\u00c8?\u00e0O\u008d\u0097n\u0012\u0019\u00c0e;\u00dfO\u008d\u0017'@L7\u0089A`\u00e5\u00f2\u00bf\u0003+\u0087\u0016\u00d9\u00ce\u001d\u00c0\u00ff\u00d4x\u00e9&q'@\u0010X9\u00b4\u00c8v\u00e2\u00bf\u000e-\u00b2\u009d\u00ef\u00a7\u0012\u00c0\f\u0002+\u0087\u0016Y\"@\u0093\u0018\u0004V\u000e-\u00ea?\u00b8\u001e\u0085\u00ebQ8 \u00c0X9\u00b4\u00c8v>&@\u007fj\u00bct\u0093\u0018\u00fc?\u0013\u0083\u00c0\u00ca\u00a1E\u001e\u00c0\u00d2\"\u00db\u00f9~\u00ea%@\u00baI\f\u0002+\u0087\u00ee?\u00dfO\u008d\u0097nR!\u00c0\u00b4\u00c8v\u00be\u009f\u001a(@%\u0006\u0081\u0095C\u008b\u00e0?\u00b2\u009d\u00ef\u00a7\u00c6\u000b\"\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8#@9\u00b4\u00c8v\u00be\u009f\u009a?)\\\u008f\u00c2\u00f5\u00e8#\u00c0d;\u00dfO\u008dW$@R\u00b8\u001e\u0085\u00ebQ\u00f6?\f\u0002+\u0087\u0016\u00d9\"\u00c0\u008bl\u00e7\u00fb\u00a9\u00b1\"@\f\u0002+\u0087\u0016\u00d9\u00ee?/\u00dd$\u0006\u0081\u0095\u0017\u00c0\u0096C\u008bl\u00e7; @2\b\u00ac\u001cZd\u00f5?\u00aeG\u00e1z\u0014.\u001b\u00c0(1\b\u00ac\u001cZ\u001f@\u0003+\u0087\u0016\u00d9\u00ce\u00f7?q=\n\u00d7\u00a3\u00f0\u0012\u00c043333\u00b3\u001d@^\u00baI\f\u0002+\u00f9?\t\u00ac\u001cZd;\u000f\u00c0\u00e6\u00d0\"\u00db\u00f9> @\u00baI\f\u0002+\u0087\u00de?\u00aa\u00f1\u00d2Mb\u0010\u0011\u00c0<\u00dfO\u008d\u0097n\u0019@\u00cf\u00f7S\u00e3\u00a5\u009b\u0006@9\u00b4\u00c8v\u00be\u001f\u0014\u00c0/\u00dd$\u0006\u0081\u0095\u001b@\u00c8K7\u0089A`\u0005@ \u0085\u00ebQ\u00b8\u001e\u0018\u00c01\b\u00ac\u001cZ\u00e4\u0019@\u0004V\u000e-\u00b2\u009d\u000b@\u00f5\u00fd\u00d4x\u00e9\u00a6\u0014\u00c0\u009a\u0099\u0099\u0099\u0099\u0019\u001f@\u0092\u00ed|?5^\u00ba?\u00c4\u00f5(\\\u008f\u00c2\b\u00c0\u0088\u0016\u00d9\u00ce\u00f7\u00d3\u0018@\u0084\u00c0\u00ca\u00a1E\u00b6\u000b@\u0083\u00c0\u00ca\u00a1E6\u0010\u00c0\u00ab\u00f1\u00d2Mb\u0090\u0017@z\u00e9&1\b\u00ac\u0006@\u00d9\u00ce\u00f7S\u00e3\u00a5\u000f\u00c0v\u0093\u0018\u0004V\u000e\u0014@h\u0091\u00ed|?5\r@D\u008bl\u00e7\u00fb\u00a9\u0004\u00c0c\u0010X9\u00b4\u00c8\u0019@?5^\u00baI\f\u0011@\u0000\u0000\u0000\u0000\u0000\u0000\u0005\u00c0M7\u0089A`e\u001d@q=\n\u00d7\u00a3p\u0005@\n\u00d7\u00a3p=\n\u0001\u00c0\u0004V\u000e-\u00b2\u009d\u001a@}?5^\u00ba\u00c9\u0010@\u00aeG\u00e1z\u0014\u00ae\u00ff\u00bf\u009d\u00c4 \u00b0r\u00e8\u0016@\u0087\u0016\u00d9\u00ce\u00f7S\u0013@\u001b/\u00dd$\u0006\u0081\u0012\u00c0\u0098n\u0012\u0083\u00c0J\u0016@\u00e4\u00a5\u009b\u00c4 \u00b0\u0015@)\\\u008f\u00c2\u00f5(\u0012\u00c0\u00edQ\u00b8\u001e\u0085\u00eb\u0019@\u0083\u00c0\u00ca\u00a1E6\u0015@\u008d\u0097n\u0012\u0083@\u0010\u00c0\u00f0\u00a7\u00c6K7\t\u0013@V\u000e-\u00b2\u009do\u0013@E\u008bl\u00e7\u00fb\u00a9\u0016\u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\u0014@m\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd\u00bf\u00a2E\u00b6\u00f3\u00fd\u00d4\u0014\u00c0\u00a3E\u00b6\u00f3\u00fd\u00d4\u0016@z\u00e9&1\b\u00ac|?\u00cav\u00be\u009f\u001a\u00af\u0018\u00c05^\u00baI\f\u0082\u0017@\u0002+\u0087\u0016\u00d9\u00ce\u00f5\u00bfy\u00e9&1\b\u00ac\u0013\u00c0o\u0012\u0083\u00c0\u00ca!\u0013@\u0014\u00aeG\u00e1z\u0014\u00f0\u00bfn\u00e7\u00fb\u00a9\u00f1\u00d2\u0010\u00c0^\u00baI\f\u0002+\u0010@\u0002+\u0087\u0016\u00d9\u00ce\u0003\u00c0F\u00b6\u00f3\u00fd\u00d4x\u0010\u00c0\"\u00b0rh\u0091m\u0016@\u00d0\u00f7S\u00e3\u00a5\u009b\u00fe\u00bf\u00b3\u009d\u00ef\u00a7\u00c6K\u0018\u00c0&\u0006\u0081\u0095C\u008b\u000f@\u001c/\u00dd$\u0006\u0081\u00ff\u00bf\u008d\u0097n\u0012\u0083\u00c0\u001b\u00c0;\u00dfO\u008d\u0097n\u0012@\u001b/\u00dd$\u0006\u0081\u00f1\u00bf/\u00dd$\u0006\u0081\u0015\u0019\u00c0`\u00e5\u00d0\"\u00db\u00f9\t@n\u00e7\u00fb\u00a9\u00f1\u00d2\u0006\u00c0Y9\u00b4\u00c8v>\u0017\u00c09\u00b4\u00c8v\u00be\u009f\u000b@\u00a2E\u00b6\u00f3\u00fd\u00d4\u0007\u00c0\u008cl\u00e7\u00fb\u00a9\u00f1\b\u00c0\u0019\u0004V\u000e-2\u0014@\u009a\u0099\u0099\u0099\u0099\u0099\u0007\u00c0\u00e5\u00d0\"\u00db\u00f9~\u0012\u00c0\u00c6 \u00b0rh\u0011\u001b@\u0080j\u00bct\u0093\u0018\u0004\u00c0\u0006\u0081\u0095C\u008b\u00ec\u0015\u00c0\f\u0002+\u0087\u0016Y\u001c@\u00a8\u00c6K7\u0089A\u0010\u00c0\u00ecQ\u00b8\u001e\u0085\u00eb\u000f\u00c0|\u0014\u00aeG\u00e1\u00fa\u001d@\u008bl\u00e7\u00fb\u00a9\u00f1\u0013\u00c07\u0089A`\u00e5\u00d0\u000f\u00c0 \u0085\u00ebQ\u00b8\u009e\u001b@\u00e4\u00a5\u009b\u00c4 \u00b0\f\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u0004\u00c0Y9\u00b4\u00c8v\u00be\u001f@\u0087\u0016\u00d9\u00ce\u00f7\u00d3\u0011\u00c0!\u00b0rh\u0091m\u0013\u00c0!\u00b0rh\u0091m!@\u00b6\u00f3\u00fd\u00d4xi\u0012\u00c0\u00cb\u00a1E\u00b6\u00f3}\u0017\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6 @\u00e8\u00fb\u00a9\u00f1\u00d2M\f\u00c0\u00ac\u001cZd;\u00df\u0013\u00c0\u00a2E\u00b6\u00f3\u00fd\u0094\"@%\u0006\u0081\u0095C\u000b\u0011\u00c0\u0085\u00ebQ\u00b8\u001e\u0085\u00f9\u00bf\u001a\u0004V\u000e-\u00b2\u001e@\u008cl\u00e7\u00fb\u00a9q\u0016\u00c0b\u0010X9\u00b4H\u0011\u00c0\u00a4p=\n\u00d7##@\u00e2z\u0014\u00aeG\u00e1\u0019\u00c0\u001f\u0085\u00ebQ\u00b8\u009e\u0010\u00c0\u00d7\u00a3p=\n\u00d7!@V\u000e-\u00b2\u009do\u0015\u00c0\u00f6(\\\u008f\u00c2\u00f5\n\u00c0?5^\u00baI\f$@w\u00be\u009f\u001a/\u00dd\u0017\u00c0\u00e9&1\b\u00ac\u009c\u0014\u00c0\u00c8K7\u0089A\u00a0%@\u0000\u0000\u0000\u0000\u0000\u0080\u001c\u00c0\u00baI\f\u0002+\u0007\u0015\u00c0q=\n\u00d7\u00a3p&@+\u0087\u0016\u00d9\u00ce\u00f7\u0013\u00c0\u00fc\u00a9\u00f1\u00d2M\u00e2\u0016\u00c0q=\n\u00d7\u00a3\u00b0&@J\f\u0002+\u0087\u0016\u0003\u00c0ffffff\u0003\u00c09\u00b4\u00c8v\u00be\u00df @?5^\u00baI\f\u00fe\u00bf5^\u00baI\f\u0002\n\u00c0\u00d3Mb\u0010Xy!@\u000f-\u00b2\u009d\u00ef\u00a7\u00fc\u00bfD\u008bl\u00e7\u00fb\u00a9\u00f3\u00bf+\u0087\u0016\u00d9\u00ce\u00b7!@\u00e3\u00a5\u009b\u00c4 \u00b0\u0003\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\u00e6\u00bf\u00b4\u00c8v\u00be\u009f\u001a#@\u00baI\f\u0002+\u0087\u00f8\u00bf\u00c2\u00ca\u00a1E\u00b6\u00f3\u00cd\u00bfx\u00be\u009f\u001a/\u00dd\u001e@\t\u00ac\u001cZd;\u00df\u00bfi\u0091\u00ed|?5\u00f6\u00bfP\u008d\u0097n\u0012C#@\u0092\u00ed|?5^\u00ca?th\u0091\u00ed|?\u00fd\u00bfZd;\u00dfO\u00cd!@\u00c9v\u00be\u009f\u001a/\u00bd\u00bf6^\u00baI\f\u0002\u00db\u00bf\u00a6\u009b\u00c4 \u00b0\u00f2#@\u00fd\u00a9\u00f1\u00d2Mb\u00fa\u00bf\u008e\u0097n\u0012\u0083\u00c0\u00ee?\u00f0\u00a7\u00c6K7\t @^\u00baI\f\u0002+\u00e3\u00bfr=\n\u00d7\u00a3p\u0002\u00c02\b\u00ac\u001cZd%@D\u008bl\u00e7\u00fb\u00a9\u00e5\u00bf\u0011X9\u00b4\u00c8v\t\u00c0\u00ad\u001cZd;\u009f$@\"\u00b0rh\u0091\u00ed\u00f2\u00bf\u00e3\u00a5\u009b\u00c4 \u00b0\u00e2\u00bf\u00d7\u00a3p=\n\u00d7\u0019@\u00a8\u00c6K7\u0089A\u00ec\u00bfP\u008d\u0097n\u0012\u0083\u00f8\u00bfd;\u00dfO\u008d\u0017\u0019@\u00cf\u00f7S\u00e3\u00a5\u009b\u00f0\u00bf\u0004V\u000e-\u00b2\u009d\u00df?\u00b3\u009d\u00ef\u00a7\u00c6\u00cb\u0015@\u00ee|?5^\u00ba\u00e5\u00bfJ\f\u0002+\u0087\u0016\u00f7?1\b\u00ac\u001cZd\u0017@ffffff\u0003\u00c0\u0089A`\u00e5\u00d0\"\u00ef?\u00b6\u00f3\u00fd\u00d4xi\u0014@\u00fe\u00d4x\u00e9&1\u00d0\u00bf\u00db\u00f9~j\u00bct\u00a3\u00bf\u0096C\u008bl\u00e7\u00fb\u0010@$\u00db\u00f9~j\u00bc\u00e4\u00bf(1\b\u00ac\u001cZ\u00f0\u00bf\u00cc\u00a1E\u00b6\u00f3\u00fd\u000f@\u00e3\u00a5\u009b\u00c4 \u00b0\u0004\u00c0^\u00baI\f\u0002+\u0001@P\u008d\u0097n\u0012\u0083\u0013@\u00fb~j\u00bct\u0093\u00f4?\u00a4p=\n\u00d7\u00a3\u00c0\u00bfffffff\u0012@\u00cav\u00be\u009f\u001a/\u00fb?S\u00b8\u001e\u0085\u00ebQ\u00e8\u00bf\u00a7\u009b\u00c4 \u00b0r\u000e@@5^\u00baI\f\u00f6?\u00aa\u00f1\u00d2Mb\u0010\u00e4\u00bfH\u00e1z\u0014\u00aeG\u0016@\u0089A`\u00e5\u00d0\"\u00d3\u00bf\u00f5\u00fd\u00d4x\u00e9&\u00ed?\u0017\u00d9\u00ce\u00f7S\u00e3\u0007@\u0083\u00c0\u00ca\u00a1E\u00b6\u00d3\u00bfth\u0091\u00ed|?\u00ff?\u00b0rh\u0091\u00ed|\n@\u00f4\u00fd\u00d4x\u00e9&\u00e1?\u0092\u00ed|?5^\u00e6?P\u008d\u0097n\u0012\u0083\u0002@R\u00b8\u001e\u0085\u00ebQ\u00f4\u00bfK\f\u0002+\u0087\u0016\u00e9??5^\u00baI\f\u0004@\u00e5\u00d0\"\u00db\u00f9~\u0000@d;\u00dfO\u008d\u0097\u00f2?B`\u00e5\u00d0\"[\u0013@\u00c5 \u00b0rh\u0091\u00fb?S\u00b8\u001e\u0085\u00ebQ\u00fc?\u00d4Mb\u0010X\u00b9\u0016@\u00d5x\u00e9&1\b\u0001@\u008cl\u00e7\u00fb\u00a9\u00f1\u00fc?\u00e4\u00a5\u009b\u00c4 \u00b0\u000f@\u00c6 \u00b0rh\u0091\b@%\u0006\u0081\u0095C\u008b\u00e8?'1\b\u00ac\u001c\u00da\u0013@z\u00e9&1\b\u00ac\u000b\u00c0\u0003+\u0087\u0016\u00d9\u00ce\u00b7?D\u008bl\u00e7\u00fb\u00a9\u0014@\u00ecQ\u00b8\u001e\u0085\u00eb\n\u00c0\u0084\u00c0\u00ca\u00a1E\u00b6\u00eb\u00bfL7\u0089A`\u00e5\u0015@\n\u00d7\u00a3p=\u008a\u0013\u00c0\u0092\u00ed|?5^\u00da?6^\u00baI\f\u0082\u0013@}?5^\u00baI\u0014\u00c0{\u0014\u00aeG\u00e1z\u00f0?\u0085\u00ebQ\u00b8\u001e\u0005\u0010@\u0091\u00ed|?5\u00de\u0015\u00c0\u00bct\u0093\u0018\u0004V\u00f4?\u00fb~j\u00bct\u0013\u0018@)\\\u008f\u00c2\u00f5\u00a8\u0016\u00c0T\u00e3\u00a5\u009b\u00c4 \u00ec\u00bf\u00d1\"\u00db\u00f9~j\u0012@2\b\u00ac\u001cZ\u00e4\u0016\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u00f7\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u0016@\u00baI\f\u0002+\u0087\u0018\u00c0\u00a8\u00c6K7\u0089A\u0002@Zd;\u00dfO\r\u0017@:\u00b4\u00c8v\u00be\u001f\u001c\u00c0\u00bct\u0093\u0018\u0004V\u00e2\u00bfo\u0012\u0083\u00c0\u00ca\u00a1\u0010@\u00d2\"\u00db\u00f9~j\u001e\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u00f7\u00bf=\n\u00d7\u00a3p=\u0010@S\u00b8\u001e\u0085\u00eb\u00d1\u001e\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u008e\u00bf\u00c9v\u00be\u009f\u001a/\u0013@\u008e\u0097n\u0012\u0083@\u001c\u00c0\u00fa~j\u00bct\u0093h?c\u0010X9\u00b4\u00c8\t@\u0093\u0018\u0004V\u000e-\u0014\u00c0h\u0091\u00ed|?5\u00fa\u00bf\u00d3Mb\u0010X9\r@\u009c\u00c4 \u00b0rh\u0011\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u0000\u00c0\u00d1\"\u00db\u00f9~j\u0010@&\u0006\u0081\u0095C\u008b\u0014\u00c0\u0099n\u0012\u0083\u00c0\u00ca\u00ed?D\u008bl\u00e7\u00fb)\u001d@\u00d1\"\u00db\u00f9~j\u0012\u00c0b\u0010X9\u00b4\u00c8\u00b6?\u0088\u0016\u00d9\u00ce\u00f7\u00d3\u001d@d;\u00dfO\u008d\u0097\u0015\u00c0\u00a6\u009b\u00c4 \u00b0r\u00fc?&\u0006\u0081\u0095C\u00cb @\u0010X9\u00b4\u00c8\u00f6\u0019\u00c0\u000f-\u00b2\u009d\u00ef\u00a7\u00fc?\u00a0\u001a/\u00dd$\u00c6 @^\u00baI\f\u0002\u00ab\u0013\u00c0\u00a7\u009b\u00c4 \u00b0r\t@\u009a\u0099\u0099\u0099\u0099Y @\u00be\u009f\u001a/\u00dd$\u0013\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u00f3?\u0006\u0081\u0095C\u008bl#@/\u00dd$\u0006\u0081\u0015\u0014\u00c0~?5^\u00baI\u00fe?\u00fa~j\u00bct\u0013%@\u00a5p=\n\u00d7\u00a3\r\u00c01\b\u00ac\u001cZd\u00f3?\u0002+\u0087\u0016\u00d9\u000e#@6^\u00baI\f\u0002\u0017\u00c0\u00bct\u0093\u0018\u0004V\u0010@\u0093\u0018\u0004V\u000em @Nb\u0010X94\u0015\u00c0\u00db\u00f9~j\u00bct\u00c3\u00bf\u00f8S\u00e3\u00a5\u009bD$@\u00e2z\u0014\u00aeG\u00e1\u0019\u00c0\u001f\u0085\u00ebQ\u00b8\u001e\u00e1\u00bfu\u0093\u0018\u0004V\u00ce#@\u00c5 \u00b0rh\u0091\u0012\u00c0]\u008f\u00c2\u00f5(\\\u00eb\u00bfh\u0091\u00ed|?\u00f5%@\u00aa\u00f1\u00d2Mb\u0010\r\u00c0\u00d8\u00a3p=\n\u00d7\u000b@\u00b9\u001e\u0085\u00ebQ\u00b8\u001f@r=\n\u00d7\u00a3p\u0007\u00c0\u0000\u0000\u0000\u0000\u0000\u0000\u0006@0\u00dd$\u0006\u0081\u0095\u001f@\u0083\u00c0\u00ca\u00a1E\u00b6\b\u00c0th\u0091\u00ed|?\u0013@\u00e6\u00d0\"\u00db\u00f9\u00fe\u001e@\u00cf\u00f7S\u00e3\u00a5\u009b\n\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2\u00cd\u0015@\u0019\u0004V\u000e-2!@\b\u00ac\u001cZd;\u000e\u00c0d;\u00dfO\u008d\u0017\u0016@K\f\u0002+\u0087\u0016\u001a@\u00a7\u009b\u00c4 \u00b0r\u00f8\u00bfZd;\u00dfO\r\u0013@I\u00e1z\u0014\u00aeG\u001e@[d;\u00dfO\u008d\u00f5\u00bf\u008e\u0097n\u0012\u0083\u00c0\u000f@\u0018\u00d9\u00ce\u00f7Sc\u001b@\u00f6(\\\u008f\u00c2\u00f5\u000f\u00c0\u00f4\u00fd\u00d4x\u00e9&\u001b@\u00d2\"\u00db\u00f9~j\u001a@|\u0014\u00aeG\u00e1z\u00e8\u00bfI\u00e1z\u0014\u00aeG\u0018@\u0018\u00d9\u00ce\u00f7Sc\u001c@^\u00baI\f\u0002+\u00f3\u00bf>\n\u00d7\u00a3p=\u001a@q=\n\u00d7\u00a3\u00f0\u0018@\u001c/\u00dd$\u0006\u0081\u00e5\u00bf.\u00b2\u009d\u00ef\u00a7F\u001b@\u0014\u00aeG\u00e1z\u0094\u001f@\u00f4\u00fd\u00d4x\u00e9&\u00d1?\u00da\u00ce\u00f7S\u00e3\u00a5\u0017@\u00da\u00ce\u00f7S\u00e3%\u001b@\u00f0\u00a7\u00c6K7\u0089\u00e9\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u0011@\u00da\u00ce\u00f7S\u00e3\u00a5!@\u0006\u0081\u0095C\u008bl\u00f5\u00bf\u000e-\u00b2\u009d\u00ef\u00a7\u000b@\u00fe\u00d4x\u00e9&\u00b1\"@?5^\u00baI\f\u00c2?\u00d9\u00ce\u00f7S\u00e3\u00a5\u000e@\u00ecQ\u00b8\u001e\u0085\u00eb @;\u00dfO\u008d\u0097n\u00e2\u00bf\u001eZd;\u00df\u00cf\u0013@X9\u00b4\u00c8v>#@\f\u0002+\u0087\u0016Y\u0010\u00c0\u0089A`\u00e5\u00d0\"\u0013@\u0085\u00ebQ\u00b8\u001e\u0005\u0016@\u00cc\u00a1E\u00b6\u00f3\u00fd\u000f\u00c0\u00c9v\u00be\u009f\u001a/\u000e@\u0014\u00aeG\u00e1z\u0014\u0016@\u0004V\u000e-\u00b2\u001d\u0013\u00c0{\u0014\u00aeG\u00e1z\u0015@\u00d5x\u00e9&1\u0088\u0011@Zd;\u00dfO\u008d\u0010\u00c0\u0019\u0004V\u000e-\u00b2\u0018@J\f\u0002+\u0087\u0016\u0010@\u001eZd;\u00df\u00cf\u0018\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\u0017@)\\\u008f\u00c2\u00f5\u00a8\u0012@\u001c/\u00dd$\u0006\u0001\u0013\u00c0\u00f4\u00fd\u00d4x\u00e9&\u0011@\u00e5\u00d0\"\u00db\u00f9~\n@?5^\u00baI\f\u000e\u00c0<\u00dfO\u008d\u0097n\u000f@\u00a7\u009b\u00c4 \u00b0r\b@\u0006\u0081\u0095C\u008b\u00ec\u0014\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u000b@\u00aeG\u00e1z\u0014\u00ae\r@\u00f9S\u00e3\u00a5\u009b\u00c4\u0019\u00c0\u000b\u00d7\u00a3p=\n\u001c@\u0002+\u0087\u0016\u00d9\u00ce\u0010@fffff\u00e6\u0015\u00c0\u00be\u009f\u001a/\u00dd\u00a4\u0012@\u00a0\u001a/\u00dd$\u0006\u0000@8\u0089A`\u00e5P\u0019\u00c0\u00f8S\u00e3\u00a5\u009bD\u0015@\u00cf\u00f7S\u00e3\u00a5\u009b\u0001@~?5^\u00baI\u0012\u00c0\u00fe\u00d4x\u00e9&\u00b1\u0015@,\u0087\u0016\u00d9\u00ce\u00f7\u00f1?333333\u0011\u00c0b\u0010X9\u00b4H\u0019@\u00b9\u001e\u0085\u00ebQ\u00b8\u00fa?p\u0012\u0083\u00c0\u00ca\u00a1\r\u00c0\u0004V\u000e-\u00b2\u001d\u0013@+\u0087\u0016\u00d9\u00ce\u00f7\u00ef?\u00cf\u00f7S\u00e3\u00a5\u001b\u0014\u00c0\u008f\u00c2\u00f5(\\\u008f\u0016@$\u00db\u00f9~j\u00bc\u00c4?\u0084\u00c0\u00ca\u00a1E6\u0018\u00c0\u00f1\u00a7\u00c6K7\u0089\u000b@b\u0010X9\u00b4\u00c8\u00f4?*\\\u008f\u00c2\u00f5\u00a8\u001a\u00c0\u001b/\u00dd$\u0006\u0081\r@433333\u00db?{\u0014\u00aeG\u00e1z\u0015\u00c0\u007fj\u00bct\u0093\u0018\u0005@\u00a8\u00c6K7\u0089A\u00f0?\u00bdt\u0093\u0018\u0004\u00d6\u001a\u00c0h\u0091\u00ed|?5\b@\u00a6\u009b\u00c4 \u00b0r\u0000@c\u0010X9\u00b4H\u001c\u00c0\u00aa\u00f1\u00d2Mb\u0090\u0014@\u00e1z\u0014\u00aeGa\u0015@\u00d2\"\u00db\u00f9~\u00ea\u001a\u00c0<\u00dfO\u008d\u0097\u00ee\u0010@j\u00bct\u0093\u0018\u0084\u0016@\u00f2\u00d2Mb\u0010\u00d8 \u00c01\b\u00ac\u001cZ\u00e4\u0015@\u00c9v\u00be\u009f\u001a\u00af\u0016@\u0014\u00aeG\u00e1z\u0094!\u00c0\u0002+\u0087\u0016\u00d9N\u0018@w\u00be\u009f\u001a/]\u0013@\u00c9v\u00be\u009f\u001a/!\u00c0\u009e\u00ef\u00a7\u00c6K7\u0019@\u0014\u00aeG\u00e1z\u0094\u001b@\b\u00ac\u001cZd\u00bb\"\u00c0\u0091\u00ed|?5\u00de\u0010@\u00bbI\f\u0002+\u0087\u0016@D\u008bl\u00e7\u00fb)\"\u00c0b\u0010X9\u00b4\u00c8\u000b@`\u00e5\u00d0\"\u00dby\u0019@\"\u00b0rh\u0091\u00ed\"\u00c0z\u00e9&1\b\u00ac\u001c@\u0090\u00c2\u00f5(\\\u000f\u001c@=\n\u00d7\u00a3p\u00bd%\u00c0\u007fj\u00bct\u0093\u0098\u0012@\u00ecQ\u00b8\u001e\u0085k\u0017@\u009e\u00ef\u00a7\u00c6K7&\u00c0\u008aA`\u00e5\u00d0\u00a2\u0015@\u00c2\u00ca\u00a1E\u00b6s\u0014@\u008d\u0097n\u0012\u0083\u0000'\u00c0 \u0085\u00ebQ\u00b8\u001e\u000e@\u00b0rh\u0091\u00ed\u00fc\u0016@$\u00db\u00f9~j\u00fc%\u00c0V\u000e-\u00b2\u009do\u0014@R\u00b8\u001e\u0085\u00ebQ\u001b@\u00c8K7\u0089A #\u00c0\u00dfO\u008d\u0097n\u0012\f@\u00d9\u00ce\u00f7S\u00e3%\u0011@\"\u00b0rh\u0091-$\u00c0\u00a4p=\n\u00d7\u00a3\u0004@\u00db\u00f9~j\u00bc\u00f4\u0011@\u0091\u00ed|?5\u00de#\u00c0\u0004V\u000e-\u00b2\u009d\u0010@x\u00be\u009f\u001a/\u00dd\u000b@\u0014\u00aeG\u00e1z\u0014!\u00c0\u00c3\u00f5(\\\u008f\u00c2\n@\u00c6 \u00b0rh\u0091\u000f@\u00d0\u00f7S\u00e3\u00a5\u009b\u001e\u00c0\u000f-\u00b2\u009d\u00ef\u00a7\u0018@L7\u0089A`e\u001f@\u009e\u00ef\u00a7\u00c6K7\u001c\u00c02\b\u00ac\u001cZd\u0015@d;\u00dfO\u008d\u0017\u001f@\u00a1\u001a/\u00dd$\u0086\u001e\u00c0\u00f3\u00d2Mb\u0010X\u001c@\u0087\u0016\u00d9\u00ce\u00f7\u0013\"@\u0091\u00ed|?5^!\u00c0\u0003+\u0087\u0016\u00d9\u00ce\u001c@T\u00e3\u00a5\u009b\u00c4\u00a0\"@\u0015\u00aeG\u00e1z\u0094\u001c\u00c0?5^\u00baI\f!@T\u00e3\u00a5\u009b\u00c4\u00a0!@\u0098n\u0012\u0083\u00c0\u00ca\u001b\u00c09\u00b4\u00c8v\u00be\u001f\u0019@\u00baI\f\u0002+G$@\u008cl\u00e7\u00fb\u00a9q\u001b\u00c0F\u00b6\u00f3\u00fd\u00d4\u00f8\u001b@\u0094\u0018\u0004V\u000e\u00ed%@\u00d4Mb\u0010X\u00b9\u0017\u00c06^\u00baI\f\u0002\u0018@+\u0087\u0016\u00d9\u00ce\u00b7#@Ob\u0010X94\u001e\u00c0\u00e6\u00d0\"\u00db\u00f9\u00be\"@\u008bl\u00e7\u00fb\u00a91#@{\u0014\u00aeG\u00e1z\u001e\u00c0K\f\u0002+\u0087\u0016\u0014@q=\n\u00d7\u00a3p%@w\u00be\u009f\u001a/]!\u00c0x\u00be\u009f\u001a/\u00dd\u0014@\u00b4\u00c8v\u00be\u009f\u009a%@,\u0087\u0016\u00d9\u00cew\u001e\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u0010@\u001c/\u00dd$\u0006\u0001$@\u00ff\u00d4x\u00e9&1\u001c\u00c0\u00f2\u00d2Mb\u0010X\u0012@fffff&(@\\\u008f\u00c2\u00f5(\u00dc\u0017\u00c0\u00dd$\u0006\u0081\u0095\u00c3\u0012@$\u00db\u00f9~j<(@,\u0087\u0016\u00d9\u00ce\u00f7\u001d\u00c0:\u00b4\u00c8v\u00be\u001f\u0015@\u00c6 \u00b0rh\u0091)@\u00e3\u00a5\u009b\u00c4 \u00b0\u001d\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\t@\u00b6\u00f3\u00fd\u00d4x\u00e9(@b\u0010X9\u00b4\u00c8\u001f\u00c0\u00e9&1\b\u00ac\u001c\u0005@\u00f4\u00fd\u00d4x\u00e9\u00a6'@\u00e8\u00fb\u00a9\u00f1\u00d2M\u0019\u00c0\u000f-\u00b2\u009d\u00ef\u00a7\b@\u00b4\u00c8v\u00be\u009f\u001a-@+\u0087\u0016\u00d9\u00cew\u0017\u00c0\u0082\u0095C\u008bl\u00e7\u000f@8\u0089A`\u00e5\u0010-@\u00a5p=\n\u00d7#\u001a\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u0005@\u00aeG\u00e1z\u0014\u00ee.@\u00aa\u00f1\u00d2Mb\u0010\u001e\u00c0%\u0006\u0081\u0095C\u008b\u00f6?\u0017\u00d9\u00ce\u00f7S\u00a3+@\u0011X9\u00b4\u00c8\u00f6\u001f\u00c0\u00c6 \u00b0rh\u0091\u00e9?d;\u00dfO\u008dW*@E\u008bl\u00e7\u00fb\u00a9\u001c\u00c0T\u00e3\u00a5\u009b\u00c4 \u00f0?\u00b4\u00c8v\u00be\u009fZ-@\u008cl\u00e7\u00fb\u00a9q\u001c\u00c0\u0018\u00d9\u00ce\u00f7S\u00e3\u0004@W\u000e-\u00b2\u009d/+@\u00edQ\u00b8\u001e\u0085\u00eb\u0019\u00c0\u008d\u0097n\u0012\u0083\u0080!@\u0094\u0018\u0004V\u000e\u00ad\u001e@\u00e3\u00a5\u009b\u00c4 \u00b0\u0018\u00c0\u00bct\u0093\u0018\u0004\u0016 @J\f\u0002+\u0087\u0016\u001c@I\u00e1z\u0014\u00aeG\u0018\u00c0\u00a2E\u00b6\u00f3\u00fd\u0014$@R\u00b8\u001e\u0085\u00eb\u00d1\u001c@\u00e4\u00a5\u009b\u00c4 0\u0018\u00c0?5^\u00baI\u008c%@\u00b2\u009d\u00ef\u00a7\u00c6\u000b @5^\u00baI\f\u0082\u001b\u00c0\u0003+\u0087\u0016\u00d9N%@\u00f5\u00fd\u00d4x\u00e9&\u0018@\u00d3Mb\u0010X9\u0012\u00c0\u00fe\u00d4x\u00e9&1$@\u00a0\u001a/\u00dd$\u0086\u001b@\u0004V\u000e-\u00b2\u001d\u0011\u00c0\u00e3\u00a5\u009b\u00c4 0&@\u0083\u00c0\u00ca\u00a1E6\u001a@X9\u00b4\u00c8v\u00be\u001d\u00c0$\u00db\u00f9~j|'@\u00a6\u009b\u00c4 \u00b0\u00f2\u0018@\u00ecQ\u00b8\u001e\u0085\u00eb\f\u00c0F\u00b6\u00f3\u00fd\u00d4\u00b8#@\u0089A`\u00e5\u00d0\" @&\u0006\u0081\u0095C\u008b\u000f\u00c0\u00cf\u00f7S\u00e3\u00a5\u001b\"@;\u00dfO\u008d\u0097n!@\u00e7\u00fb\u00a9\u00f1\u00d2M\u0004\u00c0w\u00be\u009f\u001a/\u00dd#@\u00d9\u00ce\u00f7S\u00e3\u00a5\u001f@\u00a4p=\n\u00d7\u00a3\u000f\u00c0\u00bct\u0093\u0018\u0004V%@\u00c1\u00ca\u00a1E\u00b6s!@\u00fc\u00a9\u00f1\u00d2Mb\u0011\u00c0X9\u00b4\u00c8v~\"@J\f\u0002+\u0087\u0016\u0017@\u008bl\u00e7\u00fb\u00a9\u00f1\u0010\u00c0\u00fe\u00d4x\u00e9&\u00b1 @\u00bdt\u0093\u0018\u0004V\u0018@\u00f5\u00fd\u00d4x\u00e9&\u001c\u00c0\u00e3\u00a5\u009b\u00c4 \u00f0#@<\u00dfO\u008d\u0097n\u0013@\u00b7\u00f3\u00fd\u00d4x\u00e9\u001a\u00c0\u00a0\u001a/\u00dd$\u0006\"@33333\u00b3\u0013@\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u001d\u00c0\u00f3\u00d2Mb\u0010\u0018%@z\u00e9&1\b\u00ac\f@\u00ea&1\b\u00ac\u001c\u001f\u00c0\\\u008f\u00c2\u00f5(\u001c'@\u009b\u0099\u0099\u0099\u0099\u0099\u000e@\u007fj\u00bct\u0093\u0098!\u00c0\u00ee|?5^\u00fa#@\u0001\u0000\u0000\u0000\u0000\u0000\b@>\n\u00d7\u00a3p=\u0019\u00c0\u00e0O\u008d\u0097n\u0012%@\u00fe\u00d4x\u00e9&1\u0004@\r\u0002+\u0087\u0016Y\u001a\u00c0\u00c3\u00f5(\\\u008f\u00c2%@ffffff\u00f8?i\u0091\u00ed|?\u00b5\u0018\u00c0\u00e3\u00a5\u009b\u00c4 \u00f0\"@\n\u00d7\u00a3p=\n\u0003@\\\u008f\u00c2\u00f5(\u001c\"\u00c0B`\u00e5\u00d0\"[$@ \u0085\u00ebQ\u00b8\u001e\u00fd?\u0013\u0083\u00c0\u00ca\u00a1E\u0014\u00c0F\u00b6\u00f3\u00fd\u00d4\u00b8&@\\\u008f\u00c2\u00f5(\\\u0007@#\u00db\u00f9~j<\u0012\u00c0\n\u00d7\u00a3p=\u00ca%@\u00e0O\u008d\u0097n\u0012\u000e@h\u0091\u00ed|?5\u0011\u00c0b\u0010X9\u00b4\u00c8&@\u00aa\u00f1\u00d2Mb\u0010\u0001@\b\u00ac\u001cZd;\u0016\u00c0Zd;\u00dfO\u008d)@\u00c8K7\u0089A`\n@\u009c\u00c4 \u00b0rh\u0018\u00c0q=\n\u00d7\u00a3p*@X9\u00b4\u00c8v\u00be\u0003@\u00cd\u00cc\u00cc\u00cc\u00ccL\u0018\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0)@\u0000\u0000\u0000\u0000\u0000\u0000\u0011@\u00e7\u00fb\u00a9\u00f1\u00d2M\u0011\u00c0\u00a6\u009b\u00c4 \u00b02+@\u0010X9\u00b4\u00c8v\f@\u00c2\u00ca\u00a1E\u00b6\u00f3\f\u00c0\u00cc\u00a1E\u00b6\u00f3\u00fd*@x\u00be\u009f\u001a/\u00dd\u0005@I\u00e1z\u0014\u00aeG\u000e\u00c0\u0004V\u000e-\u00b2]*@\u00f4\u00fd\u00d4x\u00e9\u00a6\u0011@\u00cf\u00f7S\u00e3\u00a5\u001b\u0013\u00c0Nb\u0010X9\u00f4-@\u0018\u00d9\u00ce\u00f7S\u00e3\u000e@L7\u0089A`\u00e5\u0015\u00c0\u00f0\u00a7\u00c6K7\u00c9-@\u00ac\u001cZd;_\u0012@\u00e3\u00a5\u009b\u00c4 0\u0010\u00c0\u00f4\u00fd\u00d4x\u00e9\u00e6.@V\u000e-\u00b2\u009do\u0011@\u0007\u0081\u0095C\u008bl\u0014\u00c0m\u00e7\u00fb\u00a9\u00f1\u0012/@\u0083\u00c0\u00ca\u00a1E\u00b6\b@X9\u00b4\u00c8v~#\u00c0\u00ee|?5^\u00fa\"@\u00c1\u00ca\u00a1E\u00b6\u00f3\u000e@\u0098n\u0012\u0083\u00c0\n#\u00c0b\u0010X9\u00b4\u00c8\"@\u0017\u00d9\u00ce\u00f7Sc\u0013@\u0006\u0081\u0095C\u008b,&\u00c0\u00ee|?5^\u00fa!@\u00fd\u00a9\u00f1\u00d2Mb\u000b@T\u00e3\u00a5\u009b\u00c4\u00e0%\u00c0\u00c9v\u00be\u009f\u001ao @\u00b2\u009d\u00ef\u00a7\u00c6K\u0005@1\b\u00ac\u001cZ\u00a4'\u00c0z\u00e9&1\b,$@\u0098n\u0012\u0083\u00c0\u00ca\u0004@\u008f\u00c2\u00f5(\\\u00cf'\u00c0\u00be\u009f\u001a/\u00dd\u00a4 @\u001b/\u00dd$\u0006\u0001\u0012@:\u00b4\u00c8v\u00be\u009f(\u00c0`\u00e5\u00d0\"\u00db9\"@\u0085\u00ebQ\u00b8\u001e\u0085\u0014@q=\n\u00d7\u00a3p&\u00c0(1\b\u00ac\u001cZ\u001f@\u0012\u0083\u00c0\u00ca\u00a1\u00c5\u0014@\u0088\u0016\u00d9\u00ce\u00f7\u00d3(\u00c0o\u0012\u0083\u00c0\u00ca\u00a1#@\u00fc\u00a9\u00f1\u00d2Mb\u00f8?\u00a6\u009b\u00c4 \u00b0\u00f2)\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u001d@\u00e7\u00fb\u00a9\u00f1\u00d2M\u000f@\u00e6\u00d0\"\u00db\u00f9>+\u00c0P\u008d\u0097n\u0012C @\u00d9\u00ce\u00f7S\u00e3\u00a5\n@\u00f4\u00fd\u00d4x\u00e9&)\u00c0\u0082\u0095C\u008bl\u00e7\u001a@\u008cl\u00e7\u00fb\u00a9\u00f1\t@\u0081\u0095C\u008bl\u00a7+\u00c0\u00f4\u00fd\u00d4x\u00e9\u00a6\u001b@R\u00b8\u001e\u0085\u00eb\u00d1\u0013@\u00bct\u0093\u0018\u0004\u00d6,\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\u001e@L7\u0089A`\u00e5\u0015@\u00cb\u00a1E\u00b6\u00f3=*\u00c0\u008cl\u00e7\u00fb\u00a9q\u001a@\u00fc\u00a9\u00f1\u00d2M\u00e2\u0016@\u0005V\u000e-\u00b2]-\u00c0\n\u00d7\u00a3p=\n\u0017@o\u0012\u0083\u00c0\u00ca!\u0012@h\u0091\u00ed|?\u00b5,\u00c0\u00db\u00f9~j\u00bct\u0013@L7\u0089A`e\u0013@\u0084\u00c0\u00ca\u00a1EV0\u00c0\u00cav\u00be\u009f\u001a/\u001c@\u008aA`\u00e5\u00d0\"\r@\u00f4\u00fd\u00d4x\u00e9F1\u00c0ffffff\u001c@\u00d6x\u00e9&1\b\n@\u00c8K7\u0089A\u00000\u00c0\u0011X9\u00b4\u00c8\u00f6\u001f@\u008cl\u00e7\u00fb\u00a9\u00f1\f@;\u00dfO\u008d\u0097\u00ae0\u00c0\u009c\u00c4 \u00b0rh\u0013@\u0014\u00aeG\u00e1z\u0014\u000e@|\u0014\u00aeG\u00e1:0\u00c0\u0004V\u000e-\u00b2\u009d\u000f@8\u0089A`\u00e5\u00d0\r@\u00ecQ\u00b8\u001e\u0085\u008b1\u00c0\u00c9v\u00be\u009f\u001a/\u0014@>\n\u00d7\u00a3p=\n@Zd;\u00dfO\u00cd/\u00c0+\u0087\u0016\u00d9\u00cew\u0017@\u009a\u0099\u0099\u0099\u0099\u0019\u0010@V\u000e-\u00b2\u009d\u00ef'\u00c0K\f\u0002+\u0087\u0096&@5^\u00baI\f\u0002\n@\u00dd$\u0006\u0081\u0095C'\u00c0\u00e0O\u008d\u0097n\u0092&@\u0098n\u0012\u0083\u00c0\u00ca\u0010@\u00ea&1\b\u00ac\\)\u00c0\u00cav\u00be\u009f\u001a\u00ef(@\u009f\u00ef\u00a7\u00c6K7\u0005@\u00fe\u00d4x\u00e9&q+\u00c0j\u00bct\u0093\u0018\u0084(@\u00d3Mb\u0010X9\u0003@e;\u00dfO\u008d\u0017(\u00c0\u0086\u00ebQ\u00b8\u001e\u0005*@\u00aa\u00f1\u00d2Mb\u0010\u00f6?-\u00b2\u009d\u00ef\u00a7\u0086)\u00c0fffff&+@,\u0087\u0016\u00d9\u00ce\u00f7\r@\u00ee|?5^z*\u00c0\u00e4\u00a5\u009b\u00c4 \u00f0,@\f\u0002+\u0087\u0016\u00d9\n@X9\u00b4\u00c8v~'\u00c0\u00e1z\u0014\u00aeG\u00a1+@m\u00e7\u00fb\u00a9\u00f1R\u0010@\u00b9\u001e\u0085\u00ebQx)\u00c0\u0089A`\u00e5\u00d0b+@F\u00b6\u00f3\u00fd\u00d4x\u00e5?\\\u008f\u00c2\u00f5(\u00dc*\u00c0\\\u008f\u00c2\u00f5(\\*@`\u00e5\u00d0\"\u00db\u00f9\u0013@^\u00baI\f\u0002k,\u00c0T\u00e3\u00a5\u009b\u00c4`(@\u00c1\u00ca\u00a1E\u00b6\u00f3\u0013@\u00ee|?5^:*\u00c0Nb\u0010X9t+@\u001a\u0004V\u000e-2\u0018@[d;\u00dfO\u008d%\u00c0\u00aeG\u00e1z\u0014n)@\u00a8\u00c6K7\u0089A\u00f2?\u0010X9\u00b4\u00c8v$\u00c0\u00c4\u00f5(\\\u008f\u00c2(@:\u00b4\u00c8v\u00be\u009f\u00fe?\u00ce\u00cc\u00cc\u00cc\u00cc\f$\u00c0r=\n\u00d7\u00a3\u00f0)@\u00c2\u00ca\u00a1E\u00b6\u00f3\u00bd\u00bfr=\n\u00d7\u00a3\u00f0$\u00c0th\u0091\u00ed|\u00bf+@\u00f8S\u00e3\u00a5\u009b\u00c4\u00e0\u00bf\u00c9v\u00be\u009f\u001a\u00af$\u00c0H\u00e1z\u0014\u00ae\u00c7'@\u009a\u0099\u0099\u0099\u0099\u0099\u00f1\u00bf\u0091\u00ed|?5\u001e!\u00c0\u0014\u00aeG\u00e1z\u0094*@\u00fc\u00a9\u00f1\u00d2Mb\u00c0?\u00d2\"\u00db\u00f9~\u00ea\u001f\u00c0\u0099n\u0012\u0083\u00c0\n)@&\u0006\u0081\u0095C\u008b\u00e4?\u008bl\u00e7\u00fb\u00a91!\u00c0\u0094\u0018\u0004V\u000e-,@X9\u00b4\u00c8v\u00be\u00eb?\u00d8\u00a3p=\n\u00d7%\u00c0~?5^\u00baI(@H\u00e1z\u0014\u00aeG\u0001\u00c0\u000f-\u00b2\u009d\u00ef'\u001f\u00c0\u00a0\u001a/\u00dd$F+@\u00aeG\u00e1z\u0014\u00ae\u00f1\u00bf?5^\u00baI\f\u001e\u00c0+\u0087\u0016\u00d9\u00ce\u00b7-@%\u0006\u0081\u0095C\u008b\u00f8\u00bf\u00fb~j\u00bct\u0093\u001f\u00c0&\u0006\u0081\u0095C\u008b/@\u0085\u00ebQ\u00b8\u001e\u0085\u00f1\u00bf\u009a\u0099\u0099\u0099\u0099\u0099\u001c\u00c0\u000e-\u00b2\u009d\u00efg)@z\u00e9&1\b\u00ac\u0000\u00c0v\u0093\u0018\u0004V\u000e\u001a\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\f+@:\u00b4\u00c8v\u00be\u009f\b\u00c0\u00d3Mb\u0010X9\u001c\u00c0\"\u00b0rh\u0091\u00ad&@\u00ac\u001cZd;\u00df\u0001\u00c0I\u00e1z\u0014\u00aeG\u001e\u00c0\u00c5 \u00b0rh\u0091%@\u009a\u0099\u0099\u0099\u0099\u0099\u00f7\u00bf,\u0087\u0016\u00d9\u00cew\u001b\u00c0i\u0091\u00ed|?\u00b5-@\u008bl\u00e7\u00fb\u00a9\u00f1\u0005\u00c0\u00d0\u00f7S\u00e3\u00a5\u001b\u001b\u00c0\u0099n\u0012\u0083\u00c0J/@\u00e2z\u0014\u00aeG\u00e1\n\u00c0G\u00b6\u00f3\u00fd\u00d4x\u0017\u00c0\f\u0002+\u0087\u0016\u0019'@;\u00dfO\u008d\u0097n\u0011\u00c0\u00a8\u00c6K7\u0089A\u0015\u00c0\u00c7K7\u0089A`&@\u00f2\u00d2Mb\u0010\u00d8\u0014\u00c0\u00cd\u00cc\u00cc\u00cc\u00ccL\u0017\u00c0\u00c7K7\u0089A\u00e0)@th\u0091\u00ed|\u00bf\u0010\u00c0\u00d3Mb\u0010X\u00b9\u0015\u00c0\u00e6\u00d0\"\u00db\u00f9>+@h\u0091\u00ed|?\u00b5\u0013\u00c0c\u0010X9\u00b4\u00c8\u0019\u00c0\"\u00b0rh\u0091m%@7\u0089A`\u00e5\u00d0\n\u00c0`\u00e5\u00d0\"\u00dby\u0019\u00c0\u0085\u00ebQ\u00b8\u001eE#@\u001eZd;\u00dfO\u000b\u00c0\u0012\u0083\u00c0\u00ca\u00a1\u0085$\u00c0B`\u00e5\u00d0\"[%@\u001f\u0085\u00ebQ\u00b8\u001e\u00e5\u00bf\u008bl\u00e7\u00fb\u00a9\u00b1#\u00c0\u0091\u00ed|?5\u00de$@\u0019\u0004V\u000e-\u00b2\u00cd?\b\u00ac\u001cZd\u00fb$\u00c0\u0086\u00ebQ\u00b8\u001e\u0005#@\u0094\u0018\u0004V\u000e-\u00f8\u00bf\u00e9&1\b\u00ac\u009c#\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u00d3\"@w\u00be\u009f\u001a/\u00dd\u0002\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0'\u00c0\u0093\u0018\u0004V\u000e\u00ed\"@\u00e9&1\b\u00ac\u001c\u0001\u00c0U\u00e3\u00a5\u009b\u00c4`$\u00c09\u00b4\u00c8v\u00be\u009f @\u000e-\u00b2\u009d\u00ef\u00a7\u00e2\u00bf\u00f1\u00a7\u00c6K7\u0089%\u00c08\u0089A`\u00e5\u00d0\u001d@\u009b\u0099\u0099\u0099\u0099\u0099\u00ed\u00bf\u00edQ\u00b8\u001e\u0085+%\u00c0\u00d7\u00a3p=\n\u0017!@B`\u00e5\u00d0\"\u00db\u00d9?&\u0006\u0081\u0095C\u000b(\u00c0\u008e\u0097n\u0012\u0083\u0080\"@[d;\u00dfO\u008d\n\u00c0\u0085\u00ebQ\u00b8\u001eE!\u00c0\\\u008f\u00c2\u00f5(\u00dc\u001f@\u00f0\u00a7\u00c6K7\u0089\u00d9\u00bf\u00d1\"\u00db\u00f9~* \u00c0\u00b8\u001e\u0085\u00ebQ\u00b8!@*\\\u008f\u00c2\u00f5(\u00bc\u00bf\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd \u00c0~?5^\u00ba\u00c9\u001b@P\u008d\u0097n\u0012\u0083\u00e8?\u00d5x\u00e9&1\u0088!\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0017@\u0011X9\u00b4\u00c8v\u00de?\u00b7\u00f3\u00fd\u00d4xi\u001d\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u00cc\u001b@\u00a2E\u00b6\u00f3\u00fd\u00d4\u00f0?\b\u00ac\u001cZd\u00bb!\u00c0J\f\u0002+\u0087\u0016\u001d@\u00e0O\u008d\u0097n\u0012\u00fb? \u0085\u00ebQ\u00b8\u009e\u001f\u00c0=\n\u00d7\u00a3p=\u001d@\u001dZd;\u00dfO\u00f9\u00bfB`\u00e5\u00d0\"[\u001b\u00c0\u00a0\u001a/\u00dd$\u0006\u001e@B`\u00e5\u00d0\"\u00db\u00f7\u00bfz\u00e9&1\b\u00ac \u00c0\u0080j\u00bct\u0093\u0018\u001f@\u008e\u0097n\u0012\u0083\u00c0\u0003\u00c0m\u00e7\u00fb\u00a9\u00f1\u0012 \u00c0\u0082\u0095C\u008bl\u00e7\u0018@\u0015\u00aeG\u00e1z\u0014\u00fa\u00bf\u0084\u00c0\u00ca\u00a1E\u00b6)\u00c0sh\u0091\u00ed|\u007f#@J\f\u0002+\u0087\u0016\u00f5\u00bfx\u00be\u009f\u001a/])\u00c0\u00a4p=\n\u00d7\u00a3#@\u00cb\u00a1E\u00b6\u00f3\u00fd\u00d4\u00bf\u0010X9\u00b4\u00c8v,\u00c0\u00cd\u00cc\u00cc\u00cc\u00ccL#@\u0086\u00ebQ\u00b8\u001e\u0085\u00fb\u00bf8\u0089A`\u00e5\u0090,\u00c0\u00c3\u00f5(\\\u008fB!@\u0002+\u0087\u0016\u00d9\u00ce\u0000\u00c0\u00f7(\\\u008f\u00c2\u00f5,\u00c0\u00bct\u0093\u0018\u0004V%@H\u00e1z\u0014\u00aeG\u0007\u00c0#\u00db\u00f9~j<.\u00c0fffff\u00a6#@z\u00e9&1\b\u00ac\u00e0\u00bf%\u0006\u0081\u0095C\u008b-\u00c0\u00a2E\u00b6\u00f3\u00fd\u0014%@%\u0006\u0081\u0095C\u008b\u00cc?\u00fd\u00a9\u00f1\u00d2M\".\u00c09\u00b4\u00c8v\u00be\u009f$@\u00d9\u00ce\u00f7S\u00e3\u00a5\u000f\u00c0\u00e3\u00a5\u009b\u00c4 \u00900\u00c09\u00b4\u00c8v\u00be_$@\u0018\u00d9\u00ce\u00f7S\u00e3\u00e9\u00bf\u0098n\u0012\u0083\u00c0\u00aa0\u00c0\u00e3\u00a5\u009b\u00c4 0&@Nb\u0010X9\u00b4\u00f6\u00bffffff\u00061\u00c0\u008f\u00c2\u00f5(\\\u00cf\"@\u00fc\u00a9\u00f1\u00d2Mb\u00f6\u00bf\u00a4p=\n\u00d7\u00031\u00c0H\u00e1z\u0014\u00ae\u00c7$@\u001f\u0085\u00ebQ\u00b8\u001e\u00c5?\u00ad\u001cZd;\u009f.\u00c0j\u00bct\u0093\u0018\u0004!@\u00d6x\u00e9&1\b\u00cc?\u009c\u00c4 \u00b0r\u00a8,\u00c0\u00b6\u00f3\u00fd\u00d4x) @/\u00dd$\u0006\u0081\u0095\u00db?`\u00e5\u00d0\"\u00db\u00b9/\u00c0j\u00bct\u0093\u0018D!@\u0091\u00ed|?5^\u00f2?n\u00e7\u00fb\u00a9\u00f1\u00d2/\u00c0q=\n\u00d7\u00a3p\u001f@-\u00b2\u009d\u00ef\u00a7\u00c6\u00db\u00bf-\u00b2\u009d\u00ef\u00a7\u0006,\u00c0\u00d7\u00a3p=\n\u00d7'@\u0002+\u0087\u0016\u00d9\u00ce\u0005\u00c0y\u00e9&1\b\u00ec*\u00c02\b\u00ac\u001cZ$(@h\u0091\u00ed|?5\u00fe\u00bf\b\u00ac\u001cZd;,\u00c0\u00fa~j\u00bct\u0013*@\u00e8\u00fb\u00a9\u00f1\u00d2M\r\u00c0\u0090\u00c2\u00f5(\\O.\u00c0\u0013\u0083\u00c0\u00ca\u00a1\u0085*@\u001dZd;\u00dfO\u000f\u00c0\u0094\u0018\u0004V\u000e\u00ed*\u00c0\u00a4p=\n\u00d7c)@th\u0091\u00ed|?\u0014\u00c0\u00b7\u00f3\u00fd\u00d4x\u00e9*\u00c0c\u0010X9\u00b4\u0088,@\u0099n\u0012\u0083\u00c0\u00ca\u0007\u00c0\u00a5p=\n\u00d7\u00e3(\u00c0\u0014\u00aeG\u00e1z\u0014,@\u00e0O\u008d\u0097n\u0012\u0005\u00c0_\u00baI\f\u0002\u00eb*\u00c0\u0013\u0083\u00c0\u00ca\u00a1E.@\u0080j\u00bct\u0093\u0018\r\u00c0\u00ef|?5^\u00fa+\u00c0\u00ac\u001cZd;\u001f*@n\u00e7\u00fb\u00a9\u00f1R\u0018\u00c0\u00be\u009f\u001a/\u00dd\u00a4,\u00c0\u008aA`\u00e5\u00d0b-@\u00dc\u00f9~j\u00bct\u00fd\u00bf\u009c\u00c4 \u00b0rh,\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6+@\u0083\u00c0\u00ca\u00a1E\u00b6\u00f1\u00bf0\u00dd$\u0006\u0081\u00d5+\u00c0\u001eZd;\u00df\u000f/@&\u0006\u0081\u0095C\u008b\u00f4\u00bfe;\u00dfO\u008d\u0097/\u00c0H\u00e1z\u0014\u00ae\u0007.@\u00da\u00ce\u00f7S\u00e3\u00a5\u0001\u00c0\u00c8K7\u0089A\u00a0/\u00c0\u00ce\u00cc\u00cc\u00cc\u00cc\u008c/@\f\u0002+\u0087\u0016\u00d9\u0007\u00c0p\u0012\u0083\u00c0\u00caa0\u00c0m\u00e7\u00fb\u00a9\u00f1R,@\u00f4\u00fd\u00d4x\u00e9&\u0004\u00c0L7\u0089A`\u00850\u00c0<\u00dfO\u008d\u0097\u00ae.@7\u0089A`\u00e5\u00d0\u00ee\u00bf\u0088\u0016\u00d9\u00ce\u00f7\u00d3/\u00c0\u0014\u00aeG\u00e1z\u00140@\u00cc\u00a1E\u00b6\u00f3\u00fd\u00dc\u00bfR\u00b8\u001e\u0085\u00eb\u00b10\u00c0\u009d\u00c4 \u00b0r\u00e8,@\u00c1\u00ca\u00a1E\u00b6\u00f3\u00d5\u00bfZd;\u00dfO\u00cd1\u00c0\u00baI\f\u0002+\u00c7/@-\u00b2\u009d\u00ef\u00a7\u00c6\u00f5\u00bf\u0014\u00aeG\u00e1z42\u00c0;\u00dfO\u008d\u0097.0@^\u00baI\f\u0002+\u00df\u00bf\u009a\u0099\u0099\u0099\u0099y2\u00c0\u0001\u0000\u0000\u0000\u0000\u0080.@\u00e8\u00fb\u00a9\u00f1\u00d2M\u00fc\u00bfd;\u00dfO\u008d\u00b71\u00c0\u0006\u0081\u0095C\u008b\u00ac0@\u0096C\u008bl\u00e7\u00fb\u00ff\u00bf\u008e\u0097n\u0012\u0083\u00c0(\u00c0\u00a4p=\n\u00d7\u00e3'@^\u00baI\f\u0002+\u0014\u00c0E\u008bl\u00e7\u00fb\u00e9'\u00c0\u00dc\u00f9~j\u00bct'@\u00aa\u00f1\u00d2Mb\u0090\u0010\u00c0H\u00e1z\u0014\u00aeG'\u00c0h\u0091\u00ed|?5'@\u00fa~j\u00bct\u0013\u0019\u00c0\u001b/\u00dd$\u0006\u0081'\u00c0.\u00b2\u009d\u00ef\u00a7\u00c6(@\u00baI\f\u0002+\u0007\u001c\u00c0\u00ab\u00f1\u00d2Mb\u0090(\u00c0fffff\u00a6$@~?5^\u00ba\u00c9\u001b\u00c0b\u0010X9\u00b4H$\u00c0\u0091\u00ed|?5\u00de&@L7\u0089A`\u00e5\u0017\u00c0\u0014\u00aeG\u00e1z\u00d4#\u00c0/\u00dd$\u0006\u0081U%@\u00a6\u009b\u00c4 \u00b0\u00f2\u0014\u00c0\u008d\u0097n\u0012\u0083\u0080#\u00c0m\u00e7\u00fb\u00a9\u00f1\u0012&@)\\\u008f\u00c2\u00f5\u00a8\u001b\u00c0\u00cd\u00cc\u00cc\u00cc\u00ccL'\u00c0\u00baI\f\u0002+\u0087#@\u00f7(\\\u008f\u00c2u\u001f\u00c0\u00fc\u00a9\u00f1\u00d2Mb\"\u00c0L7\u0089A`%)@!\u00b0rh\u0091\u00ed\u0015\u00c0\u00d7\u00a3p=\nW!\u00c0M7\u0089A`e(@\u009c\u00c4 \u00b0rh\u0012\u00c0\u00bct\u0093\u0018\u0004\u00d6 \u00c0\u00a4p=\n\u00d7c)@\u00a6\u009b\u00c4 \u00b0\u00f2\u0018\u00c0\u0087\u0016\u00d9\u00ce\u00f7\u0093#\u00c0gffff\u00a6+@\u00e1z\u0014\u00aeG\u00e1\u0013\u00c07\u0089A`\u00e5P#\u00c00\u00dd$\u0006\u0081U,@\u00ac\u001cZd;\u00df\r\u00c0\u008f\u00c2\u00f5(\\O\"\u00c0\u00a2E\u00b6\u00f3\u00fd\u0014+@?5^\u00baI\f\t\u00c0u\u0093\u0018\u0004V\u008e$\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2\u00cd-@\u0012\u0083\u00c0\u00ca\u00a1E\u000b\u00c05^\u00baI\fB%\u00c0\u00c5 \u00b0rh\u00d1,@\u00b0rh\u0091\u00ed|\u0016\u00c0\u00d0\u00f7S\u00e3\u00a5\u00db*\u00c0J\f\u0002+\u0087\u0096#@fffff\u00e6\u0019\u00c0\u00fe\u00d4x\u00e9&\u00f1+\u00c0 \u0085\u00ebQ\u00b8\u009e$@D\u008bl\u00e7\u00fb)\u0017\u00c07\u0089A`\u00e5\u0010,\u00c0\u0006\u0081\u0095C\u008b\u00ec @;\u00dfO\u008d\u0097n\u001b\u00c0\u009f\u00ef\u00a7\u00c6K\u00b7-\u00c0sh\u0091\u00ed|\u007f @\u009f\u00ef\u00a7\u00c6K\u00b7\u0018\u00c0\u0013\u0083\u00c0\u00ca\u00a1E*\u00c0\u0097C\u008bl\u00e7\u00fb\u001c@e;\u00dfO\u008d\u0097\u001a\u00c0\u00b4\u00c8v\u00be\u009f\u001a-\u00c0\u0083\u00c0\u00ca\u00a1E6!@9\u00b4\u00c8v\u00be\u009f \u00c0.\u00b2\u009d\u00ef\u00a7\u0086-\u00c0\u0000\u0000\u0000\u0000\u0000@#@5^\u00baI\fB!\u00c0E\u008bl\u00e7\u00fb\u00a9+\u00c0\u00b2\u009d\u00ef\u00a7\u00c6\u008b @w\u00be\u009f\u001a/\u001d\"\u00c0\u0086\u00ebQ\u00b8\u001e\u0085*\u00c0X9\u00b4\u00c8v>\u0019@\u00b8\u001e\u0085\u00ebQ\u00b8\u001d\u00c0[d;\u00dfO\u008d/\u00c0\u0010X9\u00b4\u00c8\u00f6\u001e@;\u00dfO\u008d\u0097.!\u00c0-\u00b2\u009d\u00ef\u00a7\u00860\u00c0\u00c5 \u00b0rh\u0011\u001f@433333\u001f\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u00cc.\u00c0x\u00be\u009f\u001a/\u00dd\u001a@\u00e9&1\b\u00ac\u001c!\u00c0\u0096C\u008bl\u00e7{0\u00c0)\\\u008f\u00c2\u00f5(\u001f@\u00d0\u00f7S\u00e3\u00a5\u00db#\u00c0|\u0014\u00aeG\u00e1z1\u00c0\u0006\u0081\u0095C\u008bl\u001d@\u00d1\"\u00db\u00f9~\u00aa#\u00c0\u0012\u0083\u00c0\u00ca\u00a1\u00a50\u00c0)\\\u008f\u00c2\u00f5\u00a8!@\\\u008f\u00c2\u00f5(\\$\u00c0\u00d5x\u00e9&1\u0088/\u00c0\u00b7\u00f3\u00fd\u00d4xi\u001c@sh\u0091\u00ed|\u00ff%\u00c0\u00b6\u00f3\u00fd\u00d4x\t0\u00c0d;\u00dfO\u008d\u0097\u0018@)\\\u008f\u00c2\u00f5h&\u00c0\u00c6 \u00b0rh\u0011-\u00c0\u00db\u00f9~j\u00bc\u00b4!@/\u00dd$\u0006\u0081\u0095'\u00c0\u00bbI\f\u0002+\u0007.\u00c0\u00a4p=\n\u00d7##@%\u0006\u0081\u0095C\u008b&\u00c0\u00e2z\u0014\u00aeG\u00e1+\u00c01\b\u00ac\u001cZ$\"@\u00ecQ\u00b8\u001e\u0085+)\u00c0\u008d\u0097n\u0012\u0083\u0000-\u00c0\u00f9S\u00e3\u00a5\u009bD\u001c@p\u0012\u0083\u00c0\u00ca\u00e1)\u00c0\u0084\u00c0\u00ca\u00a1E6,\u00c0D\u008bl\u00e7\u00fb\u00a9\u001e@R\u00b8\u001e\u0085\u00ebQ+\u00c0\u00b1rh\u0091\u00ed|-\u00c0Zd;\u00dfO\u008d\u0018@X9\u00b4\u00c8v~*\u00c0E\u008bl\u00e7\u00fb\u00e9-\u00c0\u00f0\u00a7\u00c6K7\u0089\u001e@\u00d4Mb\u0010X\u00b9'\u00c0x\u00be\u009f\u001a/\u009d(\u00c0\u0010X9\u00b4\u00c8\u00f6\u001c@\u0096C\u008bl\u00e7{\u0016\u00c05^\u00baI\f\u00c2(\u00c0R\u00b8\u001e\u0085\u00eb\u0011 @5^\u00baI\f\u0002\u0014\u00c0=\n\u00d7\u00a3p='\u00c0|\u0014\u00aeG\u00e1z\u0018@L7\u0089A`e\u0014\u00c0H\u00e1z\u0014\u00ae\u00c7(\u00c0\u00a0\u001a/\u00dd$\u0086\u0015@\u00c7K7\u0089A`\u0013\u00c0L7\u0089A`\u00e5%\u00c0r=\n\u00d7\u00a3p\u0019@\u009a\u0099\u0099\u0099\u0099\u0019\u0011\u00c0\u00fd\u00a9\u00f1\u00d2Mb%\u00c0u\u0093\u0018\u0004V\u008e\u0015@\u00cav\u00be\u009f\u001a\u00af\u0018\u00c0\u00c2\u00ca\u00a1E\u00b63$\u00c0\\\u008f\u00c2\u00f5(\u00dc\u0017@\u0098n\u0012\u0083\u00c0J\u001c\u00c0p\u0012\u0083\u00c0\u00caa%\u00c0D\u008bl\u00e7\u00fb)\u0010@\u0018\u00d9\u00ce\u00f7Sc\u0018\u00c0\u00a4p=\n\u00d7\u00e3&\u00c0?5^\u00baI\f\r@\u00b2\u009d\u00ef\u00a7\u00c6K\u0016\u00c0\u0082\u0095C\u008bl\u00e7#\u00c0\u00c8K7\u0089A`\t@\u00b8\u001e\u0085\u00ebQ8\u001c\u00c0\u00e4\u00a5\u009b\u00c4 \u00f0!\u00c0\u009e\u00ef\u00a7\u00c6K7\r@\u00e3\u00a5\u009b\u00c4 0\u001c\u00c0\u00a0\u001a/\u00dd$\u0006%\u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\t@y\u00e9&1\b\u00ec \u00c0\u00fc\u00a9\u00f1\u00d2M\u00a2#\u00c0\u00d3Mb\u0010X9\u00fc?\u0002+\u0087\u0016\u00d9\u00ce\u0019\u00c0\u00aa\u00f1\u00d2MbP\"\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u00f4?}?5^\u00ba\u00c9\u001c\u00c0\u00ac\u001cZd;\u009f%\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u00f5?(1\b\u00ac\u001c\u00da\u0019\u00c0X9\u00b4\u00c8v~#\u00c0j\u00bct\u0093\u0018\u0004\n@(1\b\u00ac\u001c\u00da\"\u00c0\u0093\u0018\u0004V\u000e-\"\u00c0v\u0093\u0018\u0004V\u000e\u00f9?!\u00b0rh\u0091m\u0014\u00c0^\u00baI\f\u0002+#\u00c0:\u00b4\u00c8v\u00be\u009f\u00f2?\u00a9\u00c6K7\u0089A\u000f\u00c0\u00bbI\f\u0002+G%\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5\u00ef?\u00bct\u0093\u0018\u0004V\u000e\u00c0\u00a1\u001a/\u00dd$\u0086\u001e\u00c0\b\u00ac\u001cZd;\u00fd?333333\u0013\u00c0|\u0014\u00aeG\u00e1z\u001d\u00c0|\u0014\u00aeG\u00e1z\u00f8?\u00b2\u009d\u00ef\u00a7\u00c6K\u000b\u00c0z\u00e9&1\b,\u001a\u00c0Zd;\u00dfO\u008d\u0002@y\u00e9&1\b,\u0016\u00c0\u00d8\u00a3p=\n\u00d7\u001a\u00c0\u0087\u0016\u00d9\u00ce\u00f7S\u0005@\u0083\u00c0\u00ca\u00a1E6\u001a\u00c0L7\u0089A`%!\u00c0\u007fj\u00bct\u0093\u0018\u00f2?ffffff\u0007\u00c0#\u00db\u00f9~j|!\u00c0 \u0085\u00ebQ\u00b8\u001e\u00ed?\u00cav\u00be\u009f\u001a/\u00ff\u00bf|\u0014\u00aeG\u00e1\u00fa\u0013\u00c01\b\u00ac\u001cZd\u0000@V\u000e-\u00b2\u009d\u00ef\f\u00c0\u009e\u00ef\u00a7\u00c6K7\u0010\u00c0333333\u0002@h\u0091\u00ed|?5\t\u00c0I\u00e1z\u0014\u00aeG\u0018\u00c0I\u00e1z\u0014\u00aeG\u00f9?\u00be\u009f\u001a/\u00dd$\u0007\u00c0\u009c\u00c4 \u00b0r\u00e8\u0017\u00c0\u001f\u0085\u00ebQ\u00b8\u001e\u00f3?)\\\u008f\u00c2\u00f5(\u00fe\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u0015\u00c0u\u0093\u0018\u0004V\u000e\u0003@\u00d5x\u00e9&1\b\u0014\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\u0011\u00c0\u00ecQ\u00b8\u001e\u0085\u00eb\u0006@\u0092\u00ed|?5^\u0016\u00c0\u007fj\u00bct\u0093\u0098'\u00c0\u007fj\u00bct\u0093\u0018\u000b@\u00f4\u00fd\u00d4x\u00e9f!\u00c0,\u0087\u0016\u00d9\u00ce\u00f7(\u00c0w\u00be\u009f\u001a/\u00dd\f@G\u00b6\u00f3\u00fd\u00d4\u00f8\u001f\u00c0\u00a6\u009b\u00c4 \u00b0\u00f2(\u00c0\u00d3Mb\u0010X9\f@\u0099n\u0012\u0083\u00c0\n$\u00c0:\u00b4\u00c8v\u00be\u009f(\u00c0\u00a6\u009b\u00c4 \u00b0r\u0005@\u00ac\u001cZd;_%\u00c0\u00b0rh\u0091\u00ed\u00fc'\u00c0\u0093\u0018\u0004V\u000e-\u0013@E\u008bl\u00e7\u00fbi%\u00c0&\u0006\u0081\u0095C\u000b,\u00c0S\u00b8\u001e\u0085\u00ebQ\r@\u00e3\u00a5\u009b\u00c4 p#\u00c0Nb\u0010X9t,\u00c0\u000e-\u00b2\u009d\u00ef\u00a7\u0011@\u00d1\"\u00db\u00f9~\u00ea!\u00c0\u00f4\u00fd\u00d4x\u00e9\u00a6,\u00c0/\u00dd$\u0006\u0081\u0095\u0005@\u00c7K7\u0089A\u00a0\"\u00c0\u00e6\u00d0\"\u00db\u00f9~'\u00c0\u00a4p=\n\u00d7#\u0013@Zd;\u00dfO\u00cd'\u00c0r=\n\u00d7\u00a3\u00b0-\u00c0\u00dc\u00f9~j\u00bct\u000e@$\u00db\u00f9~j\u00fc%\u00c0\u0019\u0004V\u000e-\u00b2,\u00c0v\u0093\u0018\u0004V\u000e\u000b@\u0080j\u00bct\u0093\u0018(\u00c0\u009b\u0099\u0099\u0099\u0099\u00d9/\u00c0y\u00e9&1\b\u00ac\u0011@\u00d5x\u00e9&1\u00c8%\u00c0/\u00dd$\u0006\u0081\u0095'\u00c0\u00e0O\u008d\u0097n\u0092\u0017@\u0091\u00ed|?5\u00de#\u00c0~?5^\u00ba\t(\u00c0\\\u008f\u00c2\u00f5(\\\u0017@\u009c\u00c4 \u00b0r\u00e8!\u00c0\u00e0O\u008d\u0097nR&\u00c0\u00da\u00ce\u00f7S\u00e3\u00a5\u001c@J\f\u0002+\u0087\u00d6$\u00c0sh\u0091\u00ed|?'\u00c0\u009f\u00ef\u00a7\u00c6K\u00b7\u001d@th\u0091\u00ed|\u00bf&\u00c0<\u00dfO\u008d\u0097\u00ee&\u00c0\u00e6\u00d0\"\u00db\u00f9\u00fe\u001f@7\u0089A`\u00e5\u0090#\u00c0=\n\u00d7\u00a3p=#\u00c0th\u0091\u00ed|\u00bf\u001c@+\u0087\u0016\u00d9\u00ce\u00b7$\u00c0\u0093\u0018\u0004V\u000e-\"\u00c0\u008e\u0097n\u0012\u0083\u00c0\u001f@\u00e3\u00a5\u009b\u00c4 p&\u00c0\u00ea&1\b\u00ac\u00dc!\u00c0\u00f8S\u00e3\u00a5\u009bD\u0019@\u001f\u0085\u00ebQ\u00b8\u001e#\u00c0#\u00db\u00f9~j\u00bc\"\u00c0\u0010X9\u00b4\u00c8v\u0016@\u009e\u00ef\u00a7\u00c6K\u00f7!\u00c0\u00d1\"\u00db\u00f9~\u00ea\u001d\u00c0\u00e3\u00a5\u009b\u00c4 \u00b0\u0018@\u00fe\u00d4x\u00e9&q#\u00c0=\n\u00d7\u00a3p=\u001c\u00c0\u00d4Mb\u0010X\u00b9\u001c@\u00f4\u00fd\u00d4x\u00e9f#\u00c0\u001dZd;\u00df\u00cf\u001c\u00c0.\u00b2\u009d\u00ef\u00a7F\u0016@\u00aeG\u00e1z\u0014.&\u00c0\b\u00ac\u001cZd\u00bb\u001b\u00c0&\u0006\u0081\u0095C\u008b\u0015@!\u00b0rh\u0091\u00ed \u00c06^\u00baI\f\u0002\u001c\u00c0\u00ef|?5^:\u0018@\u00c2\u00ca\u00a1E\u00b6s\u001e\u00c0\u00bct\u0093\u0018\u0004\u00d6\u001d\u00c0\u00a8\u00c6K7\u0089\u00c1\u0011@\u0083\u00c0\u00ca\u00a1E\u00b6 \u00c0\u00f9S\u00e3\u00a5\u009b\u00c4\u0018\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\u0017@\u001b/\u00dd$\u0006\u0081'\u00c0\u0098n\u0012\u0083\u00c0\u00ca\u0015\u00c0\u00dd$\u0006\u0081\u0095\u00c3\u0013@\u00d7\u00a3p=\n\u0017!\u00c0T\u00e3\u00a5\u009b\u00c4 \u0012\u00c0_\u00baI\f\u0002+\u0018@T\u00e3\u00a5\u009b\u00c4 !\u00c0?5^\u00baI\u008c\u0013\u00c0\u00b8\u001e\u0085\u00ebQ8\u001c@\u00be\u009f\u001a/\u00dd\u00e4 \u00c0\u00d4Mb\u0010X9\u0014\u00c0X9\u00b4\u00c8v\u00be\f@|\u0014\u00aeG\u00e1z!\u00c0\u00dfO\u008d\u0097n\u0012\u0017\u00c0\u00dd$\u0006\u0081\u0095C\u0006@d;\u00dfO\u008d\u0097!\u00c0333333\t\u00c0\u00bdt\u0093\u0018\u0004V\u0017@Zd;\u00dfO\u008d!\u00c0H\u00e1z\u0014\u00aeG\u0003\u00c0,\u0087\u0016\u00d9\u00cew\u001a@u\u0093\u0018\u0004V\u00ce!\u00c0\u008f\u00c2\u00f5(\\\u008f\r\u00c0\u00b0rh\u0091\u00ed|\u000b@\u0098n\u0012\u0083\u00c0\n\"\u00c0\u0004V\u000e-\u00b2\u009d\n\u00c0ffffff\u0003@\u0098n\u0012\u0083\u00c0J\"\u00c0\u00db\u00f9~j\u00bct\u0006\u00c0\u00d5x\u00e9&1\b\u0012@\u00c5 \u00b0rh\u0011\"\u00c0\u00be\u009f\u001a/\u00dd$\u00fc\u00bf$\u00db\u00f9~j<\u0011@B`\u00e5\u00d0\"[\"\u00c0H\u00e1z\u0014\u00ae\u0007 \u00c0\u0087\u0016\u00d9\u00ce\u00f7S\u0012@\u007fj\u00bct\u0093\u0018'\u00c0\u00ecQ\u00b8\u001e\u0085\u00ab!\u00c0\u00a2E\u00b6\u00f3\u00fdT\u0011@Zd;\u00dfO\r&\u00c0\u0080j\u00bct\u0093\u0098\u001f\u00c0\u00be\u009f\u001a/\u00dd$\u0010@G\u00b6\u00f3\u00fd\u00d4\u00b8)\u00c0\u001eZd;\u00dfO\u001b\u00c0\u00c6 \u00b0rh\u0091\u000f@B`\u00e5\u00d0\"\u001b*\u00c0\u00d3Mb\u0010X\u00f9 \u00c00\u00dd$\u0006\u0081\u0095\u0013@\u00aa\u00f1\u00d2Mb\u0010,\u00c0\u00ecQ\u00b8\u001e\u0085\u00ab \u00c0{\u0014\u00aeG\u00e1z\u0004@~?5^\u00ba\u00c9)\u00c0\u00f0\u00a7\u00c6K7\t \u00c08\u0089A`\u00e5\u00d0\u0001@P\u008d\u0097n\u0012\u00c3+\u00c0\b\u00ac\u001cZd{ \u00c0\u00c9v\u00be\u009f\u001a/\u0012@\u009a\u0099\u0099\u0099\u0099Y.\u00c0\u0092\u00ed|?5\u00de\u001e\u00c0\u0084\u00c0\u00ca\u00a1E\u00b6\u00fb?v\u0093\u0018\u0004V\u008e'\u00c00\u00dd$\u0006\u0081\u0095\u001a\u00c0\u009e\u00ef\u00a7\u00c6K7\u00f9?\u001f\u0085\u00ebQ\u00b8\u00de'\u00c0\u00c9v\u00be\u009f\u001a\u00af\u001f\u00c0w\u00be\u009f\u001a/\u00dd\u0001@L7\u0089A`\u00a5%\u00c0\u00fc\u00a9\u00f1\u00d2Mb \u00c0*\\\u008f\u00c2\u00f5(\u00e8?`\u00e5\u00d0\"\u00dby'\u00c0\u00d9\u00ce\u00f7S\u00e3\u00a5#\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\u0003@0\u00dd$\u0006\u0081\u00d5)\u00c0\u00fe\u00d4x\u00e9&q$\u00c0\u009c\u00c4 \u00b0rh\u0007@\u00de$\u0006\u0081\u0095\u0003(\u00c0\u00e7\u00fb\u00a9\u00f1\u00d2M$\u00c0\u00b6\u00f3\u00fd\u00d4x\u00e9\u00f6?>\n\u00d7\u00a3p\u00fd)\u00c0R\u00b8\u001e\u0085\u00ebQ$\u00c0\b\u00ac\u001cZd;\b@/\u00dd$\u0006\u0081\u0095+\u00c0^\u00baI\f\u0002k\"\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u0017@\u0018\u00d9\u00ce\u00f7Sc+\u00c0V\u000e-\u00b2\u009do\"\u00c0\u00db\u00f9~j\u00bc\u00f4\u0018@!\u00b0rh\u0091m)\u00c0\u0086\u00ebQ\u00b8\u001e\u0005#\u00c0\u0082\u0095C\u008blg\u001c@\u0001\u0000\u0000\u0000\u0000@-\u00c0~?5^\u00ba\u0089#\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u001a@\u00a9\u00c6K7\u0089A/\u00c0\u00c5 \u00b0rh\u00d1 \u00c0433333 @S\u00b8\u001e\u0085\u00eb\u0091-\u00c0\u009a\u0099\u0099\u0099\u0099\u0099%\u00c0\u0019\u0004V\u000e-2\u001f@\u00da\u00ce\u00f7S\u00e3e,\u00c0\u0010X9\u00b4\u00c86%\u00c0\u008d\u0097n\u0012\u0083\u0000!@~?5^\u00ba\u00c9*\u00c0\u00b4\u00c8v\u00be\u009f\u001a'\u00c07\u0089A`\u00e5P\u001c@\u00e5\u00d0\"\u00db\u00f9\u00be+\u00c0\u0096C\u008bl\u00e7; \u00c0\u00c7K7\u0089A\u00e0 @\u00fc\u00a9\u00f1\u00d2M\u00e2/\u00c0\u00b5\u00c8v\u00be\u009f\u009a&\u00c0\u00a4p=\n\u00d7\u00e3 @\u00f4\u00fd\u00d4x\u00e9\u00e6.\u00c0\u0000\u0000\u0000\u0000\u0000@%\u00c0b\u0010X9\u00b4\u0088\"@<\u00dfO\u008d\u0097n/\u00c0$\u00db\u00f9~j<'\u00c0\u00e0O\u008d\u0097n\u0012\u001f@\u00e9&1\b\u00ac<0\u00c06^\u00baI\fB)\u00c01\b\u00ac\u001cZd\"@\u00b0rh\u0091\u00ed<.\u00c0v\u0093\u0018\u0004V\u000e*\u00c0\u00ecQ\u00b8\u001e\u0085\u00ab\"@x\u00be\u009f\u001a/\u00dd+\u00c0~?5^\u00ba\u00c9*\u00c0\u00f0\u00a7\u00c6K7I#@\u0012\u0083\u00c0\u00ca\u00a1\u00050\u00c0`\u00e5\u00d0\"\u00db\u00f9\u001e\u00c0\u00fa~j\u00bct\u00d3 @\u00f3\u00d2Mb\u0010X+\u00c0h\u0091\u00ed|?5 \u00c0\u00ecQ\u00b8\u001e\u0085\u00eb\u001f@*\\\u008f\u00c2\u00f5\u00a8)\u00c05^\u00baI\f\u0002\u001a\u00c09\u00b4\u00c8v\u00be_\"@^\u00baI\f\u0002++\u00c0\u00c6 \u00b0rh\u0091\u001a\u00c0\u0091\u00ed|?5^$@6^\u00baI\f\u0002,\u00c0\u00f0\u00a7\u00c6K7\t\u0015\u00c0\u000e-\u00b2\u009d\u00ef'!@E\u008bl\u00e7\u00fb\u00a9,\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0018\u00c0/\u00dd$\u0006\u0081\u00d5\"@z\u00e9&1\b,(\u00c0th\u0091\u00ed|?\u001a\u00c0\u008f\u00c2\u00f5(\\\u000f!@\u00e2z\u0014\u00aeG!'\u00c0;\u00dfO\u008d\u0097n\u001b\u00c0w\u00be\u009f\u001a/]$@\u00c6 \u00b0rhQ'\u00c0\u00f8S\u00e3\u00a5\u009bD\u0012\u00c0+\u0087\u0016\u00d9\u00ce\u00b7\"@\u00a6\u009b\u00c4 \u00b0\u00f2-\u00c0?5^\u00baI\f\u0013\u00c0\u00cd\u00cc\u00cc\u00cc\u00cc\u008c#@+\u0087\u0016\u00d9\u00cew'\u00c0\u00f2\u00d2Mb\u0010X\u0011\u00c0\u0094\u0018\u0004V\u000e-&@|\u0014\u00aeG\u00e1\u00ba'\u00c0\u00d7\u00a3p=\n\u00d7\u0013\u00c0\u00a8\u00c6K7\u0089\u00c1'@+\u0087\u0016\u00d9\u00cew(\u00c0@5^\u00baI\f\u000f\u00c0\u0082\u0095C\u008blg!@b\u0010X9\u00b4\u00c8&\u00c09\u00b4\u00c8v\u00be\u009f\u0010\u00c0\u001a\u0004V\u000e-\u00b2\u001e@\u0092\u00ed|?5^&\u00c0\u00ea&1\b\u00ac\u001c\b\u00c0\u00c3\u00f5(\\\u008f\u00c2&@\u00bct\u0093\u0018\u0004\u0016'\u00c0D\u008bl\u00e7\u00fb\u00a9\u0004\u00c0sh\u0091\u00ed|\u00bf(@\u00de$\u0006\u0081\u0095\u0003'\u00c0F\u00b6\u00f3\u00fd\u00d4x\u0004\u00c0J\f\u0002+\u0087\u0016\"@\u00b7\u00f3\u00fd\u00d4x)&\u00c0\u00d1\"\u00db\u00f9~j\u00fc\u00bf\u009c\u00c4 \u00b0r\u00a8 @b\u0010X9\u00b4\u00c8%\u00c0\u00b8\u001e\u0085\u00ebQ\u00b8\u0000\u00c0\u00f6(\\\u008f\u00c2\u00b5$@\u00f0\u00a7\u00c6K7I&\u00c0\u00b2\u009d\u00ef\u00a7\u00c6K\u00f1\u00bfB`\u00e5\u00d0\"[%@x\u00be\u009f\u001a/\u00dd%\u00c0\u00ecQ\u00b8\u001e\u0085\u00eb\u0014\u00c0u\u0093\u0018\u0004V\u000e\u001d@\u00b0rh\u0091\u00ed\u00bc,\u00c0\u00dfO\u008d\u0097n\u0012\u0017\u00c0\f\u0002+\u0087\u0016\u00d9\u001a@\u0082\u0095C\u008blg+\u00c0\u00a6\u009b\u00c4 \u00b0r\u0010\u00c0\u00d2\"\u00db\u00f9~j\u001a@&\u0006\u0081\u0095CK.\u00c0|\u0014\u00aeG\u00e1z\r\u00c0\u0084\u00c0\u00ca\u00a1E6\u001d@,\u0087\u0016\u00d9\u00ce\u00b7/\u00c0\u00d7\u00a3p=\nW\u0012\u00c0\"\u00b0rh\u0091m\u0015@\u00aeG\u00e1z\u0014\u00ee/\u00c0\u0003+\u0087\u0016\u00d9\u00ce\u0007\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d2\u0018@\u00e9&1\b\u00ac\\,\u00c0\u0012\u0083\u00c0\u00ca\u00a1E\u0006\u00c0\u00d3Mb\u0010X9\u001c@\u00cd\u00cc\u00cc\u00cc\u00cc\f+\u00c07\u0089A`\u00e5\u00d0\t\u00c0h\u0091\u00ed|?\u00b5\u0015@\u0006\u0081\u0095C\u008b\u00ec*\u00c0\u00ce\u00cc\u00cc\u00cc\u00ccL\u0015\u00c0\u00c2\u00ca\u00a1E\u00b6\u00f3\u0011@\u0019\u0004V\u000e-\u00f2.\u00c0v\u0093\u0018\u0004V\u000e\u00fb\u00bf\u008bl\u00e7\u00fb\u00a9\u00f1\u0016@M7\u0089A`\u00a5-\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u00f8\u00bf\u007fj\u00bct\u0093\u0098\u0011@6^\u00baI\f\u0082.\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0002\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\r@ \u0085\u00ebQ\u00b8^.\u00c0y\u00e9&1\b\u00ac\u00e4\u00bf\u00fe\u00d4x\u00e9&\u00b1\u001a@H\u00e1z\u0014\u00ae\u00c7-\u00c09\u00b4\u00c8v\u00be\u009f\u00e6\u00bf\u00d0\u00f7S\u00e3\u00a5\u009b\u001e@U\u00e3\u00a5\u009b\u00c4\u00e0,\u00c0\u009c\u00c4 \u00b0rh\u00d1\u00bf\u0000\u0000\u0000\u0000\u0000\u0000\u0010@#\u00db\u00f9~j|/\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2M\u00c2\u00bf/\u00dd$\u0006\u0081\u0095\u0007@\u00d8\u00a3p=\n\u00d7/\u00c0X9\u00b4\u00c8v\u00be\u00e3?\u0096C\u008bl\u00e7\u00fb\u0018@\u00ef|?5^\u00ba.\u00c0\u00d1\"\u00db\u00f9~j\u00f6?\u00b6\u00f3\u00fd\u00d4x\u00e9\u001b@\u00c7K7\u0089A\u00e0.\u00c0@5^\u00baI\f\u00ea?\u00a8\u00c6K7\u0089\u00c1\u0013@fffff\u00a6/\u00c0\u00e1z\u0014\u00aeG\u00e1\u00fc?/\u00dd$\u0006\u0081\u0095\u0012@\u00d9\u00ce\u00f7S\u00e3%0\u00c0;\u00dfO\u008d\u0097n\u0011\u00c0D\u008bl\u00e7\u00fb\u00a9\u0015@-\u00b2\u009d\u00ef\u00a7F1\u00c0o\u0012\u0083\u00c0\u00ca!\u0010\u00c0\u008aA`\u00e5\u00d0\"\u0019@\u008f\u00c2\u00f5(\\\u00af1\u00c0}?5^\u00ba\u00c9\u0013\u00c0\u00be\u009f\u001a/\u00dd\u00a4\u0011@\u00db\u00f9~j\u00bc42\u00c0\"\u00b0rh\u0091\u00ed\u0017\u00c0\u0002+\u0087\u0016\u00d9N\u0011@w\u00be\u009f\u001a/\u00dd1\u00c0\u009e\u00ef\u00a7\u00c6K\u00b7\u0010\u00c0\u00b1rh\u0091\u00ed|\b@\u00f2\u00d2Mb\u0010\u00182\u00c0\u00d7\u00a3p=\n\u00d7\u0013\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u0013@?5^\u00baI\u00ac3\u00c0\u0096C\u008bl\u00e7\u00fb\u0014\u00c0\u00baI\f\u0002+\u0007\u0018@\u008bl\u00e7\u00fb\u00a9\u00b13\u00c0\u00d2\"\u00db\u00f9~j\u000f\u00c0\u00cc\u00a1E\u00b6\u00f3}\u0013@1\b\u00ac\u001cZ\u00044\u00c0b\u0010X9\u00b4\u00c8\u0007\u00c0\f\u0002+\u0087\u0016\u00d9\b@\u0096C\u008bl\u00e7\u00db1\u00c0e;\u00dfO\u008d\u0017\u0017\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u0010@w\u00be\u009f\u001a/\u00bd4\u00c0\u00f5\u00fd\u00d4x\u00e9&\u001c\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\u0011@/\u00dd$\u0006\u0081\u00155\u00c0r=\n\u00d7\u00a3p\u001e\u00c0D\u008bl\u00e7\u00fb)\u0015@\u008e\u0097n\u0012\u0083\u00c04\u00c0\u008d\u0097n\u0012\u0083@\u0015\u00c0\u00cb\u00a1E\u00b6\u00f3\u00fd\b@d;\u00dfO\u008dw5\u00c0\u001f\u0085\u00ebQ\u00b8\u009e\u0011\u00c0\u00db\u00f9~j\u00bct\u0005@\u00f2\u00d2Mb\u0010x5\u00c0\u00e2z\u0014\u00aeGa\u0019\u00c0\u0002+\u0087\u0016\u00d9\u00ce\u0005@\u000e-\u00b2\u009d\u00efG6\u00c0I\u00e1z\u0014\u00aeG\u0019\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\u00fe?w\u00be\u009f\u001a/\u00fd6\u00c0\u0088\u0016\u00d9\u00ce\u00f7\u00d3\u001d\u00c0\u00e8\u00fb\u00a9\u00f1\u00d2M\f@\u00f2\u00d2Mb\u0010\u00186\u00c0\u00c6 \u00b0rh\u0091\u0013\u00c0K\f\u0002+\u0087\u0016\u00ff?H\u00e1z\u0014\u00aeg2\u00c0%\u0006\u0081\u0095C\u008b\u0017\u00c0ffffff\u0000@\u008bl\u00e7\u00fb\u00a9\u00912\u00c0\u00aeG\u00e1z\u0014.\u0011\u00c0\u0010X9\u00b4\u00c8v\u00e2?\u00baI\f\u0002+\u00872\u00c0\u00f2\u00d2Mb\u0010X\n\u00c0\u0014\u00aeG\u00e1z\u0014\u00e6?%\u0006\u0081\u0095C\u00eb2\u00c0\u00c7K7\u0089A\u00e0\u0014\u00c0H\u00e1z\u0014\u00aeG\u00c1\u00bf\u00f2\u00d2Mb\u0010\u00983\u00c0\u0081\u0095C\u008bl\u00e7\u0010\u00c0\u00f4\u00fd\u00d4x\u00e9&\u00d1\u00bf/\u00dd$\u0006\u008151\u00c0-\u00b2\u009d\u00ef\u00a7\u00c6\u0014\u00c0\u00c1\u00ca\u00a1E\u00b6\u00f3\u00d5\u00bfh\u0091\u00ed|?\u00b50\u00c0:\u00b4\u00c8v\u00be\u009f\u0019\u00c0j\u00bct\u0093\u0018\u0004\u00a6\u00bfp\u0012\u0083\u00c0\u00ca\u00813\u00c0\u009d\u00c4 \u00b0rh\u000e\u00c0\u00b4\u00c8v\u00be\u009f\u001a\u00fb\u00bf\u00ecQ\u00b8\u001e\u0085\u008b1\u00c0\u00be\u009f\u001a/\u00dd$\u0007\u00c0\u0088\u0016\u00d9\u00ce\u00f7S\u00fb\u00bf}?5^\u00ba)2\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\u0012\u00c0\u0004V\u000e-\u00b2\u009d\u0000\u00c0B`\u00e5\u00d0\"\u001b2\u00c0\u00b1rh\u0091\u00ed|\f\u00c0d;\u00dfO\u008d\u0097\u0002\u00c0R\u00b8\u001e\u0085\u00eb\u00b10\u00c0r=\n\u00d7\u00a3p\t\u00c0\u00c3\u00f5(\\\u008f\u00c2\u00d5?\u00e7\u00fb\u00a9\u00f1\u00d2M0\u00c0!\u00b0rh\u0091\u00ed\u0001\u00c0}?5^\u00baI\u00d4?\\\u008f\u00c2\u00f5(\u00dc0\u00c0\\\u008f\u00c2\u00f5(\\\t\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u00d0\u00bfc\u0010X9\u00b4\u00c8.\u00c0\u00f1\u00a7\u00c6K7\u0089\u000b\u00c0\u0014\u00aeG\u00e1z\u0014\u00f6?=\n\u00d7\u00a3p\u001d0\u00c0\u0017\u00d9\u00ce\u00f7S\u00e3\u0012\u00c0\u00baI\f\u0002+\u0087\u00ea\u00bf\u00be\u009f\u001a/\u00dd\u00a44\u00c0K\f\u0002+\u0087\u0016\u000e\u00c0\f\u0002+\u0087\u0016\u00d9\u00e2\u00bfx\u00be\u009f\u001a/\u00dd4\u00c0\u007fj\u00bct\u0093\u0018\u0016\u00c0\u00fd\u00a9\u00f1\u00d2Mb\u00fa\u00bfr=\n\u00d7\u00a3\u00905\u00c0\u00bct\u0093\u0018\u0004V\u0019\u00c0\u00d1\"\u00db\u00f9~j\u00f0\u00bf\u00e3\u00a5\u009b\u00c4 \u00f05\u00c0b\u0010X9\u00b4H\u0018\u00c0\u009a\u0099\u0099\u0099\u0099\u0099\u0007\u00c0\u00ecQ\u00b8\u001e\u0085\u00eb4\u00c0\u00a2E\u00b6\u00f3\u00fd\u00d4\u0012\u00c0\u00f2\u00d2Mb\u0010X\u00ff\u00bf&\u0006\u0081\u0095C\u00cb6\u00c0\u0018\u00d9\u00ce\u00f7Sc\u0011\u00c0P\u008d\u0097n\u0012\u0083\u00f0\u00bf\u00ac\u001cZd;?7\u00c0\u00cav\u00be\u009f\u001a/\u0015\u00c0\n\u00d7\u00a3p=\n\u0004\u00c0\u00a0\u001a/\u00dd$\u00867\u00c0r=\n\u00d7\u00a3\u00f0\u0015\u00c0ffffff\r\u00c0`\u00e5\u00d0\"\u00db\u00194\u00c0,\u0087\u0016\u00d9\u00ce\u00f7\u000b\u00c0\u00afG\u00e1z\u0014\u00ae\u0006\u00c0?5^\u00baI\u008c6\u00c05^\u00baI\f\u0002\u000f\u00c0333333\u000e\u00c0\u0082\u0095C\u008bl'6\u00c0:\u00b4\u00c8v\u00be\u009f\b\u00c0\u0083\u00c0\u00ca\u00a1E\u00b6\b\u00c0\u00dd$\u0006\u0081\u0095\u00837\u00c0\u00fc\u00a9\u00f1\u00d2Mb\u0002\u00c0\u00d0\u00f7S\u00e3\u00a5\u009b\u0002\u00c0\u0004V\u000e-\u00b2\u00bd5\u00c0%\u0006\u0081\u0095C\u008b\u0000\u00c0\u00f8S\u00e3\u00a5\u009b\u00c4\u00f0\u00bf\u0098n\u0012\u0083\u00c0\u00aa5\u00c0\u0082\u0095C\u008bl\u00e7\u00f9\u00bf\u00aa\u00f1\u00d2Mb\u0010\t\u00c0\u00e9&1\b\u00ac\u001c5\u00c0!\u00b0rh\u0091m\u001d\u00c0Y9\u00b4\u00c8v\u00be\t\u00c0.\u00b2\u009d\u00ef\u00a7F5\u00c0,\u0087\u0016\u00d9\u00cew\u001f\u00c0\u00e9&1\b\u00ac\u001c\u0005\u00c0\u00c9v\u00be\u009f\u001a\u00ef5\u00c0\u007fj\u00bct\u0093X \u00c0R\u00b8\u001e\u0085\u00ebQ\u0011\u00c0\u00a4p=\n\u00d7\u00c34\u00c0\u0098n\u0012\u0083\u00c0J\u001e\u00c0\b\u00ac\u001cZd\u00bb\u0014\u00c0\u0088\u0016\u00d9\u00ce\u00f7s4\u00c0\u009a\u0099\u0099\u0099\u0099\u0019\"\u00c0\u009c\u00c4 \u00b0rh\u0013\u00c0Zd;\u00dfO\u00ed5\u00c0\u001f\u0085\u00ebQ\u00b8\u00de!\u00c0\u00aa\u00f1\u00d2Mb\u0010\u000e\u00c0\u0092\u00ed|?5~3\u00c07\u0089A`\u00e5\u00d0\"\u00c0\u0019\u0004V\u000e-\u00b2\u0006\u00c0m\u00e7\u00fb\u00a9\u00f1\u00d23\u00c0\u0092\u00ed|?5^ \u00c0\u00bdt\u0093\u0018\u0004V\f\u00c0\b\u00ac\u001cZd\u00bb2\u00c09\u00b4\u00c8v\u00be\u00df!\u00c0\u00ad\u001cZd;_\u0018\u00c0\u00d5x\u00e9&1(6\u00c0B`\u00e5\u00d0\"\u00db#\u00c0\u0091\u00ed|?5^\u0013\u00c0\u00aeG\u00e1z\u0014\u00ee2\u00c0\u00e0O\u008d\u0097nR&\u00c0\u00c3\u00f5(\\\u008fB\u0012\u00c0'1\b\u00ac\u001c\u00ba2\u00c0\u0010X9\u00b4\u00c8\u00f6\"\u00c0^\u00baI\f\u0002\u00ab\u0017\u00c0\u000e-\u00b2\u009d\u00ef\u00a72\u00c0\u0080j\u00bct\u0093\u0018$\u00c0\u0019\u0004V\u000e-\u00b2\u0010\u00c06^\u00baI\fb6\u00c0"], "name": ""} \ No newline at end of file diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/setup/RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616 b/src/openfe/tests/data/warehouse/mc1_campaign/setup/RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616 new file mode 100644 index 000000000..7991d5fc8 --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/setup/RelativeHybridTopologyProtocol-59d604ce336f12d44f6e4647a6f7e616 @@ -0,0 +1 @@ +{":version:": 1, "__module__": "openfe.protocols.openmm_rfe.hybridtop_protocols", "__qualname__": "RelativeHybridTopologyProtocol", "settings": {":is_custom:": true, "__class__": "RelativeHybridTopologyProtocolSettings", "__module__": "openfe.protocols.openmm_rfe.equil_rfe_settings", "alchemical_settings": {":is_custom:": true, "__class__": "AlchemicalSettings", "__module__": "openfe.protocols.openmm_rfe.equil_rfe_settings", "endstate_dispersion_correction": false, "explicit_charge_correction": false, "explicit_charge_correction_cutoff": {":is_custom:": true, "magnitude": 0.8, "pint_unit_registry": "openff_units", "unit": "nanometer"}, "softcore_LJ": "gapsys", "softcore_alpha": 0.85, "turn_off_core_unique_exceptions": true, "use_dispersion_correction": false}, "engine_settings": {":is_custom:": true, "__class__": "OpenMMEngineSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "compute_platform": null, "gpu_device_index": null}, "forcefield_settings": {":is_custom:": true, "__class__": "OpenMMSystemGeneratorFFSettings", "__module__": "gufe.settings.models", "constraints": "hbonds", "forcefields": ["amber/ff14SB.xml", "amber/tip3p_standard.xml", "amber/tip3p_HFE_multivalent.xml", "amber/phosaa10.xml", "amber/lipid17_merged.xml"], "hydrogen_mass": 3.0, "nonbonded_cutoff": {":is_custom:": true, "magnitude": 0.9, "pint_unit_registry": "openff_units", "unit": "nanometer"}, "nonbonded_method": "PME", "rigid_water": true, "small_molecule_forcefield": "openff-2.2.1"}, "integrator_settings": {":is_custom:": true, "__class__": "IntegratorSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "barostat": "MonteCarloBarostat", "barostat_frequency": {":is_custom:": true, "magnitude": 25.0, "pint_unit_registry": "openff_units", "unit": "timestep"}, "constraint_tolerance": 1e-06, "langevin_collision_rate": {":is_custom:": true, "magnitude": 1.0, "pint_unit_registry": "openff_units", "unit": "1 / picosecond"}, "n_restart_attempts": 20, "reassign_velocities": false, "remove_com": false, "surface_tension": {":is_custom:": true, "magnitude": 0, "pint_unit_registry": "openff_units", "unit": "bar * nanometer"}, "timestep": {":is_custom:": true, "magnitude": 4.0, "pint_unit_registry": "openff_units", "unit": "femtosecond"}}, "lambda_settings": {":is_custom:": true, "__class__": "LambdaSettings", "__module__": "openfe.protocols.openmm_rfe.equil_rfe_settings", "lambda_functions": "default", "lambda_windows": 3}, "output_settings": {":is_custom:": true, "__class__": "MultiStateOutputSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "checkpoint_interval": {":is_custom:": true, "magnitude": 1.0, "pint_unit_registry": "openff_units", "unit": "nanosecond"}, "checkpoint_storage_filename": "checkpoint.chk", "forcefield_cache": "db.json", "output_filename": "simulation.nc", "output_indices": "not water", "output_structure": "hybrid_system.pdb", "positions_write_frequency": {":is_custom:": true, "magnitude": 100.0, "pint_unit_registry": "openff_units", "unit": "picosecond"}, "velocities_write_frequency": null}, "partial_charge_settings": {":is_custom:": true, "__class__": "OpenFFPartialChargeSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "nagl_model": null, "number_of_conformers": null, "off_toolkit_backend": "ambertools", "partial_charge_method": "am1bcc"}, "protocol_repeats": 1, "simulation_settings": {":is_custom:": true, "__class__": "MultiStateSimulationSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "early_termination_target_error": {":is_custom:": true, "magnitude": 0.0, "pint_unit_registry": "openff_units", "unit": "kilocalorie_per_mole"}, "equilibration_length": {":is_custom:": true, "magnitude": 0.004999999999999999, "pint_unit_registry": "openff_units", "unit": "nanosecond"}, "minimization_steps": 500, "n_replicas": 3, "production_length": {":is_custom:": true, "magnitude": 0.009999999999999998, "pint_unit_registry": "openff_units", "unit": "nanosecond"}, "real_time_analysis_interval": {":is_custom:": true, "magnitude": 250.0, "pint_unit_registry": "openff_units", "unit": "picosecond"}, "real_time_analysis_minimum_time": {":is_custom:": true, "magnitude": 500.0, "pint_unit_registry": "openff_units", "unit": "picosecond"}, "sampler_method": "repex", "sams_flatness_criteria": "logZ-flatness", "sams_gamma0": 1.0, "time_per_iteration": {":is_custom:": true, "magnitude": 1.0, "pint_unit_registry": "openff_units", "unit": "picosecond"}}, "solvation_settings": {":is_custom:": true, "__class__": "OpenMMSolvationSettings", "__module__": "openfe.protocols.openmm_utils.omm_settings", "box_shape": "dodecahedron", "box_size": null, "box_vectors": null, "number_of_solvent_molecules": null, "solvent_model": "tip3p", "solvent_padding": {":is_custom:": true, "magnitude": 1.5, "pint_unit_registry": "openff_units", "unit": "nanometer"}}, "thermo_settings": {":is_custom:": true, "__class__": "ThermoSettings", "__module__": "gufe.settings.models", "ph": null, "pressure": {":is_custom:": true, "magnitude": 1, "pint_unit_registry": "openff_units", "unit": "bar"}, "redox_potential": null, "temperature": {":is_custom:": true, "magnitude": 298.15, "pint_unit_registry": "openff_units", "unit": "kelvin"}}}} diff --git a/src/openfe/tests/data/warehouse/mc1_campaign/setup/SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab b/src/openfe/tests/data/warehouse/mc1_campaign/setup/SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab new file mode 100644 index 000000000..c1cdc539c --- /dev/null +++ b/src/openfe/tests/data/warehouse/mc1_campaign/setup/SmallMoleculeComponent-8f5b6a9848f63293c9b2361b51b466ab @@ -0,0 +1 @@ +{":version:": 1, "__module__": "gufe.components.smallmoleculecomponent", "__qualname__": "SmallMoleculeComponent", "atoms": [[6, 0, 0, true, 0, 0, {"PartialCharge": -0.15505882352941178}, 3], [8, 0, 0, false, 0, 0, {"PartialCharge": -0.7983588235294118}, 3], [16, 0, 0, true, 0, 0, {"PartialCharge": 0.028441176470588237}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.15005882352941177}, 3], [8, 0, -1, false, 0, 0, {"PartialCharge": -0.7983588235294118}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.09305882352941176}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.09905882352941177}, 3], [6, 0, 0, false, 0, 0, {"PartialCharge": 0.9317411764705882}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.03485882352941176}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.05565882352941176}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.10515882352941176}, 3], [6, 0, 0, true, 0, 0, {"PartialCharge": -0.052858823529411764}, 3], [17, 0, 0, false, 0, 0, {"PartialCharge": -0.09245882352941176}, 4], [1, 0, 0, false, 0, 0, {"PartialCharge": 0.11994117647058823}, 1], [1, 0, 0, false, 0, 0, {"PartialCharge": 0.11094117647058824}, 1], [1, 0, 0, false, 0, 0, {"PartialCharge": 0.11194117647058824}, 1], [1, 0, 0, false, 0, 0, {"PartialCharge": 0.13194117647058823}, 1]], "bonds": [[0, 3, 12, 0, {}], [0, 5, 12, 0, {}], [0, 14, 1, 0, {}], [1, 7, 2, 0, {}], [2, 9, 12, 0, {}], [2, 10, 12, 0, {}], [3, 6, 12, 0, {}], [3, 15, 1, 0, {}], [4, 7, 1, 0, {}], [5, 10, 12, 0, {}], [5, 13, 1, 0, {}], [6, 11, 12, 0, {}], [6, 16, 1, 0, {}], [7, 9, 1, 0, {}], [8, 9, 12, 0, {}], [8, 11, 12, 0, {}], [8, 12, 1, 0, {}], [10, 11, 12, 0, {}]], "conformer": ["\u0093NUMPY\u0001\u0000v\u0000{'descr': ' 0 + for u, v in graph.edges: + assert u in graph.nodes + assert v in graph.nodes + + +@pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) +def test_alchemical_network_to_task_graph_edge_direction_matches_dependencies(request, fixture): + warehouse = _RecordingWarehouse() + network = request.getfixturevalue(fixture) + + graph = _alchemical_network_to_task_graph(network, cast(WarehouseBaseClass, warehouse)) + units_by_key = {str(unit.key): unit for unit in warehouse.stored_tasks} + + for upstream_id, downstream_id in graph.edges: + # as of now this is true, but 'node' may contain more info + upstream_key = upstream_id + downstream_key = downstream_id + upstream_unit = units_by_key[upstream_key] + downstream_unit = units_by_key[downstream_key] + assert upstream_unit in downstream_unit.dependencies + + +def test_alchemical_network_to_task_graph_raises_for_cycle(): + class _Unit: + def __init__(self, name: str, key: str): + self.name = name + self.key = key + + class _Transformation: + name = "cyclic" + key = "Transformation-cycle" + + def create(self): + unit_a = _Unit("unit-a", "ProtocolUnit-a") + unit_b = _Unit("unit-b", "ProtocolUnit-b") + dag = mock.Mock() + dag.protocol_units = [unit_a, unit_b] + dag.graph = nx.DiGraph() + dag.graph.add_nodes_from([unit_a, unit_b]) + dag.graph.add_edges_from([(unit_a, unit_b), (unit_b, unit_a)]) + return dag + + network = mock.Mock(AlchemicalNetwork) + network.edges = [_Transformation()] + warehouse = mock.Mock() + + with pytest.raises(ValueError, match="not a DAG"): + _alchemical_network_to_task_graph(network, warehouse) + + +# TODO: slow test +@pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) +def test_build_task_db_checkout_order_is_dependency_safe(tmp_path, request, fixture): + network = request.getfixturevalue(fixture) + # Build the real sqlite task DB from a real alchemical network fixture. + wh_dir = tmp_path / "campaign" + db, warehouse = build_task_db_from_alchemical_network( + network, + warehouse_dir=wh_dir, + db_path=tmp_path / "campaign.db", + ) + + # Read task IDs and dependency edges from the persisted DB state. + initial_task_rows = list(db.get_all_tasks()) + graph_taskids = {row.taskid for row in initial_task_rows} + with db.engine.connect() as conn: + dep_rows = conn.execute(sqla.select(db.dependencies_table)).all() + graph_edges = {(row._mapping["from"], row._mapping["to"]) for row in dep_rows} + + checkout_order = [] + # Hard upper bound prevents infinite checkout loops. + max_checkouts = len(graph_taskids) + + for _ in range(max_checkouts): + taskid = db.check_out_task() + if taskid is None: + break + + checkout_order.append(taskid) + protocol_unit_key = taskid + loaded_unit = warehouse.load_task(GufeKey(protocol_unit_key)) + assert str(loaded_unit.key) == protocol_unit_key + db.mark_task_completed(taskid, success=True) + + # Coverage/completion: every task is checked out exactly once. + observed_taskids = set(checkout_order) + assert observed_taskids == graph_taskids + assert len(checkout_order) == len(graph_taskids) + + # Dependency safety: upstream tasks must appear before downstream tasks. + checkout_index = {taskid: idx for idx, taskid in enumerate(checkout_order)} + for upstream, downstream in graph_edges: + assert checkout_index[upstream] < checkout_index[downstream] + + # Final DB state: all tasks are completed. + task_rows = list(db.get_all_tasks()) + assert len(task_rows) == len(graph_taskids) + assert {row.taskid for row in task_rows} == graph_taskids + assert {row.status for row in task_rows} == {exorcist.TaskStatus.COMPLETED.value} + + +# TODO: revisit this after deciding how we want to handle defaults +# @pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) +# def test_build_task_db_default_path(request, fixture): +# network = request.getfixturevalue(fixture) +# warehouse = mock.Mock() +# fake_graph = nx.DiGraph() +# fake_db = mock.Mock() + +# with ( +# mock.patch( +# "openfe.orchestration.exorcist_utils._alchemical_network_to_task_graph", +# return_value=fake_graph, +# ) as task_graph_mock, +# mock.patch( +# "openfe.orchestration.exorcist_utils.exorcist.TaskStatusDB.from_filename", +# return_value=fake_db, +# ) as db_ctor, +# ): +# result = build_task_db_from_alchemical_network(network, warehouse) + +# task_graph_mock.assert_called_once_with(network, warehouse) +# db_ctor.assert_called_once_with(Path(f"{warehouse.name}.db")) +# fake_db.add_task_network.assert_called_once_with(fake_graph, 1) +# assert result is fake_db + + +@pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) +def test_build_task_db_forwards_graph_and_max_tries(request, tmp_path, fixture): + network = request.getfixturevalue(fixture) + fake_graph = nx.DiGraph() + fake_db = mock.Mock() + db_path = tmp_path / "tmp_campaign.db" + wh_path = tmp_path / "tmp_campaign" + with ( + mock.patch( + "openfe.orchestration.exorcist_utils._alchemical_network_to_task_graph", + return_value=fake_graph, + ) as task_graph_mock, + mock.patch( + "openfe.orchestration.exorcist_utils.exorcist.TaskStatusDB.from_filename", + return_value=fake_db, + ) as db_ctor, + ): + db, warehouse = build_task_db_from_alchemical_network( + network, + wh_path, + db_path=db_path, + max_tries=7, + ) + task_graph_mock.assert_called_once_with(network, warehouse) + db_ctor.assert_called_once_with(db_path) + fake_db.add_task_network.assert_called_once_with(fake_graph, 7) + assert db is fake_db + + +@pytest.fixture() +def benzene_star_map_task_db(benzene_variants_star_map, tmp_path): + warehouse = _RecordingWarehouse() + network = benzene_variants_star_map + global_task_dag = _alchemical_network_to_task_graph( + network, cast(WarehouseBaseClass, warehouse) + ) + db = exorcist.TaskStatusDB.from_filename(":memory:") + db.add_task_network(global_task_dag, 5) + return db + + +def test_get_task_df(benzene_star_map_task_db): + df = get_task_df(benzene_star_map_task_db) + assert isinstance(df, pd.DataFrame) + assert list(df.columns) == [ + "taskid", + "status", + "last_modified", + "tries", + "max_tries", + "task_type", + ] + assert len(df) == 276 + assert len(df[df.status == "AVAILABLE"]) == 12 + assert len(df[df.status == "BLOCKED"]) == 264 + + +def test_get_dependency_df(benzene_star_map_task_db): + df = get_dependency_df(benzene_star_map_task_db) + assert isinstance(df, pd.DataFrame) + assert list(df.columns) == ["from", "to", "blocking"] + assert len(df) == 504 diff --git a/src/openfe/tests/orchestration/test_worker.py b/src/openfe/tests/orchestration/test_worker.py new file mode 100644 index 000000000..de07a67d1 --- /dev/null +++ b/src/openfe/tests/orchestration/test_worker.py @@ -0,0 +1,274 @@ +from pathlib import Path +from unittest import mock + +import exorcist +import gufe +import networkx as nx +import pytest +from gufe.protocols.protocolunit import ProtocolUnit + +from openfe.orchestration import Worker +from openfe.orchestration.exorcist_utils import build_task_db_from_alchemical_network +from openfe.storage.warehouse import FileSystemWarehouse + + +def _result_store_files(warehouse: FileSystemWarehouse) -> set[str]: + result_root = Path(warehouse.result_store.root_dir) + return {str(path.relative_to(result_root)) for path in result_root.rglob("*") if path.is_file()} + + +def _contains_protocol_unit(value) -> bool: + if isinstance(value, ProtocolUnit): + return True + if isinstance(value, dict): + return any(_contains_protocol_unit(item) for item in value.values()) + if isinstance(value, list): + return any(_contains_protocol_unit(item) for item in value) + return False + + +class _ToyProtocolUnit(ProtocolUnit): + @staticmethod + def _execute(ctx, **inputs) -> dict[str, int]: + increment = inputs["increment"] + upstream = inputs.get("upstream") + base = 0 if upstream is None else upstream.outputs["value"] + return {"value": base + increment} + + +class _FileWritingUnit(ProtocolUnit): + @staticmethod + def _execute(ctx, **inputs) -> dict[str, str]: + shared_file = ctx.shared / "simulation.nc" + shared_file.parent.mkdir(parents=True, exist_ok=True) + shared_file.write_text("unit output", encoding="utf-8") + return {"shared_file": str(shared_file)} + + +def _get_dependency_free_unit(absolute_transformation): + for unit in absolute_transformation.create().protocol_units: + if not _contains_protocol_unit(unit.inputs): + return unit + raise ValueError("No dependency-free protocol unit found for execution test setup.") + + +@pytest.fixture +def worker_with_real_db(tmp_path, absolute_transformation): + warehouse_root = tmp_path / "warehouse" + db_path = tmp_path / "tasks.db" + network = gufe.AlchemicalNetwork([absolute_transformation]) + db, warehouse = build_task_db_from_alchemical_network(network, warehouse_root, db_path=db_path) + worker = Worker(warehouse=warehouse, task_db_path=db_path) + return worker, warehouse, db + + +@pytest.fixture +def worker_with_executable_task_db(tmp_path, absolute_transformation): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse = FileSystemWarehouse(str(warehouse_root)) + unit = _get_dependency_free_unit(absolute_transformation) + warehouse.store_task(unit) + + taskid = unit.key + task_graph = nx.DiGraph() + task_graph.add_node(taskid) + + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(task_graph, 1) + + worker = Worker(warehouse=warehouse, task_db_path=db_path) + return worker, warehouse, db, unit + + +def test_get_task_uses_default_db_path_without_patching( + tmp_path, monkeypatch, absolute_transformation +): + # TODO: tasks.db shouldn't exist _within_ the warehouse + monkeypatch.chdir(tmp_path) + warehouse_root = "warehouse" + db_path = Path("warehouse/tasks.db") + network = gufe.AlchemicalNetwork([absolute_transformation]) + db, warehouse = build_task_db_from_alchemical_network(network, warehouse_root, db_path=db_path) + + warehouse = FileSystemWarehouse.from_dir("warehouse") + worker = Worker(warehouse=warehouse) + taskid, loaded = worker._get_task() + + expected_keys = {task_row.taskid for task_row in db.get_all_tasks()} + assert worker.task_db_path == Path("./warehouse/tasks.db") + assert str(loaded.key) in expected_keys + assert taskid == loaded.key + + +def test_get_task_returns_task_with_canonical_protocol_unit_suffix(worker_with_real_db): + worker, warehouse, db = worker_with_real_db + + task_ids = [row.taskid for row in db.get_all_tasks()] + expected_protocol_unit_keys = {task_id for task_id in task_ids} + + taskid, loaded = worker._get_task() + reloaded = warehouse.load_task(loaded.key) + + assert str(loaded.key) in expected_protocol_unit_keys + assert loaded == reloaded + assert taskid == loaded.key + + +def test_execute_unit_stores_real_result(worker_with_executable_task_db, tmp_path): + worker, warehouse, db, _ = worker_with_executable_task_db + before = _result_store_files(warehouse) + + execution = worker.execute_unit(scratch=tmp_path / "scratch") + assert execution is not None + taskid, _ = execution + + after = _result_store_files(warehouse) + assert len(after) > len(before) + rows = list(db.get_all_tasks()) + status_by_taskid = {row.taskid: row.status for row in rows} + assert status_by_taskid[taskid] == exorcist.TaskStatus.COMPLETED.value + + +def test_execute_unit_propagates_execute_error_without_store( + worker_with_executable_task_db, tmp_path +): + worker, warehouse, db, unit = worker_with_executable_task_db + before = _result_store_files(warehouse) + taskid = list(db.get_all_tasks())[0].taskid + + with mock.patch.object( + type(unit), + "execute", + autospec=True, + side_effect=RuntimeError("unit execution failed"), + ): + with pytest.raises(RuntimeError, match="unit execution failed"): + worker.execute_unit(scratch=tmp_path / "scratch") + + after = _result_store_files(warehouse) + assert after == before + rows = list(db.get_all_tasks()) + status_by_taskid = {row.taskid: row.status for row in rows} + assert status_by_taskid[taskid] == exorcist.TaskStatus.TOO_MANY_RETRIES.value + + +def test_checkout_task_returns_none_when_no_available_tasks(tmp_path): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse_root.mkdir(parents=True, exist_ok=True) + warehouse = FileSystemWarehouse.from_dir(str(warehouse_root)) + exorcist.TaskStatusDB.from_filename(db_path) + worker = Worker(warehouse=warehouse, task_db_path=db_path) + + assert worker._checkout_task() is None + + +def test_execute_unit_returns_none_when_no_available_tasks(tmp_path): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse_root.mkdir(parents=True, exist_ok=True) + warehouse = FileSystemWarehouse.from_dir(str(warehouse_root)) + exorcist.TaskStatusDB.from_filename(db_path) + worker = Worker(warehouse=warehouse, task_db_path=db_path) + + assert worker.execute_unit(scratch=tmp_path / "scratch") is None + + +def test_execute_unit_resolves_dependency_results(tmp_path): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse = FileSystemWarehouse(str(warehouse_root)) + + first_unit = _ToyProtocolUnit(name="first", increment=1) + second_unit = _ToyProtocolUnit(name="second", upstream=first_unit, increment=2) + + warehouse.store_task(first_unit) + warehouse.store_task(second_unit) + + first_taskid = first_unit.key + second_taskid = second_unit.key + + task_graph = nx.DiGraph() + task_graph.add_edge(first_taskid, second_taskid) + + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(task_graph, max_tries=1) + + worker = Worker(warehouse=warehouse, task_db_path=db_path) + + first_execution = worker.execute_unit(scratch=tmp_path / "scratch") + second_execution = worker.execute_unit(scratch=tmp_path / "scratch") + + assert first_execution is not None + assert first_execution[0] == first_taskid + assert second_execution is not None + assert second_execution[0] == second_taskid + assert second_execution[1].outputs["value"] == 3 + + status_by_taskid = {row.taskid: row.status for row in db.get_all_tasks()} + assert status_by_taskid[first_taskid] == exorcist.TaskStatus.COMPLETED.value + assert status_by_taskid[second_taskid] == exorcist.TaskStatus.COMPLETED.value + + +def test_execute_unit_marks_missing_dependency_as_failed(tmp_path): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse = FileSystemWarehouse(str(warehouse_root)) + + missing_upstream = _ToyProtocolUnit(name="missing", increment=1) + dependent_unit = _ToyProtocolUnit(name="dependent", upstream=missing_upstream, increment=2) + warehouse.store_task(dependent_unit) + + taskid = dependent_unit.key + task_graph = nx.DiGraph() + task_graph.add_node(taskid) + + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(task_graph, max_tries=1) + + worker = Worker(warehouse=warehouse, task_db_path=db_path) + + with pytest.raises(RuntimeError, match="Missing ProtocolUnitResult"): + worker.execute_unit(scratch=tmp_path / "scratch") + + status_by_taskid = {row.taskid: row.status for row in db.get_all_tasks()} + assert status_by_taskid[taskid] == exorcist.TaskStatus.TOO_MANY_RETRIES.value + + +def test_execute_unit_uses_isolated_shared_workspace_per_task(tmp_path): + warehouse_root = tmp_path / "warehouse" + db_path = warehouse_root / "tasks.db" + warehouse = FileSystemWarehouse(str(warehouse_root)) + + first_unit = _FileWritingUnit(name="first") + second_unit = _FileWritingUnit(name="second") + + warehouse.store_task(first_unit) + warehouse.store_task(second_unit) + + first_taskid = first_unit.key + second_taskid = second_unit.key + + task_graph = nx.DiGraph() + task_graph.add_node(first_taskid) + task_graph.add_node(second_taskid) + + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(task_graph, max_tries=1) + + worker = Worker(warehouse=warehouse, task_db_path=db_path) + + first_execution = worker.execute_unit(scratch=tmp_path / "scratch") + second_execution = worker.execute_unit(scratch=tmp_path / "scratch") + + assert first_execution is not None + assert second_execution is not None + + first_path = Path(first_execution[1].outputs["shared_file"]) + second_path = Path(second_execution[1].outputs["shared_file"]) + + assert first_path != second_path + assert first_path.name == "simulation.nc" + assert second_path.name == "simulation.nc" + assert first_path.parent != second_path.parent diff --git a/src/openfe/tests/storage/conftest.py b/src/openfe/tests/storage/conftest.py new file mode 100644 index 000000000..1851b7c05 --- /dev/null +++ b/src/openfe/tests/storage/conftest.py @@ -0,0 +1,118 @@ +import gufe +import pytest +from gufe import ChemicalSystem, SolventComponent +from gufe.tests.test_protocol import DummyProtocol +from openff.units import unit + + +@pytest.fixture +def solv_comp(): + yield SolventComponent(positive_ion="K", negative_ion="Cl", ion_concentration=0.0 * unit.molar) + + +@pytest.fixture +def solvated_complex(T4_protein_component, benzene_transforms, solv_comp): + return ChemicalSystem( + { + "ligand": benzene_transforms["toluene"], + "protein": T4_protein_component, + "solvent": solv_comp, + } + ) + + +@pytest.fixture +def solvated_ligand(benzene_transforms, solv_comp): + return ChemicalSystem( + { + "ligand": benzene_transforms["toluene"], + "solvent": solv_comp, + } + ) + + +@pytest.fixture +def absolute_transformation(solvated_ligand, solvated_complex): + return gufe.Transformation( + solvated_ligand, + solvated_complex, + protocol=DummyProtocol(settings=DummyProtocol.default_settings()), + mapping=None, + ) + + +@pytest.fixture +def complex_equilibrium(solvated_complex): + return gufe.NonTransformation( + solvated_complex, + protocol=DummyProtocol(settings=DummyProtocol.default_settings()), + ) + + +@pytest.fixture +def benzene_variants_star_map(benzene_transforms, solv_comp, T4_protein_component): + variants = ["toluene", "phenol", "benzonitrile", "anisole", "benzaldehyde", "styrene"] + + # define the solvent chemical systems and transformations between + # benzene and the others + solvated_ligands = {} + solvated_ligand_transformations = {} + + solvated_ligands["benzene"] = ChemicalSystem( + { + "solvent": solv_comp, + "ligand": benzene_transforms["benzene"], + }, + name="benzene-solvent", + ) + + for ligand in variants: + solvated_ligands[ligand] = ChemicalSystem( + { + "solvent": solv_comp, + "ligand": benzene_transforms[ligand], + }, + name=f"{ligand}-solvent", + ) + + solvated_ligand_transformations[("benzene", ligand)] = gufe.Transformation( + solvated_ligands["benzene"], + solvated_ligands[ligand], + protocol=DummyProtocol(settings=DummyProtocol.default_settings()), + mapping=None, + ) + + # define the complex chemical systems and transformations between + # benzene and the others + solvated_complexes = {} + solvated_complex_transformations = {} + + solvated_complexes["benzene"] = gufe.ChemicalSystem( + { + "protein": T4_protein_component, + "solvent": solv_comp, + "ligand": benzene_transforms["benzene"], + }, + name="benzene-complex", + ) + + for ligand in variants: + solvated_complexes[ligand] = gufe.ChemicalSystem( + { + "protein": T4_protein_component, + "solvent": solv_comp, + "ligand": benzene_transforms[ligand], + }, + name=f"{ligand}-complex", + ) + solvated_complex_transformations[("benzene", ligand)] = gufe.Transformation( + solvated_complexes["benzene"], + solvated_complexes[ligand], + protocol=DummyProtocol(settings=DummyProtocol.default_settings()), + mapping=None, + ) + + return gufe.AlchemicalNetwork( + list(solvated_ligand_transformations.values()) + + list(solvated_complex_transformations.values()) + ) diff --git a/src/openfe/tests/storage/test_warehouse.py b/src/openfe/tests/storage/test_warehouse.py new file mode 100644 index 000000000..262bab58a --- /dev/null +++ b/src/openfe/tests/storage/test_warehouse.py @@ -0,0 +1,325 @@ +import tempfile +from importlib import resources +from pathlib import Path +from typing import Literal +from unittest import mock + +import pytest +from gufe.storage.externalresource import MemoryStorage +from gufe.tokenization import GufeTokenizable +from openff.units import unit + +from openfe.orchestration import Worker, exorcist_utils +from openfe.storage.utils import convert_to_quickrun_output +from openfe.storage.warehouse import ( + FileSystemWarehouse, + WarehouseBaseClass, + WarehouseStores, +) + + +class TestWarehouseBaseClass: + def test_store_protocol_dag_result(self): + pytest.skip("Not implemented yet") + + @staticmethod + def _build_stores() -> WarehouseStores: + return WarehouseStores( + setup=MemoryStorage(), + results=MemoryStorage(), + shared=MemoryStorage(), + tasks=MemoryStorage(), + protocol_dags=MemoryStorage(), + ) + + @staticmethod + def _get_protocol_unit(transformation): + dag = transformation.create() + return next(iter(dag.protocol_units)) + + @staticmethod + def _test_store_load_same_process( + obj, + store_func_name, + load_func_name, + store_name: Literal["setup", "results", "tasks"], + ): + stores = TestWarehouseBaseClass._build_stores() + client = WarehouseBaseClass(stores=stores, name="test_warehouse") + store_func = getattr(client, store_func_name) + load_func = getattr(client, load_func_name) + assert stores["setup"]._data == {} + assert stores["results"]._data == {} + assert stores["shared"]._data == {} + assert stores["tasks"]._data == {} + store_func(obj) + store_under_test: MemoryStorage = stores[store_name] + assert store_under_test._data != {} + reloaded: GufeTokenizable = load_func(obj.key) + assert reloaded is obj + return reloaded, client + + @staticmethod + def _test_store_load_different_process( + obj: GufeTokenizable, + store_func_name, + load_func_name, + store_name: Literal["setup", "results", "tasks"], + ): + stores = TestWarehouseBaseClass._build_stores() + client = WarehouseBaseClass(stores=stores, name="test_warehouse") + store_func = getattr(client, store_func_name) + load_func = getattr(client, load_func_name) + assert stores["setup"]._data == {} + assert stores["results"]._data == {} + assert stores["shared"]._data == {} + assert stores["tasks"]._data == {} + store_func(obj) + store_under_test: MemoryStorage = stores[store_name] + assert store_under_test._data != {} + # make it look like we have an empty cache, as if this was a + # different process + key = obj.key + registry_dict = "gufe.tokenization.TOKENIZABLE_REGISTRY" + with mock.patch.dict(registry_dict, {}, clear=True): + reload = load_func(key) + assert reload == obj + assert reload is not obj + + def test_store_load_task_same_process(self, absolute_transformation): + unit = self._get_protocol_unit(absolute_transformation) + self._test_store_load_same_process(unit, "store_task", "load_task", "tasks") + + def test_store_load_task_different_process(self, absolute_transformation): + unit = self._get_protocol_unit(absolute_transformation) + self._test_store_load_different_process(unit, "store_task", "load_task", "tasks") + + def test_store_task_writes_to_tasks_store(self, absolute_transformation): + unit = self._get_protocol_unit(absolute_transformation) + stores = self._build_stores() + client = WarehouseBaseClass(stores, name="test_warehouse") + client.store_task(unit) + + assert stores["tasks"]._data != {} + assert stores["setup"]._data == {} + assert stores["results"]._data == {} + assert stores["shared"]._data == {} + + def test_exists_finds_task_key(self, absolute_transformation): + unit = self._get_protocol_unit(absolute_transformation) + stores = self._build_stores() + client = WarehouseBaseClass(stores, "test_warehouse") + + client.store_task(unit) + + assert client.exists(unit.key) + + def test_load_task_returns_object(self, absolute_transformation): + unit = self._get_protocol_unit(absolute_transformation) + stores = self._build_stores() + client = WarehouseBaseClass(stores, name="test_warehouse") + + client.store_task(unit) + loaded = client.load_task(unit.key) + + assert loaded is not None + assert isinstance(loaded, GufeTokenizable) + + def test_load_task_wrong_type(self, absolute_transformation): + transformation = absolute_transformation + stores = self._build_stores() + client = WarehouseBaseClass(stores, name="test_warehouse") + + client.store_setup_tokenizable(transformation) + with pytest.raises(TypeError, match="as ProtocolUnit"): + _ = client.load_task(transformation.key) + + def test_store_load_protocol_dag_wrong_type(self, absolute_transformation): + transformation = absolute_transformation + stores = self._build_stores() + client = WarehouseBaseClass(stores, name="test_warehouse") + + with pytest.raises(TypeError, match="Unable to write"): + client.store_protocol_dag(absolute_transformation) + client.store_setup_tokenizable(absolute_transformation) + + with pytest.raises(TypeError, match="Unable to load"): + client.load_protocol_dag(absolute_transformation.key) + + @pytest.mark.parametrize( + "fixture", + ["absolute_transformation", "complex_equilibrium"], + ) + @pytest.mark.parametrize("store", ["setup", "results"]) + def test_store_load_transformation_same_process(self, request, fixture, store): + transformation = request.getfixturevalue(fixture) + store_func_name = f"store_{store}_tokenizable" + load_func_name = f"load_{store}_tokenizable" + self._test_store_load_same_process(transformation, store_func_name, load_func_name, store) + + @pytest.mark.parametrize( + "fixture", + ["absolute_transformation", "complex_equilibrium"], + ) + @pytest.mark.parametrize("store", ["setup", "results"]) + def test_store_load_transformation_different_process(self, request, fixture, store): + transformation = request.getfixturevalue(fixture) + store_func_name = f"store_{store}_tokenizable" + load_func_name = f"load_{store}_tokenizable" + self._test_store_load_different_process( + transformation, store_func_name, load_func_name, store + ) + + @pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) + @pytest.mark.parametrize("store", ["setup", "results"]) + def test_store_load_network_same_process(self, request, fixture, store): + network = request.getfixturevalue(fixture) + assert isinstance(network, GufeTokenizable) + store_func_name = f"store_{store}_tokenizable" + load_func_name = f"load_{store}_tokenizable" + self._test_store_load_same_process(network, store_func_name, load_func_name, store) + + @pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) + @pytest.mark.parametrize("store", ["setup", "results"]) + def test_store_load_network_different_process(self, request, fixture, store): + network = request.getfixturevalue(fixture) + assert isinstance(network, GufeTokenizable) + store_func_name = f"store_{store}_tokenizable" + load_func_name = f"load_{store}_tokenizable" + self._test_store_load_different_process(network, store_func_name, load_func_name, store) + + @pytest.mark.parametrize("fixture", ["benzene_variants_star_map"]) + @pytest.mark.parametrize("store", ["setup", "results"]) + def test_delete(self, request, fixture, store): + network = request.getfixturevalue(fixture) + store_func_name = f"store_{store}_tokenizable" + load_func_name = f"load_{store}_tokenizable" + obj, client = self._test_store_load_same_process( + network, store_func_name, load_func_name, store + ) + client.delete(store, obj.key) + assert not client.exists(obj.key) + + +class TestFileSystemWarehouse: + @staticmethod + def _test_store_load_same_process(obj, store_func_name, load_func_name): + with tempfile.TemporaryDirectory() as tmpdir: + wh_dir = Path(tmpdir) / "warehouse_name" + client = FileSystemWarehouse(wh_dir) + store_func = getattr(client, store_func_name) + load_func = getattr(client, load_func_name) + # TODO: top dirs should exist but be empty + # assert not any((Path(tmpdir)/store_func_name).iterdir()) + store_func(obj) + assert any(Path(f"{wh_dir}").iterdir()) + reloaded = load_func(obj.key) + assert reloaded is obj + + @staticmethod + def _test_store_load_different_process(obj: GufeTokenizable, store_func_name, load_func_name): + with tempfile.TemporaryDirectory() as tmpdir: + wh_dir = Path(tmpdir) / "warehouse_name" + client = FileSystemWarehouse(root_dir=wh_dir) + store_func = getattr(client, store_func_name) + load_func = getattr(client, load_func_name) + # TODO: top dirs should exist but be empty + # assert not any(Path(f"{tmpdir}").iterdir()) + store_func(obj) + assert any(Path(f"{wh_dir}").iterdir()) + # make it look like we have an empty cache, as if this was a + # different process + key = obj.key + registry_dict = "gufe.tokenization.TOKENIZABLE_REGISTRY" + with mock.patch.dict(registry_dict, {}, clear=True): + reload = load_func(key) + assert reload == obj + assert reload is not obj + + @pytest.mark.parametrize( + "fixture", + ["absolute_transformation", "complex_equilibrium"], + ) + def test_store_load_transformation_same_process(self, request, fixture): + transformation = request.getfixturevalue(fixture) + self._test_store_load_same_process( + transformation, + "store_setup_tokenizable", + "load_setup_tokenizable", + ) + + def test_filesystemwarehouse_has_shared_and_tasks_stores(self, absolute_transformation): + unit = TestWarehouseBaseClass._get_protocol_unit(absolute_transformation) + + with tempfile.TemporaryDirectory() as tmpdir: + wh_dir = Path(tmpdir) / "warehouse_name" + client = FileSystemWarehouse(wh_dir) + assert client.name == "warehouse_name" + + assert "shared" in client.stores + assert "tasks" in client.stores + + client.stores["shared"].store_bytes("sentinel", b"shared-data") + with client.stores["shared"].load_stream("sentinel") as f: + assert f.read() == b"shared-data" + + client.store_task(unit) + assert client.exists(unit.key) + + def test_filesystem_warehouse_exists_error(self): + with tempfile.TemporaryDirectory() as tmpdir: + wh_dir = Path(tmpdir) / "warehouse_name" + client = FileSystemWarehouse(wh_dir) + # store some data so files are created + client.stores["shared"].store_bytes("sentinel", b"shared-data") + + with pytest.raises(FileExistsError, match="already exists"): + _ = FileSystemWarehouse(wh_dir) + + reloaded_client = FileSystemWarehouse.from_dir(root_dir=wh_dir) + + @pytest.mark.parametrize( + "fixture", + ["absolute_transformation", "complex_equilibrium"], + ) + def test_store_load_transformation_different_process(self, request, fixture): + transformation = request.getfixturevalue(fixture) + self._test_store_load_different_process( + transformation, + "store_setup_tokenizable", + "load_setup_tokenizable", + ) + + +@pytest.fixture +def warehouse_partial_failure(): + with resources.path("openfe.tests.data.warehouse", "mc1_campaign") as d: + warehouse = FileSystemWarehouse.from_dir(root_dir=d) + return warehouse + + +class TestWarehouseResultsGathering: + def test_gather_results(self, warehouse_partial_failure): + wh = warehouse_partial_failure + result_edges = wh.gather_all_results() + # TODO: how much to check here + + results_ok = [dag.ok() for _, dag in result_edges] + assert sorted(results_ok) == [False, True, True, True] # one failed edge + + uncertainties = [pr.get_uncertainty() for pr, dag in result_edges if dag.ok()] + assert uncertainties == [0.0 * unit.kilocalorie_per_mole] * 3 + + expected_estimates = {-0.658, 5.547, 5.769} + estimates = {round(pr.get_estimate().m, 3) for pr, dag in result_edges if dag.ok()} + assert expected_estimates == estimates + assert len(result_edges) == 4 + + def test_convert_to_quickrun_output(self, warehouse_partial_failure, tmp_path): + wh = warehouse_partial_failure + result_edges = wh.gather_all_results() + out_dir = tmp_path / "quickrun_style_output" + convert_to_quickrun_output(result_edges, out_dir=out_dir) + assert out_dir.is_dir() + out_files = [str(p.name) for p in out_dir.rglob("Trans*")] + assert len(out_files) == 4 diff --git a/src/openfecli/cli.py b/src/openfecli/cli.py index d9bb11848..adc69ee63 100644 --- a/src/openfecli/cli.py +++ b/src/openfecli/cli.py @@ -14,7 +14,7 @@ class OpenFECLI(CLI): # COMMAND_SECTIONS = ["Setup", "Simulation", "Orchestration", "Analysis"] - COMMAND_SECTIONS = ["Network Planning", "Quickrun Executor", "Miscellaneous"] + COMMAND_SECTIONS = ["Planning & Setup", "Execution", "Results Gathering", "Miscellaneous"] def get_loaders(self): commands = str(pathlib.Path(__file__).parent.resolve() / "commands") diff --git a/src/openfecli/commands/gather.py b/src/openfecli/commands/gather.py index 9692b2fbc..9f20997ef 100644 --- a/src/openfecli/commands/gather.py +++ b/src/openfecli/commands/gather.py @@ -11,6 +11,7 @@ from openfecli import OFECommandPlugin from openfecli.clicktypes import HyphenAwareChoice +from openfecli.utils import rich_print_to_stdout FAIL_STR = "Error" # string used to indicate a failed run in output tables. @@ -695,26 +696,6 @@ def _get_legs_from_result_jsons( return legs -def rich_print_to_stdout(df: pd.DataFrame) -> None: - """Use rich to pretty print a table to stdout.""" - - from rich import box - from rich.console import Console - from rich.table import Table - - table = Table(box=box.SQUARE) - - for col in df.columns: - table.add_column(col) - - for row_values in df.values: - row = [str(val) for val in row_values] - table.add_row(*row) - - console = Console() - console.print(table) - - @click.command( "gather", short_help="Gather result JSONs for network of RBFE results into a TSV file.", @@ -822,11 +803,7 @@ def gather( rich_print_to_stdout(df) -PLUGIN = OFECommandPlugin( - command=gather, - section="Quickrun Executor", - requires_ofe=(0, 6), -) +PLUGIN = OFECommandPlugin(command=gather, section="Results Gathering", requires_ofe=(0, 6)) if __name__ == "__main__": gather() diff --git a/src/openfecli/commands/gather_abfe.py b/src/openfecli/commands/gather_abfe.py index 34157d4af..a903f9ac9 100644 --- a/src/openfecli/commands/gather_abfe.py +++ b/src/openfecli/commands/gather_abfe.py @@ -13,8 +13,8 @@ _collect_result_jsons, format_df_with_precision, load_json, - rich_print_to_stdout, ) +from openfecli.utils import rich_print_to_stdout def _get_name(result: dict) -> str: @@ -360,8 +360,4 @@ def gather_abfe( rich_print_to_stdout(df) -PLUGIN = OFECommandPlugin( - command=gather_abfe, - section="Quickrun Executor", - requires_ofe=(0, 6), -) +PLUGIN = OFECommandPlugin(command=gather_abfe, section="Results Gathering", requires_ofe=(0, 6)) diff --git a/src/openfecli/commands/gather_septop.py b/src/openfecli/commands/gather_septop.py index e76448adf..97056b6ce 100644 --- a/src/openfecli/commands/gather_septop.py +++ b/src/openfecli/commands/gather_septop.py @@ -13,8 +13,8 @@ _collect_result_jsons, format_df_with_precision, load_json, - rich_print_to_stdout, ) +from openfecli.utils import rich_print_to_stdout def _load_valid_result_json(fpath: os.PathLike | str) -> tuple[tuple | None, dict | None]: @@ -451,8 +451,4 @@ def gather_septop( rich_print_to_stdout(df) -PLUGIN = OFECommandPlugin( - command=gather_septop, - section="Quickrun Executor", - requires_ofe=(0, 6), -) +PLUGIN = OFECommandPlugin(command=gather_septop, section="Results Gathering", requires_ofe=(0, 6)) diff --git a/src/openfecli/commands/generate_partial_charges.py b/src/openfecli/commands/generate_partial_charges.py index d1a83580f..1f307e044 100644 --- a/src/openfecli/commands/generate_partial_charges.py +++ b/src/openfecli/commands/generate_partial_charges.py @@ -94,4 +94,4 @@ def charge_molecules(molecules, yaml_settings, output, n_cores, overwrite_charge output.write(mol.to_sdf()) -PLUGIN = OFECommandPlugin(command=charge_molecules, section="Miscellaneous", requires_ofe=(0, 3)) +PLUGIN = OFECommandPlugin(command=charge_molecules, section="Planning & Setup", requires_ofe=(1, 3)) diff --git a/src/openfecli/commands/plan_rbfe_network.py b/src/openfecli/commands/plan_rbfe_network.py index 25c454e87..18fa554bd 100644 --- a/src/openfecli/commands/plan_rbfe_network.py +++ b/src/openfecli/commands/plan_rbfe_network.py @@ -1,6 +1,5 @@ # This code is part of OpenFE and is licensed under the MIT license. # For details, see https://github.com/OpenFreeEnergy/openfe - import click from openfecli import OFECommandPlugin @@ -13,6 +12,7 @@ OVERWRITE, PROTEIN, PROTEIN_MEMBRANE, + WAREHOUSE, YAML_OPTIONS, ) from openfecli.utils import print_duration, write @@ -134,6 +134,7 @@ def plan_rbfe_network_main( @N_PROTOCOL_REPEATS.parameter(multiple=False, required=False, default=3, help=N_PROTOCOL_REPEATS.kwargs["help"]) # fmt: skip @NCORES.parameter(help=NCORES.kwargs["help"], default=1) @OVERWRITE.parameter(help=OVERWRITE.kwargs["help"], default=OVERWRITE.kwargs["default"], is_flag=True) # fmt: skip +@WAREHOUSE.parameter(help=WAREHOUSE.kwargs["help"], is_flag=True) @print_duration def plan_rbfe_network( molecules: list[str], @@ -145,6 +146,7 @@ def plan_rbfe_network( n_protocol_repeats: int, n_cores: int, overwrite_charges: bool, + warehouse: bool, ): """ Plan a relative binding free energy AlchemicalNetwork, saved as JSON files for use by the quickrun command. @@ -179,6 +181,7 @@ def plan_rbfe_network( write("______________________") write("") + from openfe.storage.warehouse import FileSystemWarehouse from openfecli.plan_alchemical_networks_utils import plan_alchemical_network_output write("Parsing in Files: ") @@ -247,13 +250,18 @@ def plan_rbfe_network( # OUTPUT write("Output:") write("\tSaving to: " + str(output_dir)) + warehouse_object = None + if warehouse: + warehouse_object = FileSystemWarehouse() + plan_alchemical_network_output( alchemical_network=alchemical_network, ligand_network=ligand_network, folder_path=OUTPUT_DIR.get(output_dir), + warehouse=warehouse_object, ) PLUGIN = OFECommandPlugin( - command=plan_rbfe_network, section="Network Planning", requires_ofe=(0, 3) + command=plan_rbfe_network, section="Planning & Setup", requires_ofe=(0, 3) ) diff --git a/src/openfecli/commands/plan_rhfe_network.py b/src/openfecli/commands/plan_rhfe_network.py index 5b4ebf1ac..b1e0a99c7 100644 --- a/src/openfecli/commands/plan_rhfe_network.py +++ b/src/openfecli/commands/plan_rhfe_network.py @@ -216,5 +216,5 @@ def plan_rhfe_network( PLUGIN = OFECommandPlugin( - command=plan_rhfe_network, section="Network Planning", requires_ofe=(0, 3) + command=plan_rhfe_network, section="Planning & Setup", requires_ofe=(0, 3) ) diff --git a/src/openfecli/commands/quickrun.py b/src/openfecli/commands/quickrun.py index 677552435..f8aa68277 100644 --- a/src/openfecli/commands/quickrun.py +++ b/src/openfecli/commands/quickrun.py @@ -203,7 +203,7 @@ def quickrun(transformation, work_dir, output, resume): ) -PLUGIN = OFECommandPlugin(command=quickrun, section="Quickrun Executor", requires_ofe=(0, 3)) +PLUGIN = OFECommandPlugin(command=quickrun, section="Execution", requires_ofe=(0, 3)) if __name__ == "__main__": quickrun() diff --git a/src/openfecli/commands/status.py b/src/openfecli/commands/status.py new file mode 100644 index 000000000..931cb74d2 --- /dev/null +++ b/src/openfecli/commands/status.py @@ -0,0 +1,76 @@ +# This code is part of OpenFE and is licensed under the MIT license. +# For details, see https://github.com/OpenFreeEnergy/openfe + +import pathlib + +import click + +from openfecli import OFECommandPlugin +from openfecli.utils import rich_print_to_stdout + + +def status_main( + task_db_path: pathlib.Path, +): + """ + Parameters + ---------- + task_db_path : pathlib.Path + Path to a task.db + + Example + ------- + > openfe status task.db + + ┌─────────────────────────────┬──────────────────┬─────────────────────┬───────┬───────────┐ + │ task_id │ status │ last_modified │ tries │ max_tries │ + ├─────────────────────────────┼──────────────────┼─────────────────────┼───────┼───────────┤ + │ SetupUnit-d568ebe569b445c7… │ COMPLETED │ 2026-08-14 11:19:16 │ 1 │ 3 │ + │ SetupUnit-17dc05e0d79747e7… │ COMPLETED │ 2026-08-14 11:19:21 │ 1 │ 3 │ + │ SetupUnit-78321eda905c4c2c… │ COMPLETED │ 2026-08-14 11:19:22 │ 1 │ 3 │ + │ SetupUnit-0238f65b55044b1e… │ COMPLETED │ 2026-08-14 11:19:22 │ 1 │ 3 │ + │ MultiStateSimulationUnit-2… │ COMPLETED │ 2026-08-14 11:25:10 │ 1 │ 3 │ + │ MultiStateSimulationUnit-1… │ COMPLETED │ 2026-08-14 11:25:34 │ 1 │ 3 │ + │ MultiStateSimulationUnit-f… │ COMPLETED │ 2026-08-14 11:26:22 │ 1 │ 3 │ + │ MultiStateSimulationUnit-c… │ TOO_MANY_RETRIES │ 2026-08-14 11:26:24 │ 3 │ 3 │ + │ MultiStateAnalysisUnit-a72… │ COMPLETED │ 2026-08-14 11:26:51 │ 1 │ 3 │ + │ MultiStateAnalysisUnit-e44… │ COMPLETED │ 2026-08-14 11:26:26 │ 1 │ 3 │ + │ MultiStateAnalysisUnit-7e9… │ COMPLETED │ 2026-08-14 11:29:07 │ 1 │ 3 │ + │ MultiStateAnalysisUnit-72c… │ BLOCKED │ NaT │ 0 │ 3 │ + └─────────────────────────────┴──────────────────┴─────────────────────┴───────┴───────────┘ + + """ + + from exorcist import TaskStatusDB + + from openfe.orchestration import get_task_df + + # TODO: rewrite this using just sql and rich table + task_db = TaskStatusDB.from_filename(task_db_path) + task_df = get_task_df(task_db) + task_df["last_modified"] = task_df["last_modified"].dt.floor("s") + # TODO: add task_type back in once it's used + rich_print_to_stdout(task_df.drop("task_type", axis=1)) + + +@click.command("status", short_help="Output the status of the task database as a table.") +@click.argument( + "task_db_path", + type=click.Path( + exists=True, + readable=True, + file_okay=True, + dir_okay=False, + path_type=pathlib.Path, + ), +) +def status(task_db_path: pathlib.Path): + """ + Show the status of a task.db as a table. + + + """ + status_main(task_db_path=task_db_path) + + +PLUGIN = OFECommandPlugin(command=status, section="Execution", requires_ofe=(1, 13)) diff --git a/src/openfecli/commands/view_ligand_network.py b/src/openfecli/commands/view_ligand_network.py index 24125907a..0024cb8e1 100644 --- a/src/openfecli/commands/view_ligand_network.py +++ b/src/openfecli/commands/view_ligand_network.py @@ -33,6 +33,6 @@ def view_ligand_network(ligand_network: os.PathLike): PLUGIN = OFECommandPlugin( command=view_ligand_network, - section="Network Planning", + section="Planning & Setup", requires_ofe=(0, 7, 0), ) diff --git a/src/openfecli/commands/worker.py b/src/openfecli/commands/worker.py new file mode 100644 index 000000000..791b6d2c1 --- /dev/null +++ b/src/openfecli/commands/worker.py @@ -0,0 +1,133 @@ +# This code is part of OpenFE and is licensed under the MIT license. +# For details, see https://github.com/OpenFreeEnergy/openfe + +import pathlib + +import click + +from openfecli import OFECommandPlugin +from openfecli.utils import configure_logger, print_duration, write + + +def _build_worker(warehouse_path: pathlib.Path, db_path: pathlib.Path): + from openfe.orchestration import Worker + from openfe.storage.warehouse import FileSystemWarehouse + + warehouse = FileSystemWarehouse(str(warehouse_path)) + return Worker(warehouse=warehouse, task_db_path=db_path) + + +def _write_failure_result_details(taskid: str, result) -> None: + source_key = getattr(result, "source_key", None) + exception = getattr(result, "exception", None) + traceback_text = getattr(result, "traceback", None) + + write(f"Task '{taskid}' returned a failure result.") + if source_key is not None: + write(f"Failed unit source key: {source_key}") + + if isinstance(exception, tuple) and len(exception) == 2: + exc_type, exc_args = exception + write(f"Protocol unit exception: {exc_type}: {exc_args}") + + if isinstance(traceback_text, str) and traceback_text: + write("Protocol unit traceback:") + write(traceback_text) + + +def worker_main(warehouse_path: pathlib.Path, scratch: pathlib.Path | None): + import logging + import os + import sys + import traceback + + from openfe.utils import logging_control + + # avoid problems with output not showing if queueing system kills a job + sys.stdout.reconfigure(line_buffering=True) + + stdout_handler = logging.StreamHandler(sys.stdout) + + configure_logger("gufekey", handler=stdout_handler) + configure_logger("gufe", handler=stdout_handler) + configure_logger("openfe", handler=stdout_handler) + + # silence the openmmtools.multistate API warning + logging_control._silence_message( + msg=[ + "The openmmtools.multistate API is experimental and may change in future releases", + ], + logger_names=[ + "openmmtools.multistate.multistatereporter", + "openmmtools.multistate.multistateanalyzer", + "openmmtools.multistate.multistatesampler", + ], + ) + # turn warnings into log message (don't show stack trace) + logging.captureWarnings(True) + db_path = warehouse_path / "tasks.db" + if not db_path.is_file(): + raise click.ClickException(f"Task database not found at: {db_path}") + + if scratch is None: + scratch = pathlib.Path.cwd() + + scratch.mkdir(parents=True, exist_ok=True) + + worker = _build_worker(warehouse_path, db_path) + + try: + write("Executing unit...") + execution = worker.execute_unit(scratch=scratch) + except Exception as exc: + write(traceback.format_exc()) + raise click.ClickException(f"Task execution failed: {exc}") from exc + + if execution is None: + write("No available task in task graph.") + return None + + taskid, result = execution + if not result.ok(): + _write_failure_result_details(taskid, result) + raise click.ClickException(f"Task '{taskid}' returned a failure result.") + + write(f"Completed task: {taskid}") + return result + + +@click.command("worker", short_help="Execute one available task from a filesystem warehouse") +@click.argument( + "warehouse_path", + type=click.Path( + exists=True, + readable=True, + file_okay=False, + dir_okay=True, + path_type=pathlib.Path, + ), +) +@click.option( + "--scratch", + "-s", + default=None, + type=click.Path( + writable=True, + file_okay=False, + dir_okay=True, + path_type=pathlib.Path, + ), + help="Directory for scratch files. Defaults to current working directory.", +) +@print_duration +def worker(warehouse_path: pathlib.Path, scratch: pathlib.Path | None): + """ + Execute one available task from a warehouse task graph. + + The warehouse directory must contain a ``tasks.db`` task database and task + payloads under ``tasks/`` created via OpenFE orchestration setup. + """ + worker_main(warehouse_path=warehouse_path, scratch=scratch) + + +PLUGIN = OFECommandPlugin(command=worker, section="Execution", requires_ofe=(1, 13)) diff --git a/src/openfecli/parameters/__init__.py b/src/openfecli/parameters/__init__.py index c25ff4fcb..db3814c33 100644 --- a/src/openfecli/parameters/__init__.py +++ b/src/openfecli/parameters/__init__.py @@ -9,3 +9,4 @@ from .output_dir import OUTPUT_DIR from .plan_network_options import YAML_OPTIONS from .protein import PROTEIN, PROTEIN_MEMBRANE +from .warehouse import WAREHOUSE diff --git a/src/openfecli/parameters/warehouse.py b/src/openfecli/parameters/warehouse.py new file mode 100644 index 000000000..5fb2f07f6 --- /dev/null +++ b/src/openfecli/parameters/warehouse.py @@ -0,0 +1,4 @@ +import click +from plugcli.params import Option + +WAREHOUSE = Option("--warehouse", type=click.BOOL, help="Use a warehouse", default=False) diff --git a/src/openfecli/plan_alchemical_networks_utils.py b/src/openfecli/plan_alchemical_networks_utils.py index 0b50da135..4fe73629d 100644 --- a/src/openfecli/plan_alchemical_networks_utils.py +++ b/src/openfecli/plan_alchemical_networks_utils.py @@ -3,8 +3,12 @@ from __future__ import annotations import pathlib +from pathlib import Path +from typing import Optional from openfe import AlchemicalNetwork, LigandNetwork +from openfe.orchestration.exorcist_utils import build_task_db_from_alchemical_network +from openfe.storage.warehouse import FileSystemWarehouse from openfecli.utils import write @@ -12,26 +16,33 @@ def plan_alchemical_network_output( alchemical_network: AlchemicalNetwork, ligand_network: LigandNetwork, folder_path: pathlib.Path, + warehouse: Optional[FileSystemWarehouse] = None, ): """Write the contents of an alchemical network into the structure""" - base_name = folder_path.name - folder_path.mkdir(parents=True, exist_ok=True) - - an_json = folder_path / f"{base_name}.json" - alchemical_network.to_json(an_json) - write("\t\t- " + base_name + ".json") - - ln_fname = "ligand_network.graphml" - with open(folder_path / ln_fname, mode="w") as f: - f.write(ligand_network.to_graphml()) - write(f"\t\t- {ln_fname}") - - transformations_dir = folder_path / "transformations" - transformations_dir.mkdir(parents=True, exist_ok=True) - - for transformation in alchemical_network.edges: - transformation_name = transformation.name or transformation.key - filename = f"{transformation_name}.json" - transformation.to_json(transformations_dir / filename) - write("\t\t\t\t- " + filename) + if warehouse: + # TODO: update this to match API user experience + _ = build_task_db_from_alchemical_network( + alchemical_network, warehouse_dir="campaign/", db_path="campaign.db" + ) + else: + base_name = folder_path.name + folder_path.mkdir(parents=True, exist_ok=True) + + an_json = folder_path / f"{base_name}.json" + alchemical_network.to_json(an_json) + write("\t\t- " + base_name + ".json") + + ln_fname = "ligand_network.graphml" + with open(folder_path / ln_fname, mode="w") as f: + f.write(ligand_network.to_graphml()) + write(f"\t\t- {ln_fname}") + + transformations_dir = folder_path / "transformations" + transformations_dir.mkdir(parents=True, exist_ok=True) + + for transformation in alchemical_network.edges: + transformation_name = transformation.name or transformation.key + filename = f"{transformation_name}.json" + transformation.to_json(transformations_dir / filename) + write("\t\t\t\t- " + filename) diff --git a/src/openfecli/tests/commands/test_status.py b/src/openfecli/tests/commands/test_status.py new file mode 100644 index 000000000..2cf41be2e --- /dev/null +++ b/src/openfecli/tests/commands/test_status.py @@ -0,0 +1,31 @@ +import exorcist +import networkx as nx +import pytest +from click.testing import CliRunner + +from openfecli.commands.status import status + +from ..utils import assert_click_success + + +@pytest.fixture +def simple_task_graph(): + task_graph = nx.DiGraph() + node_ids = ["HybridTopologySetupUnit-123", "HybridTopologySetupUnit-456"] + + for id in node_ids: + task_graph.add_node(id) + + return task_graph, node_ids + + +def test_status(simple_task_graph): + runner = CliRunner() + with runner.isolated_filesystem(): + task_graph, node_ids = simple_task_graph + db_path = "test.db" + db = exorcist.TaskStatusDB.from_filename(db_path) + db.add_task_network(task_graph, max_tries=6) + result = runner.invoke(status, [db_path]) + assert_click_success(result) + assert all(id in result.stdout for id in node_ids) diff --git a/src/openfecli/tests/commands/test_worker.py b/src/openfecli/tests/commands/test_worker.py new file mode 100644 index 000000000..b060b57e2 --- /dev/null +++ b/src/openfecli/tests/commands/test_worker.py @@ -0,0 +1,143 @@ +from pathlib import Path +from unittest import mock + +from click.testing import CliRunner + +from openfecli.commands.worker import worker + + +class _SuccessfulResult: + def ok(self): + return True + + +class _FailedResult: + def ok(self): + return False + + +class _FailedResultWithDetails: + source_key = "HybridTopologyMultiStateSimulationUnit-deadbeef" + exception = ("RuntimeError", ("simulation blew up",)) + traceback = 'Traceback (most recent call last):\n File "sim.py", line 1\nRuntimeError: simulation blew up' + + def ok(self): + return False + + +def test_worker_requires_task_database(): + runner = CliRunner() + with runner.isolated_filesystem(): + Path("warehouse").mkdir() + result = runner.invoke(worker, ["warehouse"]) + assert result.exit_code == 1 + assert "Task database not found at" in result.output + + +def test_worker_no_available_task_exits_zero(): + runner = CliRunner() + with runner.isolated_filesystem(): + warehouse_path = Path("warehouse") + warehouse_path.mkdir() + (warehouse_path / "tasks.db").touch() + + mock_worker = mock.Mock() + mock_worker.execute_unit.return_value = None + + with mock.patch( + "openfecli.commands.worker._build_worker", return_value=mock_worker + ) as build_worker: + result = runner.invoke(worker, ["warehouse"]) + + assert result.exit_code == 0 + assert "No available task in task graph." in result.output + build_worker.assert_called_once_with(warehouse_path, warehouse_path / "tasks.db") + kwargs = mock_worker.execute_unit.call_args.kwargs + assert kwargs["scratch"] == Path.cwd() + + +def test_worker_executes_one_task_and_reports_completion(): + runner = CliRunner() + with runner.isolated_filesystem(): + warehouse_path = Path("warehouse") + warehouse_path.mkdir() + (warehouse_path / "tasks.db").touch() + + mock_worker = mock.Mock() + mock_worker.execute_unit.return_value = ( + "Transformation-abc:ProtocolUnit-def", + _SuccessfulResult(), + ) + + with mock.patch("openfecli.commands.worker._build_worker", return_value=mock_worker): + result = runner.invoke(worker, ["warehouse", "--scratch", "scratch"]) + + assert result.exit_code == 0 + assert "Completed task: Transformation-abc:ProtocolUnit-def" in result.output + assert Path("scratch").is_dir() + kwargs = mock_worker.execute_unit.call_args.kwargs + assert kwargs["scratch"] == Path("scratch") + + +def test_worker_raises_when_result_is_failure(): + runner = CliRunner() + with runner.isolated_filesystem(): + warehouse_path = Path("warehouse") + warehouse_path.mkdir() + (warehouse_path / "tasks.db").touch() + + mock_worker = mock.Mock() + mock_worker.execute_unit.return_value = ( + "Transformation-abc:ProtocolUnit-def", + _FailedResult(), + ) + + with mock.patch("openfecli.commands.worker._build_worker", return_value=mock_worker): + result = runner.invoke(worker, ["warehouse"]) + + assert result.exit_code == 1 + assert "returned a failure result" in result.output + + +def test_worker_prints_failure_result_details_when_available(): + runner = CliRunner() + with runner.isolated_filesystem(): + warehouse_path = Path("warehouse") + warehouse_path.mkdir() + (warehouse_path / "tasks.db").touch() + + mock_worker = mock.Mock() + mock_worker.execute_unit.return_value = ( + "Transformation-abc:ProtocolUnit-def", + _FailedResultWithDetails(), + ) + + with mock.patch("openfecli.commands.worker._build_worker", return_value=mock_worker): + result = runner.invoke(worker, ["warehouse"]) + + assert result.exit_code == 1 + assert ( + "Failed unit source key: HybridTopologyMultiStateSimulationUnit-deadbeef" + in result.output + ) + assert "Protocol unit exception: RuntimeError: ('simulation blew up',)" in result.output + assert "Protocol unit traceback:" in result.output + + +def test_worker_raises_when_execution_throws(): + runner = CliRunner() + with runner.isolated_filesystem(): + warehouse_path = Path("warehouse") + warehouse_path.mkdir() + (warehouse_path / "tasks.db").touch() + + mock_worker = mock.Mock() + mock_worker.execute_unit.side_effect = RuntimeError("boom") + + with mock.patch("openfecli.commands.worker._build_worker", return_value=mock_worker): + result = runner.invoke(worker, ["warehouse"]) + + assert result.exit_code == 1 + assert "Traceback (most recent call last):" in result.output + assert "RuntimeError: boom" in result.output + assert "Task execution failed: boom" in result.output diff --git a/src/openfecli/tests/test_cli.py b/src/openfecli/tests/test_cli.py index 8c13ac8e7..421a2aed9 100644 --- a/src/openfecli/tests/test_cli.py +++ b/src/openfecli/tests/test_cli.py @@ -50,7 +50,7 @@ def test_command_sections(self, cli): # This test does not ensure the order of the sections, and does not # prevent other sections from being added later. It only ensures # that the main 4 sections continue to exist. - included = ["Network Planning", "Quickrun Executor", "Miscellaneous"] + included = ["Planning & Setup", "Execution", "Results Gathering", "Miscellaneous"] for sec in included: assert sec in cli.COMMAND_SECTIONS diff --git a/src/openfecli/utils.py b/src/openfecli/utils.py index 6e7570c83..f50a10ec1 100644 --- a/src/openfecli/utils.py +++ b/src/openfecli/utils.py @@ -8,6 +8,7 @@ from typing import Callable, Optional import click +import pandas as pd def import_thing(import_string: str): @@ -121,3 +122,23 @@ def wrapper(*args, **kwargs): return result return wrapper + + +def rich_print_to_stdout(df: pd.DataFrame) -> None: + """Use rich to pretty print a table to stdout.""" + + from rich import box + from rich.console import Console + from rich.table import Table + + table = Table(box=box.SQUARE) + + for col in df.columns: + table.add_column(col) + + for row_values in df.values: + row = [str(val) for val in row_values] + table.add_row(*row) + + console = Console() + console.print(table)