From 21265dc36eb33138703d93b448fb1d4bcc63cd72 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 13 Aug 2026 13:19:55 +0200 Subject: [PATCH 001/117] Record the decision to move the network topology layer to mikeio1d Reopens the question ecomodeller raised on #694, with the seam set where NetworkModelResult already draws it: modelskill keeps the comparer-facing classes, mikeio1d gets the formats, the graph and the Network class itself. Co-Authored-By: Claude Opus 5 --- adr/013-network-topology-in-mikeio1d.md | 44 +++++++++++++++++++++++++ adr/README.md | 1 + 2 files changed, 45 insertions(+) create mode 100644 adr/013-network-topology-in-mikeio1d.md diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md new file mode 100644 index 000000000..ea00f430e --- /dev/null +++ b/adr/013-network-topology-in-mikeio1d.md @@ -0,0 +1,44 @@ +# ADR-013: The Network Topology Layer Belongs to mikeio1d + +**Status**: Draft + +**Date**: 2026-08 + +## Context + +`modelskill.network` grew into a topology layer of its own: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, a table of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. Roughly 630 code lines, against 25 for mikeio1d's `experimental.to_networkx`, which converts the same file and ignores gridpoints. + +Most of that difference is work the upstream function declines to do rather than work done twice. But the layer sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp`, `network_chinese.res1d` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses four things from `Network` and never traverses the graph. + +## Decision + +mikeio1d gains an optional network module that builds and owns `Network`. modelskill requires it and consumes what it produces. + +| Owner | Pieces | +|---|---| +| mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `from_mike`/`from_epanet`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | +| modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | + +`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` travels with the class rather than leaving a stub behind. modelskill's `networks` extra requires a mikeio1d release new enough to contain it. + +Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index — they exist because the ID space is mixed and a tuple cannot be an xarray coordinate value, not because anyone should type one. A saved comparer records the original ID beside the integer, so reloading it does not depend on the numbering the installed mikeio1d happened to hand out. + +The move is verified rather than trusted: the current loader's output over every fixture is snapshotted first — graph edges with their lengths and boundary flags, the alias map, the dataframe, the answers `find` and `recall` give — and those snapshots become the upstream module's acceptance test. Code moves verbatim before it is cleaned up. Neither project releases the feature until both can: modelskill 1.4.0 waits for the mikeio1d release that carries the module. + +## Alternatives Considered + +**Keep the layer here.** Defensible while the API is private, but it means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform — and taking a CI failure when someone else's release adds a format. + +**Move only the constructors and companions**, leaving the graph and the abstract types here. Splits the format knowledge from the topology it produces, and leaves `Res1DReach` here as the single adapter for a plug point with no second implementation. + +**A separate `modelskill-network` package.** Rejected in ADR-010 for fragmenting the install, and it would still own format knowledge that mikeio1d has better. + +**Ask mikeio1d to guarantee stable node numbering** instead of dropping integers from our API. Puts a promise on someone else's release process to protect a number users should never have been handling. + +## Consequences + +- ADR-012 is narrowed: the constructors, the companion arguments and the extension tables it describes become mikeio1d's, and the coverage test goes with them. Its reasoning about naming constructors after products still holds — upstream is simply where it now applies. +- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `networks` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. +- A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend nobody has written. +- Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Cheap now, expensive after 1.4.0. +- Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule, not ours. In exchange, a format mikeio1d adds no longer breaks our CI. diff --git a/adr/README.md b/adr/README.md index 59b6d3bf2..48939a2ea 100644 --- a/adr/README.md +++ b/adr/README.md @@ -31,6 +31,7 @@ Each ADR follows this structure: - [ADR-010](010-optional-domain-dependencies.md) - Optional dependencies for domain-specific model types (Draft) - [ADR-011](011-vertical-pre-extracted-columns.md) - VerticalModelResult ingests pre-extracted columns - [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (Draft) +- [ADR-013](013-network-topology-in-mikeio1d.md) - The network topology layer belongs to mikeio1d (Draft) ## Contributing From 9d3d1c64a4e350cbc030229b70fef1050c2bbd3b Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 13 Aug 2026 13:20:17 +0200 Subject: [PATCH 002/117] Note the proposed move to mikeio1d in the network roadmap entry Co-Authored-By: Claude Opus 5 --- roadmap/features/network-models.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/roadmap/features/network-models.md b/roadmap/features/network-models.md index 2190befb9..e6993e05e 100644 --- a/roadmap/features/network-models.md +++ b/roadmap/features/network-models.md @@ -26,3 +26,5 @@ In active development. MIKE 1D, MIKE 11 and EPANET result files can be read toda MOUSE and Water Hammer results are not read yet: no shareable result file exists for either format, so support cannot be verified. SWMM results are not read yet: the reach connectivity lives in the companion '.inp' input file, which modelskill does not read yet. +The layer that reads those files and builds the network is proposed for mikeio1d rather than modelskill, where the formats, the fixtures and a first graph conversion already live (ADR-013). ModelSkill would keep the model result, the observations and the matching, and require the upstream module. The release is coordinated with it: this feature ships once both projects can ship, so that nothing is published here which then moves. + From 4c8e92d9b1133651674d394d5a288fc3905f44df Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 15:30:58 +0200 Subject: [PATCH 003/117] Accept ADR-013 now that the upstream module exists Phase 1 landed as mikeio1d #247, so the decision is no longer a proposal: the module is built upstream and the Phase 0 snapshots pass against it. Co-Authored-By: Claude Opus 5 --- adr/013-network-topology-in-mikeio1d.md | 4 +++- adr/README.md | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md index ea00f430e..acc444dbf 100644 --- a/adr/013-network-topology-in-mikeio1d.md +++ b/adr/013-network-topology-in-mikeio1d.md @@ -1,6 +1,6 @@ # ADR-013: The Network Topology Layer Belongs to mikeio1d -**Status**: Draft +**Status**: Accepted **Date**: 2026-08 @@ -25,6 +25,8 @@ Original IDs become the only identifier a user handles: `NodeObservation.at` tak The move is verified rather than trusted: the current loader's output over every fixture is snapshotted first — graph edges with their lengths and boundary flags, the alias map, the dataframe, the answers `find` and `recall` give — and those snapshots become the upstream module's acceptance test. Code moves verbatim before it is cleaned up. Neither project releases the feature until both can: modelskill 1.4.0 waits for the mikeio1d release that carries the module. +Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The six snapshots pass there unchanged: first against the code moved verbatim, then again after the entry points collapsed into a single `Network.open`. That second pass is what says the redesign changed no behaviour. The module is still unreleased, so the version pin this decision requires waits on mikeio1d's next release. + ## Alternatives Considered **Keep the layer here.** Defensible while the API is private, but it means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform — and taking a CI failure when someone else's release adds a format. diff --git a/adr/README.md b/adr/README.md index 48939a2ea..6ce0ae2d4 100644 --- a/adr/README.md +++ b/adr/README.md @@ -31,7 +31,7 @@ Each ADR follows this structure: - [ADR-010](010-optional-domain-dependencies.md) - Optional dependencies for domain-specific model types (Draft) - [ADR-011](011-vertical-pre-extracted-columns.md) - VerticalModelResult ingests pre-extracted columns - [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (Draft) -- [ADR-013](013-network-topology-in-mikeio1d.md) - The network topology layer belongs to mikeio1d (Draft) +- [ADR-013](013-network-topology-in-mikeio1d.md) - The network topology layer belongs to mikeio1d ## Contributing From c9dc5b127c047e88a14fb3f998e69d7c44f01dea Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 15:40:38 +0200 Subject: [PATCH 004/117] Locate network observations with a MIKE+ database A network result file identifies nodes and reaches by ID, but observations are usually recorded against real-world station names held in the MIKE+ setup database. Read that sqlite database to resolve a station to the node or reach it sits on, so observations can be placed without hand-mapping every ID. The resolver is one class in obs.py rather than a module of its own: everything MIKE+ specific -- the table names, the join, the locationtype codes, the encoding of resitemname -- sits in one class body, and its only caller is a few lines below it. It returns a list of _Station rather than a DataFrame with five agreed column names, so the contract is in the type. Dataset variables also gain a long_name attribute, so a quantity keeps its label once it reaches xarray. Co-Authored-By: Claude Opus 5 --- src/modelskill/model/network.py | 7 + src/modelskill/network.py | 7 +- src/modelskill/obs.py | 623 +++++++++++++++++++++++++++++++- tests/test_mikeplus.py | 478 ++++++++++++++++++++++++ tests/test_network.py | 97 ++++- 5 files changed, 1199 insertions(+), 13 deletions(-) create mode 100644 tests/test_mikeplus.py diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 328c1cdea..fd290d9b2 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -144,6 +144,13 @@ def __init__( if quantity is None: da = self.data[sel_items.values] quantity = Quantity.from_cf_attrs(da.attrs) + if quantity == Quantity.undefined(): + # A network knows its quantity by name even when no unit + # travels with the data -- res1d and EPANET files carry the + # name only. Quantity.from_cf_attrs needs both, so fall back to + # the name alone rather than reporting nothing at all. + name = da.attrs.get("long_name") or str(sel_items.values) + quantity = Quantity(name=name, unit="") self.quantity = quantity # Mark data variables as model data diff --git a/src/modelskill/network.py b/src/modelskill/network.py index 4487c5809..90f288b05 100644 --- a/src/modelskill/network.py +++ b/src/modelskill/network.py @@ -902,7 +902,12 @@ def to_dataset(self) -> xr.Dataset: df = df_raw.reorder_levels(["quantity", "node"], axis=1) quantities = df.columns.get_level_values("quantity").unique() return xr.Dataset( - {q: xr.DataArray(df[q], dims=["time", "node"]) for q in quantities} + { + q: xr.DataArray( + df[q], dims=["time", "node"], attrs={"long_name": str(q)} + ) + for q in quantities + } ) @property diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index e06b79858..f169b0553 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -1,19 +1,30 @@ """ # Observations -ModelSkill supports four types of observations: +ModelSkill supports five types of observations: * [`PointObservation`](`modelskill.PointObservation`) - a point timeseries from a dfs0/nc file or a DataFrame * [`TrackObservation`](`modelskill.TrackObservation`) - a track (moving point) timeseries from a dfs0/nc file or a DataFrame * [`VerticalObservation`](`modelskill.VerticalObservation`) - a vertical profile from a dfs0/nc file or a DataFrame * [`NodeObservation`](`modelskill.NodeObservation`) - a network node timeseries for specific node IDs. +* [`ReachObservation`](`modelskill.ReachObservation`) - a network reach timeseries for a quantity uniform along the reach. An observation can be created by explicitly invoking one of the above classes or using the [`observation()`](`modelskill.observation`) function which will return the appropriate type based on the input data (if possible). """ from __future__ import annotations -from typing import Literal, Any, Union, overload +import sqlite3 +from pathlib import Path +from typing import ( + Any, + Iterable, + Literal, + NamedTuple, + Sequence, + Union, + overload, +) from typing_extensions import Self import warnings import pandas as pd @@ -34,6 +45,10 @@ # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file Serializable = Union[str, int, float] +# Where a node observation sits: an internal network ID, an original node alias, +# or a breakpoint given as (reach_id, distance) along a reach. +NodeLocation = Union[int, str, tuple[str, float]] + def observation( data: DataInputType, @@ -113,6 +128,339 @@ def _guess_gtype(**kwargs) -> GeometryType: return GeometryType.POINT +def _item_names(data: Any) -> list[str]: + """Names of the individual timeseries held by an already-opened data source.""" + if isinstance(data, pd.DataFrame): + return [str(c) for c in data.columns] + if isinstance(data, xr.Dataset): + return [str(v) for v in data.data_vars] + if hasattr(data, "names"): # mikeio.Dataset + return [str(n) for n in data.names] + if hasattr(data, "name"): # pd.Series, mikeio.DataArray, xr.DataArray + return [str(data.name)] + raise ValueError( + f"Cannot determine item names from data of type {type(data).__name__}" + ) + + +class _Station(NamedTuple): + """One measured timeseries, resolved to the network location it belongs to.""" + + item_name: str #: name of the item in the data source + name: str #: display name for the observation + location: str | tuple[str, float] #: node name, or (reach, chainage) + kind: Literal["node", "reach"] #: which observation class fits + quantity: str #: modelled quantity name + + +class _MikePlusStationResolver: + """Resolves data source items to network locations, via a MIKE+ database. + + A MIKE+ project ships a sqlite database alongside its result files. Two of + its tables say where the measured timeseries belong in the network: + + * ``m_Measurement`` - one row per measured timeseries, naming the file + (``tsfilename``) and the item within it (``tsitemname``), plus the + modelled quantity (``resitemname``). + * ``m_Station`` - the location, as ``locationid`` plus a ``locationtype`` + saying whether that identifier names a node or a link. + + Everything MIKE+ specific is contained here - the table names, the join, the + ``locationtype`` codes, the encoding of ``resitemname`` - so a change to the + database layout is a change to this class alone. Callers see only + :class:`_Station`. + """ + + _TABLES: dict[str, set[str]] = { + "m_Station": { + "muid", + "locationid", + "locationtype", + "chainagevalue", + "assetname", + }, + "m_Measurement": { + "measurementstationid", + "tsfilename", + "tsitemname", + "resitemname", + }, + } + + # m_Station.locationtype codes. 8 is a junction and 12 a tank or reservoir; + # both are graph nodes. 9 is a link, which becomes a breakpoint when the + # station carries a chainage and a whole reach when it does not. Unknown + # codes raise rather than guess. + _NODE_TYPES = frozenset({8, 12}) + _LINK_TYPES = frozenset({9}) + + _QUERY = """ + SELECT m.tsitemname AS item_name, + m.tsfilename AS tsfilename, + m.resitemname AS resitemname, + s.assetname AS assetname, + s.locationid AS locationid, + s.locationtype AS locationtype, + s.chainagevalue AS chainagevalue + FROM m_Measurement m + JOIN m_Station s ON s.muid = m.measurementstationid + """ + + def __init__( + self, + db: str | Path | sqlite3.Connection, + *, + source: str | None = None, + ) -> None: + """Read the join, and the station names needed to explain a failure. + + ``db`` is a path or an already-open connection; an open one is left open. + ``source`` restricts the measurements to one result file, matched on file + name, so a full path is fine. Without it, measurements from every file + are considered and an item registered against two of them raises. + """ + self._source = source + + if isinstance(db, sqlite3.Connection): + conn, opened = db, None + else: + conn = opened = sqlite3.connect(str(db)) + try: + self._validate(conn) + + query, params = self._QUERY, [] + if source is not None: + query += " WHERE m.tsfilename LIKE ?" + params.append(f"%{Path(source).name}%") + rows = pd.read_sql_query(query, conn, params=params) + + # Read the station names now rather than on demand: the only other + # use is naming stations that carry no measurement, on the failure + # path, and reading them here is what lets the connection close. + self._assets = set( + pd.read_sql_query("SELECT assetname FROM m_Station", conn)["assetname"] + .dropna() + .tolist() + ) + finally: + if opened is not None: + opened.close() + + rows["quantity"] = rows["resitemname"].str.split(";").str[0].str.strip() + self._rows = rows + + def resolve( + self, + item_names: Iterable[str], + *, + quantity: str | None = None, + kind: Literal["node", "reach"] | None = None, + on_missing: Literal["raise", "skip"] = "raise", + ) -> list[_Station]: + """Resolve item names, e.g. the columns of a dfs0, to their locations. + + ``quantity`` selects one of several measured quantities; left None it is + inferred, and raises when the selection holds more than one. ``kind`` + restricts the result to nodes or to reaches. ``on_missing="skip"`` drops + items the database does not register, which otherwise raise. + """ + requested = list(dict.fromkeys(item_names)) + rows = self._rows[self._rows["item_name"].isin(requested)].copy() + + missing = [item for item in requested if item not in set(rows["item_name"])] + if missing and on_missing == "raise": + raise ValueError( + f"{len(missing)} of {len(requested)} items could not be resolved " + f"against the MIKE+ database.\n" + + self._unresolved_message(missing) + + '\n Pass on_missing="skip" to ignore these.' + ) + + if ambiguous := sorted( + rows.loc[rows.duplicated("item_name", keep=False), "item_name"].unique() + ): + raise ValueError( + f"Item(s) {ambiguous} are registered against more than one file. " + "Pass 'source' to say which file the data comes from." + ) + + if rows.empty: + raise ValueError("No items could be resolved against the MIKE+ database.") + + located = rows.apply(self._location, axis=1) + rows["kind"] = [k for k, _ in located] + rows["location"] = [location for _, location in located] + + if quantity is None: + pool = rows if kind is None else rows[rows["kind"] == kind] + available = sorted(pool["quantity"].unique()) + if len(available) == 0: + raise ValueError( + f"No {kind} locations found. Quantities present: " + f"{rows['quantity'].value_counts().to_dict()}." + ) + if len(available) > 1: + raise ValueError( + "Several quantities present, so 'quantity' cannot be inferred: " + f"{pool['quantity'].value_counts().to_dict()}. " + f"Pass one of {available}." + ) + quantity = available[0] + + selection = rows[rows["quantity"] == quantity] + if selection.empty: + raise ValueError( + f"Quantity {quantity!r} not found. Available: " + f"{rows['quantity'].value_counts().to_dict()}." + ) + + if kind is not None: + of_kind = selection[selection["kind"] == kind] + if of_kind.empty: + other = sorted(selection["kind"].unique()) + raise ValueError( + f"All {len(selection)} {quantity!r} station(s) are of kind " + f"{other}, not {kind!r}." + ) + selection = of_kind + + names = self._display_names(selection) + return [ + _Station( + item_name=str(row.item_name), + name=str(name), + location=row.location, + kind=row.kind, + quantity=str(row.quantity), + ) + for name, row in zip(names, selection.itertuples()) + ] + + def _validate(self, conn: sqlite3.Connection) -> None: + tables = { + row[0] + for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'") + } + if missing := sorted(set(self._TABLES) - tables): + raise ValueError( + f"Database is missing table(s) {missing}. " + "A MIKE+ database with 'm_Station' and 'm_Measurement' is required." + ) + for table, required in self._TABLES.items(): + columns = {row[1] for row in conn.execute(f"PRAGMA table_info([{table}])")} + if missing_cols := sorted(required - columns): + raise ValueError( + f"Table '{table}' is missing column(s) {missing_cols}. " + "The database layout is not the one modelskill expects." + ) + + def _location(self, row: pd.Series) -> tuple[str, str | tuple[str, float]]: + # A link station with a chainage names a point along a reach, which is a + # node observation at a breakpoint. Without a chainage it names the reach + # as a whole. + try: + location_type = int(row["locationtype"]) + except (TypeError, ValueError): + location_type = -1 + + location_id = str(row["locationid"]) + if location_type in self._NODE_TYPES: + return "node", location_id + if location_type in self._LINK_TYPES: + chainage = row["chainagevalue"] + if pd.isna(chainage): + return "reach", location_id + return "node", (location_id, float(chainage)) + + raise ValueError( + f"Station '{row['locationid']}' has unsupported locationtype " + f"{row['locationtype']!r}. Known codes are " + f"{sorted(self._NODE_TYPES | self._LINK_TYPES)}." + ) + + def _unresolved_message(self, missing: Sequence[str]) -> str: + known = [item for item in missing if item in self._assets] + unknown = [item for item in missing if item not in self._assets] + + lines = [] + if known: + where = f" for '{Path(self._source).name}'" if self._source else "" + lines.append( + f" Known station, no measurement registered{where} ({len(known)}):\n" + + "\n".join(f" {item}" for item in known) + ) + if unknown: + lines.append( + f" Not found in the database ({len(unknown)}):\n" + + "\n".join(f" {item}" for item in unknown) + ) + return "\n".join(lines) + + @staticmethod + def _display_names(selection: pd.DataFrame) -> pd.Series: + # assetname is far shorter than the raw item name and is normally unique, + # but it is only safe as a display name when it distinguishes every row. + assets = selection["assetname"] + if assets.notna().all() and assets.nunique() == len(selection): + return assets.astype(str) + return selection["item_name"].astype(str) + + +def _observations_from_mikeplus( + cls: type, + *, + data: PointType, + db: Any, + kind: Literal["node", "reach"], + location_arg: str, + quantity: Quantity | str | None, + source: str | None, + on_missing: Literal["raise", "skip"], + aux_items: list[int | str] | None, + attrs: dict | None, +) -> list[Any]: + """Build observations from a data source and a MIKE+ database.""" + from .timeseries._point import _open_and_name + + if source is None and isinstance(data, (str, Path)): + source = str(data) + + # Open once rather than per observation; a path would otherwise be re-read + # for every station in the database. + opened, _ = _open_and_name(data, None) + + given_quantity = quantity if isinstance(quantity, Quantity) else None + wanted = quantity.name if isinstance(quantity, Quantity) else quantity + + stations = _MikePlusStationResolver(db, source=source).resolve( + _item_names(opened), + quantity=wanted, + kind=kind, + on_missing=on_missing, + ) + + observations = [] + for station in stations: + obs = cls( + opened, + item=station.item_name, + name=station.name, + quantity=given_quantity, + aux_items=aux_items, + attrs=attrs, + **{location_arg: station.location}, + ) + if given_quantity is None: + # The database names the quantity; the data source knows its unit. + obs.quantity = Quantity( + name=station.quantity, + unit=obs.quantity.unit, + is_directional=obs.quantity.is_directional, + ) + observations.append(obs) + return observations + + def _validate_attrs(data_attrs: dict, attrs: dict | None) -> None: # See similar method in xarray https://github.com/pydata/xarray/blob/main/xarray/backends/api.py#L165 @@ -595,7 +943,7 @@ def from_multiple( cls, *, data: PointType, - nodes: dict[int, str | int], + nodes: dict[NodeLocation, str | int], quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, @@ -606,20 +954,37 @@ def from_multiple( def from_multiple( cls, *, - nodes: dict[int, PointType], + nodes: dict[NodeLocation, PointType], quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[NodeObservation]: pass + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + db: str | Path | Any, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[NodeObservation]: ... + @classmethod def from_multiple( cls, *, data: PointType | None = None, - nodes: dict[int, Any] | None = None, - quantity: Quantity | None = None, + nodes: dict[NodeLocation, Any] | None = None, + db: str | Path | Any | None = None, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[NodeObservation]: @@ -638,14 +1003,41 @@ def from_multiple( obs = NodeObservation.from_multiple(data=df, nodes={123: "col_a", 456: "col_b"}) + 3. **MIKE+ database** — pass a single ``data`` object together with + ``db``, and the locations are looked up in the database:: + + obs = NodeObservation.from_multiple(data="calib.dfs0", db="model.sqlite") + + One observation is created per item of ``data`` that the database + places on a node, so several sensors at the same node are all kept. + Parameters ---------- data : PointType, optional - Shared data source (required when ``nodes`` values are column selectors). - nodes : dict[int, PointType | str | int] - Mapping of node_id -> data source or column selector. - quantity : Quantity | None, optional - Physical quantity metadata, by default None. + Shared data source (required when ``nodes`` values are column + selectors, and when ``db`` is given). + nodes : dict[int | str | tuple[str, float], PointType | str | int] + Mapping of location -> data source or column selector. A location + takes any of the forms accepted by ``at``: an internal network ID, + a node alias, or a ``(reach_id, distance)`` breakpoint. + + Note that a location can appear only once, so this form cannot + express several observations at the same node. Use ``db`` when the + data has several sensors at one location. + db : str, Path or sqlite3.Connection, optional + MIKE+ database locating the items of ``data`` in the network. + Mutually exclusive with ``nodes``. + quantity : Quantity or str, optional + Physical quantity metadata, by default None. With ``db``, a string + selects which quantity to build observations for and the metadata + comes from the database; omit it and the quantity is inferred when + the data holds only one. + source : str, optional + With ``db``, the file the items come from. Taken from ``data`` when + that is a path, by default None. + on_missing : {"raise", "skip"}, optional + With ``db``, what to do with items the database cannot place, by + default "raise". aux_items : list[int | str] | None, optional Auxiliary items, by default None. attrs : dict | None, optional @@ -655,7 +1047,39 @@ def from_multiple( ------- list[NodeObservation] List of NodeObservation objects. + + Raises + ------ + ValueError + If both ``nodes`` and ``db`` are given, if neither is, or if the + database cannot resolve the requested items. """ + if db is not None: + if nodes is not None: + raise ValueError( + "'nodes' and 'db' are mutually exclusive: the database " + "supplies the locations." + ) + if data is None: + raise ValueError("'data' is required when 'db' is given") + return _observations_from_mikeplus( + cls, + data=data, + db=db, + kind="node", + location_arg="at", + quantity=quantity, + source=source, + on_missing=on_missing, + aux_items=aux_items, + attrs=attrs, + ) + + if isinstance(quantity, str): + raise TypeError( + "'quantity' must be a Quantity unless 'db' is given, got str" + ) + if nodes is None: raise ValueError("'nodes' argument is required") if not isinstance(nodes, dict): @@ -764,6 +1188,183 @@ def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" return self.__class__(data, reach=str(data.coords["reach"].item())) + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + reaches: dict[str, str | int], + quantity: Quantity | None = None, + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: ... + + @overload + @classmethod + def from_multiple( + cls, + *, + reaches: dict[str, PointType], + quantity: Quantity | None = None, + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: + pass + + @overload + @classmethod + def from_multiple( + cls, + *, + data: PointType, + db: str | Path | Any, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: ... + + @classmethod + def from_multiple( + cls, + *, + data: PointType | None = None, + reaches: dict[str, Any] | None = None, + db: str | Path | Any | None = None, + quantity: Quantity | str | None = None, + source: str | None = None, + on_missing: Literal["raise", "skip"] = "raise", + aux_items: list[int | str] | None = None, + attrs: dict | None = None, + ) -> list[ReachObservation]: + """Create multiple ReachObservation objects. + + Two calling conventions are supported: + + 1. **Separate data sources** — pass only ``reaches`` as a dict mapping + each reach ID to its own data source (file path, DataFrame, etc.):: + + obs = ReachObservation.from_multiple(reaches={"r1": df1, "r2": "sensor.csv"}) + + 2. **Shared data source** — pass a single ``data`` object together with + ``reaches`` as a dict mapping each reach ID to the column name or + index to select from ``data``:: + + obs = ReachObservation.from_multiple(data=df, reaches={"r1": "col_a", "r2": "col_b"}) + + 3. **MIKE+ database** — pass a single ``data`` object together with + ``db``, and the reaches are looked up in the database:: + + obs = ReachObservation.from_multiple(data="calib.dfs0", db="model.sqlite") + + One observation is created per item of ``data`` that the database + places on a link without a chainage. + + Parameters + ---------- + data : PointType, optional + Shared data source (required when ``reaches`` values are column + selectors, and when ``db`` is given). + reaches : dict[str, PointType | str | int] + Mapping of reach_id -> data source or column selector. + + Note that a reach can appear only once, so this form cannot express + several observations on the same reach. Use ``db`` when the data has + several sensors on one reach. + db : str, Path or sqlite3.Connection, optional + MIKE+ database locating the items of ``data`` in the network. + Mutually exclusive with ``reaches``. + quantity : Quantity or str, optional + Physical quantity metadata, by default None. With ``db``, a string + selects which quantity to build observations for and the metadata + comes from the database; omit it and the quantity is inferred when + the data holds only one. + source : str, optional + With ``db``, the file the items come from. Taken from ``data`` when + that is a path, by default None. + on_missing : {"raise", "skip"}, optional + With ``db``, what to do with items the database cannot place, by + default "raise". + aux_items : list[int | str] | None, optional + Auxiliary items, by default None. + attrs : dict | None, optional + Additional attributes, by default None. + + Returns + ------- + list[ReachObservation] + List of ReachObservation objects. + + Raises + ------ + ValueError + If both ``reaches`` and ``db`` are given, if neither is, or if the + database cannot resolve the requested items. + """ + if db is not None: + if reaches is not None: + raise ValueError( + "'reaches' and 'db' are mutually exclusive: the database " + "supplies the locations." + ) + if data is None: + raise ValueError("'data' is required when 'db' is given") + return _observations_from_mikeplus( + cls, + data=data, + db=db, + kind="reach", + location_arg="reach", + quantity=quantity, + source=source, + on_missing=on_missing, + aux_items=aux_items, + attrs=attrs, + ) + + if isinstance(quantity, str): + raise TypeError( + "'quantity' must be a Quantity unless 'db' is given, got str" + ) + + if reaches is None: + raise ValueError("'reaches' argument is required") + if not isinstance(reaches, dict): + raise TypeError( + f"'reaches' must be a dict mapping reach_id -> data_source, got {type(reaches).__name__}" + ) + + reach_ids = list(reaches.keys()) + + if data is None: + data_sources: list[PointType] = list(reaches.values()) + return [ + cls( + data_i, + reach=reach_i, + item=None, + quantity=quantity, + aux_items=aux_items, + attrs=attrs, + ) + for data_i, reach_i in zip(data_sources, reach_ids) + ] + else: + reach_items: list[int | str | None] = list(reaches.values()) + return [ + cls( + data, + reach=reach_i, + item=item_i, + quantity=quantity, + aux_items=aux_items, + attrs=attrs, + ) + for reach_i, item_i in zip(reach_ids, reach_items) + ] + def unit_display_name(name: str) -> str: """Display name diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py new file mode 100644 index 000000000..1169033dc --- /dev/null +++ b/tests/test_mikeplus.py @@ -0,0 +1,478 @@ +import sqlite3 + +import numpy as np +import pandas as pd +import pytest + +from modelskill.obs import NodeObservation, ReachObservation + +STATION_COLUMNS = [ + "muid", + "locationid", + "locationtype", + "chainagevalue", + "assetname", +] +MEASUREMENT_COLUMNS = [ + "measurementstationid", + "tsfilename", + "tsitemname", + "resitemname", +] + +JUNCTION = 8 +LINK = 9 +TANK = 12 + + +def station(muid, locationid, locationtype, assetname, chainagevalue=None): + return dict( + muid=muid, + locationid=locationid, + locationtype=locationtype, + chainagevalue=chainagevalue, + assetname=assetname, + ) + + +def measurement(station_muid, item, quantity, file="calib.dfs0"): + return dict( + measurementstationid=station_muid, + tsfilename=rf"..\Scripts\{file}", + tsitemname=item, + resitemname=f"{quantity};{quantity};100450", + ) + + +def build_db(path, stations, measurements, *, station_columns=STATION_COLUMNS): + conn = sqlite3.connect(str(path)) + pd.DataFrame(stations, columns=station_columns).to_sql( + "m_Station", conn, index=False + ) + pd.DataFrame(measurements, columns=MEASUREMENT_COLUMNS).to_sql( + "m_Measurement", conn, index=False + ) + conn.commit() + conn.close() + return str(path) + + +@pytest.fixture +def db(tmp_path): + """Two pressure sensors on nodes, one flow meter on a link.""" + stations = [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "Tank_A", TANK, "LT.410"), + station("s3", "Pipe_7", LINK, "FT.403"), + ] + measurements = [ + measurement("s1", "item_pressure_1", "Pressure"), + measurement("s2", "item_pressure_2", "Pressure"), + measurement("s3", "item_flow_1", "Flow"), + ] + return build_db(tmp_path / "mikeplus.sqlite", stations, measurements) + + +def frame(*items): + """A data source holding one timeseries per named item.""" + time = pd.date_range("2024-01-01", periods=24, freq="h") + rng = np.random.default_rng(42) + return pd.DataFrame( + {item: rng.normal(35.0, 1.0, len(time)) for item in items}, index=time + ) + + +def test_junction_and_tank_resolve_to_nodes(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2"), db=db, quantity="Pressure" + ) + + assert {obs.at for obs in obs_list} == {"wNode_1", "Tank_A"} + + +def test_link_without_chainage_resolves_to_a_reach(db): + (obs,) = ReachObservation.from_multiple( + data=frame("item_flow_1"), db=db, quantity="Flow" + ) + + assert obs.reach == "Pipe_7" + + +def test_link_with_chainage_resolves_to_a_breakpoint(tmp_path): + path = build_db( + tmp_path / "chainage.sqlite", + [station("s1", "Pipe_7", LINK, "FT.403", chainagevalue=24.5)], + [measurement("s1", "item_flow_1", "Flow")], + ) + + (obs,) = NodeObservation.from_multiple( + data=frame("item_flow_1"), db=path, quantity="Flow" + ) + + assert obs.at == ("Pipe_7", 24.5) + + +def test_several_items_at_one_location_all_survive(tmp_path): + path = build_db( + tmp_path / "shared.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_1", JUNCTION, "PT.402"), + ], + [ + measurement("s1", "before_valve", "Pressure"), + measurement("s2", "after_valve", "Pressure"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("before_valve", "after_valve"), db=path, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] + assert {obs.at for obs in obs_list} == {"wNode_1"} + + +def test_name_falls_back_to_item_name_when_assetnames_collide(tmp_path): + path = build_db( + tmp_path / "collide.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "same"), + station("s2", "wNode_2", JUNCTION, "same"), + ], + [ + measurement("s1", "item_a", "Pressure"), + measurement("s2", "item_b", "Pressure"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a", "item_b"), db=path, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["item_a", "item_b"] + + +def test_quantity_is_inferred_when_unambiguous(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2"), db=db + ) + + assert {obs.quantity.name for obs in obs_list} == {"Pressure"} + + +def test_ambiguous_quantity_raises_and_lists_options(tmp_path): + path = build_db( + tmp_path / "two_quantities.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_2", JUNCTION, "LT.410"), + ], + [ + measurement("s1", "item_pressure", "Pressure"), + measurement("s2", "item_level", "Water Level"), + ], + ) + + with pytest.raises(ValueError, match="cannot be inferred") as excinfo: + NodeObservation.from_multiple( + data=frame("item_pressure", "item_level"), db=path + ) + + assert "Pressure" in str(excinfo.value) + assert "Water Level" in str(excinfo.value) + + +def test_the_observation_kind_narrows_the_pool_used_for_inference(db): + # The database holds pressure on two nodes and flow on a reach. Asking for + # node observations leaves only one quantity, so it needs no naming. + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "item_pressure_2", "item_flow_1"), db=db + ) + + assert {obs.quantity.name for obs in obs_list} == {"Pressure"} + assert len(obs_list) == 2 + + +def test_unknown_quantity_raises(db): + with pytest.raises(ValueError, match="not found"): + NodeObservation.from_multiple( + data=frame("item_pressure_1"), db=db, quantity="Discharge" + ) + + +def test_asking_for_a_node_when_the_station_is_a_reach_raises(db): + with pytest.raises(ValueError, match="not 'node'"): + NodeObservation.from_multiple(data=frame("item_flow_1"), db=db, quantity="Flow") + + +def test_missing_items_raise_and_separate_the_two_causes(db): + with pytest.raises(ValueError) as excinfo: + NodeObservation.from_multiple( + data=frame("item_pressure_1", "PT.401", "never_heard_of_it"), + db=db, + quantity="Pressure", + ) + + message = str(excinfo.value) + assert "no measurement registered" in message + assert "PT.401" in message + assert "Not found in the database" in message + assert "never_heard_of_it" in message + + +def test_missing_items_can_be_skipped(db): + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure_1", "never_heard_of_it"), + db=db, + quantity="Pressure", + on_missing="skip", + ) + + assert [obs.name for obs in obs_list] == ["PT.401"] + + +def test_source_selects_between_files(tmp_path): + path = build_db( + tmp_path / "files.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [ + measurement("s1", "item_a", "Pressure", file="main.dfs0"), + measurement("s1", "item_a", "Pressure", file="other.dfs0"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure", source="main.dfs0" + ) + + assert len(obs_list) == 1 + + +def test_source_accepts_a_full_path(tmp_path): + path = build_db( + tmp_path / "fullpath.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [measurement("s1", "item_a", "Pressure", file="main.dfs0")], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), + db=path, + quantity="Pressure", + source="/some/where/main.dfs0", + ) + + assert len(obs_list) == 1 + + +def test_item_registered_against_several_files_raises_without_source(tmp_path): + path = build_db( + tmp_path / "ambiguous.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [ + measurement("s1", "item_a", "Pressure", file="main.dfs0"), + measurement("s1", "item_a", "Pressure", file="other.dfs0"), + ], + ) + + with pytest.raises(ValueError, match="more than one file"): + NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure" + ) + + +def test_unknown_locationtype_raises(tmp_path): + path = build_db( + tmp_path / "weird.sqlite", + [station("s1", "wNode_1", 99, "PT.401")], + [measurement("s1", "item_a", "Pressure")], + ) + + with pytest.raises(ValueError, match="unsupported locationtype"): + NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure" + ) + + +def test_accepts_an_open_connection(db): + conn = sqlite3.connect(db) + try: + (obs,) = ReachObservation.from_multiple( + data=frame("item_flow_1"), db=conn, quantity="Flow" + ) + finally: + conn.close() + + assert obs.reach == "Pipe_7" + + +def test_missing_table_raises(tmp_path): + path = str(tmp_path / "empty.sqlite") + conn = sqlite3.connect(path) + pd.DataFrame({"a": [1]}).to_sql("something_else", conn, index=False) + conn.close() + + with pytest.raises(ValueError, match="missing table"): + NodeObservation.from_multiple(data=frame("item_a"), db=path) + + +def test_missing_column_raises(tmp_path): + path = build_db( + tmp_path / "thin.sqlite", + [ + dict(muid="s1", locationid="wNode_1", locationtype=JUNCTION, assetname="a"), + ], + [measurement("s1", "item_a", "Pressure")], + station_columns=["muid", "locationid", "locationtype", "assetname"], + ) + + with pytest.raises(ValueError, match="missing column"): + NodeObservation.from_multiple(data=frame("item_a"), db=path) + + +@pytest.fixture +def calibration_data(): + """A data source holding both pressure and flow items.""" + time = pd.date_range("2024-01-01", periods=24, freq="h") + rng = np.random.default_rng(42) + return pd.DataFrame( + { + "item_pressure_1": rng.normal(35.0, 1.0, len(time)), + "item_pressure_2": rng.normal(36.0, 1.0, len(time)), + "item_flow_1": rng.normal(120.0, 5.0, len(time)), + }, + index=time, + ) + + +class TestNodeObservationFromDatabase: + def test_builds_one_observation_per_item(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert len(obs_list) == 2 + assert all(isinstance(obs, NodeObservation) for obs in obs_list) + assert [obs.at for obs in obs_list] == ["wNode_1", "Tank_A"] + + def test_names_come_from_the_database(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["PT.401", "LT.410"] + + def test_quantity_comes_from_the_database(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + assert all(obs.quantity.name == "Pressure" for obs in obs_list) + + def test_data_is_selected_per_item(self, db, calibration_data): + obs_list = NodeObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + expected = calibration_data["item_pressure_1"].to_numpy() + assert obs_list[0].values == pytest.approx(expected) + + def test_quantity_is_inferred_when_only_nodes_are_wanted( + self, db, calibration_data + ): + obs_list = NodeObservation.from_multiple(data=calibration_data, db=db) + + assert len(obs_list) == 2 + assert all(obs.quantity.name == "Pressure" for obs in obs_list) + + def test_several_sensors_at_one_node_are_all_kept(self, tmp_path): + path = build_db( + tmp_path / "shared.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "wNode_1", JUNCTION, "PT.402"), + ], + [ + measurement("s1", "before_valve", "Pressure"), + measurement("s2", "after_valve", "Pressure"), + ], + ) + time = pd.date_range("2024-01-01", periods=5, freq="h") + data = pd.DataFrame( + {"before_valve": range(5), "after_valve": range(5, 10)}, index=time + ) + + obs_list = NodeObservation.from_multiple(data=data, db=path) + + assert [obs.at for obs in obs_list] == ["wNode_1", "wNode_1"] + assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] + + def test_flow_on_a_link_points_at_reach_observation(self, db, calibration_data): + with pytest.raises(ValueError, match="not 'node'"): + NodeObservation.from_multiple(data=calibration_data, db=db, quantity="Flow") + + def test_unresolvable_item_raises(self, db, calibration_data): + data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) + + with pytest.raises(ValueError, match="could not be resolved"): + NodeObservation.from_multiple(data=data, db=db, quantity="Pressure") + + def test_unresolvable_item_can_be_skipped(self, db, calibration_data): + data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) + + obs_list = NodeObservation.from_multiple( + data=data, db=db, quantity="Pressure", on_missing="skip" + ) + + assert [obs.name for obs in obs_list] == ["LT.410"] + + def test_db_and_nodes_are_mutually_exclusive(self, db, calibration_data): + with pytest.raises(ValueError, match="mutually exclusive"): + NodeObservation.from_multiple( + data=calibration_data, db=db, nodes={1: "item_pressure_1"} + ) + + def test_db_without_data_raises(self, db): + with pytest.raises(ValueError, match="'data' is required"): + NodeObservation.from_multiple(db=db) + + def test_quantity_string_without_db_raises(self, calibration_data): + with pytest.raises(TypeError, match="must be a Quantity"): + NodeObservation.from_multiple( + data=calibration_data, + nodes={1: "item_pressure_1"}, + quantity="Pressure", + ) + + +class TestReachObservationFromDatabase: + def test_builds_reach_observations(self, db, calibration_data): + obs_list = ReachObservation.from_multiple( + data=calibration_data, db=db, quantity="Flow" + ) + + assert len(obs_list) == 1 + assert isinstance(obs_list[0], ReachObservation) + assert obs_list[0].reach == "Pipe_7" + assert obs_list[0].name == "FT.403" + assert obs_list[0].quantity.name == "Flow" + + def test_quantity_is_inferred_when_only_reaches_are_wanted( + self, db, calibration_data + ): + obs_list = ReachObservation.from_multiple(data=calibration_data, db=db) + + assert [obs.reach for obs in obs_list] == ["Pipe_7"] + + def test_pressure_on_a_node_points_at_node_observation(self, db, calibration_data): + with pytest.raises(ValueError, match="not 'reach'"): + ReachObservation.from_multiple( + data=calibration_data, db=db, quantity="Pressure" + ) + + def test_db_and_reaches_are_mutually_exclusive(self, db, calibration_data): + with pytest.raises(ValueError, match="mutually exclusive"): + ReachObservation.from_multiple( + data=calibration_data, db=db, reaches={"r1": "item_flow_1"} + ) diff --git a/tests/test_network.py b/tests/test_network.py index a41fc997b..afe6dcf47 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -31,7 +31,7 @@ _MIKE_EXTENSIONS, _UNSUPPORTED_EXTENSIONS, ) -from modelskill.obs import NodeObservation +from modelskill.obs import NodeObservation, ReachObservation from modelskill.quantity import Quantity @@ -154,6 +154,36 @@ def test_init_with_network(self, sample_network): assert isinstance(nmr.time, pd.DatetimeIndex) assert len(nmr.nodes) == 3 + def test_quantity_name_survives_to_the_model_result(self, sample_network): + """The network knows its quantity by name even without a unit.""" + nmr = NetworkModelResult(sample_network) + + assert nmr.quantity.name == "WaterLevel" + assert nmr.quantity != Quantity.undefined() + + def test_quantity_carries_into_extracted_node(self, sample_network): + nmr = NetworkModelResult(sample_network) + obs_data = pd.DataFrame({"sensor": np.zeros(len(nmr.time))}, index=nmr.time) + extracted = nmr.extract(NodeObservation(obs_data, at="123")) + + assert extracted.quantity.name == "WaterLevel" + + def test_explicit_quantity_wins(self, sample_network): + given = Quantity(name="Water Level", unit="meter") + nmr = NetworkModelResult(sample_network, quantity=given) + + assert nmr.quantity == given + + def test_unit_is_used_when_the_data_carries_one(self, sample_network): + network = sample_network.copy() + ds = network.to_dataset() + ds["WaterLevel"].attrs["units"] = "meter" + network.to_dataset = lambda: ds # type: ignore[method-assign] + + nmr = NetworkModelResult(network) + + assert nmr.quantity == Quantity(name="WaterLevel", unit="meter") + def test_init_with_name(self, sample_network): """Test initialization with explicit name""" nmr = NetworkModelResult(sample_network, name="Test_Network") @@ -374,6 +404,71 @@ def test_single_node_dict(self, sample_node_data): assert isinstance(obs_list[0], NodeObservation) assert obs_list[0].node == 123 + def test_nodes_keys_accept_aliases(self, multi_data): + obs_list = NodeObservation.from_multiple( + data=multi_data, nodes={"node_A": "station_0", "node_B": "station_1"} + ) + + assert [obs.at for obs in obs_list] == ["node_A", "node_B"] + + def test_nodes_keys_accept_breakpoints(self, multi_data): + obs_list = NodeObservation.from_multiple( + data=multi_data, + nodes={("reach_1", 24.5): "station_0", ("reach_1", 50.0): "station_1"}, + ) + + assert [obs.at for obs in obs_list] == [("reach_1", 24.5), ("reach_1", 50.0)] + + +class TestReachObservationFromMultiple: + @pytest.fixture + def multi_data(self, sample_node_data): + return pd.DataFrame( + { + "station_0": sample_node_data["WaterLevel"].values, + "station_1": sample_node_data["WaterLevel"].values + 0.1, + }, + index=sample_node_data.index, + ) + + def test_returns_list_of_reach_observations(self, multi_data): + obs_list = ReachObservation.from_multiple( + data=multi_data, reaches={"reach_1": "station_0", "reach_2": "station_1"} + ) + + assert len(obs_list) == 2 + assert all(isinstance(obs, ReachObservation) for obs in obs_list) + assert [obs.reach for obs in obs_list] == ["reach_1", "reach_2"] + assert [obs.name for obs in obs_list] == ["station_0", "station_1"] + + def test_separate_data_sources(self): + obs_list = ReachObservation.from_multiple( + reaches={ + "reach_1": "tests/testdata/network_sensor_1.csv", + "reach_2": "tests/testdata/network_sensor_2.csv", + } + ) + + assert [obs.reach for obs in obs_list] == ["reach_1", "reach_2"] + assert all(len(obs.time) > 0 for obs in obs_list) + + def test_attrs_propagated(self, multi_data): + obs_list = ReachObservation.from_multiple( + data=multi_data, + reaches={"reach_1": "station_0"}, + attrs={"source": "sensor_array"}, + ) + + assert obs_list[0].attrs["source"] == "sensor_array" + + def test_reaches_none_raises(self, multi_data): + with pytest.raises(ValueError, match="'reaches' argument is required"): + ReachObservation.from_multiple(data=multi_data, reaches=None) + + def test_reaches_must_be_dict(self, multi_data): + with pytest.raises(TypeError, match="'reaches' must be a dict"): + ReachObservation.from_multiple(data=multi_data, reaches="reach_1") + class TestNodeModelResult: """Test NodeModelResult class""" From 34d3aad2ee397ec255c3bc6325add1ac232ce9a7 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 11 Aug 2026 10:41:00 +0200 Subject: [PATCH 005/117] Document locating observations from a MIKE+ database Co-Authored-By: Claude Opus 5 --- docs/user-guide/network.qmd | 40 +++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/docs/user-guide/network.qmd b/docs/user-guide/network.qmd index a769d9c16..001e2a226 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -456,6 +456,46 @@ cc_q.skill() Use `ReachObservation` when your measured quantity is representative of the whole reach (e.g. discharge, which is constant along a reach in steady flow). If you need to compare a quantity that varies spatially along the reach (e.g. water level at a specific chainage), use a `NodeObservation` with a `(reach, distance)` tuple instead (see [Option B](#option-b-breakpoint-by-reach-distance-tuple) above). ::: +## Locating observations with a MIKE+ database + +The examples above assume you already know where each sensor sits in the network. A MIKE+ project normally records that itself, in the sqlite database shipped alongside the result files: `m_Measurement` says which file and item each measured timeseries lives in, and `m_Station` says where in the network it belongs. + +Pass that database as `db` and modelskill does the lookup for you: + +```python +quantity = "Pressure" + +network = Network.from_epanet("model.res", quantities=quantity) +network_model = ms.NetworkModelResult(network, item=quantity) + +obs = ms.NodeObservation.from_multiple( + data="calibration.dfs0", + db="model.sqlite", + quantity=quantity, +) + +cc = ms.match(obs, network_model) +``` + +One observation is created per item of the data source, named after the station's asset name. Because the mapping runs item by item rather than location by location, several sensors at the same node — a pair either side of a check valve, say — all become separate observations. + +Reach-uniform quantities work the same way through the sibling method: + +```python +obs_q = ms.ReachObservation.from_multiple( + data="calibration.dfs0", db="model.sqlite", quantity="Flow" +) +``` + +Which class to use is decided by the database, not by you: stations recorded on a junction or a tank are node observations, and stations recorded on a link are reach observations. Asking `NodeObservation` for a quantity that the database places on links raises an error naming `ReachObservation`, and the other way around. + +A few details worth knowing: + +* **`quantity` is optional.** Omit it and the quantity is inferred, as long as the data holds only one for the class you asked for. A calibration file mixing pressure and flow raises an error listing what it found. +* **The quantity name comes from the database, the unit from the data.** Calibration files often carry no usable EUM information, so the database is the only reliable source for the name. +* **`source` picks between files.** It defaults to `data` when that is a path. Pass it explicitly if you hand over an already-read `mikeio.Dataset` or a `DataFrame`, since neither remembers where it came from. +* **Items the database cannot place raise by default**, separating the two causes: a station that exists but has no measurement registered for this file, and an item that is not in the database at all. Pass `on_missing="skip"` to build observations from the rest. + ## Development ### Custom network formats From 62486c7e6c8b6ef77841166f6aaf987c001e469f Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 15:50:40 +0200 Subject: [PATCH 006/117] Identify a network timeseries by name, not by graph integer A node observation records whatever the caller addressed it with, so a comparer built from at="node_A" already carries the name. The model side disagreed: it recorded the integer the network handed out, and load() coerced the coordinate back with int(), which raises on a name. A breakpoint was worse off again -- it carries reach and distance rather than node, and several places tested for "node" alone. - One list of the coordinates that say where a timeseries sits, so the three places that dropped a subset of them on the way to a dataframe now drop the same set. Fixes NodeObservation(df, at=("r1", 24.5)).to_dataframe(), which raised because the node coordinate it dropped is not there. - NodeModelResult takes a node name or a (reach, distance) pair, and records the graph integer beside it as node_index. Neither identity nor load reads that integer back. - load() stops re-deriving the location: the coordinates travelled with the file. A reach comparer can now be saved and loaded at all, where it used to raise NotImplementedError. The backend is unchanged, so extraction still hands out integers; the next commit swaps it. Co-Authored-By: Claude Opus 5 --- src/modelskill/comparison/_comparison.py | 62 ++++++++++++++----- src/modelskill/model/network.py | 78 ++++++++++++++++++------ src/modelskill/timeseries/_coords.py | 33 ++++++++++ src/modelskill/timeseries/_timeseries.py | 11 ++-- tests/test_comparercollection.py | 60 +++++++++++++++++- tests/test_network.py | 33 ++++++++++ 6 files changed, 236 insertions(+), 41 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 8838184e5..41e82f1c3 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -26,8 +26,14 @@ from .. import metrics as mtr from .. import Quantity from ..types import GeometryType -from ..obs import PointObservation, TrackObservation, NodeObservation +from ..obs import ( + PointObservation, + TrackObservation, + NodeObservation, + ReachObservation, +) from ..model import PointModelResult, TrackModelResult, VerticalModelResult +from ..timeseries._coords import NETWORK_LOCATION_COORDS, location_from_coords from ..timeseries._timeseries import _normalize_time_to_ns, _validate_data_var_name from ._comparer_plotter import ComparerPlotter from ..metrics import _parse_metric @@ -54,7 +60,7 @@ def _drop_scalar_coords(data: xr.Dataset) -> xr.Dataset: """Drop scalar coordinate variables that shouldn't appear as columns in dataframes""" - coords_to_drop = ["x", "y", "z", "node"] + coords_to_drop = ["x", "y", "z", *NETWORK_LOCATION_COORDS] return data.drop_vars(coords_to_drop, errors="ignore") @@ -72,8 +78,8 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # coordinates # Only add x, y, z coordinates if they don't exist and we don't have node coordinates - has_node_coords = "node" in data.coords - if not has_node_coords: + has_network_coords = bool({"node", "reach"} & set(data.coords)) + if not has_network_coords: if "x" not in data.coords: data.coords["x"] = np.nan if "y" not in data.coords: @@ -112,8 +118,10 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # Validate attrs if "gtype" not in data.attrs: # Determine gtype based on available coordinates - if "node" in data.coords: + if "node" in data.coords or {"reach", "distance"} <= set(data.coords): data.attrs["gtype"] = str(GeometryType.NODE) + elif "reach" in data.coords: + data.attrs["gtype"] = str(GeometryType.REACH) else: data.attrs["gtype"] = str(GeometryType.POINT) # assert "gtype" in data.attrs, "data must have a gtype attribute" @@ -645,6 +653,21 @@ def node(self) -> Any: """node-coordinate""" return self._coordinate_values("node") + @property + def reach(self) -> Any: + """reach-coordinate""" + return self._coordinate_values("reach") + + @property + def distance(self) -> Any: + """along-reach distance of a breakpoint""" + return self._coordinate_values("distance") + + @property + def _at(self) -> Any: + """Where this comparer sits, in the form NodeObservation.at takes""" + return location_from_coords(self.data) + def _coordinate_values(self, coord: str) -> None | Any: """Get coordinate values if they exist, otherwise return None""" if coord not in self.data.coords: @@ -773,7 +796,9 @@ def rename( return Comparer(matched_data=data, raw_mod_data=raw_mod_data) - def _to_observation(self) -> PointObservation | TrackObservation | NodeObservation: + def _to_observation( + self, + ) -> PointObservation | TrackObservation | NodeObservation | ReachObservation: """Convert to Observation""" if self.gtype == "point": df = _drop_scalar_coords(self.data)[self._obs_str].to_dataframe() @@ -804,7 +829,16 @@ def _to_observation(self) -> PointObservation | TrackObservation | NodeObservati return NodeObservation( data=df, name=self.name, - at=self.node, + at=self._at, + quantity=self.quantity, + # TODO: add attrs + ) + elif self.gtype == "reach": + df = _drop_scalar_coords(self.data)[self._obs_str].to_dataframe() + return ReachObservation( + data=df, + name=self.name, + reach=self.reach, quantity=self.quantity, # TODO: add attrs ) @@ -1012,9 +1046,9 @@ def _to_long_dataframe( """Return a copy of the data as a long-format pandas DataFrame (for groupby operations)""" if self.gtype == "vertical": - data = self.data.drop_vars("node", errors="ignore") + data = self.data.drop_vars(NETWORK_LOCATION_COORDS, errors="ignore") else: - data = self.data.drop_vars(["z", "node"], errors="ignore") + data = self.data.drop_vars(["z", *NETWORK_LOCATION_COORDS], errors="ignore") # this step is necessary since we keep arbitrary derived data in the dataset, but not z/node # i.e. using a hardcoded whitelist of variables to keep is less flexible @@ -1361,7 +1395,7 @@ def save(self, filename: Union[str, Path]) -> None: # https://docs.xarray.dev/en/stable/user-guide/io.html#groups # There is no need to save raw data for track data, since it is identical to the matched data - if self.gtype in ("point", "node"): + if self.gtype in ("point", "node", "reach"): ds = self.data.copy() # copy needed to avoid modifying self.data for key, ts_mod in self.raw_mod_data.items(): @@ -1396,7 +1430,7 @@ def load(filename: Union[str, Path]) -> "Comparer": # FIXME: consider during Phase3 return Comparer(matched_data=data) - if data.gtype in ("point", "node"): + if data.gtype in ("point", "node", "reach"): raw_mod_data: Dict[ str, PointModelResult @@ -1413,10 +1447,8 @@ def load(filename: Union[str, Path]) -> "Comparer": {"_time_raw_" + new_key: "time", var_name: new_key} ) ts: PointModelResult | NodeModelResult - if data.gtype == "node": - ts = NodeModelResult( - data=ds, node=int(ds.coords["node"].item()), name=new_key - ) + if data.gtype in ("node", "reach"): + ts = NodeModelResult(data=ds, name=new_key) else: ts = PointModelResult(data=ds, name=new_key) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index fd290d9b2..3275c8ab2 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -1,13 +1,18 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Sequence +from typing import TYPE_CHECKING, Any, Sequence import numpy as np import numpy.typing as npt import pandas as pd import xarray as xr -from modelskill.timeseries import TimeSeries, _parse_network_node_input +from modelskill.timeseries import ( + TimeSeries, + _parse_network_breakpoint_input, + _parse_network_node_input, +) +from modelskill.timeseries._coords import location_from_coords from ._base import SelectedItems from ..obs import NodeObservation, ReachObservation from ..quantity import Quantity @@ -50,41 +55,74 @@ class NodeModelResult(TimeSeries): def __init__( self, data: PointType, - node: int, + node: int | str | tuple[str, float | None] | None = None, *, + node_index: int | None = None, name: str | None = None, item: str | int | None = None, quantity: Quantity | None = None, aux_items: Sequence[int | str] | None = None, ): if not self._is_input_validated(data): - data = _parse_network_node_input( - data, - name=name, - item=item, - quantity=quantity, - node=node, - aux_items=aux_items, - ) + if isinstance(node, tuple): + reach, distance = node + data = _parse_network_breakpoint_input( + data, + name=name, + item=item, + quantity=quantity, + aux_items=aux_items, + reach=reach, + distance=distance, + ) + elif node is not None: + data = _parse_network_node_input( + data, + name=name, + item=item, + quantity=quantity, + node=node, + aux_items=aux_items, + ) + else: + raise ValueError( + "'NodeModelResult' needs a node name or a (reach, distance) " + "pair when the data does not already carry its location" + ) if not isinstance(data, xr.Dataset): raise ValueError("'NodeModelResult' requires xarray.Dataset") - if data.coords.get("node") is None: - raise ValueError("'node' coordinate not found in data") + if not {"node", "reach"} & set(data.coords): + raise ValueError( + "'NodeModelResult' needs a node name, a (reach, distance) pair, or " + "data that already carries a 'node' or 'reach' coordinate" + ) + if node_index is not None: + data = data.assign_coords(node_index=int(node_index)) data_var = str(list(data.data_vars)[0]) data[data_var].attrs["kind"] = "model" super().__init__(data=data) @property - def node(self) -> int: - """Node ID of model result""" - node_val = self.data.coords["node"] - return int(node_val.item()) + def node(self) -> Any: + """Where this result was extracted, as its network named it.""" + return location_from_coords(self.data) + + @property + def node_index(self) -> int | None: + """Graph integer this location had in the network it came from, if recorded. + + Provenance only. Nothing reads it back: the numbering belongs to one + network built by one version, so a saved result is identified by + :attr:`node` instead. + """ + if "node_index" not in self.data.coords: + return None + return int(np.atleast_1d(self.data.coords["node_index"].values)[0]) def _create_new_instance(self, data: xr.Dataset) -> NodeModelResult: - """Extract node from data and create new instance""" - node = int(data.coords["node"].item()) - return self.__class__(data, node=node) + """Create a new instance; the location already travels in the coords.""" + return self.__class__(data) class NetworkModelResult: diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index 98304befa..f0cd5fbff 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -1,4 +1,37 @@ +from __future__ import annotations + +from typing import Any + import numpy as np +import xarray as xr + +#: Scalar coordinates that say where a network timeseries sits, rather than what +#: it holds. They are dropped on the way to a dataframe, where they would +#: otherwise become columns. +NETWORK_LOCATION_COORDS = ("node", "node_index", "reach", "distance") + + +def location_from_coords(ds: xr.Dataset) -> Any: + """Where a network timeseries sits, as the network that produced it named it. + + Returns a node name for a node, a ``(reach, distance)`` pair for a + breakpoint, a reach name when no distance was given, and None for data that + carries no network location. The value is returned as recorded, so a comparer + saved by an older version gives back the integer it stored. + """ + if "node" in ds.coords: + return _scalar(ds, "node") + if "reach" in ds.coords: + reach = _scalar(ds, "reach") + if "distance" not in ds.coords: + return reach + return (reach, _scalar(ds, "distance")) + return None + + +def _scalar(ds: xr.Dataset, name: str) -> Any: + value = np.atleast_1d(ds.coords[name].values)[0] + return value.item() if hasattr(value, "item") else value class XYZCoords: diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index bba5d78f7..4bec9abcd 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -10,6 +10,7 @@ from ..types import GeometryType from ..quantity import Quantity +from ._coords import NETWORK_LOCATION_COORDS from ._plotter import TimeSeriesPlotter, MatplotlibTimeSeriesPlotter from .. import __version__ @@ -366,10 +367,12 @@ def to_dataframe(self) -> pd.DataFrame: return df[cols] elif self.gtype == str(GeometryType.VERTICAL): return self.data.drop_vars(["x", "y"]).to_dataframe() - elif self.gtype == str(GeometryType.NODE): - return self.data.drop_vars(["node"]).to_dataframe() - elif self.gtype == str(GeometryType.REACH): - return self.data.drop_vars(["reach"]).to_dataframe() + elif self.gtype in (str(GeometryType.NODE), str(GeometryType.REACH)): + # A breakpoint carries reach and distance rather than node, so drop + # whichever of them this one has. + return self.data.drop_vars( + NETWORK_LOCATION_COORDS, errors="ignore" + ).to_dataframe() else: raise NotImplementedError(f"Unknown gtype: {self.gtype}") diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index bdf4aa807..5f50f8f28 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -472,8 +472,45 @@ def node_comparer() -> modelskill.comparison.Comparer: network = Network([reach]) nmr = NetworkModelResult(network, name="Network_Model") - node_id = network.find(node="123") - obs = NodeObservation(node_a_data, at=node_id, name="Node_123_Obs") + obs = NodeObservation(node_a_data, at="123", name="Node_123_Obs") + + return ms.match(obs, nmr) + + +@pytest.fixture +def reach_comparer() -> modelskill.comparison.Comparer: + """A comparer built by matching a ReachObservation (reach gtype).""" + pytest.importorskip("networkx") + from modelskill.model.network import NetworkModelResult + from modelskill.network import Network, BasicNode, BasicReach, ReachBreakPoint + from modelskill.obs import ReachObservation + + class Point(ReachBreakPoint): + def __init__(self, reach, distance, data): + self._id = (reach, distance) + self._data = data + + @property + def id(self): + return self._id + + @property + def data(self): + return self._data + + time = pd.date_range("2019-01-01", periods=6, freq="D") + values = pd.DataFrame({"WaterLevel": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, index=time) + empty = pd.DataFrame() + reach = BasicReach( + "r1", + BasicNode("123", empty), + BasicNode("456", empty), + length=100.0, + breakpoints=[Point("r1", 50.0, values)], + ) + + nmr = NetworkModelResult(Network([reach]), name="Network_Model") + obs = ReachObservation(values, reach="r1", name="Reach_r1_Obs") return ms.match(obs, nmr) @@ -490,6 +527,25 @@ def test_save_and_load_round_trips_node_gtype_raw_data(node_comparer, tmp_path): assert len(cc2[0].raw_mod_data["Network_Model"]) == len( node_comparer.raw_mod_data["Network_Model"] ) + # The node was addressed by name, and the name is what comes back: reloading + # must not depend on the integer the network happened to hand out. + assert cc2[0].node == "123" + assert cc2[0].raw_mod_data["Network_Model"].node == "123" + + +def test_save_and_load_round_trips_reach_gtype_raw_data(reach_comparer, tmp_path): + """Reach-gtype comparers must survive a save()/load() round trip too.""" + cc = ms.ComparerCollection([reach_comparer]) + fn = tmp_path / "test_cc_reach.msk" + cc.save(fn) + + cc2 = ms.load(fn) + + assert cc2[0].gtype == "reach" + assert cc2[0].reach == "r1" + assert len(cc2[0].raw_mod_data["Network_Model"]) == len( + reach_comparer.raw_mod_data["Network_Model"] + ) # ======================== plotting ======================== diff --git a/tests/test_network.py b/tests/test_network.py index afe6dcf47..76c145394 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -1507,3 +1507,36 @@ def test_a_repeated_section_header_accumulates(self, tmp_path): ) assert read_pipe_lengths(path) == {"1": 10.0, "3": 20.0} + + +# ======================== location identity ======================== + + +class TestLocationIdentity: + """A network timeseries is identified by the name its network gave it.""" + + def test_breakpoint_observation_converts_to_a_dataframe(self, sample_node_data): + obs = ms.NodeObservation(sample_node_data, at=("r1", 24.5), item="WaterLevel") + + df = obs.to_dataframe() + + assert list(df.columns) == ["WaterLevel"] + assert len(df) == len(sample_node_data) + + def test_reach_observation_converts_to_a_dataframe(self, sample_node_data): + obs = ms.ReachObservation(sample_node_data, reach="r1", item="WaterLevel") + + df = obs.to_dataframe() + + assert list(df.columns) == ["WaterLevel"] + + def test_a_named_node_survives_trimming(self, sample_network, sample_node_data): + nmr = NetworkModelResult(sample_network) + extracted = nmr.extract(ms.NodeObservation(sample_node_data, at="123")) + + trimmed = extracted.trim( + start_time=extracted.time[1], end_time=extracted.time[-1] + ) + + assert trimmed.node == extracted.node + assert len(trimmed) == len(extracted) - 1 From 72ec69ddcf62c26f8ba87831430c39c9a05d5b7a Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 15:53:47 +0200 Subject: [PATCH 007/117] Take the network topology layer from mikeio1d The extra is renamed networks -> network, matching mikeio1d's own, so modelskill[network] and mikeio1d[network] read the same. It shipped in the 1.4.0a3 alpha only, so nothing needs a deprecation. networkx and xarray now arrive through mikeio1d's extra rather than being named here. The module is unreleased, so a uv source points at mikeio1d's main branch. Both entries carry a TODO to swap it for a version floor once mikeio1d releases; per ADR-013, modelskill 1.4.0 waits for that release. Co-Authored-By: Claude Opus 5 --- .github/workflows/docs.yml | 2 +- .github/workflows/full_test.yml | 6 +++--- .github/workflows/notebooks_test.yml | 2 +- docs/user-guide/network.qmd | 8 ++++---- pyproject.toml | 11 +++++++++-- src/modelskill/network.py | 4 ++-- 6 files changed, 20 insertions(+), 13 deletions(-) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index cd57ed263..e854ab5b1 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -36,7 +36,7 @@ jobs: version: "1.8.27" - name: Install dependencies - run: uv sync --group dev --group docs --group networks + run: uv sync --group dev --group docs --group network - name: Build documentation run: just docs diff --git a/.github/workflows/full_test.yml b/.github/workflows/full_test.yml index bd62ad2b4..55f019b59 100644 --- a/.github/workflows/full_test.yml +++ b/.github/workflows/full_test.yml @@ -35,7 +35,7 @@ jobs: enable-cache: true - name: Install dependencies - run: uv sync --group test --group networks --no-dev + run: uv sync --group test --group network --no-dev - name: Install pandas 2.x if: matrix.pandas-version == 'pandas2' @@ -54,7 +54,7 @@ jobs: - name: Test run: just test - build-no-networks: + build-no-network: runs-on: ubuntu-latest steps: @@ -68,7 +68,7 @@ jobs: python-version: "3.12" enable-cache: true - - name: Install dependencies (without networks) + - name: Install dependencies (without network) run: uv sync --group test --no-dev - name: Test diff --git a/.github/workflows/notebooks_test.yml b/.github/workflows/notebooks_test.yml index dd64a1df6..84cbd346e 100644 --- a/.github/workflows/notebooks_test.yml +++ b/.github/workflows/notebooks_test.yml @@ -21,7 +21,7 @@ jobs: python-version: "3.14" enable-cache: true - name: Install dependencies - run: uv sync --group test --group notebooks --group networks --no-dev + run: uv sync --group test --group notebooks --group network --no-dev - name: Test notebooks run: | uv run pytest tests/notebooks/ diff --git a/docs/user-guide/network.qmd b/docs/user-guide/network.qmd index 001e2a226..ec3ff15f5 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -8,16 +8,16 @@ jupyter: python3 ## Extra dependencies required Network support depends on libraries that are **not** installed -by default, e.g. `networkx`. You can install them alongside `modelskill` using the _networks_ extra: +by default, e.g. `networkx`. You can install them alongside `modelskill` using the _network_ extra: ```bash -uv pip install modelskill[networks] +uv pip install modelskill[network] ``` or ```bash -uv add modelskill[networks] +uv add modelskill[network] ``` ::: @@ -132,7 +132,7 @@ Network → NetworkModelResult → match() → Comparer ## Building a Network -You can build a `Network` object by loading it from a supported network result file. Reading these files relies on [mikeio1d](https://github.com/DHI/mikeio1d), so install the `networks` dependency group first. +You can build a `Network` object by loading it from a supported network result file. Reading these files relies on [mikeio1d](https://github.com/DHI/mikeio1d), so install the `network` dependency group first. There is one constructor per product that writes the file: diff --git a/pyproject.toml b/pyproject.toml index 890fc7574..e33d442ed 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,7 +43,9 @@ classifiers = [ ] [project.optional-dependencies] -networks = ["mikeio1d", "networkx"] +# networkx and xarray arrive through mikeio1d's own network extra, which +# carries the topology layer this package builds on (ADR-013). +network = ["mikeio1d[network]"] [dependency-groups] dev = ["pytest", "plotly >= 4.5", "ruff==0.6.2", "netCDF4", "dask"] @@ -62,7 +64,12 @@ test = [ notebooks = ["nbformat", "nbconvert", "jupyter", "plotly", "shapely", "seaborn"] -networks = ["mikeio1d>=1.2.1", "networkx"] +network = ["mikeio1d[network]"] + +[tool.uv.sources] +# TODO: swap for a version floor in both "network" entries above once mikeio1d +# releases the network module. ADR-013 holds modelskill 1.4.0 until it does. +mikeio1d = { git = "https://github.com/DHI/mikeio1d", branch = "main" } [project.urls] "Homepage" = "https://github.com/DHI/modelskill" diff --git a/src/modelskill/network.py b/src/modelskill/network.py index 90f288b05..b28d13456 100644 --- a/src/modelskill/network.py +++ b/src/modelskill/network.py @@ -1,9 +1,9 @@ """Opt-in network module for network model results (e.g. MIKE 1D / res1d). -Requires the ``networks`` dependency group (networkx, mikeio1d). +Requires the ``network`` dependency group (networkx, mikeio1d). Install with:: - uv sync --group networks + uv sync --group network Import this module explicitly to use network functionality:: From f6765b65f0fd570167a6abc3cb00ccff31eac9c2 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 16:03:19 +0200 Subject: [PATCH 008/117] Build the network model result on mikeio1d's topology layer modelskill's own topology layer goes: the abstract types, the Res1D adapter, the per-product constructors, the EPANET companions, the extension policy table and the .inp reader. All of it now lives in mikeio1d, where the formats and the fixtures already were (ADR-013). 1503 lines of source, and the CI failure that came with the extension table -- a mikeio1d release adding a format is no longer our problem. NetworkModelResult takes a path or a mikeio1d Network. A path goes to Network.open, which picks the reader and finds the EPANET companions; refusals for .out, .resx and the fixture-less formats are upstream's to word now. The network is used as given rather than deep-copied, which was the largest cost of building a model result on a river model. Extraction reads the dataset and consults the topology only to explain a failure. Two consequences worth knowing: - A location whose column is entirely NaN now counts as having no data. It used to be selected, and produced a match with no points, so the observation quietly disappeared; another break point on the reach is used instead. - Break points with an unknown distance now take part. That is EPANET read without its .inp, where no reach has a length and the second break point of every reach is unaddressable by distance. Node lookups delegate to Network.find, so there is one chainage tolerance rather than a second copy here, and a failed lookup names the near misses instead of listing the first five aliases in the map. Co-Authored-By: Claude Opus 5 --- src/modelskill/model/adapters/__init__.py | 1 - src/modelskill/model/adapters/_inp.py | 109 -- src/modelskill/model/adapters/_res1d.py | 189 ---- src/modelskill/model/network.py | 255 ++--- src/modelskill/network.py | 1205 --------------------- tests/test_comparercollection.py | 13 +- tests/test_match.py | 28 +- tests/test_network.py | 905 ++-------------- 8 files changed, 252 insertions(+), 2453 deletions(-) delete mode 100644 src/modelskill/model/adapters/__init__.py delete mode 100644 src/modelskill/model/adapters/_inp.py delete mode 100644 src/modelskill/model/adapters/_res1d.py delete mode 100644 src/modelskill/network.py diff --git a/src/modelskill/model/adapters/__init__.py b/src/modelskill/model/adapters/__init__.py deleted file mode 100644 index 33ad255b1..000000000 --- a/src/modelskill/model/adapters/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Network format adapters.""" diff --git a/src/modelskill/model/adapters/_inp.py b/src/modelskill/model/adapters/_inp.py deleted file mode 100644 index 329b2c92a..000000000 --- a/src/modelskill/model/adapters/_inp.py +++ /dev/null @@ -1,109 +0,0 @@ -"""Minimal reader for EPANET and SWMM ``.inp`` input files. - -mikeio1d reads only the binary result formats, so the ``.inp`` that accompanies a -result file has to be parsed here. Both products use the same layout: bracketed -section headers, ``;``-prefixed comments (including the ``;;Name Node1 ...`` -column headers the products write), whitespace-delimited data rows, and blank -lines to ignore. - -Only the sections modelskill needs are interpreted; everything else is kept as -raw fields for a caller to use, or ignored. -""" - -from __future__ import annotations - -from pathlib import Path - - -def read_sections(path: str | Path) -> dict[str, list[list[str]]]: - """Parse an ``.inp`` file into its sections. - - Parameters - ---------- - path : str or Path - Path to an EPANET or SWMM ``.inp`` file. - - Returns - ------- - dict[str, list[list[str]]] - Section name (upper case, without brackets) mapped to its data rows, - each row split into whitespace-delimited fields. Comment-only and blank - lines are dropped, as is any trailing comment on a data row. - - Examples - -------- - >>> sections = read_sections("model.inp") # doctest: +SKIP - >>> sections["PIPES"][0] # doctest: +SKIP - ['10', '10', '11', '3209.544', '304.8', '100', '0', 'Open'] - """ - sections: dict[str, list[list[str]]] = {} - current: list[list[str]] | None = None - - with open(path, "r", encoding="utf-8", errors="replace") as f: - for line in f: - # A comment can trail a data row, so strip it before anything else. - line = line.split(";", 1)[0].strip() - if not line: - continue - - if line.startswith("["): - name = line.strip("[]").strip().upper() - current = sections.setdefault(name, []) - continue - - if current is not None: - current.append(line.split()) - - return sections - - -def read_pipe_lengths(path: str | Path) -> dict[str, float]: - """Read reach lengths from the ``[PIPES]`` section of an EPANET ``.inp``. - - Parameters - ---------- - path : str or Path - Path to an EPANET ``.inp`` file. - - Returns - ------- - dict[str, float] - Pipe ID mapped to its length. Pumps and valves are links too, but carry - no length, so they are absent from the result rather than present with a - placeholder. - - Raises - ------ - ValueError - If the file has no ``[PIPES]`` section, or a row there has too few - fields to read a length from. - - Notes - ----- - ``[PIPES]`` rows are ``ID Node1 Node2 Length Diameter Roughness ...``, so the - length is the fourth field. The units are whatever the model declares in - ``[OPTIONS]``; no conversion is applied. - """ - sections = read_sections(path) - - try: - rows = sections["PIPES"] - except KeyError: - raise ValueError( - f"'{path}' has no [PIPES] section, so it does not look like an " - "EPANET input file. Available sections: " - f"{sorted(sections)}." - ) - - _ID, _LENGTH = 0, 3 - lengths: dict[str, float] = {} - for row in rows: - if len(row) <= _LENGTH: - raise ValueError( - f"Cannot read a pipe length from [PIPES] row {' '.join(row)!r} " - f"in '{path}': expected at least {_LENGTH + 1} fields " - f"(ID, Node1, Node2, Length), got {len(row)}." - ) - lengths[row[_ID]] = float(row[_LENGTH]) - - return lengths diff --git a/src/modelskill/model/adapters/_res1d.py b/src/modelskill/model/adapters/_res1d.py deleted file mode 100644 index 567f0d498..000000000 --- a/src/modelskill/model/adapters/_res1d.py +++ /dev/null @@ -1,189 +0,0 @@ -from __future__ import annotations - -from typing import TYPE_CHECKING - -import pandas as pd - -if TYPE_CHECKING: - from mikeio1d.result_network import ResultNode, ResultGridPoint, ResultReach - -from modelskill.network import NetworkNode, ReachBreakPoint, NetworkReach - - -def _simplify_colnames(node: ResultNode | ResultGridPoint) -> pd.DataFrame: - # We remove suffixes and indexes so the columns contain only the quantity names - - # Some formats keep no timeseries at all on some locations - MIKE 11, for instance, - # stores everything on reach gridpoints, leaving the nodes empty. Asking mikeio1d - # for a dataframe there raises, so return an empty one instead. - if not node.quantities: - return pd.DataFrame() - - # The columns in a Res1D dataframe follow the convention "Quantity:Location:Sublocation" - # where Location refers to the node id or the reach id followed by the chainage. - RES1D_NAME_SEP = ":" - df = node.to_dataframe() - renamer_dict = {} - for quantity in node.quantities: - column_pairs = [ - (col, quantity) - for col in df.columns - if quantity in col.split(RES1D_NAME_SEP) - ] - if len(column_pairs) != 1: - raise ValueError( - f"There must be exactly one column per quantity, found {column_pairs}." - ) - old_name, new_name = column_pairs[0] - renamer_dict[old_name] = new_name - return df.rename(columns=renamer_dict).copy() - - -def _merge_extra_quantities( - base: pd.DataFrame, extra: pd.DataFrame, *, node_id: str -) -> pd.DataFrame: - """Append a companion file's quantities to a node's frame as extra columns. - - Parameters - ---------- - base : pd.DataFrame - The node's frame from the main result file. - extra : pd.DataFrame - The same node's frame from the companion file, sharing its time index. - node_id : str - Node ID, used in error messages. - - Returns - ------- - pd.DataFrame - - Raises - ------ - ValueError - If a quantity appears in both frames. Concatenating would give the node - two columns of the same name, which is the state ``_simplify_colnames`` - already refuses. - """ - if extra.empty: - return base - - overlapping = base.columns.intersection(extra.columns) - if len(overlapping) > 0: - raise ValueError( - f"Node {node_id!r} already has {sorted(overlapping)} in the main " - "result file, so the companion file's copy cannot be merged in." - ) - - return pd.concat([base, extra], axis=1) - - -class Res1DNode(NetworkNode): - def __init__( - self, - id: str, - *, - data: pd.DataFrame | None = None, - boundary: dict[str, pd.DataFrame] | None = None, - ): - self._id = id - self._data = pd.DataFrame() if data is None else data - self._boundary = {} if boundary is None else boundary - - @property - def id(self) -> str: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - @property - def boundary(self) -> dict[str, pd.DataFrame]: - return self._boundary - - -class GridPoint(ReachBreakPoint): - def __init__( - self, reach_id: str, chainage: float, data: pd.DataFrame | None = None - ): - self._id = (reach_id, chainage) - self._data = pd.DataFrame() if data is None else data - - @property - def id(self) -> tuple[str, float]: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - -class Res1DReach(NetworkReach): - """NetworkReach adapter for a mikeio1d ResultReach.""" - - def __init__( - self, - reach: ResultReach, - start_node: Res1DNode, - end_node: Res1DNode, - *, - populate_gridpoints: bool = True, - length: float | None = None, - ): - self._id = reach.name - - # Must be checked separately: some formats (.resx) report None for both the - # reach and the node, which the identity checks below would let through. - if reach.start_node is None or reach.end_node is None: - raise ValueError( - f"mikeio1d reported no start/end node for reach {reach.name!r}; " - "this result format's topology cannot be represented as a Network." - ) - - if start_node.id != reach.start_node: - raise ValueError("Incorrect starting node.") - if end_node.id != reach.end_node: - raise ValueError("Incorrect ending node.") - - intermediate_gridpoints = ( - reach.gridpoints[1:-1] if len(reach.gridpoints) > 2 else [] - ) - - self._start = start_node - self._end = end_node - - # A length read from a companion input file wins, since mikeio1d has none - # to offer for the formats that need one. Otherwise: mikeio1d returns 0 - # when it cannot read a reach length - link-node models such as EPANET - # report this for every reach. Report it as undefined rather than as a - # zero-length reach, which would make length-weighted graph algorithms - # treat the reach as free. The two cases cannot be told apart upstream. - self._length = length if length is not None else (reach.length or None) - self._breakpoints: list[ReachBreakPoint] = [ - GridPoint( - gridpoint.reach_name, - gridpoint.chainage, - _simplify_colnames(gridpoint) if populate_gridpoints else None, - ) - for gridpoint in intermediate_gridpoints - ] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> Res1DNode: - return self._start - - @property - def end(self) -> Res1DNode: - return self._end - - @property - def length(self) -> float | None: - return self._length - - @property - def breakpoints(self) -> list[ReachBreakPoint]: - return self._breakpoints diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 3275c8ab2..e96384b55 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -1,5 +1,6 @@ from __future__ import annotations +from pathlib import Path from typing import TYPE_CHECKING, Any, Sequence import numpy as np @@ -19,7 +20,20 @@ from ..types import PointType if TYPE_CHECKING: - from modelskill.network import Network + from mikeio1d.network import Network + + +def _network_class() -> type[Network]: + # Imported here, not at module scope, so this module stays importable + # without the optional network dependencies (ADR-010). + try: + from mikeio1d.network import Network + except ImportError as err: + raise ImportError( + "NetworkModelResult needs the network topology layer from mikeio1d, " + "which the 'network' extra installs: pip install modelskill[network]" + ) from err + return Network class NodeModelResult(TimeSeries): @@ -128,15 +142,15 @@ def _create_new_instance(self, data: xr.Dataset) -> NodeModelResult: class NetworkModelResult: """Model result for network data with time and node dimensions. - Construct a NetworkModelResult from a Network object containing - timeseries data for each node. Users must provide exact node IDs - (integers obtained via ``Network.find()``) when creating observations — - no spatial interpolation is performed. + Construct one from a result file, or from a :class:`mikeio1d.network.Network` + already built. Observations name the location they sit at, and no spatial + interpolation is performed. Parameters ---------- - data : Network - Network-like object with a ``to_dataset()`` method (e.g. :class:`modelskill.network.Network`). + data : Network, str or Path + Path to a ``.res1d``, ``.res11`` or ``.res`` result file, or a + :class:`mikeio1d.network.Network`. name : str, optional The name of the model result, by default None (will be set to first data variable name) @@ -151,23 +165,46 @@ class NetworkModelResult: Examples -------- >>> import modelskill as ms - >>> from modelskill.network import Network - >>> network = Network(reaches) # reaches is a list[NetworkReach] - >>> mr = ms.NetworkModelResult(network, name="MyModel") - >>> obs = ms.NodeObservation(data, node=network.find(node="node_A")) + >>> mr = ms.NetworkModelResult("model.res1d", item="WaterLevel") + >>> obs = ms.NodeObservation(data, at="node_A") >>> extracted = mr.extract(obs) + + Open the network yourself to name EPANET companion files, or to keep memory + down on a large model by reading only the locations you will score: + + >>> from mikeio1d.network import Network + >>> network = Network.open("model.res1d", nodes=["node_A", "node_B"]) + >>> mr = ms.NetworkModelResult(network, name="MyModel") + + Notes + ----- + The network is used as given, not copied, so ``mr.network`` is the caller's + object. + + See Also + -------- + mikeio1d.network.Network.open : Read a network from a result file. """ def __init__( self, - data: Network, + data: Network | str | Path, *, name: str | None = None, item: str | int | None = None, quantity: Quantity | None = None, aux_items: Sequence[int | str] | None = None, ): - self.network = data.copy() + network_class = _network_class() + if isinstance(data, (str, Path)): + self.network = network_class.open(data) + elif isinstance(data, network_class): + self.network = data + else: + raise TypeError( + "NetworkModelResult takes a mikeio1d.network.Network or a path to a " + f"result file, got {type(data).__name__}" + ) ds = self.network.to_dataset() sel_items = SelectedItems.parse( @@ -183,10 +220,9 @@ def __init__( da = self.data[sel_items.values] quantity = Quantity.from_cf_attrs(da.attrs) if quantity == Quantity.undefined(): - # A network knows its quantity by name even when no unit - # travels with the data -- res1d and EPANET files carry the - # name only. Quantity.from_cf_attrs needs both, so fall back to - # the name alone rather than reporting nothing at all. + # A result file names its quantity but carries no unit, and + # Quantity.from_cf_attrs needs both. Fall back to the name alone + # rather than reporting nothing at all. name = da.attrs.get("long_name") or str(sel_items.values) quantity = Quantity(name=name, unit="") self.quantity = quantity @@ -197,7 +233,10 @@ def __init__( def __repr__(self) -> str: return f"<{self.__class__.__name__}>: {self.name}" - _CHAINAGE_TOLERANCE = 1e-3 # Tolerance in source-network distance units (e.g., meters if chainage is in meters). + #: Coordinates mikeio1d puts on to_dataset() to say what each column is. They + #: are re-applied through NodeModelResult, which knows modelskill's names for + #: them, so they never reach a comparer under these. + _UPSTREAM_IDENTITY_COORDS = ("name", "reach", "distance") @property def time(self) -> pd.DatetimeIndex: @@ -218,7 +257,7 @@ def extract( Parameters ---------- observation : NodeObservation or ReachObservation - observation with node ID or reach ID + observation naming a node, a breakpoint, or a reach Returns ------- @@ -237,134 +276,104 @@ def extract( def _extract_node(self, observation: NodeObservation) -> NodeModelResult: node_id = self._resolve_alias(observation.at) - available_nodes = set(self.data.node.values) - if node_id not in available_nodes: + if node_id not in self.data.indexes["node"]: raise ValueError( - f"Node {node_id} exists in the network topology but its timeseries was not loaded. " - f"Re-create the NetworkModelResult with the relevant nodes populated, " - f"e.g. Network.from_mike(path, nodes=[...])." + f"{observation.at!r} exists in the network topology but its " + "timeseries was not loaded. Re-create the NetworkModelResult with " + "the relevant nodes populated, e.g. " + "NetworkModelResult(Network.open(path, nodes=[...]))." ) - return NodeModelResult( - data=self.data.sel(node=node_id).drop_vars("node"), - node=node_id, - name=self.name, - item=self.sel_items.values, - quantity=self.quantity, - aux_items=self.sel_items.aux, - ) + return self._as_node_result(node_id) def _extract_reach(self, observation: ReachObservation) -> NodeModelResult: - # Extract model result from an arbitrary breakpoint belonging to the reach. - - # Searches the alias map for breakpoints whose reach component matches - # ``observation.reach``, then returns the first one that has data in the - # dataset. Raises if no breakpoint with data is found or if the quantity - # is not present for any breakpoint of that reach. - + # A reach observation matches any breakpoint along the reach, so long as + # they agree. Which breakpoints those are is read off the dataset's own + # coordinates; the network is consulted only to explain a failure. item = self.sel_items.values reach_id = observation.reach - try: - reach = self.network._reaches[reach_id] - except KeyError: + if reach_id not in self.network.reaches: raise ValueError(f"Reach {reach_id} not found in network.") - # This only searches intermediate breakpoints since reach-level data is not - # expected in nodes. - - available_nodes = {int(node_id) for node_id in self.data.node.values} - found_ds = None - found_int_id: int | None = None - missing_node_data = False - for breakpoint in reach.breakpoints: - if breakpoint.data is None: - continue - if item not in breakpoint.data.columns: - continue - - int_id = self.network.find( - reach=breakpoint.id[0], distance=breakpoint.distance - ) - if int_id not in available_nodes: - missing_node_data = True - continue - - ds = self.data.sel(node=int_id).drop_vars("node") - if found_ds is not None: - da1, da2 = xr.align(ds[item], found_ds[item], join="inner") - if not np.allclose(da1.values, da2.values, equal_nan=True): - raise ValueError( - "Not all data in breakpoints are equivalent. " - "Select a specific node instead of the reach." - ) - else: - found_ds = ds - found_int_id = int_id - - if found_ds is not None and found_int_id is not None: - return NodeModelResult( - data=found_ds, - node=found_int_id, - name=self.name, - item=item, - quantity=self.quantity, - aux_items=self.sel_items.aux, - ) - if missing_node_data: + on_reach = np.flatnonzero(self.data["reach"].values == reach_id) + # A location that carries no data for this quantity is all-NaN here, + # since quantities with different coverage are aligned on the way in. + with_data = self.data[item].isel(node=on_reach).notnull().any("time").values + candidates = self.data.isel(node=on_reach[np.flatnonzero(with_data)]) + + if candidates.sizes["node"] == 0: + raise ValueError(self._explain_no_reach_data(reach_id, item)) + + values = candidates[item].transpose("time", "node").values + if not np.allclose(values, values[:, :1], equal_nan=True): raise ValueError( + "Not all data in breakpoints are equivalent. " + "Select a specific node instead of the reach." + ) + + # Lowest distance first, unknown distances last, so the breakpoint chosen + # does not depend on the numbering mikeio1d happened to hand out. + distance = np.nan_to_num(candidates["distance"].values, nan=np.inf) + order = np.lexsort((candidates["node"].values, distance)) + return self._as_node_result(int(candidates["node"].values[order[0]])) + + def _explain_no_reach_data(self, reach_id: str, item: str) -> str: + # Whether the reach has no such data at all, or has it at breakpoints this + # model result did not load, is a distinction only the network can make. + has_source_data = any( + breakpoint.data is not None and item in breakpoint.data.columns + for breakpoint in self.network.reaches[reach_id].breakpoints + ) + if has_source_data: + return ( f"Reach '{reach_id}' has breakpoint data for quantity " f"'{item}', but matching breakpoint nodes are " "missing from the model dataset. Re-create the NetworkModelResult " "with the relevant reaches populated." ) - - raise ValueError( + return ( f"Reach '{reach_id}' was found in the network but none of its " - f"breakpoints have data loaded for quantity '{self.sel_items.values}'. " + f"breakpoints have data loaded for quantity '{item}'. " f"Re-create the NetworkModelResult with the relevant reaches populated." ) - def _resolve_alias(self, alias: int | str | tuple[str, float]) -> int: - # Resolve a node alias to an internal node ID. - - # Breakpoint tuple aliases are matched first by exact key lookup and then - # by reach ID and distance within ``_CHAINAGE_TOLERANCE``. If multiple - # candidates are within tolerance, the closest distance is selected; ties - # are broken by choosing the smallest node ID. Distance units are the - # same as the network chainage units. + def _as_node_result(self, node_id: int) -> NodeModelResult: + # The location is taken from the network rather than from the observation, + # so a distance given as 24.5001 is recorded as the network's own 24.5. + where = self.network.recall(int(node_id)) + location = ( + where["node"] if "node" in where else (where["reach"], where["distance"]) + ) + data = self.data.sel(node=node_id).drop_vars( + ("node", *self._UPSTREAM_IDENTITY_COORDS), errors="ignore" + ) + return NodeModelResult( + data=data, + node=location, + node_index=int(node_id), + name=self.name, + item=self.sel_items.values, + quantity=self.quantity, + aux_items=self.sel_items.aux, + ) - if isinstance(alias, int): - if alias not in self.data.node: + def _resolve_alias(self, alias: int | str | tuple[str, float]) -> int: + # Delegated to Network.find rather than matched against the dataset's own + # name/reach/distance coords: find() searches the whole topology, so a hit + # that is missing from the dataset is a location whose timeseries was not + # loaded, which is a different mistake from one that does not exist. + if isinstance(alias, (int, np.integer)) and not isinstance(alias, bool): + if alias not in self.data.indexes["node"]: raise ValueError( f"Node {alias} not found. Available: {list(self.nodes[:5])}..." ) - return alias - else: - if alias in self.network._alias_map: - return self.network._alias_map[alias] + return int(alias) + try: if isinstance(alias, tuple): - # Handle tolerances reach_id, distance = alias - candidates: list[tuple[float, int]] = [] - for key, node_id in self.network._alias_map.items(): - if isinstance(key, tuple) and key[0] == reach_id: - diff = abs(key[1] - distance) - if diff <= self._CHAINAGE_TOLERANCE: - candidates.append((diff, node_id)) - if candidates: - return min( - candidates, key=lambda candidate: (candidate[0], candidate[1]) - )[1] - - available = list(self.network._alias_map.keys())[:5] - if isinstance(alias, tuple): - raise ValueError( - f"Breakpoint {alias} not found in network. " - f"Available aliases (first 5): {available}" - ) - raise ValueError( - f"Node alias '{alias}' not found in network. " - f"Available aliases (first 5): {available}" - ) + return int(self.network.find(reach=str(reach_id), distance=distance)) + return int(self.network.find(node=str(alias))) + except KeyError as err: + raise ValueError(f"Location {alias!r} not found. {err.args[0]}") from err diff --git a/src/modelskill/network.py b/src/modelskill/network.py deleted file mode 100644 index b28d13456..000000000 --- a/src/modelskill/network.py +++ /dev/null @@ -1,1205 +0,0 @@ -"""Opt-in network module for network model results (e.g. MIKE 1D / res1d). - -Requires the ``network`` dependency group (networkx, mikeio1d). -Install with:: - - uv sync --group network - -Import this module explicitly to use network functionality:: - - from modelskill.network import Network - -""" - -from __future__ import annotations - -import sys - -from abc import ABC, abstractmethod -from pathlib import Path -from typing import Any, Sequence, overload, TYPE_CHECKING -from copy import deepcopy - -import networkx as nx -import pandas as pd -import xarray as xr - -if TYPE_CHECKING: - from mikeio1d import Res1D - from mikeio1d.result_network import ResultReach - from .model.adapters._res1d import Res1DReach - - -_MIKE_EXTENSIONS = frozenset({".res1d", ".res11"}) -_EPANET_EXTENSIONS = frozenset({".res"}) - -_NO_FIXTURE = ( - "{product} results are not supported yet: modelskill has no test fixture for " - "this format, so support cannot be verified. Please open an issue if you need it." -) -# A result file that holds timeseries but no topology of its own. The connectivity -# is in a companion file we do not parse yet. -_TOPOLOGY_IN_COMPANION_FILE = ( - "SWMM '.out' files carry no reach connectivity of their own - it lives in the " - "companion '.inp' input file, which modelskill does not read yet. Tracked in " - "https://github.com/DHI/modelskill/issues/689." -) -# A companion result file: readable, but it describes a network defined elsewhere. -_COMPANION_RESULT_FILE = ( - "'.resx' holds extra EPANET results (tank volume, pump energy) for a network " - "defined in the sibling '.res' file, so it has no topology of its own. Read the " - "'.res' file and pass this one alongside it: " - "Network.from_epanet(res, resx=...)." -) - -# extension -> why modelskill will not read it, even though mikeio1d can -_UNSUPPORTED_EXTENSIONS: dict[str, str] = { - ".out": _TOPOLOGY_IN_COMPANION_FILE, - ".resx": _COMPANION_RESULT_FILE, - ".prf": _NO_FIXTURE.format(product="MOUSE"), - ".crf": _NO_FIXTURE.format(product="MOUSE"), - ".xrf": _NO_FIXTURE.format(product="MOUSE"), - ".whr": _NO_FIXTURE.format(product="Water Hammer"), -} - -# extension -> the constructor that reads it, for "use X instead" errors -_EXTENSION_CONSTRUCTORS: dict[str, str] = { - **{extension: "from_mike" for extension in _MIKE_EXTENSIONS}, - **{extension: "from_epanet" for extension in _EPANET_EXTENSIONS}, -} - - -def _check_file_path_is_str(res: Res1D) -> None: - """Reject a Res1D opened with a path object rather than a string. - - mikeio1d resolves reach topology with ``str.endswith`` on - ``Res1D.file_path``, which raises ``AttributeError`` from deep inside the - load when that attribute is a ``Path``. Fail here instead, where the cause - can be named. - """ - file_path = getattr(res, "file_path", None) - if file_path is not None and not isinstance(file_path, str): - raise TypeError( - f"This Res1D was opened with a {type(file_path).__name__} file_path, " - "which mikeio1d cannot resolve reach topology from. Re-open it as " - "Res1D(str(path)), or pass the path to the constructor directly." - ) - - -class NetworkNode(ABC): - """Abstract base class for a node in a network. - - A node represents a discrete location in the network (e.g. a junction, - reservoir, or boundary point) that carries time-series data for one or - more physical quantities. - - Three properties must be implemented: - - * :attr:`id` - a unique string identifier for the node. - * :attr:`data` - a time-indexed :class:`pandas.DataFrame` whose columns - are quantity names. - * :attr:`boundary` - a dict of boundary-condition metadata (may be empty). - - The concrete helper :class:`BasicNode` is provided for the common case - where the data is already available as a DataFrame. - - See Also - -------- - BasicNode : Ready-to-use concrete implementation. - NetworkReach : Connects two NetworkNode instances. - Network : Container that assembles nodes and reaches into a graph. - """ - - @property - @abstractmethod - def id(self) -> str: - """Unique string identifier for this node.""" - pass - - @property - @abstractmethod - def data(self) -> pd.DataFrame: - """Time-indexed DataFrame with one column per quantity.""" - pass - - @property - @abstractmethod - def boundary(self) -> dict[str, Any]: - """Boundary-condition metadata dict (may be empty).""" - pass - - @property - def quantities(self) -> list[str]: - """List of quantity names available at this node.""" - return list(self.data.columns) - - -class ReachBreakPoint(ABC): - """Abstract base class for an intermediate break point along a network reach. - - Break points represent locations between the start and end nodes of a - reach (e.g. cross-section chainage points along a river reach) that carry - their own time-series data. - - Two properties must be implemented: - - * :attr:`id` - a ``(reach_id, distance)`` tuple that uniquely locates the - break point within the network. - * :attr:`data` - a time-indexed :class:`pandas.DataFrame` whose columns - are quantity names. - - The :attr:`distance` convenience property returns ``id[1]`` (the - along-reach distance in the units used by the parent network). - - Examples - -------- - Minimal subclass: - - >>> class MyBreakPoint(ReachBreakPoint): - ... def __init__(self, reach_id, chainage, df): - ... self._id = (reach_id, chainage) - ... self._data = df - ... @property - ... def id(self): return self._id - ... @property - ... def data(self): return self._data - - See Also - -------- - NetworkReach : Owns a list of ReachBreakPoint instances. - NetworkNode : Represents a start/end node of a reach. - Network : Assembles reaches (and their break points) into a graph. - """ - - @property - @abstractmethod - def id(self) -> tuple[str, float]: - """``(reach_id, distance)`` tuple uniquely identifying this break point.""" - pass - - @property - @abstractmethod - def data(self) -> pd.DataFrame: - """Time-indexed DataFrame with one column per quantity.""" - pass - - @property - def distance(self) -> float: - """Along-reach distance of this break point, measured from the start node.""" - return self.id[1] - - @property - def quantities(self) -> list[str]: - """List of quantity names available at this break point.""" - return list(self.data.columns) - - -class NetworkReach(ABC): - """Abstract base class for a reach in a network. - - A reach represents a directed connection between two :class:`NetworkNode` - instances (e.g. a river reach between two junctions). It may also carry - a list of :class:`ReachBreakPoint` objects for intermediate chainage - locations. - - Subclass this to integrate your own network topology. Four properties - must be implemented: - - * :attr:`id` - a unique string identifier for the reach. - * :attr:`start` - the upstream/start :class:`NetworkNode`. - * :attr:`end` - the downstream/end :class:`NetworkNode`. - * :attr:`breakpoints` - list of :class:`ReachBreakPoint` instances ordered - by increasing distance from the start node (empty list if none). - - :attr:`length` is optional and defaults to ``None``. Reach length matters - in some domains (rivers, sewer networks) and not in others (link-node water - distribution models), so override it only where a length exists. - - The concrete helper :class:`BasicReach` is provided for the common case - where all data is already available in memory. - - Examples - -------- - Minimal subclass, without a length: - - >>> class MyReach(NetworkReach): - ... def __init__(self, rid, start_node, end_node): - ... self._id = rid - ... self._start = start_node - ... self._end = end_node - ... @property - ... def id(self): return self._id - ... @property - ... def start(self): return self._start - ... @property - ... def end(self): return self._end - ... @property - ... def breakpoints(self): return [] - - Add a :attr:`length` property on top of that when the domain has one: - - >>> class MyMeasuredReach(MyReach): - ... def __init__(self, rid, start_node, end_node, length): - ... super().__init__(rid, start_node, end_node) - ... self._length = length - ... @property - ... def length(self): return self._length - - See Also - -------- - BasicReach : Ready-to-use concrete implementation. - NetworkNode : Represents the start/end of this reach. - ReachBreakPoint : Intermediate data points along this reach. - Network : Assembles a list of NetworkReach objects into a graph. - """ - - @property - @abstractmethod - def id(self) -> str: - """Unique string identifier for this reach.""" - pass - - @property - @abstractmethod - def start(self) -> NetworkNode: - """Start (upstream) node of this reach.""" - pass - - @property - @abstractmethod - def end(self) -> NetworkNode: - """End (downstream) node of this reach.""" - pass - - @property - def length(self) -> float | None: - """Total length of this reach in network units, or ``None`` if undefined.""" - return None - - @property - @abstractmethod - def breakpoints(self) -> list[ReachBreakPoint]: - """Ordered list of intermediate :class:`ReachBreakPoint` objects (may be empty).""" - pass - - @property - def n_breakpoints(self) -> int: - """Number of break points in the reach.""" - return len(self.breakpoints) - - -class BasicNode(NetworkNode): - """Concrete :class:`NetworkNode` for programmatic network construction. - - Parameters - ---------- - id : str - Unique node identifier. - data : pd.DataFrame - Time-indexed DataFrame with one column per quantity. - boundary : dict, optional - Boundary condition metadata, by default empty. - - Examples - -------- - >>> import pandas as pd - >>> time = pd.date_range("2020", periods=3, freq="h") - >>> node = BasicNode("junction_1", pd.DataFrame({"WaterLevel": [1.0, 1.1, 1.2]}, index=time)) - """ - - def __init__( - self, - id: str, - data: pd.DataFrame, - boundary: dict[str, Any] | None = None, - ) -> None: - self._id = id - self._data = data - self._boundary: dict[str, Any] = boundary or {} - - @property - def id(self) -> str: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - @property - def boundary(self) -> dict[str, Any]: - return self._boundary - - -class BasicReach(NetworkReach): - """Concrete :class:`NetworkReach` for programmatic network construction. - - Parameters - ---------- - id : str - Unique reach identifier. - start : NetworkNode - Start node. - end : NetworkNode - End node. - length : float, optional - Reach length, by default None (undefined). - breakpoints : list[ReachBreakPoint], optional - Intermediate break points, by default empty. - - Examples - -------- - >>> reach = BasicReach("reach_1", node_a, node_b, length=250.0) - - Where the domain has no reach length, leave it out: - - >>> reach = BasicReach("pipe_1", node_a, node_b) - """ - - def __init__( - self, - id: str, - start: NetworkNode, - end: NetworkNode, - length: float | None = None, - breakpoints: list[ReachBreakPoint] | None = None, - ) -> None: - self._id = id - self._start = start - self._end = end - self._length = length - self._breakpoints: list[ReachBreakPoint] = breakpoints or [] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float | None: - return self._length - - @property - def breakpoints(self) -> list[ReachBreakPoint]: - return self._breakpoints - - -class Network: - """Network built from a set of reaches, with coordinate lookup and data access.""" - - def __init__(self, reaches: Sequence[NetworkReach]): - graph = self._generate_graph(reaches) - self._initialize_network_attributes(graph) - self._reaches = self._generate_reaches_dict(reaches) - - def _initialize_network_attributes(self, graph: nx.Graph): - self._alias_map = self._generate_alias_map(graph) - self._df = self._build_dataframe(graph) - self._graph = graph.copy() - - def __repr__(self) -> str: - time = self._df.index - time_window = "N/A - N/A" if len(time) == 0 else f"{time[0]} - {time[-1]}" - out = [ - "", - f"Reaches: {len(self._reaches)}", - f"Nodes: {self._graph.number_of_nodes()}", - f"Quantities: {self.quantities}", - f"Time: {time_window}", - ] - return "\n".join(out) - - @classmethod - def from_mike( - cls, - res: str | Path | Res1D, - *, - nodes: str | list[str] | None = None, - reaches: str | list[str] | None = None, - ) -> Network: - """Create a Network from a MIKE 1D or MIKE 11 result file. - - Parameters - ---------- - res : str, Path or Res1D - Path to a ``.res1d`` or ``.res11`` file, or an already-opened - :class:`mikeio1d.Res1D` object. - nodes : str, list of str, or None, optional - Controls which nodes have their timeseries data loaded into memory. - - * ``None`` *(default)* — data is loaded for every node. - * A single node ID or a list of node IDs — only those nodes get - data; others are topology-only. - * ``[]`` (empty list) — no node data is loaded at all. - - The full network topology is always constructed regardless of this - setting, so ``find()`` and ``recall()`` still work on all nodes. - reaches : str, list of str, or None, optional - Controls which reaches have their intermediate gridpoint data - populated. - - * ``None`` *(default)* — gridpoints are populated for every reach. - * A single reach name or a list of reach names — only those reaches - get gridpoint data; others are topology-only. - * ``[]`` (empty list) — no gridpoint data is loaded at all. - - Returns - ------- - Network - - Raises - ------ - NotImplementedError - If the file extension is not one modelskill can read. - ValueError - If the extension belongs to another constructor, such as EPANET. - - Examples - -------- - Load everything (default behaviour): - - >>> from modelskill.network import Network - >>> network = Network.from_mike("model.res1d") - - Load data only for the two nodes where observations exist, and skip - all intermediate gridpoint data to keep memory usage low: - - >>> network = Network.from_mike( - ... "model.res1d", - ... nodes=["node_a", "node_b"], - ... reaches=[], - ... ) - - Load data for selected nodes and gridpoints for one specific reach: - - >>> network = Network.from_mike( - ... "model.res1d", - ... nodes=["node_a", "node_b"], - ... reaches=["reach_1"], - ... ) - - Notes - ----- - MIKE 11 keeps its timeseries on reach gridpoints rather than on nodes, - so the nodes of a ``.res11`` network carry no data of their own. Pass - ``reaches`` rather than ``nodes`` to control what gets loaded. - - See Also - -------- - from_epanet : Read an EPANET result file. - """ - return cls._from_mikeio1d( - res, - nodes=nodes, - reaches=reaches, - allowed=_MIKE_EXTENSIONS, - caller="from_mike", - ) - - @classmethod - def from_epanet( - cls, - res: str | Path | Res1D, - *, - resx: str | Path | Res1D | None = None, - inp: str | Path | None = None, - nodes: str | list[str] | None = None, - reaches: str | list[str] | None = None, - ) -> Network: - """Create a Network from an EPANET result file and its companions. - - An EPANET run writes up to three files that modelskill can use. The - ``.res`` holds the network and its main timeseries; the optional - ``.resx`` holds extra results; and the optional ``.inp`` is the input - file, which is the only one of the three carrying reach lengths. - - Parameters - ---------- - res : str, Path or Res1D - Path to a ``.res`` file, or an already-opened - :class:`mikeio1d.Res1D` object. - resx : str, Path, Res1D or None, optional - Companion ``.resx`` file from the same run. Its extra node - quantities (tank ``Volume`` and ``Volume Percentage``) are merged - onto the matching nodes. By default None, and those quantities are - simply absent. - inp : str, Path or None, optional - EPANET ``.inp`` input file for the same model, read for its - ``[PIPES]`` lengths. By default None, and reach lengths are - undefined. - nodes : str, list of str, or None, optional - Which nodes get their timeseries loaded. See :meth:`from_mike`. - reaches : str, list of str, or None, optional - Which reaches get their gridpoint data loaded. See - :meth:`from_mike`. EPANET results have no intermediate gridpoints, - so this argument has no effect. - - Returns - ------- - Network - - Raises - ------ - NotImplementedError - If the file extension is not one modelskill can read. - ValueError - If the extension belongs to another constructor, such as MIKE, if a - companion file has the wrong extension, or if ``resx`` does not come - from the same run as ``res``. - - Examples - -------- - >>> from modelskill.network import Network - >>> network = Network.from_epanet("model.res") - - With both companions, for real edge lengths and the extra quantities: - - >>> network = Network.from_epanet( - ... "model.res", - ... resx="model.resx", - ... inp="model.inp", - ... ) - - Notes - ----- - EPANET is a link-node model, and mikeio1d reports no length and a - single synthetic gridpoint for each of its reaches. As a result: - - * without ``inp``, every edge of :attr:`graph` has ``length=None``, so a - length-weighted graph algorithm fails rather than returning a - meaningless number. Pumps and valves keep ``length=None`` even with - ``inp``, since ``[PIPES]`` is the only section carrying lengths - * reaches have no breakpoints, so - :class:`~modelskill.obs.ReachObservation` cannot be matched against - an EPANET network — use :class:`~modelskill.obs.NodeObservation` - * ``find(reach=..., distance=)`` never resolves; only - ``distance="start"`` and ``distance="end"`` work - - For the same reason, ``resx`` merges node quantities only. Its - reach-level quantities (pump energy, efficiency and costs) have no - breakpoint to live on, which is tracked in issue #680. - - Node timeseries, :meth:`to_dataframe`, :meth:`to_dataset`, - ``find(node=...)`` and :meth:`recall` are unaffected. - - See Also - -------- - from_mike : Read a MIKE 1D or MIKE 11 result file. - """ - return cls._from_mikeio1d( - res, - nodes=nodes, - reaches=reaches, - allowed=_EPANET_EXTENSIONS, - caller="from_epanet", - resx=resx, - inp=inp, - ) - - @classmethod - def _from_mikeio1d( - cls, - res: str | Path | Res1D, - *, - nodes: str | list[str] | None, - reaches: str | list[str] | None, - allowed: frozenset[str], - caller: str, - resx: str | Path | Res1D | None = None, - inp: str | Path | None = None, - ) -> Network: - """Shared implementation behind the public ``from_*`` constructors. - - Parameters - ---------- - allowed : frozenset of str - Extensions this constructor accepts. - caller : str - Name of the public method, used in error messages. - resx : str, Path, Res1D or None, optional - Companion result file whose node quantities are merged in. - inp : str, Path or None, optional - Companion input file read for reach lengths. - """ - if sys.version_info >= (3, 14): - raise NotImplementedError( - f"Current version of 'mikeio1d' requires python < 3.14 and {sys.version} is being used." - ) - - from mikeio1d import Res1D as _Res1D - - if isinstance(res, (str, Path)): - path = Path(res) - cls._validate_extension(path.suffix, allowed=allowed, caller=caller) - res = _Res1D(str(path)) - elif isinstance(res, _Res1D): - _check_file_path_is_str(res) - suffix = Path(res.file_path).suffix - cls._validate_extension(suffix, allowed=allowed, caller=caller) - else: - raise TypeError( - f"Expected a str, Path or Res1D object, got {type(res).__name__!r}" - ) - - if nodes is None: - nodes_list: list[str] = list(res.nodes.keys()) - elif isinstance(nodes, str): - nodes_list = [nodes] - else: - nodes_list = list(nodes) - - if reaches is None: - reaches_list: list[str] = list(res.reaches.keys()) - elif isinstance(reaches, str): - reaches_list = [reaches] - else: - reaches_list = list(reaches) - - extra = None if resx is None else cls._open_companion_result(res, resx) - lengths = None if inp is None else cls._read_companion_lengths(inp) - - list_of_reaches = cls._load_res1d_network( - res, nodes_list, reaches_list, extra=extra, lengths=lengths - ) - return cls(list_of_reaches) - - @staticmethod - def _read_companion_lengths(inp: str | Path) -> dict[str, float]: - """Read reach lengths from a companion ``.inp`` input file.""" - from modelskill.model.adapters._inp import read_pipe_lengths - - path = Path(inp) - if path.suffix.lower() != ".inp": - raise ValueError( - f"Expected an EPANET '.inp' input file, got '{path.suffix}'. " - "This argument reads reach lengths from the model input, not " - "from a result file." - ) - return read_pipe_lengths(path) - - @staticmethod - def _open_companion_result(res: Res1D, resx: str | Path | Res1D) -> Res1D: - """Open and validate a companion ``.resx`` result file. - - Raises - ------ - ValueError - If the extension is not ``.resx``, or if the file does not come from - the same run as ``res``. - """ - from mikeio1d import Res1D as _Res1D - - if isinstance(resx, (str, Path)): - path = Path(resx) - if path.suffix.lower() != ".resx": - raise ValueError( - f"Expected an EPANET '.resx' companion file, got '{path.suffix}'." - ) - extra = _Res1D(str(path)) - elif isinstance(resx, _Res1D): - _check_file_path_is_str(resx) - if Path(resx.file_path).suffix.lower() != ".resx": - raise ValueError( - "Expected an EPANET '.resx' companion file, got " - f"'{Path(resx.file_path).suffix}'." - ) - extra = resx - else: - raise TypeError( - f"Expected a str, Path or Res1D object, got {type(resx).__name__!r}" - ) - - # Merging two different runs would line up silently and produce a network - # that is wrong in a way no later error would reveal. - if not res.time_index.equals(extra.time_index): - raise ValueError( - "The '.resx' companion does not share a time axis with the " - "'.res' file, so the two are not from the same run. Got " - f"{len(extra.time_index)} steps ending {extra.end_time} against " - f"{len(res.time_index)} ending {res.end_time}." - ) - - unknown_nodes = set(extra.nodes) - set(res.nodes) - if unknown_nodes: - raise ValueError( - f"The '.resx' companion holds nodes {sorted(unknown_nodes)} that are " - "absent from the '.res' network, so the two files do not describe " - "the same model." - ) - - unknown_reaches = set(extra.reaches) - set(res.reaches) - if unknown_reaches: - raise ValueError( - f"The '.resx' companion holds reaches {sorted(unknown_reaches)} that are " - "absent from the '.res' network, so the two files do not describe " - "the same model." - ) - - return extra - - @staticmethod - def _validate_extension( - suffix: str, *, allowed: frozenset[str], caller: str - ) -> None: - """Check a file extension against mikeio1d and against one constructor. - - Raises - ------ - NotImplementedError - If modelskill cannot read the extension, either because mikeio1d - does not support it or because modelskill does not. - ValueError - If another constructor is the one that reads this extension. - """ - from mikeio1d import Res1D as _Res1D - - extension = suffix.lower() - - # Checked before the supported set below, since these all *are* readable - # by mikeio1d - it is modelskill that cannot use the result. - reason = _UNSUPPORTED_EXTENSIONS.get(extension) - if reason is not None: - raise NotImplementedError(f"Cannot read '{suffix}' files. {reason}") - - supported = _Res1D.get_supported_file_extensions() - if extension not in supported: - readable = sorted(supported - set(_UNSUPPORTED_EXTENSIONS)) - raise NotImplementedError( - f"Unsupported file extension '{suffix}'. " - f"Supported extensions are {readable}." - ) - - if extension not in allowed: - constructor = _EXTENSION_CONSTRUCTORS.get(extension) - if constructor is None: - raise NotImplementedError( - f"File extension '{suffix}' is supported by mikeio1d but is not mapped " - "to a Network constructor in this version of modelskill. " - "Please upgrade modelskill or open an issue." - ) - raise ValueError( - f"Network.{caller}() reads {sorted(allowed)} files, got '{suffix}'. " - f"Use Network.{constructor}() instead." - ) - - @staticmethod - def _load_res1d_network( - res: Res1D, - nodes: list[str], - reaches: list[str], - *, - extra: Res1D | None = None, - lengths: dict[str, float] | None = None, - ) -> list[Res1DReach]: - from modelskill.model.adapters._res1d import ( - Res1DReach, - Res1DNode, - _merge_extra_quantities, - _simplify_colnames, - ) - - nodes_set = set(nodes) - reaches_set = set(reaches) - lengths = lengths or {} - - # In order to work with bigger files, we might want to select a subset of nodes and avoid - # potential memory issues. For this reason, we create this intermediate step that populates - # only the data in the passed nodes - - def _init_node(reach: ResultReach, is_end: bool) -> Res1DNode: - id = reach.end_node if is_end else reach.start_node - gpt_idx = -1 if is_end else 0 - if id in nodes_set: - node = res.nodes[id] - df = _simplify_colnames(node) - # Merged here rather than up front so selective loading still - # decides what is held in memory. - if extra is not None and id in extra.nodes: - df = _merge_extra_quantities( - df, _simplify_colnames(extra.nodes[id]), node_id=id - ) - overlapping_gridpoint = reach.gridpoints[gpt_idx] - boundary = _simplify_colnames(overlapping_gridpoint) - return Res1DNode(id, data=df, boundary={reach.name: boundary}) - else: - return Res1DNode(id) - - return [ - Res1DReach( - reach, - _init_node(reach, False), - _init_node(reach, True), - populate_gridpoints=reach.name in reaches_set, - length=lengths.get(reach.name), - ) - for reach in res.reaches.values() - ] - - @staticmethod - def _generate_alias_map(g: nx.Graph) -> dict[str | tuple[str, float], int]: - return {g.nodes[id]["alias"]: id for id in g.nodes()} - - @staticmethod - def _generate_reaches_dict( - reaches: Sequence[NetworkReach], - ) -> dict[str, NetworkReach]: - return {r.id: r for r in reaches} - - @staticmethod - def _build_dataframe(g: nx.Graph) -> pd.DataFrame: - data_in_nodes = { - k: v["data"] - for k, v in g.nodes.items() - if v["data"] is not None and not v["data"].empty - } - if len(data_in_nodes) == 0: - columns = pd.MultiIndex.from_arrays([[], []], names=["node", "quantity"]) - return pd.DataFrame(index=pd.Index([], name="time"), columns=columns) - df = pd.concat(data_in_nodes, axis=1) - df.columns = df.columns.set_names(["node", "quantity"]) - df.index.name = "time" - return df.copy() - - def to_dataframe(self, sel: str | None = None) -> pd.DataFrame: - """Dataframe using node ids as column names. - - It will be multiindex unless 'sel' is passed. - - Parameters - ---------- - sel : Optional[str], optional - Quantity to select, by default None - - Returns - ------- - pd.DataFrame - Timeseries contained in graph nodes - """ - df = self._df.copy() - if sel is None: - return df - else: - df.attrs["quantity"] = sel - return df.reorder_levels(["quantity", "node"], axis=1).loc[:, sel] - - def to_dataset(self) -> xr.Dataset: - """Dataset using node ids as coords. - - Returns - ------- - xr.Dataset - Timeseries contained in graph nodes - """ - df_raw = self.to_dataframe() - if len(df_raw.columns) == 0: - return xr.Dataset() - df = df_raw.reorder_levels(["quantity", "node"], axis=1) - quantities = df.columns.get_level_values("quantity").unique() - return xr.Dataset( - { - q: xr.DataArray( - df[q], dims=["time", "node"], attrs={"long_name": str(q)} - ) - for q in quantities - } - ) - - @property - def graph(self) -> nx.Graph: - """Graph of the network.""" - return self._graph - - @property - def quantities(self) -> list[str]: - """Quantities present in data. - - Returns - ------- - List[str] - List of quantities - """ - return list(self.to_dataframe().columns.get_level_values(1).unique()) - - @staticmethod - def _generate_graph(reaches: Sequence[NetworkReach]) -> nx.Graph: - g0 = nx.Graph() - for reach in reaches: - # 1) Add start and end nodes - for node in [reach.start, reach.end]: - node_key = node.id - if node_key in g0.nodes: - g0.nodes[node_key]["boundary"].update(node.boundary) - else: - g0.add_node(node_key, data=node.data, boundary=node.boundary) - - # 2) Add edges connecting start/end nodes to their adjacent breakpoints - start_key = reach.start.id - end_key = reach.end.id - if reach.n_breakpoints == 0: - g0.add_edge(start_key, end_key, length=reach.length) - else: - bp_keys = [bp.id for bp in reach.breakpoints] - for bp, bp_key in zip(reach.breakpoints, bp_keys): - g0.add_node(bp_key, data=bp.data) - - g0.add_edge(start_key, bp_keys[0], length=reach.breakpoints[0].distance) - - # Only the final segment needs the total length. Break point - # distances are known even when the total is not, so a reach - # without a length still gets real lengths on every edge but - # this one. - tail_length = ( - None - if reach.length is None - else reach.length - reach.breakpoints[-1].distance - ) - g0.add_edge(bp_keys[-1], end_key, length=tail_length) - - # 3) Connect consecutive intermediate breakpoints - for i in range(reach.n_breakpoints - 1): - current_ = reach.breakpoints[i] - next_ = reach.breakpoints[i + 1] - length = next_.distance - current_.distance - g0.add_edge( - current_.id, - next_.id, - length=length, - ) - - return nx.convert_node_labels_to_integers(g0, label_attribute="alias") - - @overload - def find( - self, - *, - node: str, - reach: None = None, - distance: None = None, - ) -> int: - pass - - @overload - def find( - self, - *, - node: list[str], - reach: None = None, - distance: None = None, - ) -> list[int]: - pass - - @overload - def find( - self, - *, - node: None = None, - reach: str | list[str], - distance: str | float, - ) -> int: - pass - - @overload - def find( - self, - *, - node: None = None, - reach: str | list[str], - distance: list[str | float], - ) -> list[int]: - pass - - def find( - self, - node: str | list[str] | None = None, - reach: str | list[str] | None = None, - distance: str | float | list[str | float] | None = None, - ) -> int | list[int]: - """Find node or breakpoint id in the Network object based on former coordinates. - - Parameters - ---------- - node : str | List[str], optional - Node id(s) in the original network, by default None - reach : str | List[str], optional - Reach id(s) for breakpoint lookup or reach endpoint lookup, by default None - distance : str | float | List[str | float], optional - Distance(s) along reach for breakpoint lookup, or "start"/"end" - for reach endpoints, by default None - - Returns - ------- - int | List[int] - Node or breakpoint id(s) in the generic network - - Raises - ------ - ValueError - If invalid combination of parameters is provided - KeyError - If requested node/breakpoint is not found in the network - """ - by_node = node is not None - by_breakpoint = reach is not None or distance is not None - - if by_node and by_breakpoint: - raise ValueError( - "Cannot specify both 'node' and 'reach'/'distance' parameters simultaneously" - ) - - if not by_node and not by_breakpoint: - raise ValueError( - "Must specify either 'node' or both 'reach' and 'distance' parameters" - ) - - ids: list[str | tuple[str, float]] - - if by_node: - assert node is not None - if not isinstance(node, list): - node = [node] - ids = list(node) - - else: - if reach is None or distance is None: - raise ValueError( - "Both 'reach' and 'distance' parameters are required for breakpoint/endpoint lookup" - ) - - if not isinstance(reach, list): - reach = [reach] - - if not isinstance(distance, list): - distance = [distance] - - if len(reach) == 1: - reach = reach * len(distance) - - if len(reach) != len(distance): - raise ValueError( - "Incompatible lengths of 'reach' and 'distance' arguments. One 'reach' admits multiple distances, otherwise they must be the same length." - ) - - ids = [] - for reach_i, distance_i in zip(reach, distance): - if distance_i in ["start", "end"]: - if reach_i not in self._reaches: - raise KeyError(f"Reach '{reach_i}' not found in the network.") - - network_reach = self._reaches[reach_i] - if distance_i == "start": - ids.append(network_reach.start.id) - else: - ids.append(network_reach.end.id) - else: - if not isinstance(distance_i, (int, float)): - raise ValueError( - "Invalid 'distance' value for breakpoint lookup: " - f"{distance_i!r}. Expected a numeric value or 'start'/'end'." - ) - ids.append((reach_i, distance_i)) - - _CHAINAGE_TOLERANCE = 1e-3 - - def _resolve_id(id): - if id in self._alias_map: - return self._alias_map[id] - if isinstance(id, tuple): - reach_id, distance = id - for key, val in self._alias_map.items(): - if ( - isinstance(key, tuple) - and key[0] == reach_id - and abs(key[1] - distance) <= _CHAINAGE_TOLERANCE - ): - return val - return None - - resolved = [_resolve_id(id) for id in ids] - missing_ids = [ids[i] for i, v in enumerate(resolved) if v is None] - if missing_ids: - raise KeyError( - f"Node/breakpoint(s) {missing_ids} not found in the network. Available nodes are {set(self._alias_map.keys())}" - ) - if len(resolved) == 1: - return resolved[0] - return resolved - - @overload - def recall(self, id: int) -> dict[str, Any]: - pass - - @overload - def recall(self, id: list[int]) -> list[dict[str, Any]]: - pass - - def recall(self, id: int | list[int]) -> dict[str, Any] | list[dict[str, Any]]: - """Recover the original coordinates of an element given the node id(s) in the Network object. - - Parameters - ---------- - id : int | List[int] - Node id(s) in the generic network - - Returns - ------- - Dict[str, Any] | List[Dict[str, Any]] - Original coordinates. For single input returns dict, for multiple inputs returns list of dicts. - Dict contains coordinates: - - For nodes: 'node' key with node id - - For breakpoints: 'reach' and 'distance' keys with reach id and distance - - Raises - ------ - KeyError - If node id is not found in the network - ValueError - If node id string format is invalid - """ - if not isinstance(id, list): - id = [id] - - reverse_alias_map = {v: k for k, v in self._alias_map.items()} - - results: list[dict[str, Any]] = [] - for node_id in id: - if node_id not in reverse_alias_map: - raise KeyError(f"Node ID {node_id} not found in the network.") - - key = reverse_alias_map[node_id] - if isinstance(key, str): - results.append({"node": key}) - else: - results.append({"reach": key[0], "distance": key[1]}) - - if len(results) == 1: - return results[0] - else: - return results - - def copy(self) -> "Network": - """Create a deep copy of the Network. - - Returns - ------- - Network - Deep copy of the Network object - """ - return deepcopy(self) - - -def _make_basic_network(node_ids, time, data, quantity="WaterLevel"): - nodes = [ - BasicNode(nid, pd.DataFrame({quantity: data[:, i]}, index=time)) - for i, nid in enumerate(node_ids) - ] - reaches = [ - BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) - for i in range(len(nodes) - 1) - ] - return Network(reaches) diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 5f50f8f28..f77e087a1 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -454,9 +454,9 @@ def test_save_and_load_preserves_raw_model_data(cc, tmp_path): @pytest.fixture def node_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a NodeObservation against a NetworkModelResult (node gtype).""" - pytest.importorskip("networkx") + pytest.importorskip("mikeio1d.network") + from mikeio1d.network import Network, BasicNode, BasicReach from modelskill.model.network import NetworkModelResult - from modelskill.network import Network, BasicNode, BasicReach from modelskill.obs import NodeObservation time = pd.date_range("2019-01-01", periods=6, freq="D") @@ -480,9 +480,14 @@ def node_comparer() -> modelskill.comparison.Comparer: @pytest.fixture def reach_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a ReachObservation (reach gtype).""" - pytest.importorskip("networkx") + pytest.importorskip("mikeio1d.network") + from mikeio1d.network import ( + Network, + BasicNode, + BasicReach, + ReachBreakPoint, + ) from modelskill.model.network import NetworkModelResult - from modelskill.network import Network, BasicNode, BasicReach, ReachBreakPoint from modelskill.obs import ReachObservation class Point(ReachBreakPoint): diff --git a/tests/test_match.py b/tests/test_match.py index 3324f4788..3e5bcf37d 100644 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -7,10 +7,21 @@ import modelskill as ms from modelskill.comparison._comparison import ItemSelection from modelskill.model.dfsu import DfsuModelResult -try: - from modelskill.network import _make_basic_network -except ImportError: - pass + + +def _make_basic_network(node_ids, time, data, quantity="WaterLevel"): + """A chain of nodes, each carrying one quantity, joined by unit reaches.""" + from mikeio1d.network import Network, BasicNode, BasicReach + + nodes = [ + BasicNode(node_id, pd.DataFrame({quantity: data[:, i]}, index=time)) + for i, node_id in enumerate(node_ids) + ] + reaches = [ + BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) + for i in range(len(nodes) - 1) + ] + return Network(reaches) @pytest.fixture @@ -366,7 +377,7 @@ def network_mr(network): @pytest.fixture def node_obs1(network): """NodeObservation for node '100'""" - node_id = network.find(node="100") + node_id = "100" time = pd.date_range("2017-10-27", periods=18, freq="h") # Add some noise to make it different from model np.random.seed(123) @@ -378,7 +389,7 @@ def node_obs1(network): @pytest.fixture def node_obs2(network): """NodeObservation for node '200'""" - node_id = network.find(node="200") + node_id = "200" time = pd.date_range("2017-10-27", periods=15, freq="h") np.random.seed(456) data = np.random.normal(1.6, 0.25, len(time)) @@ -410,7 +421,7 @@ def network_mr2(network2): @pytest.fixture def node_obs_gaps(network): """NodeObservation with time gaps""" - node_id = network.find(node="100") + node_id = "100" time = pd.date_range("2017-10-27", periods=10, freq="2h") # Different frequency data = np.random.normal(1.5, 0.2, len(time)) df = pd.DataFrame({"WaterLevel": data}, index=time) @@ -1064,7 +1075,8 @@ def test_network_match_multi_obs_multi_model_comprehensive( def test_network_match_error_non_node_observation(network_mr, point_obs_error): """Test that non-NodeObservation raises appropriate error""" with pytest.raises( - TypeError, match="NetworkModelResult supports NodeObservation and ReachObservation" + TypeError, + match="NetworkModelResult supports NodeObservation and ReachObservation", ): ms.match(point_obs_error, network_mr) diff --git a/tests/test_network.py b/tests/test_network.py index 76c145394..250a6d83f 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -2,39 +2,39 @@ # ruff: noqa: E402 import sys -from pathlib import Path import pytest -pytest.importorskip("networkx") +pytest.importorskip("mikeio1d.network") import pandas as pd import xarray as xr import numpy as np import modelskill as ms +from mikeio1d.network import Network, BasicNode, BasicReach, ReachBreakPoint from modelskill.model.network import ( NetworkModelResult, NodeModelResult, ) -from modelskill.model.adapters._inp import read_pipe_lengths, read_sections -from modelskill.model.adapters._res1d import ( - Res1DNode, - Res1DReach, - _simplify_colnames, -) -from modelskill.network import ( - Network, - BasicNode, - BasicReach, - NetworkReach, - ReachBreakPoint, - _EPANET_EXTENSIONS, - _MIKE_EXTENSIONS, - _UNSUPPORTED_EXTENSIONS, -) from modelskill.obs import NodeObservation, ReachObservation from modelskill.quantity import Quantity +class BreakPoint(ReachBreakPoint): + """A break point at a known distance along a reach.""" + + def __init__(self, reach, distance, data): + self._id = (reach, distance) + self._data = data + + @property + def id(self): + return self._id + + @property + def data(self): + return self._data + + def _make_network(node_ids, time, data, quantity="WaterLevel"): nodes = [ BasicNode(nid, pd.DataFrame({quantity: data[:, i]}, index=time)) @@ -123,6 +123,23 @@ def dataset_without_node(): return ds +@pytest.fixture +def breakpoint_network(): + """A one-reach network whose data sits on a break point, not on the nodes.""" + time = pd.date_range("2010-01-01", periods=10, freq="h") + np.random.seed(42) + values = pd.DataFrame({"WaterLevel": np.random.randn(10)}, index=time) + empty = pd.DataFrame() + reach = BasicReach( + "r1", + BasicNode("start", empty), + BasicNode("end", empty), + length=100.0, + breakpoints=[BreakPoint("r1", 50.0, values)], + ) + return Network([reach]) + + @pytest.fixture def sample_node_data(): """Sample node observation data""" @@ -215,7 +232,7 @@ def test_repr(self, sample_network): def test_extract_valid_node(self, sample_network, sample_node_data): """Test extraction of a valid node""" nmr = NetworkModelResult(sample_network) - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123") extracted = nmr.extract(obs) @@ -490,7 +507,7 @@ class TestNetworkIntegration: def test_network_to_node_extraction(self, sample_network, sample_node_data): """Test complete workflow from network model to node extraction""" nmr = NetworkModelResult(sample_network, name="Network_Model") - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123_Obs") extracted = nmr.extract(obs) @@ -503,7 +520,7 @@ def test_network_to_node_extraction(self, sample_network, sample_node_data): def test_matching_workflow(self, sample_network, sample_node_data): """Test matching workflow with network data""" nmr = NetworkModelResult(sample_network, name="Network_Model") - node_id = sample_network.find(node="123") + node_id = "123" obs = NodeObservation(sample_node_data, at=node_id, name="Node_123_Obs") comparer = ms.match(obs, nmr) @@ -524,9 +541,9 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data } ) - node_0 = sample_network.find(node="123") - node_1 = sample_network.find(node="456") - node_2 = sample_network.find(node="789") + node_0 = "123" + node_1 = "456" + node_2 = "789" # Create multiple NodeObservations using .from_multiple obs_list = NodeObservation.from_multiple( @@ -548,10 +565,11 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data @pytest.mark.skipif( sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" ) -def test_open_res1d(): - path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) - assert network.graph.number_of_nodes() == 259 +def test_a_model_result_can_be_built_from_a_result_file(): + mr = NetworkModelResult("./tests/testdata/network.res1d", item="WaterLevel") + + assert mr.quantity.name == "WaterLevel" + assert len(mr.nodes) > 0 @pytest.mark.skipif( @@ -559,7 +577,7 @@ def test_open_res1d(): ) def test_extract_reach_observation_happy_path(sample_node_data): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge", name="network_model") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") @@ -568,7 +586,8 @@ def test_extract_reach_observation_happy_path(sample_node_data): assert isinstance(extracted, NodeModelResult) assert extracted.name == "network_model" - assert extracted.node in nmr.nodes + reach, _ = extracted.node + assert reach == "100l1" @pytest.mark.skipif( @@ -576,7 +595,7 @@ def test_extract_reach_observation_happy_path(sample_node_data): ) def test_extract_reach_observation_non_equivalent_breakpoints_raises(sample_node_data): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) obs = ms.ReachObservation(obs_data, reach="113l1", item="Discharge") @@ -592,7 +611,7 @@ def test_extract_reach_observation_with_reaches_not_populated_raises_valueerror( sample_node_data, ): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, reaches=[]) + network = Network.open(path_to_file, reaches=[]) nmr = NetworkModelResult(network, item="WaterLevel") obs = ms.ReachObservation(sample_node_data, reach="100l1", item="WaterLevel") @@ -607,17 +626,13 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( sample_node_data, ): path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file) + network = Network.open(path_to_file) nmr = NetworkModelResult(network, item="Discharge") obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) - baseline_obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") - node_id = nmr.extract(baseline_obs).node - remaining_nodes = [] - for node in nmr.data.node.values: - node_int = int(node) - if node_int != node_id: - remaining_nodes.append(node_int) - nmr.data = nmr.data.sel(node=remaining_nodes) + on_reach = set(nmr.data.node.values[nmr.data["reach"].values == "100l1"]) + nmr.data = nmr.data.sel( + node=[int(node) for node in nmr.data.node.values if node not in on_reach] + ) obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") @@ -625,303 +640,6 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( nmr.extract(obs) -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_filter_creates_full_network(): - """When nodes is specified, the full network topology is created.""" - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - - selected_nodes = ["1", "108"] - partial_network = Network.from_mike(path_to_file, nodes=selected_nodes) - - # Full topology is preserved - assert ( - partial_network.graph.number_of_nodes() == full_network.graph.number_of_nodes() - ) - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_filter_only_selected_have_data(): - """When nodes is specified, only selected nodes contain non-empty data.""" - path_to_file = "./tests/testdata/network.res1d" - - selected_nodes = ["1", "108"] - network = Network.from_mike(path_to_file, nodes=selected_nodes, reaches=[]) - g = network.graph.copy() - - n_nodes = network.graph.number_of_nodes() - assert sum([g.nodes[n]["data"].empty for n in g.nodes]) == n_nodes - 2 - for n in selected_nodes: - assert not g.nodes[network.find(n)]["data"].empty - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_nodes_single_string(): - """nodes argument accepts a single string (not just a list).""" - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - - network = Network.from_mike(path_to_file, nodes="108", reaches=[]) - g = network.graph.copy() - - assert g.number_of_nodes() == full_network.graph.number_of_nodes() - - nodes_with_data = [n for n in g.nodes if not g.nodes[n]["data"].empty] - nodes_with_data = [network.recall(n)["node"] for n in nodes_with_data] - assert nodes_with_data == ["108"] - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_dataframe_from_partial_network(): - """nodes argument accepts a single string (not just a list).""" - path_to_file = "./tests/testdata/network.res1d" - selected_nodes = ["108", "101"] - network = Network.from_mike(path_to_file, nodes=selected_nodes, reaches=[]) - nodes_in_df = network.to_dataframe().droplevel(axis=1, level=1).columns - - assert set(nodes_in_df) == set([network.find(n) for n in selected_nodes]) - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_nodes_filtered_network_keeps_datetime_index(): - """Topology-only nodes must not degrade the time index to object dtype. - - A nodes-filtered network keeps the full topology, storing empty data for - the unselected nodes. Concatenating those empty (RangeIndex) frames must - not corrupt the DatetimeIndex, otherwise ms.match() later fails with - "time must be datetime". - """ - path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, nodes=["108", "101"], reaches=[]) - - assert isinstance(network._df.index, pd.DatetimeIndex) - assert network._df.index.dtype == "datetime64[ns]" - assert network.to_dataset()["time"].dtype == np.dtype("datetime64[ns]") - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_res1d_empty_nodes_and_reaches_keeps_topology_and_empty_outputs(): - path_to_file = "./tests/testdata/network.res1d" - network = Network.from_mike(path_to_file, nodes=["108", "101"], reaches=[]) - - assert isinstance(network._df.index, pd.DatetimeIndex) - assert network._df.index.dtype == "datetime64[ns]" - assert network.to_dataset()["time"].dtype == np.dtype("datetime64[ns]") - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_from_mike_empty_nodes_and_reaches_keeps_topology_and_empty_outputs(): - path_to_file = "./tests/testdata/network.res1d" - full_network = Network.from_mike(path_to_file) - network = Network.from_mike(path_to_file, nodes=[], reaches=[]) - - assert network.graph.number_of_nodes() == full_network.graph.number_of_nodes() - - df = network.to_dataframe() - assert df.empty - assert isinstance(df.columns, pd.MultiIndex) - assert df.columns.names == ["node", "quantity"] - assert df.index.name == "time" - - ds = network.to_dataset() - assert isinstance(ds, xr.Dataset) - assert len(ds.data_vars) == 0 - - -# --------------------------------------------------------------------------- -# Optional reach length -# --------------------------------------------------------------------------- - - -class _StubBreakPoint(ReachBreakPoint): - """Minimal concrete ReachBreakPoint for building reaches by hand.""" - - def __init__(self, reach_id, distance, data=None): - self._id = (reach_id, distance) - self._data = pd.DataFrame() if data is None else data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -def _two_node_pair(): - time = pd.date_range("2020", periods=3, freq="h") - df = pd.DataFrame({"WaterLevel": [1.0, 1.1, 1.2]}, index=time) - return BasicNode("a", df), BasicNode("b", df.copy()) - - -class TestOptionalReachLength: - """Reach length is undefined in some domains, so it must be omittable.""" - - def test_subclass_may_omit_length(self): - class LengthlessReach(NetworkReach): - def __init__(self, id, start, end): - self._id, self._start, self._end = id, start, end - - @property - def id(self): - return self._id - - @property - def start(self): - return self._start - - @property - def end(self): - return self._end - - @property - def breakpoints(self): - return [] - - a, b = _two_node_pair() - reach = LengthlessReach("r1", a, b) - - assert reach.length is None - assert Network([reach]).graph.number_of_nodes() == 2 - - def test_basic_reach_length_defaults_to_none(self): - a, b = _two_node_pair() - - assert BasicReach("r1", a, b).length is None - - def test_edge_length_is_none_when_undefined(self): - a, b = _two_node_pair() - - network = Network([BasicReach("r1", a, b)]) - - assert [d["length"] for *_, d in network.graph.edges(data=True)] == [None] - - def test_breakpoint_distances_survive_an_undefined_length(self): - """Only the final segment needs the total, so the rest keep real lengths.""" - a, b = _two_node_pair() - breakpoints = [_StubBreakPoint("r1", d) for d in (30.0, 70.0)] - - network = Network([BasicReach("r1", a, b, breakpoints=breakpoints)]) - - lengths = sorted( - (d["length"] for *_, d in network.graph.edges(data=True)), - key=lambda v: (v is None, v), - ) - assert lengths == [30.0, 40.0, None] - - def test_length_weighted_algorithms_fail_loudly(self): - """Storing None keeps networkx honest. - - Omitting the attribute instead would let networkx default the weight to - 1, so every call below would return a plausible but meaningless number. - With None, shortest-path treats the edge as hidden and the arithmetic - consumers raise. - """ - import networkx as nx - - a, b = _two_node_pair() - g = Network([BasicReach("r1", a, b)]).graph - - with pytest.raises(nx.NetworkXNoPath): - nx.shortest_path_length(g, 0, 1, weight="length") - - with pytest.raises(TypeError): - g.size(weight="length") - - def test_known_length_is_unchanged(self): - a, b = _two_node_pair() - breakpoints = [_StubBreakPoint("r1", 40.0)] - - network = Network([BasicReach("r1", a, b, 100.0, breakpoints)]) - - assert sorted(d["length"] for *_, d in network.graph.edges(data=True)) == [ - 40.0, - 60.0, - ] - - -# --------------------------------------------------------------------------- -# Which extensions each constructor accepts, and why the rest are refused -# --------------------------------------------------------------------------- - - -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -class TestExtensionPolicy: - @pytest.mark.parametrize("suffix", [".res1d", ".res11", ".RES1D"]) - def test_from_mike_accepts_mike_extensions(self, tmp_path, suffix): - """The file does not exist, so mikeio1d - not the guard - is what complains.""" - with pytest.raises((FileExistsError, FileNotFoundError)): - Network.from_mike(tmp_path / f"network{suffix}") - - def test_error_lists_only_readable_extensions(self): - with pytest.raises(NotImplementedError) as excinfo: - Network.from_mike("network.nc") - - message = str(excinfo.value) - for extension in _MIKE_EXTENSIONS | _EPANET_EXTENSIONS: - assert extension in message - for extension in _UNSUPPORTED_EXTENSIONS: - assert extension not in message - - def test_swmm_refusal_names_the_companion_inp(self): - """A real file, so this fails the day SWMM support lands.""" - with pytest.raises(NotImplementedError, match=r"companion '\.inp'"): - Network.from_mike("./tests/testdata/swmm.out") - - def test_resx_refusal_points_at_the_resx_argument(self): - """'.resx' is a companion, so the message must name what to do instead.""" - with pytest.raises( - NotImplementedError, match=r"from_epanet\(res, resx=\.\.\.\)" - ): - Network.from_mike("./tests/testdata/epanet.resx") - - @pytest.mark.parametrize("suffix", [".prf", ".crf", ".xrf", ".whr"]) - def test_formats_without_a_fixture_are_refused(self, tmp_path, suffix): - with pytest.raises(NotImplementedError, match="no test fixture"): - Network.from_mike(tmp_path / f"network{suffix}") - - def test_every_mikeio1d_extension_is_accounted_for(self): - """A new mikeio1d format must be read or explicitly refused, never ignored.""" - from mikeio1d import Res1D - - accounted_for = ( - _MIKE_EXTENSIONS | _EPANET_EXTENSIONS | set(_UNSUPPORTED_EXTENSIONS) - ) - - assert accounted_for == Res1D.get_supported_file_extensions() - - def test_res1d_opened_with_a_path_is_refused(self): - """mikeio1d calls str.endswith on file_path, so a Path breaks it later on.""" - from mikeio1d import Res1D - - res = Res1D(Path("./tests/testdata/network.res1d")) - - with pytest.raises(TypeError, match="file_path"): - Network.from_mike(res) - - -# --------------------------------------------------------------------------- -# NodeObservation — alias / breakpoint node forms -# --------------------------------------------------------------------------- - - class TestNodeObservationAliases: """NodeObservation accepts int, str alias, and (reach, distance) tuple.""" @@ -986,107 +704,74 @@ def test_string_roundtrip_via_create_new_instance(self, sample_node_data): class TestNetworkModelResultAliasResolution: - """NetworkModelResult.extract() resolves str and tuple aliases via alias_map.""" + """extract() resolves a node name or a (reach, distance) pair to a location.""" - def test_network_stored(self, sample_network): + def test_the_network_is_kept_as_given(self, sample_network): nmr = NetworkModelResult(sample_network) - assert hasattr(nmr, "network") - assert "123" in nmr.network._alias_map - assert "456" in nmr.network._alias_map - assert "789" in nmr.network._alias_map + + assert nmr.network is sample_network def test_extract_with_string_alias(self, sample_network, sample_node_data): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at="123", name="Node_123") + extracted = nmr.extract(obs) - expected_id = sample_network.find(node="123") + assert isinstance(extracted, NodeModelResult) - assert extracted.node == expected_id + assert extracted.node == "123" def test_extract_string_alias_wrong_key_raises( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at="nonexistent_node") + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) - def test_extract_with_tuple_breakpoint(self, sample_network, sample_node_data): - """Tuple alias is resolved via _alias_map (mapping injected for this test).""" - nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - nmr.network._alias_map[("reach_test", 10.0)] = existing_int - obs = NodeObservation(sample_node_data, at=("reach_test", 10.0)) - extracted = nmr.extract(obs) - assert extracted.node == existing_int - - def test_extract_with_tuple_breakpoint_tolerance( + def test_a_failed_lookup_names_the_near_misses( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - nmr.network._alias_map[("reach_test", base_distance)] = existing_int - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol / 2) - ) - extracted = nmr.extract(obs) - assert extracted.node == existing_int + obs = NodeObservation(sample_node_data, at="124") - def test_extract_with_tuple_breakpoint_outside_tolerance_raises( - self, sample_network, sample_node_data - ): - nmr = NetworkModelResult(sample_network) - existing_int = int(sample_network.find(node="123")) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - nmr.network._alias_map[("reach_test", base_distance)] = existing_int - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol + 1e-4) - ) - with pytest.raises(ValueError, match="not found"): + with pytest.raises(ValueError, match="123"): nmr.extract(obs) - def test_extract_with_tuple_breakpoint_uses_closest_within_tolerance( - self, sample_network, sample_node_data - ): - nmr = NetworkModelResult(sample_network) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - node_a = int(sample_network.find(node="123")) - node_b = int(sample_network.find(node="456")) - nmr.network._alias_map[("reach_test", base_distance + 2e-4)] = node_a - nmr.network._alias_map[("reach_test", base_distance + 8e-4)] = node_b + def test_extract_with_tuple_breakpoint(self, breakpoint_network, sample_node_data): + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0)) - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol * 0.6) - ) extracted = nmr.extract(obs) - assert extracted.node == node_b - def test_extract_with_tuple_breakpoint_tie_uses_smallest_node_id( - self, sample_network, sample_node_data + assert extracted.node == ("r1", 50.0) + + def test_extract_with_tuple_breakpoint_tolerance( + self, breakpoint_network, sample_node_data ): - nmr = NetworkModelResult(sample_network) - base_distance = 10.0 - tol = NetworkModelResult._CHAINAGE_TOLERANCE - node_a = int(sample_network.find(node="123")) - node_b = int(sample_network.find(node="456")) - nmr.network._alias_map[("reach_test", base_distance + 4e-4)] = node_a - nmr.network._alias_map[("reach_test", base_distance + 8e-4)] = node_b + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0 + 5e-4)) - obs = NodeObservation( - sample_node_data, at=("reach_test", base_distance + tol * 0.6) - ) extracted = nmr.extract(obs) - assert extracted.node == min(node_a, node_b) + + # The distance recorded is the network's own, not the one typed. + assert extracted.node == ("r1", 50.0) + + def test_extract_with_tuple_breakpoint_outside_tolerance_raises( + self, breakpoint_network, sample_node_data + ): + nmr = NetworkModelResult(breakpoint_network) + obs = NodeObservation(sample_node_data, at=("r1", 50.0 + 2e-3)) + + with pytest.raises(ValueError, match="not found"): + nmr.extract(obs) def test_extract_tuple_alias_wrong_key_raises( self, sample_network, sample_node_data ): nmr = NetworkModelResult(sample_network) obs = NodeObservation(sample_node_data, at=("nonexistent_reach", 0.0)) + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) @@ -1094,421 +779,13 @@ def test_match_with_string_alias(self, sample_network, sample_node_data): """Full ms.match() workflow works end-to-end with a string alias.""" nmr = NetworkModelResult(sample_network, name="Network_Model") obs = NodeObservation(sample_node_data, at="123", name="Node_123") + comparer = ms.match(obs, nmr) + assert comparer.n_points > 0 assert "Network_Model" in comparer.mod_names -# --------------------------------------------------------------------------- -# Res1D adapter — no mikeio1d required, the adapter is duck-typed -# --------------------------------------------------------------------------- - - -class _StubLocation: - """Stands in for a mikeio1d ResultNode / ResultGridPoint.""" - - def __init__(self, quantities, df=None): - self.quantities = quantities - self._df = df - - def to_dataframe(self): - if self._df is None: - raise AssertionError("to_dataframe() should not be called") - return self._df - - -class TestSimplifyColnames: - def test_location_without_quantities_gives_empty_frame(self): - """MIKE 11 keeps its data on gridpoints, leaving nodes with no quantities.""" - df = _simplify_colnames(_StubLocation(quantities=[])) - - assert df.empty - assert list(df.columns) == [] - - def test_quantity_columns_are_stripped_of_location_suffix(self): - time = pd.date_range("2020", periods=2, freq="h") - raw = pd.DataFrame({"WaterLevel:node_1": [1.0, 2.0]}, index=time) - - df = _simplify_colnames(_StubLocation(quantities=["WaterLevel"], df=raw)) - - assert list(df.columns) == ["WaterLevel"] - - -class _StubReach: - """Stands in for a mikeio1d ResultReach.""" - - def __init__(self, name="r1", start_node="a", end_node="b", length=100.0): - self.name = name - self.start_node = start_node - self.end_node = end_node - self.length = length - self.gridpoints = [] - - -class TestRes1DReachConnectivity: - """Formats that expose no reach connectivity must fail with a clear message.""" - - @pytest.mark.parametrize("missing", ["start_node", "end_node"]) - def test_missing_node_raises(self, missing): - reach = _StubReach(**{missing: None}) - - with pytest.raises(ValueError, match="no start/end node for reach 'r1'"): - Res1DReach(reach, Res1DNode("a"), Res1DNode("b")) - - def test_both_nodes_missing_raises(self): - """.resx reports None for both, which the identity checks alone would allow.""" - reach = _StubReach(start_node=None, end_node=None) - - with pytest.raises(ValueError, match="no start/end node"): - Res1DReach(reach, Res1DNode(None), Res1DNode(None)) # type: ignore[arg-type] - - def test_mismatched_start_node_still_raises(self): - with pytest.raises(ValueError, match="Incorrect starting node"): - Res1DReach(_StubReach(), Res1DNode("wrong"), Res1DNode("b")) - - -class TestRes1DReachLength: - """mikeio1d returns 0 when it cannot read a length; that is not a real zero.""" - - @pytest.mark.parametrize("reported", [0, 0.0]) - def test_zero_becomes_undefined(self, reported): - reach = Res1DReach(_StubReach(length=reported), Res1DNode("a"), Res1DNode("b")) - - assert reach.length is None - - def test_real_length_passes_through(self): - reach = Res1DReach(_StubReach(length=47.5), Res1DNode("a"), Res1DNode("b")) - - assert reach.length == 47.5 - - -# --------------------------------------------------------------------------- -# from_mike / from_epanet -# --------------------------------------------------------------------------- - -requires_mikeio1d = pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) - - -@requires_mikeio1d -class TestFromMike: - def test_res1d(self): - network = Network.from_mike("./tests/testdata/network.res1d") - - assert network.graph.number_of_nodes() == 259 - - def test_res11(self): - """MIKE 11 keeps its data on gridpoints, so its nodes are empty.""" - network = Network.from_mike("./tests/testdata/network_cali.res11") - - assert len(network._reaches) == 3 - assert network.graph.number_of_nodes() == 71 - assert set(network.quantities) == {"Discharge", "Water Level"} - assert [r.n_breakpoints for r in network._reaches.values()] == [23, 21, 23] - - def test_res11_reaches_have_real_lengths(self): - network = Network.from_mike("./tests/testdata/network_cali.res11") - - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert all(length > 0 for length in lengths) - - def test_open_res1d_object(self): - from mikeio1d import Res1D - - res = Res1D("./tests/testdata/network.res1d") - - network = Network.from_mike(res, nodes=[], reaches=[]) - - assert network.graph.number_of_nodes() == 259 - - def test_epanet_file_is_redirected(self): - with pytest.raises(ValueError, match=r"Use Network\.from_epanet\(\)"): - Network.from_mike("./tests/testdata/epanet.res") - - def test_unknown_extension(self): - with pytest.raises(NotImplementedError, match="Unsupported file extension"): - Network.from_mike("./tests/testdata/obs.dfs0") - - def test_unsupported_type(self): - with pytest.raises(TypeError, match="Expected a str, Path or Res1D object"): - Network.from_mike(42) # type: ignore[arg-type] - - -@requires_mikeio1d -class TestFromEpanet: - def test_epanet(self): - network = Network.from_epanet("./tests/testdata/epanet.res") - - assert network.graph.number_of_nodes() == 11 - assert len(network._reaches) == 13 - assert set(network.quantities) == { - "Demand", - "Head", - "Pressure", - "WaterQuality", - } - assert not network.to_dataframe().empty - - def test_link_node_reaches_have_no_length_or_breakpoints(self): - """Without inp=, mikeio1d reports neither - documented in the docstring.""" - network = Network.from_epanet("./tests/testdata/epanet.res") - - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert lengths and all(length is None for length in lengths) - assert all(r.n_breakpoints == 0 for r in network._reaches.values()) - - def test_reach_observation_cannot_be_matched(self, sample_node_data): - """Follows from having no breakpoints; also documented in the docstring.""" - network = Network.from_epanet("./tests/testdata/epanet.res") - nmr = NetworkModelResult(network, item="Pressure") - obs = ms.ReachObservation(sample_node_data, reach="10", item="WaterLevel") - - with pytest.raises(ValueError, match="breakpoints"): - nmr.extract(obs) - - def test_mike_file_is_redirected(self): - with pytest.raises(ValueError, match=r"Use Network\.from_mike\(\)"): - Network.from_epanet("./tests/testdata/network.res1d") - - def test_open_res1d_object_is_validated(self): - from mikeio1d import Res1D - - res = Res1D("./tests/testdata/network.res1d") - - with pytest.raises(ValueError, match=r"Use Network\.from_mike\(\)"): - Network.from_epanet(res) - - @pytest.mark.parametrize("suffix", [".res", ".RES"]) - def test_extension_is_case_insensitive(self, tmp_path, suffix): - with pytest.raises((FileExistsError, FileNotFoundError)): - Network.from_epanet(tmp_path / f"network{suffix}") - - -# --------------------------------------------------------------------------- -# EPANET companion files: .inp for reach lengths, .resx for extra quantities -# --------------------------------------------------------------------------- - -_EPANET_RES = "./tests/testdata/epanet.res" -_EPANET_RESX = "./tests/testdata/epanet.resx" -_EPANET_INP = "./tests/testdata/epanet.inp" - -# The 12 [PIPES] entries; reach "9" is the pump, which carries no length. -_PUMP_REACH = "9" - - -@requires_mikeio1d -class TestEpanetCompanionInp: - """`.inp` is the only one of the three files carrying reach lengths.""" - - def test_pipe_reaches_get_real_lengths(self): - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = {r.id: r.length for r in network._reaches.values()} - assert lengths["10"] == pytest.approx(3209.544) - assert lengths["110"] == pytest.approx(60.96) - - def test_pump_reach_stays_undefined(self): - """[PIPES] is the only section with lengths, so pumps keep None.""" - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = {r.id: r.length for r in network._reaches.values()} - assert lengths[_PUMP_REACH] is None - assert sum(v is None for v in lengths.values()) == 1 - - def test_graph_edges_carry_the_lengths(self): - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - lengths = [d["length"] for *_, d in network.graph.edges(data=True)] - assert sum(v is not None for v in lengths) == 12 - - def test_node_ids_overlapping_reach_ids_are_not_confused(self): - """Most IDs here name both a node and a reach, e.g. '9', '10', '21'.""" - network = Network.from_epanet(_EPANET_RES, inp=_EPANET_INP) - - assert set(network._reaches) & set(network._alias_map) # they do overlap - # Reach "10" is 3209.544 long; node "10" is untouched by the length map. - assert network._reaches["10"].length == pytest.approx(3209.544) - node_10 = network.find(node="10") - assert "Head" in network.to_dataframe()[node_10].columns - - def test_wrong_suffix_is_refused(self): - with pytest.raises(ValueError, match=r"Expected an EPANET '\.inp'"): - Network.from_epanet(_EPANET_RES, inp=_EPANET_RESX) - - def test_file_without_a_pipes_section_is_refused(self, tmp_path): - other = tmp_path / "not-epanet.inp" - other.write_text("[JUNCTIONS]\n;;Name\n9 1000\n") - - with pytest.raises(ValueError, match=r"no \[PIPES\] section"): - Network.from_epanet(_EPANET_RES, inp=other) - - -@requires_mikeio1d -class TestEpanetCompanionResx: - """`.resx` holds extra results for the network defined in the sibling `.res`.""" - - def test_extra_node_quantities_are_merged(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - - assert set(network.quantities) == { - "Demand", - "Head", - "Pressure", - "WaterQuality", - "Volume", - "Volume Percentage", - } - - def test_only_the_nodes_present_in_the_resx_gain_them(self): - """The .resx covers the tank and the reservoir, not all eleven nodes.""" - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - df = network.to_dataframe() - - with_volume = { - node - for node in df.columns.get_level_values("node").unique() - if "Volume" in df[node].columns - } - # Node IDs are re-indexed to integers, so recall the original labels. - assert {network.recall(node)["node"] for node in with_volume} == {"2", "9"} - - def test_values_come_through(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX) - - reservoir = network.find(node="9") - volume = network.to_dataframe()[(reservoir, "Volume Percentage")] - assert len(volume) == 25 - assert volume.notna().all() - - def test_selective_loading_still_governs_what_is_read(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX, nodes=["2"]) - - df = network.to_dataframe() - tank = network.find(node="2") - assert set(df.columns.get_level_values("node").unique()) == {tank} - assert "Volume" in df[tank].columns - - def test_both_companions_together(self): - network = Network.from_epanet(_EPANET_RES, resx=_EPANET_RESX, inp=_EPANET_INP) - - assert "Volume" in network.quantities - assert network._reaches["10"].length == pytest.approx(3209.544) - - def test_an_open_res1d_object_is_accepted(self): - from mikeio1d import Res1D - - network = Network.from_epanet(_EPANET_RES, resx=Res1D(_EPANET_RESX)) - - assert "Volume" in network.quantities - - def test_wrong_suffix_is_refused(self): - with pytest.raises(ValueError, match=r"Expected an EPANET '\.resx'"): - Network.from_epanet(_EPANET_RES, resx=_EPANET_RES) - - def test_a_result_file_of_another_format_is_refused(self): - from mikeio1d import Res1D - - other = Res1D("./tests/testdata/network.res1d") - - with pytest.raises(ValueError, match=r"Expected an EPANET '\.resx'"): - Network.from_epanet(_EPANET_RES, resx=other) - - def test_a_companion_from_another_run_is_refused(self, monkeypatch): - """Merging two runs would line up silently and give a wrong network.""" - from mikeio1d import Res1D - - res = Res1D(_EPANET_RES) - resx = Res1D(_EPANET_RESX) - shifted = resx.time_index + pd.Timedelta("1D") - - # Both objects share the Res1D class, so shift only this one instance. - original = type(resx).time_index.fget - monkeypatch.setattr( - type(resx), - "time_index", - property(lambda self: shifted if self is resx else original(self)), - ) - - with pytest.raises(ValueError, match="does not share a time axis"): - Network.from_epanet(res, resx=resx) - - def test_a_companion_naming_an_unknown_node_is_refused(self, monkeypatch): - """A node the .res has never heard of means these are different models.""" - from mikeio1d import Res1D - - res = Res1D(_EPANET_RES) - resx = Res1D(_EPANET_RESX) - strangers = dict(resx.nodes) | {"not_in_the_res": None} - - original = type(resx).nodes.fget - monkeypatch.setattr( - type(resx), - "nodes", - property(lambda self: strangers if self is resx else original(self)), - ) - - with pytest.raises(ValueError, match="not_in_the_res"): - Network.from_epanet(res, resx=resx) - - def test_unsupported_type_is_refused(self): - with pytest.raises(TypeError, match="Expected a str, Path or Res1D object"): - Network.from_epanet(_EPANET_RES, resx=42) # type: ignore[arg-type] - - -class TestReadInp: - """Minimal .inp reader - see modelskill/model/adapters/_inp.py.""" - - def _write(self, tmp_path, text): - path = tmp_path / "model.inp" - path.write_text(text) - return path - - def test_sections_are_keyed_without_brackets_and_upper_cased(self, tmp_path): - path = self._write(tmp_path, "[Pipes]\n1 a b 10\n[TANKS]\n2 5\n") - - assert set(read_sections(path)) == {"PIPES", "TANKS"} - - def test_comment_and_blank_lines_are_dropped(self, tmp_path): - path = self._write( - tmp_path, - ";a leading banner\n\n[PIPES]\n" - ";;ID Node1 Node2 Length\n" - ";;-- ----- ----- ------\n" - "1 a b 10\n\n", - ) - - assert read_sections(path) == {"PIPES": [["1", "a", "b", "10"]]} - - def test_trailing_comment_is_stripped_from_a_data_row(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b 10 ; the short one\n") - - assert read_sections(path)["PIPES"] == [["1", "a", "b", "10"]] - - def test_rows_before_any_section_are_ignored(self, tmp_path): - path = self._write(tmp_path, "stray row\n[PIPES]\n1 a b 10\n") - - assert read_sections(path) == {"PIPES": [["1", "a", "b", "10"]]} - - def test_lengths_are_read_from_the_fourth_field(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b 10.5 300 100\n") - - assert read_pipe_lengths(path) == {"1": 10.5} - - def test_a_short_row_raises_rather_than_dropping_a_length(self, tmp_path): - path = self._write(tmp_path, "[PIPES]\n1 a b\n") - - with pytest.raises(ValueError, match="Cannot read a pipe length"): - read_pipe_lengths(path) - - def test_a_repeated_section_header_accumulates(self, tmp_path): - path = self._write( - tmp_path, "[PIPES]\n1 a b 10\n[TANKS]\n2 5\n[PIPES]\n3 c d 20\n" - ) - - assert read_pipe_lengths(path) == {"1": 10.0, "3": 20.0} - - # ======================== location identity ======================== From dfc9fe4158cb5ae51c551c2fd47994a088085f96 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 16:13:30 +0200 Subject: [PATCH 009/117] Drop the integer form of NodeObservation's at= A network hands out integers to label its graph, and which integer a location gets depends on the network it was built from and the mikeio1d that built it. Nothing a user writes should depend on that, so at= now takes a node name or a (reach, distance) pair, and an integer raises with the recipe for getting the name back. The signature shipped in the 1.4.0a3 alpha only, so it goes without a shim. The guard catches np.int64 as well as int: Comparer.node returns a numpy scalar, and isinstance(np.int64(5), int) is False. Co-Authored-By: Claude Opus 5 --- src/modelskill/comparison/_comparison.py | 4 +- src/modelskill/model/network.py | 24 ++++--- src/modelskill/obs.py | 63 ++++++++++--------- src/modelskill/timeseries/_coords.py | 2 +- src/modelskill/timeseries/_point.py | 2 +- tests/test_match.py | 4 +- tests/test_network.py | 79 +++++++++++------------- 7 files changed, 88 insertions(+), 90 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 41e82f1c3..34387d07f 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -650,12 +650,12 @@ def z(self) -> Any: @property def node(self) -> Any: - """node-coordinate""" + """Name of the node this comparer sits at""" return self._coordinate_values("node") @property def reach(self) -> Any: - """reach-coordinate""" + """Name of the reach this comparer sits on""" return self._coordinate_values("reach") @property diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index e96384b55..7ca802fe7 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -49,8 +49,13 @@ class NodeModelResult(TimeSeries): name : str, optional The name of the model result, by default None (will be set to file name or item name) - node : int, optional - node ID (integer), by default None + node : str or tuple[str, float], optional + Where the data sits: a node name, or a break point as + ``(reach_id, distance)``. By default None, which requires data that + already carries a ``node`` or ``reach`` coordinate. + node_index : int, optional + The integer the network used for this location, recorded as provenance. + Nothing reads it back, by default None item : str | int | None, optional If multiple items/arrays are present in the input an item must be given (as either an index or a string), by default None @@ -62,14 +67,14 @@ class NodeModelResult(TimeSeries): Examples -------- >>> import modelskill as ms - >>> mr = ms.NodeModelResult(data, node=123, name="Node_123") - >>> mr2 = ms.NodeModelResult(df, item="Water Level", node=456) + >>> mr = ms.NodeModelResult(data, node="123", name="Node_123") + >>> mr2 = ms.NodeModelResult(df, item="Water Level", node=("r1", 24.5)) """ def __init__( self, data: PointType, - node: int | str | tuple[str, float | None] | None = None, + node: str | tuple[str, float | None] | None = None, *, node_index: int | None = None, name: str | None = None, @@ -358,18 +363,11 @@ def _as_node_result(self, node_id: int) -> NodeModelResult: aux_items=self.sel_items.aux, ) - def _resolve_alias(self, alias: int | str | tuple[str, float]) -> int: + def _resolve_alias(self, alias: str | tuple[str, float]) -> int: # Delegated to Network.find rather than matched against the dataset's own # name/reach/distance coords: find() searches the whole topology, so a hit # that is missing from the dataset is a location whose timeseries was not # loaded, which is a different mistake from one that does not exist. - if isinstance(alias, (int, np.integer)) and not isinstance(alias, bool): - if alias not in self.data.indexes["node"]: - raise ValueError( - f"Node {alias} not found. Available: {list(self.nodes[:5])}..." - ) - return int(alias) - try: if isinstance(alias, tuple): reach_id, distance = alias diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index f169b0553..330617375 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -6,7 +6,7 @@ * [`PointObservation`](`modelskill.PointObservation`) - a point timeseries from a dfs0/nc file or a DataFrame * [`TrackObservation`](`modelskill.TrackObservation`) - a track (moving point) timeseries from a dfs0/nc file or a DataFrame * [`VerticalObservation`](`modelskill.VerticalObservation`) - a vertical profile from a dfs0/nc file or a DataFrame -* [`NodeObservation`](`modelskill.NodeObservation`) - a network node timeseries for specific node IDs. +* [`NodeObservation`](`modelskill.NodeObservation`) - a network node timeseries for a named node or break point. * [`ReachObservation`](`modelskill.ReachObservation`) - a network reach timeseries for a quantity uniform along the reach. An observation can be created by explicitly invoking one of the above classes or using the [`observation()`](`modelskill.observation`) function which will return the appropriate type based on the input data (if possible). @@ -27,6 +27,7 @@ ) from typing_extensions import Self import warnings +import numpy as np import pandas as pd import xarray as xr @@ -45,9 +46,9 @@ # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file Serializable = Union[str, int, float] -# Where a node observation sits: an internal network ID, an original node alias, -# or a breakpoint given as (reach_id, distance) along a reach. -NodeLocation = Union[int, str, tuple[str, float]] +# Where a node observation sits: the name the network gave the node, or a +# breakpoint given as (reach_id, distance) along a reach. +NodeLocation = Union[str, tuple[str, float]] def observation( @@ -93,7 +94,7 @@ def observation( >>> import modelskill as ms >>> o_pt = ms.observation(df, item=0, x=366844, y=6154291, name="Klagshamn") >>> o_tr = ms.observation("lon_after_lat.dfs0", item="wl", x_item=1, y_item=0) - >>> o_node = ms.observation(df, item="Water Level", at=123, name="123") + >>> o_node = ms.observation(df, item="Water Level", at="123", name="123") >>> o_reach = ms.observation(df, item="Discharge", reach="reach_1", name="reach_1_Q") """ if gtype is None: @@ -818,14 +819,13 @@ class NodeObservation(Observation): """Class for observations at network nodes. Create a NodeObservation from a DataFrame or other data source. - The ``at`` parameter accepts three forms: + The ``at`` parameter accepts two forms: - * **int** — internal network ID, used directly. - * **str** — original node alias (e.g. Res1D node name), resolved to an - integer ID automatically when matched against a - :class:`~modelskill.model.network.NetworkModelResult`. - * **tuple[str, float]** — breakpoint location as ``(reach_id, distance)`` - along a reach, resolved via the alias map at match time. + * **str** — the node's name in the model (e.g. a Res1D node name). + * **tuple[str, float]** — a breakpoint, as ``(reach_id, distance)`` along a + reach. + + Both are resolved against the network when the observation is matched. .. note:: "Node" in this API follows the broad graph sense: it covers both @@ -842,12 +842,11 @@ class NodeObservation(Observation): ---------- data : str, Path, mikeio.Dataset, mikeio.DataArray, pd.DataFrame, pd.Series, xr.Dataset or xr.DataArray data source with time series for the node - at : int, str, or tuple[str, float] + at : str or tuple[str, float] Observation location. Accepted forms: - * **int** — internal network ID. - * **str** — original node alias (e.g. Res1D node name). - * **tuple[str, float]** — breakpoint as ``(reach_id, distance)``. + * **str** — the node's name in the model (e.g. a Res1D node name). + * **tuple[str, float]** — a breakpoint, as ``(reach_id, distance)``. item : (int, str), optional index or name of the wanted item/column, by default None if data contains more than one item, item must be given @@ -865,8 +864,8 @@ class NodeObservation(Observation): Examples -------- >>> import modelskill as ms - >>> o1 = ms.NodeObservation(data, at=123, name="123") - >>> o2 = ms.NodeObservation(df, item="Water Level", at=456) + >>> o1 = ms.NodeObservation(data, at="123", name="123") + >>> o2 = ms.NodeObservation(df, item="Water Level", at="456") >>> >>> # String alias resolved at match time >>> o3 = ms.NodeObservation(data, at="node_A") @@ -875,14 +874,14 @@ class NodeObservation(Observation): >>> o4 = ms.NodeObservation(data, at=("reach_1", 24.5)) >>> >>> # Multiple node observations from separate data sources - >>> obs = ms.NodeObservation.from_multiple(nodes={123: df1, 456: df2}) + >>> obs = ms.NodeObservation.from_multiple(nodes={"123": df1, "456": df2}) """ def __init__( self, data: PointType, *, - at: int | str | tuple[str, float], + at: str | tuple[str, float], item: int | str | None = None, name: str | None = None, weight: float = 1.0, @@ -890,6 +889,12 @@ def __init__( aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> None: + if isinstance(at, (int, np.integer)) and not isinstance(at, bool): + raise TypeError( + "'at' takes a node name or a (reach, distance) pair, not an integer. " + "The integers a Network hands out are an internal index; " + "network.recall() gives the name back." + ) if isinstance(at, tuple): reach, distance = str(at[0]), float(at[1]) if not self._is_input_validated(data): @@ -916,14 +921,14 @@ def __init__( super().__init__(data=data, weight=weight, attrs=attrs) @property - def at(self) -> int | str | tuple[str, float]: - """Observation location: node ID (int/str) or breakpoint ``(reach_id, distance)`` tuple.""" + def at(self) -> str | tuple[str, float]: + """Observation location: a node name, or a ``(reach_id, distance)`` breakpoint.""" if "reach" in self.data.coords: return ( str(self.data.coords["reach"].item()), float(self.data.coords["distance"].item()), ) - return self.data.coords["node"].item() # int or str + return str(self.data.coords["node"].item()) def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" @@ -935,7 +940,7 @@ def _create_new_instance(self, data: xr.Dataset) -> Self: float(data.coords["distance"].item()), ), ) - return self.__class__(data, at=data.coords["node"].item()) + return self.__class__(data, at=str(data.coords["node"].item())) @overload @classmethod @@ -995,13 +1000,13 @@ def from_multiple( 1. **Separate data sources** — pass only ``nodes`` as a dict mapping each node ID to its own data source (file path, DataFrame, etc.):: - obs = NodeObservation.from_multiple(nodes={123: df1, 456: "sensor.csv"}) + obs = NodeObservation.from_multiple(nodes={"123": df1, "456": "sensor.csv"}) 2. **Shared data source** — pass a single ``data`` object together with ``nodes`` as a dict mapping each node ID to the column name or index to select from ``data``:: - obs = NodeObservation.from_multiple(data=df, nodes={123: "col_a", 456: "col_b"}) + obs = NodeObservation.from_multiple(data=df, nodes={"123": "col_a", "456": "col_b"}) 3. **MIKE+ database** — pass a single ``data`` object together with ``db``, and the locations are looked up in the database:: @@ -1016,10 +1021,10 @@ def from_multiple( data : PointType, optional Shared data source (required when ``nodes`` values are column selectors, and when ``db`` is given). - nodes : dict[int | str | tuple[str, float], PointType | str | int] + nodes : dict[str | tuple[str, float], PointType | str | int] Mapping of location -> data source or column selector. A location - takes any of the forms accepted by ``at``: an internal network ID, - a node alias, or a ``(reach_id, distance)`` breakpoint. + takes either of the forms accepted by ``at``: a node name, or a + ``(reach_id, distance)`` breakpoint. Note that a location can appear only once, so this form cannot express several observations at the same node. Use ``db`` when the diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index f0cd5fbff..ea768f4ce 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -51,7 +51,7 @@ def as_dict(self) -> dict: class NodeCoords: - def __init__(self, node: int | str | None = None): + def __init__(self, node: str | None = None): self.node = node if node is not None else np.nan @property diff --git a/src/modelskill/timeseries/_point.py b/src/modelskill/timeseries/_point.py index f0742f4dc..38d3bedb0 100644 --- a/src/modelskill/timeseries/_point.py +++ b/src/modelskill/timeseries/_point.py @@ -286,7 +286,7 @@ def _parse_network_node_input( name: str | None, item: str | int | None, quantity: Quantity | None, - node: int | str | None, + node: str | None, aux_items: Sequence[int | str] | None, ) -> xr.Dataset: if node is None: diff --git a/tests/test_match.py b/tests/test_match.py index 3e5bcf37d..781a8642e 100644 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -403,7 +403,7 @@ def node_obs_invalid(network): time = pd.date_range("2017-10-27", periods=10, freq="h") data = np.random.normal(1.5, 0.2, len(time)) df = pd.DataFrame({"WaterLevel": data}, index=time) - return ms.NodeObservation(df, at=999, name="Node_999_Obs") + return ms.NodeObservation(df, at="999", name="Node_999_Obs") @pytest.fixture @@ -1038,7 +1038,7 @@ def test_match_node_obs_with_multiple_network_models( def test_match_network_invalid_node_error(node_obs_invalid, network_mr): - with pytest.raises(ValueError, match="Node 999 not found"): + with pytest.raises(ValueError, match="not found"): ms.match(node_obs_invalid, network_mr) diff --git a/tests/test_network.py b/tests/test_network.py index 250a6d83f..83822d03b 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -244,9 +244,9 @@ def test_extract_valid_node(self, sample_network, sample_node_data): def test_extract_invalid_node(self, sample_network, sample_node_data): """Test extraction of a node not present in the network""" nmr = NetworkModelResult(sample_network) - obs = NodeObservation(sample_node_data, at=999, name="Node_999") + obs = NodeObservation(sample_node_data, at="999", name="Node_999") - with pytest.raises(ValueError, match="Node 999 not found"): + with pytest.raises(ValueError, match="not found"): nmr.extract(obs) def test_extract_wrong_observation_type(self, sample_network): @@ -283,26 +283,26 @@ def test_init_with_df(self, sample_node_data): """Test initialization with pandas DataFrame""" obs = NodeObservation( - sample_node_data, at=123, name="Sensor_1", item="WaterLevel" + sample_node_data, at="123", name="Sensor_1", item="WaterLevel" ) - assert obs.at == 123 + assert obs.at == "123" assert obs.name == "Sensor_1" assert len(obs.time) == 10 assert isinstance(obs.time, pd.DatetimeIndex) def test_init_with_series(self, sample_series): """Test initialization with pandas Series""" - obs = NodeObservation(sample_series, at=456, name="Node_456") + obs = NodeObservation(sample_series, at="456", name="Node_456") - assert obs.at == 456 + assert obs.at == "456" assert obs.name == "Node_456" assert len(obs.time) == 10 def test_node_attrs(self, sample_node_data): """Test attrs property""" attrs = {"source": "test", "version": "1.0"} - obs = NodeObservation(sample_node_data, at=123, attrs=attrs, weight=2.5) + obs = NodeObservation(sample_node_data, at="123", attrs=attrs, weight=2.5) assert obs.attrs["source"] == "test" assert obs.attrs["version"] == "1.0" @@ -313,7 +313,7 @@ def test_multiple_nodes_returns_list_of_observations(self, multi_data): """Test that from_multiple returns a list of NodeObservation objects""" obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) assert len(obs_list) == 3 @@ -322,17 +322,17 @@ def test_multiple_nodes_returns_list_of_observations(self, multi_data): def test_node_ids_are_assigned_correctly(self, multi_data): obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 - assert obs_list[2].node == 789 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" + assert obs_list[2].node == "789" def test_names_derived_from_column_names(self, multi_data): obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={123: "station_0", 456: "station_1", 789: "station_2"}, + nodes={"123": "station_0", "456": "station_1", "789": "station_2"}, ) assert obs_list[0].name == "station_0" @@ -348,12 +348,12 @@ def test_from_xarray_dataset(self, sample_node_data): coords={"time": sample_node_data.index}, ) obs_list = NodeObservation.from_multiple( - data=ds, nodes={123: "station_0", 456: "station_1"} + data=ds, nodes={"123": "station_0", "456": "station_1"} ) assert len(obs_list) == 2 - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" def test_nodes_must_be_dict(self, multi_data): with pytest.raises(TypeError, match="'nodes' must be a dict"): @@ -363,7 +363,7 @@ def test_attrs_propagated_to_all_observations(self, multi_data): attrs = {"source": "sensor_array", "version": 2} obs_list = NodeObservation.from_multiple( data=multi_data, - nodes={1: "station_0", 2: "station_1", 3: "station_2"}, + nodes={"1": "station_0", "2": "station_1", "3": "station_2"}, attrs=attrs, ) @@ -373,38 +373,38 @@ def test_attrs_propagated_to_all_observations(self, multi_data): def test_init_from_csv(self): obs = NodeObservation( - "tests/testdata/network_sensor_1.csv", at=1, item="water_level@sens1" + "tests/testdata/network_sensor_1.csv", at="1", item="water_level@sens1" ) - assert obs.at == 1 + assert obs.at == "1" assert len(obs.time) == 110 assert isinstance(obs.time, pd.DatetimeIndex) def test_from_multiple_csvs_via_dict(self): obs_list = NodeObservation.from_multiple( nodes={ - 1: "tests/testdata/network_sensor_1.csv", - 2: "tests/testdata/network_sensor_2.csv", - 3: "tests/testdata/network_sensor_3.csv", + "1": "tests/testdata/network_sensor_1.csv", + "2": "tests/testdata/network_sensor_2.csv", + "3": "tests/testdata/network_sensor_3.csv", } ) assert len(obs_list) == 3 assert all(isinstance(obs, NodeObservation) for obs in obs_list) - assert obs_list[0].node == 1 - assert obs_list[1].node == 2 - assert obs_list[2].node == 3 + assert obs_list[0].node == "1" + assert obs_list[1].node == "2" + assert obs_list[2].node == "3" for obs in obs_list: assert len(obs.time) > 0 def test_nodes_dict_maps_node_to_item(self, multi_data): obs_list = NodeObservation.from_multiple( - data=multi_data, nodes={123: "station_0", 456: "station_1"} + data=multi_data, nodes={"123": "station_0", "456": "station_1"} ) assert len(obs_list) == 2 - assert obs_list[0].node == 123 - assert obs_list[1].node == 456 + assert obs_list[0].node == "123" + assert obs_list[1].node == "456" assert obs_list[0].name == "station_0" assert obs_list[1].name == "station_1" @@ -414,12 +414,12 @@ def test_nodes_none_raises(self, multi_data): def test_single_node_dict(self, sample_node_data): obs_list = NodeObservation.from_multiple( - data=sample_node_data, nodes={123: "WaterLevel"} + data=sample_node_data, nodes={"123": "WaterLevel"} ) assert len(obs_list) == 1 assert isinstance(obs_list[0], NodeObservation) - assert obs_list[0].node == 123 + assert obs_list[0].node == "123" def test_nodes_keys_accept_aliases(self, multi_data): obs_list = NodeObservation.from_multiple( @@ -494,9 +494,9 @@ class TestNodeModelResult: def test_init_(self, request, fixture_name): """Test initialization with pandas DataFrame""" data = request.getfixturevalue(fixture_name) - nmr = NodeModelResult(data, node=123, name="Node_123_Model") + nmr = NodeModelResult(data, node="123", name="Node_123_Model") - assert nmr.node == 123 + assert nmr.node == "123" assert nmr.name == "Node_123_Model" assert len(nmr.time) == 10 @@ -641,17 +641,12 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( class TestNodeObservationAliases: - """NodeObservation accepts int, str alias, and (reach, distance) tuple.""" - - def test_integer_node_unchanged(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=42) - assert obs.at == 42 - assert isinstance(obs.at, int) + """NodeObservation accepts a node name or a (reach, distance) tuple.""" - def test_integer_node_coord(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=42) - assert "node" in obs.data.coords - assert int(obs.data.coords["node"].item()) == 42 + @pytest.mark.parametrize("at", [42, np.int64(42)]) + def test_an_integer_is_refused(self, sample_node_data, at): + with pytest.raises(TypeError, match="not an integer"): + NodeObservation(sample_node_data, at=at) def test_string_alias_stored(self, sample_node_data): obs = NodeObservation(sample_node_data, at="node_A", name="test") From 7f9efc6a127149cb6ad813c23bcae696296d91e8 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 16:22:44 +0200 Subject: [PATCH 010/117] Point the docs and the records at the upstream module The user guide loses the sections that documented the topology layer -- building a network, the companions, selective loading, inspecting the graph, find and recall -- and gains a short section saying where the network comes from and how to hand modelskill a path. What stays is the part modelskill still owns: the skill assessment workflow and the MIKE+ database lookup. 587 lines to 197. The notebook addressed its observations by graph integer and highlighted junctions by reading a node attribute that upstream moved to edges; both are fixed, and it runs end to end. It is in the notebook SKIP_LIST, so CI would not have caught either. ADR-012 is narrowed rather than superseded: the constructors and the extension tables it argues for are mikeio1d's now, and the reasoning still applies there. ADR-010's open question about version constraints is answered for this feature. The res1d mapping diagram went with the section that explained it. The fixtures for the formats whose tests moved are kept, and the testdata README now says nothing here reads them. Co-Authored-By: Claude Opus 5 --- adr/010-optional-domain-dependencies.md | 5 +- adr/012-network-format-constructors.md | 14 +- docs/images/res1d_network_mapping.png | Bin 56798 -> 0 bytes docs/user-guide/network.qmd | 509 +-- notebooks/Collection_systems_network.ipynb | 3422 +++++++++++--------- roadmap/features/network-models.md | 2 +- tests/testdata/README.md | 20 +- tests/testdata/network_sensor_1.csv | 220 +- tests/testdata/network_sensor_2.csv | 160 +- tests/testdata/network_sensor_3.csv | 180 +- 10 files changed, 2185 insertions(+), 2347 deletions(-) delete mode 100644 docs/images/res1d_network_mapping.png diff --git a/adr/010-optional-domain-dependencies.md b/adr/010-optional-domain-dependencies.md index c67cab5b9..ef8c38852 100644 --- a/adr/010-optional-domain-dependencies.md +++ b/adr/010-optional-domain-dependencies.md @@ -56,7 +56,10 @@ Installation: `pip install modelskill modelskill-network` **Open Questions:** - Should `modelskill[all]` install all optional model types? -- How to handle version constraints for optional dependencies? +- How to handle version constraints for optional dependencies? *Answered for network + support by [ADR-013](013-network-topology-in-mikeio1d.md): the `network` extra names a + minimum mikeio1d, since the topology layer it depends on ships there. Network support + therefore requires whatever Python that release requires.* - Should optional dependencies be tested in CI for every commit or separately? ## Status Notes diff --git a/adr/012-network-format-constructors.md b/adr/012-network-format-constructors.md index 324959247..d1f69033c 100644 --- a/adr/012-network-format-constructors.md +++ b/adr/012-network-format-constructors.md @@ -1,6 +1,6 @@ # ADR-012: One Network Constructor per Modelling Product -**Status**: Draft +**Status**: Accepted, narrowed by [ADR-013](013-network-topology-in-mikeio1d.md) **Date**: 2026-08 @@ -23,6 +23,18 @@ A product's companion files are arguments rather than constructors of their own. Every extension mikeio1d reads is accounted for in one of three module-level tables in `network.py`: readable by `from_mike`, readable by `from_epanet`, or refused with a reason that names the file or method which would lift it. A test asserts the tables cover exactly `Res1D.get_supported_file_extensions()`, so a mikeio1d release adding a tenth format fails CI instead of leaving that format silently unreachable. `from_res1d` is removed without a deprecation shim: it shipped only in the 1.4.0a3 alpha, and the network module is opt-in and absent from the API reference. +## Superseded in part by ADR-013 + +Everything below the line this note sits above is now mikeio1d's: the constructors, the +companion arguments, the extension tables and the coverage test moved there with the rest +of the topology layer, and `Network.open` replaced the two product constructors with one +entry point that reads the extension. The reasoning about naming a constructor after the +product that wrote the file still holds, and still applies -- upstream. What stays here is +the consequence for modelskill: a path handed to `NetworkModelResult` is opened by +mikeio1d, and the refusal messages for `.out`, `.resx` and the fixture-less formats are +upstream's to word. The `.inp` reader went with them, so the last consequence below is no +longer ours to carry. + ## Alternatives Considered **One constructor per extension** - `from_res`, `from_out` and `from_whr` say nothing about the product they belong to, and MOUSE would need three identical methods. diff --git a/docs/images/res1d_network_mapping.png b/docs/images/res1d_network_mapping.png deleted file mode 100644 index 2930e99144da25f2cd829e2c99ae6816a82dfa8f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 56798 zcmeFZcT`hR^EMh$L{Pv`M5IZOE+AdHN|WAul`36o=wKyu>Am+}Lkj_w-g^s8=_Ej; zh8k|v_x;`P`}3~#-M{XItd)~<&faIw%$}KNKYNl;byay{qDMpk0DxHGwTvbJfZq!M z+?2e7hdYy_>Pd!syKSK)F9W##^PdebiUR;10~BOlYI~>eEP{=-FxZ}bwTE~sfQ1i` zFi#iP$Ieb=6?yh$QwaNz1*{_+@vF&j9@SLYpbM{iK|DC!G(!cTd=-K`6f20Bcg5TfK{d)koCsX}LEC9g#@dwI(r*8iLUEvh* ze^OUpBWv#d)vZ3HP6^?E`O(X@ei?t+xx4H(8}JtAGi!`j`}KHI2$A1(SDw?AD6yC) z&1etIVZxrWzqb07)x!DVVaj2n2_KB)Cs@@sZ>$6#&qjY_5ozMbCDHE*-{G2HVh zLkjG6!Qr~g`(~_N-qVfOf+WV<2URMvyeG+UsO%To?8&?_o$%B0BFK#r zP~4`wg;TcZu)lCnfPA|!O+sH|$^6B}b*t#l-l^BeD_eR4E7^ds_vZK;`IsUH_ntP* zZsVo%vyf%FQM)H@XQ!VX&;ndAD`w=WFhdo$$DM~)N2gX(x$gx9?{1IfYz|*yFUS>! zrijh17Mh)Y1q9%y$s3T;!KM+=DO+tJbP&J-n_Eh#4ze|XSK~| zIwL$>NK^23ooBIeMQZp)drPEPyMWEFXw=CN!z>@#CMn1mwp-}Rfs>&6HESZzG8k4a zcIyUPG|phd_L4LCA8QJocFO95aE{`vUrAX-{&_P^^GWpJ{BwR-K zyx;T=z-b-`{8HV3-<2mp6D|Z@o$TIy!wUipXF4q`h^JoMdw6CuW8ad75ZHNM9#qB1 zgE@2qLl%5%^Hr5PTfW~}X77m#^wNfL2>d>P5_0vwyF-n$#=zl^>^^xt|Ge!KazFFA z5g6>sK|Ru9Plg(N)%$&!gjUl1MDc9|$OHCp_g|3|L2FMOEMerO zb}7KWFwkXZk#(GA&Q%Vt?add9Oq1q~uCLA)@E>;9Ngk`{-}E?S^Q~uU7_-dp!N6M*i8iGCJ0^ldLpdA>jh4c z;Z&&``_uB4q;0UhT3?ZkZT$gbym`1|nd6~sB_;CVf{@fCDJ4mB%4(EmG`GcQmjLdXr z84F^M{Y%0si{asg!wBC-2;fzcXL!Sv#{-woOOwrd#O>aU&qt<{hE3pEu=~`&O1RI? zWEPN=r5-r(oOES2a< zn(rQTq?$2SIwxOig>c1*iH1F4n1}w37$!-@q&#ocn>X|Vfe10f8SOhRdK|Vo#gC>A z)4v)=Mv%F3T3O;mj*sYD#4fB}>vllje$nAh{L=W(>)-a868b-p{EEH3!VN^Xw;G=oBf9 z9=Yq*C>DP%eLn2$Z7)~Bq=s-)6#SiJkXr6dy;pG|(_R!njW0`+CmiTexQXRZ2gK<* z6C=H})l={${I*WT6EWT*rd9}~)7apwios|veZ2iE`SS1ihTKZXbjMZMCVF})Md@(N zEI_jOCG}wQt@v9w|A;Ft+a!9cx-xDv8ef7YaoLXF+{JEyj1gcxJ?YW;mrOzyWpJy06FKP%cJ@U8fT#FSYmC&gl5o>pI)a4Ca z#HlMdr_{qYXnd3|4*XX0i&0wJS&3HKLR#Mk_K%HMwM@c^@3uw2yPHhzHV%7p^LYml zQr)+)spMiL%d}@UOi8L8tYEU3IwhR<4c%7pmj|ofO46-3?|&~X5>Dm(MWIm+1nN(l z5oitzvF)fjG$TfDhtzq2C!jru3oMcZaBlBcc<9Br3 zW*~WT-OItK1f$zWK}Dk)SmV|n?quFV80=#t-*KRfMGoAT46n_oeBN-qxo={5SJz4% zKc2<||AUVMFH*_@dvsxC)ut``B#E@oL=;kOX15I7pY$Au>*l+fkcV{h`aHdBrZe)CT`Sx z-rfNjCl9A95SU4Be6uF{k|1{HAvj{Y^+ZlJFLppLx|pF^z-0ooxownGwFCslBv(6Z zx|QuaPiS7T2|hDVb0*Dx$)I-Ko~|t`!!fz_J1DDl%)s{JfZy=i*{+6OM@%>se13lM zyPQlpojq*EDvgr~ujczeY&DR?}w<-_mnueivXeu*0aW`|C=rC(+)pbXY z@ZnRv(%xPuPH^jdw`)QM5{c)mMZo^Z1T&ZID^%KN=fJ}aGtp4lh~=K4E22eRXNf?z zgGoXU55a@I3B}>{dMOcCG41@gUg%w0fjWFo)a=L=QizZo7&Eb1)g4udehOx)&xk#T zzAbBxgHyWcf=8sycC@ZS^E~N))~$HFa4yLa&dYbo!0Si;?!PMwjwVwOt#O{SaiXD4 znvqNq{*a?%Zt=DT&z%o}{xL>FMM96Y_g32NFNSB0_*j@%BqtMe&AM2)g+XRL0({Qz zo=FLSD(MXP!TpCOJ<9q%2c}=%d(yD1^_%6i3=l6Oo8#^N!1@Oja?7OHIW50yPtT!r zLB06TPPBAX#90~7w%1Z%_uZL}q98KH&&xs$&l{W&b)Op&`f5hSKx95* z0vJ`dw-*mYoD?+UJZ*vYdX1(x+UKV{9g1Pe2|B$Zjdp7}^1JT`+7|NN)#m*WFv+fD z3PLsp93}~LTs&8~MDk~liZt(cwCnB!9_{#f(Y5@%;L0MlH+m5WT))0L0`hw;b05{! z=d<%%)vTxQ5sgqGpidqD#yUJqPFvQ=#P~mm{LqbIYtf(RK|%)dHSQdE5M!dfU#|$=0br?c-j<)rELbowwDZi|uN- z7O^`0Xg85fU(0t+w2G+LQTW10c=F9dJ%!DYkn#$sf%sFDGpGgDnF1s9E+q!`3-Hg4FIu-^fTiyvC)a7jtfOe0B@p zKPtI*M@iK9wVU#|`+(<4NaqvvDUk|E!VZbUpBDOS+Ydr~bKVr4jD)_PAd#>RIbS+m z82XxAE#J&EbK*E9N7MiOxe!Gkyic6UM_4v>!=;|gM_2}2^JRcvFtu`an`^oJTeSNo zW6O@Pi(Q(h*%7x#wox{1ZWqyDyeE8S$w$5sUw&|dK{soVPGb=I(sJ>1b*q{4?3_qK z=d=CLMdYbPU-Y$DbKn%rw1t5gS(s3uL=Cn%ZkIZN<-mrmN7I<*c{_1v{DnbXiPT%< zptG#YrUn{6qagWbS<5RzRej1(TY8I*)4$kgKDIIAzy2~|*v zPTwRoCTvX+b8`xb8d`*2*v&TO?KwwhKF_#j5kYm&F|`a8`uPg^bicutdZhpU{@O{8 zC3NwbZC|07^)v}B+YQ_j$VkY^H081|WH_vvA<;!7>rl<(BI>4xRF2SyS?w=fEPG(B z<{q6vGbfwv{@{q2vnWG_SX7vbY~#|$fd0aps&W>}9#*~EaFi6a)Lx{^M-O=is-(;; zY@W*yANx(5oA?+AKg13nsmeO(6h%f4w@SG=Pwi0JS{xJ+q(l#+P2INwml6b#4dW)_ zEe^|z<*Z)l@zMk@&4G_aCnls?QiF6-1=gJC1=z9}Rpr8z_@rw6QxJ$`NwUM!Io48m z(BNQVy=kGtT87r-_Ze8!T}o-0e%I5D`limVkXOrIfZyO)!2l+~gv#${%9tm>rra%B zc$v0^6zD{IcTbmlfS+f z`gJT2?I6?_v3NCS1WOV+^4VYKHpwb`!vi7|2D>2Kl>KBjlMIE~=iHwQfREhWvsykY zg=4M{x8F6!N<76W;>c!kYe?-H-CO2E7Q))pcG^E$AP)r>CS6JHx@GTHV=ElyLm{uv z^X~SjWi(OFW9o>}Yd$&QN?eOwvp3zPXj=y=N_D*aLmDvw$rC?1E1LDhMDp#F+<3Qm zjz8kCqg|@qyukhrW39A|%rKpJDZ8}TSnZd*5hZd_rwO=%>GO>(ByQ2F4UOIDoTvJ6 zaM?QJzjOMYnXgcJogNJr_8l2qP)M>Q2|U|R{gTF7|MP-F8P7#K8TtsmMBnb$qlcId zD{42as~Eu{olt#YU-xO&&F%o77Z<&B(HX-2w2Jxf z0;YEPQDxCfj;ajWI6YX_`Z#y?kdwBZ>_!$jYC$nDv&eQ)(?)49E`Ld7@z^i_F|LV_ z%Y=e}g)~oR7-Wq)zd*y!g;a#9aOtre+!H3`rP29l zqueeDTl3Z>-^*mMf|K{)R#K)rRTTOt;wsopXFr9{Z;K($^FxtKy8!};QiHkW-6ema z_c&P?Rmjv0Up590g%&I`__BdOLdOJLi_e4n(~6=5Q5H_POmA#<`nzX@K#&dQs){^1 z@A=UoCdI0QO9X5L<@0U4ylAJ*I1X^yoqgae?K?uL(0Y-%R|)VM+VU zC9X94B##h-G4C38G5NlcLhLtYR8qjgs-3*YF7IAXWL9*!SuCba$1gfVLSz92_lM49e?dX{Q3jedaPKkl^*f*138ftGG9ClI_ zQ*qqpz^vdO#TBX)#Fh!yUbhs7MQBpP9st|fipdWg5-pVvoIWB{ykn%K|w>pyPW9m z2v+Qg7`uqts-&MEH8vKSR%Qpj`;TD_<6@SD1{!%Om!Hslc*W>ss1M$KyQ@7_-_8hl z!QMBV$T^cBuf{=64!!n9%=TteRb)B5{c-I^_LsZuic4XqX|UdI&?(s{e|VYew42Iu z*@bfeIk`ew@l?-WVSM1ogoFrsn_a^h?Q6nne@7=W>qgr@c`$= z=A1V#=8m>2=^BN^i~^UlGSVGOrGv@;J>}g+lp?s^P>rz zC9hW@KQ2y3?8LTAnctA{FKc{MpxO65520O9~PWYF14!}2? z#HJz&KMSsw0>0I$v#oVW3N;gYTEudke%KcL@1x0Rs=^}1h4i)&W9QrRHvwVV&9y(u zDo(N{!u3>K(kcHk)-QP8fa@DC_9}H%b?hqf0LTe*0EoXQCT5q6FBtW_nvyxBrPyhVS6 zHrej3EV#vdIcXAL%6P#PX`*yyQ|Je*8>2wuRsJG+HI>N z|E{QTr$zW@UU6%gRz>1>tr**qxU)7}Tz4ZJDIiqDdZv z{f+2Gje9#z$dYr2J%rKLY3Q+5L`CshFn-DI`a|1iCk@`)jV>lRxy4!Vg#S`;aLJl6 zPAZ})*?z|`n`&ygeaUbyi+xzoEU05aixTKseA!Jg(+y%o?O`8Sec->Dq?f>HcdenK z!e8@%^WVfbjaS^Yw%wKfb|=TRV{(QP#D?SW~efg9)5s~OEyTm8 z(M#_zT1Q5v+-TB2pt$1oL81=nweADB#L=4y{-Mm%2icS`;58th%eDwg9OwE>fW<9c$+lcCjZ42t|TE77TRR!)IHzYx}?)_X@-JkgI z$WsPuNG;(05%M}o%_yqs@^r?trbl|bz^iMIr$yzV9@KY_bfdo<<;N5_M|Pp7UwA&J zdKM(5Cvhk6a`S!D-JBA=SL3ofk9_p@cn3YbH;GaMwrJ0L`hArX-&m zWHeYZmtr_TeD#V(A+4L4Srhpxkpz>JK%L8qrkgYj3}RH^!?w4TOJ7^6yyv$`O10Lg zw=V_LqATy$S=XIc8TgFO`dSj`DHBE*A6nLLpvCgBAuihEBKSI&%e+RylH%^%?0-js z6sSINsM6*hrg>3rq_?{cJX6x&$RQ_m!IW)i&K|$Fe*D*k)Fs*Kn4+b`-{Iuke}Tza z6xc;2fEjqOTPHOa2x5j$omV_h_JXieMFD$bWu`Sfu+RlhKg99c^Wz^^@v9ClPqdwy z-+lTBf$;5)Gz%xv_orO02lnqng`+l?U#=|my)mi}-xj_(;c~k>Bxq?RF7QllK}G7f z%Ivf|Xhpq3>DbhP{8IMG<85EZNYP;&FEh}`ibEN2v#HAxMS8+^e=acOF1b2qc9XxwuJrzU6dl@l$n*k4omW`9|NoEtD!W)iq_f%s-x3y|=M*u`Lob)VZki z3Z$mpO8v0v>Y|dULR}1_7S|q3z~~A~>Y{7^xxY>&Xk2mZe-i?+BzG|)9Ekr&NX4py zTE9Gs3rWf2y#L2tEbrd&gZYgHn|??8pFGZYPRQX;9mzoE+D+sr&z%*Vi#0eklBT*G zVGu!0yLt@I#X@_Jd&&Ys1jXc|}U=5e1mc0j^Y zbYJa%P24bYiC0XWfDh~l`{*aY% zL`{`s8?3K4TsI|cv@g>fPdy=t%43;!+I`$VO29dp^QG?4uWWu-WDknM*r1PVDPz6{ z{Aw?OO;H^3(CbaDuP)MI7@W`A3ds#@-kIxO^UUw=y9k5p&uRHd=^}%Q0}oE5Rc@#t z{rCNPuCR1%7qfE;Pllx|W=b5#FvO2RM2+W2DTB+5>JL05PYM2lh2VoHd~bR_d@Z?4 z|LI8>q!-$BGYGdDLLu_xMRlPMYM@S%xi&$zz?defTs8Rz7k5lM9FB|g?mLv-UQCCT z=$QM(a%Ft%O1fbYeH?W)k*O+4?WE`4I4lWUW@*y*7(i)DMeQdouLqI-{Xo@Vp<9dhxz7^ zI2h#htKXmN@do+_)mdet1RW&y)A^jPYky1EfIyMUo7`==iukot#OV10fX z2jDz1;mf_sy(geppDlIc_)OdU4%9l5E`!1X^>a#xJgzSs8sgbd)6lRzyIkl+KL+3e0S%0EdX zxMuyHSnSzzJ522;!zF(Q>8BCh*+8)gW~B+1SNYamUz+EQ=BMl!$sU7THGm+`aIk-9(9|ig($_k}f)>11h6c6svvVYO>J_ z^kO8_K5Cqpg}A_n3`f#S9R#x0kXb2%>5s*yuZVPIci@=tphC#&3qO-}9F+K13*Z~K zTx`V!iggv%<`3~Y{DSys1Vac?iZFw2Y-@m~yDq~Wu2Y+h9R+|&vJNVwh1ENgt@t}v zdcT+atHOG{*>un0Hx3~FUl}b#Zenr)_5UKU>8x&*z)l4Mse9WssM9Qh(puL*h(MkF zP*{Zh#bjIc+##AlkJMsY(#AhK7^JIFx|%!wRiK_#}{F=NiXfGV$BhQ=GnG4vC;G#q+99 zM4ca3daI5U}JZ)2!~zXX7b< zTH48Fwm1gKQ9Ie#)Kk&hNa%+0U7SS0+HY++$0cN^RIu>lg042{r651`cENk4>p&1l zuTnzvDg-i1vZo1!oOxubW}&o3Y6^VQW{ZcUSc|JhmJ)zIWtF4-N{jDV>;^_KRg#0c zVGzCx*Vj8$%M#r0uvTN8qM+C_Hc@_ClW8*tv~w#rXk~I>H{<(BOB@|^OIJ(c{?2DJ z(8&_6p_QcS?5TrxIs~$-BvJZ&+ehw;{X%663sJN>b;dJ3Whm{LQH-I9 zvt6%EV<8aj3iKOqiD#t$W~#a4jW;e}(t*0}IiK-)Zf=l;$u@LE!ddm67%Nkgo}Wh;B-+}+lLxi)bGTh2LePrhs} zxDM|PgDg->@Do-gBCy%&kj}cc zX9w~(Q&fJW321NmwRJ-^(moslsgtgggt7)qIF5bdXbugPw6$VOJ3$K@!Fns&!Lma# za>FD;t!2?!Mk@S8ZeuP0AaMQo^jkOx1osu4^63sUKc}#x_PxjOhgQ*Vl^uYBhxxI6 zPaZ!@MjqAHnK@DdLxkI$cngoo;}FRd)>~I8t7y~v+k$nw^;BF|4`+5JmW?khj0(Lc zQ`!*~SN!sp>PFSdVnfsQ3WbyKFAx5%K-9lzu3n2i0fBZMPLsV$L7?eOLHTG;3gGoI zW`yMtER`>()h+0%K^Zuo#4^dE^Zx$dCH0Fr4Vw%Tnr2R28Ar268Wn9d1MGyl70Y(d zOOh%+EnctB+&YZbjaNuZlKTV^pwHlEyZ4kH{fCqWum!|KV`njf2a8c%LY3k-b{YL*rJn6p*FZFZe^y#HH zu_e`w>^0u*{})QU93xEr48WZIm5VhE>=uB{Gn1IBj5x$PgX_fy!7{;NA{Z+KNLVI#q1t8m6C?lCvzdzqVxgBZ4~vpUwikZQcy@E&?EX(5&zMmx^x{rC zk7O*s{sOk+Bi)sF>wr4EKdX9xveM7|bz(I&d;Qsoq9l|Yy^75at;nRxg=6Q5O2>v7 z6%dGCUzR*W&eAbd=)cphdv-EE$Kb)<`ZbfsC5X#rw(}c~N8p$K=cB1q3)7%^hTra(?bF!E{~#<-|U)lzq1ZFf34jEvTV-?5cNLU{wdszgP$!!L9&ou zczZ)Je^TSpb2{-0kKZBuz8gMg+w1L>=We%8{HFB0o0P}+67yt5xz`mK!@~bXaB>GJ=#r7N zOr+VvEswc}dRF8flHR~2Zy6!9dSCg*zuLiX`AyKQTxTV|>yhQ~esN=zuHVM0tb9y) z_Pcwgf2-V{@m6+ZW&z&?d>=!h!cvo1L3}Nbr!h4tZcw-iS$wl)I z3kbCoYByuCu4o7Z^{lGqu&RpOK-hIybQj6OFKLhF0GWsmZc#V=Ebbj?_u?)tQQCaN z1HSedacyoh?@h-S;p_>Vuc}wQVe|f<`vc{gHrR|{L1Ul+5}o0|$9x3%2) z$9A(hNNVA|QnDSnVe~+WCri5LLx+4*OVTi-dL?dm|Bnv_$C6QOZBF%DY}01Mba$S^yd-*aJbR(*cg2Lemt?@|Vrv?u zcX=f`gqvZ9dxf9b++J@HG*Y>@zPr02Xx}h`)OsnZ))Zw({|s6Nng6LXK!EaWdxk5n z{QHyxZhw@A+OpW;3H~S3dw1Xus~f(rNLJ|G7H?j}Y2_xBuwlWR29hED3WpT!ZhUupv-oN3$5TUAfRsHr!=dOISU1C7t z(~QTcn^{{9}%u!|t_vlet)ziB{7y z1eJJq(>$At@{^2Au?LRd#@WmKROk}gnIWj+nI6b;d>5;y5U1O+^T(d3q^Y)M z>0h_GPE4{cta9q`Bp82A`cf~Cv5ts(O4#0gXhmi7sq)1?^9%=c{^;O?kG#k-K(6mA zNheVWBr48er1e6Js-i{JQmXAITIZRfDWL9I>^B^`Y>gc}Gx=;@dYa1`>5wzTT#RQB+qZRo*Gud-81*q#F%vP02{X7YmXLs zCRkE5Iq$dp%M^fzub1z?&gpH?wAN>@rHHNg>Il>+NyG;{3m{6+FVUV>l>O|OP*D^9 zC$A{Vj(rb%730KZHyz6z##c-LFc;D$(%_&_%_153G>Mf6tx40MkHL*~WwDfEI6A&4-#%~)+x(fT5no9H=)Y7-Ywh*VQ z+YLIUWKjJEKbSuOx8%{<`F{66Y<45w-doBaGRc5oOQF`mZrhKeP|*!^>nRFjZ`YfEXSo*|2Aji$Sz>7?n1qOW?Nzk}AWhyqN!%-r1$06Z z_JC^_;Z^T2GghhVWC+GvH+jE16mdO*vozkH4%oCf5{#SUu@jhmhPI2}9bg9RQNU$$ z-S#@8P9H0m4kc}TgN^ki0a`r$Xi2(VXJ3!Uy13sYMb6Ewz}A6bWLh%wPs}g6kogn9 zMbyroN~XXh-?}bw-Ap|9<|ghB2t`jrf(t}=((5^mZKHn~6*)wE3ae2flD6nkOWe!T z6T+Db>+^`7y5oKw#7#TSqs2#z7_YO9lIpj})G2~v+(%Zu4KBgAu2?PZ(+G7%h}0hk zN#;*btTY>XPW{#QK*rF~!{F$M{iQ~Xfd;JhWLL3LbE?#d0G1iR*tUmpdOOFTHtxtOc+;r7fEpcH))I1NVV+XoMQck|4;T~2DG^Wvb0B~cCm*L_eudvC zlUd7ux-UWVtZP92u=H;jE@}z8MdP*iK2=mU^FjYxU$W0$lt4m#MFnR>00XWKBoOl!GBApv@u+OKDPSL<1}4n{hz? zN{=yKl=pv*p6z8S0?9?bBVKNCf(~n~2zhVpe3Sf}E+5dbMVO`Xr-sfH&q)SE;Sb!= zi^-03$73lsEbf!(bU^+MbsKv@NJx4Tc=!3s>5yg0z7(#vKTsmo#eIxIQpS7vs zg#DKo%+^^z%^f8a=mq(0UZmpbv{P9R5Ao34_~uke0Kx6sOEf#fR&oWQf5COI0d8-y zeK?;^{HxoZqhZ5b#FD~)KuRLbf1?pdxFzWM~ap?HZCgelDMtph; zEKx5oWS;5PkuZEcCrtZPDq(9R)}dj|y;0d%0uW5CprnIOtFj1}VCVZWxS5G_<)8d^ z-)+b3r)&45M)%KdP;!bIsf>CqSAb0)beN8n~vWoc(VMy%UdA_ z`BJuussaPD)j!T^SjJy?u`paRF|*_9fs4hbItcoY0|~_%StO*YSHeGXh=>`fw&IWwE4i*u zD8x@9OWH>a`zeb^d~(3A(1!g*QJHEdd>%x6G-Fx#M)6IyNMH5G}Za9cB0)+Hp^7_y&Ph|ROG4msUQq?K2DUbLC$ z$=>UcY2;^K2cEVnI^&ZSO*;u@TSs7)&jp^FQT(a0foRTgykrGc_-kBbnvNoUSk#l_ zUwEsWGRw7M#v!VJu65dTaE7*O(l^7((Uxb|?RX-j`| zCx#GEU_0ivn{gNs6#JY;OE=LTJ-oJ?7ONRM)acn==UQ$h=&xOH<0Gw;<5MiQr&r*R zL5(Z!hORQ=f7Ud*kEiP-(=uEVB0)oJ1wRcI5Oql0R73U<-)>zD?8ihwY1j?|?`pD9 zL_tw741GdE>O(4DRT(n0X=920+*vb;jlus+MeU`^Oifxv|15yIuWI^qUqQKzb{qGq7RoD~d*79EFN?^}$8Qvq<+RYy^7)U|u6<-d>L7r0QfU6?9SGOhB0p*WcGCayseJlf&$L0tZ#?U$@mfp^d~V9Gtz8U&;a38 z(NO_oj^8s{d-NWFJT`;sG~;CQ?LQ_CEhQI>D5XYUl`CFtfMOF8{c#?>q4z(U`s=jZ z1)3*&%9*0uV>tcDx*VD2GYL!bWuy9E4Lv;6fJBP(85A&RT_e1T{VlBT((zI5|UG{btA@8#)l_$W)}cK>TVr=_pYud<@0 zrTHRF!VBIp)I2+~c(FynV@dTvQ_tSyy{L-G{f8}&-{}<94s0xlaS{FbXr8+?R6hJP zb01mWu2fgZcR%PN*0(`hY%>)%uV=15PtAKYx|ec;?8Y?qMWnS;<^O93rLwkz$T9-J zGg-v~$8$kfWWKy`=uO2R8P$UZ3{r?%NsW@HzLo%AzJh&o_3X7?BP798s^?h7Ox|mv z&k0I(+^HEdi+n}@4Gu~E)`h`;x)X_}XKPR1_eQyd&JA8_xy38awKBR+vqn>U;__w=dA0KA>Y*w(d#(bFWmsD2o6&tm|v#whuBPzv_CnVsv5d*!xdc2o`yTq#O)nQ8VHo8+Ax~8 zW11`x38LX~RxW#G-Q_0F##mi=4=}ls{0|iB>_V1lSFn@P@$z=Aq?4pOCP)ellw=B7 z%CH~>ud2lSTsZy}GQBD3g%*<=IgaL`=ZsOT)g%x1T(C7T1L^T_Z3NoQl)&0#D%}kS z1AtR?=pvaVk@Ko{hWhI{2i5RqGohf8gNC-XB@x`$QSh%nvP%UpWTh%DXK4a`nJf|c z^5|CdWF9I1(T$PPEpujJVT}vFv8EsA!?bDQmA@C)I%yx31*IDQ_6p)b=E1Hl<0P0_ zjrwqlgx-AvGhYTD>j5n>TDq*`b=Qop}l8fWfq#QHShNroCuqHeBMuxvA7twD1g!0A^;~t3YU>7Ma`1&-(seQ#}-Ko3+xDppoA=>Zg)PlD(!2g%N?}8<;rb@R67YR4C z{}TZ*Q^sIwtGsPhB816E%pXjXlP>-3j9v~#ITRnB{=_eG?s z2Xc&MG0!;mZ91nk`QrBc6boXxP~>{t;aWDl+7)9~wgaTg-4_*Mdi(N#u##f)t|@p5 zZrdCF))E4N$e`2BdS}_xe(jap4b+~m4Zi~d31`iEUvP;M^iwBxEmowyhDO1s5@_ce zcn#r_7OM)!_Z}|#3H$c{g!-OdWVUb+o=szvKS5rvhT_Ut$2@d>DJZeZemnu0(o)r~ z#ZN)|jXc*^DDePOx8o!cLNN9LkjAg)3(s}O<^Mi#H#VHF>w#NExoYz zFO}s)e-WwQlfBI;vYOnB%xaae_4eDyN|Kj~3>h9Ee0x5KOPVpZU$XrV=-6!aAIxa* zsGvA=GYNa$zcg;%8_MquFiWx8dd4PF6Voy?!Xwrpm{(SesR|7|7uwZdf<4zMUK#g3 zm70onL0@n8Bj(i3xC{#hTWY<$X5T}RU7MyCv%@7VXaAixi+rv)zg|}{Ott?-#mjoB zg&S+VYS!ztYaan}lbh$9Eu8ABp`uq7GQR%qP1WBWvbsGd)80Gyt#Ny0VfutW6Pv4ocBA$ADZT0Ex;jf7^fKj)elUTOy=mY zhtsAu-0-l{OBE{fgzF>_=Tg-BW6dMe$JB^!aA-nB2DRRQ9BPp-p{y*a(v3TE5$^@N z!GG9g|8nuT{LY=TEZLARR*zu!DN0{5%^SFv>692|_N;$0FsN3hsZ&j}vg}k0E5n6n z-y(F1XxVKKO`gwLDbw;2-HL>)k8g1@zba^fqIGbitd1 zg&tInS#N~nIF05P_~L&Vy4B==I~Ir43rtFlw`=Sww6_Hbsha^{bD6e{-QgwIDWO zVD+_*@?^o`HfLLy7B4=(`u%^raDg-2>{W13X-!%1FI9TA#U}3WvpRrvAWn%mwr$*V z>qY;tlUiCB3Co*{!u-E6izs`6{h5BwDlH)U-XG%U!LJ|9M+|L|{9cr7)VS;$wC(RZ zHh&{AKiFKhD}x)5eN^&RkPz_T=f3p%0dtLFK@I8!p$5k~>T?Y#!*445dZMP1p$GG| zRW||Vb~w4d?O0nCw_U0!zw&RWx%*N(DO3s4WMrEK`&VgfL4i=tH)xooGf)YFKi zHY4(ldx8tIfeT00a~Lv^%^v+u_Ydg#a{a`2lZBqwLYC(}`- z(Os#ZZD~w*u&pnOrSvImOn7h3{+blp-SIneedfg&yia+*9P&Ex`7BYM*G+(8xaN*F z2ad4~o@-%9IL6Up-IXf_a|n({-UuOQ!|!zp_|ab)RJo^R+dEa?I27HNXMeXk`*s}% zRvBmbURByIkn|1q^X-~FoGy=WK(xLZLdcpu_|{5ETW(e6Sl2bJ__7X{zwFf6bWXY} zZvfN{;}s3so^W$bX=~kNr9yd`o>a`w2|8HY+Umvf`#smI^QyF2Y{-K{@{39;O%>Zc zxUZ_R>reILcDTRB<{CCU@fu!1PRnpsJK_^?f@0aDD4)D!+?dcM2B@oAg)uSB;0069 zpBq{99^b>M&=E&pws?TI)^>jz*Aaz{XR%EUn~n_+v}Gh+&0YIBs`D{(A)T^n1@$9V^5c8U}Zc}+@O=lxHo`mJ5(SjLe*`V|piFK^ecmU){T z4`C00F+`LUl5mdmqtb`I606@T^Kq;Uht`%#fp$M;VCBKnikBge^~;O!acCpAS6in+ z*GgZBWAOv-=T)@AGBmB#NFM{9xrj9~FE=~k-4x`Y7;k}J{hr~RIb@4=ZMTgh%FJq! zSsFmVB=*<#Cl45^7TQvpH!=B)OdQlW4DdYcp012cd?}G)iFrY9y{LN9ciPKRxa|X{5726W{Y%R?kE@4Z|XW32Gki zhVIW)C1QqOrU^gs+Osi(MVXpCyTPv&fr0y$J|?5YeY0SH?grq2InH^gsn^fVE|G%e z@=;}onmYC&<;}5Cuk&=Ity-b;r3mA>>lq!EkICc@iX9Z0iZHoje(P2kE;Il#bw*3- z!#5`)O=NQ@h_=V7R*D--5%V-}yb-oDHD%H$k`pmuR%{Jt$pXp$#n@X%MHzK{!($*S zNQy`+h)7F!DBU@9cXziUT@nM*AkEMzGn909r!+%%$9o~(_j=a5p6^>P%Rf-BIOpu% z`?vR{YtPHh!~UVrH;!^ei9hI#3IjOqGpS%ESYKHm_hIAW-Yz=m&+R1q^z8lS;q8)g zR7!u$ki7KDfZfom;L0}-(S*_jF#L(A`WRkjGe&X{3aH>+cUB*aZildE`%W^jIutOz zTz%f*|4>hzx>e~DP0mB|%$FYmQWBR>MTVGps!f}dnTyw&+x0t>FKx)F*?JQ<56_up z74&BgatOqg2MY#1R{POE=IB7JWIf!ICFjNb$k=B-d|@6JLRjHw*qu#4rpGfolf+o} z(4sByFSv^6U@#ynt^y7Aef=zm7wSFTJgI;alABHp^(NqS`dU5Y$Gokl+q>fpq0&UM zf!`0RDVgmh@b|WYXF1?V*__Jq9G9n^hkQ+PIFqrjtplUHa!$Op_zn*st1mvChdXY@ zW`rv}-15Cod~Q2gHGq{iY_v1s0VY~n*o-^wyyCce^h+drsyDZvVUFV;G(`ons!?w* zD5R)uXzw$?77j}=-BS^?Q(Bm{_bHC~=L@c@uU$mUI^Qqzl?5))9e!1x5B8~#OAykT zKiUeoe^uB`&9;$HjXrHDw_eP6FiZGEmoEC3S>^_Dv>;+cp2OQ?#TWu-E9aI$U7uu( z0(R(n?i@|$1AfdIZxHDHc+onaG`#{W*lmY+^ZJS&?&`+5xJ>4>h{#gAg8qTGv5%3q zyYo`f)(8(j*FgGfXh75kKU#`mbse+sL!QrmQ6+T&4ak^3y%Z5 zB4tz#ab__^p9M4B1C2Vnf2U|=QW+5w=eIU&t-c8%#X%f#OyY#5J=hKe3@OErC4n6j zcLCM{4yqBy_VxiN&X8HWP1mpCZNSmM)t^$3p}7rRdFs=3;-7myX+Y@@@5MK|(7!Cq zpGbHKJD39dwLjoFiRPDi@}M#xF3zkk`niala>y}7I0ODu%~$uQ$l7@&x!?rRb#@C6 zK9#R}V(f6Lvir6fhnO3Z=TMBT!}pKf-ci8ie?y^)KV8=R4&5BI(#pywRt>NV(z^fA zopZZ2L1GFY2_+ET&ZU;CoXrKXfiuU53x{|gBp&Z zU*piEq5L>D@hOv{7Ks?B_*xXC(+XhCaaUJx0o?&oZn;JVX+)O^aO~hO5zVzr{eB4Z zne&{Du~h4nV@~{!)bdjwxpCZtML}Vbt{uw1q0V>;*_V_q$NDvpC%#|Dk+=NrPloz= zpQ3UM0R-l@j1lq47e{L(+dL3|gW;oisZ3cxk4t@;S|0S#$$iUO8qPeiLYb!F;>#&8 zXYc9z%MUJ&hTh*nT>r%5IZ^}q(V%@zC z0&`Ht;TyXgj_96p3=}^~PbhAhW&AwS{&ghBLy^;&5*v~~wXSKjrKt(>>95^Dc$&D zarc~dZL(RuJvkf}uTcf?b{=d{>UtJbJxeNY_LNJN=`b;$1cL9*>fB_HH0s>uGNn=b zh%35|#>u#Ws59h!)$OPgd(B&u?ixplu|AZYKS2YoqR;P&ixq;uAsRdQ+gWK z9T-FJpK#jieDO();KbRCC;Xi`cxVDlk-W%HA=3WWPmgstVOwwt4BCz=e9;v`j2JyI zNfSLqZ+Cm|o?kR=V^^t&ZtrcKrhZ`zY2W}~%laz!CvWFd)1e2dt7948b_>!`iB;W# zr#6@U(`ePD(6wc&u!R1xYLNW=x7k^+z^+4)j!-er6#^C`FgY$M6HxohvX40+DZ#=e zG^b4}tC)e+ORO-zW}M74x1A5)!ujw7y>9c%cdoXJQ-amujN-(IRPn5Qx;j;-^O>-( zOUm^e8V<`1EGulZm+txEJEv+`MSbiV#{|BmJ0WW|<-scsC5hKL)$e;m-RX;Lz(ZJB z=5i13Wj0o0h>FR6yYYjwjEphfQ-cp2H^)^YGB^9K!%NzPVb#_7xBRCH^DG(}?NVJ7 zuGa;{(>Y@Vp3TTF+|J^)^hw5Cm^Gw3$lgqly6$_*{wM0`o*(KuI{C-}#Vtz$HN{Xx>Jr>-<(yOCaml&$9%*Zi! zv?qB|Hi4~gFRUFnTLw00D;IF8cl<19pfscux!>EP76o>H7WuZ@36+Dpn^C3{$^}J-R{xf`&W6n8$B!*Rttk9q*cNzIiZM&<#;3|E)}AQyY>CK9_mobpSMbBMz>e5b>mPhY{&?EaaVE`QRH0F^9nq$b7_sA$KJI?BJy-}L zCG`vA`xM7tvRH6%fZ|ul0s8O-us6SA)Y)DbW<3$2+a??y+knz7dt47z3G`v*sh|?C z4!%*5gPP%IQsK+&{^rx*)Y*_xOc-n6FypSfl=i6T|2Annq|k8LZhZ{K$=>#y<@Ib_ zJCEp|XFV?b;q}wQW14GrEq=?eoQ}R*%*(|mP~+NW)D$yFJK4iU%jueZX(NEZP*bdo z(!WCuQn6gBvuW~YuRC7fJ_;Qj1M?gl>?k_;tpF@0F<0^ppMveNCC3NGakBt>f?-45 zgN0K`oD{2#iJD##xZ`!qw`Owt)|bCqtRPd)a_$AA@TXW%i>#Ew@+bq5gN4ymD2*!1 z-rk1j@UM3Y5A9qW4HVj04nI|Tr3D6h#MNjCCk7)&kKaL0On~CQ9ttfw{#M8DV698X zIX>^p8zy_L>-{Ki4ov_$85w2=b?1pHP{5f_d9>qcxYlTjG8L7tlFPjFh~xq>q3m?w ze_U;`m2+-Tux8dhOsaY5o%@`R$M&PHXc7m{GcOm%j2o0ZPedIIMCvscx{shJ+vGHn z?uhy37WS5wJ-Y5X>}|Iljd6%Zg}#QbCK?*?>H5*m zj|EYyE$~)v=J=~4BqQjjF$#|Atvk++l7lQYY>jT`N+op7G<TOTR!#ru= z=QZ5YR!_z8xg^FQ??~vxc$1hiypk9)Wo}P2Dk{&?vVLSML~Qdkwgp06X}x6&@dyP= z^!{1W@*-^oqpuL&Yr-1MEJ}eUWNOXN?#DqNBlc^i51nHn5SElV=W9KEWCa{-U^&3A z(NnXv7141QYDw+4LEC(aj~2&bfw#KaSzYwCq}55Gxlqm|)v)Lat1%5nvX?b6QEUta zA3^=Xw6|xvIku5kzTXeSWZt}RH2exF(drv68Y*o6mCAilT}>PahJ8PIzKwWKT2HmD zbGjWH=Ii}yWEGP?4C#n~lYL*Pd-yG}X}#HO7y;2mday-6%B_4A)2x05-^>v$P%N&Hm^RK1bWbjNH-baRe$i7jr)f$wm zQ;mA$L;C9$JT}0&M02s;H#g;*fwhGWs)di=Z!&+LY+L1-%(WWmZ!Oio9cW&8-HKq0h z6pL3_tAB{7AK}(F$RhALsowQSkzWATlt%qYuSb=pIjGW4e2Ld&)xO62Dhpv6bBQcs zMN_`O9XH61DOt9kXiXOkHa&N|_wLe0+J=M#o=HMHLpT!S=?d zn96Bwt$1hUq-Mo*T@!tR42+2xmLn4}0mFD(vRJ}Xq~|O}^Ak1jpBng5FC4Ga+MjxN z8%Y|PoVUI!zFoV@r6%=qpKWaWmkW(c&0K8F>pcc&Wx&a){a`#vo$Dl;u z$qgRwmFc!}ef*ehYEyP>>Nc?Bn`32OaNv;_bG@y@5L^a5a;aAnx|O|Rn^ih}Wa;<9 zDNO>YFXTQ3DW92%d8TA`B<%cFrL;J~Oh2As1gjuMlXqOOMBZhgEU=@g!v&KghSzEC z!SKm`F^%S>iGn+8VL@)=!7mM*vEN+}0{*%6s#ecE^>Yh8x?NV(6L9`4Yf{mBJtCEC z?dF#8$7LWbk~L}VZ0a(uxX_dFR78ro9OxQV9`Cl3U>Wd-g3v-(dhVi3>)2&b+S46A z&>#7j1i_P4DPPiYM@k?T2|jjKNzpoAwZY~(-We7UG+64S!NiNRIWrKSqHa!@kP#GI zwUSn4F6vYcKBVb>)$LeqLO}h55R2$9nmb`7Ye0~K%^IU%LK8vTEOh<4d-x~W?Wl6B zId|RWE(@Jq5#atffcQLd%*f-%XM z;*W91dc$?Yr{M_xQJ?1jJnrftK!9LJH=&|U`CvyD;lZSWc#fu}h-}&%UJoeX)=`DI z*Im2uT`Vt@s&?CfUA1;z9>bk%=GJQps_m>YIwJSW=uld=}&_8i*0OgeY!sO|v>Q80IQFh5OF_ z$GZD8eE!|Fg8z3#AxESKQlk++dE`gsX-Tu<`jW(Ch|UIN2)3u`y|z2ggw^4ESM4zY z>NQ>Q5v&lLWG0@mkoMAqn$w9h0kGXV8ATV7INJ5G%x>56a*XQRRazvHt7Es)K!oX0 zK~8EIIu^qUWwG~1Z$wY-5975s?zl)UI;!`XHRVlj8UCrKE1V6LK~scEDc5WkJ|-p0 z3AbFb$>iBApO^dLRZt(SC9Hhj zov$ohl+@@ZH?QR#`+M85v^okDLBXGT#Bp^22iD4v^>+?H{;c-uGp4RC8mOA&E(oUl zG7Au=4_A@ePBYGKA*qITJ){d48FoFb04629$PcF1*8a%q8X%%`ik8w)wtNr=gevK< zp`(hX*H?xsSeVbAk4@NAEk@@UbO=Iqe*W=YF?H{aSn6GJ#t&biJkxPaP-Z`L6j&UUMm^5?Yf=`1P5i;TWp-TqcPL1vDN5tRZrSbL043_Dy59dlLtW^#tSGAgRZ%eYsSJIMQcL{GtG&(*xcSH z0pID1IXZ0)^0!~Idp=~UJ1cZNr1*RvSQ{O$n@ZS!%3*hh!PK2wi{`u@;S!6h*cm_l6H}g3q%zf`&(*Ww-M* zSzIA>X5>6qA8vPX;`H4`&OM@xC z-Nw|EXzjQvmABQzz{cX+MBmRYiigd` z))K|KEvCxEkE(8BeEQceld!T@e6kN#ZwsA~KBvIQo@(sr^<@Qn<>)e=CBI>ELV|sxl28 zmzyt8@w9ep9AR=YiY*2lb}RWEkgs*k$mHYU?WT5&F|UMY2xYvldmruh=g_do%tj4{ zs|k=I3+`gKtOH4WyID*0TAm+jibm)#r0rPu;HwQO(ne#u05S=HZ=$}6~)ZynTZ8aLD& z^e%LBT$)pf6C~{==2I|IDdQK^yZE1$olC6eEmD*I*4vPAt)4?ICRYw7=N^ht5JZjt ze$v?)wWD12K0+0rboKhMNCVf@{kxpaVq;pnwi&ZUPUMpeub!`$`rb6)|6l=x(C073 zlzKiA{EVh1cWw5?QlCdh`vxQ@ONo&|SvEjMRvCM6{u(ePrN3R_-=qZ06NTvS$|lg9OhVqsGDP2CnrN*5*D8BVNsrg~J|M(gj-OXN=L z)io@WobkW!u`pd(ZT!BFb08fX8iI~RdG>~-+wH@^+{hyVNrfzpUa9G~QiV6z%vMv& zwc|HOGmsX(cNNy2soBx^?5y{G5-oy_zts9g4F}*B?mJ2gb#o;ZoqMI<%&|wzzt|TY z7QJjUK(sDRZ-_J$XvmwQnp~O9-&iIWWqtYH@##Qro4NEiLx24{>$;N*`|NRl8R;82 zNzK=oGxTaF^<26m<&NrlDaqOg8XKGLnEx@g99VJm!@V>6c&w=Sve)$- zCFQx2UE&H+p`_MeI>g!X)$7cg*|roj0;6UAL)0hd=U*k*imFXr;)>PSX0EN}c1X_h zD++fs%uxG_6ON^hu?^b>R!`1*p|iVzRof9Vo#_oXc`iLeuehYP3hyikrX*eUZ+CzHXD4 z(;E-XNhgS$Z3XndWs~Z~KIK-Rk=k!qK3$3p>4yym^F9s7t z#IrDJ?u4aX?;1I|bdycLa!PtOD?nEpny=3ZFuCLgl(B&RQ@M~*q^c1?)caDmUTmx5 zgg;A?n3}iJfd5pk@-JPgRW-rWe0`rwu7VlYHf4MfT;_vI97a%cm$a&SIM;4O*JX(- zzda2#Cd7a-e#J3{#A*MC)6R9k0cl{~d1;0M{;o%|ZkD(ia;$Z(g|$f!J{5kTXR=W9 zmYU=+7kXEaqrR-u_8^`5ex}=i5*1{IZ&Cz7wQLu8W1T1-Q`9tQIq6b&R@UU}Be;A+ z$s79U^Z37l8qtpTfXFsTn+%QQ17At8B!Y@?{H87oFCa$ylUPP%5c&r`57ZKBcW z2}>K|-)|Ep*aLnrE?Mtt@Y(090oM;AuJTWBwlEZ~?#fyo{iB-K&*VWZ1Hx7??Fq zLJf2)W`=$O-=2o20X5j2QD|^+u?5zY0=9dc05jVICm|rm{4>K%MC4fMKV?n+!dO!# zPe@Ty!5_(E|MB9nk?)0~j+OhTx9-O?cp`YjEKA5<;U9_6b*!&`+=b~T)t3~PXUObb z)j_ox5bN7{mO23k(+_Pr-=(Z$J)+ftGPIG`&Bi6M4k3od*NmCJ)fRS48JSVvXJ|*2 z=iNQQ&R*WVIUQ^fI_I%U0n0Bd6z%#;Nn1uDNWbeSo6=;u$K>>FYieNA-)UIAiFh+kjZ-sYDAU^UJa2N0ZA zQIJN>m0qQCtb7Prn&`~i&5w%1O?CXi;zL86fWXD*V3YcV;Wcxolqak%X!x}G0xs2n zLU8KA=HjEvt{A!&t&?3^P54GvB{kakkEOL7uMXYV#V1zi0q{qE`H2)b*vSaa#a|H{ zR75TAJH|yPJ{i*F+yp9&H7uy4>xPDC*-ZTWxjX z5SV#;@5=$W;X~JLl{n%vXS*{n2JCuq1yw{1)S5mKF+e)gxc%wAI45vdQTO8H zM^Gg=)`;FMwAY))c4G{3V7CO%8`qYis$Xn8Jh(YS@P{SpOBtcgJV8sKzGD*`Qs-9p zu-7Z+qnPb#DQ!(AF*1B~-Q9T}N1ZC4w)QOBz1RSk1CjdDp#EUrgt)!tn^x7l2$J?hzXN6i;_oPCE2&cCG5u9o`nQ+ZLD|)6=6z>|ZTlKfpvI zEPk0%eExCU=wxk0xIHX?qvt%*+e9X82n_1_=aX|7T{Z3=`mO+Pq1F`L3|~gFoyY|ehzAt#N_3b{{V|?*D<3=Px(Q9q*u#i<&%joQAsSF?z%2WCFxosSt zq0Mm26fLcj4P8K+dqu0C1I||;E)I}=*>b>fCvXdBM_)ao)W)0*RO1hiwF5iCu3ls=6GGY$N&a_*6|~dasNhdf&pavQQ8ho?-hV&fuJS z=v1A8V9U7jEJYJ-MUJ{Cx|HY-b=mJzeEi!$1hOYzW2%^RaLX-0L5rnNy$see3+2@*GJ(RHRJv z7FtU4vD=d@0;7{9<5%5xPirAX4{e@SSl)?rNk~r0i%`NX6>7W;1ytgV{UxLa028u5 zzt_}G3p+(>7k1S?{PhkFlwUq=Xw&Sj?i4K#jra&G0B$?bU#gBc~6VB6s_?)+7Wl`IkP1+jt+YpFDRfp}9Y+t<9TGUcR&R z)FE(M20(RhyRQI%1BCVuMKsHEVbFMXsVdkO6qfwwy1C}&ZkeS2mYE~p$<&W56k+f( zNC6*n^Sm6_S5Xr3i21&@(zyL+Azdx@CHIx|D;+0B-vBonP0Sufet!FV8#ePkB_-bw z3PTUJQ-)zwfC1_3Rz`Mrjm`)4k^-A>J@*6t0Pnj8jyQaah}c*eoxK$PMXC8zZJe!% z)>O)wkFTEfA?KX*9PR4o_&Q) zxq(M1%K_+q9pK`QEq;EoPY!;dHhz(cozbOI$f}edHfomfsYMiMr#E?&5%`JR4N|IR zSupVWi0bA91R7ZaSoB={6tlDdd)a0ubYG(s#+CPcK)CQqZV(y@HY00z@d(733*0jF z`fT$tNT+vLq0$1pcNR1!j{BAKH1yP{N-a%O?YWYfVw)MuH6_TWPZuLko*?WSfMciL z*~wq?9^4LyxTL0&RuRnht?pdPtJ{t{P5r)AY zxv4%pe?F>;iHYDt$bOdmR<`2sRv1z$u1GAraLNLFZcCgz$o^WOiP_uZ5LWNM3k*p# zSq5|~iR2y_hS7M=OjPh%3_Kw8@~U5bdLGMluRcgz`C*RT+v+zLt%uKm;yRNT8y(r+ z)$5-SX?;aJ^N~fXH$apz!ekpIBZ}S&s~oq|F!uDHru`^-eW>jSCrdcD0;x0eyv!9Q zZ=tgBLb^R1bBe!NgqMorKFk?5zUubuL2pM-Jksf_@ePh0K3)g+%prkHJ|8{pA0In? z%^hR-!y5V}a;Nx48(ki!(MakswXoN`Uo_07#M*6VEOh?ZbJO|O{*xf7me+|;_qcu< z`3rBCf|=SI+uKI3u9#8C=m22KOvG&hSJ{f4Zf{VZWX`;g&b}x(w-go46-ImpQH-_7 zzQN!9)6%y?9q6@x^*XEDhso?BVC`b8mYz7&CHM<}a$hbZzF;d=ILN0B7|zOfZu%$f zLxl4j6(#kOw#RmByK>!LO{055dz2)<2n%Mxdb}o5AM`e}rXshIRqAR_V?N=guNcakY12}J9PFhUBZ4XfgulxL{hokM&+nz>Z@X80EQ10{4Apg&G~Lrk>ezK}^B()I$-r zL{i-)9;CeC;tI`{KJ;WC?C+20ll|j#?-2Zn0Z?>IB>V0)L{8|St&gDtWiicb}zzNZwCd`b$=^|%ega#kVN9KZp|KZ`Xauw~AYsWSB zwE#%yExdTE!M!_}&N118ydY=#I@PxR)PCKKR;Y;oMI^^Y15(%ddLNGFv%4lrp8J%$-4oqk^+uE+(UwSKubDaPwe8y5YIcbjGO8N*7#RK9&SGGRWIqJjKPhp`)cC zOOk*d(5S<4ytZjh?axq9u%09mt7WGbvTz$BuG-=1mh9(pEnJth{qK9#Zlr6EyT^=+ z;J`>lkGL|ArRhqU4Jmtf@}<1-`FZ0>+X*t{6hiF5DPYDq@Pl#-as*W9I%Y~Ntzniw zY4S~(w6_|^f7)VJVPRA$F)_a+@Y2x1Abwe>%>ZL~i2LqF%gkiCaqnq7% zMdeyQg4UY{Y*r3&vz1hs^D@pGjX&ip&4P1~=8?4jIN>&ZZirv^_tOSMYfI1_KG|9C zH29slmfgmCZZH~c_i;8Rf21n<2TUlu;dZB!p_|OmqiGZAS*1ukfmrzU+6bf_?o8hy z&XPmrNJKtgmk7T7yc%a#p19P`3uk=)^U|3zdp)xXRYAL_o(KK73^29 z-l2MNr_W80-cbYOBRzhiLtbD_5cOQaO`eNZLZp9;wf%Wf=h8lUj)!}Xhn&KJ-l+C4 zxReTcD=d}a?j94>b|oY;yRQ?`B=L{X>?;OMSYyLYxrYk_10B4tI>$+>t)hW*C+{*d zQ@^_&a3GAP4Mu$1r7$ofmv$+PHS=a&R%VYvA4YzKa$@EYa2nt>k&zBv&!smD2^!pD zt1~|DX*bLqNzQbQl<9|oWUSI`_7Dg6UY1<<7_HH^jl_H?%HLKOv_a#YX zx!NXr(XZidvDE#-TL)wKFVq$U;wp1IKibis6H`rLESO_G%q))_M(e@Xf?F=m%fI4P zxb0|9^_Vq7#*FOv!%F@JbN>(}mX|Sat}5s-;q|L`j9Zb9C|5_5@0@QCXiE?*2Oic@ z@M}vG1&odIQdTv~JTi#9KvVlP@$dkb8wVJt21|)yqoR$7qurVKR#J`IFnAYL1JU?@ zKX@yAuT+7|z`tQtppyHJE8uv;l1zWz%`i-(&MPXKgkK(dUNYAAab>|3HI$Un9fUvw z?{9AE>)cO&xgRAndE49uV){bpM0Ec?(&ynxruWIl?bZ3!xdh<*fVQ0ujS$uIv0j(k zlMOd3+UVTuZln3BCmY!L4syY!dLO=ToG3p4+3*17w$TuA>>tCjOXJ4sr-;OlyO$aP z^uwxO8J;j?p~y)p{0`nfiMzX2_$LmCZo^yq`j9Kp=>vdKc1YM9x4u3Lg3u)vGEbH^ zS;IgexB}+#BO5XIAwDwjgMnj3MMa+58E726wgLs;2%3oet#h@PdI>37bTa2u8GH@K_nJon zO$3OyB-`?XG=|t*b7JTofVMV=Wf~M=-=+&Eg)P{8#iizfu|{Y!qF~Uk{GUImffNDg z#Brfk8i8e1ZRCps3FPve0wiJ8Dvc7$XOoJyP!{$WR8pMCCIO*aa56XD;D^Yq=*lwG zyaA;tWpX1^Gl8qY?w%Q_#Qz{ET2%px^=;IIh4d_>mh%MPDag z%!se3hry8lR22j&lnn}$%aX@qc>+=UR+RFx$^MtehnL5Q)x44f|JOaZ2Y0ky6KW{kWE}|mFN=H z)m^ngXW!8P1$FN>|5m8;=7!}~x#5P`QwkozK^~`8q#MRtRzT> zV5EC#D%7JN7iG5?jT?%IY5H-oO|cwd>r}VTbw?^@lBgm|X`3L2PXQ>zR8>FfYHqtO9$|Y-1$(B)3oLB)VkXuFCu@FMO<`(YP}>g)3F-;6mR9eWIGrs1THl*JF?m<&5V)LO zPfAJ(kd{qdD@;Af17JK3Xz%WI=eJ_X2jV?fn$%cKY`v-VGUjfkOA>lrN=+1nQ@{9G zX{09#nYLMlmut^0dOb^EN6J-W&`*N!%gS%Fju8q%g3BGN;~US>Bf?2&O-WXQI|jEb zRA2I#*%xv2bWOrwH^4q$|NY)kqmW8i*Rxbkayh4>TuUL2GFPdDo*%p{JtL%%rMeQ^ zDZsNO%cFl(?LsZ(28nw6Vh43;LpkwS^n~I5(b$zcz^cq_l_K{_vVtK&T>hRS^$^^8 zJ?Y9UA}DwXmKIi*Hf%P2>hSb$Spqb!6Cae}NT>|4|`CP(eV#0a4te zTBmNDKtb-QJgktV@(g8@Ob_2`SUAoBZwNY@=i@ZrCZRBt*sFx!Fx+NltdmDyYpijt zBkIh|rEVk=5mi#c8x@(Xd^$v~DO?^0z1FeBj4tV*>KWRZuGDO65vtyMX6n2v2Ia#+ z(eVbNLV(r(Bp4NoT96FPm6X{7+F~k?K8tSSC}FY5J-EW2=DX8r>@oFt z&aN5vn#3I$-t#U*XS}WAHKJm580T=~SwSu>9ZjF$O(Id5L zGU5Z9iK*(FtN~lC#*3*zhUi zTCpX`b~Dn6Si_U&Avk$)=_>M1HqT9_Gh|F$d}T-#a&RA3&-s^F(*9RT|UEURA6Ct9!ew5iaeV{>cmjP$r%pCyS%-kiL+k7bw_y zx1&7V6~zX|o?!2fky|lFEcJrsZvJ7BA#nViF((Aa6k`VWUc%!RZh_Dum5!Ah@bTW(D%afrauCpJvN*1-c@ZVwxNs-Lm7R6(+R=?;H zTbTNJsFwn(bn=dTl_SV;FxuxNm5EP02Gxw79V2EnH7Ex#dcF3GV|~hHMl0`zOBWPU zHMlw5uTwNIIm(O`+SZX!dJj9=da7xpW``CGPLltF1wfwWT~Nq*HzrYL)_*%Ht@{dx z{nb6_=hx4f5rnxxoFVIX*fa48xVFSVuhjf6%TfenYVboI3fu9l3fy}&`&u9{gA|5&uJza9gXPfwie~$}!FcQ5^o_rIm{-#t!;sN9 z4>?<^v#`+Uu2g{)nx~vy&N9L9s@{k~?;Ewdgd!FM@QU> z!xD_WmX531`lRNM>Ha5HV4c z7qYnJ;+2+h*E;xrxde zE(fP@=cmDjq_q&-U1n;F@>%j&fI@$+>-12x@x;mqe~xaA;T>H}-gpe zgg6!bsHeABxj5UpbBo?NS-F)Jh(@tgYM%{9t!Az=bIQK6Y<>@AY70%GH5IE-g0~ux zue4AkI`>VKOyrZjH@Ydp30iIEQkI-|%e2*f(NB-XH6Hb8gipP^BCf1|(}DCS{5x$N zO=2@3HJv9cA{DR_NmXvr_bfS87M6qOl7qp3m(%9=b1L-1>G}zdd3H;tbst2U<&M+K z%g5p{V@fn&Ko!UqN`yBl9KlWKwnz5nka;amL z#gtM1Vx;6%KS}IIOMeS(g=zNa#Dofko@RSHg`9pdlPm4RS@H!kz4ng23=Y6&DYj!Y zE1rvzfT1FA#&!nz0S|DScb`_r``&U4@Zu5}0b}`fbv@saaTV`CfD552VR*YC7emMR-WvNzW4z*3dpB+7TeV&*MbY(ZWclbrVG=!C zNv7_RY0f*#T50Nh>F*a*VZZS1PSt3M&sG-BakKbD|Eu@>7vjMm?Jy;YFt2+H7&$|< zn3LDT<#L~G(?zGJ&J#P|t0m}X?XSv_8HobQyjZ3984;8Bc<>pfE@DdQGxjj|uj4*e z>*<6^S`ve(SvDHs%;>dxBrDu|C9?jQa~25?8<(ga?vy0kUozEc=m!Ow&B33{oz*Z@t7L$C)V$|vsx_ju!m4kbwRgvi zQ*5L5_3-dr)X>$Z33sGT;bUVlUHbvBYI{P8KRI`$PR|JsVmp-juX5NbD8^?^Av`zB z8Ic~Cu1L|1F#7X&Bw>DS8K13WC;2&CU4XG zsFC}OMrtk1Tl{OA_gj1BS%lzwl_#tnX`7s`C)%upkOSeYmHo2Tz7eFRd(kOrAWIz2 z>`jRph+W{9CimEgX*ogXdI$ri!~EZf7mx)Y84kAl3ehmd3M^jJg`XkRFdYK40jGbB z6`(#EWAo2Y`vP{{?fTJSNYMk?*Y`O1|2@y~UxU-KT-is(nO{9b4ziI00=h;cAi=?A z9edaPJQ11N5HUnPW99JI6{;57SZ(cs|8Ft(I&A>_s){=8p zINq}Fc@(Ttl zO{DY<{}bb(G4`herkx^_%%Z3?X%{sx@aLGoYh`6+(A4mOkG{%T&z4xUB_8rS(wshg znutrzX{?xkyZ?6l{m&cwVR5N2120wmY1hRa;+wdJI;@w=^R8JBe41YIGPxt@*Cw5| zDzTQ%n_xPI{EzQ_OHIY2J(%`sx!qB<)g(J+qo!@M^Yx`v;;ktzh!6-&&ZY^JZw{3C zN?q-C`pY(+D4zf=Ge^#4I<2v#G5{0$n8VD!U33?RW|M!(hZ>%Gn;XeED^DKbys1_0 z0PbB~S=n{DZBSL!)&{zbY%?mNyOBVbd&kGmH}UL@9hR3nPbCw$r+Rx&EEazDogG&@ z{_e`f>>IzmM}|}Y8Dhy_BFDR)tHO{gCVv6di~S51*3^%joK&2g`O*20Kokl}R#$&A z%=9e}wM9!%!yL+-aCAT14J03+b4F7*-2tDv-x|lWXp>ai`n>^wTW)n*XSu5vy)Xty z^v>|a*rQw;un;87-s(=MiV#Y9wukdCva%etpS%yZC$Nv(_M`^=G3)9IAZL0gWm5EjOaGNIlm_?~U>he5q2QFgYjuGa+iUTs~0w`px3Jf?LB`ACaMtP>x zD>dTcN~NsSe%~m;3bPsfb*+679PCDL?Ex0Z7`eX8YlcBRJQRsk07y(yiWdC}P8*cG z?Q`M&2wwAfi2oBV)IizZ9~&)s!S~M~lJfxbUO7wcgR?e4APNWP0=Gr>%II)V*?rxK zGc#Kl&0F`3v|YB@dJHtc`t~;?f>%mVo1$M)5C8zX0@DeCMS;EReGuMBJJ+4@bDmbOre6>rmG zr9g2fEycA+g1fsz(NwUa1&RfCclWlqyIXN5c#uHuhX4PZ^WOJ8_dNH0y?OEhcJ}N& zvu4ejHNUlfGvuA@e(hBQ8*X9;g{7bmzHZ>F2mU8790Vf!%g9{6?tg3$0W|8bz61XF z7nJGxez>sNfYU!y8HWr^&Ccfh_)R-*pv0nZo~RNdUWs1N!~@SReVa zJ_54_FMkFl3GRIRt1JL#|BvJg5a=~f4K)0ChhNbD%oBa$=EQ}?Bk|Vj_Pg&=1Uww% z^P(Suzle#5l%=E}86T-z?wRN71dOQVPZk2_3s)wk_$58_eO?-k8sEpiVJ+Geg)rXXz%PL99;oDe)!)X zBW@i+D1#4$D#;AQ`O~DB_E037e7qefMY$$CJ(wt?2K<_@96QH*YgX823 zIKFzNiohZ8w|$1P$F~lzQpexs4(fyuj%1HhNLxMt-Fuly!x_s1)<_2+_@`Z5Q*owK zao{k79%+OS+YM082wY}Zc#BX20PR1o4yS#A>jCfXR~yD;G9KiBK!}j0>@3-uD`6yY zWMu-UB&$|0zrO)0qj0!>*XD=5xpE}{aqsDoz@q~0$`=v{AIl+yulvx+gyXve*O80q zem1K#1wWxoe)$p+UZciKs~Ua(Nze=UpOBSys*&ty)fZPOLwA+sbXz*AP>)l2%LHmI zNHC0;=Up&`tvu(%ac)Hn1K20Cg6s|5Z;N?iVUB&QOOsKw?I`?eBch+;1i3Tw#o5zF zMk|w#=WR^1;i?r@juO8}psVV<4(!@&3`XcQIz-zu;FUz}R3f2Hc&@lOpnFV_>UTf+ z3@fV8mm=)e~v>`!?TAm1q^G#Q;|hZ>aUc0Y;TNxd%Gm6#GXfExG~wV_0+01i_w3_;N9A-jyq;Qll+IVFDzMU~+E}3^ zY*o$HK=M_z9jH0({*{&9y&(V->dK@dEOaj%*VjjS&R1es8_ZEfG;^M4l@|3v0t#Lo z)VLrr;W(9+H6!)ts)v%6a0RZoXgUrnV#G}Q<4W^Mb8s8-lV6vUkUp2`{dn8=TQex? zX4$=t;c@1%-WtzEaX`3hr4jQ@-a-l9@Xz~A~Pq}ZE@dPqKXeM$S2X1o}v+{G6K6?%>H z-Gy)20kj!b?GIbqe3SAq`6CjZ;*x0z9NdWEO8CjoTj@c__rDqe}qx$MpxRgS1|(YSm0aVzJ)D0p|3u_9g^Z>9VJ!Qkl^2 zuyvT#h$YtEuS|#7P`?Qx-{A}<-;loj7s@Hu8XvgQ8Co9s_`11>xe6JD9F zV6hx%Et@g|ws+sFYdy;fhvdgbo!WowxU~)jXAjLusFz*eAtKjjy7g#DPCe>iUEo%m ztZSVa%_x`W*p)(};Ai1WOpS9KQk&z(tp2Em^XB0_{d2UwuQ{{WuX$!IH?zyFSWUjb z#EadgLc^u;+>o;#$g4TGKL1;8V|9n>V+muIeTmBCbYcE+J=VaX-{+NuhJ+jxhA)0) z-EkYkSpLGq@;0!BK^klM8hHaozSM7GtOuG(3moe&R#Z^}OU-xi&mu9SDX5+!|_q2@}9A?|bmkM%yyW3pxaH=vmB8at9?5UP3g7Vjy{jv@BA1`)b*!q_ z=W~4c3ce4s)@A~;?yr*)&nKg#&6XG`PZw>gZwaS4Ox5Dn7td-2+mN4I{3^s$RES!4 zPgAkME~AU>nud)N&n^OY$|W6ZwbUJ)wLF(U#MU7r1upxGd+LuZC$!3`&r6Akd}!;> z4$CP#utfz*Hkc16&pSOZU{qV6A;c)J3w_}x*SDq{nG&dsygaIP%bkmFw3hNb&c~Hv z#tXIL60Fz|#S69O9LA^uw&QX?)H&xaHX&vA$wyt$nR;wzI4a0bd?Bgpe0X}+`p@`n z9u2xpCkr=|{f7{~7Qm8W){w{jTrT5=37LVs>~pxHJD+|rYSy=1e(YRlo{i$g}wD|+h&kOLJTUGq_IV{jP|RoTQ) z*jEbNhhT_xqhEVm!clM5&EeF|z$ho{*&-XIJy;cm8ke=j-@qlvQrgRdaxrA!m*d66*~5{~+t!Tao0A`+E7I3| z;Dxi5_D8wSH5-q;b2;5}G1?t!zsS!%hUVrBVn&rYEx3yg4&*MmIpx!In#`q!Iz?nH zROD5m)$4@}sGV7No%2p;-{nFI4J~~RI%AI6?H3f9jm|jdtVi#r)fn#RV`i`!3{4V~wXyGEegyEb9+I14KeIuHe)owmgb68QeY9cC zU6aYQWV??t%LXw}zTvfcFnGkHYjwI}FCjsJqtWP$EhdJIwgV^RD{+Cxx*tZHFHKl< zq(($TZF-GjX4^L^K->)Zs{`C2U@UdEU$&)L{XUG;ij0_etmefG$Al89wOsuLbFs0> zjthS_%%$ubdhf^OhmDCGO!dYp^m3R$!T6g1+2l|o+7uyn`B7sBgco|rRd<4N%Xk?p z*%eoUswbQSj<5WqzEgiOD2&JA{FHyyn5(Y%6mmylcfD1nF+s&%B$;JQh9caAsQTkp zw0wy5rKqq$Ymak~nKd2>o8w?V7mk5{`#f8w@S&4KK3=!8l=d`m&T?gMqX+tqE?D=1 zCWzvoc?GI)(i@xy36ybCQfe@rt2jjZ%8>SFzsE>8ACH~Bb7LFZ%Ds@mXO2hZsy9sU zBD)c_*-o*!Qe7hP{0%~b-USbwlY0vM-+Ts6GX0g-*w)#uS}7T8(gC$BO&B6RB*Y6n?A|`w{v-HBY6J)BJV30RuV!~FT;L#KM`4DsFC~_9UoR5> zUFN1X!uh^6zip_`3mfq`*G-nx-&bcSZha}S~#i0+RsF7U?=%g z#caD^!m+KV=ZS8%#xE-EI}%5Ga?#m!&zSk*Cfa4oLm?)E`3GNr z^E!7&9@e}Z+u(Abn=0TXtufsq#ahY^9e9i5>$H?qzY>{dFv@EQt?QsF429$;D4&M2 z=b^*_3HwqO0H+r>lqDzgJ~+K4kn&=xnu?G7ofcP)=$o9{_mb~xdR(^_$97`b7W9-| z(*M{@n#0k{@ywo?nZc>3SQ;9Q@nI%nCmkQc+hIAKdm7uZmc1xg4s$~eB@gT(go%Y{t`4IS&vElc_YcAXwXoxzY!y2S*FHeV)z5ukXdWC~t5cW(vo&f2_9ns4&*V$#c{qJr>2APmj?ZMG*8BN7< z$E6|Ea3kO8Eo;ZkSvL6w`p2Qj5TmZ5*@AqtOF7j7F~zeZ%VL!FouO^6_7 z=)~!0TYrajtF_H%=A^A8ZX3zu@~5Te4%kh3=j5{Coic~xVHy+k1p;Rk^Kt><&}z$X z9o6P3A39Kg)h4$*LfQYrd5|O9O2}QhzWBzhJe237(z$2iLA!0f(M(~|hs}X{I|5_j zTZ;Eu+Mtk2r%X0l_#NpEYg zO|cIvEaY&pJi;3-%ujHEuZE3y1ILjM+Ksg)qh3#*)NP8(9*^MvyBAL6)1h*m2gmnGCj*2*64i|p@Vnn^4IdZ@W z4>RhWt#UtWN5m@N*RmI}o!%;ZL}FWO9u{UD)v)_(UIE(d$$0^h!YDoihkYE1W?>xX zSuD{VJAQ%}>Kuh$4R}HAgcs_6Am-F?adHk=u%!amogijUerS$A^~P_li&~UTeZEIk z!n!$Q)N$jlBTdf2lhuu;^qg@yV}8u<+B*q+PTT8h&YQa=A>Z8WgOPZ6p}DS_3#XJn zu{Jq*0YxhfF`=x_#_oke8mela7#ISJ-oMTWV0Di+J$WG7>W}{OAgB}Yv$npz@3)ig|?zyy&H7GJjC7ECD+PAez`-m`f z>3Qi&o`g1yqq7Z_?%9`yuEYr>LVUS8Cm-;wX~C3aB555Xx`z9X}_B?rO5K@q`}+2iF+YW7{bEYo9V-iON}ez{P7MWk*=BBv1iQc03>|KsF$ z8eFN%pTsL&E0CjeD$hL>Gd6bP$AwjI3m7w~`NcS}@DCW%<1u+XE5dR-C8p;?GVbp)E7nY1-Dy=Tr<-v@~=x zHLqrBUuiP^s2bl$kw8*PA}JH@*yW2Z3qz@q!pp!}2~OL#JF^TIuCbyTrW@iZH%&%v zvb1$ZgmY%haMq4ygvwYdFVG(4G==#nqAa%p4P3yHHVw*c!g)$C zkgV_MEFlwKsYSnUpYd=cx&A^@z6ZX|tEJQ6u9F676E*=~uf3nQ40^O4P}QTm3kxX5 z`bLOfC6E2wb7pk+1j5=O{^kqypNaT3DlwNE-ltzb#|Vhb%_TQ$yWjWacvz)u|a z`pw%O<;CfUgt>;qy0o!%X?Ys?^ftpN&@)IINqO6X8FF@SGi=Hq6DjnRiqdj*V^j!rRa%w&AHBg3p9VfJN(V7I+GH zq=xLq@CWoVzCH3H>4WR+>8!u@LyiFPQ)RiC{Y?~h`YNC$=ObBJI#~BoCl2ZlHXZWo zH1I>KAzZYMrjhap$g+t#TYN#a_4$#4k!-rhjUtVe18SD(uh;%C6&d!LKF+>Y5^B}*sjm8n`U-J+ z`=GsJXjVO&H$FnHkW`OUVA^00j`x7snrQ3$m*BG?LjY6(QIP<7=W*Q)R#kY8(6!g_OM& zQx->DvNUobF&=IjA1=3rKU@KIU8`3hSCSz&d5LX+{Ss8tLi&w4$!b73VPaNhA54%U zLQhg=9{CXDBc@9&Y>2Kz2SxQl$2}UO$cQq!FAULZ_XGc!1OQb}r9SWlAY}H$IR1Qd zg?7jL#gj{^9A>gs%Z;q~VzEAtGAeHV9Dj;UkixVOH(&-%2QqsXo~)0&mlw*e(JL0m2xbf!mwmAZgDLpv1ZsR0 z+(CcpU0w5jOm&mO*L?2EgahywRlU0VzSnBs@OMD+nVQ6Gu6kuL!D5z_Ko^(2y`=Lm z3rGTD6SuXj5{|7#EXuR#Gvt%Grd#K~G1Y=xNC|rE zY20&SecB*Uv2buS_cl0y>xk+xi@S7f7nbPYOHmmBFdE1^)mL~K2FT$yqFlr6qP{aC zg3s}Xx^*RN9R8PnaFN~*D3FVJ{vHOMZR{7j4}t?jXWMYQKAYU z@Wtijbl0lj=z*yXIyC-Xdpfi`?3Y^@v|;8xIok`>EcmjI+hu&Y^D~*iwtKJw zU{5LerGlw$iYIDk+I}fQs|cu}wkK@#gL+MY(>AbuK#GwDF(KKUUBt80X8K>fbW~5* zrbz?lS$}aoB7(8YSU5#u-2`-9xN68kubIC8?1+RLCfseL*ctKFc&AJ2yjnYN!`W2;dC4@l8URPPe8R5eW+b{ay)k)PS+|8zkm(rFv1lZd$m+2BNymFw zjfZ@p=_ggx*NNcFOC=Qzg7*0smf{SI=5Rw_y4LW(zMP3QJjvg$<7H#r%(P$uHEH&0 zACIC;L%l!3wN>67c>!7qFn zj<+iew@Y})j~cm3;!AeFd1-mnnP6UPr&C@?;D_#IXXN^@yWQe|^zAMEw$GG>9Sg37 zS)86)+J5yB*;sc@GA%K$J!(o{m0N;xX7D<4V)piq<7;nUYSqXuINZ+;Gz%-f8XOGx z=rLj477-|6ZByD_)Em%GWuj6dBilhKA`?Z@S9w)$gy}vgK`&1cO=g66)!VBpOH8iJ z7@>wa%6igM)*vI8Vr|UC}XKOcJhB zG1aG&p^0T(=k(i)u@~9_X#O^RjJk@_8Udb2C<#|{Zxu_c-rkNq1&-yBZ;QEdWEH98 z-u;XgIojJ5nwCGfHH8>cN&nUjuTT9@6*i!i>jMU>hj{x#Az0-jiP_+=$A#UE?~$xUPO-;rbA-cus9$~q+dwc#kWA#N&qdp0H(DujF4~Tt!&lHlfFm5d>xVbKF-h@Qj+x;#ke`27b}aMK5ormmW*nEDLK!FtdEKG)ibpE-r~fU38y6{+?g;W z4)wdYj0)gA+#uUoWhsRhVJ`McooZ>oUwynGXq7J*0rsFLnX#W)J8f1+RUZDhf5X7j zVLnBt4Zt5i!PZ)$<_^s;Uw+%KPqEHvoXrQvyMe(kn06v9I5)T914h|7?w1imBTH4s zW{PPI<>DdacCTIb>e|HNrK&qFZ)}^Rofl#3C7I zl^iEe`Op~{?Qdfqs{r9m5a_YLe=jk!_TD;U<4Mo(=8nq#S*>v&(QUqz4-T(0OV0Z1 zb7ylp=f4I6lSoKVlj2lR{E`&22QGfWw+6Exs~+n}r}1F&K|ai<6mb!6@t{JYx8|^j zhzMShrQa{R4#{rv`{|5sjrU3r;nCCE7HDqs5d3Bk{We71%+~q!?=gEb;5r^JH2JGZ z408!DOw;mcV)i`xQ^VX?V8c=S91PBsRfbX3tTW|VsH{%RUfEf-RjZ=Dm1zDG;`MlP|X@O;j}#I zsf2l#1V>iMIHu%8c@C0IV9F|Heg5aKfUo#d@KUm7+Dk_m_^^k-_K&asV3?ZXGcRv? z{EUwkP&E4u=t>5T?+x!jtopnFN~OFo2(eFl`|c2_0B` zB_?1YQ+np~_(~JcNTA{W5OVOfkRN_~E+jY}wd@jk_o2Vvw?{Uq&p3M>Cf@b|ZnQuR zuweFo*{sYNhuwGQ^-E|36$&XUX-#ruu&Yc9?DbY*4A&g%pjpe0s7ORWADp9xN+ z4i<>&zvf$b5sW=fKFp8Vvn?KzrsOg|`;q(=>o#9jzvEVs@nR;1utr&=W2V~X7~v2) z(Z`H{8{(g9alX-WHp-tmY71Gb&y9P`Y>X`|+)Hd8&vz$7`<+(s2I;NAf~C8_%j6hRCvjIos1fCCIpDCURM)AjgCmV9$KH$<@5yTUQ3Bfcrx4$MbGl;dPVnxT)6k?n`Dq z5WscY$~;KTn9f9%0`ZI^=eo&y7M2W_?Vhm!znz^|SHZ3_iT5HouHIX7HK{ggc0(Ki z517jQ#)S>$7nG&qOl5YE+HrqjuEIGr%4w^F{%f!DPVh6;6~^&tvN=M0b^>|pnq!H| zF(k{1IDX=DSVx4zX4vi397Kt%$u`?!>tLqV$1^@6mGau71Y`o zFdkTZE(;h`{ISjhu?)S84Dl-qIOfj-yNUrT*?Ai3pIo10pox^Kv_(D->)U{cjgx#> z!50yw5qfCz<~M$KzoDLydcCxUXDyA~GX#4Y>SEfW)x5Wl;sr7bdvW)#R7IeYg4Ydl zm-iW9;@vyEreCNJ2^%a8U23XtXpO2-UMEuYpNXt#a9}-8l0(MSGoQxzp?4R3Cwv9( zJ8_3qx?b3uf?4gdf_Y$HlFW9<@IrYi*U7O6G=RVvq)b|rDVkq%)QzJ#&yX;In+Cj& zn_kmfP>Y3s^M$pTQ;lEuIz2OELY1_zLr(=hV(luC`V*|(f-{I*@DOu(xq4VA=;=O> zWJb=>j^o`)s7>|PM12ttb=-L##nsm{yRXpKWR~K*j1y38SFYx(MwIn24w`6{kFT=G zs;$P4in#!LP-zrY%4@P)5+zgEBH3qe_9v9z+Wbpe4y<>Z`w#ilmOXsFY zze7lt7m(Ev0H{A3lW9HnDNbE~j~ZVilF?DFJp8gdK!(O82epb)HLSDV$=Im(O5rv51#hRy1WHnLx_i zr(YD~^*rOxLC5s5OvMglBEnJa5oh3Nk*gb`JqCA2w{+hav8&dR5q zF66?4r_$xlI{0i={r=UkpkjS)s)7tHnXBdad^7ZZ&+`*JV2FbR* zDRe0tJJU9{eMQ^q=8uxbE895tCf9t9Q4`>)DyL{)x6V zF2L+o^I0k1AZ@kzEL@&RaOu+Ttd*;b zz)#PQHeB|Qm{ny{ZO_9MhCWTVqpAuR6fabk!eExX3wfEiyvlYoONfO0Jb1l5VaPy# ztnqb1u4Oge4fT=Jlc`Z?4E+m1;|&eSbTXkT`rd7{?(DMMa}Yn}Ang|Fwo@fXRc5cg zERBD`{D946ZhW6t7PlrU|A)du?Q%>rN`71fn-QCl3#Q-stdJ zd5j*!0R)<)O-8;y^f*9-Y3o$ zn;_CGbK-2c49iwGN_k1BWr;DYl2;KA?$Y%cbVnAVj<2!?zaayZ01Pk=e6u4RGle9; zidXxD*pCEeY!%|KDfYcb=28Nj!Qw&e>JCAh#maON zngrnzysoNjW`ocd;M5cXypAs0t;wD0FA{GJtQh;Dt1qo`^-wyzsurTZ1F7FT_;iNyxUo)gIhLVtEU0=Ts zSVwz*6df_B0;aROonD_(ukuqreITGB<~wgCVVFDbGp1_ffY0XVdu|)d5hM(0dA|2J zl{qS9KAI)kartKW=R+S0=hR>)m&d#d!#Eb1AoEPZ4v$;QcZL^C$97H~yEYOgKGaIa z0I)!z|0ERuG*}KsfOY(bikVq3X7zDsw8~Ifj3>u20DuHMXYK6y+qM5JqI@VcW6)q3XYaSc?T{je^p#O3|`KXHEIwc_dO%9{23leE#2 zl4V;LgdALEh^=uoN@C-UfvzYXeXcwPkHvKRUfv6%j6Q!#0WBm!g6etPDQ)?&t$+H2 zl@Mx+!fE$y%QttZu#;8kaqa7r_hN81#&fLm062q9Pc`3Cr{C0$zoi*$coaWVs@+Jb z{%<(p@!RVKM*nLEA|TYDXWSFLfAaed?zA(i|JSXQlt~SY3xwXt5MDt8UJWoDe^$@c zajs3-aG`*qU=w zV7SdZZVox-W*SrEalJTxbNm zVWmh-1W3M|%_|)OqKK$H(q$^5f;aq^rh7yM*G_Oz#NWxLn`JXgGy{5wS`(~r(yI-Zd2AY;7f4U*K9 z&}n-S*B_#-Ik91$sH29K{_P!qYht4H3SLqZ<>>v#Li3$&OIAsVy@;1L52%d400MF_ z%PJboU2Q2flCIWW;pi44qXV#;oykRlP|BHzSR>bgaqf>v3wsbEwXV&?xE4KmCbFlt z6F>bZqr4nz`kxS{`iZN4bJ|E--2LT`be?LM(^sVU8^7sj)~c^J(QUvKyKYs{fZyLm z6i`lW9Vh~G1Ap=EbT)p@=DN2;WMbbpGCOEm0vfjvInjjdMlgN(xq;MK_yL+w0z28N+p z14pGFtcIe)hcWVu6B57ZY$c1>IoC9l9M&k^_>)!r&XCo)a3}ejrz8MQLxi8ODEPROpu;3we83j5MIx8g!fDnp2T%?41HdMIonq!nVrxeqoVg8JNROmH`?Wi}#TQ_KbUysu zGV1J7Aig(Ier6|IP+=CoVd0w59=T}Kp3^rx%`YQNAd;bF*|7UXr|mY#^Y1EiUYx(e zS75*lTT>N!^@3?&xpj?_0uE(%JtOy1WiHOIn56n_KYxp45qHJkydKIr_nPj;<~h;R z4bueUM3ngVFm=JWr*FYU)1!SJVMhSrC*!~BGfL0Vl4hEsbaaoNend9z34B!NSW&pj zL0YMoz{DSnFAA_A`XxVH(@4}9ouMu3KSmPy?Cr{Rzsl(Q#Qy&M1;39YyxSOi7*Cny z=DoL@??Rsf;xoBum|5@c7!fvTV_G$r8rf=6>vG@u+%(BYmE+{LJmhCneE?&F5`yyY z|1CtakJTLl_p-87)T>1=cJVnd!fcVs`?4lfc`%4p>dLaY=~T`bHFkWA!;NRp{@NX- z%yS#O>_f6r58-Z<9O~@iz~gaO;&WGuXK!U^@3)U9=PNMWvZ3VD(kwrn|HSE9b=w?` z2V!UV=Y#`dY&MJNA?clQi$~DVgrhfb>@_S5xQrsX-n#7uvQ@mrmK=t)PL5@oP{$Q+`Md08C81MwB*M+`? zDE<)bdX1nFSuL*%A1tk1$cYseV_3-{^67XPb<7e}rLg|}XW%O!@c-8{zax)%8&5h_ z?E@xW-{0%}&hX=xvQjW1uftW-N+(*ZhOh(Dio_KGXMHmx=3GNTRX_qWTJ2Hkq)N5i z`AgEBoEi`-)%B_vByRi7%UeQ32Lk}oHPLoCwgw$P&_pucSGwR;hEH2b0m~By7Q9mc|guhg2Dp;1R;P0zGC20 z7QTBZi{tbRG)WFjI)H1b{wXT&ib(;e4c~v_2mOmh^cO`9$mbS2{C5N=V1)yG{x{Ck zzb>VAcJ}sk_C9hV08N7bssP!w4gy8~JzwfyWv`zLqN0b@z8Giu>z}7j{*p8Zh-U6jwB~tM%l+m}vjG?fAb=CNSjQ? zX)4>n*U<^!A06@k|5O3!6%y{&X~@dI~>ue6Koy z{ee`tn@I|fQqOu?g16U8f-IRyxis1Lm+f>-lfj(8d9b$(rCtjKUvL{ExF!EQ<_%}d3A|vdym|oyw z67+u~xdn0pdhmAhgPg8+4zTlXwJE8H`&H4qN3ScpscN1}4ZVcO_3#xCB{)t3iw7@X zhWixK62vjJFJn}H5&VPW1|58{QIw{!#G`@7g#1-4)RLneN1=JI-`{WJg&xp-tV>-LagJ!JVu4WuO5hgMF6E{Q%@Cj_5PBGYgjcx5v4#^gLx3x(n3f`?Xod1(L7S1XblL^i*ToT7gDc zV+`HLc4XvKZ2rk>BgPXc!^!a2?!lU(zeArrf8pc!ZDWutM(#l0;_BqfnWU+a9bGG-H1p@=P(PTfq*dJtt>P!8aQt#wy zpT+q&>?61;bj^4=TF(8TSZ#}>l&!>me~qkG_S{3oJ(DIxQQl$yWYXB43vN=8c=)k{ ze5(2&tN&uB^{ie!M`Q5Y`DwBsJK^)@3zI&F4Ah^Z?^!4!XpphCR8qWR7WgDn<1D7ypo~{mqysZzq0tsuB;h11ERY9%6_BN%CQ3rKzFLs zjhVajFn%&OkQMo9`0ktK&#Y`k^UCg%2u zYy)s}=^eHw7n7ph#uXmVz#g7QqWRJ9Y3&c$7LbIzHzRn0fILBT@q0os9B5UgdsUu= ziDcEp;7Z?>W~)*Bl~$(^f5aU3ZKc#)tR;gvM|t4`!Ra>DlSTZxs?b=}DP(^XGjvqd zR({~azia2PN-4Pw`<_BK5MS#|1}{ymJDL8a308`qCxdCrWBvAY+LegTf4*bc~up&D)lqh(a zTiXuv_MN_fS>qTr1ilUa>+j?2=sTTynR=d#H_RmLs;!G$%xu(@SXru<6(u^QC&J_ z+S_*KJiyP4vEyP3Q+HM+O0Ioi;U}D;9UCwK3#;968EgG7$`dS$pCLTrUSnOUnfm_a zb&q`|go&n2zXlQx+B6~vmOk91g(x!$YS*{g8Kl{*FV6=xQd=MGU(-C9w5n=8uy1!C zhiFWl&+az{O~VT$Sk%vE_OZqm6{iFvKe0OlKUajj2LmlP=!WEZ=qqd_(xzX!U~0H7 zc!Kd7-5%@VPnV3EW#56UjF@$g<% zkt|h4E0z^v-iFq}!qcIYdX3r|T0#eV*RmehQl=Y|^YDJy@;(JW3GL5b{4{U|sa*Uy zfVa&z*&AO>yi{N3X{ws3H7mOF{LH`!^BX_;@i$LPwv~@kwyS=MG$H{UQ787~FFa9^ zAv_MZ7q*ro^VC@nBIp(eD z;gAx6gKG9ro)^Z7=OF@voc!XN;VJL$a!zt9gj9tNu)KV$--B&pBH$3jbXMlS*i!} zLgC};7iE6}OXoeV9L4v8rs)!IT04giWf}Bd=IO4`w(KTU?CBee-xmxANAW?R(#SE= z=*JXO&30)qe1jqe27~>{_P{RAdsH~J6=F0_d&j9$j#=dL5ju>=$MufX;{oqq0)1`K zef*pMyjt;+s?Be%-di7s;s%e~T&$F^sGuekSWf|@LDI=xGJSpX3x+G=;8nNYpzw}} z<3QooZuhBgxGbM^ieYuTS}FF(s3*j#Id>#5_Q~WIPi4?zJTPDJR~olHPcKfHKL+>1 zFJ=*ZX&4t6eiz8nb-yB8E@SLtZLLc9DY^*Z`^3fVbM2YE`*P~79goJ=cSOVI9Phj5 zyA8pE&L>4)$xWibuAr&jP-d4oy=;VqkaVeKq>TRAU)`As5t>{5Wqx)%MEgJIA z9?WbZrr>?9!^6m>Ip!}RGdK?)l zL35H0PP`D6xJ|5tGj6M3xpe--2*zl$vSGx z+=(`u)%y4_;1y)E#ziipkqInz5HeP(pPqAzW`_HG1!C=@EgZbG@@>gFpa10iz_(u8 z9`mBwWv7tyG8E&S$}s$6JtWAbahWgwrBfbsmNy1zVqiSR{Y*lgjmt5}TuMP?x%s;> z%FqO%h#9_*Sb2S-o4dK!{BF_Lxu!WbYZK2SCw1$bjsQGR*wcz`?t=F>SFg$?p153% ze4=1rz(@Lw=yP#V+)N`)7#nt+GuB}cxhcN=C#1F|+5A6H4 zX7%`-MTLLkhkJ6k1k-uWNsRiy&nNIJe&hcFW_(T(d-)UZftiBGc+~vB#;j%8NJ_8h z_r4fo<_1Mv^-O*V_}YB4TKE{}n;!qBWC|XW!fI;z80ybJ75gW>&^=9Y=obZ8#Lm_2 zt6!BKz0SErUOq;Elcd6UI1A2vi&V?0jwd(gMmTW9MFrz4Oj0)+mxsjs!W@nKHjgfl zko4>z$B(u{N^O8=FmhC-*m?BX)cBQT+mFq^?YWzrV`-DP;M5S>PO?PRUemyM%92=#M|5PMCc*_ub^xm@TB-7TNn5=zceq44_K>+v`I3(=eC(C~VIw$iC9;s~$7rSg z{A9?Wh*=+b%(VW;91Hp_W41Ow@qy5K$m@%M1l$?a@xnoy=VLs31L^%?%pT82T;iUO z{p2LX*r97)oj&z!E*MW=yz|DE0bxD^oM==6*7 zUm`vg?y9hZbwg#Z%83*rpjXt2X?$-!^7y08)#!;l2k)QNnQW*&4r`yy6h z<;n^i8PDZ7ZqG5xx?hZyc|Kd)+_D(0PpM(!q0r>UWzu|v8w@|MmI22m)LH%v9}zp3 zHtW8pXnZ#^lFLrIxq?0Re7)Clbg}Ifkf0B9EA%pzV??Z+j&=sQBs%ldpmD)=1~Z$8 zl`V*Ks9pi4ZA7W9!I_BaVnJqXXlD%a1n||98pKsB+5m^xVX0p1>;Ee6+P{*%-}qD+p@f%Sxrfu)>lk{ zm5R#?WK9sKXG8O%r#zWf}IHP zS27G!&9JWEU&tbRa{o*l4F0*vzG^Fp8+QxUldv)1%;1X45vnpbU!x9u?s}c7?;feb z5;3qyat#P!vxVPwSusXRuB{I~5~7m(h3+0cA z5rZFZc6>XdvQtU?xLaeK%h_*EJALdkDVi}0VhgoEYI@&f*rjp1>k~6{!}=xKp|ng# z%XcA_zO3$OLI=*Ucs;|7)4Bit{5Z?RU@XCl84nivqy>&k^&QH1go8>QoWoCD$JC%H z(ZY3#i}5rv3V-0K=V+^6-{hCNH!svD;^z9C|Cz-0C4VL?;PS+~>(De84E0d=!@Mv$ zQej5uh0(Z)`mfT-0T{h*77bg)Ui|lS8&6w|+L;21hy_Z7Zn}*&42BQ*YJ$~h7 zU<{g{7EGb2C|`Q;T{dMe1v`6cvuPeqaMe3h2Ub9Zy#%3tay)z_xGXG*=j+vVb)TK94d zlV!C%M>CY07h_VyJzbLQc``zx7{dsbXWzGftxTU1b0{M#&2U%AeC?tFR*H&m#4@8X z{>0JWk_HeTKpUq%=#!1z`No&!*$5Y>#Yas0F>LTN{#Q?aBt^I7#Vf`htj)fya9`AlXqctG*}%!2@|6AN;yA^domDLnyXa@CJ;Q0n;*>j6J@sGCKGTne zmlYN={iZh*=tp0+?sC~y`tbL+#c0Bwg;abo_Onjp-opZos0#l?AC~hg*0j4=tMwX6lGw_ zKa-OZHc%ZI)MzGhl6wncTAcy_U@$Ua+eHdG9c=1Sb+G(!ouKp2XsVD6ekGMH60d3f zxa~^ZDR9X6vEvccUZfy*%n$0N`E2|>Fm@Q1CE*ZKjG@A|cO)R;76$^atguL9uya1hnu*TOE z9=~_U7dTv$wq-pifRca@1si;k^rQfChaC{bPV0{-2LMf}O6lwn%0AjYES&&uS|Kkd zZE5D5fiMIxw@_fOC+U(p;r=_1P5m0S^@SHlo}3C`wg9Vux&dcTcFE7} str: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - @property - def boundary(self) -> dict[str, Any]: - return {} - - -class ExampleReach(NetworkReach): - """Reach connecting two nodes with a given length.""" - - def __init__( - self, - reach_id: str, - start: NetworkNode, - end: NetworkNode, - length: float, - breakpoints: list | None = None, - ): - self._id = reach_id - self._start = start - self._end = end - self._length = length - self._breakpoints = breakpoints or [] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float: - return self._length - - @property - def breakpoints(self) -> list: - return self._breakpoints - - -class ExampleBreakPoint(ReachBreakPoint): - def __init__(self, reach_id: str, distance: float, data: pd.DataFrame): - self._id = (reach_id, distance) - self._data = data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -# Synthetic model output covering the observation period -model_time = pd.date_range("1994-08-07 16:00", periods=180, freq="1min") -t = np.linspace(0, 2 * np.pi, len(model_time)) - -df1 = pd.DataFrame({"WaterLevel": 194.0 + np.sin(t)}, index=model_time) -df2 = pd.DataFrame({"WaterLevel": 193.8 + 0.8 * np.sin(t)}, index=model_time) -df3 = pd.DataFrame({"WaterLevel": 193.6 + 0.6 * np.sin(t)}, index=model_time) -df4 = pd.DataFrame({"WaterLevel": 193.9 + 0.9 * np.sin(t)}, index=model_time) - -node_s1 = ExampleNode("sensor_1", df1) -node_s2 = ExampleNode("sensor_2", df2) -node_s3 = ExampleNode("sensor_3", df3) - -bp = ExampleBreakPoint("r1", 200.0, df4) -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0, breakpoints=[bp]) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) -network = Network(reaches=[reach1, reach2]) -``` - -A **Network** represents a 1D pipe or river network as a directed graph: nodes hold timeseries data (e.g. water level at a junction) and reaches carry the topology and reach length between them. Break points along a reach (e.g. cross-section chainages) are supported as observation locations too. - -The typical workflow is: - -``` -Network → NetworkModelResult → match() → Comparer -``` - -## Building a Network - -You can build a `Network` object by loading it from a supported network result file. Reading these files relies on [mikeio1d](https://github.com/DHI/mikeio1d), so install the `network` dependency group first. - -There is one constructor per product that writes the file: - -| Constructor | Extensions | Product | -|---|---|---| -| `Network.from_mike` | `.res1d`, `.res11` | MIKE 1D, MIKE 11 | -| `Network.from_epanet` | `.res`, plus optional `.resx` and `.inp` | EPANET | - -The remaining formats mikeio1d can open cannot be turned into a `Network`, and say so when you try: - -| Extension | Why not | -|---|---| -| `.out` (SWMM) | The reach connectivity is not in the `.out` at all — it lives in the companion `.inp` input file, which modelskill does not read yet ([#689](https://github.com/DHI/modelskill/issues/689)). | -| `.resx` | Not a network on its own. It holds extra results for the network defined in the sibling `.res`, so pass it as `from_epanet(res, resx=...)` instead. | -| `.prf`, `.crf`, `.xrf` (MOUSE), `.whr` (Water Hammer) | No test fixture exists for these formats, so support cannot be verified. [Open an issue](https://github.com/DHI/modelskill/issues) if you need one. | - -### From a network result file - -The quickest way to get a `Network` is from the path to a result file: - -```{python} -# | echo: false - path_to_res1d = "../../tests/testdata/network.res1d" -path_to_res11 = "../../tests/testdata/network_cali.res11" -path_to_epanet = "../../tests/testdata/epanet.res" path_to_sensor_data_1 = "../../tests/testdata/network_sensor_1.csv" path_to_sensor_data_2 = "../../tests/testdata/network_sensor_2.csv" ``` -```{python} -from modelskill.network import Network - -network = Network.from_mike(path_to_res1d) -network -``` - -or a `mikeio1d.Res1D` that has already been opened: +A **network** is a 1D pipe or river network read as a graph: nodes hold timeseries +data (water level at a junction, say), reaches carry the topology and the length +between them, and break points along a reach are locations in their own right. -```python -from mikeio1d import Res1D - -res = Res1D(path_to_res1d) -network = Network.from_mike(res) -``` +The workflow is the usual four steps, with the network standing in for a grid or a +mesh: -MIKE 11 files work the same way. Note that MIKE 11 keeps its timeseries on reach gridpoints rather than on nodes, so the nodes of such a network carry no data of their own: - -```{python} -Network.from_mike(path_to_res11) ``` - -EPANET results use `from_epanet`: - -```{python} -Network.from_epanet(path_to_epanet) +result file → NetworkModelResult → match() → Comparer ``` -#### EPANET companion files - -An EPANET run writes more than one file, and the `.res` is not the whole picture: +## Where the network comes from -| File | What it adds | -|---|---| -| `.res` | The network and its main timeseries. Required. | -| `.resx` | Extra results — tank volume and pump energy. Merged onto matching nodes. | -| `.inp` | The model input. The only one of the three carrying reach lengths. | +Reading the file and building the graph is [mikeio1d](https://github.com/DHI/mikeio1d)'s +job, not modelskill's. `Network.open` reads MIKE 1D (`.res1d`), MIKE 11 (`.res11`) +and EPANET (`.res`) results, finds the EPANET companion files, and says so when a +format cannot be turned into a network. See its documentation for the companions, +for loading only part of a large file, and for `find`/`recall` between the names the +model uses and the graph's own integers. -Pass the companions alongside the result file to get a fuller network: +modelskill takes the file path directly, and opens it for you: ```{python} -# | echo: false -path_to_epanet_resx = "../../tests/testdata/epanet.resx" -path_to_epanet_inp = "../../tests/testdata/epanet.inp" -``` - -```{python} -network_epanet = Network.from_epanet( - path_to_epanet, - resx=path_to_epanet_resx, - inp=path_to_epanet_inp, -) -network_epanet -``` - -`Volume` and `Volume Percentage` come from the `.resx`, and the reach lengths from the `.inp`: - -```{python} -sorted( - d["length"] - for *_, d in network_epanet.graph.edges(data=True) - if d["length"] is not None -) -``` - -::: {.callout-warning} -## EPANET reach geometry is limited - -EPANET is a link-node model, and mikeio1d reports no length and a single synthetic gridpoint for each reach. So for an EPANET network: - -* without `inp=`, every edge of `network.graph` has `length=None`. A length-weighted `networkx` call then fails rather than returning a meaningless number — shortest-path treats the edge as unreachable, and anything that sums the weights raises `TypeError`. The attribute is always present, since `networkx` defaults a missing weight to `1`. With `inp=`, only pumps and valves stay `None`, since `[PIPES]` is the one section carrying lengths -* reaches have no breakpoints, so a `ReachObservation` cannot be matched — use `NodeObservation` instead -* `find(reach=..., distance=)` never resolves; only `distance="start"` and `distance="end"` work - -For the same reason, `resx=` merges node quantities only. Its reach-level quantities — pump energy, efficiency and costs — have no breakpoint to live on, which is tracked in [#680](https://github.com/DHI/modelskill/issues/680). - -Node timeseries, `to_dataframe()`, `to_dataset()`, `find(node=...)` and `recall()` are unaffected. -::: - -A MIKE 1D network contains multiple levels that are unified into a generic network structure as depicted in the image below. The image introduces concepts like _find_, _recall_ and _boundary_ which are explained in the following sections. - -![How a Res1D file maps to a Network object. Reaches and nodes are re-indexed as integers; boundary nodes expose `find()`/`recall()` round-trip lookups.](../images/res1d_network_mapping.png) - -#### Selective loading - -Large result files can contain thousands of nodes and gridpoints. Loading all of that data into memory is slow and may cause memory issues — especially when you only need the timeseries at a handful of nodes where observations exist. - -Both constructors accept the same two optional arguments to restrict what gets loaded: - -| Argument | Type | Effect | -|---|---|---| -| `nodes` | `None` \| `str` \| `list[str]` | Control which nodes have timeseries data loaded. `None` (default) loads all nodes; `[]` skips all node data; a name or list loads only those nodes. | -| `reaches` | `None` \| `str` \| `list[str]` | Control which reaches have intermediate gridpoint data populated. `None` (default) loads everything; `[]` skips all gridpoints; a name or list of names loads only those reaches. | - -::: {.callout-note} -Selective loading only controls **which timeseries are held in memory**. The full network topology (nodes, reaches, lengths) is always constructed so that `find()`, `recall()`, and graph algorithms still work on the complete network. -::: - -The most memory-efficient setup — useful when you only care about specific junction nodes — is to pass the node IDs you need and skip all intermediate gridpoints with `reaches=[]`: - -```{python} -network_subset = Network.from_mike( - path_to_res1d, - nodes=["78", "46"], - reaches=[], -) -network_subset -``` - -If you also need gridpoint data along a particular reach, pass its name (or a list of names): - -```{python} -network_subset = Network.from_mike( - path_to_res1d, - nodes=["78", "46"], - reaches=["94l1"], -) -network_subset -``` - -When only some nodes are loaded, `to_dataframe()` and `to_dataset()` only contain columns for those nodes — the rest are graph-connected but data-free: - -```{python} -network_subset.to_dataframe(sel="WaterLevel").head() -``` - -## Inspecting the Network - -### Available quantities - -```{python} -network.quantities -``` - -### Underlying graph - -The network exposes a `networkx.Graph` so you can use any NetworkX algorithm or -plotting function directly: - -```{python} -# | echo: false - -plot_kwargs = { - "font_size": 6, - "node_size": 130, - "node_color": "white", - "edgecolors": "black", - "with_labels": True, -} -``` - -```{python} -import networkx as nx -import matplotlib.pyplot as plt - -fig, ax = plt.subplots(figsize=(10, 9), layout="tight") -nx.draw(network.graph, ax=ax, **plot_kwargs) -plt.show() -``` - -### Timeseries data - -```{python} -# Multi-index DataFrame: columns are (node, quantity) -network.to_dataframe().head() -``` - -```{python} -# Select a single quantity -network.to_dataframe(sel="WaterLevel").head() -``` - -## Looking up node IDs - -After construction, nodes are re-labelled as integers. Use `find()` to go from original coordinates to the integer ID and `recall()` to go back. - -::: {.callout-tip} -When creating `NodeObservation` objects for skill assessment you generally do **not** need to call `find()`. You can pass the original string ID as `node=`, and `NetworkModelResult` will resolve it for you during matching. For breakpoints, use `at=(reach, distance)` rather than `node=`. See [Skill assessment workflow](#skill-assessment-workflow) for details. -::: - -```{python} -# Look up a named node by its original id -node_id = network.find(node="117") -print(f"Node '117' → integer id {node_id}") +import modelskill as ms -# Recover the original label -print(network.recall(node_id)) +mr = ms.NetworkModelResult(path_to_res1d, name="MyModel", item="WaterLevel") +mr ``` -```{python} -# Look up a break point by reach + chainage -bp_id = network.find(reach="94l1", distance=21.285) -print(f"Break point (94l1, 21.285) → integer id {bp_id}") -print(network.recall(bp_id)) -``` +Open the network yourself when you need to name EPANET companion files, or to keep +memory down on a large model by reading only the locations you will score: ```{python} -# Node batch lookup -ids = network.find(node=["20", "113", "38"]) -print(ids) -``` +from mikeio1d.network import Network -```{python} -# Reach lookup -ids = network.find(reach="58l1", distance="start") -print(ids) -ids = network.find(reach="58l1", distance=[51.456, 77.185]) -print(ids) -ids = network.find(reach="58l1", distance=["start", 77.185]) -print(ids) +network = Network.open(path_to_res1d, nodes=["78", "46"], reaches=["94l1"]) +ms.NetworkModelResult(network, name="MyModel", item="WaterLevel") ``` ## Skill assessment workflow -### 1. Wrap the Network in a NetworkModelResult +### 1. The model result -```{python} -import modelskill as ms -from modelskill.model.network import NetworkModelResult - -mr = NetworkModelResult(network, name="MyModel", item="WaterLevel") -mr -``` +`mr` above is the model side of the comparison, holding one quantity over every +location the file was read for. ### 2. Create NodeObservations and compute skill `NodeObservation` accepts a file path directly; the observation name is taken from the filename. -The `at=` argument can be specified in three ways, depending on what information you have at hand. +The `at=` argument takes either of two forms, depending on what you have at hand. ::: {.callout-note} ## MIKE 1D vocabulary vs the modelskill API -In MIKE 1D, "nodes" are the named connection points in the 1D network (manholes, junctions, outfalls) while "reaches" are the pipe or channel segments that connect them. The modelskill API uses `NodeObservation` more broadly: the `at=` argument accepts either a node ID (int or string) **or** a `(reach_id, distance)` breakpoint tuple that identifies a specific chainage along a reach. If you only need a reach-level quantity (uniform across the reach), use `ReachObservation` with `reach=` instead. +In MIKE 1D, "nodes" are the named connection points in the 1D network (manholes, junctions, outfalls) while "reaches" are the pipe or channel segments that connect them. The modelskill API uses `NodeObservation` more broadly: the `at=` argument accepts either the node's name **or** a `(reach_id, distance)` break point tuple that identifies a specific chainage along a reach. If you only need a reach-level quantity (uniform across the reach), use `ReachObservation` with `reach=` instead. ::: -#### Option A — original string alias +#### Option A — the node's name -Pass the original node identifier from the source format (e.g. the Res1D node name) as a plain string. The `NetworkModelResult` resolves it to the correct integer ID at match time, so you do not need to call `network.find()` yourself: +Pass the node's name in the model, e.g. the Res1D node name. It is resolved against the network at match time: ```{python} obs_1 = ms.NodeObservation(path_to_sensor_data_1, at="78") @@ -411,7 +101,7 @@ cc.skill() ``` ::: {.callout-note} -Resolution happens inside `ms.match()`. If the string is not found in the network's alias map a `ValueError` is raised with a clear message indicating which alias could not be resolved. +Resolution happens inside `ms.match()`. A name the network does not hold raises a `ValueError` that names the near misses. ::: #### Option B — breakpoint by `(reach, distance)` tuple @@ -425,12 +115,12 @@ cc = ms.match(obs=obs_bp, mod=mr) cc.skill() ``` -The tuple form is equivalent to calling `network.find(reach="94l1", distance=21.285)` beforehand and is resolved during matching. +The tuple form is equivalent to calling `network.find(reach="94l1", distance=21.285)` beforehand, and is resolved during matching. ::: {.callout-note} ## Chainage tolerance -Breakpoint distances are matched with a tolerance of **1 × 10⁻³** (i.e. ±0.001 in whatever distance units the network uses). This means that small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no breakpoint falls within that tolerance a `ValueError` is raised. +Break point distances are matched within the tolerance mikeio1d uses to decide two chainages are the same place, so small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no break point falls within it, a `ValueError` is raised. The distance recorded on the match is the network's own, not the one you typed. ::: ### 3. Using ReachObservation for reach-uniform quantities @@ -447,7 +137,7 @@ obs_q Pass the observation to `ms.match()` exactly as you would a `NodeObservation`. modelskill resolves which breakpoint to use automatically: ```{python} -mr_q = NetworkModelResult(network, name="MyModel", item="Discharge") +mr_q = ms.NetworkModelResult(network, name="MyModel", item="Discharge") cc_q = ms.match(obs=obs_q, mod=mr_q) cc_q.skill() ``` @@ -465,7 +155,7 @@ Pass that database as `db` and modelskill does the lookup for you: ```python quantity = "Pressure" -network = Network.from_epanet("model.res", quantities=quantity) +network = Network.open("model.res", quantities=quantity) network_model = ms.NetworkModelResult(network, item=quantity) obs = ms.NodeObservation.from_multiple( @@ -496,131 +186,6 @@ A few details worth knowing: * **`source` picks between files.** It defaults to `data` when that is a path. Pass it explicitly if you hand over an already-read `mikeio.Dataset` or a `DataFrame`, since neither remembers where it came from. * **Items the database cannot place raise by default**, separating the two causes: a station that exists but has no measurement registered for this file, and an item that is not in the database at all. Pass `on_missing="skip"` to build observations from the rest. -## Development - -### Custom network formats - -In case you have your network data in a format that is not included in [Building a Network](#building-a-network), you can assemble a `Network` object by subclassing the abstract base classes `NetworkNode` and `NetworkReach`. - -`NetworkNode` requires three properties: `id`, `data`, and `boundary`. -`NetworkReach` requires four: `id`, `start`, `end`, and `breakpoints`. - -`NetworkReach.length` is optional and defaults to `None`. Reach length matters in some domains (rivers, sewer networks) and not in others (link-node water distribution models), so override it only where a length exists. Where it is left undefined, the reach contributes an edge with `length=None` to `network.graph`, which keeps length-weighted graph algorithms from quietly treating the reach as free. Nothing else in modelskill reads the length — matching and extraction work from break point distances alone. - - -The following is a simple implementation example: - -```python -import pandas as pd -import numpy as np -from typing import Any -from modelskill.network import NetworkNode, NetworkReach, Network - - -class ExampleNode(NetworkNode): - """Node backed by an in-memory DataFrame, e.g. model output.""" - - def __init__(self, node_id: str, data: pd.DataFrame): - self._id = node_id - self._data = data - - @property - def id(self) -> str: - return self._id - - @property - def data(self) -> pd.DataFrame: - return self._data - - @property - def boundary(self) -> dict[str, Any]: - return {} - - -class ExampleReach(NetworkReach): - """Reach connecting two nodes with a given length.""" - - def __init__( - self, reach_id: str, start: NetworkNode, end: NetworkNode, length: float, - breakpoints: list | None = None, - ): - self._id = reach_id - self._start = start - self._end = end - self._length = length - self._breakpoints = breakpoints or [] - - @property - def id(self) -> str: - return self._id - - @property - def start(self) -> NetworkNode: - return self._start - - @property - def end(self) -> NetworkNode: - return self._end - - @property - def length(self) -> float: - return self._length - - @property - def breakpoints(self) -> list: - return self._breakpoints -``` - -::: {.callout-tip} -The three abstract properties that **every** `NetworkNode` subclass must implement are `id`, `data` and `boundary`. If `boundary` is not relevant for your use case, define the property to return an empty dictionary, as in the example above. Similarly, a `NetworkReach` with no intermediate points can return an empty `breakpoints` list, and one with no meaningful length can leave the `length` property out altogether. -::: - - -```{python} -from modelskill.network import Network - -# df1, df2 and df3 are DataFrame objects that are loaded in memory -node_s1 = ExampleNode("sensor_1", df1) -node_s2 = ExampleNode("sensor_2", df2) -node_s3 = ExampleNode("sensor_3", df3) - -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) - -network = Network(reaches=[reach1, reach2]) -network -``` - -### Adding break points along a reach - -Break points represent intermediate chainage locations on a reach (e.g. cross-sections). Subclass `ReachBreakPoint` the same way — implement `id` (a `(reach_id, distance)` tuple) and `data`: - -```python -from modelskill.network import ReachBreakPoint - - -class ExampleBreakPoint(ReachBreakPoint): - def __init__(self, reach_id: str, distance: float, data: pd.DataFrame): - self._id = (reach_id, distance) - self._data = data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -# df4 is a DataFrame object that has been loaded in memory -bp = ExampleBreakPoint("r1", 200.0, df4) -reach1 = ExampleReach("r1", node_s1, node_s2, length=500.0, breakpoints=[bp]) -reach2 = ExampleReach("r2", node_s2, node_s3, length=300.0) -network = Network(reaches=[reach1, reach2]) -``` - - ## See also * [API reference — NetworkModelResult](../api/NetworkModelResult.qmd) diff --git a/notebooks/Collection_systems_network.ipynb b/notebooks/Collection_systems_network.ipynb index 89e9962e0..ffb8e9548 100644 --- a/notebooks/Collection_systems_network.ipynb +++ b/notebooks/Collection_systems_network.ipynb @@ -1,1629 +1,1883 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "fdb0d0b9", - "metadata": {}, - "outputs": [], - "source": [ - "import modelskill as ms\n", - "import pandas as pd\n", - "import numpy as np\n", - "\n", - "import networkx as nx\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from modelskill.network import Network" - ] - }, - { - "cell_type": "markdown", - "id": "b643e568", - "metadata": {}, - "source": [ - "# 1D network workflow\n", - "\n", - "This notebook shows how to use `modelskill` to evaluate model results from 1D network simulations, such as collection systems or river networks. The workflow follows the same four-step pattern used elsewhere in `modelskill`: define model results → define observations → match → compare.\n", - "\n", - "## Loading network results\n", - "\n", - "The `Network` class organises data from a network simulation (e.g. a sewer system or a river) into a form that `modelskill` can work with. It stores time-series data for every node and break point in the network, and exposes the topology via a `networkx` graph.\n", - "\n", - "### Loading from a supported format\n", - "\n", - "The easiest way to create a `Network` is to load it directly from a supported file format. Currently **Res1D** (MIKE 1D) is supported:\n", - "\n", - "```python\n", - "from modelskill.network import Network\n", - "\n", - "network = Network.from_mike(\"path/to/results.res1d\")\n", - "``` \n", - "\n", - "### Custom network format\n", - "\n", - "For other simulation tools you can build a `Network` from your own data by subclassing the abstract base classes `NetworkNode` and `NetworkEdge`. Notice that this approach requires that you build the logic to generate a list of `NetworkEdge` to pass it to the network.\n", - "\n", - "```python\n", - "from modelskill.network import Network, NetworkNode, NetworkEdge\n", - "\n", - "class MyNode(NetworkNode): ...\n", - "\n", - "class MyEdge(NetworkEdge): ...\n", - "\n", - "\n", - "def generate_list_of_edges(a_network: CustomNetwork) -> list[MyEdge]: ...\n", - "\n", - "\n", - "edges = generate_list_of_edges(custom_network)\n", - "\n", - "network = Network(edges)\n", - "``` \n", - "\n", - "#### Break points\n", - "\n", - "Edges can optionally contain **break points** — intermediate locations along a reach (e.g. cross-section chainages) that carry their own time-series data. You can include them with subclass `EdgeBreakPoint`.\n", - "\n", - "### Example" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "cd363bae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Reaches: 118\n", - "Nodes: 259\n", - "Quantities: ['WaterLevel', 'Discharge']\n", - "Time: 1994-08-07 16:35:00 - 1994-08-07 18:35:00" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network = Network.from_mike(\"../tests/testdata/network.res1d\")\n", - "network" - ] - }, - { - "cell_type": "markdown", - "id": "33a451d3", - "metadata": {}, - "source": [ - "All time-series data stored in the network can be accessed as an `xarray.Dataset` with `to_dataset()`. The dataset has one variable per physical quantity and uses the network's integer node IDs as the `node` coordinate:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2a2d7414", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 231kB\n",
-              "Dimensions:     (time: 110, node: 259)\n",
-              "Coordinates:\n",
-              "  * time        (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n",
-              "  * node        (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n",
-              "Data variables:\n",
-              "    WaterLevel  (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n",
-              "    Discharge   (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0
" - ], - "text/plain": [ - " Size: 231kB\n", - "Dimensions: (time: 110, node: 259)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n", - " * node (node) int64 2kB 0 1 2 3 4 5 6 7 ... 252 253 254 255 256 257 258\n", - "Data variables:\n", - " WaterLevel (time, node) float32 114kB 195.4 194.7 nan ... 188.5 nan nan\n", - " Discharge (time, node) float32 114kB nan nan 5.72e-06 ... nan 0.01692 0.0" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.to_dataset()" - ] - }, - { - "cell_type": "markdown", - "id": "a972271a", - "metadata": {}, - "source": [ - "`Network` also exposes the underlying `networkx.Graph` via the `graph` property. This graph contains the full network topology — each graph node stores the node's data and boundary metadata — making it straightforward to run graph-based analyses (shortest path, connectivity checks, etc.):" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "06e8c2cb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.graph" - ] - }, - { - "cell_type": "markdown", - "id": "885523e1", - "metadata": {}, - "source": [ - "Querying the underlying `networkx` graph lets you run topology-based analyses (e.g. shortest path, connected components) directly on the network. The visualisation below plots the graph, highlighting boundary/junction nodes with a thicker outline:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1d068e44", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_network(g: nx.Graph):\n", - "\n", - " g = g.copy()\n", - " lengths = nx.get_edge_attributes(g, \"length\")\n", - " max_len = max(lengths.values()) if lengths else 1.0\n", - " nx.set_edge_attributes(\n", - " g,\n", - " {e: v / max_len for e, v in lengths.items()},\n", - " \"norm_length\",\n", - " )\n", - "\n", - " widthmap = [2 if 'boundary' in g.nodes[node] else 1 for node in g.nodes()]\n", - " plot_kwargs = {\n", - " \"font_size\": 6,\n", - " \"node_size\": 130,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": widthmap,\n", - " \"with_labels\": True,\n", - " }\n", - " fig, ax = plt.subplots(1, 1, sharey=True, layout=\"tight\", figsize=(10, 9))\n", - "\n", - " n = g.number_of_nodes()\n", - " k = 10 / np.sqrt(n) # increase multiplier (5, 10, ...) until nodes stop overlapping\n", - "\n", - " pos = nx.kamada_kawai_layout(g, weight=\"norm_length\", scale=10)\n", - " nx.draw(g, ax=ax, pos=pos, **plot_kwargs)\n", - "\n", - " # Set limits explicitly AFTER draw, otherwise matplotlib auto-scales them away\n", - " xs, ys = zip(*pos.values())\n", - " pad = 0.5\n", - " ax.set_xlim(min(xs) - pad, max(xs) + pad)\n", - " ax.set_ylim(min(ys) - pad, max(ys) + pad)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "53ab2b9c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network(network.graph)" - ] - }, - { - "cell_type": "markdown", - "id": "5d3030f5", - "metadata": {}, - "source": [ - "Notice that in the visualisation above, some graph nodes have a thicker outline — these are the *nodes* (junctions and boundaries), while the others are *break points* along each reach.\n", - "\n", - "#### Mapping original IDs to integer IDs\n", - "\n", - "Internally, the `Network` relabels all nodes and break points with consecutive integers for efficient indexing. The original IDs used by the simulation tool are preserved and can be looked up with `find()`:\n", - "\n", - "In this Res1D example the original node IDs are strings. `find(node=...)` returns the corresponding integer ID:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d9d23a8b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "252" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.find(node=\"98\")" - ] - }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "fdb0d0b9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:00.197602Z", + "iopub.status.busy": "2026-08-25T14:20:00.197216Z", + "iopub.status.idle": "2026-08-25T14:20:02.473745Z", + "shell.execute_reply": "2026-08-25T14:20:02.471396Z" + } + }, + "outputs": [], + "source": [ + "import modelskill as ms\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from mikeio1d.network import Network" + ] + }, + { + "cell_type": "markdown", + "id": "b643e568", + "metadata": {}, + "source": [ + "# 1D network workflow\n", + "\n", + "This notebook shows how to use `modelskill` to evaluate model results from 1D network simulations, such as collection systems or river networks. The workflow follows the same four-step pattern used elsewhere in `modelskill`: define model results → define observations → match → compare.\n", + "\n", + "## Loading network results\n", + "\n", + "The `Network` class organises data from a network simulation (e.g. a sewer system or a river) into a form that `modelskill` can work with. It stores time-series data for every node and break point in the network, and exposes the topology via a `networkx` graph.\n", + "\n", + "It comes from [mikeio1d](https://github.com/DHI/mikeio1d), which reads the result files, and it arrives with `modelskill[network]`.\n", + "\n", + "### Loading from a supported format\n", + "\n", + "`Network.open` reads MIKE 1D (`.res1d`), MIKE 11 (`.res11`) and EPANET (`.res`) results:\n", + "\n", + "```python\n", + "from mikeio1d.network import Network\n", + "\n", + "network = Network.open(\"path/to/results.res1d\")\n", + "```\n", + "\n", + "It also takes the arguments for reading only part of a large file, and for naming the EPANET companion files. See mikeio1d's documentation for those, and for building a network from a format it does not read.\n", + "\n", + "### Break points\n", + "\n", + "A reach can carry **break points** — intermediate locations along it (e.g. cross-section chainages) with their own time-series data. They are locations you can compare against, addressed by their reach and their distance along it.\n", + "\n", + "### Example" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cd363bae", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:02.477942Z", + "iopub.status.busy": "2026-08-25T14:20:02.477210Z", + "iopub.status.idle": "2026-08-25T14:20:03.381839Z", + "shell.execute_reply": "2026-08-25T14:20:03.377494Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "ae495c5d", - "metadata": {}, - "source": [ - "Break points are identified in the original network by the edge (reach) they belong to and their distance from the start node.\n", - "\n", - "> **Note:** The current `Network` implementation assumes a directed edge, so distance is always measured from the start node." + "data": { + "text/plain": [ + "\n", + "Reaches: 118\n", + "Nodes: 495\n", + "Quantities: ['WaterLevel', 'Discharge']\n", + "Time: 1994-08-07 16:35:00 - 1994-08-07 18:35:00" ] - }, + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network = Network.open(\"../tests/testdata/network.res1d\")\n", + "network" + ] + }, + { + "cell_type": "markdown", + "id": "33a451d3", + "metadata": {}, + "source": [ + "All time-series data stored in the network can be accessed as an `xarray.Dataset` with `to_dataset()`. The dataset has one variable per physical quantity, and the `node` coordinate is the graph's own integer index. Alongside it, `name`, `reach` and `distance` carry the names the model gave each location, so a column can be read without holding on to the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a2d7414", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.387636Z", + "iopub.status.busy": "2026-08-25T14:20:03.387172Z", + "iopub.status.idle": "2026-08-25T14:20:03.730978Z", + "shell.execute_reply": "2026-08-25T14:20:03.729115Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 9, - "id": "30c88717", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "131" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 498kB\n",
+       "Dimensions:     (time: 110, node: 495)\n",
+       "Coordinates:\n",
+       "  * time        (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n",
+       "  * node        (node) int64 4kB 0 1 2 3 4 5 6 7 ... 488 489 490 491 492 493 494\n",
+       "    name        (node) <U17 34kB '100' '99' '' '' '' '101' ... '' '' '' '' '' ''\n",
+       "    reach       (node) <U10 20kB '' '' '100l1' ... 'Pump:115p1' 'Pump:115p1'\n",
+       "    distance    (node) float64 4kB nan nan 0.0 23.84 ... 1.0 0.0 41.21 82.43\n",
+       "Data variables:\n",
+       "    WaterLevel  (time, node) float32 218kB 195.4 194.7 195.4 ... 193.8 nan 195.0\n",
+       "    Discharge   (time, node) float32 218kB nan nan nan 5.72e-06 ... nan 0.0 nan
" ], - "source": [ - "network.find(reach=\"44l1\", distance=44.841)" + "text/plain": [ + " Size: 498kB\n", + "Dimensions: (time: 110, node: 495)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 880B 1994-08-07T16:35:00 ... 1994-08-07...\n", + " * node (node) int64 4kB 0 1 2 3 4 5 6 7 ... 488 489 490 491 492 493 494\n", + " name (node) " ] - }, + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.graph" + ] + }, + { + "cell_type": "markdown", + "id": "885523e1", + "metadata": {}, + "source": [ + "Querying the underlying `networkx` graph lets you run topology-based analyses (e.g. shortest path, connected components) directly on the network. The visualisation below plots the graph, highlighting boundary/junction nodes with a thicker outline:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1d068e44", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.742500Z", + "iopub.status.busy": "2026-08-25T14:20:03.742219Z", + "iopub.status.idle": "2026-08-25T14:20:03.748104Z", + "shell.execute_reply": "2026-08-25T14:20:03.746842Z" + } + }, + "outputs": [], + "source": [ + "def plot_network(network):\n", + "\n", + " g = network.graph.copy()\n", + " lengths = nx.get_edge_attributes(g, \"length\")\n", + " max_len = max(lengths.values()) if lengths else 1.0\n", + " nx.set_edge_attributes(\n", + " g,\n", + " {e: v / max_len for e, v in lengths.items()},\n", + " \"norm_length\",\n", + " )\n", + "\n", + " # recall() says what each integer stands for: a named node, or a break point\n", + " # given as a reach and a distance along it.\n", + " kinds = network.recall(list(g.nodes()))\n", + " widthmap = [2 if \"node\" in kind else 1 for kind in kinds]\n", + " plot_kwargs = {\n", + " \"font_size\": 6,\n", + " \"node_size\": 130,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": widthmap,\n", + " \"with_labels\": True,\n", + " }\n", + " fig, ax = plt.subplots(1, 1, sharey=True, layout=\"tight\", figsize=(10, 9))\n", + "\n", + " pos = nx.kamada_kawai_layout(g, weight=\"norm_length\", scale=10)\n", + " nx.draw(g, ax=ax, pos=pos, **plot_kwargs)\n", + "\n", + " # Set limits explicitly AFTER draw, otherwise matplotlib auto-scales them away\n", + " xs, ys = zip(*pos.values())\n", + " pad = 0.5\n", + " ax.set_xlim(min(xs) - pad, max(xs) + pad)\n", + " ax.set_ylim(min(ys) - pad, max(ys) + pad)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "53ab2b9c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:03.752735Z", + "iopub.status.busy": "2026-08-25T14:20:03.752107Z", + "iopub.status.idle": "2026-08-25T14:20:04.992453Z", + "shell.execute_reply": "2026-08-25T14:20:04.991033Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 10, - "id": "e25a4ba8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "([241, 3, 40], [131, 133])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.find(node=[\"92\", \"101\", \"113\"]), network.find(reach=[\"44l1\", \"45l1\"], distance=[44.841, 37.206])" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/japr/Repos/modelskill/.venv/lib/python3.12/site-packages/networkx/drawing/layout.py:987: RuntimeWarning: divide by zero encountered in divide\n", + " costargs = (np, 1 / (dist_mtx + np.eye(dist_mtx.shape[0]) * 1e-3), meanwt, dim)\n" + ] }, { - "cell_type": "markdown", - "id": "c4f36cfd", - "metadata": {}, - "source": [ - "Use `recall()` to translate integer IDs back to the original identifiers. This is useful when you want to know which original node or break point corresponds to a given integer ID:" + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAN5CAYAAAAVQ1h+AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYVNf2N/A1fYYZeu9N6aB0kK4IdkHsvWLsHbvYe+wlsWvsvfcSFRtYYsWOvSuKKGWY+b5/8LJ/zjW5N0WjJvvzPPMkORnO2XNmGM46e+21BABAHMdxHMdxHMdxHMd9csIvPQCO4ziO4ziO4ziO+6fiQTfHcRzHcRzHcRzHfSY86OY4juM4juM4juO4z4QH3RzHcRzHcRzHcRz3mfCgm+M4juM4juM4juM+Ex50cxzHcRzHcRzHcdxnwoNujuM4juM4juM4jvtMeNDNcRzHcRzHcRzHcZ8JD7o5juM4juM4juM47jPhQTfHcRzHcRzHcRzHfSY86OY4juM4juM4juO4z4QH3RzHcRzHcRzHcRz3mfCgm+M4juM4juM4juM+Ex50cxzHcRzHcRzHcdxnwoNujuM4juM4juM4jvtMeNDNcRzHcRzHcRzHcZ8JD7o5juM4juM4juM47jPhQTfHcRzHcRzHcRzHfSY86OY4juM4juM4juO4z0T8pQfAcRzHcf9UGo2Gbt++TS9fviShUEjm5ubk5OREAoHgL+/75cuXtH79erp79y69e/eODA0NycvLi5KSkkgul3+C0XMcx3Ec9ynwoJvjOI7j/oLLly/T3Llzafv27fT8+XPSaDRkbGxMFhYW9OTJE3r27JnO893d3SkgIIDUajW9e/eOJBIJ2dnZUUxMDJ04cYJOnTpFr1+/Jj09PXJxcaHg4GA6c+YMXbx4kd6+fUsSiYS0Wi09fPiQ1Gr1R+MxMDAge3t7UiqVJBAIyMjIiGJjYyk8PJz27dtHT548oZKSEjIxMaEaNWpQUFAQHThwgJ4/f04CgYAsLCyoXLlytGLFCjp+/Djl5uaSRCIhS0tLSk5OpmbNmpFSqfy7Ti/HcRzHffMEAPClB8FxHMdxn9uLFy/o0qVL9ObNG5LL5WRjY0M+Pj4EgF6+fElv374lpVJJZmZm9O7dO1q9ejXduHGD3r9/TwYGBuTh4UFPnjyhFStW0L1796iwsJBEIhG9f//+T41HKBSSr68v2dra0oULF+jBgwckk8koODiYAgMDqaCggI4dO0aXL18muVxOkZGRFBYWRvn5+bRnzx7Kzs4msVhMJSUlv7p/sVhMcXFxJJPJaN++faRWq0kikZCHhwcplUp68OAB3bt3jyQSCanVajb7DoBEIhFpNJpf3a9MJiNLS0syMzMjAwMDcnZ2pnbt2pGFhQVdunSJ3r59SyqViry9vcnd3f2/ngONRkMajYakUumfOoccx3Ec9y3gQTfHcRz3j1RUVERCoZBOnDhBc+bMoQ0bNnwUoFpYWFBxcTG9fv2abVMqlVRcXEwajYZcXV1JT0+PXr58SQ8ePCCxWEyenp5Ur149MjY2pmfPntHKlSvpzp07bMZaX1+f7t27p7NPgUBA0dHRpNVq6ejRozpjGDJkCI0YMYL27NlDs2bNop07d1KvXr3o+++/JyKiEydO0PTp02nt2rXUp08fmjRpEhERHTt2jCZNmkRbt26lTp06UbVq1WjNmjW0bt06NgMuEolo8+bNVKlSJVqyZAlNnTqVSkpKaPfu3eTn50dHjx5l5yY2NpbWrVtHubm5tHDhQpo7dy69evWKxGIxAfgoCDc0NKTo6Gi6fPky3b59+1cDdR8fH5JKpZSfn08FBQVkYGBAbm5uJBKJ6MiRI/T8+XMCQHp6ehQWFkbfffcdJSUlkUQi+UvvPcdxHMd9VcBxHMdx36DCwkLs3r0bS5cuxeLFi7F161bs2LEDDRo0gFKpBBGBiCAWi9m//9ZDT08PI0aMwObNm9GjRw8YGBhAIBCgY8eOKCoqAgCcP38e3333HZRKJcqVK4cbN24AADQaDfbu3YuwsDDI5XJs374dhYWFWL58OcLCwnSOs2LFCly6dAlt27bV2T579mz2umbNmgUiwuDBg3Ve74wZM0BEGD16NNum1WoxdOhQEBEWLFgAAHjy5Anq16+v89qys7PZ/wsICIClpSVycnLYfg4ePAgDAwNUqVKFvd6ioiJ0794dRIQZM2YgKysLbdu2hVwuZ/t2dnbGo0ePsGfPHlSvXh1EhIEDB+LZs2dYvXo1IiIiQESwtrZGz5490aVLF9jY2ICIIBKJfvW9UCgU8PX1Rc2aNdG6dWts2bIFJSUl7D0v+3eO4ziO+1bwoJvjOI77ql27dg2DBg1C8+bN0aBBAzRu3Bi1a9eGmZnZRwGbSCSCkZERunfvjiVLlmDhwoXo168fjI2NQURwdHTEwIEDMXToUERGRur8rEAgwOLFiwEA+fn5mDZtGiQSCapXr47i4mI2ntu3b8Pd3R329vZ4+PAh215QUIC6detCoVAgKysLQGlAnpaWphNQPn36FMD/BdFlgXFubi7b14QJE0BEbD9lhgwZAoFAoBMwa7VatGvXDvr6+sjLy2PHbdSoEdt/+/bt2fOfPn0KR0dHJCcn6+z7559/hkQiwbhx43S29+nTBwKBAMePHwcA5OTkwMPDg+27Ro0abBzjx48HEWHy5Mns50+ePAlra2uUL18ez58/R0lJCbZs2YKgoCCIRCJ4eHjAwcHho/fSxcUFPj4+ICKoVCqdmydWVlbo06cPzpw5g4yMDOzYsQOHDh3CvXv32HuRk5ODS5cu4d69ezrvH8dxHMf93XjQzXEcx30RWq0W+fn5KCkpgUajwe7du5GcnAx3d3fY2dnB0dERVlZWICIYGxsjKioK8fHx8Pb2BhFBqVSibdu2ePToEYqKinDz5k0MGTIElpaWICJMnDgRWq0WANjMs6WlJVxcXFhwdv78edSrV08naN+3bx8b4969eyGRSJCamqoz9gcPHsDOzg6JiYk629+/f48KFSqgSpUqOq+zcePG7Bjdu3dHXl4e4uLiYGFhwbb3798fz58/h42NDQwMDNh4Ll68iKZNm0KlUkEoFIKI0KhRI7aPsLAwCAQCEBGGDBmCIUOGwNDQUGe2Xy6Xo2nTpjAwMIC+vj5sbW0hEAhw//59TJ8+HY6OjkhJSUHbtm1hb2+vM5us0Wjg4eGBhg0b6rz+shlrImIz6QDQr18/CIVC3Llzh227efMmzM3NER8fz7YVFRWhUaNGkEqlOHToEPbv34+kpCSdwHvEiBHIyspCmzZtIBaL4ePjg9mzZ6NXr14wMjICEbFzUvawtbX9KLvB0NAQ3bt31xknx3Ecx/1deNDNcRzHfVZv377FnTt38ODBA7x58warVq1CVFSUTmBUlrLs5eWFXr16YejQoejRowfKlSsHIoKnpye2bdvG9nn16lX07NkT+vr68PDw0Jn5LSoqwqBBg0BEGDlypM5YcnJy4ODgAF9fX+Tn5wMoDYq7du3KxuLr68uC9devX7NZ2F27drFANzw8nI1527Zt2L59OwtopVIpiAhbtmzBnj17oK+vrxMAW1lZoU2bNggPD0dgYCDb7ujoiLFjx2LRokUoLi5mgXpGRgaaN2+OPXv24NmzZ7C3t4dMJsPr16/x8OFDLFmyBBUqVIBUKkW5cuXY9vfv3+scd/DgwXj48CHu3LkDmUwGIkJqaipu3bqFsLAwmJiYQE9Pj6WTZ2dnw8LCAmKxGCqVCkSEgwcP4uDBgzAzM9MJdnv06IGjR48iJCQEISEhkEqlGDRokM65X79+PYgIZ8+e1XmvoqKi4O3tzc75/PnzdQLm8+fPAwAOHDgAfX19VKtWDWq1Gu/fv8fChQthbGwMNzc3HD9+HIsWLYK/v/9/TV93dnZGmzZtMHDgQBw4cIAdl+M4juM+Fx50cxzHcZ9Efn4+cnJycOPGDTx+/Bhr1qxBTEzMRyncRIQKFSpg2rRpWL58OebPn4927dpBT08PYrEY3333HVtXrNVqceDAASQkJEAgEGDu3Lk6x7x27RpcXFxY6vKHBg8ezAL6ixcvAgDq1auHihUrsrXeFy9exPDhw9msadkjIyMDISEhUCgUUCgUEIlEaNu2LXJychAdHY3w8HB89913EAqFaN68OUJCQnDlyhXk5ubCw8MDQqEQzZo1Q82aNXH48GEAgL6+Ptv/kSNHAJTeBPgwMK5UqRL69u2LmJgYtG/fHkSEKVOmoHXr1ggLC0N8fDxLuT5z5gxKSkpQt25d9OvXD4aGhiAilqaen5/PnktEaN26NYDSGwnly5eHgYEB/Pz8UFBQgJMnTyI5ORmrV6+GVCpF3bp1kZycjKNHj2LmzJmws7ODUChEWloawsLCcOrUKdjZ2bF9GxkZwdbWFkZGRnBwcIBAIICRkRHatWsHS0tLiMViSCQS2NjYoEOHDigsLERqaiq7gfHhOQGAESNGsH1/mGWwd+9eCIVCnTXw2dnZsLS0RGhoKAoLCwEAx44dg5WVFQwNDZGQkKCzDp2IIJPJWJaBo6MjYmNj0aRJE7Ro0QJ9+vTByZMneTDOcRzHfTI86OY4juP+EI1Gg9zcXDZzvW/fPqSkpHw0sygSieDm5oY5c+Zg9+7d2LFjB6ZMmcLWA1eoUAE3b95k+83NzcXkyZMhlUpRuXJlFBQU6ByzW7duEAgEWL9+vc54fvnlF4jFYhZEA6XBdVRUFJRKJUxMTHDx4kUsXLgQERERCAkJgYODA8RiMS5cuIBbt24hPz8f06dPZ2Nv0qQJS1v39fWFnp4eS1Het28f1Go1vLy8YGRkBEtLSwQFBbHx+Pj4QF9fHxUqVED//v1x8uRJqNVqnXTsVatWAQDGjh3LgmUigoODA9auXYt3796xFPP09HS8ePECQGk6fFmGwIEDB7B06VIsWbIEbm5ucHZ2BhEhJycHPXr0gLW1tU5gnJSUBADo0qUL3N3d4erqCkdHRwClwX9KSgoOHjwIlUqF6OhohIaGAgAWL14MHx8fKJVKtGrVCkFBQSguLsaMGTN03vO2bdti0KBBGD16NExMTEBEOH36NB4+fIiRI0dCJpNBKpVCLpdj/PjxiI2NhampKQvSExMT0apVK5iamkIsFrN96+np4fXr19BoNPD09ISfn5/OzDgAnDp1CkSE5cuXs213796FjY0NQkJC8Pz5c0yZMgXm5uZsvAEBAdi1axfq16/PagGEhoay98nFxQXx8fFo3rw5OnTogNGjR+Pu3bt4+vQpMjMzcfDgQWRlZbH3huM4juN+i5A4juM47r/A/+8seffuXRo0aBBZW1uTsbEx2dnZkaGhIVWvXp0yMjJo9OjRtHfvXjp48CAtX76c4uPj6fr16zRkyBAqKSmhGjVqUK9evejKlSt08OBBKigooPDwcLpy5QoRERkZGVGfPn1o48aNdOjQIdLX16dLly4REVGDBg3ozJkzJBQKqX79+nTu3DkaPnw4GRoaUkxMDMnlctJoNPTq1SsiIlq1ahXp6elRSEgIvXr1im7fvk3NmzenjIwMOnXqFMnlciopKaGzZ8+Si4sLKZVK6tChA3vN+/fvJ2tra5JKpaTRaMjExITevHlDx48fp8qVK5NWq6XXr1+TmZkZvXr1imQyGd27d4/u379P2dnZZGRkRG/fvqV69epRSkoKubm5UUFBAdt/WW/vqVOnUmBgINuuUqmocuXK1LlzZ4qJiSGi0n7bpqamREQ0ZcoUkslkbPvatWvpwIEDVLlyZdZmS6FQ0LRp06hKlSqs9zYRkVwup0WLFtH+/ftpxIgRJJFIdFpzabVaGj58OCmVShIIBKTVanV+ViAQUElJCclkMnr8+DFptVqd59SpU4fmzp1L06ZNI3NzcyIievXqFdnY2NCFCxeoWrVqFBkZSYWFhbRjxw7y8PAgU1NTCggIIB8fHzp79iwREa1du5amT59OCoWCnasdO3ZQdHQ03bx5k4yMjOjy5cvsMxcdHU1dunQhNzc3mj17NhuPg4MD/fTTT5SZmUm//PIL9erVi06ePEkODg5ERHT27Fk6d+4crVu3jo4cOUIikYgEAgFdu3aNduzYQe7u7rR//37au3cvnTlzhsaNG0dOTk5kZWVFISEhVLlyZQoODiZLS0tq0KABHTp0iP2ucBzHcdyHeNDNcRz3L3fp0iWaMWMGpaen04gRI2jmzJk0b948ql69OhkbG5NIJCKpVErlypWjKVOmUFJSEq1du5a2b99Oy5cvp5SUFHr58iWNGjWKzp8/T7GxsdSsWTPavXs33bhxgyIjI6lOnTq0cuVKIirtWR0XF0e7d++m/Px88vHxoWPHjhERUUpKCk2YMIEcHByopKSELl26RADI1dWVZDIZubu7E1FpUExEtGTJEnr9+jUdOXKEANCmTZuIiCgrK4uIiGxtbUkkEtG2bdtIKpUSEVFUVBTdvXuXiIiuXr3KzoOPjw/791evXhEAio6OpuvXr5OlpSUR/V/v79TUVAoNDSWRSEQAaPr06dSmTRuKioqicuXKkVQqJYVCQb169aLDhw9TVFQUyeVytn8jIyPq2bMnqVQqFkQTEQUHB1Pv3r3JxcWFcnNziYjI1NSU8vLyaMSIEWRhYcECaZlMRmfPnqUTJ05QRkYG3b17l2QyGSmVShoxYgSVK1dO55hqtZrGjx9PjRo1okaNGlFubi5ZWFiw/3/27Fnq1KkTFRQUkImJCQmF/3eJUFBQQMXFxWRgYMBe6/Lly3WeM3bsWBowYAANHTqU8vLyiIjYOT937hyFhoay5z98+JAqV65MaWlpdOnSJRIKhfT27VsSCAQ0ePBgmjVrFkVGRrJ9P3z4kFQqFTVs2JAuXrxIAoGAlixZQmlpaeTk5EQ5OTn07NkzOnHiBJ0/f546duxIlSpVokGDBpGTkxPNmTOHiIhcXFxo+/bt7Bz+8MMPpNFoqFKlSrRr1y66cOECjRw5kmrUqEE7d+6kVatWUW5uLvn5+dHjx49p7ty55OHhoXMzQ6PR0Pr166ly5crk7OxMo0ePptWrV9Pjx4+J4ziO44iIeHo5x3Hcv1BxcTFWrlz5UdusDx8GBgZo0aIF5syZg6lTp6JBgwYQi8VQKBRIS0uDWq1m+3v8+DF69uwJIkLv3r11Un9LSkrQpEkTCAQCKBQKlgKelJSEgIAAEBHq168PoHQddkxMDEJCQkBEiIuLw7p16zBt2jQAwIULF6Cnp4eAgACkp6ejYsWKiI6Oxvz581lKNwA0bNgQXl5eLC28Vq1aAIBx48bByckJTZs2hUAgQNeuXQEAe/bsQXJysk7V8LLX4OvrywqJBQcHY9iwYRgxYgS6du0KZ2dnWFhYAACGDx+OtLQ0NGjQAIaGhqhWrRoiIiKQlpaG4cOH66Ri9+jRAwKBAE5OTmybVCpF37592bkve35oaCjc3d11ioNJpVKMHDkSIpEIMTExrABaWap72T7K1tCX/Tf9/0reZSnt48aNw6pVq2Bvbw+lUskKu/3www9ISkrCzZs3MWfOHFZFftmyZex9HTNmDNu3mZkZIiIiMHPmTMycOZNVkL9x4wZycnLg6emJmTNnss9bYGAgXrx4gcWLF6Nq1aooV64cDA0NWar22LFjdVLBU1JSsHz5crRp0wa1a9eGqakp6tWrB6B0TbejoyN7rUuWLEFSUhLMzMwwYcIEODo6QigUYsyYMaxKe40aNdi+PyzQV9Ze7t27d2zb8uXLQURYs2YN+zx369YNRISYmBj2Wv/zIRaL0bBhQ6xatQpZWVk4d+4cHj9+/Jd+bzmO47hvEw+6OY7j/iWePn2KadOmoVOnTiyI+j2P2rVrs0rfjx8/xrBhwyASiVC3bt2P+h+X9ZeWSqU666sjIyOhUChgamqKixcvIjs7G+Hh4WzdtUQi0WlTderUKYhEIkilUjRq1Ai9e/dmbbDc3d0hEAhY4bTQ0FCIxWLY29vDyckJhw8fxpgxY3Do0CF06NABYrEYiYmJ0Gq1KC4uRklJCapVqwYiQlpaGs6fP4+IiAg8e/aMrZc2Nzdnr01fXx9CoRASiQShoaEQCoWIjo5mAbCVlRXi4+NBRDAxMWGF0Tw9PdGyZUu2LrnsfJa1EwsPD0eXLl3Y9lGjRrHX//btWxgYGHxUAfyXX34BEWHdunU621etWgUiwoULF9i27du3s31/uOYcAAtEQ0NDdYJ3qVQKgUCAsLAwjB49GnZ2dlAoFBAKhWx7/fr14eDgwKq0l53HPXv2wMXFBS4uLlAoFPD19QUATJo0CS1btsTMmTNha2vLKtTv378fixcvhpeXF2xsbODp6cnGt3jxYrYunIjg7e2NkpIStGvXDvXr14exsTFrYdatWzcYGBjAzs4OEokE06dPx8OHDzF79mzY2dmxYLysJZlUKv0ooPf09IRKpYKXlxeICIsWLcLBgwcRFhaGyMhI+Pn5ITo6mo2vrDe6RCLBrVu3sHr1alZpn/7/2vwxY8bA1dX1o9+n2NhYrF27lvcO5ziO+xfhQTfHcdw/0KtXr3D8+HHs3r0bCxYsQHJyMiQSCWQyGZydneHh4QEzMzMQERQKBZKSkrBp0ybs2LGDzQZ/GChERkbqFDZbu3YtBALBrxYvMzU1hUQiwenTp3HhwgVEREQgKioKzZo1AxFh586d6NatG3bv3g0AbKZw586dAICoqCgYGhrC2tqazfROnDgRAFCrVi1WifrNmzdsPDVr1oRUKoWzszPq1auHFy9e4NChQ6zdl4WFBWbMmIGYmBjExMSw4NrDwwPu7u7Q09PTaYEVGhqKChUqwMjICCKRCEKhEL169cKjR48QHx/PqpcTEa5cucLGodVqkZSUBHd3dzZT/uLFC5QvX57te8OGDQCATZs2sWOKxWI2C6rRaNCwYUPI5XLcvXuX7fvly5fw8PBA+fLldQK2K1euwNjYGDVr1mTbDh8+zGbny2Z/y+zYsQMikQgjRozQ+cxs27YNQqGQZRWUOXDgAIRCIX788Ue27caNG5BIJGz/EydOxIABA+Dl5QWFQgEigqurKxYvXgxbW1u4ubnBxcUFRKW9t588eYJq1aqhXLlyiIuLg0AgwKBBg9h7On36dJ2g3sPDA4mJibC1tYWlpSVEIhE6d+7MxjNv3jx2Y2PRokUAgAULFqBSpUosm+LYsWM4efIkAgMDMXDgQLZvKysrVKhQAbdu3YJCoYBAIEB0dDTCwsKwePFihISEsH1fvHhRpzWaRCLBsGHD2PtcoUIFtt+yjI958+ZBJBKhRo0aWLp0KZvtl8lkUKlUsLGxQVxcHFauXIlz585h//792L59OzIyMlgleo7jOO7bxoNujuO4f5DMzEy0bt36oxZJAoEAvr6+2LhxIwsGtVotDh8+jMaNG0MsFiM8PJzNHpeUlGD9+vU6ba7KUrSB0qCrbKZ3w4YNyM7ORmRkJMLDwzF58mQQEcaOHYuaNWvixo0bKCkpQUBAAAQCAdq2bYu5c+di9erViIqKYrPIkydPZvuvWbMmCxqjo6Nx8uRJAMD333/PXtuzZ89QXFyMd+/esecaGBjA1tYWxsbGOj2z16xZg/T0dMTExCAiIgJ+fn5wdHRks+tqtZr1dyYinDhxgo1l7NixEIlEePDgAdv2+PFjODo6slnrMmUz/WVVtK9cucJmT4lKe4A/efKEzS6XbR88eDAA4P3792jcuDEEAgE2btzI9nv9+nV4eXnB1NQU165dY+/fvn37YGpqCh8fH+Tm5uLcuXNITU3VCViTk5NRUlICrVaLlStXQiaToU6dOjqZBZs2bYJcLkdSUpLO9iNHjrC2W2WB/sWLF9nNjA+XBgBAXl4e/P39YW9vr3OTRqvVwtraGgKBACEhIVi8eDEL0suC9+DgYFSsWBF2dnasjzgRwc3NjX1m27Vrh+DgYJYWXtYibNGiRSzYP3bsGACgTZs2iIqKYlkNly5dQk5ODoKCgjBu3Di2f319fbRp0wbFxcVISEiAVCqFj48PAgMDERYWhqKiIvj4+EAikWD06NGoXbs2rl69CgCwtbWFhYUFOzf3799nYzc2Nsb79+8B/F8mwsyZMwGULpOoWLEi5HI52rdvz1rr/WcHALlcjtatWyMzMxMcx3Hct4sH3RzHcd+onJwcDBgwAL6+vrCxsYG+vj7EYjGMjY0xZMgQnD9/Hnfu3MHly5cxZ84ceHt7s3WoL1++1NlXZmYmzMzMoKenB6VSyWavT548qRPAX79+HdOnT4e+vj7MzMwgk8nQsGFDJCcn4/r163jz5g0qVqwIpVKJChUqsLTmqKgoyOVyGBoaIi4uDrdu3YKLiwvc3d1hb28PkUiEYcOG6QTRZbPRlStXhpubG0t/lkgkkEgkiIyMhIGBAfT19eHi4vJRH+9Dhw6hQoUKsLKy0pkZvn//PuRyOcaNGwegdGa5rCc2EcHf358FeevWrYNQKESfPn3Yz9+9exfe3t6wsbHBvXv3AJT2vu7Tpw+ICO3bt8fatWtZyvmHwV1ycrJOQElEaN68OW7evIn+/fvD1NQUMpkMK1aswMuXL7Fz505Ur14dAoEA9vb2OH78OG7duoV58+axHtz6+voIDQ1lrdg+fFSrVg3379/HnDlzWPDftGlTFBYWQq1WY+PGjahSpQoLnssC5StXrqBbt26QSqWIjo7GvXv3sGfPHtStW1cnI8Db25vNxj548ABBQUHQ19fH+fPn2fnSaDTo3r07iAirV6/W+dzt3r0bIpEIaWlpbNubN290ZoydnZ11gnS5XM4+ox07dkRMTAxcXV2hUChQrlw5djPCz88P06ZNg6enJ4yNjVFYWMiC7rK182U3anr06AEAaNasGSQSCXx8fBAQEICkpCTW110ikaBXr16oW7cufHx8EBsby96DOnXqsCyKDwPnsll3AGjRogWcnZ3ZTY23b98iLCwMFhYWePLkCS5fvqzzOfzPR2RkJI4dO4anT5/+ru8HjuM47uvBg26O47hvQGFhITZs2IApU6awQJuotChWu3btMHz4cAwdOhQNGjRgvZBTU1PZWmygdLZxz549MDY2hkKh0AmuAWDLli0syLl48SJSU1MRHh6uk6bcu3dvZGZmonnz5nB0dISbmxsUCoVOcC2VSuHi4gKlUol69erh1KlTyM/Ph6OjI8RiMUJCQtCoUSPs27cP1atXZzOUKSkpiImJgZeXF+zs7NCjRw+IxWLcvn0b9evXR3R0NFq3bg19fX02M1xmyJAh0NfXR15eHtt28eJF6OnpsfRfoDTtvkKFCrCzs8Pz589x8uRJnaJaEokEhw8fxrNnzzBs2DAIBAI0btwYJSUlyM7ORvfu3aGvrw8bGxts3boVBw8eRGpqKuRyuU7Rst/7KAsgy9KNf20fJiYmv7r99xyvLEAWCAQQCASQSqVwcnKCq6sre1/L+qk3b94czZs3R2hoKEt5/2/7DggIwN27d5GRkYEmTZpAIpHA2toaZ8+eBVCaLbF9+3bExcVBKBRizpw57H0oKSnBkiVLIJVKUbNmTVaU78qVKyzIJSrtlf3hZ3jSpEnsnJSlfw8YMICtpw4JCQEAuLi4wNHRkd2Mad++PQCwoLtSpUrsGLa2tmjTpg2A0uULYrEYUVFRWLhwIezs7FCrVi1YWFhAIpGgZ8+e8PHxgbW1NSQSCXsPNm/ejLVr18Lf318nOyQlJQWpqamIi4tDVFQUiAg7duxgr+fp06dQKpUYPnw42/bDDz+AqLTYnJGR0a+e+8qVK2P9+vV8XTjHcdw3QgDwppIcx3Ffq3v37tGcOXNo4cKF9OLFC1IqlSQWi+nt27ek1WopMjKSunXrRikpKSQSiYiI6NmzZ7Rw4UIaO3YseXh40J49e8jExITt8+LFixQdHU16enq0Z88e1iqrS5cutHPnTrp//z5lZGSw9lTDhg2j5cuXE1Fpq6v69etTq1atqHnz5uTo6EhHjhwhLy8vunz5MhERJScn0+7du6mwsJBu3LhB3bp1I6FQSJmZmfTixQsyNjYmFxcXEggEpFQqKTs7m549e0b79u2j+Ph4atSoEaWlpVGLFi3Ix8eH1q5dy8Y+e/Zs6t69O+Xk5LB+y5mZmRQbG0sdO3akqVOnEhFRdnY2JSQkkKmpKR09epRUKhWdOHGC2rZtS/fv36f69evTpUuXWG9oIiKhUEgdOnSg/Px8WrNmDWm1WjIyMiInJyfKzc2lnJwcEovFVFJSovMe/dq2/0YkEpGlpSXp6+uTTCYjmUxGxsbG5OnpSUKhkF6+fElarZb09fXJzs6OPDw8qLCwkJ49e0ZqtZpMTEzI1NSUjh07RuvXr6cHDx6w/tne3t7Url07sre3pxcvXlBhYSEZGxtTREQECQQCWrt2LT19+pTUajXp6+uTubk5HThwgDIyMujNmzes9/bvuTQQiUSk0WjYOVAqlVSjRg0yNzent2/f0r59++jBgwfk4uJCQ4cOpZo1a1Jubi5t3ryZZs2aRffv36f4+HgaOHAgPX78mBYtWkQHDx5k+zcxMaHjx4+Tu7s7abVamjBhAg0aNIgGDRpEY8aMYc97+vQpubi4UFFREQUEBFDnzp3p2rVrtHXrVnr27Bm9ePGCdu/eTbm5uTRr1iy6cOEC5efnEwDS09OjuLg4evjwIe3fv58iIiLo2rVrNGLECKpfvz5NnjyZJk6cSIGBgXT//n3q1asXLV++nA4fPkzGxsZkb29ParWaNm7cSBMnTqSEhAT64Ycf6NmzZ0REVK5cOUpOTqaMjAxSKBT05MkT8vPzI5lMRpcvXyalUkmFhYV0//59unPnDuubPnjwYJo4cSJdu3aNDh06RP3796eXL18SEZGbmxuZmZnR8ePHSaVSkZeXF1lbW5OXlxe1b9+eXFxcfvdnkeM4jvt78KCb4zjuK6HRaGjPnj00d+5cOnnyJL1+/ZqISoPBiIgImjRpEgUGBhIRUXFxMW3atInmzJlDR44coRo1atCaNWtIpVKx/R09epTi4uIIAGVlZVFAQAAREd29e5fKlStHJSUltGrVKrp58yZt3bqV7t69SzY2NvTLL7+wwOa7776jHj16kI+PD2m1WiIiatCgAU2cOJFiY2OpXLlydODAAfLw8KALFy6QRCIhc3NzevXqFQkEApo1axatXr2aNBoNXb58mQoKCmjAgAFUp04d6tq1K4nFYrp16xbJ5XK6fv066+O8c+dOqlmzJh06dIhiY2OJqDS4jouLo5SUFFq2bBkRER05coSSkpLI09OT9u/fT69evaL58+fT1KlTyczMjMaNG0cvXrygOXPm0OXLl3UCxd9Srlw5atGiBUmlUnr06BG9e/eODA0NKSgoiJKTk+nJkyeUk5NDeXl5JJPJyNzcnM6fP0+HDx+mFy9eUHFxMcnlcnJ2diYLCwu6desWvX79moqLi0koFJKhoSEVFxdTQUEBvX///jf/WVhY+Ls/O0KhkJRKJSkUCtLT09P5569t+7V/SiQSevToEV2/fp0uXLhAFy9eJLVaTQKBgAwMDKiwsJA8PDxo8eLFlJ2dTW/evCE9PT1ydnYmPT09mjdvHl28eJHy8vJIpVKRUqmkvLw8OnPmzEdjLfss/RYnJyfauXMnWVlZ0ZIlS2ju3Ll048YNSk9Pp/T0dBIIBASAfv75Z2rXrh0VFBTQ0aNHqVy5cmwfCxcupPbt25NKpSIfHx/q2LEjXb58mebOnUvv3r0jIiJLS0vq1q0b/fTTT/Tw4UNSKBSUm5tLx48fp71799LEiROpUqVKlJOTQ9euXaO1a9dSjx496NKlS2RiYkJSqZTUajWtWrWK9u7dS1euXKFZs2ZRcHAwEZXepFIoFOTs7Ey3bt2iZ8+ekb+/P/n6+pKvry9t2LCBNBoNZWZm0pYtW6hOnTqk1WrJy8uLbt++TcOGDaMhQ4bQ9evXKSoqigXzy5cvJx8fH2rVqhVlZ2dTYGAge0+qVKlCrVq1Ii8vLzIxMSFHR0edvuIcx3Hc348H3RzHcV/Iu3fvaP/+/fTs2TP65ZdfaP369eyiPCkpiUxMTOj9+/d04sQJ2rp1KymVSurZsycNHz6cBadERLt376b69euzYObkyZPk4+NDarWali9fTm3btqXOnTvT7NmziYioc+fOtHTpUlKr1VSrVi1avXo1de/enfr27UtBQUEkk8nIwcGBVq9eTZMmTSKZTEbz58+ngoICIiLy8/MjIyMjysjIIKFQSCUlJVS+fHkyNjYmiURCFy5cIDc3N5LL5dS+fXtaunQpicVi8vf3pylTptDdu3fJ1taWiIhu3rxJXl5eNGHCBOrVqxcREV2+fJmioqLI39+f9u/fT0REW7ZsoZYtW5KPjw/t2bOHjhw5QrNmzaI9e/aQjY0NVa1alZ4+fUp79+4lgUCgM/MsFArJ3t6eHj16RGq1Wuc9CA4Ops6dO1NKSgppNBpSKpVstvFL02q1VFhY+D+D81/75x/9mT8S4BOVnlO5XE4qlYqMjIxIpVL9ZkBfVFREBQUFJBAI6M2bN3Tr1i3Kzs7+r7PpBgYGJBAIKC8vj4iIbGxsKDU1lWJjY0mtVrPg+erVq+Tv70+bNm0iR0dHIiK6dOkSTZs2jRYuXEidOnWi2bNnk0AgoHPnzlH37t0pIyODiIhMTU3pzJkz7OdOnz5NoaGhpFAoyNfXlzp27EgKhYKmT59OWVlZVLFiRVq6dCn16tWLXr9+TRKJhE6cOEHm5ua0bt06Wrx4Md29e5cmTpxIQUFBRESkp6dHISEhtHPnTqpSpQqdOXOG3N3dyd/fnzZs2EBCoZCKiopIq9XS+PHjycHBgQYNGkSvXr0iZ2dnevr0KXXo0IH2799PT58+pevXrxMRUaVKlejYsWOUn59PVatWpdu3b9OJEyfo559/pu+//56uXr3Kbmx4eHhQy5Ytyc/PjzQaDcnlcrKxsSFvb28ejHMcx/1dvlBaO8dx3L9GUVERtmzZgilTpmDkyJEYOHAg6tSpAwMDA7betmztrUKhQPv27XHu3Dmdfdy7dw/9+/eHQCCAsbHxR+uxV65cCaLSNk0XL15Eq1atEBQUBBsbG4hEIjg7O0Or1eL27duIj4+HjY0NLC0tIZPJcOnSJXTs2BH5+fmws7ODs7MzXF1dsWHDBpQrV+6j9cqZmZnIycmBo6MjBg0aBJFIhCNHjrDq5QsXLgQR4aeffmLjy8/Ph5ubG+rVq8e2PXz4EOXLl0f58uXx+vVrqNVqrF69GkZGRvDy8sLp06cxffp0tl5XLpfDwcGBrZl1dnaGn58fAgMDERgYiISEBMyaNQtv3rzBs2fPcPXqVdy8eZO1oXrz5g1OnTqFPXv24MiRI7h58+bnfeO/IRqNBu/evcOLFy9w7949XLt2DefOncPx48exf/9+bNu2DV27dgURoV69eh+tXTYxMYG7uzvCwsIQHx+PuLg4hIWFwc/PD+XLl4etrS1MTEw+qqr/vx5l69D/s/hc2efR0tISvXr1wqhRozBgwABERESw36P69etjyZIlmDJlCsLCwnR+XqlUsirnAHDixAmYmZkhNDQU79690zk3U6dOBRFhzpw5KC4uZhXNd+3aBSJC9+7dcfnyZQQFBWHu3LlITU1lx7GyskJqaioAYMCAARCJRIiMjMTx48fRqlUrHDt2DGZmZhCLxRg2bBhCQ0NRu3ZtDBgwAJ6eniAqLV4IAMXFxTrnoew74tmzZ1Aqlax2QVFREZo1awaRSIThw4ejQYMGrO3dh+fAy8uL/b5wHMdxnxcPujmO4z6T+/fvY/DgwbCwsPjVgEJfXx89e/bEw4cPodFocO/ePYwcORK2trYgIowbN45V0S6zdu1aCIVCeHh46ATdnTt3hoODA8RiMU6dOoVWrVph165d6NKlC+t3ferUKXTo0AFVq1ZFpUqVWC/uuXPnwsbGBjKZjF2cy+Vy9O3bFzVq1EBxcTGMjY3ZuGfOnImIiAhYWFiwYmkfateuHczMzFgl7IKCAtSsWRNKpRLnz5+HWq3Gpk2bYGdnB3NzcyxatAgjRoyAlZWVTvGvsn//MLhTKpXw8fFBjx49cPLkSV5I6m+Uk5MDIsLWrVsBgN3EWbJkCdq2bctujhCVtvlq3749li1bhjt37ujs5/cE+GvWrMGSJUswZ84cfP/99xg5ciR69OiBVq1aoUmTJmjcuDFiY2Nha2sLAwMDyGQySCSSjwLLX3vY2Njg9OnT0Gq1OHLkCBo3bgyJRIKIiAi8ePGCjVOr1bKAW6lUssJtq1evRnh4OMzNzSEUCnHo0CEUFxdDpVLhwoULLDBWKBRo0qQJEhMTAQCVK1cGEaFv3744duwYq5huZmYGIsKAAQMQFRWFefPmwdnZmY33/PnzWLt2LUJCQljRPaLSXvLh4eEIDQ1FzZo1YW1tzX4f1Go1atSoAXNzcxQWFuLRo0do0qTJr54PAwMD1jue4ziO+zx40M1xHPeJFRUVYeHChb97Vk9fXx+7d+9mP69Wq9GvXz8QlVbT/jC4vnPnDmtJtGXLFhQWFqJJkyawtbVlwfXw4cPRunVrWFhYICIiAnZ2dpBKpRg0aBDi4uKwfPlyGBkZsfGNHj0aQGlwbGpqikqVKiE6OhouLi4ICAjQ6V9dVh0aAPbs2QMiwoEDB9i2siBl9uzZ0Gq1OHr0KMLCwiCVStG/f3+kp6fDxsYGRLo9ifX09JCamordu3dj//792Lx5Mw4ePIgnT54AAF68eIFt27ZhwIABiI6OZmNXKBSIjo7GwIEDsX379o9aoXGfjlarhY2NDfr37/+bz3n06BHWrFmDLl26sAr7RAR7e3s0a9YMP/74I7Kzsz+6mfQpPHv2DOPHj2c3k37tIZVK4eHhgYoVK8LS0hJEBGtra0ycOJHdJHr37h0WLFjAPvdpaWnQaDTsOIWFhWjWrBmISntxlwXjS5Ys0blB1LBhQ9y/fx+GhoYIDw9nfeozMjJw6tQptGnTBk+fPmU/M3v2bDg5OaGgoAAzZsxgn/Hs7GxYWVnB0tIShoaGbP8dO3bE2rVrERwczILxTZs2Yfr06XB0dERCQgKI/q9nvFarRdeuXSEQCFirsw8fRkZGaNSoEQ4fPvxZ3h+O47h/Mx50cxzHfQIlJSXYunUrqlWrppOKXdaqKTY2FsuWLcPWrVuxdOlS1KlT56NZOblczgLs4uJidOnSBUTE2mOlpqbCxsaGXXjXr18fkyZNQmJiInJyctCqVSuYm5sjODgYWVlZ6NixI7KzsyGTyWBsbIz69evD2NgYCQkJMDIyYkHHrVu3AJRelIeGhkIkEmHatGkASmcla9asyca4ZMkSAMC1a9dgbm6OqKgoaLVaPHjwgKUf16xZExMnTmQX9h+2nlIqlWjfvj2ysrLw+PFjXL16Fffu3WMBz+9VVFSEkydP4vvvv0e9evXYaylLm+3QoQMWL16M69ev8wDiE2rQoAEiIyN/9/NfvHiBLVu2oE+fPggODmY3WszNzZGSkoLp06fj3LlzrHf1p1BSUoJDhw5hyZIlmDVrFpYtW4bMzEzcvXsX48ePR9euXdGhQwfUq1cPAQEB7HPp6uoKBwcH1rotLCwMu3btYvt98uQJRo8eDXt7e0ilUtZzXKvVYv/+/WxfZRkaAQEBbGY8ICAAEokEjo6OuHjxImrWrMn6qxsZGcHAwAAHDhyAqakpEhMT4ePjA4FAALFYjNOnT6NNmzbIy8uDq6srO0a/fv0QFhaG3NxceHp6QiqVYuLEiXj69Clu3ryJlJQUVKlSBZUqVdI5N2FhYYiLi8P58+eRkpKi811lZ2fHMhVmzZqFzMxMPHjw4JO9NxzHcf9WPOjmOI77ky5fvozNmzdj+PDhLIU8KCgIs2bNwpYtW7Bx40aMHz+epd0GBgayABconbVOSkpiF70ikUgnzbNTp06QSCTw9fUFANy+fRtdunRBSkoKFAoFVCoVQkND4efnh5iYGISFhcHZ2RnOzs7YsGEDIiMjWepqWTAcGBiIxMREGBkZQaVSwdraGqmpqYiJiUF4eDhq1aoFhUKB3NxcaDQaFkgTEczMzJCfn49t27bB1NQU9vb2mDVrFlJSUiASiXRmrmUyGZKSkrB3716o1Wq8fv0a+fn5ny0A1mq1uHXrFpYtW4aOHTuyoIWIYGFhgaSkJEycOBHHjh1DYWHhZxnDv8G0adMgk8n+9DnMy8vDnj17MHjwYNbTnai033zNmjUxYcIEnDhxAkVFRZ945L/t+vXrmDhxItLS0tCnTx8kJSXBxcWFfeZdXV1ha2vLll4YGxsjNTUVkyZNwqBBg+Du7q5z88zQ0BBZWVls/3fu3IG7uzsUCgUsLS110tT9/PxAVLou/MP14gMHDoRQKETdunVx6NAh9OjRA1qtVifo7tu3L5o1awYLCwvIZDKIxWKkp6ezfuHm5uaYMmUKiAhZWVmIiopCeHg4Bg0aBCLClStXoNVq0aNHD7ZPT09P7Nu3D5UqVdK5eRgbG4u1a9fy5Rwcx3F/Eg+6OY7j/oDCwkIsX74clSpV+ig9UyQSITk5Gfv27dMJLjUaDfbs2QNnZ2eIxWIoFAo2o11SUoI6deqwfVSrVg1Hjx5FhQoVYGVlBT09PZZi2rFjR+Tk5CAwMJBdfJubm8PDwwNVq1Zls+pSqRRz5swBADx9+pTNjJfNzAHAzJkzIRaLMX78eLbt0qVLMDQ0RPv27VnQ/uHMXZs2bdha0w8D7A8LMhUVFeHdu3dfxexybm4udu3ahSFDhiAuLo6dS5lMhoiICKSlpWHLli149uzZlx7qNyMzMxNEhOPHj3+S/RUUFODIkSMYPXo0EhISWJq0QqFA5cqVMXz4cBw8ePCj4mafm1arxcGDBzF8+HCdter/6+Hi4oJLly4BKJ0ZHzVqFMzNzeHs7MwKopW5du0aW4seEhKis168LEtk1apVaNiwIaysrBAeHs6WkJRlnVSpUgVt2rRBq1atIBAIMHHiRISFheHatWuIjY1F9erVWRp8vXr18PLlSzg6OrJZ90ePHkGj0SA8PJzt99ChQygqKkKTJk0glUoxZMgQREVFse+bvn37Yt68ebhw4cLf+p5wHMd9y3jQzXEc9z9cvnwZkyZNQqdOndjMcWRkJNavX4+nT5/i7du3uH//PubMmQNvb28QEapXr47AwECdKuOPHj1iwfLSpUsBAAcPHoSFhQWbVRKLxUhISECjRo2Qk5MDuVwOhUKBzp07o2PHjgAAiUTCAmlra2tW/MnHxwchISEICQlB7dq1ERERgbCwMDRo0AAmJiZ4//49e019+vSBVCplAee5c+fYmtEPU7X/cz1s8+bNcezYMeTl5eHx48c6+/zaFRcXs4roDRs2ZAXrytJp27RpgwULFrAZQO5jxcXF0NPTw+TJkz/L/tVqNTIzMzF58mTUqVOHFfCTSCSoVKkSBgwYgJ07d+L169ef5fj/aefOnSAiTJ06FcuWLfuoCvqHDwcHBzRu3BitW7dGtWrVIJFIoFAo0K5dO1abAADevn2LH3/8ESYmJvDw8MDjx491jnnlyhWYmJjAxsYGFy9eZDPgZWMhIlSsWBELFiyAnZ0d1Go1W7+9dOlStGnTBjk5OUhJSWH1E/z9/TFhwgQsXboUpqamSEhIQEREBDp16gQAWLVqFdt3gwYNAJQu4QgPD0dQUBAA4Pz58/Dy8tK54RYREYEVK1bwGXCO47j/gQfdHMdx/59Wq8W5c+ewadMm/PTTT0hLS0NISAhb82lnZwdra2tIpVKIxWI0atRIp+1Q2T42btwIPT09hIWFoXnz5jqF0Fq2bAkiQrNmzQAA/v7+aN++Pby8vNiFbHBwMJKSkqBWqyGXy+Hi4oK4uDhERkYiOjoaUqkUFStWBBGhadOm2L9/PwCgatWqUCgUGD58ODteXl4ejI2N0bdvX7Zt2rRpICJMnDgRmZmZaNWqFSQSic7FdNnDyckJs2bNwpUrV/5xrYW0Wi3u3LmDlStXokuXLqhYsSJbZ29iYoJatWph3LhxOHLkyDd1c+Fzi42NRXJy8t9yLI1GgwsXLmDWrFlsxvfDNdM9e/bEhg0bPku2wosXL2BlZYXExESdmzDZ2dnYuXMn1q5di127duH69evYtWsXmjRpgpiYGPj7+8PIyAhEBFtbWwwYMACzZs3C9OnT0blzZxgYGEAoFCIlJQWvXr1i+9Vqtdi5cydMTU2hUqlgZWXFUtGnTp2qUxth3LhxcHFxgVKpZN8J+vr6yMjIQI8ePVjQbWhoCKFQiMDAQOzbtw/VqlWDm5sbqw1hZGQEtVqNadOmsf3r6emxMW3btg1EpW0CgdK2ewEBAbCxscHixYsRGxvLXmf79u0xZswY3L59+5O/FxzHcd86HnRzHPevl5eXh7lz5+pUW/7w4eXlhZUrV7LZnNzcXEybNg1ubm4gKq3M/OGMdrly5VCxYkUIBALY2tri4sWLyM7ORnBwMKysrKBQKGBqaoqSkhKYm5sjJycHycnJ7HgeHh6QSqUsABSJRKxq+KRJkxAWFoaBAwdCLBbj8uXLqFatGipVqoTq1atDLBbj4cOHAEpnqqpXrw59fX3k5OTgl19+QYsWLdgMeVmVZ6VSqVPUTSaToW7duti7d69O1eZ/gzdv3mDv3r0YPnw4qlatyipLSyQShIaGonfv3tiwYYPOzOW/TVkbvC+RDaDVanHjxg0sXLgQrVq10mmt5enpiY4dO2LFihW4f//+Xz5OSkoKTExM2O/TH3X69Gm0a9cOlpaWkEgkEIvFEIvFUKlU6NmzJ06fPo2bN2/il19+wYwZM+Dh4cHWT5dV4c/Pz8e8efNgamqqk3ESGhrK0tErVKgAIkKXLl1w+fJlxMTEsJZ+AoEArq6uCA0NRf/+/VGjRg0olUo4OjoiLCwMBgYGWLNmDby8vBAaGsqOoVarAZQuf3F0dETr1q3Z63rw4AGkUinLdvj5559hYGAAlUoFlUoFgUCAGjVqsJuBHMdxHA+6OY77lyurGPx71muWL18eV69eZT+r0WiQlpbGZqfLgu7AwEAAwPjx4yEUCnH48GEkJyejcePGuHDhAiseNW/ePFhZWeHu3bs6Kd1yuRw3b96ERqOBvb09rK2t0a1bNwBAeHg4nj59Ck9PT5YGCpReCNvY2LBtDx48QFxcHMRiMZo0acLWoBsZGSEmJgZt27ZFnz59sG3bNpSUlECj0eD169fIy8vjqdUfKCkpwblz5zBr1iw0bdoUjo6OOut3W7RogR9++AEXL17819ygKEtzvnHjxpceCgDg3r17WLFiBTp27AhPT0/2/jg7O6NVq1ZYuHAhbty48Yc+10uXLgURYd26dZ90rL/88gtSU1NZfYGyR1k9Bi8vL6SlpSE9PR3t27fXaRFGRPDz89Npi3fz5k3Y29vD2NgYp06d0inGNn36dBCVti4zMzNDixYt0LVrV5iYmLDq7BUrVkSXLl1Qq1YtBAYGsuO0atUKeXl5iImJga2tLeRyOSpWrMiO26xZM7i6urLP/NmzZ6FSqdj5LsvEcXd3R7NmzTB37lzk5eV90nPJcRz3LeFBN8dx/zpqtRobN25EXFzcR227wsPDMXr0aEyfPh1Dhw79qDIxEWH9+vUASme0Y2JiYG9vD6LSQmXTp0+HWCyGmZkZ6tWrB4FAgJ49e6JChQpsTbaenh709PTQvHlzVKxYESYmJjo9vQ0NDdmFdVm7ri1btrDx7969mxU8AkqDDi8vL9jY2GDFihWoV68ehEIhRCIR5HI5HBwckJiYiA0bNrAZLO7Pe/DgAdasWYPu3bsjKCiIpeUbGRmhevXqGDVqFA4ePIj8/PwvPdTP4tWrV6yQ19fo6dOn2LBhA3r27ImAgAD2O25tbY2GDRti1qxZuHDhwm/eJMnJyYG+vj5atmz52cb45s0bZGVlYfjw4ax43P961KxZk61lf/fuHRYuXAhzc3Po6el9VBU9KCgIcrkcPj4+0Gq1uHz5MhwcHODt7Y3q1atDIBCwYolNmzbFzJkzWV0JpVKJCRMmYM2aNQCAYcOGwcjISGfZSkZGBogIBw8eZNsmTZrE6kRotVoMHz6crXUXCoVQqVSIj4/HmDFjMH/+fGzfvv0PtwrkOI77VvGgm+O4f42ioiKMHj2aFdDy8fFBnTp1ULt2bRZcu7i4YMqUKaxvsFarxYEDB3RSzy0sLPDkyRM2o11SUgKlUok6derg6dOnyMrKQkpKCpYuXQoDAwM4OzujXLlyH7Xwql69OhtbTEwM2x4bG4uQkBBERESgfPnysLe3Z+O5fv0664997949dkH8n9XEJ02ahJ49e0Imk8HCwgJz5szhxY4+k/z8fBw8eBCjRo1CtWrV2OykSCRCUFAQunfvjjVr1vyj+h17e3sjNTX1Sw/jd3n9+jV27tyJAQMGoFKlSpBIJCAqrehdp04dTJ48GZmZmVCr1SgpKUFUVBQcHBz+tmJteXl5mDNnDqtY/p8PhUKB1q1bY86cOZg5cya6desGIyMjCAQC1K1bF8+fP9fZ361bt+Dh4QFLS0tkZmYiNjYWlStXxpgxY/DmzRsolUooFApYWVmhY8eO6NmzJxwcHNjxjI2NsXfvXnTp0gUA0Lt3b4hEIgQHB6NNmzZQq9W4c+cOiEoLEA4bNgxA6Rp4uVyOcePGsbEMHjwYRISdO3diyJAhMDIy0lmbbmpqin79+um0UuQ4jvsn4kE3x3H/aI8ePcLo0aNRt25dmJqaQiAQwN/fH9u3b9d5nlarxYkTJ9C8eXMIBAIYGRnprNN2cXFh63uJCGlpaTA0NISBgQFMTU3h7OwMiUSCFy9esCJGCQkJrLevi4sLO5adnR1UKhXGjx+PcePGITY2Vie9vGwmPSsrCzKZDGPHjoVGo8GOHTtgYmICQ0NDhIWFQSQSQaVSISUlBStWrMC+fftw4cIFnTTau3fvomXLlhAIBHB3d8emTZt4+vhnptFocPHiRfzwww9o0aIF6/lMRHB0dETTpk0xa9YsnDt3jt1M+dakpqbC29v7Sw/jT3n37h1rB1a5cmUoFAoQEVQqFcqXLw+BQIAZM2b87bOwWq0WV65cwYEDB7Bjxw4cO3YMBw4cQEpKChQKBQQCAYRCIcRiMcqVK4elS5ey2XqtVosjR46gUaNGEIvFcHFxwbVr13T2//btW1SpUgWGhobIzs4GAKSnp+PgwYM6s+3Ozs5IS0tD06ZNAQDly5eHVCoFADYD3qhRIwiFQpQrV44F4uXKlYOlpSX09PSwd+9eAKVZRfb29mjXrh0A4P79+/Dw8NAJvMsK4zVu3BgbN27802voOY7jvmY86OY47h/p4sWLaNCgAcRiMfT09FC5cmXUq1cPVatWZdWDq1WrBi8vr4+KoHl7e0MgEMDCwgLnz5/HqFGjoFKpWMGishmassrlc+bMgUwmY+u0r169ipSUFOzevRvh4eEQiURISkrCzZs3kZeXBz8/PxARC/zPnz/PUmBtbGygVqtx7tw5WFhYwNvbGxMmTED58uVBVNonNy4uDo0aNcLs2bN/d0Xxc+fOoWrVqiAqbXd24sSJz3PiuV/1+PFjbNiwAb1790ZoaCibbdXX10fVqlUxfPhw7N2795tZ91q25vnD6tvfqqKiIhw/fhzdu3dnfe7LCpZFRUVh8ODB2LNnzxd9b7RaLTZt2gR7e3uIRCJ2k04sFsPAwIAFseXKlcPUqVN1Zuk1Gg127twJf39/qFQqbNiwgc1+jx49Gp07d2bfayKRCG5ubujatSt69+6N8+fPg4hQqVIlAMC+ffvQuXNn1rvcw8MDnTp1wpo1axAYGIhx48bB1NRUZ+yjR4+GQqFgn5VHjx7Bzs4OdnZ27Fx/+BCJRKhXrx7279/PbxByHPePwYNujuP+Mc6fP4/+/fsjPj4eYrEYhoaGSE1N1Sk8BPxfRWAvLy9IpVLExMR8VARt06ZNICKMHTsWRUVFcHd3R1RUFFv3SERYtmwZAKBKlSoQCAQQiUSoVq0avL29YWpqivj4ePTu3Rumpqa4fPkyIiMjER4ejoSEBDg4OKCkpATXr19na8KJCD179kRaWhrkcjlLGZdIJGjcuDGOHDnyly9C9+zZw4L++vXrfzXFsP5t3r9/jyNHjmDcuHGoVasWTExM2IxfWXGrlStX4s6dO19l4HHjxg0QEXbs2PGlh/JJFBQUwMfHB76+vnj37h3OnTuH6dOnIyUlBebm5iwYDA4ORp8+fbBly5aPvlf+Du/fv0d6ejqkUiksLCzQvn17pKenIyAgAAKBAEqlEt999x2mT5+OOXPmYMiQIaxLgb+/P86dO8f2dfr0adSpU0cn2C2rOJ6eno7Dhw+jbdu2kEgkaNSoEQCgf//+qFy5Mvtu+vnnn+Hm5oYuXbrA3d0dzs7OEAgEiIiIYDPgjx49YjcIyr5n582bB4FAgKysLPTp0+c317FXrVoVubm5f/dp5jiO++R40M1x3DepqKgIV65cwbFjxzBx4kQEBQWxmeCwsDBER0ezll6Ojo5IT09HYGCgzqy2q6sru6Du0aMHALDg2sDAAPr6+qhQoQKA0vWK+fn5OinmZYWW6tati+joaJiammLs2LEsvVyr1cLLywspKSls3Hfv3oVcLsfAgQMxcuRIFmyVpbeWFeRq3bo1Dh48iPPnz3/y2cSSkhIsWbIEdnZ2EIvF6Nat20frQrm/l0ajwZUrV7BgwQK0adOGfXaJSnsgN2zYENOnT8fp06e/imJ4Wq0WFhYWGDx48JceyifRp08fSKVSXLhw4aP/p9VqkZ2djR9//BHNmjWDnZ0de298fX3RpUsXrFmzBo8ePfrbxnvr1i3Url0bRIT4+HhcuXIF9+7dw5AhQ+Do6AiRSASBQMBmwJVKJdq2bYuhQ4eiX79+CAkJ+Si9e9q0aTrrvxcsWACi0paIvXv3RlxcHJsBl8lksLGxAQDY2NigcePGePHiBWrVqgWFQoGuXbvqFGMTCoUoX748++7Nz8+HoaEhBg4cCACYOnWqzlg+HJuZmRmmT5+Ot2/f/m3nl+M47lPjQTfHcd+Umzdvom/fvjrBatmjfPnyWLx4sc5azMzMTLRu3RoSiQQhISFo3Lixzqy2Wq2GjY0NTExMUFhYiBcvXmD58uXw9fVlBbHOnj2LHj16QCaT6ax9NDQ0RPny5WFnZ4fLly9DKBSiffv2rEduQEAAiAgHDhwAADx79gyenp7Q09PTKXxGRNDT00NCQgIWLlyId+/e/S3n8v379xg3bhwMDAxgYGCAsWPH4v3793/Lsbn/7dmzZ9i8eTPS0tIQERHBUnH19PQQFxeHIUOGYNeuXV9sJjA5ORmxsbFf5Nif0sGDByEQCFjf6f9Fq9UiJycHS5cuRfv27XVukJQrVw5t27bFkiVLcPv27c+epbB9+3a4urpCLBajX79+LAX+9evXqFGjxu+qim5sbIytW7eyfb579w4jR44EEaFTp046ryE9PR3Tpk0DESEhIQHR0dEwNzdH7969UVxcDH19fVSpUgVRUVHYt28funTpguvXr7OlFElJSVCr1ahXrx6srKygUChw+PBhANAZb58+fXSKTpbdlOzatStycnI+6znlOI77HHjQzXHcN6GwsBBt27bVSe/+rYeZmRnc3Nx0ZrXLZnUlEglmzZoFADAwMIBKpWLBzIoVK1BSUoK6detizpw5UKlUUKlUGD58OAoLC1FQUABnZ2d2nEqVKqFGjRpQq9WYPXs2RCIR7t+/D6B0Jj46OhoeHh4oKSnB7t272QzUrxUQ+rsqJf+aZ8+eoXv37hCLxbCzs8PixYu/2QJf/2SFhYUssyMpKYllaQgEAvj4+KBjx45YtmwZbt269bekpE+ePBkKheKbroqfm5sLe3t7xMbG/qU+648fP8batWvRtWtX+Pn5se8pOzs7NG3aFD/88AOuXLnyWd6XgoICjBo1CgqFAjY2Nli5ciU7TlZWFtq2bavTkrDsIZfL0aJFCxw7dgzZ2dnIyMhAz549WWX0IUOGQKvV4vHjx2wGvEuXLjA2Noa/vz8iIiIQEhKCJk2a4PDhw1i5ciWICNHR0WjTpg369++Ppk2bIjo6mm3v1asX1qxZg6KiIqSnp8PCwgJVqlQBAOzatYuNLSEhAdeuXWOfcaLSfuPm5uZQqVTo0aMH1q1b949ty8dx3D8PD7o5jvvqnT9/Ht7e3joXjFKpFPXq1UOPHj3QqVMnnZZeZYFIZGSkzqz2qVOnIBKJWKujslnvyMhIWFhYIDw8HAsWLMDy5cvh5OQEiUQCuVyOSpUqISAgAJGRkToz3fr6+ggICEBMTAxUKhXq1asHoDQ4ql+/PiQSCTp06MAC9Q8DbisrKwwePBh37979Yuf1P924cQMNGjQAEcHPzw+7d+/+0kPi/gutVovr169j8eLFaN++Pby8vHQ+X/Xq1cP333+PkydPoqio6JMf/8SJEyAiZGZmfvJ9/12aN28OAwODT/57+PLlS2zduhV9+/ZFSEgI+903MzNDvXr1MHXqVJw5c+aT3ty6c+cOkpOTQVTadrDsuw8onfk+efIkdu/ejYMHD2LevHmoXLnyRzcxDQ0N0a9fP9y+ffuj1zN58mQolUoEBQXh6tWrOqno165dg1wuh4GBARwcHBAeHo6uXbsiKSkJtra2kEqlaNKkCebNm4cuXbqgpKQEPj4+kEgk8PLyQl5eHuLi4tgNUJlMBgDYuHEjG1uNGjXw6tUrREZGsvNpaGiIHj16fFSpneM47mvDg26O475KxcXFWLduHeLi4j6aoREIBEhISMDatWsRHBwMpVKJCxcuICMjA3p6ejrPnTdvHgoLC2FoaAhDQ0OIxWIYGRmhqKgIrVu3hpGREaRSKbvY09fXR2RkJLy8vDBy5Ei4uLigYsWKiImJQXh4uE5wv3HjRgDAjBkzQETYs2cP1q5dC39/f7YuUSqVolmzZsjIyMDr16/x8OFD5OXlfZXFscqcOHECkZGRrJDRh8WXuK/by5cvsX37dgwcOBDR0dFshlMulyM6OhoDBgzAtm3bPkkRsMLCQshkMkydOvWvD/wLWLNmDYgIP/3002c/1tu3b7Fv3z4MHToUMTExrNuBgYEBqlevjnHjxuHYsWOf5ObI7t274ebmBpFIhF69ev3XLJrHjx8jMzMTY8eOhZWVFYgI1tbW6NevH6ZMmYIJEyagZcuWkMvlkEgkaNu27Uezyy9fvkRERASMjIxw5coVtj09PR3p6ekQi8VQKpWwsbGBra0tGjVqhHXr1kGhUEAsFqNdu3ZYunQpHj58iKioKPb9WlhYiJKSEtZDXCAQ4Pbt28jPz0dQUBAcHByQlpYGMzMzSCQSDBs2DFeuXPkqah5wHMf9Jx50cxz3VVGr1bh48SKrsB0REYFVq1bhyZMnePv2LR4+fIj58+ejYsWKLGWxSZMmOjPanTp1Yhdujo6OmDhxIqs07u/vzy60y/rBzp8/n63f9vHxQWJiInx8fODu7g6pVIopU6YAAK5evcqCaTs7O6jVavz4448QCoXw9vaGtbU1iIilRDo6OmLhwoXf5EWgVqvF5s2b4e7uDoFAgBYtWnxVs/Lc71NUVIRTp05hypQpSElJYYEVEcHT0xPt27fHokWLcO3atT91IygyMhINGjT4DCP/vB48eABjY2M0aNDgi9wAKywsxNGjRzFmzBgkJiayIooKhQJxcXFIT0/HgQMH/nR9h8LCQowbNw56enqwtLTEsmXLftfrPH36NOrVqwcjIyOIRCKIRCLo6+ujadOmePDggc5zX758ie+//x6Ojo4wNTXFiRMndFLRx4wZgwEDBoCI0Lx5c1hZWaFJkybo3bs3Bg8eDJFIhKFDh8LV1RVdunQBAISGhrLPZ6tWraBWq9nfAqL/6xhx6tQpEJW2XSwoKEDr1q3Zc+zt7TF69Gg8efLkT507juO4z4EH3RzHfXFarRanTp1Cq1atPlp7GBsbi7Vr1360blSr1WLXrl0wNDSEqakpTp06BeD/qo9/WITH39+fFV8r69Ht5+eHgIAAREVFIT4+Hq6uriAitiZ78eLFaNCgAVun/eDBA9Yrm4jQtGlTVKlSBUSl1caDgoLQqVMnVv34l19+Qb169UBEcHV1xZIlS77J4Lu4uBhz586FhYUFZDIZ0tLSeAufb5hWq8Xt27fx008/4bvvvoOvry9LMTY3N0fdunUxYcIEZGRk6BQk/C39+/eHjY3NV5258Z80Gg2qVq0Ka2vrL9L269eo1WpkZWXh+++/R926dVmhSLFYjPDwcKSlpWH79u1/+Hfv3r17aNiwIYgIkZGR+OWXX373z2q1WsyYMYO1NLSwsEDt2rXRuHFjJCQkQC6XQyqVomnTph+1HtRqtRg6dCiISKdAXXp6On7++Wc0bdoUIpEIt27dYuve3717B4VCwTIAyqqfz5o1i33vTps2je0/MDAQNWrUYP/dpk0biMVipKSkQKFQ6NTv4DiO+9J40M1x3Bf14MEDREREgIjg5OSE0aNHY+PGjdi6dSt+/PFHlm5oZWUFd3d3neJo5cqVQ2BgIIgIwcHBAICWLVsiJiYGNjY27EJNqVRixYoVUKvV8PX1hZ2dHeLj4/HmzRsAwNOnT2FrawuRSMRmlrRaLby9vVG3bl0sXLhQp01QWRuesLAwrF69+r8GHOfOnUNSUhKISqurL1u27JsMvvPy8jBs2DDo6enBxMQEU6dO/SzrhLm/X25uLnbv3o2hQ4eicuXKrG6BVCpFpUqV0K9fP2zatAnPnj376Ge3bt0KIvqmKkqXLQf5mmsWaDQaXLx4EXPmzEHjxo1ZFo1AIEDFihXRvXt3rF+/Hk+fPv1d+9u/fz88PT0hFArRrVu3Pxy8nz17FvXr14eDgwP7/vP09MSaNWt0CtC9ffsWP/74IypUqAAiwvjx4/Ho0SOd2e/jx49DKBRCqVTC0NAQ9erVQ+/evVmLMiJCmzZtWPXzZcuWse0zZ85kx5ozZw4EAgH7zi4qKoKVlRW6dOmCV69eoVu3buz7Pz4+HuvWrfumi/5xHPdt40E3x3F/u9zcXEybNg3R0dHQ09ODnp4ewsPDsWbNml+9KLpw4QLi4+MhEol0CgQFBgYCAMLCwiAQCHDnzh32M2Vrkssefn5+iIqKgpOTE4KDg5GQkIDatWsjIiICYWFhsLe3R/369dnPDxkyBET/1zv7wwA+NTUVZ86c+UOv+ezZs6hbty6ICG5ubvjpp5++yQrhDx8+RIcOHSAUCuHi4vI/bzpw3x61Wo0zZ85gxowZaNSokc4Np/Lly6N169aYP38+Ll++jKdPn4KIsHz58i897N/lypUrkMvl6Nq165ceyh+i1Wpx8+ZNLFq0CK1bt4aLiwt7Tzw8PJCamorly5f/1yUgRUVFmDRpElQqFczNzbFo0aI/VbG9oKAAPXv2ZNlEpqam8PLyYh0jhEIh6tSpg0OHDn30s0ePHoWJiQmCg4PZ2vD09HTs27cPFhYW7DVlZmay6ufdu3fXyXxSq9VYu3YtPD09QUQsywkAhg4dCn19fdY6bfjw4ewcERFsbGywZMmSP/yaOY7j/ioedHMc99lptVq8fPkSZ86cQfPmzVkBnWrVqqF9+/Zo3bo1wsLCQESwtLSEnZ3dRzPaZf1gBQIBVq1ahaNHj7JquQYGBtDT00P//v1RWFgIAGjXrh0MDAzYxdqWLVsAANWrV4eHhweaN2/OxnfgwAEQEQ4ePIiSkhIMHDjwo+JtRISYmJi/vE7wzJkzqF27Ngu+ly9f/k0G35cuXUKtWrVYlkFZr13un+nu3btYuXIlunbtqlMo0MTEBEqlEqGhoTh8+PBX3ee9qKgIAQEB8PDw+NNrpb8m9+/fx8qVK/Hdd9/pVK53dHREixYtMH/+/F9dq//w4UM0bdqUZev80RuIZbRaLQ4dOoTGjRvDzs4OAoEAUqkU7dq1w/Xr19nzSkpKsHXrVlSrVo3V4cjOzmaz3yNHjtTp0S2RSODg4ICuXbuiW7durDimWCzGsGHDsGbNGoSFhWHLli1sqc+H54SotP1j2RgTExNRsWJFnDt3Do0bNwYRISgoCGPHjmXLiTiO4z43HnRzHPfZPHjwAOnp6Tqp3mUXVY0aNUJWVpbO88+fP4/27dtDKBTC3t4ep0+fBvB/M9qFhYUwMjJCdHQ0ateujRMnTqB69eoQiUSQy+WshVdUVBQMDQ1ZIE9EqFKlCipVqoT27duDiLBt2zYAwPPnz1GuXDl4e3tj3LhxOrN6ZVWfW7dujVOnTn3SGd3Tp0+zoNXDwwMrV678JoPvQ4cOISgoCESE2rVr61Qv5v658vLysG/fPowYMQK2trYsCBeLxQgJCUGvXr2wfv16PH78+EsPlRk8eDDEYvFH3zv/FM+fP8emTZvQq1cvBAYGsvfE0tISDRo0wMyZM3H+/Hk2u/3zzz/Dx8cHAoEA33333V9e33716lUkJyezddkqlQpmZmasUnuFChWwaNEitixFrVZj06ZNOsXT9PT02PuTnp6uM8sdEhKCffv2oXLlymjTpg1b661SqRAREYHs7GysXLmSZeFcvnwZwP/1/z5+/Di0Wi1Gjx7Nlk+IRCIkJyfj2LFjf+m1cxzH/S886OY47pN7//492rZtq9OX+rceSqUSenp6OrPaZW25AgMDodFoYG9vD319fZibm7M0wY4dO+LkyZNQq9WIiopi6ZZqtRo5OTmoXLmyTn/ssgvN1q1bw9HRESUlJbhz5w7c3d3ZGkWZTIZGjRph+fLlyMjIwIULF1ia4ueSmZmJmjVrsjWSq1at+uaCb41Gg1WrVsHJyQlCoRCpqalfVbDFfV4LFy6EUChERkYGZs+ejWbNmsHJyYn9jjs7O6N58+aYO3cuLly48KdSmv+qY8eOQSgUYtSoUX/7sb+UN2/eYNeuXRg4cCAiIiIgkUhY4cfatWtj0qRJOHbsGL7//nsYGBjA1NQU8+bN+8vvT0FBAUaNGvXRd71QKER8fDxatWr10bKFshucy5cvZzPgrVu3ZmMum8EPCgpCbGwsunfvDg8PD9jY2CA4OBhHjhxB+/bt4e/vD2NjYwwYMAB169YFUPr95OLigrZt2wIonf1u3749DA0NMXXqVHh6ekIgEEBfXx/e3t7o27cvbt68+VdPP8dxnA4edHMc90m9efMG4eHhH11sxcbGomHDhqhZsyZrz1X2kMlkWLt2LYD/m9WOiYlhaeFBQUHIzc3FvHnzoFAooFKp0KJFC9ja2sLFxQWNGjViz8/Pz8ekSZN0ZkiqVKkCANi5cydEIhG6dOmCZs2aQSqVwtTUFH379sXixYvx4sWLL3beTp06herVq4OI4OXl9VGBom9BYWEhpkyZAmNjYyiVSqSnp+Pt27dfeljcZ3b16lUQlfap/9DDhw+xdu1a9OjRA8HBwezmlqGhIRITEzFy5EgcOHDgo77Pn1peXh5cXFwQHh7+TRYx/FTev3+PQ4cOYcSIEahSpQpL29bT00N0dDRrwxgYGKizTvqPevz4MSwtLVktjbL3/b89ypcvjxMnTgAAcnJykJaWpvNzfn5+iIuLQ9euXZGUlMSyhKKjo1mq+XfffcdS2MuVKweFQoHs7GysX78eJiYm0NfXZ4XYcnJyIBAIMH/+fJSUlKBLly464xEIBKhevTouXbr0Sc49x3EcD7o5jvsk8vLyMGvWLBgZGbG0RpFIBEdHR8yYMQNPnz5FcHAwlEolTp06hfnz5+vMhikUCty5cweurq4wMjKCTCaDtbU1EhMTERQUBABISEiAQCCAgYEBFAoFvL29ERkZCXNzc3Tu3BkSiQRarRbh4eGoWrUq2/eGDRuwefNmyGQydiHn6uqKyZMn49WrV1/4zOk6ceIEu3D09vbG2rVrv7ng+9WrV+jXrx9kMhksLS3xww8//KuDnX86rVYLU1NTDBs27L8+Lz8/H4cOHcLo0aNRvXp1GBkZse+JwMBAdOvWDatXr/7k62zbt28PpVL5UVurf7vi4mKcPHkSEydORK1atdjN0LIWchUqVMCaNWv+ULZPXl4evLy8IBQKER0djZKSEjx8+BDDhw9nVfH/8+Ho6IjWrVsjNTUVVatWZccve6SkpLDvj/T0dOzatQtKpRLOzs5ISEiAoaEhHBwccPfuXRbs7969GyKRCO3atUNQUBBatWqFwMBA+Pr6su/TWrVqwd/fH0DpZ7ht27YfHVsmk6FXr14sVZ3jOO7P4kE3x3F/SdkaOX19fQiFQtStWxfTp0/HggUL8P3337Ne1mZmZpg6dSpatWrFUsnr1auHgIAAdoFTv359dOzYEfv27UNERASrHO7v74+7d+9i1apVkEqlqFmzJgwMDNgaxFatWsHHxwfx8fEAgPHjx7N9mpiYsFlwb29vTJo0Cfv27fvqA9njx48jISEBRAQfHx+sW7fuqx/zf7pz5w6aN2/O1q1v2bKFVzr/h6pduzb7/fu9NBoNLl26hB9//BEtW7aEq6sr+711cHBAkyZNMHPmTJw9e/ZPL7koK7Y1b968P/Xz/yYlJSX45ZdfMHXqVPj7+7MAVCAQICgoCL1798amTZvw/PnzX/354uJiVKlSBUKhELa2tuz7uaSkBG3btgURYcqUKZg5cyZMTU3/5+y3RCJBWloaHjx4wFLOhwwZgujoaMhkMjg7O8PKygr37t1DVlYWGjZsCCcnJ0ilUrRs2RIeHh4YOHAgmjZtCltbWxgYGEClUiE7Oxt16tSBm5sbS7cHSm8YqFQqVK5cGY6Ojh+NJyYm5jc7bHAcx/0vPOjmOO5PycvLw6JFi+Dv7w8iQlRUFDZv3vyrQVV2djZatmzJZk8uXryI4uJihIWFISkpSWdmPCgoCNWqVYOVlRVbz2dlZQVDQ0NYWFggODgYiYmJCAsLQ0hICCIiIlgf7Hnz5uG777776GIpIiICK1as+OaCVqB0LWrZrL2fnx82bNjwzb2OM2fOsJsv0dHRfyl1lfs6jR8/HiqV6i9nNDx58gQbN25Enz59EBYWxr4DVCoV4uPjkZ6ejj179uDNmze/a1/m5uaoXbs2v9nzJzx58gQpKSkgIhgbG8PKyop9p3p7e6NTp05YtWoVHj58CK1WixYtWkAgEEAul+P8+fMASgPuFi1aQCgU4qeffmL7LiwsxIoVK1CpUqWPvq/19fXRq1cvnU4ROTk5GDBgAMzNzWFqaopjx45h586d6NOnD/v/ZbVA4uLi4OTkBJVKhfv377ObsPr6+ujTpw86dOgAANi4cSOICI0bN2bH6dy5M6ysrJCbm8u6TPznIyQk5C93seA47t+HB90cx/0hV69eRefOnaFSqSAQCGBqagoHBwfo6+uzWenp06cjKChIp+3XvXv3WBG06OhoPHr0CBKJBC4uLpDL5eyCxtraGgCwe/du+Pn5QaVSYdy4cQBKq/MmJyfD0NAQgwYNAlB6UVetWjUolcqPUgMTEhLwyy+/fJkT9YkdPXoU8fHx7MbFxo0bv6lAQqvVYteuXfDx8QERoVGjRrxY0T/I0aNHQUQ4e/bsJ93v+/fvcfToUYwfPx61a9dmM6RCoRAVKlRA586dsWLFCuTk5Oj8Pmi1WtSuXRvm5uY8QPqLTpw4wTKS6tevj9mzZ6NDhw5wd3dn37VlSwWICDNmzIBWq4VarUbjxo0hEomwevXq39z/s2fPcOnSJezZswepqakszd3R0RG+vr4oV64cBAIBDA0N0aNHD9y5cwdAafXzhg0bIjo6GuXLl4dIJIKDgwOsrKyQkpKCffv2oWHDhizl/OrVq/D09ETPnj0BAD/99BOICBs3bmRjOX36NIgIR44cQWFhoU4HjA8fdnZ2bBwcx3G/Bw+6OY773TZv3gyFQgFLS0sMHToU9+7dY/+vpKQEO3bsYAVuKlWqhCZNmrCgu3Hjxrh//z5cXV1ZariHhwcSExN1CuYIBAJERkYiPj4erVu3hlwuR40aNRAbG4saNWpg7NixEAgEyMnJgVqtRuvWrT8KtqVSKebOnfulTtNndeTIEVSuXBlEhIoVK/5mdsHXqqSkBIsWLYKNjQ0kEgl69OjxRQvYcZ/G+/fvIZFIWKGqz0Wr1SI7OxsLFy5E27ZtdQI/GxsbNGjQANOmTcPgwYNBVFqIkfvrSkpK8MMPP8DExASGhoaYMWMG1Go1njx5gg4dOnwUlNrY2MDOzg5CoRBTp079Q9k579+/x7Jly9CpUycYGhpCIpEgMTERFy5c0HmeVqvFsWPHWM/xJk2aYOvWrTqz3/Hx8ZDJZLCxsYGbmxtkMhlOnz4NjUbD0svDw8ORnZ2N3NxcJCcng4hQtWpVAKU3f8tek7+/v07FdZFIhF69evFaARzH/S486OY47r+6f/8+hg4dChsbGwiFQohEIlhZWaF169Y4ePAgK45WFlzfv38fEREREIvFUCgUyMrKwtChQ6FSqWBiYsLWaS9ZsgQxMTHIzc2Fv78/SyPV09PDgQMHoFarWer6mjVrAJS2ovHx8UHNmjWxZcsWhIeH6wTctra2GDlyJB49evQlT9nf4vDhw4iLi2MXg9/aeul3795hzJgx0NfXh6GhIcaPH4/3799/6WFxf0FYWBiaNGnytx/3+fPn2LJlC/r374/IyEhIpVIWFMXGxmLw4MHYuXMncnNz//ax/dO8ePECqampEAgE8PPzw5gxY1hKedWqVfH8+XNs3LiRzU6XLR0yNTVFUlISpkyZgtOnT//uZQhv3rxBnz59YGxszALkhg0bol69evD29gZRaaXymTNnQqPR6Mx+BwcHIyQkBBKJBEZGRggLC0O7du3QsGFDHDlyBCKRCBUqVMCRI0fQoUMHdO/eHQcOHNCZ/dZoNDq1BrKysnQC77K/ZwMHDvzmlv1wHPf34kE3x3G/6vXr12jSpAlEIhFUKhVSU1MxdepUzJw5EwMHDmSFZipWrIg6derozGg/ePAAmZmZEIlEaNasGU6cOAG5XI7o6GiIRCIIhUK4uLjg2LFjiIyMhJ6eHlsvaGhoiPj4eISHh6NGjRowMjLCu3fvUFxcjPr160MikbB0QXd3dwwaNAjr1q3D0aNH/5UVsg8dOsQKxQUEBGDr1q3fVPD99OlTdO3aFWKxGPb29li6dCm/eP1G9enTBw4ODl90DGq1GmFhYbCxscGoUaOQnJwMCwsLlkXj7e2N1NRULF26FDdv3vymfle+JllZWfD09GQFzxwcHPDy5UsUFBSgRo0akMlk2LlzJ/Lz87F//34MGzYMsbGxbCmRvr4+qlWrhrFjxyIjIwOFhYX/9Xjv37/H4sWLkZSUBCMjI4hEIgQEBPxqa8WSkhJs27YNAQEBUCqVGDt2rM7sd2JiIusjvmzZMmzZsgUDBw5EVFQU7O3tWSG/7OxsxMTEwNramgXZmZmZ2LlzJ/vvKlWqYOzYsSAqbXs2derUr64jBsdxXwcedHMcp6OgoACrV6+GnZ0dFAoFOnXqhMePH3/0vLILG19fX0gkEixbtowVR2vUqBHi4uLg6uoKhUKBJ0+ewMfHB1qtFhUqVICTkxPEYjG74PX392ftZFxdXQGUXmSZmpqiV69eOHfuHOLi4iAUCuHq6op27drh9OnTf+t5+dodPHgQUVFRICIEBQVh+/bt31RAcf36dVa0qUKFCti7d++XHhL3B5UVpvrULb/+iNGjR0MoFOLYsWNsm1arxY0bN7BkyRKkpqayGVIigqWlJZKTkzF58mScOHECRUVFX2zs35Jr166x3tdlGUrjxo1DfHw8FAoF9u3b96s/V1hYiIyMDIwdOxbVqlVjPy+XyxETE4OhQ4di3759/7V3+/v379GxY0fIZDLIZDI0a9YM48ePx5QpU9C/f392QzgwMBBnzpzRmf0ODQ3F7NmzIZFIIJVKUb58eTg4OOD+/fuQSCSwtbWFtbU1ypcvjzZt2iAmJgY9evRgn5dDhw59NPt9/fp1LFq0iNUaUCgUaNeuHW7fvv25Tj/Hcd8gHnRzHAegdAagf//+MDMz+2h9nqGhITp27AhfX9+PUsmrV6/OLmCOHj0KsViM4OBgBAQEQC6XQygUYvbs2YiJicGYMWMwdOhQ1p+7LJ34w37dLVq0gEajQYMGDSCVSlGxYkWWOn7gwIEveYq+elqtFgcOHEBkZCSICMHBwdixY8c3FXwfP36cVTROTEz8xxTC+zd48uQJiOi/Fs36nLKysiAWizF48OD/+dxXr15hx44dGDRoEGJiYqBQKFjwFxUVhf79+2Pr1q283sCvePz4MZydnVnG0fz585GamsqCzqlTp/7ufanVapw+fRpTp05FcnIyK5QnFosRGhqKfv36Ydu2bb86e/z8+XNMmDABXl5ekEqlEIlEMDU1RcuWLZGZmfmrx1q2bBnkcjn8/PzQokULAGDtxhwcHCASiTBixAhERUXhu+++Q1xcHHudHxYKHD16NNtWVpW9Xbt2sLS0xIgRI2BjYwNTU1NkZGT8iTPMcdw/EQ+6OY7DsmXLIJFIYGhoiJ49e+LixYsoKChAYWEhrl27hoEDB7JgPCQk5KNU8iZNmsDGxgYNGzaEl5cXAKB69eoQCAQwMDCAm5sbpkyZAlNTUwQHB6Nz584QCoU4ePAg6+tadgGzb98+NuNJRIiPj8fGjRv/lanjf5ZWq8X+/fsREREBIkJoaCh27dr1zQTfWq0WGzduRPny5SEQCNCqVasvOnvK/X6urq7o1q3b337cd+/ewcPDAwEBAX9qtrq4uBiZmZmYOnUq6tevr5NS7OHhgXbt2mHhwoW4evXqN/N79Dnk5eUhICAApqamEIlE6NevH/Ly8hAVFQU9PT3WnaDsb8MfpdFocPnyZcydO5f9XSlbGlChQgV069YN69at+6gifX5+PiuC5ujoiLFjxyIzMxPZ2dk4deoURo4cydZiN27cGJs3b9ZJOU9ISICdnR0EAgGcnZ0hlUpx/fp13Lt3j1VTJyKEhYUhOzubVT4nItaC7Pz58yAirFu3Di9evEBoaChEIhFcXV0xY8YMvH79+q+/ARzHfbN40M1x/1JqtRqbNm1is4p2dnZo1qwZtm7dipcvX35UIO3mzZtwcXFhQdyHqeRSqRQeHh6QSCSoVKkScnNz8fr1axgaGqJbt25wcnJCZGQk3r59CwBo2rQp3N3dAQBDhw5lFy9mZmZQqVRQKBRYvHgxT/X8i7RaLfbu3Yvw8HB2wbh79+5vJmgoLi7G7NmzYW5uDrlcjoEDB/IL169cy5YtERgY+Lcft1u3bpDL5bhy5con2Z9Wq0VOTg6WL1+OTp06wc/PjxVtNDMzQ506dTBhwgQcPXoUBQUFn+SYX7vi4mIkJiZCpVLB2NgY8fHxePHiBcLDw2FgYIDjx49Do9FgyZIlsLCwgFKpxIQJE/7S97hWq8WtW7ewePFitGnTRiet283NDe3bt8eyZctY+67MzEy0bt0aMplMJ1tLT08PHTp0YDPVH6ach4SEoEaNGqz1WWhoKAYNGoSGDRtiwYIFbB+mpqas6FpZOjkRoXPnzmy8kZGRqFatGoDSuije3t4wMzODWCyGnp4eBg8e/D/Xr3Mc98/Eg26O+5cpKirC2LFj2V1/Hx8fJCUloW7duvD19WVFZIYNG4YWLVp8NKvt5+fHKorL5XL4+/tDKpVCLBZDLBajY8eOcHR0hFQqRWJiIvr16weFQgEvLy/ExMQgPDwcYrEYw4cPR6dOnXQujIyMjDBkyBCdVmTcX6fVarFnzx7WczY8PBx79uz5ZoLvN2/eYMiQIVAoFDA1NcX06dP5DZmv1I8//giRSMRusP0d9uzZA6LS/tCf0+vXr7Fnzx4MGzYMVapUYXUopFIpwsPD0bdvX2zatAlPnz79rOP4ErRaLVq3bg2xWIzy5cvD2dkZN2/eREhICIyMjD5K587NzUWPHj0gEong4eHxm2u8/4wHDx5g1apV6Ny5M5tZJyJYWVnB19eXpYOX3RwQiURITk7G4cOHdb7zytLTnZ2dIZFI0K9fP53Z75iYGFbgs2y5TlnRtdatW7PtdnZ2yM7ORpcuXWBnZweZTIZ169YBALZt2wYiws6dO9G3b1+dThtDhw7lGTwc9y/Cg26O+xfJy8tDlSpVIBaLde76fygzMxNt2rSBWCyGra0tMjMzdWa1rays4OzsjISEBPj4+KBhw4bYtm0brK2tUaVKFdSrVw9AaaG12rVrIz4+HqGhoWz/Q4cOZQH6hwF3amoqD6Q+M61Wi127diEkJAREpb3U9+3b980E3w8ePEC7du1YQb21a9d+M2P/t7h06RKI6G+rv/DixQtYW1ujatWqf3vVe7VajbNnz2LmzJlo3Lgxq3xd1saqVatWmDdvHi5fvvzNV+QfMmQIiAgRERFQKBT4+eefERAQABMTk1/9O1Lm/PnzrMBjSkoK7t69+0nHdfnyZaSlpbFzLxKJ2Htgbm6O5ORkJCcns+JqpqamcHNzYzeGZTIZWrZsiXPnzunMfvv6+uoE3BKJBI6OjnBwcMDly5fZ3y+JRIIRI0agQ4cOKCoqwrBhw2BjY4MKFSoAKP076OjoiNatWwOAzgx52XibNGnC29lx3L8AD7o57l/g7NmzaNu2LWvXIhQKYWlpiW7duuHUqVO/2ms7LCwMAoEATk5OuH//PkQiEdzd3WFubg6lUgmBQAAPDw8MGTIEO3fuhIWFBRo2bIi4uDh23Hr16kEqlWLs2LEASqsbf9hXu+yiZeHChV/kvPxbabVa7Ny5E8HBwSAiREZGYv/+/d9MAHvx4kWWDhoaGoqjR49+6SFx/59Go4GRkRFGjhz52Y+l1WrRoEEDGBsb/6n1w5/DvXv3sHr1anTr1g0BAQGsXoWxsTFq1KiBMWPG4Oeff8a7d+++9FB/tx9++AFEhDp16oCI8OOPP8LPzw/m5uY4f/78//x5rVaL5cuXw8rKCnp6ehgzZsxfSrHOzs7GyJEj2Sy3gYEBWrZsie3bt6OwsBBv3rzB7t27MWjQIJ2+7QqFQicoFwgESExMxPbt23Hz5k3cuHEDGzZsQHx8vM7fKGtrazRu3BiAbqu0sk4RQ4YMwcCBAwEAXbp0gbu7u06/+iFDhsDU1JT9d79+/XTqmJRll/HvMY77Z+NBN8f9g928eZOt2baxscGgQYPw448/4ocffkDfvn1Z/9qYmBg0aNDgo1TyKlWqgIjwww8/wNzcHIGBgbC2toZKpYJcLoejoyPCwsLg4eGBpKQk1KxZE25uboiJiUFERATi4+MhkUiQk5OD77//HkKhUGddZP/+/XlblS9Iq9Vix44dCAoKAhEhKioKBw8e/NLD+t0OHDiAgIAAEBHq1q2Lq1evfukhcSgtoli2rvVzKitmtWbNms9+rD/r7du32L9/P0aOHInExEQYGBiw6tzBwcHo2bMn1q1bh0ePHn3pof6qLVu2QCgUIjk5GSKRCJ06dYKXlxcsLS1x+fLlP7SvN2/eoE+fPixFfdeuXb/7Z69du4bRo0ez5U36+vpo3rw5tm7d+j8D+IKCAhw+fBijRo1CpUqVPrrx+98eFSpUwLJly1ja+bRp03T+v1gshkQiYe3mRCIRhEIhypcvj+zsbNSqVYutQz9z5gyA0urvEokEiYmJMDEx0dlfaGgoVqxYwdd9c9w/EA+6Oe4f5tKlS+jSpQucnZ0hEAggEolgZ2eH7t274/Tp0zqz2oWFhZg5cyZr7dW0aVMUFxcjNDQUnp6ekEqlUCqV8Pf3h6OjI3x9fREREYHy5csjODgYJiYmSExMRHBwMBwdHWFoaIjevXsDAG7fvg1zc3N4eHjAyMgIAoEAERERmDFjBrZs2cIvKr4iWq0W27ZtQ2BgILsJc+jQoS89rN9Fo9FgxYoVcHR0ZEHBf1Y25v5eo0ePhqGh4WdNqb579y4MDAzQrFmzz3aMz6GkpATnz5/HnDlz0KxZMzg7O7OAy9nZGc2aNcOcOXNw/vx5lJSUfNGxnjhxAgqFAtWrV4eZmRkiIyPh5uYGGxubv3SD6/Lly4iLi2M3y3Jycn71eTdu3MDYsWNZ20ilUokmTZpg06ZNf6p43ZMnT9CpUycIhUJWsPO3gm0XFxdMmjQJ+fn5UKvVqFq1qk7rMCKCn58f0tPTMWXKFDRs2BDff/89iEp7edvZ2aF9+/a4desWZs+eDZFIhJo1a7KxNG7cGG5ubrhx4wZLff/wYW9vj9OnT//ZU8xx3FeIB90c9w+RmZmJmJiY/3nnPjo6GrVr19aZ1c7KyoK+vj4cHBxw5coVSCQSlCtXDhYWFiwlfdq0aYiMjGQBeKVKlVif00OHDqFmzZogIly5coVdSIjFYhgbG/MZ7W+EVqvF1q1b4e/vDyJCbGwsDh8+/KWH9bsUFBRg8uTJMDIygkqlwogRI5Cfn/+lh/WvdOjQIRARLly48Fn2r9FoEBsbC3t7+3/EWtiHDx9i3bp16NmzJ0JCQth6YQMDAyQkJGDEiBHYv3//31qc7tq1azAzM0N4eDj8/f1hb28PZ2dn2Nvb48aNG395/1qtFmvWrIGtrS3kcjlGjBiB9+/f49atWxg/fjzLYNHT00OjRo2wYcMGvH///k8dKz8/HyNHjoRKpYKRkREmTZqEgoICqNVqbNiwAVWrVv1o9tvW1ha1a9dGvXr1WND/4aN69ersBnNOTg6qVq2KChUqwMTEBAUFBXB1dWUp5z169IClpSVq167NxrR06VIQEQoKCpCdnQ2JRPLRMZRKJU8557h/EB50c9w/wNq1a9m6tbKHTCaDs7MznJycPvp/YrEYc+bM0SmQZm5uDolEgvT0dBgZGaF3796IiYmBnZ0dTExMkJ6ezo7XoEEDODk5oXv37gBKZ29CQ0MRFhaGnj17wsDAAE5OTvj55595cbRvkFarxebNm9nFZlxcHI4cOfKlh/W7vHz5En369IFUKoWVlRXmzZvHe7z/zd69eweRSIS5c+d+lv1PnjwZRPRNLYX4I969e4eff/4ZY8aMQY0aNWBkZMSKbgUEBKBbt25YtWrVZ+vy8OTJEzg7O8PDwwMNGzaEXC6HjY0NnJycPvnN07dv3+K7776DUCjUWXvdoEEDrFu37i+tfVer1Zg/fz6sra0hlUrRu3dvvHjx4lefe/DgQZ12ZL/1MDAwwOTJk1FcXKzTciw2NhYCgQDGxsaQy+UwMzPD/fv3kZ+fD6lUCrlcDh8fH2RnZ6N///4wNjYGEeHZs2cASttofliE78O/45s3b/7T54DjuK8HD7o57htV1me7LCX4w4erqytmzZqFoKAgKJVKZGRk4Pvvv9dJYxMKhdiyZQtEIhHCwsJgbm4OIoKlpSWMjY3ZTKGRkRFcXFzQsWNHAKUXhGUXBZs3b4ZWq0XXrl111mqnpaXh5cuXX/gMcX+VVqvFpk2bUKFCBRARqlSp8s3MvNy+fZtdyHp5eWHbtm3fTKG4f4KgoCA0b978k+/3woULLID6t9BoNLh8+TLmzZuHVq1a6QRl9vb2aNy4MWbMmIEzZ8785RtMb9++ZbU7hg8fDqLSit+urq6ftPL43bt3MXnyZNZJQSaTsRojiYmJf2k2XavVYvv27fD29gYRoUmTJr/rZoFGo8GuXbtQu3ZtnYJrZd8hP/74o062gUajwc6dOxEeHg6ZTIahQ4eyKuVZWVlo2LAhO4dpaWmsx/fjx48xcOBAEBGbvc/IyGDHqlWrFhISEnSOHxISgv379//pc8Jx3JfHg26O+wZt3rxZpz3Nbz3Mzc0RGRnJUskbNGjA0sCJSquyent7o3r16rCysmKBs5+fHypWrIiQkBB07twZlpaW8PX1RXh4OLur7+DggAcPHrDAxtfXF8uWLftTa+24r5tGo8HGjRtZEaP4+HgcO3bsSw/rd8nKykJsbCxLl8/KyvrSQ/pX6NGjB1xcXD7pPgsLC+Hr6wsfH59//ffM06dPsWnTJvTt2xfh4eFsllilUqFKlSoYNmwYdu/ejdevX//ufRYXF6NatWrQ19fH/PnzIRKJoFKp4Obm9kmqw9+/fx9Tp05FeHg4C7STk5OxatUqvH37FlqtFhs2bICDgwOkUimGDBnyh2e6s7Ky2Hrxv/L7XlRUhIcPH6JHjx7Q19eHQCBAjRo1MHz4cIwfPx59+/aFi4sLiAgVK1ZERkYGdu7cqdPnOyoqCiqVCnp6etBqtazHt0ajgY2NDUQiESIiIpCdnY3Dhw+zv8s+Pj548+YNK7ImFosRGhoKkUiERYsW/anXw3Hcl8eDbo77xsyePfuj9WdOTk6oVasWatWqpTMLUvbo3r07SyVv0KCBzvoxT09P5ObmYtmyZbC0tIS1tTWqVauGBQsWAADatWsHmUyGiRMnAgDOnTsHuVwOX19fiMViSKVSdnHg5uaGsWPHfjXte7hPS6PRYP369axVT0JCAo4fP/6lh/U/lc18eXl5/aGZL+7PW7t2LYgIjx8//mT77NevH6RSKX755ZdPts9/ioKCAmRkZGDChAmoU6cOTE1NQVTaFsvPzw+dOnXC8uXLcfv27V/N+NBqtWjTpg0kEglWrFgBY2NjSKVSeHp6/qX38OHDh5g+fToiIiJARJBKpahTpw6WL1+ON2/e/OrPvHv3DoMHD4ZUKoWjoyM2btz4P7NUbt++jSZNmrBZ6e3bt3+yzJb8/Hy0bdsWIpEIEokEUqkUDg4OaN68OU6cOMGO82Gfbz8/P1Z4zdTUFAqFAkqlEvfv38eBAwcgEAgQFRXFZr+jo6PZ32V9fX0AQN++fdnf6bFjx6JDhw4QCATw9/fH5s2bv3ihPY7j/hgedHPcN2TBggU6wbSbmxt++OEHvHr1ilUlv3DhAg4ePIiqVavqPHfixImQSqUwMDBghXqISluiREZGwsTEBFOnToWnpye6dOmC+vXrIzo6GpGRkRAKhbhz5w4uXrwIc3NziEQilCtXDtOmTUNubi40Gg3279+PZs2aQaFQQCgUIjExEatWrfrTxW+4r5dGo8G6detY+mZiYiJOnDjxpYf1P6nVaixYsICt8ezVqxdfBvGZPHz4EESE9evXf5L9/fzzzxAIBOzmH/ffabVaXL16FYsWLUK7du3g4eGhk+FUv359TJ06FZmZmSguLsbQoUNBRFi0aBG8vLwgFArh6emJp0+f/uFjP3r0CDNnzkRUVBQEAgEkEglq1aqFZcuW/aGZ9+vXr6N69ersBt+1a9c+es7Lly/Ru3dvSKVSWFtbY/78+Z+lhoNWq0X16tVhbm4Oc3NzqFQqdOrUiWWRlT3n0KFDqF+/PkQiEfz8/LBs2bKPUs779esHgUCA7777Dlu2bEHPnj3ZTYkPg+4bN26wbfHx8dBoNKhTpw5kMhmISnt7f83t8jiO08WDbo77BmRlZaFJkyYQCoUQCoUwMzODjY0Na3kSHR2NBQsWoGXLljpVycvWjZXNMBgbG2P37t3QarU6a9ays7Ph6+sLALC3t8eQIUMAlF5EVKhQAVWrVsXQoUNhYGAAd3d3nDp16jdnEV6/fo358+eziwhDQ0N07NhRZ0aA+2fQaDRYs2YNm0GuVq0aTp069aWH9T/l5+dj1KhRrJrxxIkT//Xpyp+Do6MjevXq9Zf38/r1azg4OCA6OprP7v0FL168wNatWzFgwABERUWxzhRlM6yxsbFsjbW7u/tvFh37NU+ePMHs2bMRExMDgUAAsViMGjVqYMmSJX+pwnxZWraTkxMkEgkGDBiA/Px8FBQUYNKkSaxbwciRIz97t4K7d+9CpVKhRYsWSE9Ph7W1NUvpt7GxgUqlYtljM2fOxNu3bz9KOa9YsSIEAgEcHR1hbGwMBwcH3L17V6d1nEgkQrdu3bBixQq2zcPDA0BpuzUiwpgxY5CcnAwiwpQpUz7r6+Y47tPgQTfHfeVmzZoFoVAIJycnTJw4Ec+fP2f/r6ioCKtWrUJUVBSISvu8njlzRqcq+Ye9SE1NTbFw4ULk5+ezu+VEhFGjRqF///64desWBAIBli5dCgAYMWIES1HU19dH165dkZeX97vHfv36dQwePBh2dnbswmH8+PF4+PDhJz9P3JdTUlKC1atXw9PTE0SEGjVqIDMz80sP63968uQJOnfuDJFIBAcHB/z000+ftbf0v03Tpk0RGhr6l/fTsmVL6Ovr/2Y/Z+7PKSoqwqRJkyAQCODi4qLzt8Ld3R0dOnTAkiVLcOPGjV+9Yfr06VPMnTsXcXFxEAqFEIvFqFatGhYtWvTJM0jev3+P9PR0tpypLOOqU6dOePLkySc91n8ze/ZsEJX24i4uLsb69evh5eUFgUCAWrVqYceOHTrnqizlPCIiAvb29uxcm5iYwMHBAQkJCUhJSWE3QIgIxsbG+Pnnn+Hv7w+hUMhuXpeJjY1FZGQktFot0tLS2Pu1cuVK3i2E475iPOjmuK/U8+fP0aBBA5YCPnDgQOzZs0cnlbxsVvv+/fusirmzszMePHgAqVQKQ0NDnVRyU1NTyOVyyOVyODg4sO0xMTE4c+YM0tLSYGRkhLz/x95Zh0Xxtf//bC/s0p2SIihIK6IgioFggRgodhOKja3Y3Z0fu7sbuwMVW0xsVDp23r8/+O35ug+ogKTO67r2ep7PMjtzZtydOfd93vf7/v6dyg2trKywaNGiQgXb/0tOTg6OHj2KkJAQiMVicLlcNG7cGJs3b2ZXGP8icnJysGnTJipl9ff3rxDGZQ8ePKCrRk5OTqxLcDGxcOFCCASCPyox2bZtGwghNBHIUnxcunQJSkpKaNmyJebPn0/NNxcvXoyePXuiWrVq1D9EV1cXLVq0wNixYzFkyBAaaPN4PDRs2BArVqwo1Mp4UThx4gQtaSGEoGbNmrh//36JHvN/kclkqF27NqysrKjJW3Z2NsLDw8HlciGRSBAeHo7du3fjxIkT2LVrF3r37g2JRAIej4cBAwZg3759dPX72bNnCs9iLy8vSCQSvHv3jhpAEpLbr1zOkiVLQAhBVlYWGIZBq1ataMJEV1cX27ZtK9VrwsLCUjDYoJuFpZxx48YNhIaGQigUgs/nw9LSEg4ODlTKZmlpiXHjxqF9+/YKUvLXr19T19Zp06ZBRUUFjx8/Rk5OjoKUfNGiRQBAJcGEEFy+fBlJSUnQ0tJC7dq1qdRtypQpxS4J//r1K5YtW4ZatWqBEAJ1dXX06dPnl5J1lopFTk4ONmzYABsbGxBC0LRpU1y7dq2sh/Vbzp07R52V/fz8cOfOnbIeUoXm1q1bIITgzJkzRfr8mzdvoKmpiaCgIPbeUMw8evQI2tra8PT0xIYNG8DhcKCmpoYvX74obJeUlITNmzfD39+f9paWq5+srKwQHh6OPXv2KCiwipu4uDha212zZk2cPXsWBw4cgKWlJfh8PgYNGvRHSeHC8uDBA4hEIgwePFjh/RcvXqBbt24KiW5CcttwjhkzhhqMyle/PTw8aKtO+atSpUpo27YtZDIZ1NTUFP4WERGB7du3U7PUyZMnAwBu375NZeaBgYHUTG7SpEmlqgJgYWH5NWzQzcJSjli3bh0EAgHMzc3zSMkZhsG5c+cQEhICgUAALS0tKnGTS8n19fXh4eEBS0tLqKioICkpCSkpKQrStfnz5yM9PZ1mxoVCId68eQMvLy/weDwIhUJ07NixVGpzHzx4gOjoaBgZGdFauKlTp7Ly87+EnJwcrF+/HpUrVwYhBM2aNcONGzfKeli/hGEYOrHlcrno2rUr68ZfRHJycqCiooJJkyYV+rMMw6BRo0bQ19cv0YDuX+Tdu3ewsLBAlSpVsHXrVnC5XIjFYiQkJNBtvnz5glWrVqFx48bg8/ngcrnw8fHBggULcOTIEcyZMwfBwcEwNDRUkKR37doVK1asQHx8/B8nSl6/fo2uXbuCy+XC0tIS27ZtU9hneno6JkyYACUlJRgYGGDDhg2llpyZPHkyuFxuvkqejRs3KgTLPB4Pbdq0wdatW3H06FFs27YNHTp0oG3e5K9Vq1ahc+fOOHPmDD59+gRlZWX6eW1tbZw+fRqurq5YtWoVCCGoWrUqLYepXbs2fHx8IJPJEBkZSfcpEAjQrl073Lt3r1SuCwsLy89hg24WlnJASkoK+vTpQycuAwcOxMaNG/H+/XsFKXlaWhq8vb3h4uICDocDkUiEhw8fQiQSQUNDAwKBgJri2Nvbo3r16nBxcYGKiorCxEi+AimXANeoUQMikQjR0dFlMsHNycnBkSNH0K5dOyo/b9KkCbZu3crKz/8CsrOz8d9//9EVmubNm+PmzZtlPaxfkpmZifnz50NbWxtKSkoYPnz4T1scsfycBg0awN/fv9Cfk9fOHjp0qARG9e+SnJwMV1dXGBgYYN26deDxeOByuTh//jySkpKwZs0aNGnSBAKBABwOB97e3li4cOFP24YxDIOEhARs2LABffv2RfXq1WkdspaWFpo2bYopU6YgNja2wPfyb9++YcSIEVBSUoKWlhbmzZv3y1rlhIQEusLr7e2t4CheUmRlZcHJyQn29vb5jm3Xrl0KNfK/egmFQmzcuBFZWVmoWrUqvn79quBm3qJFC6irq0Mmk6F9+/bo27cvVFVV4e7uTo83ffp0SKVSALkSeF9fX4UVd6lUyv6WWFjKGDboZmEpQ54/f47IyEioqqqCw+HAzMwMjo6OsLCwACEE2traiIyMROvWrfNMJJycnCAUCtGlSxdoaWnh2LFjyM7OhlQqhY2NDYKCguDn54cmTZqgUqVK9OG7ZcsWamwmfxkbG5cb46ukpCQsWbIENWvWpKYyffv2xZUrV1iJaQUnOzsba9eupcF3y5Yty33P5a9fv2L48OEQi8XQ1tbG/PnzkZWVVdbDqjCMHTsWmpqahTKoe/DgAZSUlNC3b98SHNm/R1ZWFvz8/KCiooIFCxbQoKx79+4ICAiggXadOnUwf/58vH37tkjH+fbtG44ePYoxY8bA19eXunoLBALUrFkTAwcOxM6dO/NIn7OysrBgwQLo6OhALBYjOjq6UC3Gjhw5gsqVK4PH46Ffv36F+mxRuHHjBng8HmJiYvL8LTU1Fb169QKHw1Eo7/rxpampiUGDBuHZs2cAgH379sHf3x8ODg4KK9Wurq7o1q0bAGDSpEl09VtXVxf9+/dHs2bNqJpIXV0dAHD8+HFqwCbfF5fLxbBhw9g2niwsZQQbdLOwlAGpqalYu3YtVFRUoK6ujsjIyDzOvPHx8ejXrx/U1NSgrKycp9+tkZEROnToALFYDBUVFXz+/BkpKSnQ0dGBl5cX/Pz8AOQasslXv4VCoUIArqamhs2bN5dbx9P4+HgMGzaMShirVq2K6dOn/3TVhaVikJ2djTVr1sDS0hKEEAQGBuL27dtlPaxf8urVK3Tp0gUcDgfW1tbYvn07mwQqAMeOHQMhpMCGV1lZWXB1dUXlypWpURXLn8MwDLp27Qo+n4/hw4fTQFC+Ku3p6Ym5c+eWSClFdnY2bty4gQULFqBdu3YKxmGWlpYIDQ1Fr169UKlSJXA4HHTu3BmvXr0q0rEyMzMxZcoUSCQS6OnpYe3atSX6O42OjoZQKFSQbx8+fBjm5uYQiUSYOHEivn//jtmzZ0MikSgE3QYGBujTpw+io6MRFhamcF3kCedr165RyTkAWop1+/Zt6OrqYt++fQCAuXPnQiAQ0J7gDMPAxsYGrVq1QlBQkMJ+1dXVMWjQoBI3vmNhYVGEDbpZWEqRO3fuoHfv3vnKzry9vWFlZZVHSu7h4QEejwcej4cnT55g69attNbLxcWFZrxr164Nd3d32p6kWrVqqFu3roJh2v8atrx//76sL0mByMnJweHDh9GmTRuIRCLweDz4+/tj27ZtyMjIKOvhsRSRrKwsrFq1ihr3tWrVqtybl92+fRuNGzcGIQQeHh44f/58WQ+pXPP9+3dwuVwsX768QNuPGjUKPB6v3Chv/haGDRsGQghVURFCoKqqihkzZhQ5wP0TXr16hc2bNyM4OFghGFVRUYGfnx8mTJiAU6dOFTnx8urVK7Ru3ZomFEqqnCU9PR2VK1eGh4cH3r59i5CQEBBCUK9ePTx69Ehh26dPn6J69eoFkpzb2toiPj6eSs5lMhni4+Ppsy8zMxPKyso0SdKmTRtoaGjg4MGD9Hj9+/eHra0tsrOz0ahRozzHsLS0zDNGFhaWkoMNullYSoGvX7+iWbNmBXrYSiQSrFu3TuHz7u7uUFNTg7u7Oz5+/IgVK1bA0NAQABAUFAQVFRUq3wwPD4ednR1CQkJw//59BcdZ+cve3r5MJlrFwZcvX7B48WLUqFGDSvTCw8Nx7do1duWxgpKVlYWVK1fCzMwMhBAEBwfj7t27ZT2sX3Ls2DE4OjrSlfqHDx+W9ZDKLY6OjnQF7ldcvHgRXC4X48aNK4VR/f2kpKRgy5YtcHZ2Vrj/KykpwdDQEB8+fCizsT169IjWYTs6OmLPnj04ceIExo8fj8aNG1NZNJ/Ph6urK/r164etW7cW2mTz+PHjsLW1BZfLRVhYWB539uIgNjaWXlctLa1frq7LZDIcO3YMLVu2pCoD+Uve6/vgwYP0eX7w4EFERETg7Nmz0NHRgZGREZydnVGlShW4ubnhwoULtOMCj8dDREQEkpKS0LZtW5iZmdFWY/fu3ct3vmFkZFRh5wIsLBUNNuhmYSlhPn36pNBbVB5Yt23bFv3790evXr1ojeuPxio/ZqyNjIwwcuRIEJLb3svf3x9Vq1YFAAwaNAjq6uo4ceIEsrOzaSZ94MCB0NLSUtiv3BU9JSWlrC5HsXL//n0MGTKEtlOrVq0aZsyYwcrPKyhZWVlYvnw5lZm2adOmXLvuymQyrFu3DqampuDxeOjbt2+FUY+UJmFhYahcufIvt0lOToaVlRVq1KiB7OzsUhrZ30dqaiq2bduG4OBgBUWVtbU1Xd0Ui8W4fv16mYzv/fv3CAsLA5/Ph4mJCf7777986/1lMhnu3LmDxYsXIzQ0VGGF3szMDCEhIVi4cCFu3bqFnJycXx4zKysLM2bMgFQqhY6ODlauXFkoj4FfER8fDy8vL5ogKMx1/fDhAw4dOkSNTV1cXLBp0yZ8/PgRGRkZ+PjxI9avX0/ba9aqVYsanf4oOR81ahSEQiHMzc1x+vRpREZG4saNG4iKikKVKlXo8X7s+y1XF8mv5+fPn4vlerCwsPwcNuhmYSkh0tLSsGLFCmoi8+NL3tZLLiVPSUmBg4MDVFVV6TbKysro1asXfc/S0hJaWlpo164dXFxc4OLiAgAYPHgwzMzM4OvrCw8PD/j6+uZpRUJIbt/hv3Uym52djYMHD6J169YQCoXg8Xho2rQpduzYUW7r1Vl+TmZmJpYtWwZTU1NwOBy0bdu2wDXBZUF6ejqmTZsGNTU1qKioYMKECWw98g/IWyj9amW1Z8+eUFZWZuWuRSAtLQ07duxAmzZtaOmRs7MzwsLCoKSkRFe65eaU/6ukKg1SU1MxYcIEqKioQE1NDVOnTi20odfbt2+xfft2REVFwd3dnRrBqaqqomHDhhg7diyOHTv2057db968ofLvGjVq4Nq1a0U+n4yMDIwdOxZCoRBWVlbYu3cvTExM0KBBg0IrrrKysrB161bo6+vnuxpdv3597Nixgz6/f5Sc79mzB1wuF05OTjAxMYFMJkOdOnXQrVs3SCQS1KhRgx5n3rx5dJ9z586lyiJ5on/gwIF/7RyBhaU8wAbdLCwlwLJly6CpqflbKbmSkhJmz55NP5eZmamwOu3m5oY1a9Zg1KhRqFatGsaOHQuJRAIANOgODg5GzZo1AQBXrlzJE3D7+vpizpw54HA46N69+29XBSo6nz9/xqJFi+Du7g5CctvWRERE4Pr166z8vIKRmZmJJUuWwMTEBBwOB+3atUN8fHxZD+unfPr0CVFRURAIBDA0NMSKFSv++t9bQXjx4gUIIdi9e3e+f9+3bx8IIViyZEkpj6zikp6ejl27dqFdu3a0JtrR0RGTJk3C48eP8fjxY2hra1OzwqZNm4LP56N///6lOs6cnBysXLkShoaGEAgE6N+/f7EZeKWlpeHMmTOYNGkS/P39aSmVPAgNCwvDxo0b8eLFC4XPnTlzBvb29uBwOOjVq1ehxxMbG4sqVapQUzp58uDgwYMghGD16tVFOp+XL19CKBRCXV0dysrKGDJkCB48eJBnu4MHD6JPnz6YO3cueDweAgMDYWpqSt3+BQIBdTMXCAQIDw+Ht7c3fY8Qgnnz5mHNmjX0vx0cHMDn82m9OAsLS/HDBt0sLMUIwzAYPnx4nuC6atWqCAoKQmBgIJ0E/fhasGAB3YehoSF16yaEwMvLC/fv30f16tWxdu1aEEKQlpYGFxcXfPz4EUKhENOmTcPly5ehrq5OXWnNzMygpKREJxRr164Fl8tFhw4d/pls9t27dzF48GC6gmBvb4+ZM2eyEuAKRkZGBhYvXgxjY2NwuVy0b98+38loeeHp06do27YtLXk4cODAP5/wMTY2xuDBg/O8/+HDB+jq6sLf3/+fv0a/IyMjA3v27EH79u2hoqJCg6UJEyYoeAq8f/8elpaW0NPTAyEEnTp1gq6uLurWrVtq936GYXDw4EFUq1YNhBC0adMGT548KdFjymQy3L9/H8uXL0fnzp2ppJ6Q3LaYbdq0wbx583Dt2jWkp6dj7ty5UFVVhaamJpYuXfrbBNmXL1/QvXt3qlbLrx94aGgo1NXVi1ziNGbMGAgEAipZl5eEXbx4EXFxcTh79iyGDh0KbW1tEELQt29fZGdnK8jNLS0t0bJlS1haWsLMzAwbNmyAt7c3ZsyYQa/H6tWrkZaWRhcHhEIhduzYQQP2kjKeY2H5l2GDbhaWYmT27NkKwXSDBg1w6tQpJCUlwc3NDRKJBLdv38b+/fvzrIRv2bIFtra29AEof19HRwezZs1CTEwM1q1bB0IIfHx8oKKiAisrKwgEAoSEhEAoFMLMzAyzZs3Co0eP8P79eygrK2PkyJF0fJs3bwaPx0OrVq3+qWx2dnY2Dhw4gODgYAiFQvD5fDRr1gw7d+78p65DRScjIwOLFi2iwXeHDh3KtYHZlStX4O3tDUJy3Yz/RM5a0WndujVq1aql8B7DMGjevDm0tbVZH4afkJmZiX379iE0NJSWGlWrVg3jx4/PV/WRkpICNzc3GpRHRETAzc0NpqampWacdv36ddSrV48mjS9fvlwqx82P9+/fY/fu3Rg8eDBq1apFn60SiQT16tVDVFQUfH19QQiBq6srLl26lGcfDMNg06ZN0NXVhaqqKhYvXvzTmvBPnz5BR0cHQUFBRRpvamoqjI2N0aJFC1y8eBEdOnTI0+dbXV0dUVFR9N73o9ycYRg6j1izZg3EYjGSk5Ph4+Oj0LM7NjYWQG6SQP5eXFwcVqxYoVAGd/bs2SKdBwsLS17YoJuFpRjIysrCkiVL8jwcCcnttdm/f39cunQJnTp1otlxhmHoKoD8Qbpw4UKMGzcOX79+pc6menp6aNmyJWQyGWJiYqgb6YMHD+hD1MTEBBMmTMhTIzd48GBIpVIF+dzu3bshFArRtGlTpKenl95FKid8+vQJCxYsgKurK5WfR0ZGspn9CkRGRgYWLFgAQ0NDcLlcdOzYsdzWAjMMg3379tGJcEhICJ4/f17Wwyp15s6dC6FQqNDib+XKlSCEYNeuXWU3sHJIZmYmDh48iM6dO9N7vK2tLcaOHftLY8Hs7Gw0adKEBpZDhgxB586dS804LSEhAR06dAAhBFWqVMHevXvLnXohPT0d58+fx7Rp02jCh5Bc53CxWAxCctt3Xr16FQzD4NmzZ7RFYKtWrQrknr5lyxYQQrB9+/YijXHDhg0ghODkyZP4+PEjJk6cCIlEAolEghkzZuSpWZc7nL958wa9evWiK+Q2Njbw8fEBACxdupTONTgcDvr16wcA6N27N33/woULyM7OhrGxMXx9feHu7g6hUIht27YV6TxYWFgUYYNuFpY/5PHjx7RWqlatWtiwYQPi4+Px/PlzXLlyBYMGDaKr2g4ODgp9iDt16qRQw21vb4/4+HhkZ2dTAzYul4vk5GTIZDJYWFigQ4cOiIuLg4GBAbS0tLB+/fqfSgY/fPgAiUSC6OhohfcPHToEsViMhg0b/tOGT3FxcRg0aBCVYVavXh2zZ89m5ecVhPT0dMybNw8GBgbg8Xjo1KkTHj9+XNbDypfs7GwsW7YM+vr6EAqFGDRoUIm0LyqvXLt2DYQQ2tf86dOnkEql6Nq1axmPrHyQlZWFw4cPo2vXrrQ22cbGBqNGjUJcXNxvg1eGYdC9e3earB01ahTmz58PQgj++++/Eh37ly9fMGjQIAiFQujp6WHp0qUVpoSJYRg8fPgQq1evRrdu3RTMzEQiEXg8HtTV1TFjxowCq6LkCg49Pb0i/cbfvXsHCwsLSKVScLlccLlc1K5dmybp9fT0MHbsWOzfvx/Hjx/H5s2b0apVK/B4PEgkEuqNIJecy5Mx8vNSVlbG6dOnAUChnZx8bhITEwMlJSW8f/8ebdu2BY/Hw5QpU4rN8Z2F5V+FDbpZWP6Ahw8fQltbG1ZWVrhy5QqA3J7ccil5XFwc0tLSUKdOHeoUqq6uDoZh4OfnBz09PYVenUpKSpg0aRLMzMzoxIvD4cDb2xv29vYghCAgIABisRjVq1cvUNZ92LBhkEqltNWInBMnTkBZWRl169b9qdvrv0JWVhb27duHoKAgCAQC8Pl8NG/eHLt27UJWVlZZD4/lN8jrM+XBd+fOnUu8frSoJCcnY9y4cZBIJNDQ0MCMGTMUVn//VrKzs6GsrIxp06YhJycHnp6eMDc3/6fvPdnZ2Th69Ci6d+9OE7NWVlYYMWIEbt++XahV4jFjxtDnyPjx4xEbGws+n09XNEuCjIwMzJw5ExoaGpBIJBg7diySk5NL7HilxbZt26g8n8/nQyAQ0Oezl5cXoqOjsX///l+22Xrz5g3U1NTQpUuXAh0zMTERCxcuhI+PDw205cqYH5PAN2/ehJGRUZ4e37a2tpg/fz6+fv0K4P8k56mpqWjdujXdTkVFBcrKypDJZPjw4QNEIhFN7iclJQEAbt++TVe+s7Ky4OXlBT6fDwsLC8yaNYt9JrKwFBE26GZhKQKpqalYtGgRbc8if1WqVAljx47F3bt3FaTkcuQmaosXLwYAjBgxAlZWVnSllRCC58+fIzk5mUrVjY2N8eXLF1SuXBk8Hg/GxsaYMGFCgSernz59glQqxdChQ/P87dy5c1BRUYGHhwd9WP/rfPr0CfPnz4eLiwutqe/fvz9u3bpV1kNj+Q1paWmYM2cO9PX1wePx0LVrVzx9+rSsh5UviYmJ6N27N3g8HszMzLBx48a/fiXJx8cHzZs3x6RJk8Dlcv/JetHs7GwcP34cPXv2pNJmS0tLREdH4+bNm0WSYy9fvpw+P6ZMmYJXr15R47SSCJBkMhk2btwIMzMz8Hg89OrVC2/fvi3245Q2379/R2RkJLhcLhwdHbFmzRpahtSkSROMHTsWQUFBCqvhdnZ26N69O1avXo1Hjx4p/PvJ/12OHj2a7/HevHmDefPmwcvLCxwOB3w+H40aNcLy5cvx8eNHdOrUCdra2jQYlvP27VsFs1WhUIiOHTvi0qVLyM7Ohkwmw6pVq+Dq6gpdXV0FWXmlSpXQtm1bALm/R/nfxGIx+vfvj7CwMNSoUQOEEAwfPhxArts7Ibmty+Rj/BuSKywspQ0bdLOwFJIlS5ZAXV0dHA4Hfn5+WLp0KbZs2ULlaUpKShAIBKhSpQpu3Lih8FkjIyN4e3vD1NQUOTk5MDAwwKJFi+Do6EgffpcvX8bq1avpf7dq1QouLi5QVlbGwoULiyTbGz58OJSVlfOVTV+5cgUaGhpwcXEptlYufwu3b9/GgAED6MTF0dERc+bMKTVDIpaikZaWhlmzZkFPTw98Ph/dunUrt3XU8fHxaN68OQghcHFxwcmTJ8t6SCXGyJEjoaGhAR6Pl6fk5W8mJycHJ0+eRO/evaGjo0NrbocOHfrHrQz3798PDocDQghmzpyJ9PR0uLm5wcTEpETuU6dOnaKBaLNmzXD//v1iP0ZZsGfPHhgbG0NZWRkzZsygz9mcnBwsXboUmpqaUFVVxZw5c5CVlYWnT5/iv//+Q69evWj7MXmStnnz5pg2bRrOnTsHb29vmJmZ0SD15cuXmD17Njw9PUFIbksvPz8/rFq1Ks/z982bN5BIJBgwYACA3GT/pk2bFKTi+b3+dxVcbhy3f/9+KjlPSEigJWyEEDg5OeH06dPIzMxEfHw8VV0A/+c/07JlSxw/fhxSqRSurq7/pCcMC8ufwAbdLCyFQC7h6969O549e5avlFwum5Q/6DIzMzFmzBjaS1W+ujF69GgYGhri1KlTdFVVXlcs35YQAlVVVejr6+cJ4AvD58+foaKigkGDBuX791u3bkFbWxv29vZsPXM+ZGVlYe/evQgMDIRAIIBAIEDLli2xZ88eVmpXjklNTcXMmTOhq6sLPp+PHj16lNvg+8yZM7S3vL+/P+7evVvWQyp2du/eTaWwf3vXgJycHJw+fRp9+/alSqZKlSph8ODB1KTrT7l8+TL4fD4Iye27zDAMunTpArFYXOxO+Xfv3kVAQAAIIXB3d6ftqSo6b968QVBQEAgh8PPz++n94dOnT+jduzc4HA7s7e3znH9SUhIOHTqEkSNHwsfHh6rghEIhOBwOjIyMYGNjQ98LCAjA2rVrf1vzPWHCBPB4PLRs2ZJK3u3s7MDlctGlSxdERUVBXV39pwE4n89H69atERcXRyXniYmJsLOzU1gpF4vFePbsGQBg2bJlIISgRYsWdBzjx4+HpqYmAOD48ePg8XjQ0NDA5MmT85SusbCw5A8bdLOwFIC0tDR06dKFTpxq1KgBf39/LFmyBAkJCflKyatWrQoul4uuXbtizJgx6N+/P8aNGwcAcHV1hYGBAb59+4ZTp07BysqKPgDbt29P/z+Px8OAAQPw+vXrPz6HUaNGQUlJCe/evcv37/fu3YO+vj6qVKlSoFrxf5WPHz9i7ty5cHJyoisbUVFRuH37dlkPjeUnpKSkYPr06dDR0QGfz0fPnj2RkJBQ1sPKA8Mw2LJlCywsLMDlctG9e/e/6rcod0qeMGFCWQ+lRJDJZDh79izCw8OpBNnExAQDBw7E5cuXi9XJ++HDh9Rte/78+QCAhQsXFrtx2tu3b6lBm4WFBbZs2VLuHMmLgkwmw8KFC6Gqqgo9PT1s3ry5QOd17do1Kr9u3779T3+fDx8+REREBExNTfMEwpaWlujSpQuWL1+O+/fv53vcuLg4DBkyBEZGRtT8bOzYsTh16hS0tLTQoEEDuhqfmpqK6OhohRVuoVBI27UxDAOGYbBo0SLY29vT4F3+/GratCn8/f1x4cIFeHt709K2hg0bIiAgAJ6enrC0tASHw6FjbdeuHdTV1SESiaCjo1OmbeFYWCoKbNDNwvIL0tPTMXToUGpq5uXlha5du6Jbt26oX78+OBwO1NXVUbVqVWqkJsfIyIhOMvv27QtVVVW4urrixIkTCAsLg1gsRqNGjRSk5XJTE7lEbN++fcV2Ll++fIGamhqioqJ+us2jR49gYmICS0vLchmUlDdu3bqFqKgoKhl1dnbGvHnz2Mx/OSUlJQXTpk2DtrY2BAIBevXqhRcvXpT1sPKQmZmJuXPnQktLC8rKyhg1alSFNxw7duwYCCEwMDBA9+7dy3o4xYZMJsP58+fRr18/WmdrZGSE/v374+LFiyVSp5+YmEh7ds+bNw8AcPbsWfD5fERGRhbLMb5//47Ro0dDWVkZmpqamDNnzl9j+Hfnzh3UrFkThBD06NGj0A7jMpkMK1euhLa2NqRSKWbMmIGsrCw8fvwYkydPpo7gYrEYgYGBWL9+PVxcXGBlZYW1a9ciLCwMjo6ONEjW1NREQEAAoqOj0bdvXzg4OND3+/bti4kTJ4IQgt27d8PBwQEWFhb5mrgdPXpUIaD+MQCXKyJ+fBkZGeH27dtUcg7klg8Qkts2zdjYmHaDkAf1cmJjY0EIwZYtW1CzZk1IJJJiV1ewsPxtsEE3C8tPePv2LVxcXCAUCtG9e3fcvXs3j5z8/v37MDExASG5zqb29vYAQANyVVVV8Hg8dOjQAS4uLnj37h2qVauGqKgoWi/VtWvXPA9DDoeDlStXFvs5jRkzBmKx+JemN8+fP4e5uTlMTU3LrQN0eSMrKwu7d+9GixYtqNttYGAg9u7dy8rPyyHJycmYOnUqDb779OmDly9flvWw8pCUlIRhw4ZBLBZDV1cXixYtqpDfp8+fP8PIyAj169dHz549YWtrW9ZD+iMYhsHFixcRFRUFY2NjmkyIjIzEuXPnStQQ79u3b7TN5MyZMwEAr169gp6eHry9vf/4+5GVlYVFixZBV1cXIpEIQ4cOzWPkVVFJS0tDdHQ0+Hw+bG1tERsb+0f7+/LlC9q3bw8Oh0MT5srKyggODsaWLVsUzMbi4uIgEAgwatQo+t7379+xd+9etGzZUqF1KIfDgbW1Nfr164cdO3bg7du38PLyos7j/6uq+5H79++jdevW+QbZ8peysjJ69OiBN2/eUMm5TCbD06dPoaenB3d3d9jY2MDZ2Znut2XLlpBKpfS/GYaBhYUFIiIikJKSAicnJ4hEIsyaNQvfvn37o+vKwvK3wgbdLCz/w5UrV9CxY8c8ZiQSiQTdu3fHqVOn8sjJAwICoKSkBBMTE6SlpSEsLAyNGzcGkJshVlVVpf2wg4ODqTna2bNnFVa3CSGQSqXYsWNHiZxbUlIS1NTUfttG5tWrV6hcuTIMDQ0RHx9fImP5W/nw4QPmzJlDFQx6enoYOHDgLydKLGVDcnIyJk+eDC0tLQiFQvTt2xevXr0q62Hl4eXLl+jUqRM4HA4qV66MnTt3ViiJb9u2baGuro5Xr17hv//+AyHkl+2WyiMMw+Dy5csYOHAglQzr6+sjPDwcsbGxpeI8n56eTlfTJ0+eTN9zd3eHiYnJH/lxMAyDXbt2wcbGBhwOBx07diyXKpCicuzYMVhaWkIoFGL8+PF/tGp/7949jBs3jrbxVFJSol4tgYGBP72HjBkzBnw+Hzdu3MCRI0cQGhpK/Vvq1KmDJUuW4MyZM1i4cCFCQkJQqVIlOi+Qr2B7enoiLi7ut9+3t2/fYty4cTQppK+vj3r16mHOnDkKSZSDBw8iPDwcBw8ehK6uLiQSCWxtbaGvr0/nIR8/fgSXy0WvXr0UjuHt7Y2QkBAAwOPHj2nCQCqVYtWqVUW+viwsfyts0M3C8v95+fIlateu/UtXUPnLwMAAp0+fpp/t1KkTHB0dwefzMWPGDBgZGaFz587w9vamteD3799HamoqqlWrBh0dHdSvXx9KSkoKhmmzZs0q8cno+PHjIRKJflsrmpiYiKpVq0JXVxd37twp0TH9rdy8eRP9+vWjEzIXFxfMnz+fdYkvZ3z//h2TJk2CpqYmhEIhwsPDi8VHobi5efMmGjZsSCffFy5cKOsh/ZYNGzaAEIJNmzYBAJ4+fQpCCPbv31/GI/s9DMPg6tWrGDx4MA2AdHV10bdvX5w+fRo5OTmlNpbMzEyYmZmBEEJXSxmGQdeuXSESiXD16tUi7/vixYv02degQQPcvHmzmEZd9nz48AGhoaFUMv3gwYNC74NhGMTFxWH06NHUgExFRQUhISHYtWsX0tLSwDAM1q5dCz09PUgkEkyZMiWPWeCVK1egpaVF+35XrlwZMTEx1MAsP16/fo0hQ4bQ4F4+X1BTU0Pjxo0RExODkydPIiUl5adjHz9+PHg8HqRSKfr06YPjx4/jxo0bOH/+PGbPno3KlSuDEILatWvjw4cPCnLzCxcuUKM2CwsL9O/fH0OHDoWBgQGMjIzQoUMHeqzGjRvD0dGRznlat27NllqxsPwAG3SzsCC3bc+PfS/lDzUNDQ3w+Xz4+voqOIoTktvqIyEhAVZWVhAIBOByueDxeDA0NISqqiqmTZsGAHSSbG9vD3d3d4SHh+cJ4mvUqFFq9XLfvn2DhoYGwsPDf7vtx48f4eTkBE1NTbZe6w/IzMzErl270Lx5cyo/DwoKwv79+4vUAo6lZPj27RsmTJgADQ0NiEQiRERElEsjsyNHjtC6z1atWuHRo0dlPaR8efnyJdTU1NCuXTv6HsMw0NfXL7ctwxiGwfXr1zF06FDahUJHRwe9e/fGyZMnSzXQlpORkYEqVaqAEKKgUlq0aBEIIVi7dm2R9vv48WO0atUKhBA4ODjgyJEjxTTisodhGKxZswZaWlrQ0NDAypUrC6UOYRgGt27dwsiRI6nruKqqKkJDQ7Fnz56ftsv6+vUr+vfvDx6Ph8qVK2PDhg2YOnUqXRWXB7CRkZEFGs/9+/ehoqKCFi1a0Fr+Fi1aICYmBn5+flBTU6Omqy4uLoiMjMSWLVvyJA1fvXqFUaNGUfO9H+cxbdu2RWxsLBiGUZCbA/9Xy92nTx906tQJp0+fRmJiIo4dOwaJRIKBAwfSY+zatQuEEDx48ADR0dEgJNc9PTQ0FJcuXSrwtWdh+Vthg26Wf573798ryLhMTEywZMkSfP36FR8+fKBS8u/fv2PRokUKwbmtrS2+fv2KNWvWYMSIEXSS5uXlRYPUQYMGgRCCe/fuITU1lbqay/cREhJS6gY1EyZMgFAoLJCU9suXL6hRowbU1NQqxMpaeef9+/eYPXs2DZr09PQwaNCgv7JFVEXl27dviImJoe68kZGRv/RBKAtycnKwZs0aGBsbg8/nIyIiolz1j5fJZKhXrx6MjY3zGFUFBgbCy8urjEaWF3mANXz4cNpJQktLCz179sTx48fLNDGWnp5OA7ZOnTrR9+XGaREREYXe58ePHxEZGQmBQABjY2OsWbOmTJIJJcWjR49Qr149EJLrMF5Q2b084RIdHU2/B+rq6ujcuTP2799f4Of09+/f6f1DboratGlT7N+/H1lZWYiKioJYLKYmZT8jKSkJ1tbWsLOzo0aK06dPB4/Ho88LmUyGuLg4LFmyBKGhobC0tKRzC1NTU7Rr1w4LFizAzZs3kZOTg+fPn0NfXx/6+vrYunVrnnr9gwcPIiIiAgzDYPPmzTTZULt2baipqdFgXG7u9qPC4tGjRyCE4NSpU2AYBo0aNaJO6IQQDBw4sFTKMFhYyits0M3yT5OTkwM/P7889ds8Hg8tWrTAsWPH0LFjR4V63NevXyuYlAwfPhz+/v6YPXs2lSHWq1cPK1asAJDbHkwkEuH9+/f0WDweD61bt8bp06fLpDbz+/fv1Bm1IHz79g116tSBRCJRkNWzFB2GYXDjxg1ERkZSEx03NzcsXLiwwtW7/q18/foV48ePh7q6OsRiMfr374/ExMSyHpYCaWlpmDJlClRVVaGqqopJkyZR/4iyZNasWSCE4Pjx43n+NnPmTIjF4jI1hWMYBnfu3MHIkSOpvFZDQwPdunXDkSNHyoVhXWpqKm1NGBAQQJ8Vr1+/LpJxWlpaGiZNmkS/K5MnT0ZaWlpJDb/UyczMRExMDEQiEczNzQu0cs8wDK5cuYIhQ4bAwsIChOS6hnfr1g2HDh0qcD/57OxsHDx4EO3atYOSkhI4HA58fHzQs2dP6OnpQUlJCRMmTEBGRgZSUlJgbm4Ob2/vnwah8rmJurq6QnCemZkJKysrNGjQ4Kdzh8TEROzYsQMDBgxAjRo1qJxdRUUFDRo0QP/+/em51qlTB1u2bMGbN2/w9etXPH/+HPPmzaPKipYtWyI1NRUHDhyg6rgLFy5AKpVCIBDA2toa/fv3x9mzZ6lr+9KlSwHk9vP+X1Vft27dKpQfBQtLccIG3Sz/LFevXqU1co6Ojli4cCH279+Pffv2Yc6cOahWrRqVme/Zs4d+ztfXVyHo1tbWhrOzM4KDg3Ht2jW4u7ujY8eOaNWqFerUqQNlZWU0bNgQ1atXh0gkwqBBg8rFqtnkyZMhFAoLbJaTkpICX19fKCkp/VUyxPJAZmYmdu7ciWbNmoHH40EoFCI4OBgHDhxg5eflgKSkJIwdOxZqamoQi8WIior6ab/7suLjx4/o168fBAIBjIyMsGrVqjJbvYyLi4NIJEL//v3z/fulS5dACCmT3r53797F6NGjaVChrq6OLl264NChQ+Ui0JaTkpICFxcXEEJQq1Yt+m+ZkZGBGjVqwNjYuMAruDk5OVi9ejVVRURGRpYrVURxcO7cOdjZ2YHH42Ho0KG/TDwxDINLly5h4MCBVOWmra2NHj164OjRowX+HjAMg2vXrqFfv37Q1dUFIQR2dnaYPHmyQjeE79+/Y9CgQeDz+bCyssKBAwdoQCoPUP+XYcOGgcvl5vus3bNnDwgh2Lt3b4HGmZaWhtjYWEyePBkBAQHQ1NSkpmf/WzYnl4QHBwfTFWsACnXeq1evBiEEfn5+VHLu5eWFw4cP0++r/PrIXdB/XPFu1qxZodu0sbD8DbBBN8s/yenTp6GsrAx3d3dcuXIlTyuwtLQ0eHt7w9HRETweD1wuF9evX0d8fDysrKxQqVIlBUn66tWrabswR0dH9OnTBwCwbt06uo2WltYfmd0UN8nJydDW1s7jSPor0tPT0aRJEwiFwgI/8FkKx7t37zBz5kya9NHX18fgwYNx7969sh7aP09SUhLGjBkDVVVVKCkpYeDAgX/kGF0SPHnyBK1bt6Y+EocOHSrVlaWMjAxUr14ddnZ2P617zczMhFgsxqxZs0plTPfv38fYsWOpCZaamho6deqEAwcOFHglszT5/v07XF1dweFwULVqVRpAMgyDbt26Fco47fDhw7SUJTg4+LeS5opGUlISevfuDUII3N3dcevWrXy3k/dT79+/P23zqauri969e+PEiROFSm6+ePECkyZNgq2tLS0RioqKwo0bN375W7t37x6VvTdr1gytW7eGqqpqnjKvTZs2gRCCGTNm5LsfhmHg6+sLa2vrIn1/ZTIZ4uPjsWLFCnTp0oXK4IODg3Hw4ME8iwI/1nkvW7YMPB4P/v7+6N+/P2xtbZGSkgIfHx/07dsX+vr6cHd3p5/t3bs3nJycqFRd/hKLxYiOjv6ryhpYWH4HG3Sz/HNcuHABYrEYenp6aNKkCdq1a4dx48YhLi4uTyswAKhRowZ0dHSgr6+Prl27wt3dHfHx8fDz86MPkFq1amHo0KFISUmBiooKJk6ciIsXL0IsFsPc3BxVqlRBz549y+iMf87UqVOpIVxByczMRGBgIPh8PrZt21aCo/u3kdcXRkRE0JUJd3d3LFq0iF0lKGO+fPmCUaNG0b65gwYNKnfB96VLl6gjta+vL27cuFEqxx06dCgEAsFvj+fl5YWgoKASG8eDBw8wfvx4mrxSUVFBaGgo9u3bV+oeGoXh69evcHV1BZfLhYmJiYL78+LFi0EIwZo1a367n5s3b6JBgwbUlfrixYslOexSh2EYbN26Ffr6+lBRUcH8+fPzBHA5OTmIjY1FREQE9WLR19dHWFgYTp06VaiA7+vXr1ixYgW8vb2pk3hISAgOHTpUqIBdPm5jY2OIRCJIpVL4+fnRYP3GjRtQUlJChw4dfhnAx8XFgcfj/TQwLwwMw2DYsGEghMDa2hrz5s3D169f6d937dqF+vXrw9XVlXZOcHJygo6ODqytrfHmzRvUrFkTPB4PlSpVQpUqVfDff/9RRYapqSkAUBf5H18tWrQol4kvFpaSgA26Wf4Z7t69i7Zt24LH40EkEsHb2xtNmzaFt7c3lJWVwefzYWZmptAj28/PDyKRCHZ2dlBSUkK9evVgbm4OAGjRogV9cOjq6uL69etYvnw5OBwOpkyZAiUlJXh6eiI1NRVGRkYYPXp0WZ36T0lJSYGOjg569OhRqM9lZ2ejXbt24HK5WL9+fQmNjkVORkYGtm/fjoCAAPr9bd26NQ4ePMjKz8uQz58/Y+TIkTT4Hjx4cLmS7TIMg927d9Pey6GhoSXaezk2NhYcDof2kP4Vw4YNg76+frGuwj969AgTJkygK7tSqRTt27f/pdt0eeLLly9UiqupqYmnT5/Sv507dw4CgeC3xmkvXrxAx44dweFwYGNjg927d/91NbQJCQnw9/enNcc/rhTn5OTg1KlTCAsLg76+PgghMDQ0RGRkJGJjYwsVaGdlZWHv3r0IDg6GSCQCh8OBr68v1q5dS43NikpycjKGDRtGZddy1YypqSlcXFwKVGsfFhYGVVXVYkv4xcbGIjg4GFwuF3w+H4aGhjA2NoZYLAaHw4Gfnx/279+fR3L+6dMniMVicLlcvHz5Eu7u7nByckJWVhZCQkKgpqYG4P/KSv731alTp7/uO8rCkh9s0M3yT3D48GFIpVJYWlpizpw5SEhIUJCTv337FlZWVuDxeOBwOLCwsACQO9GRSCSoU6cOGjduDA0NDZibm8PGxoZKOOVu5TKZDA4ODhAKhSCEoF27dkhLS4NMJgOfz8fChQvL+Crkz4wZM8Dn83/ZKzQ/cnJy0KVLF3A4HGoax1LyJCYmYsaMGahatSqdUA4dOhT3798v66H9s3z+/BkjRoyAVCqFRCLB0KFDy1V/2uzsbCxZsgR6enoQiUQYMmRIHtfiP+Xbt28wMzND7dq1CxTY7Nu3D4SQQt93/pcnT55g8uTJ1HBMIpGgXbt2tH9yReHTp09wdHSEQCCAkpKSQotGuXGal5fXT+uNk5KSMGTIEIhEIujq6mLx4sXlqka9OMjOzsasWbMgkUhgZGSEXbt20fePHz+O3r1709pqExMTREVF4fz584VyzGYYBpcvX0Z4eDi0tbVpO7Xp06fnacNVHDx48AB6enrUX0BLS0uhHvxXfPr0CRoaGoVOmv+Os2fPQllZGUZGRhg4cCDmzJmDJ0+eKGwjl5zn5OSgU6dOdJW8YcOGqFu3LgICApCTkwNTU1MadDMMQyX5HA6HzpUIIQqLHSwsfyts0M3y13PhwgWIRCJ4enri5MmTePToETIyMhTagclp3749bGxswOPxcPbsWVSvXh2RkZHIycmBm5sbCCEYNWoUAKBt27YKEil5X8oftwFyH4zl+aGSmpoKPT09dO3atdCflclk6NOnDwghWLBgQQmMjuVnyE18wsLCoKGhAUJy+70vXry42AMqloLx6dMnREdH0+B72LBh+PTpU1kPi/L9+3eMGTMGysrK0NTUxOzZs4tNat25c2dIpdICB9GfP38GIQTr1q0r9LGePXuGqVOnUqMxZWVltGnTBjt27CgXzu2F5f3796hWrRrEYjF4PB4OHTpE/5aRkYGaNWvC2Ng4X/O+zMxMzJ49G5qamlBWVsbo0aP/eBW2PHL9+nU4OzuDw+EgPDwcnz59wpEjR9CjRw8aHFeqVAmDBg3CpUuXCt2a6tmzZxg/fjx1sjc0NMSgQYNw+/btEjqj/yMxMZE6jPP5fIwYMaLA3+O5c+eCw+Hg5s2bxTqmK1euQFtbG6amppgxY0aejhr79u1DQEAAfH19qeN7zZo1YWtri8DAQFSvXp3WpvN4PJoAatSoEZ0nLViwQKFjzLBhw1jlFstfDRt0s/y1ZGRk4L///oOysnIeOVPlypUxe/ZstGvXTiHo7tSpEzw9PeHq6goTExOoqakhPj4eQG5ALhKJaG12jRo16P7kdV5169aFmpoakpOT6T7v3r0LQgjOnz9fuhegEMyaNQs8Hi9PNrsgMAyDAQMGgBCC6dOnl8DoWH5HRkYGtm3bBn9/f3C5XIhEIrRt2xaHDx9mjWrKgI8fP2LYsGGQSCSQSqUYPnx4uWoD9/btW/Ts2RNcLhfm5ubYtGnTH8k7d+zYAUIIVq1aVajP2draonfv3gXaNiEhAdOnT6fJTyUlJbRq1Qpbt25FSkpKUYZdLkhMTISdnR2kUik15fyRHj16QCQS4cqVKwrvy/soW1hYgMvlokePHnjz5k0pjrx0SE5OxoABA8DlcmFvb4/Zs2eja9eu1OfCwsICQ4YMwdWrVwv9Hf7y5QuWLFlCvQ8kEgk6duyIY8eOlep9c/ny5XQu0aZNGwiFQpiammLHjh2/PaesrCzY2trC29u72CXaT58+Rfv27SEQCCAUCuHn54f27dsjMDAQpqamtM3lyJEjaTuxjIwM1K5dG/v376dle6qqqti5cye2b98OFRUVeq5fv36lpnaE5PYzb9as2V+n0GBhkcMG3Sx/JdeuXYOxsTE1kbG0tISSkhJ27NiBgwcPwsXFBRwOB4QQhIaGAgDq1asHoVAILpeLli1b0ofw5cuXkZKSAktLS+jr68PAwACenp4KbcPkAaeGhgYGDhyoMBZ5a5CiBLSlRVpaGvT19dG5c+cifZ5hGIwYMQKEEIwfP56tzypD3r59i2nTplGnZkNDQwwbNgwPHjwo66H9c3z48AFDhgyBsrIyVFRUMGLEiHIVfN+7dw9Nmzalk+fTp08Xeh+JiYnQ0tJCy5YtC/2779atG+36kB8vX77EzJkzaYJTLBYjMDAQmzdvVkhsVlRev36NypUrU/fomJgYhb8vWbIk30D8zJkzNPkQEBCAu3fvluKoS4/9+/fDxMQEIpEILi4uUFNTAyEEVlZWiI6O/q1beH5kZmZi165dCAwMpM/7xo0bY/369WWSvDl//jwEAgF69eqFRo0awdjYGDdu3KA16w0bNvztvfvQoUMghGD79u0lMsbExERYWlpCIBDA2dkZjRo1Qu/evWki6OPHj6hfvz5txRYaGkol58uXL6cdUpydnem/IYfDQU5ODmJiYugcqmfPnhAIBGjTpk2JnAcLS1nDBt0sfx1bt26FSCSCmZkZJk+ejAMHDuDVq1cKUnI7Ozu8evWKtv1auXIl+vfvj8GDB2P06NGoWbMm3N3d4enpCT8/PzRp0gQBAQHQ09NDdHQ0mjRpQh8UVapUwf3797F48WJwuVw8f/5cYTwbNmwAIaTcTxLnzp0LHo+HR48eFXkfEyZMACEE0dHRbOBdxjAMgytXrqBv3750Uu/h4YGlS5ey8vNS5sOHDxg8eDANvkeOHFmuHOhPnz5Ng7imTZsWuD0dwzDw8/ODnp5ekQzkVq1aBQ6Ho/B9fPXqFWbPng0PDw8QQiASidCiRQts3Ljxr5JNv3jxApaWltDR0QGPx0OvXr0U7ply4zT5CiKQ2/pMniRxcXHBqVOnymDkJc/z58/h6elJ5daEENjY2GDkyJG4detWoZ8tDMPg/Pnz6N27N10hd3JywqxZs5CYmFhCZ/F7Xr16BT09PdSuXRuZmZlISEiARCKhLUf37t0Lc3NzCAQCDB069JdzCH9/f5iZmZWYYaDcVV8qlWLx4sV5EhQLFixAnTp14OzsjLp169KOAbq6uvDz80NiYqKCOlBbWxsAcOzYMfpedHQ0XfWvV68eTp48WSLnwsJSVrBBN8tfQXZ2Nnbs2EFlYv/70tXVhb29PY4cOQIACAgIwPfv39G6dWvo6uqCx+OhWrVqaNKkCeLj4xEeHo6hQ4eCEIL09HSkpqbCx8cHhBC6gih/qDx+/BgymQxVqlRBq1at8oxt5syZkEqlpX1JCk16ejoMDQ3pyn9RmTlzJggh6N+/Pxt4lxPS09OxZcsW+Pn5gcvlQiwWo127djhy5AgrPy9F3r9/j0GDBkFJSQmqqqoYPXp0uUmAyGQybN68Gebm5uByuejZs2eefr3/i7yF1f79+4t0zIcPH4IQgg0bNmDu3Lk00BIKhWjWrBnWr1+Pb9++FWnf5Znnz5/DzMwMBgYGUFZWRtOmTRVqWd+8eQN9fX3UqVMHWVlZSExMpOUAZmZm2LRpU6Frlss7aWlp2L59O9zd3enzVd71Iy4urkjPksePH2PMmDGwtLSk5mrDhg0rF8qA9PR0uLm5wcTERKFWf/78+SCE4MyZMwByr8u4ceMgFothbGyMLVu25HstHjx4AD6fj0mTJpXYmJOTkxESEgIOhwOpVIqIiAisWrUKGzduxNy5c2mizNDQEIMHD4aTkxMyMzNx4MABdOvWDTo6OvTftmXLlmjWrBkcHR3pewMHDkR2djYMDQ1ponjAgAF/3Xed5d+FDbpZKjyvX7+mzrW/e/F4PCxYsACLFy+GSCQCl8uFjY0NTE1NoaqqChcXFwDAiBEjMG7cOBCS24Pb19cXwcHBCpJykUhEVxrk8q5z587lGd+QIUNgaWlZmpekyMyfPx9cLvePpcgLFy4EIQS9e/dmH5jljDdv3mDq1KmoUqUKCCEwNjbG8OHD8fDhw7Ie2j/Du3fvMGDAACgpKUFNTQ1jxowpN8F3RkYGNeaSSCQYM2ZMvitsDx8+hLKycoFrsv+XxMREzJs3jxpICQQCBAQE4L///lPoEfy38eTJE5iYmMDU1BTa2tqoUaOGgmnWj8ZpT58+xZgxYyCRSKChoYFZs2aV6x7jhSU1NRXbtm1DmzZtoKSkRJ+tzs7ORfZA+fTpExYuXIiaNWvSxHjXrl1x8uTJcvMsYhgGHTt2hFgsVnCpB3KTX56enrC2tlZw33/27BmaN29OV4HzU6NERUVBIpGUeG3/tm3bFFQI8v9fv3597Ny5E9nZ2Th48CBVaSQlJVGzT/m/r6enJ758+YJ169bR9+XlFTExMVBSUsKUKVOocR6bwGf5G2CDbpYKzYsXLxSMOAghMDc3h5GREUQiEUaMGIE2bdqAy+UqbKOnp4f169fDysoKysrKWLlyJQghVFodHh6O6dOngxCCDx8+4M2bNwqGbGpqarh48SIdR6NGjeDq6prvg6Fjx47w9PQstWvyJ6Snp8PY2Bjt27f/432tXLkSHA4HnTt3ZldTyyHy1jh9+vShqwq1atXCsmXL/uqgpzyRmJiIqKgoiMViqKurY9y4ceXm2n/58oW2oNLT08PixYvpamxWVhbc3NxgZWVVqDrYd+/eYdGiRahbty44HA74fD50dXVha2tbbpIOJcnDhw9hZGQES0tLmJubw9raOk9rOblx2rBhw2iLt8GDB5ercoQ/ITk5GVu2bEGrVq3oM1VPTw88Hg9mZmZFksynp6dj27ZtaN68OQQCAXg8Hvz9/bF58+Zy2TZu9uzZVOGRH/Hx8RAKhRg6dGievx08eBBWVlbg8/kYOHCgQslFUlIStLW10alTp5IaOiUiIkJhTtW1a1fcuHGD/v3jx4/w8fHBqlWrYGFhoWCW5uPjAw8PD7x9+5YqCAkhOHHiBAAgLi6OLmLIfQ2GDx9ebpImLCxFhQ26WSosaWlpqFatGr1hGxsb04fs/7YDq1y5Ml3Zk78WL16M1NRUiMViJCcnQyQSISQkBNnZ2fDw8MCECRMgFAqRmJgIe3t78Hg8EELQuHFjhQfdvXv3QAjB+vXr8x1nw4YNERgYWCrXpDhYtGgRuFxusfR93rBhA3g8Htq2bcs6kpZj0tPTsXnzZjRu3JjKz0NCQkrdxfdf5e3bt+jXrx9EIhHU1dUxfvz4ciOrTkhIQGhoKDgcDqpUqYLdu3djzJgx4PF4uHTp0m8//+HDByxZsgT16tUDl8sFj8dDo0aNsHLlSnz+/BlTp06FRCL561sF3b9/H/r6+qhSpQqcnZ2hq6uLp0+fKmwjDzD09fVBCEGHDh2QkJBQRiMuPr5//46NGzeiZcuWEIvFtCa9e/fuMDMzg0AgwOjRowtVjyyTyRAbG4sePXpQcy43NzfMmzcP79+/L8Gz+TOOHTsGLpeLwYMH/3K7iRMngsfj5VkJB3LVEBMnToSSkhIMDAywYcMGmvCXl3z8r9t9cZOTk4MOHTrkURM6ODjA398fvr6+CuoFuXmafC7m7OxM506E5Pb4lp/D69evQQjBgQMHAAC+vr7g8XioXLky9u3bV6LnxcJSkrBBN0uFRe56KQ+Gf6wDGz9+PFq3bk2Dbh0dHejp6cHIyIhuJxQK4erqClNTUwCAp6cn9PT04OHhgdWrV8PKygo+Pj6wtraGVCqFWCxGs2bN8mRbe/bsCQMDA2RmZuY7zurVq6Nv374lezGKkYyMDJiYmKBt27bFsr/t27dDIBCgZcuWf5U08m/l9evXmDJlCmxsbGgd5IgRI/7IYI+lYLx58waRkZEQiUTQ0NBATExMuQm+b9y4gfr169P7Z7du3X667cePH7Fs2TI6WebxeGjQoAGWL1+ep2/5uXPnQAjB9evXS/oUyow7d+5AR0cH1apVQ6NGjSCRSHD16lWFbZYvX047atSrV6/CX4+vX79i3bp1aNasGUQiEQghcHd3x7Rp03Dt2jV06dIFhOR2FymocR+QW7s8YsQImJmZgZDc3twjRoygrT3LM0+ePIGGhgYaNWr022RmVlYWqlevjurVq/80Yf3ixQsEBQWBEAIvLy/cuXMH2dnZsLe3R61atUpcks0wDCZOnAhVVdXflvZZWVnROUVGRgY8PDxorT0hBF26dEFSUhLatm1LDdfk3RT27NkDQnKNQLlcLpYtW1ai58XCUlKwQTdLhSMjI4M+sFVVVREeHg5ra2uIxWLMnTsXPXr0oHWCOjo62Lp1KxYvXgwVFRUIBAJIJBJ6o9+zZw+t427atCkCAgIAAEeOHFHI3JqamqJatWp53HM/ffoEsViMCRMm/HS8enp6GD9+fMldkBJgyZIl4HA4xWY4s3//fohEIvj5+ZVLuR9LXhiGwcWLF9GrVy+6kuTp6YkVK1aUm0Dwb+X169eIiIiASCSCpqYmJk6cWC6cu5OTk2FkZERXsFq3bk1bIX7+/BkrVqxAw4YNwePxwOVyUb9+fSxduvSXzubp6ekQCoWYN29eaZ1GqXLz5k1oaWnB0dERnTp1Ao/Hw8GDB+nfnzx5gmbNmoEQAmVlZezZs6fC1q9++fIFa9asQUBAAIRCIQghqFmzJmbOnImEhAQwDIN169ZBW1sb6urqWLZsWYEkw+/fv8fcuXPh6upKy7t69OiB2NjYCiM5Tk5ORrVq1WBlZVXgUoHr16+Dx+Nh4sSJv9zu6NGjsLGxAY/HQ79+/WiQunHjxuIY+m9JTk5G+/bt8wTaysrK6NixIy5duoQPHz7QtmKrV6+mzxR5ecG3b98QGRmJGzduYPXq1eBwOHj58iWA3FV1Q0NDDBgwAGFhYSCEoEWLFnmUIiws5R026GapUGRkZMDX1xcikQgLFy5EamoqsrKy8sjJq1SpAgcHBxBCoKGhAQcHB9y7dw9fv35VqC9q1KgRDbpr166N9u3b4/379zA1NYWOjg5OnTqFevXqQUtLC8+ePcsznkmTJkEsFuepy5OTk5MDLpeLpUuXltxFKQEyMzNRqVIltG7dutj2eezYMSgpKaFevXpl0g+VpeikpaVh06ZNaNiwITgcDpSUlNChQwccP368wkx6KyKvX79GWFgYhEIhNDU1MWnSpDINvvv06QMlJSXcu3cPq1atgoGBAXg8HipVqgQ+nw8OhwMfHx8sXry4UBLfWrVq/ZW9ea9evQoNDQ24ublhxIgRIIRg1apVAHITtv369QOfz4dAIICGhkaJG2CVBJ8/f8bKlSvh5+dHk92enp6YM2cODZqA3ORCgwYNQAhBmzZtftuqKy0tDZs3b4a/vz94PB4EAgGaN2+O7du3l1hbrJJCJpMhMDAQUqm0UKv6ADB06FAIhcLfruRnZmbSUg1dXV24uLjA2NhYwaSvpImKilIIuuXtzzZt2oRdu3YhODgYKioqeYLzevXqITExEXXq1EH37t2hoqICJycnhX17e3sjJCQEMpkM/v7+1MQtICAAr169KrVzZGH5E9igm6VCERISAj6fj86dO2P48OGYPn06bt++DQAKQXdAQABCQkIwcuRIKjlnGAbZ2dmoWrUqvWErKSnBxcUFiYmJ4PP5GD16NOzs7KCnp4fnz58jIiICfD4/X3OXrKwsGBoaokePHj8d77t37+iKekVDLne8c+dOse3zzJkzkEqlqF27NrtaWkF59eoVJk2ahMqVK4MQAlNTU4wcOZKueLIUP69evULfvn0hFAqhpaWFKVOm/LJnb0lw4MABEEIwY8YMrF27Fk2aNIFAIACHwwGPx4NYLMaIESOKpGQZNGgQjI2NS2DUZcfFixehqqoKDw8P2s1h/PjxSEtLw5QpU6CmpgYVFRW4ublBKBTi8uXLZT3kAiMvH2jYsCFNtnh5eWHevHl4/fq1wrZZWVmYPHkyxGIxKlWqpLDK/7/IZDKcPHkSXbp0ocFZzZo1sXDhwjxlCRWJ8ePHgxCC3bt3F/qzaWlpsLa2Rq1atQqU4Hz16hXatGlDa6iL2l2gKDAMQ7u+FOQlFAoRFxeHAwcOoFevXhAKhRg4cCAIIRCLxdi8eTO8vb1Ru3ZtqKurw93dHQBw7dq1PCWFhU1msLCUBWzQzVIhuHXrFoKCgqgRj4GBASpVqkSl4p6enqhTpw5u3boFAKhatSq4XC4EAgFcXV3p/7q5uaFVq1YwNTWlN2wVFRVYWFiAz+dDKBTC3Nwc8fHxWLZsGQghWLRoUb5j2rhxIwghv5Rg37p1C4SQAhkOlTeysrJgbm6OoKCgYt3vxYsXoaamBnd397/GkfdfhGEYXLhwAT179qQ1fXXq1MHKlSvLhRT6b+Tly5fo3bs3BAIBtLW1MXXq1FJRjTx79gxqamrQ1dWlq5m1a9fGvHnz8PbtW3z48IEmKE1MTLB27dpCGfDt2rULhBC8ePGiBM+i9Dh79ixUVFRQu3Zt7Ny5E3w+H927d8eaNWtgYmICPp+v0CFj5cqVZT3k3/L+/XssWbIE9evXp+UDPj4+WLhw4U9XrS9evAh7e3twuVwMHDjwp9/Vu3fvYujQoTA2NgYhBJaWlhgzZgweP35ckqdUKuzevZsmXIrKmTNnQAjB/PnzC/yZkydPQktLC4QQdOzYsVSftbdv36ZBdH7BdvXq1REREUETAhkZGahduzZMTU0hFovh5OSENm3a4MmTJ/D29kZycjJsbW0VEgiurq4KRm3GxsZ5Ej4sLOUNNuhmKfesWrUKfD4fxsbGGD16NBwdHSGRSBAXF4esrCx069aNZsWrVauGxMREGBsbo1atWnB1dYWOjg54PB7mzZuHI0eOoGXLlrSHJyEEb968gY6ODlRUVDB16lR8+fIFsbGxEAgEP80SMwwDNzc3NGjQ4Jdjl9eGV1QHWnkrNXkyo7i4fv06rXP8Vb0nS8UgNTUVGzZsQIMGDcDhcKCsrIzQ0FCcOHGClZ+XAAkJCejVqxcEAgF0dHQwffr0Yg++v3//jg0bNqBZs2a05aKrqyvmzJnz08nto0eP0KpVKzqxPnr0aIGO9f79exBCsGnTpuI8hTLh1KlTkEgk8PHxwdmzZyGRSFCjRg1a7hQUFIRHjx7hwoULEAgE5dpkMzExEQsXLoSPjw9NePv6+mLJkiV49+7dTz/37ds3hIWFgcPhwMXFRaGV1I/7njVrFpycnEAIgaamJvr06YPz589X2Jr2/+XevXuQSqUIDAz84/tgnz59IJFICjWX+Pz5M1RUVMDn86GtrY0VK1aU6v04KSmJlhTUr18fs2bNwqVLl8AwDD5+/EhrvC9evIiGDRtCKBRCSUkJXl5eUFdXx9OnT+Hj4wNHR0cQQrBixQq67ylTpkBFRQXOzs50LlfcCwQsLMUNG3SzlGvWrl0LQgh69OiB7OzsfOu37ezskJ2dDW9vb3A4HDRo0ID2zM7OzoaysjKaNGkCS0tL1K5dG+/fv6d9idXU1ODq6gpNTU1qypGQkAAdHR14e3v/1DX0/PnzCi0tfjf+ilaDJicrKwuWlpZo2bJlse87Li4Ourq6sLOz+219H0vF4eXLl5g4cSKsra2pu/Do0aNZ05sSICEhAT179qT9rmfMmPFHNZzJycnYtGkTWrZsSR2n5R4YhfGluHDhAjw9PUEIQcOGDQuUtLO2tkZ4eHiRx14ekPtWNGjQAPfu3YOWlhY1jKpVqxYuXLgAINel3sDAALVr1/5p14uy4s2bN5g3bx68vLxo6UDDhg2xfPnyAiVId+7cCUNDQ0gkEsyZM0dB8ZCSkoL169ejUaNG4HK5EAqFCAwMxK5du8rddfhTvnz5AisrK1SrVq1YSkG+ffsGY2NjNGrUqFBJCXnivFGjRiCEoEaNGnmc80sShmEwevRocLlcSKVSRERE4PTp04iLi8PgwYNhaWlJ+7WbmJhAIpHA3d0dERER6NWrFz59+oQuXbpAT0+PGt0CoErEt2/fQk9PjwbeU6dO/WuSNix/H2zQzVJuuXr1KrhcLgwMDGBjYwMbGxvUqVMHc+fORbt27RTqtxs0aABdXV0oKyuDy+WiUaNGqFGjBlxdXVG9enXMnTsXhBDY2dnRVkhy93MtLS3aCzMlJQXVq1eHmZnZT83RACA4OBg2Nja/zRpPmzYNampqxXZNyoI1a9aAEJLvasWfEh8fD0NDQ1hbWyuY7rBUfBiGwfnz56kxjrytzapVq1j5eTHz/PlzdO/enQbfM2fOLHDwnZKSgi1btiAoKIj2UHZ3d8eMGTOoTLpTp06FHhPDMNi5cycqV64MDoeDTp06/fI33rlz5zzmSRWJQ4cOQSQSoUmTJrh8+TItuTA3N8fOnTtpIJCZmQkPDw8YGRmVm2Tjy5cvMXv2bJooEQgE8PPzw6pVqwpcS/3q1Ss0b96cmlvJSwVycnJw9OhRdOzYEVKplJYmLF269K8tL8rJyUHDhg0VkvnFwf79+0EIwdq1awv8GZlMBmdnZ7i6uuL06dOwt7cHh8OhAW1pkZCQgJYtW+Zp8crj8RAYGIjjx4/jwIEDNPEml5wvWLAAHA4HFhYWsLS0BJCbHJRIJBAKhQCAMWPGKOwzNDT0pwsmLCxlCRt0s5Q7kpKS0K1bNwgEAggEAgQFBWHAgAEYMGAAWrRoAT6fDx6Ph9atW+P79+9YvHgxjIyMoK+vTw05DA0NMWHCBJiZmaFnz55Yt24dCCFISkqiMj+5BPLhw4cAch9OQUFBkEgkvzQPS0hIAJfL/Wmt948MGDAANjY2xXZtyoLs7GxYW1ujWbNmJbL/J0+eoFKlSjAzM8vXIZ6l4pOamor169fD19cXHA4HEokEnTp1wqlTp1j5eTHy7NkzdOvWDTweD/r6+pg9e3a+xmapqanYtm0bgoODaV2kq6srpk2bRn+DOTk5qFOnDipVqvRHpodZWVlYtGgRdHV1IRaLMWzYMHz9+jXPdsuWLQOXy62QCZm9e/dCKBTCz88P/fv3B4fDAYfDwdixY/NM/uW1rmXt85GQkIAZM2bQUiuhUIiAgACsWbOmUMFwTk4O5s2bB6lUCgMDA2zbtg0Mw+D27dsYNGgQDA0NQQhB5cqVERMT80/c4wcPHgwul4tjx44V+77bt28PDQ2NX8r7/5fY2FgQQrBmzRpkZ2dj7ty5UFVVhaamJpYsWVIo/4U/gWEYtGnTBgKBAJMmTcKNGzcUFjd+lJxfunSJGvXVqlULN27cgK+vLwBg4sSJMDAwgKmpKYDcLg/yYN7AwAACgQDdunVjV7xZyh1s0M1Srnjz5g3s7OygoaGByZMn4/Hjx3Bzc6M13EDuDVe+ol2pUiXY2dkhLS0NX79+haqqKkJDQ0EIwfbt25GTk4OmTZti0KBBNFCXB9y2trYKN2W56+auXbt+OcbBgwdDXV29QDWUISEh8PLy+qNrUh7477//QAihioDi5sWLF7CysoKxsTFNgrD8nbx48QIxMTGwtLQEIQRmZmYYM2bMPzEZLy2ePn2KLl260OB7zpw5+Pz5M3bu3Im2bdtSA0pnZ2dMmTIl39W4KVOmgMPh4MyZM8Uypu/fv2PUqFFQVlaGlpYW5s6dqyApvnfvHgghOH78eLEcr7TYsWMH+Hw+qlevDg0NDWrgefLkyTzbyiWxP9amliZPnz7FtGnT4ObmBkIIRCIRmjdvjnXr1uWbCPkdt27dgru7OzgcDvr06YP79+9j2rRpNLGtra2N8PBwXL58+Z8JgNavXw9CCGbNmlUi+//48SO0tbURHBxcqM+1adMGBgYGVOr+7t07dO7cGYQQuLi4lFoSKCMjA61atQKHw0Hbtm1x9uxZhe/GggUL4OzsDAMDA7rAoqamBi0tLZw4cQLfvn1DixYtwOVy0a1bN/o5uYJRRUWFlvVNmzbtn/nesVQM2KCbpdxw48YN6OjoQCgUwtLSEg4ODqhfvz6mTZuGkJAQhRru0NBQbNiwATweDxKJBKmpqTh9+jSkUikGDBgAV1dXtGrVCgDQtm1b1KlTh8r95O0ofmzRsn37dhBCEBMT88sxJicnQ11dHUOGDCnQOdWvX79Ye12XFdnZ2bCxsVGoqSpu3rx5gypVqkBfX/+XjvAsfwcMw+Ds2bPo1q0blZ16e3tjzZo1pd4O62/l7t27qFevHl15lat7Jk2a9Etn6Js3b0IgEBT4PlcY3rx5g+7du4PL5cLS0hJbt24FwzCQyWTQ0NDAuHHjiv2YJcWmTZtorSohBFWqVAGPx8vX6+PixYsQCoXo06dPqY7x8ePHmDx5MjWcEovFCAwMxMaNG4usYEhNTcXgwYPB4/Fga2uLkSNHUhWLSCRC69atsW/fvn9O4nvt2jWIxWJ07NixRIO9TZs2gRCCnTt3FvgzL168gFgsxvDhwxXeP3/+PDWz69q1a6kYm8pkMsybNw8mJib0d9O0aVO0aNECLi4uIIRAX18fgYGBcHR0RGZmJlUxdunSBQYGBiCEICoqCmFhYfDy8qKKHYFAAABwcXEBl8uFi4sLO59gKTewQTdLmXPhwgU0bNjwl/0c+Xw+2rVrh0+fPkFHRwd6enpwdnaGmZkZXfHW0NBA3759MXDgQNjb20NNTQ2enp4IDw+nE055dn/v3r30+Ldu3YKysjKCg4N/+6BcsGABeDxegVvbVK1aFZGRkX90fcoLGzZsACEEV65cKbFjvH//Hg4ODtDW1sbNmzdL7Dgs5YuUlBSsW7cO9erVAyEEEokEnTt3xunTp1n5eSHJyMjA3r170aFDB1pLb2NjA0dHR3A4HBgaGmL+/Pk/NXdMT09H1apVUb16dWRkZJTYOOPi4uDv70/NnWJjY+Hv74+GDRuW2DGLk5EjR9JnSuPGjREZGfnT9l9v376FgYEBPD09S8Uw7MGDB5gwYQJ1fVZSUkKrVq2wZcuWP05oHT58GObm5hAIBKhevToNdurWrYsVK1YUacX8b+Ddu3cwNjaGm5tbiRunMgyDpk2bQl9fv1ClAKNGjYJIJMqjKsrJycHChQuhrq4OdXV1LFiwoFQk5zk5OXB0dIRIJIKPjw+aNGmC0NBQbNu2DVlZWTh48KBCjbeDgwM0NDTA4/Hg4eGBffv2ITMzEzKZDNra2iCEQEdHB8D/mdhaW1tDTU0NFy9eLPHzYWH5HWzQzVKmrFu3jvZ9/d9Xfu/r6+tj/PjxtA2Gvb09KleuDGNjY0yYMAGnTp3CwIED0bFjR3h6egLIbbUhr/cxNzfHuXPn6PHfv38PU1NTODk5/dZ4SCaTwdraulAr19ra2pg4cWLRLk45IycnB7a2tvDz8yvR43z+/Bmurq5QV1dXUCOw/BskJCRg/Pjx1DXb3NwcY8eOxfPnz8t6aOWWzMxM7N+/Hx07dqSKnqpVq2LcuHG4f/8+3e7Ro0cIDQ0Fl8uFkZERFi5cmCewjoqKglAopMqikubkyZN0FdbW1hYSiaTUakyLwoMHD+jKoJaWFo4ePUon+Pmt0mdmZqJWrVowNDQsUeO0+/fvY9y4cbC3t6eJqzZt2mD79u3F0k7u3bt3aNy4Ma3/lv97TZo06a/pr15UMjMzUbt2bejr65dar+hXr15BVVVVQWL9O1JSUmBkZPTT1lofPnxA9+7dweFw4OjoqDBXKik+f/4MW1tbaGtr48iRIwoLHz/WeJ87dw5mZmZ0biiRSGBvb4+EhAQcPHhQIQEG5CYPRSIRpk6dCk9PT2hpabEdNFjKHDboZikztm/frrACbWFhgSlTpiA+Pp62BLt58ybU1dVpn1j5Dbdfv37YvHkznJ2dcfr0aRBCsHv3bhp0+/j4oFmzZpg3bx6dHOzbt09hMpeZmYk6depAV1e3QM7ZcufQgmZMs7KyfrryUVGRy9pKOmv89etX1KpVCyoqKjh79myJHoulfMIwDGJjY9GlSxdag+zj44O1a9cWe0/qikhmZiYOHjyIzp070xaIVapUwZgxY34rp3zw4AE6dOgALpcLY2NjLFq0CBkZGTh+/DgIIZg5c2YpnUUuMpkMGzZsoK1/WrVqVW6cveW8e/cOffr0oc+sevXqITs7G0eOHAGfz0ePHj3yVUr17t0bQqGw2O+ZDMMgLi4Oo0ePhp2dHa1nDQkJwc6dO/M10CsKCQkJCAwMpM9gFRUV9OvXD9euXWPrZf8/vXv3hkAgwPnz50v1uEuXLi20D4LcVPb06dM/3eby5ctwdXUFIQQdO3YslGlbUfj48SN1zrexscHChQsRFxeHZ8+eYejQoahUqRJN9GhqaiI5ORkhISE0wJbLzeXzQDlGRkYYPXo0Pn/+DD09Pdjb27PeISxlCht0s5QJr1+/prI0uTRt7dq1OHfuHGQymUIf7oCAADRv3hympqZ0e0tLS1SvXh3Kyso4evQo+Hw+LCws4ObmBmNjYzpBJ4QgPDw8z+SAYRj06NGjUA9KX19f1KhRo1DnSAjB/v37C35hyjk5OTmoWrUqGjVqVOLHSk5ORt26daGsrFzhzJVYipfk5GSsXbuW/qalUim6du2K2NjYf2rin5WVhcOHD6Nr167Q0NCgrtCjRo1CXFxcoa9FfHw8QkJCwOFwYGRkBA0NDdStW7fMJP1fvnwBl8uFsrIyJBIJxo0bV+b1/SkpKRg3bhykUil9ZvXp0wcMw+D69euQSqXw9/dHdnZ2ns8uX74chBAsX768WMbCMAxu3bqFkSNHUuMouXnonj17ik3W/O3bN6xcuZIarskNDzdt2pTvef7LLFmypFj/jQuDTCZD3bp1YW5uXuBEpEwmQ40aNVC9evVfKkpycnKwbNkyaGlpQVVVFXPmzCnRf3uGYdCuXTsF/wn5SyKRoGfPnpg/f36elmJDhgyh23G5XDRp0gSenp50dXv8+PEAcg145YmjiRMn/lPPDZbyAxt0s5Q6DMNQh/H/vbnKa3Dc3NyotKlq1argcrng8/l0xYsQAnt7e0ydOhXVqlWDnZ0dwsPDcerUKbi5uYHH40EqlWL27Nn53lwXLFhQqFXouLg4EEKwadOmAp/n9evXS9Txu6zYunUrCCGlktVPS0tDo0aNIBKJcPDgwRI/Hkv55/nz5xg3bhzMzc2pQmb8+PFISEgo66GVCNnZ2Th69Ci6d+8OTU1NEEJgZWWFESNG4Pbt28Uyebx//z4qVaoEQggMDQ2xdOnSUqk9zg93d3cEBwdj0KBBEAqF0NfXx7Jly0o92MvOzsayZcugr68PoVCIunXrghCCAQMGgGEYPHv2DPr6+nBzc8s34JEbp/Xu3fuPxiEP7qOjo2FtbQ1CCNTV1dG5c2fs37+/2Orus7KysG/fPrRp0wYikYg+n/X09BQ8UFj+j7Nnz4LP5yMsLKzMxvD48WOIxWJERUUV+DOXLl0CIQTLli377bafPn1C7969weFwUK1atWLrZpAfb968ofc4QgicnJywd+9eavj3o9z8zJkztMxD/jI1NaUS8osXL4LD4WDp0qUAcpUqAoEADRo0ACEEAwcOLLHzYGH5GWzQzVKqZGZmIiQkhAbX06ZNg6OjIyQSCa5cuYLY2FjqXsnj8TB27Fg4ODggNTUVUVFRdDJACKEGZcHBwahUqRIGDRqE27dvQyKRoH79+j9dITlx4gR4PB769+9f4HF369YNRkZGhXJjPXDgAAghpVbjVVrIZDLY29vTnpklTUZGBpo1awaBQFAot1aWvxuZTIbTp0+jc+fONBlXr149/PfffxVefp6dnY0TJ06gV69e1CDIwsIC0dHRuHnzZrGv0sjLRqZOnYq2bduCw+GgUqVKWLZsWak7UEdFRcHMzAxAboKlffv2IITAzs4O+/btK/EVKoZhsG/fPirZDgkJwdChQ0EIwbBhw8AwDD59+gQbGxtYWlri/fv3efaRmJgIQ0ND1KpVq0jJC4ZhcOXKFQwZMoR6G2hqaqJr1644dOhQsSVE5MeJiIiAjo4O/Z7p6uqCz+dj+PDhxSZT/9t4+fIldHV14e3tXeYu7dOnTweHwylUCUNoaCh0dHQKbHx37do11KhRg/4m3rx5U9Th/pJz585BLBYrrF43a9YM27ZtQ2xsLMLCwmBsbAw+n68QcItEIoVWfNHR0eBwOApu7J6enujQoQPmzJkDQgiaNGnCys1ZShU26GYpNXJyctC8eXMIhUKsW7cODMMgKysLHz58UJCT29nZISgoCFWrVqXZ1a1bt2LmzJmwtbWlN2R1dXUkJyfDzs6OtrcxMDCAk5MTvn//nu8Ynjx5Ak1NTTRo0KDAKycfPnyASCTC5MmTC3W+q1atAiGkzB/IJYG8xVpp1VtnZWUhODgYPB6vUGoDln+D5ORkrFmzhq5GqqiooFu3bnl6wJZncnJycOrUKfTp0we6urpU0jtkyJASrZ999eoV1NXV0aZNG3qMu3fvonXr1uBwODAzM8OKFStK7T62bds2EEIUJvXXrl2jpQXe3t4l1kHh6tWr9DtUt25dXL16FTExMSCEYPTo0WAYBmlpafDw8ICOjk6+bdcyMzPh6ekJQ0NDvH37tsDHZhgGly5dwsCBA6nqQFtbGz169MDRo0eL9fo/f/4cMTExVKJuYGCAsLAwtGzZEoQQeHh4lJqRXkUkLS0Nzs7OMDU1LZUWW78jOzsbrq6usLOzK7Dy4fXr11BWVsagQYMKfByZTIZVq1ZBR0cHUqkUM2bMKJH7wvnz56GlpZWvwW5+r2HDhmH//v3o1asXHaeysjIaNGigsF9/f380bdoUANCyZUsauHfq1IlNLrGUCmzQzVJqjB49GlwuF61bt0bfvn0xaNAgLFy4EF++fFEIuuUtwZycnCAWi6GiogItLS3o6enB2toalpaW9Gbr7OyMkJAQ8Pl8iMViuLi4/NT049u3b7Czs4OVlVWh2mzExMRASUkJnz9/LtT5Tpo0CVpaWoX6TEVBJpOhevXqqFevXqkdMzs7mzovr1mzptSOy1KxePr0KcaMGUOdbq2srBATE1MuHZZzcnJw5swZhIWFURMxU1NTDBo0CFeuXCnxhIFMJkP9+vVhZGSU7/0tLi4OwcHB1EV+5cqVJR58v337FoQQbNu2TeF9hmFw4MABVK1aFYQQtG3bttjciJ89e4Z27drRFfX9+/dDJpNh1KhRIIQgJiYGQO6/V4sWLaCsrPzTwL9Pnz4FNk6TyWQ4f/48+vfvT3sW6+rqonfv3jhx4kSxSuq/fPmCpUuXok6dOrRONjQ0FEeOHMGGDRugq6sLVVVVLF68mG3T9wsYhkH79u2hpKSEGzdulPVwKLdv3wafz8eYMWMK/JmYmBgIBAI8evSoUMf68uULwsPDweVyYWtrixMnThRytL/n3bt3GDt2LO08878vgUCAunXrolWrVgD+r8YbAL1HODs7Y+fOnRg6dCgMDAxgbGyMdu3aAQDOnDmjsL9atWr9dLGGhaW4YINulhLn+/fviImJoe6TRkZGcHBwgLW1NQQCAZSUlGBlZUWlw4sXL4aRkRH09fWxatUqcLlc2NnZYdq0aQBAjdIIIXjy5AlMTU2hpKSEsWPH/lRSnpOTg4CAAKiqqiI+Pr7AY8/MzIS+vn6R6vIiIyNhZ2dX6M9VFHbt2vVbF9TiRiaToUePHiCEYPHixaV2XJaKh0wmw6lTp9CpUycoKyuDw+HA19cX69ev/217wJIe19mzZxEREUFdd42NjTFgwABcunSpVFfm586dC0IIjh49+svt7ty5g6CgICo/Xr16dYnWWJubm/+0/CcnJwcrV66EoaEhBAIBoqKi8OnTpyId5/Pnz7RFmoGBAVasWIHs7GwwDINhw4ZRyT2QG2z17dsXPB7vp+aYK1as+K2pVk5ODmJjYxEREQFDQ0MQktsKMywsDKdOnSrWdmmZmZnYvXs3goKCIBQKweVy0ahRI6xfvx4pKSl49uwZbQPWqlWrEpMM/03MmDEDhBBs3ry5rIeSh1GjRkEgEODOnTsF2j4tLQ2VKlWiq7+F5datW6hduzYIIWjdujVevXpVpP38irNnz1J/AV9fXwwfPhyLFi3C+/fvFWq8L126hNDQUDRs2BCEEDpfBHLLPQ4cOACBQECTEgzDwM7OTkGm3qhRo3LdrpCl4sMG3SwlyqtXr2Bvbw+RSISOHTvixIkTcHNzg0QiQVxcHN69e4emTZuCy+WCw+EgMjISDg4OiI6OhqenJ6RSKfh8PqRSKa5evQoAVBInry3i8/m/7ecsr+8prBmXvL3Gj71uC0qbNm1KdSW4tGEYBk5OTvD29i7140ZGRoIQgtmzZ5fqsVkqJt+/f8eqVavg5eVF5efdu3fHuXPnSiXIla9o9uvXD0ZGRjT52L9/f1y4cKFMVhbv3bsHsVhMvTEKwq1btxAYGAhCcjtIrFmzpkSC7w4dOsDNze2X26SkpGDChAmQSqVQU1PDtGnTCuzenZ6ejmnTpkFdXR1SqRQxMTHUB4BhGAwYMCDP/WXy5Mm/DKgvXboEoVBIJa4/Ii8dCAsLg76+PjWsi4yMRGxsbLFO9BmGwYULF9CnTx9qSuXo6IiZM2dSuXt2djamT58OJSUlmJiYsEZpBeTw4cPgcrkYNmxYWQ8lXzIyMmBraws3N7cCf6e2bNlSoMTbz2AYBv/99x/09PSgrKyMyZMnF7sJY1BQEPXtsLe3x/Lly+nvdcGCBahZsybMzc3pgoyysjI0NDRgampKWw9GRUWBEKKgeOratSscHBxoy0VCCAYPHswG3iwlBht0s5QYcrMZU1NT2jf2ZzXcISEh8PX1BSG5fRoZhkF2djbs7OxofduYMWOQmJhI2z7Ia7v/+++/X45j48aNIIRg+vTphRo/wzBwdnamvSALi7e3N0JCQor02YrCnj17QAjByZMnS/W4DMNQc6NJkyaV6rFZKjZPnjzB6NGj6X3F2toaEydOxMuXL4v1OPLVl6ioKDoZNDAwQGRkJG2NWFZkZmbCyckJtra2RaplvHnzJlq0aEHl+2vXri3W4HvRokXg8/kFUiS8f/8eYWFh4PP5MDU1xbp16356bWUyGdatWwdTU1PweDz07dtXoRyJYRiEh4eDEIIFCxbQ9//77z/6DMqP/IzTsrOzcfz4cfTu3ZvW6JuYmCAqKgrnz58v9n//J0+eYOzYsbCysqLqiaFDh+apzb5y5QocHR3B5XLRv3//Mm/JVlF4/Pgx1NXV4efnV66DsgsXLoDD4WDmzJkF2p5hGNSpUwdVq1b9o9/w169f0b9/f/B4PFSuXBlHjhwp8r7+l8ePH4PP56NLly500YXP50NXVxfa2trgcrkQiUTo1KkTJkyYACcnJ2RmZuLAgQPo1asXMjMzYWZmBktLS4X9hoWFwcHBgZre/li2WBKr9iwsbNDNUmIEBgZCIpGgcePGaNCgAZo2bYp+/frh1q1b+dZwOzs7QyqVQigUwsXFBW5ubujevTv69u0LQgg8PT1pnabc3XzLli2/HMPVq1chFosRGhpa6BWt2NhYEEJw+PDhIp2/jY1Nodp4VEQYhoGLiwvq1KlT6oZVDMNg7NixIIRg1KhRFcYwi6V8IJPJcOLECYSGhkJJSQkcDgcNGjTAhg0bimyqI3eDHjRoEExNTUEIgZ6eHsLCwhAbG1tuamWHDx8OPp+P69ev/9F+bty4gebNm9Pkxbp164olILl9+zYIITh16lSBP/Pw4UO6Cu/k5IRjx44p/P348eO0xVDLli3x4MEDhb/LZDL06tULhBDaZggAjh49Cj6fj27duuV7j8nMzETt2rVhYGCAFy9e4MiRI+jRowd1na9UqRIGDhyIS5cuFfu//6dPn7Bo0SJ4eHhQBUeXLl1w4sSJPP8O379/R2RkJLhcLhwdHalyjOX3fP/+HXZ2dqhcuTKSkpLKeji/pV+/flBSUsKTJ08KtP3169fB4XAUEk1FJS4uDt7e3iCEIDAwsNhaOUZGRkJVVRV3796FtrY2zMzMMGLECEycOBErVqygJSYHDx5U6OXt6elJ24Tp6upi586dOHv2LDw8PKCtrQ1nZ2cwDEPrwOUvY2Pjv7YNJUvZwQbdLMXOy5cv0a5dO3C5XAgEAvj4+KBVq1bw9/enNYy6urr0Bv9jDff69eshEAgwZ84cALntwI4fP05XHuRyOQ6H81tJ+du3b2FkZAR3d/cCyw5/JDAwELa2tkUO5tTV1Wk94N/M/v37QQjJM8ktLaZMmQJCCAYNGsQG3ixF4tu3b1i5ciU1mVJVVUXPnj1x4cKF336nGIbBtWvXMGTIEJoU1NXVRZ8+fYq9Rrc4OHfuHLhcLiZOnFhs+7x+/TqaNWsGQggqV66M9evX/9F55+TkQFVVtUhjPHfuHA1CGzdujO3bt8PPzw+EENSsWTPfjgs5OTno0qULOBwOVq1aRd+/ceMGpFIpmjRp8tNVwF69eoHP5yMgIIA+nywsLDBkyBBcvXq12O9JGRkZ2L59O5o3bw6BQAAej4cmTZpg06ZNP1UG7NmzB8bGxlBWVsaMGTNKved5RUYmk6F58+aF9oMpS5KTk2FmZgYfH58Cf/+6desGTU3NQhvG5gfDMNi4cSMMDQ2hpKSEmJiYIs3BfuTjx49QVVVFZGQkrl69ClVVVTg6OuYxs/uxznvnzp1UZRQdHU17c3t5eeH169dQVVWFhYUFgFyZ+v+atdnZ2bFKEJZihQ26WYqVW7duwcDAAHp6epg4cSIePXqkUMOdlZWFbt26UfOKNm3awMHBATdv3kSNGjUglUphZmYGa2trJCcnw97eHvfu3aPtU+Q3wzZt2vxyHOnp6ahRowYMDQ2LZA7z7NkzcLlcLFmypEjXIT09HYSQf8Jlm2EYuLu7o1atWmUW9MoNocLDw8vNaiJLxeTx48cYOXIkdZOuXLkyJk2apCA3ZBgGN27cwLBhw2gfZW1tbfTq1avYXaeLk+/fv8Pc3By1atUqkTFeu3YNAQEBIISgSpUq2LhxY5GD70aNGqFJkyZF+izDMFi2bBlUVVXpCvCSJUvyvT/l5OTQrgjr1q2j7z9//hz6+vpwc3PL0/c9IyMD+/fvh6enJ30mWVlZITo6GtevXy/2+6BMJkNsbCx69uxJ609dXV0xd+7cn3brAIA3b95QAzw/Pz88f/68WMf1LzBmzBhwOBzs27evrIdSKI4ePfpbU78feffuHVRUVArl8fA7vn//jsGDB4PP58PS0hIHDhz4o/1NnjwZfD4fjx8/xp07d+i9183NDatWrcK5c+dw8eJFmkAghEBJSQnm5uZQUVGBkpISmjdvDh8fH6xYsQIcDgeOjo4AcmX58t/yjzXerG8MS3HCBt0sxcaTJ0+grq4OQ0NDREREYMyYMVi0aBHu3r2bp4Y7NDQUXbt2BSG5vWjDw8Nx4MABVKtWDY0aNQIhBDNmzMDQoUMxYsQIhbYR9vb2+Pbt20/HwTAMQkNDIRaLi9zPdcCAAdDU1Cyyy/GLFy/+SJpe0Th48CAIIcVax1VYli5dCg6Hg+7du5e71UWWiodMJsPx48fRoUMHKj/38PBAixYtaNtCLS0t9OjRA8eOHSu3gfaPdOvWDVKptNhabf2MK1euwN/fH4QQ2NraYtOmTYX+TY4fPx7q6uqFTqJ9+/YNw4cPh5KSErS1tREcHAwtLS0oKSlh+PDhCs+O7OxstG3bFjweT8GNWu5HYmlpiffv3wPITaTu2bMHoaGhUFNTo4orJycn3Lp1q0QSjg8fPsTIkSOpgsLU1BTDhw//7YqrTCbDwoULoaqqCj09PWzevJlVARWBHTt2gBCCCRMmlPVQikSXLl2gqqqK169fF2j7qVOngsfj4d69e8U6jvj4eOrZ07Rp0yLff9LS0mBsbIzg4GAAub/fsWPHUp+fH1+Ojo5Yvnw5Vq1apVDj3bZtW9o1R1NTE+7u7pgyZQocHBzoZ9u2bUv/v1QqLbBMn4Xld7BBN8sf8/XrV8yaNQvKysp5bnyE5PZTNDc3p6sIP9Zwa2hogMvlwsTEBBYWFli8eDFtYVK3bl1cunSJZizlGc1fZfaB/2vpsWHDhiKdz/fv36Gqqoro6OgifR4ALl++DEIIbt26VeR9VCQYhkHNmjVRs2bNMp3crV27FlwuF+3bt68QQRBL+YZhGNy5cweDBw+mfbTl97QmTZrg7NmzFSaYkbf4W7FiRakd8/Lly1TabWdnh82bNxc4iJaXFclNOH9HVlYW5s+fD21tbYjFYgwfPhxfv34FkBuIjxgxggbi8+fPR0pKCoKCgsDn87Fjxw66n7S0NNSqVQva2tqIi4vDzp07ERISAhUVFXoeAwcOhK6uLjw8PJCRkVH4C/MLPnz4gHnz5sHd3R2EEKipqaF79+44c+ZMga7dnTt3ULNmTRBC0KNHD3z58qVYx/evEBcXB4lEguDg4ArzG/9fvnz5An19fTRr1qxA55CRkQFLS0s0atSo2M+ZYRhs27YNJiYmEIlEGDNmTJG8M1avXg1CCC5dukT326pVK4jFYqxcuRJ37tzB69ev6fj/t8a7atWqEAgEUFVVRVxcHJydneHj44MNGzbQ+/uoUaNQr149+t9qamq4du1a8V0Mln8WNuhm+SPi4uKoDLMgr4CAACxcuBC6uroQCASwtbWFSCRCREQELCwsYGNjg6ZNm4IQguPHj2PSpEkgJLeP6cSJE3+78nzw4ME/bukxb9488Pn8P3KvlLt6y9tV/AscOXIEhJBCt2UrbrZs2QI+n49WrVoVe+sSln+Du3fvYvTo0ahSpQqVG3bp0gWHDh3CvXv3MGLECForWKVKFUyZMqXAq0llwbt376CtrV3gyXdxc+nSJZpMrVq1KrZu3frbADI5ORk8Hg/Lli375XYMw2D79u2wtrYGh8NBly5dfnrvfvXqFVVYSSQS8Pl87Nmzh/49JycHzZo1g0gkgq+vr0KbonHjxuHevXvUOE1fX7/Y+lqnpaVhy5YtCAgIAJ/PB5/PR7NmzbBt27YC18KmpaUhOjoafD4ftra2iI2NLZax/Yt8/vwZFhYWcHBwyFNaUNGQr9b/znRWjjw597Ne9H9KSkoKoqOj6WLMnj17CnVPysnJgYODg4J5a3p6Oho2bAg+n48RI0Yo/P7lNd6ZmZmYNGkSLTmxs7NDWFgYPDw8EB4erhBkHzt2DJs3b6b/bWBgAG1tbTx+/LjYrwfLvwUbdLMUmTt37lCZnfxVt25dzJs3Dw0bNsSCBQswdOhQBWk4IQSamppo3Lgxbty4AScnJxgYGEAkElEjLrkb7siRI0EIQatWrQq0ahkfHw9VVVUEBAQUWV6ck5MDS0tLtGvXrkifl7Ns2TJwudx/SubMMAxq1aoFNze3Ml8Z2L17N4RCIZo2bfrHBi4s/wbx8fEYN24cdbFVU1NDp06dcODAgXyTNzk5OTh27BhCQkIgFovB5XLRuHFjbN68uVx95xiGQUBAAHR1dalUuqy4cOECLR+qVq0atm3b9svg29nZGZ06dfrp38+fP69gmnb79u3fjiE9PR116tShklQPDw8cPXoUmzdvpmUDcnnqhAkT8rich4WFQSAQ4Pz58wU+7/yQyWQ4deoUunbtSgOBmjVrYsGCBfj48WOh9nXs2DFYWlpCKBRi3Lhxxb76/i+RnZ0NX19faGlp4dmzZ2U9nGIhKCgIOjo61OH7VzAMg3r16qFy5colmrR++PAhTcT5+fkVKqA9fPgwCCHYvXs3fS8rKwutW7cGj8cDl8tF06ZNMXr0aEycOBHe3t4QCoUgJLezgdzxX1dXF1OnTkX16tXp757H40Emk+HGjRv0vU6dOsHMzAz16tUriUvB8g/BBt0sRSIpKUlhhdvV1RX379+nf/+xhrtJkyZwdnYGh8Oh25uYmCA7OxvVqlVDw4YNQQjBpk2bAAD29vZQUlICIQRhYWEFCuC+fPmCypUrw9bW9pf13r9DvkL9O2f03zF+/Hjo6ur+0T4qInJJaEllyQvDoUOHIBaL0bBhwyLX5rP83Tx8+BAxMTGwt7enhlsdOnTA3r17CxW4fP36FcuWLUOtWrXoynjv3r1x+fLlMk9ALV26FIQQ7N27t0zH8SPnz5+nbXwcHBywY8eOfIPviIgIWFlZ5Xn/x/Zgjo6OBe6ckJqaigYNGkBJSQl79uzB8OHD8ySOW7ZsiUePHuX7+VWrVoEQxZZiheXevXuIjo6mLeUsLCwwevTonx7zV3z48AGhoaEghMDb2ztPgoCl8AwYMAA8Hg8nT54s66EUG4mJiVBXV0doaGiBtr9z5w64XC5mzZpVouNiGAa7du1CpUqVIBQKMWLEiAI9qxmGga+vL2xsbBQWZGQyGU2c8Xg8qKurQ1tbG9bW1ujZs2eecr8DBw6gR48eCnNTc3NzLFiwAHZ2dvS9Pn36YMWKFSCEoH79+iXuicHy98IG3SxFQl43LZ+oGhsbU1fc+fPnIyQkhAbdVatWBZfLVVjx5nA4qFKlCubMmYNKlSpRuY+Hhwc4HA40NTWxbNmyAk1Ys7Oz0bBhQ2hoaPyx/MfHxwceHh5/tA8gdzXEwcHhj/dT0WAYBnXq1IGLi0uZBxsAcOLECUgkEnh7e+P79+9lPRyWcsDjx48xceJEurohlUoREhKC3bt3F8sK9cOHDzF8+HAYGRlRI7GpU6cWmxS5MDx+/BjKysro0aNHqR+7IJw7d44aLFWvXh07d+5UuG9s2rQJhBDq4/H+/Xv07dsXPB4PpqamWLduXYFrxFNSUlCnTh2IRCJ4enpCJBJRnxB5DTSHw0Hfvn3zVQRcvnwZQqGwSNfy3bt3mD17NpydnUEIgYaGBnr37o1z584V6T7JMAzWrFkDLS0taGhoYOXKleXiflvR+e+//0AIwdy5c8t6KMWOvBa6oOVfffr0gZqaGj58+FDCI8tNho0ePRoikQimpqbYvn37b7/PN27cAIfDydNhZufOnQpJtJ49eyrIzeXzAIZh0LZtW4WuOMbGxhgxYgTs7OywbNkyhRrv1NRUqKqqQk1NDbq6unlalbGwFAQ26GYpNM+ePYNUKqV1cdra2hAIBOjWrRuaN29Os4YGBga4c+cObQnm4eGhEHg7ODigSZMm8PHxoXU0ckOMwtzoo6KiwOPxcPz48T86r1u3boEQgq1bt/7RfoBcOVfDhg3/eD8VkZMnT4IQolArWZacO3cOKioq8PDwoMZKLP8WT548weTJk+Hk5ETvW23btsXOnTuLZOZTEHJycnDkyBG0a9eOys/9/PywZcuWUpGfZ2dno0aNGrC0tCz3vWZjY2NpTaWjoyN27doFhmHw8uVLqoKaMGECVFRUoKamhmnTphX4GiYlJWHx4sUKhpw1a9bEzJkzkZCQgGPHjoHP56NTp06YNm0a1NXVIZVKERMTQ+t53717ByMjo0IZp6WmpmLDhg1o3LgxeDweBAIBWrZsiZ07d/6R/PvRo0f0WrVv377MSwb+Fq5cuQKRSIQuXbr8lQkMhmHQoEEDmJiYFCgB/fHjR6rYKS2ePHlCWw42aNDgt8qN0NBQ6Onp5TmfmTNnKgTePLXaiQQAAQAASURBVB4PLVu2xPz589GvXz/aP/zHbTgcDmxsbJCSkoKAgACaICOE4OLFiwBy3eAdHBzg6uoKPT09tgUfS6Fhg26WQhEXFwctLS0YGRlh+fLlSEpKwocPH6icPDExEbVq1YKDgwP4fD709PTg6uqKli1b4v79+7T1CSEEnp6eSE1NRY0aNUAIQbNmzcDhcLBr164Cj0cu95s3b94fn1uXLl2o7P1P8fT0LLCU62/E29sbTk5O5WbycuXKFWhoaMDFxaVAdW0sFZ9nz55h6tSpcHFxASEEysrKaN26NbZv317q5QZJSUlYunQprT/W0NBA3759ceXKlRL7jYwfPx5cLhcXLlwokf2XBGfOnKFJWCcnJ+zcuROampqQSCQQCASIiooq0O/38+fPWLlyJfz8/MDn8+nEu1+/fnj58iXd7ubNm1BRUYGfnx+ysrIA5LYLGzBgAIRCIQwNDbFkyZICG6fJ6/w7depEE9Oenp5YsmQJPn/+/EfXJjMzEzExMRCJRDA3N/9n2lGWBomJiTAyMkKNGjX+6nr458+fQyKRICwsrEDbz549G1wut0BeCcXJvn37YGFhAYFAgKFDh/40aZiQkECd0P+XFStWQCAQFMjg187ODs+fP0e3bt2wfft2DBw4kP7N0tKS3qOHDRsGMzMzfPjwAUZGRmjevHkJXgWWvxE26GYpMK9fv4aRkRHs7e3ztO2SB92XLl1CpUqVYGBgADs7O3A4HFSuXBkSiQRubm5YtGgRbS3G4XDg6+uLOnXqQFlZGQKBoFBtvs6fP0/lfn86cX3//j2EQiGmTZv2R/uRY2VlhcGDBxfLvioip0+fBiGkUAmUkubWrVvQ1tbO9/vL8neQkJCAGTNm0HZLSkpKaNWqFbZu3VpuXIjj4+MxbNgwGBoa0gnftGnT8Pbt22I7xpUrV8Dj8TBy5Mhi22dpcurUKVSrVk2hhOl3vXI/fvyI5cuXUxdjeV91U1NTqKmp4erVqwrbJyQkQF9fHy4uLvlO6p89e4Z27drRZ9X06dN/+pyRt5WTlxRYW1tj/PjxxVb7ee7cOdjZ2YHH42Ho0KGsR0UxkpGRgVq1asHAwKBMSkBKm7lz54IQUiB3+6ysLNjY2MDHx6fUE+jp6ekYP348xGIxjIyMftprfsiQIZBIJPneP1+/fv3L7jp169bF1q1bacLtwIEDCAoKUtjGyMgIXl5e8Pb2hp6eHkQiEQBg1qxZ4HA4aNq0KTufYCkwbNDNUmA6dOgAqVQKBwcHGBsbw9DQEA4ODhg1ahRatWqFuLg4fPz4ETVr1kRGRgYOHToELS0tmi2Uo6urS29o8fHx4HA4cHd3x/Xr1ws8lpcvX0JPTw+1a9cuFofNsWPHQllZudh6mkqlUsyYMaNY9lVRqVevHqpXr17gmsvS4N69ezAwMECVKlXKdYsnloLz8uVLzJo1i9blisViBAYGYvPmzeVaVp2Tk4PDhw+jbdu2EIlE4PF48Pf3x7Zt2/5otS01NRU2NjZwcXGhk8mKxLVr16h82sHBgQayzs7O2L9/v8LE+/3791iyZAl8fX2pa7GPjw8WLlyIu3fvwsnJCVpaWnnqLz9//owqVarAwsLilxNmeR2stbU1CCHw8fGh/XrfvHmD6dOnw8HBAYQQaGlpISwsDJcuXSq2ACUpKQm9e/cGIQTu7u55jKBY/gyGYdCjRw8IhUIqIf7bycnJgYeHBypXrlygEo0DBw6AEIKdO3eWwujy8vz5c7Ro0QKEENSrVw/37t1T+HtSUhI0NTXRs2fPfD9/7do1BSm5paUloqOjqfGvXJqelJQEX19fhW1r166NqlWr0jlM1apVYWZmBiDXvFcsFkMqlcLc3Jw1V2MpEGzQzfJbvn79inbt2oHD4UAoFEJTUxMCgQB9+vRB586daSsGTU1N3L59G2vXroWlpSVUVFSgo6MDLy8vqKio0P1paGjQm5qHhwd0dHQKtQqVmpoKZ2dnmJqaFks9W0ZGBnR1ddG3b98/3heQa9hDCMH69euLZX8VlbNnz4IQgu3bt5f1UBR49OgRTExMYGlpiYSEhLIeDksReP36NebMmUPdwoVCIZo3b44NGzZUSMO8L1++YPHixbTURkNDA2FhYbh69WqhA7iwsDAoKSkhPj6+hEZbMjx//hwhISHUfG7fvn1gGAbXrl0DIYQ6zDs6OqJPnz7w8fGhBp2+vr5YsmSJguGavb09dHR0cOfOHYXjpKWlwdPTE9ra2r90DJfX+Hbv3h0ymQz79u2DjY0NCCHQ19cHl8uFSCRCcHAw9u7dW6ztlRiGwdatW6Gvrw+pVIr58+f/U+0nS4tFixaBEIJVq1aV9VBKlXv37kEoFCI6OrpA2zdu3BgWFhZlKr0/dOgQrK2twefzMWDAAIUuNbNmzQKXy1XooPMj+/fvp8aJ8peVlRV69eqF5s2bQ0NDg7YQlL+4XC709PSwaNEiALn15oQQTJw4ke63adOm8PLygoWFBczMzP64hITl74cNull+ybt371CtWjWoqalhxowZSExMzFPDXadOHbi7u0NVVRUqKip4+vQp3r9/j/Xr18POzg6bN2+mrpmvXr2iNzeBQACxWFyoDDPDMGjTpg2UlZVx8+bNYjnHNWvWgBBSbO1Wnj59CkLIHxu7/Q34+vqiWrVq5Wq1G8id4Jubm8PU1PSPHe9ZSoc3b95g3rx5qF27Ng20mzZtinXr1v1Rm8Dyxv379zF06FAYGBiAkNx+1vJ77+84dOgQCCFYsGBBKYy0ePjy5QsGDRoEoVAIfX19LFu2TMFXIzs7G8rKymjWrBldVSaEQFVVFZGRkXkSr4mJibCzs4O+vn6eVbGcnBwEBgZCSUkJly5d+umY3r17B2NjY9SsWRMpKSk4fPgw2rdvT0ujBAIBeDwewsLCin2inZCQAH9/fxBC0KJFCwXnZZbi48yZM+Dz+YiMjCzroZQJMTEx4PF4BXLhvn//Pvh8PqZMmVIKI/s5GRkZmDRpEpSVlWFgYID169eDYRhkZGTA3NwczZo1++lnz507R9v0/e4VEBCAr1+/0hpvIDeZyePxFIw3u3btiho1atAuEaampti6dWu5m++wlB/YoJvlp6SmpsLFxQUGBgZ5Moj51XA7OjqCx+NBRUUFtWvXRlBQEFq0aIHMzExwOBxYWVkpGKmJRCKcPXu2UGOaMGFCsa6eMgwDR0dH+Pv7F8v+gNxac0IIbZn2LyO/FsXhCF/cvH79GpUrV4aBgUGFWxX8V0hMTMSCBQvg5eUFDocDgUAAf39/rF27FklJSWU9vBIlOzsbBw8eROvWrSEUCsHj8RAQEIDt27fnu+L06dMnGBgYoFGjRuXGwPBXZGRkYMaMGdDQ0IBEIsG4ceMUygFevnyJ2bNnw9PTk9ZV+/n5YcWKFdi+fTs1patRowYOHz4MhmHob9rIyAgPHz5UOB7DMAgPDweXy/1lz/KsrCx4eXlBW1sbPXr0gL6+PgghqFKlCiZOnIiEhASkpKRg/PjxkEql0NDQwIwZM/7YkT47OxuzZs2CRCKBkZFRufLD+Nt48eIFdHR04OPjUyFLMIqDzMxMODg4wNHRsUDXoF+/fpBKpQVK/pU0L168QKtWrUAIgZeXF+7cuUPbC545c+ann8vKysL69eupueKPL6lUir59+yrM21atWgUlJSWa7PPw8MCrV6/QtGlT1K1bF9WqVYO3tzcAIDw8nO63ZcuWJdYVg6ViwwbdLD9l+vTp4HK58PDwgI2NDSpVqoTq1asjIiICLVq0yLeGW09PDyoqKoiOjsbz588RFBQEAFBXV8fYsWNhaWlJb3KnTp0q1Hh2794NQki+TpVFRW74dezYsWLbp7xP5MePH4ttnxWZRo0awc7OrlzKIxMTE1G1alXo6OiUukMrS/68e/cOixYtQt26dcHhcMDn8+Hn54fVq1cXm+dCRePz589YtGgRNYjT1NREREQErl+/DoZhwDAMgoKCoKmpWe7NoGQyGTZs2AAzMzPweDz07t2bTuQTEhIwc+ZMWp8vFAoREBCA5s2bQ0tLSyGZwDAMjhw5Qrd1dnaGgYEBTE1N8zVdmzp1KgghWLp06U/H9vLlS9SqVYu2vdTV1UW/fv1w7dq1fBMZ7969Q58+fcDj8VCpUiVs2LChSKtc169fh7OzMzgcDsLDw/8q5UZ5IzU1FU5OTjAzM/vnn9FXr14Fl8vF5MmTf7vtly9foKWlha5du5bCyArGsWPHUKVKFfB4PERERMDR0RFubm6/TTru3r0bHA4HDg4O2Lt3L+7evUuD5B/Lk3r37g0LCwuIxWLo6OggLi4Obdu2xevXr8EwDKpUqUK71Ny7d08hiPf19S3WkhOWvwM26GbJg0wmw5QpU2ittoqKCgQCAbp3744ePXrQViiqqqo4duwY/h97Zx0WRfu+/XMLWFoQCUEUFVtRQVABxUCxMLAxULFbMbFRFLs7sbtbsbAT+zFBMRCVbvZ8//Blfl8eiwZ99nMce6iz98x9zbgzc1+9ceNGGhkZ0cjIiNra2nR1dWWRIkX45MkTQelWVVUVitGkVY3MDEFBQdTU1GSbNm1yNHTH1dWVFSpUyFHP0LJlyyiRSJQhRv+fq1evEvjWa7cg8unTJ1atWpV6enpCkSQleUtYWBhXrlzJevXqCXm6jRo14tq1a5V5cv/i4cOH9PLyEjywlSpVEqps79q1K7/F+yVnz54VWri5urry0aNHfPHiBf38/GhjYyNEQLm6utLf358REREkyePHj/80BUihUHDDhg1Czma1atV46tSpdM/0LVu2EAAnTJjw3f6RkZFct26d0KoMAK2trXnkyJEMe0EfP34sFHuqXr06z549m6H9oqOjOXz4cIrFYlauXPmXIe9Kso9CoWCHDh2orq6uLEr3//Hy8qKqqmqG0uuWLl1KkUhUoN6TiYmJ9PPzo4aGhlAv6HdrDYVCQblcTk1NTcpkMrq7u/PKlStMSkrikSNHWKVKFZYqVYra2tqCkdPQ0JBJSUm0s7Nj+/btWbVqVQJId6+XLVs2XZuygQMH5vbpK/nDUCrdStKRnJzMzp07EwD79evHu3fvfpfDXbduXTo4ONDU1JQymYxnzpzhixcvGBAQwLFjxwoFbxYuXMg2bdrw/v376SyAenp634X+/YpPnz6xRIkSrFKlSo62/Xn+/DlFIhFXr16dY8ckyUmTJtHExCRHj/mn4+LiwrJlyxZIbzf5rXKpra0ttbW1/6i+xn8y4eHhXL16NRs2bChUnm7QoAFXr179n/dAZYTk5GQeOXKETZo0EcKvmzdvzr179xY4D8uDBw+EPOUaNWpwy5Yt9PX1ZbVq1dJVnN+6desPvbwREREUiURcu3btd989f/5cKIy4ceNGQXm3t7fn6dOneerUKcpkMnp4eAiKeFJSEg8fPswOHTpQTU2NIpGI1tbWlEql7Nq1a5aNsBcuXBCK4TVp0oQPHjz46djDhw+zWLFilMvlnDVr1n82zDkvSYt2KIjpTvlFbGwsS5UqRXt7+986CpKTk1mxYkXWrl27wKWwvH37VjA+qqqq/taAZWdnx3bt2tHFxSWdoiyRSIRCas2aNeP+/fuZmprKnj17cvPmzVRTU2NwcDCbNGlCNTW1dNfB3t6ejRo1opqamnCMc+fO5fapK/mDUCrdStLRr18/isViuru7c+LEifTz8+OuXbvo7u7+XQ63tbU1VVVVKZVKaWNjw+7du/PTp0+sUaMGixYtSmNjYxYpUoSmpqbCg6xQoUKZKpyWlJTEunXr0sDAIMcrTQ8ZMoT6+vo5nnvTp08fVqtWLUeP+adz/fp1AshUH/a8Jioqig4ODtTQ0Mh06oOSjPH582euXbuWjRo1EhTtevXqccWKFQwLC8tv8f44UlJS6OjoSFNTU86ZM4fW1tZC+6rBgwdnqEhSbhIaGspevXpRLBbTzMyM7du3Z5UqVQj8Xw/1HTt2ZKi1W+XKldmzZ8902548eUITExOWKVNGaAGoUCh45MgR4VpIJBLWqFGDiYmJvHHjBgcPHkwDAwOhSN2sWbN4584dmpqa0tbWNtsVmtMqj5csWZJisZg9e/ZMF/L//v17tmvXjgDo7OysbDWURxw9epQikYjjxo3Lb1EKHAEBAQTApUuX/nbsqVOnCIDbt2/PA8kyT1qbP5FIxP79+/80Jalnz56sWrUqP336RH19fZYvX56rVq3i8uXLuW3bNgYHB6cbf+TIEXp6elIikbBUqVIEwOLFi7NkyZKsU6cO69Spw9KlS9PT05OjR48WlHiRSJSh66rkv4FS6VZC8ttCIK0f6I8+Kioq7NatG2/cuJEuh9vY2JgVK1akk5MTSXLw4MH09/eng4MDO3fuzC9fvgh9Dx0dHTNdIbx///6USqW8cOFCjp5vZGQktbS0OH78+Bw9LvktZN3FxSXHj/un06xZM1paWqarTFzQiImJYYMGDaimpsYTJ07ktzh/BV++fOH69evp4uJCqVRKkUjEunXrctmyZb/skazk98yePZsikSidN+X+/fscOXIkDQ0NCYBVqlTh/Pnzc6S9YkaJioqit7c31dTUhErDAKihocH27dtz9+7dmY5a6tevH8uWLSv8++HDhzQyMmL58uV/WNzp1atX1NPTE7xOaZXHjYyMOHz4cN65c4cKhUIonGZoaCgo7jlBYmIiFy1aRH19fcrlco4fP54LFiygjo4ODQwMhMrLSnKfp0+fUkdHh82aNVOmff2EPn36UFNT8ztl80e0aNGCxYoVK7DFwnr27El1dXVqaWmxcOHCXLNmzXf/7/Pnz6eamhpTUlJ4+fJlymQy2tnZpesW8L/53WPGjOHMmTOF58jAgQNZrVo1Vq9eneS3NaWGhgZnzJjBly9fCnUh0j5z5szJm5NXUqBRKt1KePLkSSF35XcfqVTK3r1709zcnCYmJtTS0mLXrl0JgNOmTRN6XVtbW9PDw4N169almpoaT548mWm5li9fTgBctWpVTp8y58+fT5lMlitFh+zs7Ojh4ZHjx/3TSeu3u2nTpvwW5ZfEx8ezadOmVFFR+WWVYyU/JyIighs3bmTTpk0pk8koEono6OjIJUuWFIjqt38D9+7do4qKCkeOHPnD75OTk3n48GG6ublRJpNRKpXS1dWV+/bty7Xw88TERI4fP57q6urColNTU5OdOnXi3r17s7VI37x5MwEwPDycQUFBNDAwYOXKlX8YIfHy5UsaGxsLCreqqir19PQIgHXq1ElnpBg8eDClUmmmO2lklIiICHp6egrXo2bNmsp7IA+JjIxk2bJlWaZMGaFGgJLviYiIYNGiReni4vJbY9CzZ88ok8k4derUPJIuc4SGhlJdXZ0DBgxgly5dhLSWGzduCGPSPPb//PMPSXL8+PFC9FWrVq148uRJbt68mZUrV2a1atVYsWJF4RmiqqpKY2NjHjx4kGXKlKGjoyOtra0pFosFpd3R0fG79fORI0fy5XooKTgole7/OIcPH07XPiGtLYuDgwOXLVvGlStX0tDQ8Dur3dKlSxkQEMBJkyaxbNmy1NbWprm5OZOTkxkVFUVNTU2WKFGCqqqqWcppCQgIoFQqzZVCFCkpKSxRogTd3d1z/NgkWbx4cY4ZMyZXjv2n06JFC5YqVapAe7vJb8pD69atKZVKlfl/GSQyMpL+/v5s3ry5UITR3t6eixYtKvAVtf804uPjWalSJVaqVClD4dDh4eFcvHixUMSscOHCHDJkSI4Uk1IoFLxz546g3APf+li3bt2aBw4cyHYrrTRevnxJAJw/fz719fVZtWpVhoeHC98nJibywIEDbNWqlfC+ql27Njdt2sTo6GgqFAoeOHBAKIDk5OTEcePGEQCXLVuWIzL+m/j4eHp7e1Mmk9HCwoKNGjWiSCSipaUl9+7dq/R05zKpqals3rw5dXR0Mh1l91/k4MGDBEB/f//fjvXy8qK6unqB7SM/YcIEqqqqMjg4mBcvXmTlypUpEonYu3dvhoeH8/379wTAvXv3kvxWdyIt5STNWPe/H21tbfbv31/oZJDWwzs8PJzJyck0MTGhhYWFMH9aCsn/fmxtbfPrcigpICiV7v8wjx49EkJl0qrJhoSEkPy+D7ehoaGQB5f2adSoEcPCwtisWTNqaWlRLpezTp06LF++PEUiEXV1dbPkPXj58iX19fVZr169XCkuk9bSKzcqcKZVxVywYEGOH/tv4Pbt2wTADRs25LcovyU5OZmdOnWiWCzO0CLkv0hUVBS3bNlCV1dXoXp0rVq1uGDBggK7GPsbGDFiBFVUVLLU5i4oKIgjRoxgkSJFCIBWVlZcsGBBpnLqFQoFb926xbFjx9LU1FR4J5iYmHDRokXZzov+2ZyFCxemqqoqbWxs+OXLFyoUCl65coX9+/envr4+AVBHR4cymeynUSoKhYL79u0TummYmJjkePoS+a1Se+nSpSmTyThx4kTB+HD37l02atRIMAooCzfmHt7e3hSJREoPYybo2LEj9fT0fpuOEhkZySJFirBz5855JFnmiIqKYpEiRditWzeS397nixcvpo6ODvX09Lhs2TLq6+sL3vqUlBRqaGhwxIgRVFNTY/369bl//37u2bOHZ8+e/a7uxJEjRzho0CAWLlxYSJ+pUKECyW+tD8VisfBcLF++vPD3o0eP5ul1UFKwUCrd/2G6desmPAhKlChBV1dXtmnThgMGDGDjxo0ZFBSUrg/30aNHhXZhAIRiaT4+PhwzZgyLFy/O5ORklilThjo6OmzZsiXd3d3Zo0cP9uvXj0OHDuWoUaM4YcIETps2jX5+flywYAGXL1/OtWvXcvPmzdy0aZNQqG3fvn0MDAzkjRs3GBQUxCdPnvDVq1d89+4dw8PDGR0dzcTExEx7CxwdHWlvb58r1zQyMrJAFxkpCLRq1YolS5b8I6r1pqSksEePHrlS5f5PJTo6mtu3b2fr1q0Fj4CdnR3nzZsnGO2U5B5nz56lSCTi7Nmzs3WcpKQkHjx4kK1btxbCz1u2bMn9+/f/8N5UKBS8fv06R40aRQsLC8Gjnfb+OHz4cLbk+R2XL1+mVCqllpYW79y5wylTpgiKc9GiRenl5SUYyQ4cOPDLY338+JFmZmYsXbo0K1asSOBbX93AwMBsyxkeHk4PDw8h0uPhw4c/HHfy5EmhqFybNm2EMFclOcOuXbsIIEM9qJX8H2FhYdTX12f79u1/O3b16tUEkKniuHnJsmXLKBKJ0kX0fPz4Ubg/NTU1Wb9+feE7R0dHurm5cd++fZRIJGzatGm6uiP/zvGeOnUqzczMCIDDhg0T0gr79OkjRJCqqqpy6dKlwrpZXV2d9+/fz4OzV1IQEZEklPznCA0Nhbm5OUQiEVJSUiCXy5GUlIQaNWrgw4cPePXqFdTU1FCyZEl4enpi7969sLKywv379xEYGIikpCQAwK1bt9C7d29Uq1YNly5dgoODA9asWQM7OztoaGggMTERSUlJP/zzf/+empqarfNRUVGBqqoqVFVVhb//6M+EhARcuXIFNWvWRMmSJX869lfH+dV3b968gaOjI44ePYr69etDJpNBJBLlxH/ZX0NQUBCqVKmCtWvXokePHvktzm9RKBQYOHAgli9fjsWLF2PgwIH5LVKeExsbi6NHj2Lnzp04cuQI4uPjYWNjg3bt2qFt27YwNzfPbxH/E0RGRqJSpUqwsLDAmTNnIJFIcuS44eHh2LZtGzZs2IDbt2/DwMAA7u7u6NatGxISErBr1y7s3r0bwcHB0NPTg7GxMZ48eQJjY2P4+PjA3d09x2T5EZcuXULjxo0hl8vx+fNnkISmpibc3Nzg7u6OunXrYv78+fDy8sKKFSvQp0+fnx4rOTkZDRs2xJMnT3Dr1i0YGxtj3759mDx5Mh48eABnZ2dMnjwZNWvWzJSMJLFlyxYMGzYMKSkp8PPzQ8+ePSEWi3+6j0KhwJYtWzB+/Hi8f/8effv2xcSJE2FgYJCpuZWkJygoCDVr1kTz5s2xbds25Ts4k2zduhWdO3fG/v374erq+tNxqampsLa2hoqKCq5cufLL33p+kJycjIoVK6J48eI4ceJEuu+uXLmCFi1aIDw8HD169MDMmTMxa9Ys7N69G69fv8a+ffvQtm1biEQiuLm5wdPTEyEhIZg7dy7EYjFiY2MREhKC5ORkyOVyGBoa4vz580hNTUXv3r1x+vRpAEDnzp2xYsUK6OrqIjU1FXK5HLq6urh69SqKFSuWH5dFST6iVLr/g3z9+hU2NjYIDg5Gt27d4OnpCQsLC3h5eWHkyJHQ09NDxYoVYWVlhYCAAJQpUwYPHjzApUuXsGTJEjx8+BBPnjwBAAwcOBD37t1DcnIy3rx5g9DQ0CwpU6mpqfD29sasWbOwceNGODk5faeY/0ppz+iYwMBAfPr0CbVq1UJKSkqG5sgpg0BmlPfsKv8ZGZOfBgE3Nzfcvn0bT58+hUwmyxcZMgNJjBw5EvPmzYOfnx+8vLzyW6RcJy4uDseOHcPOnTtx+PBhxMXFoXr16oKiXaJEifwW8T9Hly5dcPDgQQQFBeWaoePu3buYOXMmDh48iPj4eACApqYmWrZsCRUVFezatQsikQjjxo3D4MGDIZfLc0UOAEhMTMSsWbMwdepUKBQKAN/uxSlTpmDkyJFQV1cH8H9Kwvjx4+Hj4/PLYw4ZMgTLli3D2bNn4eDgIGxXKBTYu3cvpkyZggcPHqBRo0aYPHky7Ozsfivnixcv0K9fP5w6dQrt27fHggULYGRklOHzjI+Px+LFizFjxgwoFAqMGTMGQ4cOFc5PScYJDw+HjY0NdHV1ERgYqLyGWYAkmjdvjjt37uDhw4fQ1dX96dgLFy6gTp062LRpE7p06ZJ3QmaQ/fv3o1WrVjhx4gScnZ3Tfbd06VIMHjwY2traAICWLVtiw4YNCAsLg4GBAfr374/ly5dDKpUiJSUl3b7FihVDr1690LlzZ5QoUQKenp5wcXHB0aNHcfHiRTx79gwAEBgYiFq1asHAwADh4eEoVqwYFAoFatSogT179uTNRVBSYFAq3f8xEhIS4OzsjPv37+PIkSOoVauW8F337t0xcuRI9O7dG/fu3UPlypVRsWJFrFmzBsbGxmjYsCG+fPmCRo0aYdCgQQC+LcaGDBmC6dOnQyqVYtOmTejYsWOm5dq5cyfat28PX19fjBkzJsfO93/58OEDihUrhpkzZ2L48OEZ3i81NRVJSUkZUuzPnDmDmTNnYs2aNZDJZNkyEGTku3+/CDLL75T23FL+37x5g06dOmHq1Kno3Lnzd2MKYoQASUycOBE+Pj6YOnUqvL29C5yM2SU+Ph7Hjx/Hzp07cejQIcTGxqJq1aqCol2yZMn8FvE/S9ozMjcWt6mpqbh8+TJ2796NPXv2IDQ0FEZGRqhWrRoiIyNx+fJlkIRIJEKzZs2wcuVKGBsb56gMaZBEYGAgNm/ejC1btiAmJgZaWlqYMGECOnbsCEtLS0ybNg0jRowAAJw9exaNGzdGp06dsH79+l/ek5s2bUK3bt2wdOlS9O/f/4djFAoF9uzZgylTpuDhw4do3LgxpkyZgho1anw3Njk5GXPnzsWUKVNgaGiI5cuXw8XFJcvnHh4ejunTp2Pp0qUoUqQIpk2bhq5du+ZqFMHfREpKCho1aoSgoCDcvHlTGYGTDd68eYMKFSqgQ4cOWLVq1S/HtmvXDoGBgXj69Ck0NTXzSMKMQRIODg6IiYnBrVu30t1LFy9ehKOjIy5cuAB/f3+sXr0aADB79myMHDkSz549Q9myZQWDn6enJ1q3bg0DAwNYWVmlO9bRo0exfPlyHD16VBhfqlQpVK5cGeHh4bh06RIUCgXKli2LgQMHYtCgQVi3bh26d++edxdDSb6jVLr/Y8yYMQOTJ0+Gl5cXpFIp4uPjoaOjg1q1amHjxo0YOXIkjIyM0Lx5c5w7dw4BAQHo2LEjIiIiMGzYMFSvXh3Jycno378/4uPjUbp0adSrVw/btm3Dw4cPYWpqmmmZbt++DXt7e7Rs2RJbtmzJNUVm0qRJmDdvHt6+fQsdHZ1cmWPJkiUYMWIEEhIS8kQhS01NRXJyco4o9tlR/n80JicMAjnl1c/J6AI/Pz9MmDABY8eOxfTp0/94xTshIQEnTpzAzp07cfDgQcTExKBKlSqCol26dOn8FvE/T2hoKCpVqoQGDRpgx44dOfKbS01NxcWLFwVF+8OHDzAxMYGbmxvc3NxQs2ZNnD59GqNGjcL9+/dhZWWFxMREPH78GEWKFIG7uzu6d++OSpUq5cAZAs+ePYO/vz82b96MV69ewcDAAF++fEHt2rVx4sQJqKmpAQDq1q0LfX197NmzB0FBQXBwcEDNmjVx6NChX0bN3Lp1C/b29ujUqRPWrFnz22uoUCiwa9cuTJkyBY8fP0aTJk0wefJk2NjYAACuXr2K3r174+HDhxg2bBimTJkCDQ2NHLkWL168wPjx47Fjxw5UqlQJfn5+aNSo0R//rMlthg4diqVLl+L06dOoU6dOfovzx7NixQr069cPZ86cQb169X467vXr1yhbtiy8vLwwbdq0PJQwY1y5ckVY43bt2lXY/uXLF+jr62Pbtm3o0KEDrl+/jtq1ayMlJQVdu3bFrFmzsHTp0nTRMw0aNMDAgQPRtGlTxMfHQ0tLC1++fEHbtm1x584dfP36FQAgEolgZWWFc+fO4fnz56hevToAwMnJCfv374exsTHi4uIwevRo+Pr6Ku/t/whKpfs/xOPHj2FjY4Pk5GQkJSVBJBLB1NQUsbGx+PLlCyQSCYoVK4bTp0/j0qVLGDVqFEgiKSkJmpqaSExMxPv37+Hv74/evXsjOTkZZmZmePPmjWAZzCwfP36EtbU1jIyMcOHChVwLVUxISECxYsXQoUMHLFq0KFfmAABvb2/4+/sjODg41+b4U1AoFL9UzJ88eYJOnTphyJAhaNiwYa4p/z/6M7sGAYlEgtTUVKipqUFXVxdqamp5rvz/6DsVFZUMvbwTExNx6tQp7Ny5EwcOHEBUVBQqVaokKNplypTJ1vVRknMoFAq4uLjg/v37uH//PvT19bN8rJSUFJw/fx67d+/G3r17ERYWBlNTU7i5uaFt27aws7ODWCzGnTt3MGrUKJw+fRr29vaYM2cObG1tAXwLP9+4cSM2b96M8PBwVK9eHd27d0fHjh0zLVt4eDi2b9+OzZs349q1a9DW1hYiKiZPnozGjRtj586dUFVVFfYZP3481q5di2vXrqFWrVowMjLCuXPnoKWl9dN5Pn36hOrVq8PY2Bjnz58XFPiMkJqaKijfT548gbOzM3R0dLB7925Uq1YNq1evRtWqVTN13hnl2rVr8PLywsWLF1G/fn3Mnj071+b609mwYQM8PDywZMkSDBgwIL/F+StQKBRwcnLC27dvcf/+/V+G6nt7e2Pu3Ll4/PgxihcvnndCZpC2bdvi2rVrePr0abp1ZtGiReHh4SEo1o0aNcL79+/x7t07Ya2QkJDw3fEMDAygra2N0NBQJCYm4n9VKYlEAnNzc+zfvx+VKlWCp6cn1qxZAwBCzQl3d3cEBgbi9evX8Pb2LpDGCiU5j1Lp/o9w5MgRuLm5QUNDA71790a7du2wYMECjBw5Evr6+mjatCk+f/6Mt2/fonDhwrh//z5GjRqFOnXq4O3bt9DU1MTw4cPh4OCA9+/f4/nz58Kxu3Tpgo0bN2baUpeYmIh69erh5cuXuHnzJooWLZrTpy2wbt069OrVC0+fPs1Vz12vXr0QFBSE69ev59ocfxMdO3ZEYGAgnj17lm5hndv8yiCQUcX+7Nmz2LNnD6ytrdGwYUMh4iC7BoLsGgRkMtkPFXOZTIbExERERkbiy5cvSE1NhZaWFszMzGBhYQEDA4NcjRzIqEFASXqWLFmCQYMG4fjx42jUqFGm909OTsa5c+ewa9cu7Nu3D+Hh4TA3NxcUbRsbG6EAUnBwMCZMmIDNmzfD0tISs2bNQosWLX74/5aUlISjR49iw4YNOHLkCEQiEVq0aIHu3bujcePGkEqlP5QnISEBhw4dgr+/P44dOwYAcHFxQZcuXdCsWTMcO3YM7du3h6urK7Zu3QoVFZV0+x89ehRNmzZFqVKlkJKSgitXrvwyfzo5ORnOzs549OgRbt26laVoLOCb8j1y5EgsWbIEKSkpqFChAtatW/fDsPOchCQOHTqE0aNH48mTJ3B3d4ePj48ydPp/uHbtGhwdHdG1a1esWrVK+ZzJQf755x9UqVIFAwYMwJw5c346LiYmBpaWlrC3t8fOnTvzUMKM8ezZM5QvXx4+Pj4YPXq0sN3Z2Rnq6urYv38/AGDixIlYuXIlDh06BAcHByQlJUFfXx/9+vXDrFmzkJyc/Mt56tati2XLlmHu3LlwcXGBlZUVLC0toVAoIJfLERYWBk1NTXh5eeHAgQPo1asXRo8ejYsXL8Le3j43L4GSAoBS6f4PcPr0abi4uMDFxQXbt28XrJVpOdyxsbFo37698HB59OgRtLS0oKamBoVCgYoVK8LX1xeOjo6YM2cO9uzZg/PnzwP4Fipz6tSpTOeckUTPnj2xdetWnD9/XvCi5AYkUaVKFRQvXhwHDx7MtXkAoHnz5hCJRLk+z9/CkydPUKFCBSxZsgT9+vXLb3EyTZoxp1u3blizZk2O5F6mGQRywqsfFxeHf/75Bw8ePMCzZ8+QmJgIHR0dmJmZwdjYGGpqapmKLsgpg0BeFgzM6JiCuFB/8uQJqlatil69emHx4sUZ3i/NKLRr1y7s378fX758QYkSJdC2bVu4ubnB2to63flGRERgxowZWLRoEXR1dTFlyhT07Nnzp4rzvwkLC8PWrVuxfv16BAUFwdDQEF26dEG3bt1QsWJFKBQKXLx4Ef7+/ti1axeioqJga2sLd3d3tG/fXqjWvWPHDnTu3Blt27aFv7//D+d/9+4dihYtCk1NTdy8efO3URlpIcf/LpyWGd6+fYuBAwfiwIEDaNq0KRo2bIhly5bhn3/+QYsWLTBp0iRUq1YtS8fOKCkpKVi7di0mTZqEiIgIDB48GGPHjkWhQoVydd6Czvv372FtbQ1zc3MEBATkqfH2v4Kfnx/Gjh2LK1eu/NLIlFYz4fz583B0dMxDCTPGoEGDsGnTJrx48QKFCxcGAAwfPhwHDx4UHEmHDh1CixYtoK2tjaioKLRq1Qrv37/H1atXUb16ddy6dQvAt/BxsVgMmUwGAwMDtG7dGn379kXZsmUBAOvXrxfqRqR5ymUyGezs7CCVSlG8eHFcv34d9+/fR+nSpaGnp4fz58/namFKJfmPUun+y4mMjIS5uTmsra0xfPhwREVFQVVVFWZmZliyZMkPc7i7deuGxMREuLi4YNu2bXjy5Am6deuGN2/eoH379li1ahXi4uKgoaGBDx8+ZKlwxsKFCzF06NDvcmxyg7Nnz6J+/fq/zUvKCWxsbGBlZSUU5FDye9zd3YW8p8yEfRYUtm7diq5du8LNzQ3+/v75Xo09OTkZAQEB2LlzJ/bt24cvX76gdOnSaN++Pdq1a4eKFStmWcH8t0EgP2sG/PvP33kgfsfPDAL5lTYAfAt1jI2Nxe3bt39bhTkxMRGnT5/G7t27sX//fkRERKBUqVKCol21atXv/t8TExOxfPlyTJs2DQkJCfDy8sKIESN+Gar9O+7evYsNGzZgy5YtCA8Ph5GRERITE/H161eUKFEC7u7ucHd3h6WlZbr9Nm/ejG7duqFz585Yt27dDxVuhUKB9u3bY8+ePXB1dcW+fft+KYu/vz+6du2a5ZDj1NRULFu2DOPGjYOWlhYWLVqENm3aCK02t2/fjqlTp+LZs2dwdXXF5MmTYWVllel5MkNMTAzmzp2L2bNnQ1VVFd7e3ujfv/9/UtlMTExE3bp1ERISgps3b+Zacb//OikpKbC1tUVSUhJu3br1XfRJGgqFAjVr1kRycjJu3LhR4AoAfvr0CSVLlkTPnj0xf/58AP9nOI+JiYG6urpQXA0AOnTogK1bt4IkNm3aBC8vL3z9+lXoaKOmpobevXujX79+KFu2LKKjo6GlpYW3b9+iZcuWuHv3rjC2dOnS0NLSwq1bt3DixAn06tULZcuWxalTp7Bw4UIMGzYMFSpUwMmTJ5W/478YpdL9lzNq1CjMmTMHampqQvuXNHR0dNC/f3+MHj0aBw4cwNq1a2FlZYUHDx7AxcUF48ePx9u3b2FgYAA7Ozu8fPkSJBEeHg7gm9UwK/nRJ0+ehIuLC4YPH47Zs2fnyHn+ihYtWiA4OBh3797NdW9WsWLF0K1bN2V+Tib4559/UK5cOSxcuPCP7YG9Z88edOzYEU2bNsX27dvzfAGckpKCc+fOYefOndi7dy8+f/6MUqVKoV27dmjXrh0qV65cID25OYlCocixooI5XZQwJwwCP1LMpVKpkDKQthjU0NCAmZkZSpQoAUNDwx8q+ioqKnj06BGOHj2KL1++oG7dumjfvv1Px//MQCCTyb7rzfvx40ds374dmzZtwu3btyGTyZCSkgKJRAJXV1f06NEDzs7O6ZTqDRs2oEePHvDw8MCqVat+uFgniWHDhmHx4sWoX78+3r9/j/v37//0mt2+fRu1a9dGx44dsXbt2kz//u/du4fevXvjxo0b6Nu3L3x9fX9YgDMlJQVbt27FtGnT8Pz5c7Rq1QqTJk1ClSpVMjVfZnn//j0mT56MNWvWwNzcHDNmzEC7du0KXK/k3IIkevXqhS1btuDChQu5Hub/X+fevXuwtrbGhAkTMHHixJ+OSytatmbNGvTs2TMPJcwYacWEHz9+jJIlS+L69euwtbXFzZs3oa6ujtq1a+Pr16+wsLDA06dP0z2nIiIiMGbMGKxcufK741auXBkA8Pz5c8TFxaX7TiqVomrVqpg7dy4cHBywefNmdOnSBRs2bEC3bt0QEREBPT096OjowMDAAJcvXxY88Ur+LpRK91+KQqHAyJEjMX/+fBgaGkIqleLr1684c+YMSpUqBW9vb2zYsAGJiYnQ19fHsWPHULlyZbi5ueHhw4coU6YMAgICMGXKFHh4eKBBgwZ4+PCh0AqhTJkyuHz5MvT09DIl1z///ANbW1vY2dnh8OHDuW4JffbsGcqUKYO1a9fCw8MjV+ciCVVVVcyfP19ZyCWTdO3aFWfOnMGLFy/+SG838K1uQps2bVCvXj3s2bMn18PEUlNTcf78eezcuRN79uxBeHg4LCwsBEXbysrqr1e0/xT+1yCQEeU9KCgIY8eORevWreHi4pLuu9jYWDx69AiPHj3C8+fPkZycDF1dXZiamsLY2BiqqqrfzfW/f4+OjkZkZCRSU1MhEomQ3SWATCYTWvylFekEAC0tLRgYGMDAwAASiQTh4eF4//49oqOjoaamhlKlSqF8+fIIDw/H2bNnUbVqVbRo0QJyufyHBoZjx45hw4YNGDJkCDQ0NODr64vz58/DwMDgO4NAZGQk7O3tYWhoiAsXLmTqmRIXF4fJkydj3rx5KFu2LFatWpWutebPSElJwZYtWzBt2jS8ePECrVu3xqRJk4TFeG7x+PFjjBkzBgcPHoSNjQ1mz579n6jcnVbrIC+i5ZR8w9vbG35+frhz5w4qVKjw03Hu7u44deoUnj17JvTALijExcUJuefbt28XWhJOnz4dc+bMQWRkJPT09FChQgWcO3fuh8e4efMmXF1d8e7du1/OJRaL0bZtW8hkMrRs2RJt2rRBUlISLCwsEBMTg/fv3wvrBD09PfTq1Qvr1q1DpUqVEBAQkNOnrqQAoFS6/0JIwtPTE+vWrcO8efPQp08fxMTEwMvLCyNHjkThwoVRoUIFqKioQEdHB+/fv0dsbCyMjIxQpkwZHDp0COrq6jA1NUVERAQqVaqEypUrY82aNVAoFChZsiROnz6d6QqVkZGRQu721atXoaurm/Mn/y8GDRqEHTt2ICQkJNeVubT2E7t27YKbm1uuzvW38ezZM5QrVw7z5s3D4MGD81ucLHP69Gm0aNECNWvWxMGDB3OshVAaqampuHTpEnbs2IE9e/YgLCwMxYsXFxTtatWqKRXtP5yYmBhYWVnBwMAAFy9ehFQqRVxcHI4dO4Zdu3bh8OHDiI2NRaVKlYT2XuXLl//tcR89eoQxY8bg0KFDsLa2xuzZs1G3bt1fGgR+ZRhISEhAUFAQAgMDcefOHSQmJsLMzAwVKlRAqVKlIBaLf7h/eHg4QkJC8PHjR6FGgFwuh76+PlJTU9ONzW6EgEQigZqaWoZD+r98+YK7d+8iPj4e1atXh42NDdTV1TOVNiCRSHDmzBmsW7cO7969Q+PGjTF8+HBYWVmlizTIaY/0+fPn4eXlhRs3bqBZs2aYNWtWhn4XfyIBAQFo2LAhBg0aJIQJK8l9EhISULVqVejo6CAwMPCnTpO3b9+iTJkyGDhwIGbNmpXHUv6e9evXo0ePHrh27Rpq1KgBU1NThIeHIyUlBdWqVUPTpk0xb948fP369af3KUnMnz8fXl5eQm2UNENmWsSjp6cnTE1NcfToUVy9ehVTp06Fs7Mzzpw5g3HjxqWLiCxUqBDGjBkDU1NTuLu7o3bt2lixYgUqVqyYV5dFSR6gVLr/QhYtWoQhQ4bAxsYGUqkUCQkJ0NHRQVhYGHx9fWFoaIjNmzdj8eLFSElJQZUqVaCjo4ObN2+iT58+uH//Pjp27Ih3795h7dq1CAkJQYkSJRASEgJXV1esXr1aKHyTUVJTU9G8eXNcuXIF165d+y6fLzeIiIiAqakpRowYgSlTpuT6fI8fP0b58uWVVSiziIeHB44fP46XL1/+0cVELly4gKZNm6JKlSo4evRoti39CoUCgYGB2LlzJ3bv3o0PHz7AzMwM7dq1Q/v27b8riqXkz6Z3797YunUrAgMD8fTpU+zatQtHjx5FXFwcrKysBEU7o23d3r9/j0mTJmHt2rUwNzeHr68v2rZtm2Wl78GDB/D398eWLVsQGhqKUqVKoUuXLujcuTNKliyZ4ePMnj0bo0aNgoWFBV6/fg2pVIqWLVuie/fuaNiwIaRSKUji5MmTaN68OVq1aoW5c+ciOTkZCQkJqF27Nlq2bImePXumU9RXrVqFEydOYMSIEShevHiGUgIiIyNx584dhIaGQldXFyVKlEhnNPiRESK7BgGpVJrjNQNUVFTw8OFDHDx4EJ8/f4aTkxM6d+4MIyOjTB2nIIeov379GtbW1rCyssLx48czXOxPSc4QGBgIBwcHzJs3D0OHDv3puKlTp2L69Ol4+PAhSpUqlXcCZoDU1FRYWVlBT08PixYtgo2NDVJSUoT1261bt9CwYUM8fvxYKIz2M44dO4YWLVrA3t4e/v7+MDExgVgsFvK7AWDs2LEoXLgwxo8fj6SkJOjq6uLBgwcYM2YMjh07hpEjR2Ls2LFYu3YtOnXqBGNjY3z9+hVaWlrYu3cvGjRokBeXRUkeoFS6/yISExMxe/ZsTJ48WSje8CPs7e3x+fNn3LlzBwEBAejZsydu3LiBokWLonv37li9ejXq16+P6tWrY/v27XB3dxeqlrdq1SpLso0aNQpz587FsWPH4OzsnNVTzBRz587F2LFjERIS8suWMjlFQEAA6tWrh3/++SdX25L9rbx48QJlypTB7NmzMWzYsPwWJ1tcvXoVjRs3RpkyZXD8+PFMVxhWKBS4cuUKdu7ciV27duH9+/cwNTVF27Zt0a5dO9ja2ioV7b+QnTt3on379rCyssKTJ0+QkJCAatWqoW3btmjTpk2mnisxMTGYM2cO5syZA1VVVUyYMAH9+vXLUr2B9+/fY+vWrfD398e9e/egr6+P9u3bo0uXLln6Lfr5+WH06NEYM2YMZsyYgY8fP2LLli1Yv349Hj58CGNjY3Tp0gW1atVC165dhXSk/y1S2KpVK0RGRuLs2bPCtrRcycWLF2eoPgRJrFu3Dl5eXhCLxZg3bx66dOmSofMhmaGigrGxsTh27Bi2bt2KsLAw2NraomnTpihcuHCu1RVIC/HPKv82CORmwcDMjElOToaDgwOioqJw48aNbPWsV5J1Bg8ejLVr1+L+/fuwsLD44Zi4uDiULVsW1apVE9pxFSSOHTuGJk2aQENDA/Hx8RCJRAgNDYWhoSEiIiJQqFAhbNq0CV26dPntsQICAtCsWTMoFAp069YN/fv3x9u3bzFhwgSoqamBJL58+YKnT5+icOHCKFeuHGrXro1Bgwbh5MmTOHDgAI4ePSrUUBo9ejTmzp2L1NRUyOVynDt3Tlmz4C9BqXT/JXz9+hUtW7bEhQsXvvtOIpH8UAkvWbIk5HI53r59iypVquD8+fMoXrw4Xrx4gfHjx+Pu3bu4c+cOPn78iPnz5//Sqvkr0irIZucYmSUlJQWlSpVCnTp1sHHjxjyZc/v27ejYsSOioqKyVf33v0zPnj1x5MgRvHz58rfVmgs6t2/fhrOzM8zMzHDy5MnfRocoFApcu3ZNULRDQ0NhYmIiKNp2dnYF2gOlJGtERkbi0KFD2LJlC44fPw4AsLa2Rrt27dCmTZufLmp/RkpKCtasWYPJkycjIiICQ4YMwZgxYzJt+ImJicH+/fvh7++P06dPQyaToXnz5ujSpQsaN2780wrGv8PHx0coxjR58uR0Ci5J3L59Gxs2bIC/vz8iIyOhrq6O6dOno1u3bunOYc6cOUL7LJlMJhRO69ChA9atW/dbxfnJkyfo06cPLly4gK5du2Lu3Lm5WrwoKSkJGzduhI+Pj9AJZOLEiShXrlyOz5VmEAgLC8Ps2bOxcuVKaGtrY8CAAWjRogUUCkWuFAzMyHfZNQgA36pGy+XyfFP+fzbmv/J8jomJQYUKFVC6dGmcOnXqp/da2pro9OnTqF+/fh5L+Wtu376NGjVqQKFQQEdHBxEREYiIiBCKJZYpUwaNGjXKcLHg0NBQVKxYESkpKYiJiYFEIoGqqiri4uIgEong6OiIoKAgVKhQAQ4ODpg+fTpEIhHWrVuHUaNGwcXFBf7+/gC+FZb83xpE5ubmePbsWb53RlGSfZRK919AfHw86tevjytXrgD4VryhadOmcHd3x+HDhwUrfs2aNaGrq4s3b94I+w4dOhR6enro0qULatSogU+fPiEwMBBTpkzBxYsXER8fjwULFmDIkCFZku3atWuoU6cOOnXqlKUKslllz549cHNzw+3bt1G1atU8mXPBggUYP348YmJilF7ILPLq1StYWlpi5syZGDFiRH6Lk20ePHiABg0aQF9fH6dPn/6uFQhJXL9+XVC037x5AyMjI0HRrlWr1n9mIfdfIiIiAgcOHMDu3btx8uRJJCUloVChQkhKSsK5c+dgbW2d6WOSxMGDBzFmzBg8efIEXbp0wbRp02Bubp7hY6SmpuLMmTPw9/fHvn37EBsbC0dHR7i7u6Nt27bZqsNBEpMmTcK0adMwbdo0eHt7/3RsREQEateujU+fPqFy5co4d+7cd+Hn169fR61atXDjxg2hLWaRIkVw8eLFX9bvSExMxMyZMzFjxgwUK1YMK1asyFOFICkpCRs2bMD06dPx5s0bdOjQARMnTvxtGGt2CAkJwYQJE+Dv7w9LS0vMmjULLVq0yJf3FMlfFvr72Z+7du3Crl274OnpiQoVKuRKt4GciBDIj1aDGRmT0++REydOoHHjxli7di169OjxwzEk4eDgIKRvFJRUgFu3bqFBgwZITExEfHw8+vXrh+XLlyMwMFAomuju7o7nz5/j6tWrGT7u/PnzMXLkSEyaNAlFihRBQkICdHV14eDgAFNTU6SkpEBdXR2enp5wcXFBmzZt0LJlSxw4cABXr14Vah5t2bIF7u7uqFGjBq5fvw7gW3SQl5dXzl8MJXmKUun+Cxg6dCgWLlwIADAwMMCRI0dgY2MDAOjevTtGjhyJ3r174969e6hcuTIKFy6Mw4cPC/tfuXIFFy9eFKq2WlpaonTp0jh69CgOHjyIZs2aZUmu0NBQ2NjYoHjx4ggICMjTNkr29vaQSqU/rT6ZG4wZMwY7d+7Ey5cv82zOv5HevXtj//79ePXqVY4XIssPnj59ivr160NdXR1nzpyBqakpbt68KSjawcHBMDQ0hJubG9q1a4fatWsXuP6mSrLPly9fsH//fuzevRunT59GcnIyateuDTc3NyQlJWH06NHYv38/XF1dM33sa9euwcvLCxcvXkT9+vUxe/bsDBsbSeLevXvw9/fHtm3b8P79e5QpU0bI085swcyfzTFu3DjMnDkTs2bNwqhRo346NiEhAY0bN8b9+/dx+fJllClTBu/fvxfCzx89egQTExN06tQJixYtgq+vLw4fPoyHDx/i5s2bMDMz++mxL168iN69e+P58+cYNWoUvL29861+RGJiItavX4/p06fj3bt36NixIyZMmJDhXP2scOfOHYwaNQqnT5+Gg4MDZs+eLSz0CzJHjhxB8+bN4e3tjalTp+baPD8yCORnq8HcNghkV7Hfs2cPHj58iClTpsDQ0PCHY168eAEPDw9MmDAB3bp1yxODwK+4efMmGjRoAJIgCXt7e9y+fRvh4eFYtmwZevfuDQBYuHAhRo8ejaioqAxH9aSmpqJVq1Y4ffo0duzYgebNm/9w3Pr16zFgwAAYGhri9evXcHZ2Rq9evTB//nzI5XLY2dlhzpw5OHjwIBo3bizst2rVKnh6emb/IijJN5RK9x9OZGQkihYtitjYWEilUlSuXBmJiYmQSqUwNDREbGwsFixYgOLFi6N58+Y4d+4cAgIC0LZtW8TExAAAevTogUePHmHXrl0wMzPD3LlzMXfuXNja2mLv3r1Zkis+Ph6Ojo748OEDbty4kSc51WncuHEDNWrUwL59+9CyZcs8m9fDwwNPnz7F5cuX82zOv5Hg4GCULl0aPj4+v1yc/0m8ePECDg4OiIuLg6amJkJDQ2FgYCAo2g4ODkpF+y8kPDwc+/fvx65du3D27FmkpqbCwcEBbm5uaN26NYoWLYoXL16gSpUq6NChA9asWZOp47948QLjxo3Dzp07UalSJcyePRvOzs4Z8mC+fftWyNN+8OABDAwM0LFjR3Tp0gXVq1fPMS8oSYwcORLz5s37bYqRQqFAx44dcfDgQZw5c+a7Vl0kcfPmTWzYsAFbt25FREQE1NTUkJSUhIMHD6Jp06Y/PO7Xr18xatQorFmzBjVr1sSqVasKTFXgxMRErFu3DjNmzMC7d+/QqVMnTJgwIVeLjZ44cQJeXl64f/8+2rZtC19f30wVwctLnjx5AltbW9StWxf79u37z0b+pBkECoLyn/ZdYmKisI7MDmmh2LldMyAkJARTpkwRiiQuWrQIZmZmaNmyJTQ1NeHq6opZs2ZBRUUFd+7cQb169XDr1i1Uq1Ytw+cSHx+Pzp07Y9++fWjYsCEGDhyIpk2bIi4uDlpaWoiJiUHTpk1x48YNxMfHo1WrVqhTpw62b9+O8+fP4/r163B1dYWDgwP27t2LMmXK4Pnz58LxlYr3n41S6f7DmTFjBsaPHy8skMRiMTp06ABdXV2cOHECz58/h0QiwYABA1ClShUsWrQIHz58QHx8vPDQVFFRgZ2dHbZu3QpTU1OYmJhAKpXi6tWr34XDZgSScHd3x759+3Dp0qVMPbByAnd3d1y+fBnPnj3LU0XGxcUFampq2LdvX57N+bfSt29f7NmzB69evYKmpmZ+i5Ml0jyIO3fuxM6dO/HixQuIxWLI5XIsXboUnTt3LjDhdkpyjrCwMOzbtw+7d+9GQEAASKJOnTpwc3NDq1at0j1TU1JS4OjoiI8fP+Lu3bsZrgURHh4OHx8fLFu2DEWKFMG0adPQtWvX3z7voqOjsWfPHvj7+wvRRy1btoS7uzucnZ1zPGeQJAYPHowlS5ZgyZIlGDBgwC/HDx8+HAsXLsSePXt+azBNq2B++/ZtAN/yfFu1aoXu3bujfv36kEgkIIkdO3ZgyJAhSEhIwKxZs9C7d+8CqbglJiZizZo18PX1xfv379G5c2dMmDAh14pypqamwt/fH97e3ggLC0O/fv0wYcKEXM1rzywRERGwtbWFRCLB1atXC1zPZyXA7t270bZtW2zbtg3NmjX7odIeGhqK1q1bo0mTJvD09MzVmgE/+jM7iEQiyOXyTCn4UqkUd+7cwcuXL5Gamgo9PT1oaGggLCwMycnJUCgUUFFREX7PWlpakMvlePjwIQIDA2Fvb48TJ07A2dkZAwYMwLJlywR5JBIJrly5IkSzKvnDoJI/lhcvXlBdXZ16enqcOXMmnzx5wm7duvH+/ft8//49nZyc2LJlSzZp0oRisZgNGzZkkyZNuHHjRk6dOpWmpqYEQADs0KED586dS7FYTHNzc/7zzz9ZlmvmzJkEwB07duTg2WaM0NBQSqVSzp8/P8/nrlq1Kvv27Zvn8/6NBAcHU0VFhb6+vvktSqZQKBS8d+8ex48fz9KlSxMA9fT02KtXL548eZIhISEsV64cDQ0N+eDBg/wWV0kO8f79ey5dupROTk4Ui8WUSCRs0KABV6xYwQ8fPvx0Px8fH4rFYl66dClD88TFxdHX15fa2trU0tLijBkzGBsb+8t9kpOTeeTIEXbo0IFyuZwikYhOTk5ct24dIyMjM3WemSE1NZV9+vShSCTiqlWrfjt+7ty5BMClS5dm6Pi3b9+mTCYjAF69epWzZs1iuXLlCIBFixZlv3796ODgQAB0c3NjaGhodk8pT4iPj+fixYtpYmJCiUTCbt268dmzZ7k23//+prS1tenr68u4uLhcmy+jpKSksEmTJtTV1c3WekRJ7qJQKNiqVSsWKVKEnz9//uk4X19fSqVSPn78OA+l+ybf+fPnqampSUNDQ4pEIi5evJhPnz5lUFAQb968yWPHjlEmk1FFRYUHDhzgrl27uHnzZpqZmbFWrVqcP38+p0yZwhEjRrBPnz7s3LkzW7ZsSWdnZ9rb27N69eosX748S5YsSVNTUxYpUoS6urqUSqV0dHTkpEmTOHjwYI4YMYJ+fn78559/GBMTQ4VCwZ49e9LHx4dDhgxhQkICa9euTVVVVaamppIkvby8hHV62qddu3Z5eg2V5BxKpfsP5dOnTyxVqhSLFy/OV69eCdvTlO6rV6/S3NycxsbGtLW1ZeHChSmRSCiXy9mkSRNGRkaySpUqwk3ct29fFi9enOXKleOnT5+yLNehQ4coEono7e2dA2eZecaPH08tLa1cXUz+DGNjY06ePDnP5/1b6d+/P/X09PLl/zIzKBQK3r9/nxMmTGCZMmUIgIUKFWKPHj14/PhxJiUlpRv/8eNHVq5cmYULF+bt27fzSWol2SU0NJSLFi2io6MjRSIRJRIJnZ2duXr1aoaFhf12/5s3b1IqlXLcuHG/HZuSksINGzbQ1NSUUqmUgwYN+uUcCoWCN27c4JAhQ1ikSBECYIUKFThz5kyGhIRk6jyzQkpKCj08PCgSibh+/frfjt+2bRsBcOzYsRk6/qdPn2hubi68w7Zs2ULy23kHBgayZs2awrutTJkyXLVqFSMiIrJzSnlOfHw8Fy5cSGNjY0okEnbv3p3Pnz/PtfnCwsI4ePBgSqVSmpqacsOGDUxJScm1+X7H2LFjKRaLefz48XyTQUnGePfuHXV0dNitW7efjomPj2eJEiXo4uKSJzIpFArGxcXx4MGD1NDQoJGREQFwwIAB9Pf359KlS+nr68tx48Zx4MCBtLCwIABWr16d1tbWtLS0pFwup1gs/k7p/fdHU1OTJiYmLFu2LG1sbFi/fn22atWKTk5OFIlE9PDw+G4dkMaRI0fYtm1bdunShdWqVROe1XPmzGGtWrVoYmIizFOoUCECoEQi4bt37/LkOirJWZRK9x/KkCFDqKuryzVr1nDGjBkcO3Ysp0+fTicnJ96+fZufPn2inZ0dExISeOzYMZqYmPDIkSOC583CwoIeHh7Czezo6EgAvHjxYpZlevjwIbW0tOjq6ipY6fKSuLg46uvrc+jQoXk+d2pqKiUSCZcvX57nc/+tvHnzhioqKvTx8clvUX7Iw4cPOWnSJMG7pqOjw+7du/Po0aNMTEz85b6fP3+mtbU1dXV1efXq1TySWEl2CQkJ4fz581m7dm0CoEwmo4uLC9euXcvw8PAMHycuLo5ly5ZltWrVfvtbOXHihKBcurm5/dLr9/r1a06fPp1ly5YlABoaGnLYsGG8ffs2FQpFhuXLDsnJyXR3d6dYLObmzZt/Oz4gIIAqKirs0qVLhmRMTk5mvXr1aGBgwJCQEFpaWrJ///4kyevXr9PKyopisZgDBw7kxo0b2bhxY4rFYqqpqbFTp048efJkviqTmSUuLo4LFiygkZERJRIJe/TowRcvXuTafM+ePWPbtm0JgFWqVOGJEydyba6fsX37dgKgn59fns+tJGusXbuWAH5pJNmzZw8B8OjRoz8dk5KSwoiICIaEhPDBgwe8fPkyjx8/zl27dnHt2rXpvM6enp5s3749XVxcaG9vz8qVK7N48eLU09OjVCr9paIslUqpp6fH4sWLs3LlyrSysiIAFi5cmJ6enhwxYgSbN29OsVjMZcuWcdeuXTxx4gSvXLnCBw8eMCQkhBEREb99lsyfP58ikYhVqlThpk2bGB8fz6ioKOH74cOHs2vXrlRTU6NYLGbRokXp7u5OJycnRkdHU0NDgwCopqbGESNGCPLXq1cvz57pSnIOpdL9B/LmzRuqqqpSR0dHuAFNTExYuHBh4WFSsmRJ+vj40NHRka1ataK2tjbt7e2prq5OW1tbpqamCgtHABSJROzZs2eWb+LPnz+zZMmSrFixYroHSl6yatUqikSiXF2Q/IywsDAC4L59+/J87r+ZQYMGsVChQgXGS/X48WNOmTKFFSpUIABqa2uza9euPHz4MBMSEjJ1rIiICNaqVYtaWlrZMnYpyV1ev37NuXPn0s7OjgCooqLCZs2accOGDfzy5UuWjjlo0CCqqanx4cOHPx1z9+5dOjs7EwBr167Ny5cv/3BcREQEV69ezTp16hAA1dXV2blzZx4/fpzJyclZki+rJCUlsUOHDpRIJBlKLwoKCqKOjg4bNGjwW+NDGsOHD6dEIuG5c+dIkh4eHqxcuTIHDx5MsVhMKysr3rhxI90+b9++5cyZMwVjhKmpKceNG/dHhS3HxcVx/vz5NDQ0pFQqZc+ePfny5ctcm+/KlSvCGqFhw4a8e/durs31v9y5c4dyuZydOnVSKhV/CGleZQcHB5qYmPDixYs8d+4cDx48yM2bN3PZsmWcOXMmx44dy6JFi1JHR4eurq6sX78+bWxsWKZMGRobG1NTU/O3XmUNDQ0aGxuzTJkytLGxYb169diyZUt27dqVAwcO5Lhx4zhz5kwOGzaMqqqqLFq0KAHQw8ODz54948ePHxkfH//dbys5OVlQ1C9cuEDy228xu84okrS1tRU85np6eqxRowYLFSrEQoUKUSqVUiQSsUSJEixWrBi1tLR44MABDhw4kGvWrBHOu3v37rx//366azFjxoxsyaUk71Eq3X8YT58+ZZEiRaiiosKuXbvyxIkT6fK49fX16ebmRjU1NWpoaPDevXssX748x44dy5iYGMrlcgLggwcPhAVIWkjNz8JffkdSUhLr169PfX39XF0E/AqFQsHy5cuzZcuW+TJ/UFAQAfx0Yawka4SGhlJNTY1Tp07NNxmePn1KHx8fVq5cmQCopaVFd3d3Hjx4MNOK9r+Jjo6mk5MT1dXVefr06RySWEl2efnyJf38/GhjY0MAVFVVpaurK/39/bNtADpx4gQBcOHChT/8PiQkhN26daNIJKKlpSX37t373QIxMTGRBw8eZNu2bamqqirU7Ni0aROjo6OzJV9WSUxMZJs2bSiTybh3797fjg8JCWHRokVpZWWV4RSSLVu2fHftBg4cSACUy+WcM2fOLw0NCoWCV69eZd++fQWjde3atbl69eoCn8aSRmxsLOfOncsiRYpQKpWyV69e6VLMchKFQsF9+/bR0tKSIpGIXbt2zdX0hLCwMJqbm7NatWoFIq/8byc1NZWRkZF88+YNHz58yCtXrvDEiROCV3nBggWcOnUqR44cyd69e7NDhw5s0qQJ7e3tWaVKFZYoUYL6+vpCbYWffSQSCfX09Ghubs5SpUoRAMuVK8f27dsLXuXJkydz3rx5XLNmDXfu3Mnjx4/z8uXLfPDgAYODg/n169cMR6gEBARQXV2dFStWpFgsZr9+/TJkwElL+7K1taVCoWBSUhLV1NQ4b968bF3nQ4cOCddCV1eXzs7OrFOnDps3b84JEybw1atXbN68OVNTU1m9enV++vSJVatWFULiAfD69ev88OGD8G9LS0sCYFBQULZkU5K3KJXuP4jg4GAaGxvT0tLyh3ncNWvWpLq6Ou3s7DhnzhyKxWJKpVLq6uoKxXbKly9PACxevLjwoJTJZL8sgPE7Bg0aRKlUyoCAgGyeYdY5efIkAQjej7zm1KlTBJBvRoe/mSFDhlBHR4dfv37NszmfPXvGGTNmCCFnmpqa7NSpE/fv38/4+PgcnSsuLo6NGzemqqoqjxw5kqPHVpJxnj17Rl9fX1avXl0I52vVqhW3bt2aYwrZ58+faWJiwoYNG36XghMREcHRo0dTTU2NRYoU4bJly9IZQtMUxgEDBlBfX18I/509e3a+FwlLSEhgixYtqKKiwoMHD/52/NevX1mhQgWam5tnODfx9u3blMvl7Nq1KxUKBUNDQ9mmTRthEbpp06ZMyRwXF8dt27axUaNGFIlElMvldHd35+nTp/MlPSqzxMbGcs6cOTQwMKBUKmXv3r35+vXrXJkrKSmJy5cvZ5EiRaiqqsrRo0fnePRRUlIS69atSwMDAwYHB+fosf82EhISGBYWxufPn/P27ds8f/48Dx06xC1btnD58uWcNWsWx48fz0GDBrF79+5s3bo1GzRowBo1arBs2bI0MTHJkFdZXV2dRkZGtLS0pLW1NevVq0dXV1d26dKFAwYM4NixY+nr68ulS5fS39+fBw4cYP/+/SkSibht2zZ++PCBcXFx3ym8ffr0oa6ubrbqB/2MM2fOUC6Xs2rVqpTJZOzUqVOG7+dOnTqxYsWKBMCdO3eSJGvWrMmOHTtmS6aUlJR0NZQqVqyYrjjihg0b6O/vT5KsXr067969m+7/Ry6X08bGRjD8pxVTMzQ0ZPv27bMlm5K8Ral0/0HUqlWLxYsX57Nnz/jPP//w/v37fPv2raB0/zuP29jYmOXKlaO6ujpfv37NDx8+UEdHh4UKFUpXaKZXr15ZlmnVqlUEkO+5zE2aNKGVlVW+haP5+/sTwG8rCSvJPO/evaOamhonTZqUq/O8ePGCM2fOFIqZaGhosEOHDty7d2+ue10SEhLo6uqaYS+hkpwhLYohzbgil8vp5ubGHTt25LjHWKFQsF27dixUqBDfvn0rbE9MTOSCBQuor69PuVxOb2/vdCk6L1684NSpUwXPhomJCb28vAqMhyM+Pp4uLi5UVVXlsWPHfjs+ISGBderUoZ6eXoYrGacVTqtevTpjYmK4dOlSamtr09DQkFu3bqWenl62ng9v3ryhr6+vcI3NzMzo7e2dq1XDc4qYmBj6+fmxcOHClMlk7NOnT64prVFRUZw4cSLV1dWpr6/PBQsWZDgt4HcMHDiQUqlUCO3920jzKr99+5aPHj3i1atXefLkSe7evZvr1q3jggULOG3aNHp5ebFPnz7s2LEjmzZtSgcHB1apUoUWFhYsXLgwVVRUfutVLlSoEM3NzVmxYkXWqlWLjRs3Zrt27dirVy8OHz6ckydP5ty5c7l69Wru2LGDx44dY2BgIO/fv8/g4GB++fIly6kpKSkptLW1ZdmyZX9qoA4LC6OOjo5QiyGnOHXqFNXU1FijRg3K5XI2a9YsUxGcM2bMoI6ODl1cXFiyZEkmJiZy8ODBLFWqVLZle/36dTrPtUgkYvPmzXno0CF6enqydu3arFKlCiUSSbr/TxMTE+rr6zM5OZnz5s0Ttnt5eXHSpEkUi8WcPHmyMhXjD0GpdP8hXLt2TQiF+3eBCG1tbY4aNYpfvnzhxo0b6ejoyMGDB7NevXo8f/48AbBq1aps06aNkNf9vw/orC7eLly4QJlMxn79+uXw2WaOJ0+eEAA3btyYbzLMnj2bWlpa+Tb/387w4cOpra2d5Rzan/Hq1Sv6+fnR2tpaULratm3LXbt25bkBJSkpie3ataNEIuG2bdvydO7/Eo8ePeKUKVNYqVIlwbjSvn177tq1izExMbk27+bNmwmA27dvJ/lNCd+xYwctLCwoFovZq1cvwWP95csXrlixQsip1dTUZLdu3Xjq1KkCVQQsNjaWDRs2pFwu56lTp347PjU1le3ataOamlqG26QlJyezfv36NDAw4IkTJ4Tcek9PT+F50KxZMzZo0CBb50J++z+5fPkye/fuTW1tbQKgvb0916xZk2+1SjJKdHQ0Z82aJSjf/fr1y7VQ8NDQUHp6elIsFtPCwoI7duzI1qI/LXc1v433PyIxMZGfPn3iixcveOfOHcGrvHXrVq5YsYJ+fn709vbm4MGDBa9yw4YNaWtry3LlyrFo0aLU0tL6rVdZLpfT0NCQpUuXZvXq1enk5CR4lfv3788xY8ZwxowZXLJkCTdt2sT9+/fz7NmzvHHjBp8+fcr3798zNja2QChfDx48oEwm4/jx4386Jq1FbU4ZD0+cOEE1NTXWrl2bOjo6rFOnTqaN5QcPHiQAnjp1imKxmIsWLRIcKjmx9nj27BkNDQ1/+1tI+4jFYrZr144uLi6MjIwUjIJpYeUvX74U/j1x4sRsy6ck91Eq3X8AoaGhwo2qpqZGCwsLOjk58fz58xw5ciRVVVUpEomopqbG1atX8/Hjx6xcuTLNzMx46tQpVqhQga1bt+anT5/o4uKS7qZes2ZNlmR6/fo1DQwMWLdu3SzngucU/fv3p6GhYbbza7PDyJEjWbp06Xyb/2/nw4cPlMvlnDBhQraPFRwczDlz5rBGjRrCPdWmTRvu2LEjV5WujJCcnMyuXbtmuNWSkt+T1tJt0qRJQnqNlpYWO3XqlCdRDOS335yOjg47d+5M8pvBMu3317RpU96/f58JCQncu3cvW7VqRRUVFYrFYjZu3JhbtmzJ99/lj4iOjmbdunWpoaGR4dSi4cOHUyQSZSqaY8SIEZRIJOzUqROlUinLlSv3nTfU19eXmpqaOWqQiIuL49atW+ns7EyRSER1dXV26dKFZ86cKdDh59HR0fT19aW+vj5VVFTYv39/vnnzJlfmevDgAZs1a0YArFGjRpa81JcvX6ZMJmPv3r1zTK7U1FRGRUXx7du3fPz4Ma9du8ZTp05xz549XL9+PRcuXMhp06Zx1KhR7Nu3Lzt16sRmzZrR0dGRVlZWtLCwoIGBAVVVVX+rFOnq6rJYsWKsWLEia9asyUaNGrFt27bs2bMnhw0bxkmTJnHu3LlctWoVt2/fzqNHj/LSpUsMCgri69evs+VVLshMmTKFUqmUd+7c+eH3iYmJtLS0ZP369bNtKDh27BhVVVVZp04dGhgY0NraOkspQWlK7LFjx9izZ0/q6+vzxo0bBMCTJ09mS8Y03r17J9RW+lVYv5+fH6tWrUqSXL58udAuDAAdHBxIfjPUA9+6WgBQRsn9ASiV7gJOSEgIixUrJoTRpXnfxowZw127dlFXV5dGRkZC9cc0z03r1q35/v171qpVS3gpNmrUiJ6enpRIJBSJRFy2bFmWZIqJiWGVKlVYvHjxXMnJyQyfP3+muro6p0yZkq9yuLu7097ePl9l+NsZOXIktbS0slR/ICQkhPPmzRO8ZKqqqmzVqhW3bduWb4WnfkZqaip79+5dYD0/fwIKhYJ3796lt7e3UDBSW1ubXbp04YEDB3I8L/9XpKam0snJiaamprx27RpdXV0JgNWqVeOZM2d46dIl9u3bV1hUVatWjfPnz+f79+/zTMbMEhUVRXt7e2pqama4sm9aaOTixYszPE9a4bQ0BXLKlCk/NK5euHCBAH66wM8uISEhnD59OkuXLk0ALFasGCdMmJCrfbOzS1RUFGfMmEE9PT2qqKhwwIAB6dIacpKzZ88KtRBatGiR4bSBt2/f0sjIiLVr12ZiYiITExMZHh7Oly9f8u7du7xw4QIPHz7MrVu3cuXKlZw9ezYnTJjAIUOG0MPDg23atGHDhg1pZ2fH8uXL09TUlNra2hSJRL/1KhcpUoSlSpVitWrVWLduXbZo0YLu7u7s378/R48ezenTp3Px4sXcuHEj9+3bxzNnzvDGjRt88uQJ3717x5iYmALhVS6oJCYmsmLFiqxWrdpPjQppBcb279+f5XmOHDlCFRUV1q9fn6ampixfvnyW16WpqalUV1fn7Nmz+fbtW8rlco4ZM4Y6OjqcPn16lmX8N2PHjk33W2zcuDE7d+7MIUOGcMSIEULUZvXq1RkZGUlzc/N0xerS8s3j4+OFKM969erRzs4ux2RUkjsole4CTEJCAitVqkQTExP6+fnR19eXvr6+XL16NQcNGkQfHx96eHgI4+3s7Ojt7U0A3L17N8lvYXdbt24lAD579ow6OjosXrw4z58/nyWZUlNT2aZNG2poaBSInMJZs2ZRRUWFHz9+zFc5GjZsSDc3t3yV4W/n48ePVFdX57hx4zI0/u3bt1ywYAFr1apF4FurJ1dXV27ZsqXAVypWKBQcPHgwAXD+/Pn5Lc4fgUKh4K1btzh27FhBOdLV1WX37t2z1NItp5g7dy4BsHnz5pRIJDQ3N+fcuXM5YcIEWlhYCDnEY8aM+WULsYJCREQE7ezsqK2tzStXrmRonx07dhAAR48eneF5zpw5I+Q3Ojo68smTJz8dGxcXR5lMxiVLlmT4+FlBoVAwMDCQnp6eQsiwo6Mj161bV2DDz6Oiojh9+nQWKlSIqqqqHDRoUI4W3lMoFIyOjuabN284Z84cGhsbUywW09nZmQsXLuSiRYvo4+PDUaNGsV+/fuzcuTObN29OBwcHqqurUyKRUF9f/7deZZFIRB0dHZqZmbFChQqCV9nNzY09evTg0KFDOXHiRM6ZM0fwKh85coQXL17kvXv3+OrVK37+/DnfI/P+S1y7do1isZizZs364fcKhYLOzs4sWbJklp7Phw4dooqKChs3bszSpUuzePHi2TYs2djYsFu3biRJb29vqqmp0d7enq6urtk67v8SHx+frmWvqqoqu3XrxmvXrtHLy4sNGzaks7Mz1dXVaWpqmu4+kEqldHR0FFqtAeCJEye4b98+Asre9gUdpdJdQFEoFPTy8hJeNj96Cdna2rJFixZCqJuNjQ0VCgV1dHRYsWJFKhQKdu7cWciXcnZ2plwuz1Yf68mTJxMoGP2ok5KSaGpqms7wkF9UqlSJAwcOzG8x/npGjx5NTU3Nn1qy3717x8WLF9PBwYEikYgymYzNmjXLkVZPeY1CoeDo0aMJIEet7H8TCoWCN27c4KhRowQFVk9Pjz169OCxY8dyrMhTVrl27RolEgmlUil1dHTYqlUroQ2ZtrY2e/TowYCAgAIdrvy/fPnyhdbW1tTV1f2uF/bPOHfuHFVUVOju7p6h81QoFFyyZAnFYjElEgmXL1+eIY+ira1ttqsMZ4bY2Fhu3ryZDRo0EMLPu3btyrNnzxbI/8/IyEhOmzaNurq6VFVV5YABA/jw4UO+evWK9+7d48WLF3nkyBFu27aNK1eu5Jw5czhx4kQOHTqUPXr0oJubG52dnWlnZ8cKFSrQzMyMOjo6Qv/hn32kUikNDAxYsmRJVq1alXXq1GGzZs1oYWFBiUTCrl270sfHh4sWLeKGDRu4d+9enj59mtevX+eTJ08YGhrK6OhopVf5D2XEiBFUU1Pj06dPf/j9w4cPKZFIMq0sHjhwgDKZjE2bNmWVKlVoZGSUI5EnHh4etLa2JvntnjEwMBCcXznJ58+fBYfA/3709fVpbm7+wzoA+vr6gmFx/fr1rFGjBosUKcLExEQmJycLhdoyE02kJG9RKt0FkOjoaCEkPCOfJk2a0M/PjyoqKmzTpo0QTnnhwgU2a9ZMCOsTi8U8dOhQluXavXs3AXDatGk5eLZZJ817cvfu3fwWhQYGBgXmuvzNfPr0iZqamhwzZoyw7cOHD1y6dCnr1KlDkUhEqVTKJk2acMOGDXnaZiw3UCgUnDJlCgFwwoQJyoUn/6911ogRI2hubk4ALFy4MD09PXnixIkC4clKTk7mkiVLhKKXJUqUEJTvZs2acceOHX9cH+Lw8HBaWVlRX1+ft2/fztA+9+/fp46ODhs0aJAhA8g///zDunXrCt6fW7duZVi+4cOH09zcPMPjc5Lg4GD6+PgIPYiLFy/OSZMmZcvA/SMUCgVjYmL47t07PnnyhNevX+fp06e5b98+bty4kYsXL+b06dM5evRowavcokUL1q1bl9WqVWOpUqWEFmO/8ypra2sL4bp2dnZ0dnamm5sbPTw8OGTIEE6YMIGzZ8/mypUruW3bNh45coQXLlzg3bt3+fLlSz5//pzDhw+nqqoqjYyMuHLlSiHMeMGCBQTAzZs35+j1UVLwiI2NpYWFBR0dHX9qjBo0aBC1tLT44cOHDB1z3759lMlkdHV1Ze3atVmoUKEci7ycO3cu5XK5IOuSJUuE+yKnWzPGxcVxxIgRv02H0NfXp5mZWbr3f5on/H+L1TVq1Eh4Bu3ZsydHZVWSM4hIEkoKDHFxcWjQoAGuXLkibDM1NUWfPn1w69Yt3Lt3DzExMZDL5QgJCRHGWFpaolKlSgCAlJQU3Lt3D7a2tnjz5g1SU1Nx+/ZtHDhwAC4uLlmS6969e6hVqxaaN2+Obdu2QSQSZe9Ec4BatWpBLpfjzJkz+SpHSkoKVFRUsGrVKvTq1StfZfkvMG7cOCxcuBCTJ0/GsWPHcP78eYjFYjRo0ADt2rVDy5YtUahQofwWM0fx8/PD6NGjMXLkSPj5+RWI+y8vUSgUuHr1Knbv3o3du3fjzZs3KFKkCFq3bg03NzfUqVMHUqk0v8UESRw8eBBDhgxBcHCwsN3GxgZdunRBhw4dYGBgkI8SZo2wsDA0aNAAHz58wJkzZ4R3za94+/YtatasCX19fVy4cAHa2to/HZuUlAQ/Pz/4+PhATU0N0dHROHPmDOrWrZthGffu3Ys2bdrg7du3KFq0aIb3y0lIIjAwEBs2bMDOnTsRHR2NOnXqoEuXLmjYsCFIIioq6oef6OjoDH2nUCh+Or+qqiq0tbWhra0NLS0t4e///mhpaUEqleL8+fM4cuQIkpOT0bFjRwwbNgwWFhbQ0NCAWCzOkWsSHByM8ePHY8uWLShXrhw6deqEyZMnY+jQoZgzZ06OzKGkYBMQEIB69eph+fLl6Nu373fff/nyBaVLl0br1q2xevXqXx5rz5496NChA1xdXRETE4NLly7hzJkzsLW1zRFZT548iUaNGuH58+coWbIkkpOTYWlpidevX2P//v1wdXXNkXn+l3HjxsHPzw8VK1ZEVFQUYmNjoa2tjbJlyyIsLAyXLl1CzZo1cfPmTQDfrlepUqUQFxeHf/75B8WKFQMAtGzZEklJSZBKpbh27RpCQkKgqqqa4/IqyQb5qvIr+Y527doJ1i0dHR3u2rVLqMjasmVLyuVyGhkZ0dHRkcOGDUsX2lW3bl22adOGDx8+pKGhITU0NLh8+XICWa9STn7LpS1WrBirVq1aYPpQX716lQB48ODB/BaF7969KzCy/M2EhYVx5cqVdHR0FLwxzs7OXLNmDcPDw/NbvFxn4cKFBMABAwYUyPDVnCYlJYUXLlzg4MGDWbRoUQKgkZERBwwYwICAgALVOoskd+7cyWLFiqXzUNSrV++Xuch/Au/fv2f58uVpZGSU4Zzzr1+/smLFiixWrNhvvUOXLl1i+fLlKZFI2Lx5cwLgggULsiQnAO7YsSPT+/4IhULB2NhYvn//nk+fPuWNGzd45swZ7tu3j5s2beKSJUs4Y8YMjhkzhv3796e7uztbtGhBJycnVq9enaVKlcpQ+LVIJKKWlhaLFi3KcuXK0dbWlg0bNmSbNm3o4eHBwYMH09vbm35+flyxYgW3bt3Kw4cP88KFC7xz5w5fvHjBT58+ZblmwdevXzlp0iRqa2tTLpdzxIgRGfY4ZoZbt26xZs2aBMBChQrx8uXLOT6HkoJLWh2En7WxW7x4MUUi0S+jaHbu3EmJRMJ27drRzc2NKioqPH36dI7K+fbt2++Ku6VFeXbq1ClH50ojKSmJDRs2pLq6Oo8cOSJs37BhA/39/Ul+K6pGkhs3bhQiVVasWMHmzZuzbt26nDhxImvWrMlOnTrx+vXrBEBDQ8MMRyUpyRuUnu4CRFBQEKpUqQIA0NTUhK+vLwoVKgSZTAaxWIw5c+Zg1qxZ2LdvHxYsWAAAqFixIt68eYOoqCgAQIMGDXDq1CkMGzYMx48fh6GhIZ4/f45Xr15BJpNlWqakpCQ0aNAAT58+xc2bN2FmZpZj55sdOnbsiBs3buCff/7JMYt8Vrl79y6qVq2K69evw8bGJl9l+dv4/Pkz9u3bh507d+Ls2bMgiXr16kFVVRUBAQF49eoVihQpkt9i5hmrVq1C37590aNHD6xcuRISiSS/RcpRUlNTcfHiRezevRt79uzBhw8fYGJigjZt2qBt27aoVatWgTrnsLAwLFmyBEuXLsWXL18gFovh5OSEBw8ewNLSEgEBAQVK3swSGhqKevXqITY2FmfPnoWlpeVv90lMTETjxo1x7949BAYGoly5cj8cFxERgbFjx2LFihWoUaMGRowYge7du6NNmzbYtGlTlqI5SpYsiSZNmmDq1Km/9R5nxLucmpr607lkMhl0dHS+8yD/yLOclJSEmzdv4vz58/jw4QOKFi2K9u3bo3v37qhQoUK+v8MA4OvXr1iwYAEWLFiA5ORkDBgwAF5eXjn2fI2JiUGtWrUQHh4OXV1dPH78GO3bt8eMGTNgYWGRI3MoKbhERESgQoUKqFq1Kg4dOvTd/Z2SkoIqVapAX18f58+f/+77HTt2oHPnzmjXrh3kcjk2btyI3bt3o2XLljkqJ0no6elh5MiRGD9+vLBNX18fKSkpiIiIyJX7NTY2Fs2aNcO5c+dQt25dDBgwAFevXkVQUBDEYjEuX76MsmXLIigoCImJiZgzZw5u3ryJOXPmoGjRonj9+jUsLCywcuVKeHp6omrVqggKCoJcLsfRo0fh6OiY4zIryQL5qvIrSUffvn3TWb/xL4u4iooKzczMhCqKvXv3pqamJosXLy6MKVGiBMlvxSAKFy5MVVXVDLd0+TcKhYKenp6UyWQMDAzMqdPMNm/evKFEIuGiRYvyWxSS33pEAvipBVdJ5vj8+TPXrl3LRo0aUSqVUiwWs169elyxYoVQpf7Lly/U1tbmiBEj8lnavGfTpk0Ui8Xs3LnzX9HfNTk5madPn2bfvn1ZpEgRAqCpqSmHDh3KwMDAAufVj4uL47Zt24QCWsC3Xu/9+vVjTEwMu3XrRi0tLb569Sq/Rc0WwcHBLFmyJIsVK5bhAkWpqans0KHDL987CoWCO3fupJGRETU1Nbl48WJ++PCB5ubmrFy5MoOCgnjz5k2ePXuW+/fv56ZNm7h06VL6+vpy7NixHDBgALt06UJXV1c6OTnR2tqalpaWNDIyEqqd/+qjpaVFExMTli1bljVq1GCDBg3YunVrdu/enYMHD+b48eM5a9YsLl++nFu2bOGhQ4d4/vx5wascFhaWZa+yQqHghQsX2KNHD2pqahIAnZycuHHjxgLTi/3z58/09vamlpYW1dXV6eXlxbCwsGwdU6FQsE2bNtTU1OSDBw+YkpLCtWvX0sTEhDKZjEOHDv1PRCv91zlw4AABcMuWLT/8/sSJEwT+ryVWGlu3bhXeecOHDycAoa1WbmBvb/9dUcZevXoRADdt2pRr86akpLBs2bJC+0i5XE5TU1MaGBgIdS7q1q1LNTU1JiUl0c7Oju3bt6eTkxPd3d2po6MjPEemTp0qeMR1dXV/WshOSd6iVLoLCFFRUUIfPn19fXp7e/PFixccNmwYK1euzOLFi7Nz586USqUUiUQ8ceIEd+7cyd69ezM4OFgIYZNIJPz8+bNQLOXYsWNZlimtgMTatWtz8Eyzz5gxY6itrV1gWrSsX7+eAPKtJdHfwNevX7lhwwa6uLgIv/G6dety2bJlPw11nDhxIuVyeYHuZ5xb7Nixg1KplG3atMn3Ct1ZISkpiSdPnqSnpycLFy5MADQ3N+eIESN49erVAqdop6am8syZM/Tw8BCUJYlEQlVVVY4bN05Y6KSFIW7YsCGfJc4er169YvHixVm8ePFfGg9SUlL49etXBgcH8/79++zYsSNFIhFHjBjBNWvWcN68eZw8eTKHDx/OXr16sVmzZsICUltbm0WLFqWuru5vFWWpVEp9fX2WKFGCVapUoYODA5s2bcoOHTqwd+/eHDlyJKdOncq2bdtSLBZz8+bNPHHiBK9cucKHDx/yzZs3jIyMLFC/q5iYGG7atIn16tUjAGpqatLDw4Pnz58vEAUTP3/+zPHjx1NTU5MaGhocPXp0lvsfT5s2jcD3XU9iY2M5ffp0amlpUUdHh7NmzfrjCgwqyRzt27envr7+Tw05zZo1o7m5ufA72Lx5M8ViMbt27Sr8jnLb4dK3b19WqlQp3bY054qxsTHj4+Nzbe7t27cTAJcuXcr58+dz4sSJnD59OtevX08XFxempqayevXqfPfuHdXU1BgcHCx0yRg8eLBwnMWLF6dLbWnTpk2uyawk4yiV7gKAQqEQcrl9fX3TVd/93zzuOnXqcNWqVZTL5RSJRLSysmJISAhjY2PTtRdIa52T1qs7K5w+fZoSiYRDhw7NiVPMMWJjY1moUCEOHz48v0URmDlzJgsVKpTfYvxxREREcNOmTWzWrBllMhlFIhEdHBy4ePFivnv37rf7f/36lTo6OgXuN5pX7N+/nyoqKmzWrFmuLgJyisTERB47dow9evSgnp6eEJkzatQoXr9+vUAoGv/mwYMHHD16tNArtUiRItTR0aFUKuWAAQOEyAvyW20HPT09tm7dukCeSxoKhYJxcXH8+PEjnz17xlu3bjEgIIAHDhygv78/J0+eTB0dHRYqVIjdunVj165d2bJlS9arV0/wKhsbG1NDQ+O3yrKmpiZNTExoaWlJMzMzSiQSqqmp0cnJiYMGDeL48ePp6OhIsVjMcePG8eDBgzx37hxv377N58+fMywsjPHx8Rm+nvfv3ycAnj17NpevYs7y6tUrTpkyhSVKlBDe4VOnTuXr16/zWzSGh4dz7NixgvI9ZsyYTHml07ybkydP/umYjx8/csCAAZRKpTQzM+OmTZsKlIFESc7x8eNH6unp/bS939OnTymTyejj4yNEdXXv3p2LFi0iAE6dOjXXZVyyZAllMlm6tfinT5+ELkC52Qs7JSWFzZo1o7q6Os+dOyds/3d+d1xcHCtWrMjXr1+zdOnSVFNTS+eASFuXGhoaCtGzz549yzW5lWQMpdJdANiwYQMBcPny5em2v379mnZ2djx37hyHDBkibLe2tmajRo2ora3N0NBQDh48mK1atRIWOqVLl6a9vX2W5Xn+/DkLFSpEZ2fnAhe+umLFCorF4gIVujl06FCWLVs2v8X4I4iMjOTmzZvZokULqqioEABr167NhQsX8u3bt5k+3pQpU6imppYhJf1v5Pjx41RTU2PDhg0LTJHD/yUhIYGHDx9m9+7dBY9mqVKlOHbsWN66datAKqfv3r3j3LlzaWVlReBb3+/mzZvT0tKSANi6devvQvUUCgUbN25MIyOjLHsDf0dKSgojIiIYEhLCBw8e8PLlyzx+/Dh37drFtWvXcv78+ZwyZQpHjBhBT09Ptm/fnk2aNKG9vb0QLaWnp/fbdlFpC0tTU1NWrlyZ9vb2bNKkCTt06EBPT0+OGDGCU6ZM4fz587l27Vru2rWL48ePp0gkYo8ePRgSEsKIiAih0N2tW7dYrVo1ikQiDhw4kJGRkcI5bdu2jQA4f/78HLlGqamp1NHR+WPbN6ampvL8+fPs3r27YNSoV68eN23alO/h558+feKYMWOooaFBTU1Njhs37rfK96NHj6ilpcVWrVplSIl++vQp27RpQwC0srLiqVOnckp8JQUIf3//XxafHTFiBFVVVQmAPXv25MaNGwmAw4YNy5N3xrlz5wjgu8KRaZE2Ojo6uZoOERMTQysrK0qlUo4YMYLPnj3jqFGj2LBhQ2Ht7+npSQsLC2ppaVEkErFChQosVaoU69Spwzp16tDW1pY2Njb09vYWnusmJibZThVRkj2USnc+o1AoWL58edatW5e9e/dm2bJlaWxszGLFilFHR4czZszgrVu36OHhIexjZ2fHr1+/UkNDgy1atGD//v05bty4dKF4Wc3jjoyMZPny5Vm6dGl++fIlp04zR0hNTWXZsmULXJhMx44dWbdu3fwWo8ASFRXFrVu3smXLlsKLtGbNmpw/fz7fvHmTrWNHRERQV1c3XVjVf42zZ89SQ0ODderUKRApF/Hx8Txw4AC7dOlCHR0dAmCZMmXo7e3Nu3fvFkhFOyYmhv7+/mzUqBHFYjFVVFTYpk0bLliwgM7OzsJv9tKlSz/cf+nSpQTAo0ePptuuUCgYHx/Pjx8/8vnz57x9+zbPnTvHgwcPcvPmzVy2bBlnzpzJcePGcdCgQezWrRtbtWrF+vXr08bGhmXKlKGxsbEQ0v6rj4aGBo2NjVmmTBna2NiwXr16bNmyJbt27cqBAwdy3LhxnDlzJpctW0Z/f38eOHCAAQEBvHXrFp89e8YLFy7QyMiI5cuXz1TKxvnz56miosLOnTunU6yio6M5fPhwisViVqpUiVevXk233927dymXy9m5c+cc/U00btyYjRs3zrHj5RfR0dHcsGGD0LdcU1OTPXr04MWLF/P1Hvr06RNHjx5NDQ0Namlpcfz48fz8+fN3475+/crSpUuzQoUKmX4uBQYGslatWgTARo0a8d69ezklvpICgEKhoIuLC4sWLcqIiIjvvl+8eLHgQNq3bx8lEgl79OiRZ7/7NK/2vzshtGvXjra2ttTU1OSwYcNyVYbY2FiKxWIh7bR+/focMGAABw8eTF1dXaqqqlIikVBFRYVyuZyHDh0SKpy/evWKIpGIq1atYkhISLr3RLVq1RgdHZ2rsiv5OUqlO59ZtWqVUPxFJpPRxMSEFSpUYIkSJYQwcalUSiMjI8bHx9PT05NGRka0trZmhQoVqKqqyri4OCEvDABnz56dJVnSwlq0tbX5+PHjHD7T7JOWU5NVg0Ju4eTkxA4dOuS3GAWKmJgYbt++na1bt6aamhoB0NbWlnPnzmVwcHCOzjVt2jSqqqpmyVP+t3Dp0iVqa2sLBrm8Ji4ujnv37mWnTp2EVJfy5ctz4sSJvH//foFUtFNSUnjy5El26dJF8Co6ODhw5cqVDAoKoru7O0UiEc3Nzenr6yt4ldetW8cFCxZw6tSpHDlyJNu1a0eJRMJixYrRwcGBVapUYYkSJaivry8smH72kUgkLFSoEM3NzVmpUiXWrl2bLi4ubN++PT09PTl8+HBOnjyZ8+bN45o1a7hz504eP36cly9f5oMHDxgcHMyvX79mOyIpKCiIBgYGrFy5cqY8IQ8ePKCuri7r16+frrbA4cOHWaxYMcrlcs6cOTNdmCb5LWS5RIkSudKGctq0adTR0fmrwpNfvnzJyZMnC0VTS5YsyWnTpuX4szQzhIWF0cvLi+rq6tTS0qK3t7dgqE9JSWHjxo1ZqFChDBfh+zcKhYJ79uxh6dKlKRKJ2L1792wbaZUUHIKDg6mpqck+ffqk27569WoCEFqDymQytmnTJs9bRBoaGnLChAnpts2ePZvq6uqcPHkyZTIZX758masy1K9fnwA4ZMgQOjs7s3Llyixfvjzt7e3p6+vLpUuXcuvWrYKyXaZMGTo6OrJMmTLU0tISomP+XTejd+/euSq3kp+jVLrzkRMnTlAmk7Fy5cpcs2aNYA1u1qwZNTU1qaWlRWtra9rZ2QkF1hwdHRkSEsLk5GQhTLB06dLCzVS0aNEsLzbGjh1LkUj0nbemoNCoUSNWr169wC3gy5Urly78/79KbGwsd+3axbZt21IulxMAbWxsOHv27FxNB4iMjKSenh4HDBiQa3P8Cdy4cYOFChVitWrV8qQScGxsLHfv3s327dsLSmulSpU4ZcqUDPdzzmkSEhIYFhYmeJXPnz/PQ4cOccuWLVy+fDlnzZrFXr16sWrVqsJvVF1dnUWLFqWFhQWNjIx+qyin7WNkZMTSpUtTXV2d6urqbNq0Kbt06cIBAwZw7NixwqLI39+f+/fv59mzZ3nz5k3+888//PDhA+Pi4grEs+z27dvU19dn1apVM/W7efv2rRCCnuatev/+vVCfxNnZmS9evPhuv+TkZDZs2JD6+vq5krN89uxZAuD9+/dz/Nj5TWpqKgMCAtitWzeqq6tTJBKxfv369Pf3z7f0ko8fP3LkyJGUy+XU1tbmxIkTOXjwYIrFYp48eTLbx09KSuKSJUtoYGBANTU1jh079ofeUSV/HmkRQgEBASTJlStXEgD79+/PwMBAisVi6ujo5EvNkvr167N169bptqWFnV+7do0mJiY/zUvPKTZs2CBcg3+/U1NSUti8eXOhsBr5zZiZlrJjZ2cnjE2rhv6/3TaU3QLyB6XSnU/cunWLGhoabNSo0Xcvy4kTJ9LHxyddSLmlpSWlUik9PT1JfvMkNm3alCKRSFDKs5Mbt3Xr1mx5yXObhw8fEoBQSKIgoaenR19f3/wWI1+Ii4vjnj172L59e6qrqxMAq1evzlmzZv1wwZ1bzJgxgyoqKv/5tm13796lgYEBK1Wq9NOq79khOjqaO3bsoJubm/D/bWVlRR8fHz558iRLx0xNTWVUVBTfvn3LR48e8erVqzx58iR3797NdevWceHChZw2bRq9vLzYp08fduzYkU2bNhW8yhYWFixcuLBQI+BnH5FIJEQVSSQSGhkZsWbNmmzbti09PDzo5OREdXV1ymQyNmnShOvXr+exY8cYGBjI+/fvMzg4mF++fEnnVZ44cSIlEgmvXbuWU5c4T7l+/Tp1dXVpY2OTqXSiiIgIVqpUicWKFWNoaChTU1O5cuVK6ujo0MDAgJs3b/6pQWHUqFGUSCQ8c+ZMTp1GOmJiYiiRSLhixYpcOX5BISoqiuvXr2edOnUIfGuF1qtXL166dClfjDkfPnzg8OHDBaOVs7NzjkbdREZGcvz48ZTL5SxcuDAXLVr0R3ZuUPJ/pKam0t7enqVKleKCBQsIgIMGDeL9+/epp6fHChUqEAA3b96c57INGTKElpaW6bZFRUVRJBJx7dq1XLNmDQHwxo0buSbDx48fhXtbR0eH+/fvF5xq/y6sFhsby44dOxIAO3bsSAcHB75+/Trde9HIyCjbEbFKsoeIJKEkz3FycsKXL1+wbds23Lt3D5GRkVBTU4O6ujrmz5+PmTNnYt++fViwYAEAoEaNGujVqxf69OmDDh064Pz58xgwYACmTZuGxMREAIC6ujrevn2LQoUKZUqWGzduwNHREW3btsXGjRshEoly+nSzTd++fXHw4EG8fv0aKioq+S2OQFJSElRVVbF+/Xp07949v8XJExISEnD8+HHs3LkTBw8eRGxsLKpWrYp27dqhbdu2KFmyZJ7LFB0djRIlSqBdu3ZYtmxZns9fkHj06BEaNGgAbW1tnDlzBkWLFs3W8aKjo3H48GHs3r0bx44dQ3x8PKpVq4bWrVujQYMGMDAwQFRUFKKiohAdHS38/d+fn30XHR39y/nlcjm0tbW/+2hpaf1we9p3EokEV69exZEjR3Dp0iWoqqqiRYsW6NKlCxo1agSZTAaS2Lt3L8aMGYMXL17Aw8MDU6ZMgamp6W+vy9WrV2Fvb48JEyZg0qRJ2brG+cGVK1fQuHFjVKhQAceOHYOOjk6G9ktMTISLiwvu3LmDwMBAAEDv3r0RGBiIHj16wM/PD/r6+j/cd8eOHejQoQPmzZuHYcOG5di5/Btra2uUL18emzZtyrU5ChIvXrzApk2bsHHjRgQHB6NUqVLo3r07unbtCjMzszyT4/bt26hduzaKFy+OV69eQS6XY9iwYRgyZEiGf1+/IzQ0FJMmTcL69ethYWEBX19ftGnTpkCuW5T8nqdPn6JixYpISUnBkCFDMGjQIDg4OKBIkSI4d+4cevbsiWvXruHp06fQ0NDIM7nWrFmDPn36ICYmBnK5XNhesWJFODg4YMmSJahSpQoKFy6MgICAXPv92draIjU1FXfu3IFCoYC5uTkGDBiAe/fu4cWLF0hNTcW9e/cAfFuPFilSBBs2bMCuXbsgl8tx9OhRvH79GsC3dfSKFSsAAEWKFMGHDx+U901ek89K/3+StLYmaZ4i/E/YBwCqqqqyb9++7NSpE8lv1kC5XM6FCxeyWLFi7NGjB+Pj41m1atV0npys9IZ99+4dTUxMaGtrW2DbDoWHh1Mul9PHxye/RfmON2/e/LCA0t9GWnGszp07Czm7lStXpo+Pz3eVnPOLmTNnUiaTFYg2O/nNs2fPaGZmRgsLi3TX43+9yo8fP+a1a9d46tQp7tmzh+vXrxe8ykOGDGG9evVoamoq9PpUV1ennp4e9fT0hIJ4P/uIxWLq6uqyWLFirFixImvWrMlGjRqxbdu27NmzJ4cNG8ZJkyZx7ty5XLVqFbdv386jR4/y0qVLDAoK4uvXr7/zKmeE5ORkHj16lB07dhTCx+vWrcu1a9d+F5J66dIlIUrIxcWFQUFBGZ4nJiaGpUqVYo0aNQpch4eMcPHiRWpqatLBwSFTRa5SU1PZsWNHqqqq8tSpU/T29qZMJqOlpaUQIvoz7t69S3V19RwvnPYjBg8eTAsLi1ydoyCSmprKs2fPsmvXrkL4ecOGDblly5ZcDz//+PEjzczMaG1tzbi4OL5//55Dhw6lmpoadXV1OXXq1HSV67NLUFAQmzRpIoTS/qzIoZKCzcKFC4U18JEjR2hhYcHSpUsLkVovXrygqqoqJ06cmKdyXb58mQB4+/btdNu7d+/OatWqkSSPHDlCADx8+HCuyTF58mRqa2tTX19feLf+O6pLIpGwYcOGNDU1paamJhs0aMBLly6xT58+wntQLBYzJCSE5cuXV3q78xGl0p3HxMbGCgXSrKysuHbtWg4dOpTbtm2jjo4OZ8+ezYYNG1IkElEmk/Hq1aucOHEiTU1NuXjxYqFFUnh4eLpc7qzcPPHx8bS1taWJiUmBbrk0Y8YMqqmpFchWBzdu3Pjhg/lvICEhgYcOHWKXLl2ora1NAKxYsSKnTp1aIAvtRUdHs3Dhwn9lkZDExESGh4fz5cuXvHv3Li9cuMDDhw9z27ZtXLlyJWfPns0JEyZwyJAh9PDwYJs2bejg4EBVVVXKZDIaGRlRW1s7nXHvRx+ZTJbuha6trc3y5cuzZcuW7N+/P0ePHs3p06dz8eLF3LhxI/ft28czZ87wxo0bfPLkCd+9e8eYmJg8DW9VKBS8desWhw4dKvQkLV++PH19fX9YaOrJkydCi8WqVavy9OnTmZ6zT58+VFdXLzAGp8wQEBBAdXV1Ojk5ZboNlZeXF0UiESdNmsTSpUtTJpNx4sSJvzXYfv78mSVKlKCVlVWe5B7v2LGDADJVhf1vIyoqimvXrqWDg4NwL3t6ejIwMDDH78/ExEQ6ODjQ0NDwu2Jn79694+DBg6mqqspChQpx2rRpOap8nzlzhtWqVSMAtmrVKstpLkrynvnz5xP41gqsUqVKVFVVZdGiRb8znI8dO5Zqamp5WjgwMjKSALhp06Z025cuXUqpVMr4+HgqFAo6OTmxfPnyuWZ8vX79OgGwU6dOwnu5cuXKDAwM5LVr1/jkyRPGxsZ+l9/dq1cvNmjQQNjH1dWVJNOlowLggwcPckVuJT9GqXTnIYmJiaxXrx7lcjn3798vvPgmTpxINzc3qqioCD320qqXi0Qi6urqcvbs2Vy8eDHbt28vLCqNjY0pl8u5ffv2TMuiUCjYpUsXqqmp8fr16zl9qjlGUlISTUxM2KtXr/wW5YccOnSIABgaGprfouQIiYmJPHLkCLt16ya0eypXrhwnT56cb8WxMsPs2bMplUoLRB93hULB6OhohoaG8vHjx7x+/TpPnz7NvXv3csOGDVy0aBF9fHw4atQo9uvXj507d2bz5s1Zp04dVq1alSVLlhSKB/1KURaJRNTR0aGZmRkrVKjAmjVr0tnZmW5ubmzfvj0LFSpETU1Nenl5cdWqVdy2bRuPHDnCixcv8sKFC/Tz82ODBg2EXMzatWtz/vz5BT4/Pjg4mDNmzGC5cuUIgIaGhhw6dOhP+39/+PCB/fv3FyqN+/v7Z6no5OHDhwmAy5cvz4nTyFNOnjxJuVxOZ2fnTCu/aR4pW1tbAqC9vX2GngkpKSl0dnamvr5+nt2XaRFIe/bsyZP5CjrPnj3jhAkTWKxYMQKgpaUlZ8yYkWPVwPv160eZTPZLb3NoaCgHDRpEVVVV6unpcfr06TnW4jA1NZWbN2+mubk5JRIJ+/Xrlys1LZTkHHPmzCEAjh49mpGRkUL+9o/af0ZFRdHIyIjt27fPUxmLFSvG0aNHp9uWpgSntUC8efMmAXD16tW5IkNqaioNDAzYqVMnoSYJAJYtW5YHDx5kSkrKd/ndaU68//WEW1tbs0aNGjQzMxMi14oUKcL+/fvnitxKfoxS6c5Dhg8fThUVFZ4/f17Y9vr1a9rZ2fHcuXPpKmDb2NgwOjqa5ubm1NPT48qVK7l48WKGh4cTAIcOHUoAPHjwYJZkSXvgbdmyJbunlaukFXgrqJVo16xZQ5FI9F1LnD+JpKQkHjt2jB4eHkJriTJlynDixIl/nBU0JiaGRYoUYc+ePbN8jKSkJH7+/JmvXr3ivXv3ePHiRR45coTbtm3jqlWrOGfOHE6cOJFDhw5ljx496ObmRmdnZ9rZ2bFChQo0MzOjjo6OEJb9s4+amhqLFCnCkiVLsmrVqqxTpw6bN2/Ozp07s1+/fhw9ejR9fHy4aNEibtiwgXv37uXp06d5/fp1PnnyhKGhoYyOjv6t1+rDhw+sWLEiDQwMeO/ePX769ImrV6+ms7MzpVIpRSIRHR0duWjRogLfdi0iIoJr1qwRehfL5XJ26tSJx44d+6mnISYmhtOmTaOmpqZgwMxqKk1YWBgNDQ3ZpEmTAlF5PDMcPXqUqqqqbNKkSabPf+fOnRSJRJTL5dTV1eWqVasybLAYPXo0xWJxliIKskOxYsU4fPjwPJ2zoJOamsrTp0/T3d2dcrmcIpGIzs7O3Lp1K+Pi4rJ0zFWrVhEAV61alaHxb9++5YABA6iiokI9PT3OmDEjx5Tv+Ph4zpkzh7q6utTU1OTUqVMzHc2hJPfx8/MjAI4bN45xcXF0cnKitrY2PTw8qKKi8kNj3vr16wnkbcvYJk2asGnTpum2JSQkUCaTcfHixcK2Tp060djYONd+a/Xr16dYLKalpaXQKSTtU6xYMVpbW7NUqVIsUaLED9cd5cuXZ3x8vNB2Ny3SNi096E+M2PpTUSrdeURkZKTQk7Bfv36sVKkSTU1NKZfLWbt2bc6ZM4fdunUTxtvZ2TElJUVYXPbq1YuLFy8WLPhSqZQdO3bM0sLv6NGjFIvFHDNmTA6eYc6jUChoY2PDBg0a5LcoP8XHx4cGBgb5LUamSU5O5smTJ9mrVy/q6ekR+NZ6ztvbm0FBQX+cQqFQKBgTE8N3795x9OjRlEgk9Pf35759+7hx40YuXryY06dP5+jRo9mvXz+6u7uzRYsWrFu3LqtVq8ZSpUqxSJEiGfIqa2tr09TUlOXLl6ednR2dnZ3Zpk0benh4cMiQIZwwYQJnz57NlStXctu2bTx8+DAvXLjAu3fv8uXLlwwPD8/zqruPHj2imZkZZTIZxWIxxWIxnZycuHTp0gKdWkJ+M4IcOnSI7dq1o5qaGkUiERs0aMANGzb8crGekpLCNWvW0MTEhDKZjMOGDctWmxSFQsGWLVtSX1//jwtbPnDgAFVUVOjq6sqEhIRM7btt2zZhIdeuXbtMnXtamPfcuXMzK3K26dixI21tbfN83j+FyMhIrlmzhvb29gRAHR0d9unTh1euXMnw8//SpUuUyWTs169fpud/8+YN+/fvTxUVFerr63PmzJmMjo7O9HF+xOfPnzlixAiqqKjQ2NiYq1ev/iNrL/yN+Pr6EgC9vb2ZmJhIV1dXqqmp8cKFC4yPj6elpSVr1qz5XV/u1NRUWltbs3r16llui5tZRo0aRXNz8++2W1tbs2vXrsK/X758SRUVFU6dOjVH51coFFywYIGQFvb48WPeu3fvtwb9/00Xa9KkieC0SmvnCICLFy/mixcvCICFCxdW1sLJI5RKdx6RZu1PuxFKlixJCwsL2tnZCfmyUqmUM2fOpIuLCw0MDGhnZ8eiRYtSX1+fcrmc5cqV46xZswiATk5OmV48keTjx4+pra3NZs2affdQK2ikFbLIzSIV2WXQoEGsWLFifouRIZKTk3n69Gn27t1bKMpRsmRJjh07lnfu3MkXRTs5OZmfP3/m69evGRQUxEuXLvHo0aPcvn274FWeNGkShw0bxp49e7Jt27Zs1KgRa9asyQoVKrBYsWLU1dX97UtIVVWVBgYGLFmyJK2srOjo6MhmzZqxU6dO7Nu3L0eNGkUfHx8uXLiQ69ev5549e3jq1Cleu3aNjx8/ZmhoKKOiovLsZZ8TvH//nkuXLqWTkxPFYrFgMFBTU+OhQ4fyW7xfolAoeO3aNQ4cOJCFCxcm8K0HuJ+f32+98QqFgocPHxbCFTt27MiXL19mW6Z169YRAPfu3ZvtY+Ulu3fvplQqpZubW6YicpKSkoSIKlVVVR44cCBT8967d4/q6urs1KlTvjxblixZQplMlmUP7n+Jf/75h+PHj6epqakQ6eTr6/vLe+3Nmzc0NDSko6NjtoyIISEhQnh64cKFOWvWrBzzGL58+VLIha1QoQIPHz78xxmU/yZ8fHwIgJMmTWJKSgrd3d0plUrTFaK9ePEiAXDhwoXf7X/p0iUC4Lp16/JE3k2bNhHAdzUI+vXrx3LlyqXbNnz4cGpqauZYWkNSUhJ79+5N4FsbNbFYzJUrVwrz/2q9U6hQIW7atEko+EaSVlZWwvcaGhqMjIxkUlKSoHSXL19e+azMA5RKdx5w4sQJSqVSli1blps3b2ZSUhKbNWtGTU1Namlp0cHBgf3796eJiYkQdnr8+HFh/7179xIAJ0yYwHr16rFYsWJZUpi/fPnC0qVLs3z58jlayCS3aNeuHS0tLQu0otO2bdsC7YlPSUnh2bNn2bdvXxoYGBAAS5QowdGjR/809/V3KBQKxsbG8v3793z69Clv3LjBM2fOcP/+/dy0aROXLFnCGTNmcMyYMezfvz/d3d3p6upKJycnVq9enaVLl6ahoaFQVfNXHy0tLRYtWpTlypWjra0tGzZsKHiVBw8eTG9vb/r5+XHFihXcunWr4FX28vIS+idnxTj1pxIaGspFixbR0dFR6Evt7OzM1atXMywsjFFRUXR0dKSGhsZvq03nBy9fvuTUqVNpaWlJADQ2NubIkSN57969DO1/8+ZNOjk5EQDr1KmTY/UqXrx4QU1NTXp4eOTI8fKK7du3UyKRsGPHjpny9F25coVly5YVFmSZrVnx+fNnWlhY5FnhtB9x584dAuCFCxfyZf4/kZSUFJ46dYqdO3emmpoaxWIxGzVqxO3bt6dLSYiLi6O1tTXNzMz48ePHHJk7ODiYffr0oUwmo4GBAf38/HJM+b5x44YQNejk5JSrvZWV/JipU6cSAKdMmUKFQsGBAwdSJBL9sCbRgAEDqK6u/sMaEB07dqSRkVGOpST8ilu3bhEAr1y5km77+vXrKRKJ0snw+fNn6urq5kiO9OfPn1mvXj3KZDKuXbuWJGlvby8UQ3vy5Em6gqctWrTgrl27ePLkSc6cOTNdfjdJXrhwQYhoBL4VriO/hcoD4PTp0ykSifLMmPFfRql05zK3bt2iuro6GzVqlG7xMXHiRPr4+KRbxNnZ2XHLli0EvjWxb9CgAe/evct//vmHAIScln9XU8wIycnJbNiwIQsVKsTnz5/nyLnlJsHBwZRIJFy6dGl+i/JLHBwc2Llz5/wWIx0pKSk8d+4c+/fvL1RzNjc354gRI3jmzBm+evWK9+/fZ2BgII8dO8YdO3Zw9erVnDt37v9j76zDoljfPv7MJkt3p4CUCiIhoiiiIIiBiNhYqIiBcEwsFBUDA8XGPnZhd3d3d2IiCFK7833/4N35uYeQWGRBPte11znO7sw8s8w+89z1vTFx4kRERkaiX79+6NSpE1q1aoVGjRqhTp06MDY2hpqamoSYR1EpTZqamsyiu0mTJmjdujW6dOmCAQMGYMSIEZgyZQrmz5+PlStXYtu2bTh8+DAuXryI+/fv4+3bt+WOKv/8+RN6enoSKWDVldevX2PevHlwd3cHRVHgcDjw9fVFUlJSoenUmZmZaNGiRQHnXmXx7ds3LF26lElzVVBQQM+ePXH48OESOxdfvHjBRLRsbGywZ88eqUW0hEIh3N3dYWpqWiWclWLWrVsHFouFHj16lPh7TEtLQ3h4OFMvr6urW+o6f7Fwmrq6eqUKGgqFQigqKmL69OmVNoaqzPfv37F8+XI0atQIhBCoqqpi4MCBuHDhAlMTfu3aNamf9+XLl+jfvz84HA60tbUxe/ZsqThuxBkw4pZJ0sqAqeH3TJo0CYQQTJkyBQAwbty4YnUA0tPTYWRkhJYtWxaYx1+/fg2BQPBHyiN//vwJiqKwYsUKie13794FIaSA43rWrFlgs9nlUtB/9OgRLC0toaGhIaH/NG3aNCgoKDBBBLHekfilp6eHCRMmoH///vDy8kLz5s0hLy/PZK+IX2w2G+7u7vD09MThw4dBCMGBAwfg4+NTIHpfg/SpMbormMaNG8PBwQEfP37EyZMnsXPnTqxatQr16tXDiRMnCoinAcCUKVNACEFycjJcXFzw8uVLEEJgaGgIc3PzMokADR8+HGw2+4+L2ZSVESNGQFVVVWo1XhVF7dq1ERUVVWHHp2kaP3/+REpKCh4/foyrV6/i+PHjTFQ5MTER06dPx+jRoxEQEAArKyumhzKPx4OamhrU1dVLHFXW19eHtbU1XFxc0KJFC3To0AG9evXC0KFDER0djRkzZmDx4sX4999/sWfPHpw6dQo3btzA06dP8enTJ5mKKickJIDFYlVLkZCXL18iPj6eaf/B4/Hg7++P1atX49u3b7/dPysrC61btwaPxyt12rA0yMnJwc6dO9GhQwfweDwmorZ+/fpSRbd+rd3U1dXFsmXLpF67OX36dFAU9UcFfMrLypUrQVEU+vbtW2KDe8eOHdDX14e8vDwsLS2hqqpaJiFFcSnVkSNHSr2vtGnRogX8/f0rexhVnkePHmHs2LESC/guXbpUaNeOFy9eoF+/fozxHR8fLxXjOy8vDytWrICenh54PB4iIyPx9etXKYy4hv9C0zQmTJgAQgimTZsG4H8ivjNnzix23/379zPBpv8yceJE8Hg8PHv2rCKGLYGlpSUiIiIktgmFQigoKGDGjBkS27OysmBiYoKAgIAynevYsWNQU1ODjY1NgeDYzZs3QQiRmFfXrFnz2yDIry8VFRWsX78eAHDw4EHUq1cPmpqaTHtYQgiio6PLNPYaSkaN0V2B3Lp1i7nRC/thyMvLo0GDBvjx4weys7Ohra0NT09P+Pv7Q1dXF4MGDYKrqytT26yiolImA0Jci/ir2qIs8+PHD6iqqmLEiBGVPZTfoqysXGiPdKFQiNTUVLx69Qp37tzB+fPncfDgQWzZsgUrVqzAnDlzMGnSJERGRiI0NBTBwcHw9fWFu7s76tatCxMTE6ipqYHD4RQ7ibLZbMjJyTH3F4/Hg6mpKVq0aIHQ0FD8888/mDx5MubNm8dElQ8dOoQLFy7g3r17ePPmDdLS0mQ6hb+sZGVlwcDAAN27d6/soUiF58+fY+bMmXB2dmbqbNu2bYt169bh+/fvpT5eTk4OAgMDweFwsGXLlgoYsSQ0TeP8+fMICwtjUt3q16+POXPmlFqYTKxSrKamBgUFBcTExFSIcuz169fB5XJlXnTyV5YuXQpCCAYOHFii3/WbN2/Qrl07EELQunVrtGvXrkCXjZIiFk6bPXt2WYYudSZOnAh1dfVqOb9VBgcOHACLxYKNjQ2Tfu7r64vNmzeXuSPA73j+/Dn69u0LNpsNXV1dzJ07Vyq1pxkZGZg8ebJUuhrUUBCaphEdHQ1CCOLi4gDkd3shJF+1vCT06NEDqqqqBZ4PmZmZMDQ0LLNxWxoCAgIKLSH08PBAx44dC2xfv349CCHFts8rjKVLl4LD4cDb27vQ5zlN09DX12dSw8WcPn0aPB6PEVsr7KWjowMjIyMJTY99+/aBx+Mxz7bMzEzm82vWrCnV2GsoOTVGdwVB0zQcHR1BCIGWlhaio6PRu3dv1KlTB5aWlkhOTmbStnR1ddGpUyd4e3sDyE/xGz9+POTl5WFvb4+hQ4eCx+OVKepw7tw58Hg8hIaGVhkBkcTERLDZbLx69eqPnlccVf748SOePHmCa9eu4cSJE0hOTsa6deuQmJiIuLg4jB07FoMHD5ZIZ3VycoKVlRX09PQKtHQo7KWoqAh9fX1YWVnB2dkZXl5eCAgIQEhICIYMGYLo6GjExcVh0aJFWL9+PXbv3o2TJ0/i2rVr2Lp1K/r3789oAOjr62PYsGE4d+5czeLyPyQmJoLFYuHBgweVPZQy8eTJE0yfPh0NGjRg9B4CAgKwYcMGqaQ65+XloWvXrmCxWEwdmLR58uQJJk6cCHNzcyZjZ9SoUWWaz/5kP96fP3/C1tYWDg4Of1xtvqwsWLAAhOQL7/xuvhcKhUhISICioiL09PSwdetWjBgxAhRFlckJc/v2bcjLy5e5q0ZFIE6frKq/f1ni6dOnUFNTQ6tWrRin8tKlS+Hm5sakn4eFheHy5csV8vd/9uwZ+vTpwxjf8+bNk4rxnZKSgkGDBoHNZsPExATr16+veY6WE5qmMXr0aBBCmKDEli1bwGKxMGjQoBLfH1++fIGWlhYCAwMLvCcuxTx+/LhUx/5fxo8fD11d3QLbo6KiClU2F4lEqF+/Ptzc3Ep0nUKhEMOGDQMhBIMHDy42U6tfv36wsrIqsD06OhpcLhe9e/dG27Zt4eHhAR8fH4SEhKBhw4bIy8tj6ruB/FpuHR0dcLlcpgSIpmlQFIVGjRqBy+X+8fX330KN0V0B0DSNIUOGMCk14gVb+/btmTq5pk2bYtOmTTA1NWWMtA4dOqBp06aoW7cu6tevD0IIZsyYAWVlZYwcObLU43j9+jV0dHTQuHHjKrNoFIlEqF27NoKCgkq8j1AoxPfv3/H69WvcvXsX58+fx6FDh7B161YkJSVh7ty5iImJQVRUFEJDQ9G5c2f4+fmhcePGqFevHkxNTaGurv7bqDKHw4G6ujpMTU1Rr149ODk5gRCCZs2aITQ0FFFRUYiJicHcuXORlJSErVu34tChQzh//jzu3r2L169f4/v376UWwRMrOUdFRcHY2Jhx1AwePBhnzpypWSAUQ3Z2NoyMjNClS5fKHkqJefToEWJjYxm1UYFAgI4dO2Lz5s0VUm4hFArRp08fUBSF5cuXS+WYX758QWJiIpP+rqSkhN69e+P48eNlvl+PHTvGODLbt29f4YZUREQE+Hx+lelVP2fOHBBCEBkZ+dvF3s2bN+Hi4gKKohAWFobv378jISEBhBDMmzev1OcWC6fZ29tXmnBaYaSlpYHFYhWoyayhdKSnp8POzg6WlpZITU0t8P7Dhw8xZswYGBgYgJD8vsAzZ86skHaET58+Ra9evcBms6Gnp4f58+dLJUL98OFDtG/fHoQQODo64tixY1IY7d8HTdMYOXIkCCGYM2cOgPwMCS6Xi65du5Z6/hdnz2zbtq3Aedzc3FCvXr0K7cSzadMmEELw+fPnQrd/+vSpwD5Hjx4tdMz/JS0tDb6+viXWLxKLKv839TwnJweenp5QUFDA4cOHme2rV68uIKq2du1apttL48aNoampiQULFiA9PR2E5CvDKygooG3btjLjPK1O1BjdFYA4hSYuLg5btmzB4sWLMW3aNNSuXRt79uwpUMedkZEBOTk5qKio4PPnz/Dw8MDVq1dBCEFgYCBYLFapBWkyMzPh6OgIY2NjqamLShOappGVlYWPHz/i6dOnuH79Ok6ePMnU//zzzz+Ii4tDdHQ0hgwZgpCQEAQEBMDLywvOzs6wsrKCvr4+FBUVfxtVVlBQgJ6eHqysrODk5ITmzZujffv26NmzJwYPHoyxY8ciLi4OiYmJWLduHZKTk3HixAlcu3YNT548wcePH/Hz588CE9CFCxdACCmxsnJpv58rV65gxIgRMDExASEE2traGDRoEE6ePCnz7d5kicWLF4OiKNy7d6+yh1Ik9+/fR0xMDOrWrcvcs8HBwdi6dWuFpE3/F5FIhEGDBpWrDCUrKwvbtm1Du3btwOVywWaz0bp1a2zatKlcEak7d+7Az88PhBC4urr+ETXqI0eOgBCCuXPnVvi5pEFcXBwIIRg9enSxC6XMzExG2d/Ozg7nzp0DkN9WjKKoMulTCIVC+Pj4QF1dXSaFqezt7auc6rwsIRKJEBAQACUlJdy/f7/YzwqFQhw8eBCdO3cGn88Hi8WCn58ftmzZInW9jydPniAkJAQsFgv6+vpYsGCBVIzvM2fOMM5CX19fpsdxDb+HpmlERUVJOO/OnDkDgUCANm3alKpl4a/HbNeuHXR0dArolVy+fBmEECxZskQq4y8MsWjayZMnJbaLe1zv27ev0P18fX1hYWFR5DU/f/4cdnZ2UFFRkTCUiyMtLQ1cLrfQZ3R6ejrMzMxACEGrVq2we/du/PPPP2jZsiV8fHygpKSEhg0bMsGlNWvW4N27d1i1ahUWLFjAODfu3buHwYMHg8PhoEuXLlUmYFdVqDG6pYxQKIS+vj4MDQ0LjZzy+XxYWloyLSsaNmwIIL+HHofDwbx58zB69GisW7eO2ee/Yg2/g6ZpdOrUCfLy8rhx44ZUr08kEiEtLQ1v3rzBvXv3cOHCBSaqvHLlSsybNw+TJ0/GP//8g/79+zNR5SZNmsDe3h5mZmbQ0NAAl8st1lBmsVhQU1ODiYkJ6tatC3d3d/j6+iI4OBihoaGIjIzEpEmTMGfOHKxYsQJbtmzBwYMHcf78edy5cwevXr1Camqq1EWVfmXXrl0ghEjNqUHTNK5du4ZRo0Yxk6eWlhYGDhyI48eP1xjaZSQnJwfGxsYIDg6u7KEw0DSNO3fuYOLEiYyarqKiIrp27YodO3ZUSr/MXxdMvxO5ESMSiXD69GmEhoZCVVUVhBA4Oztj/vz55f5dvH37Fn379gWLxYK5uTm2bNnyRzzv3759g4GBAby8vKpEFom4Fc+ECROK/X4OHjwIMzMz8Pl8TJ06lVlMnTlzBnw+H507dy7T9Y4ePVpmhNMKY9CgQahdu3ZlD6PKMmnSJFAUhd27d5dqv9TUVCxZsoQxYNXU1BAeHo4rV65I9Xf8+PFj9OjRAywWCwYGBkhMTCy3gU/TNLZu3QoLCwuwWCz06dOn1Cr+fxs0TSMiIgKEECQkJADIb9unoqKCZs2aleuZ9u7dO6ioqBTqPAsJCYGmpmahGRjSICcnB1wut0AkmqZpaGhoYNKkSYXud/v2bVAUVaiBfObMGWhqasLc3LzUGVvNmzeHr69voe+JHQTiUi4lJSXUqlWLyUAR2yTy8vJo2rQpRo8ezRjdHh4eaNq0KYB8LRPxWjw4OLhKPAerCjVGtxTJyMhgHjAleZmYmDCp5mIZ/9q1a8PX15epzQsLCyv1Ayo2NrZAakt2djY+ffqEp0+f4saNGzh16hT27NmDf//9F4sXL8aMGTMQHR2NoUOHolevXujQoQNatGgBFxcXWFtbQ19fH0pKSr+9Jnl5eejq6qJ27dpMVLldu3bo0aMHwsPDMWbMGEyfPp2JKu/atQvHjx/H1atXsXfvXhBCsHr16iqR1rJkyRKw2exyGcM0TePGjRsYM2YMM1FqaGigf//+OHr0aIU6Df4mli1bBoqiKjVqQdM0bt68iXHjxjE9kJWVldGjRw8kJyfLhIgPTdNMOxdxP9XCePjwIaKjo2FqasrMZdHR0VJJ+U5LS0N0dDQEAgE0NDQwf/78P+pt79KlC1RVVfHmzZs/ds6yQNM0xo8fD0L+14qnMD5+/MjoTzRv3hyPHz9m3rt//z7U1NTg6elZJkNly5YtEnWbsoi49vO/6aE1/J6dO3f+9v4qCQ8ePMCoUaOgp6cHQgjs7Owwa9asUgsoFsfDhw/RvXt3sFgsGBoaYtGiReU2vnNycpCQkABNTU0IBAJER0dXqbaBfwqapjF06FAQQhjj9NGjR9DS0oKTk5NUemovX74chJACUeF3795BQUEBkZGR5T5HUdSpUwdhYWEFtrdq1QqtW7cucr/evXtDU1NT4p5Zs2YNeDwemjZtWmhLz98xe/ZsyMnJFVnG4+Xlhfr16+Ps2bOIi4vDqFGjMGHCBCxevBitWrWCSCSSqO9etWoVhg8fDkII0zM9NTVVYl0vK8KY1YEao1tKFGZw6+jowNzcHHw+H3JyctDX15doaE8Igbe3N54+fQp3d3e4uLiAEILevXvDw8MD1tbWSE9Px9u3b3H//n1cvHgRhw8fxrZt27By5UrMnz8fU6ZMwYgRIzBgwAB06dKFEVzS1dVFrVq1oKmpWeCc/32x2WyoqanB2NgYderUQaNGjdCqVSt06tQJ/fr1Q2RkJCZOnIj4+HgsX74cmzdvxoEDB3Du3Dkmqvzt27dyG4j9+vWDvr5+mVKQKoOYmJhCBTZ+B03TuHXrFqKjo2FpaQlCCNTV1dGvXz8cPny4ylx/VSI3NxempqaFqo1WJOLshTFjxjB/a1VVVYSEhGDv3r0y1WLtV8SOu1/TlT9+/IiEhARGPV1FRQWhoaE4deqUVDzhubm5SExMhJaWFuTk5DB69OgyqbKXB3Hv0w0bNvzR85aWX4WKisqEomkaK1asgJqaGjQ0NLBmzRoJJ8q7d+9gbGyMunXrlilKdOfOHSgoKKBz584y7SQVt9ysjNZ4VZm7d+9CUVERgYGBUvv75uXl4cCBAwgODgafzwebzYa/vz+2bdsmtbnwwYMH6NatGyiKgpGRERYvXlxup933798xduxYyMnJQUtLCwsXLqx5Tv8/NE1j8ODBIIRg8eLFAIBXr17ByMgItra2UnN20TQNT09PmJqaFtA2mTp1KjgcTrn6YxdH586d0aRJkwLbx48fDy0trSJ/H2/evGGcNSKRiJmz+/btW+Z78v79+8WmtV+4cAF8Ph+dOnWSuEcLq+8G8r87RUVFuLm5MZ//9u0bCCGMInpVWpfLOjVGtxSgaRodOnRgjFgVFRWsW7cOOTk5mDBhAmJjY5m0mIyMDJiamkoYwk2aNMGiRYuQkZHB1IKXJFIuEAigo6MDS0tLNGjQAM7OzmCz2TA2NkZYWBhGjx6NadOmYeHChVi7di127dqFY8eO4cqVK3j06BE+fPiAzMxMmVgwffr0CXw+n+nlWBUICwuDg4NDiT9/9+5dTJgwgYlyqqqqok+fPjh48GDNhPYHEGstVEQN/q+I6/FHjhyJWrVqMU6VPn364MCBA1WmRkoszOXr6ws/Pz+w2WxwOBy0bdsWW7dulVpknqZpbN++HZaWlqAoCr169cLr16+lcuzS8Pr1a6iqqqJz585//NylgaZpREZGFltz/uDBA3h4eIAQgp49exZY+KalpcHe3h6GhoZliuh/+/YN5ubmqFev3h/RHCgPNE3DwMCgTGKkfytfv36Fubk56tatWyHijUD+PbRo0SIm2KCuro7Bgwfj6tWrUlmTPHjwAF26dAFFUTA2NsbSpUvLPfe+efMGvXr1AkVRsLS0xPbt22Vi/VRZiEQihIWFgRCCpUuXAsh3ztauXRumpqZST8l/+vQpBAKBhC4SkK8nYmpqWmzUuTzExsZCTU2twN969+7dIITg5cuXRe4rdta0atUKFEUhPj6+XPcMTdMwMzNDeHh4kZ/Ztm0bWCwWmjVrhkuXLgEARo4cydR3KysrIywsDP379wchBHp6elixYgXc3NzQvHlzpke6u7s7Y2+sXbu2zGOu4X/UGN1S4OLFi8yNqaysjGvXruHr16+4evUqXF1dcfLkyQLiaYcPH5ao+b558yaEQiETIdfW1kZiYiI2bdqE/fv34+zZs7h9+zZevnxZaFT58+fPMDMzg729vcwvggojNjYWAoGgTOk2lUVAQAB8fHyK/cz9+/cxadIkpm5XRUUFvXr1wv79+6uM8VVdyM3NRa1atdChQwepH5umaVy8eJFpI0IIgaamJkJDQ3Ho0KEq5VQRiUQ4fvw4evfuDT6fD0LyRfwWLFgg9RTdc+fOMa0TfXx8cPPmTakev6SIRCJ4eXnBwMCggFiPLPFrVGnhwoUF3s/OzsakSZPA4/FgYWGBo0ePFvhMTk4OvLy8oKKiUiZldqFQiFatWsmscFphBAUFwd3dvbKHUSXIy8tDy5Yt/+jf9969exg5ciR0dXVBCEHdunURHx8vlXaA9+7dQ+fOnUFRFExMTLBs2bJyz8e3bt1Cq1atQAhBo0aNGEHCvwmRSIQBAwaAoiimO0BqaiocHBygq6tbQGFbWsTHx4OiKJw/f15i+9atW0EIwcGDB6V+TnGZxbt37yS2f/jwAYQQbN26tch97927xzis9+zZI5XxhIeHw9TUtFjjXSyGRghBgwYNEB8fj/Xr12PlypXQ1tZmNFhYLBYsLCygq6uLnJwcnD17Fra2ttDR0cG+ffsYG0VJSUkmRZmrGjVGtxTo2bOnxI0pluMXvxQVFaGqqso8wGxtbeHi4gJDQ0PmMxMmTEBKSgpzjEePHpX4/Lm5uWjWrBm0tLSK9bjJKjk5OdDT08OAAQMqeyilolGjRggJCSmw/eHDh5g8eTLq1KkjUbe7Z88emU0n/ltYtWoVCCFSERgUiUQ4d+4chg8fDiMjI8Y4HThwYJWsx7937x5Gjx7NXEutWrUwceJETJ8+HRRFISQkRGpifo8fP0ZgYCAIIbC3ty+xemtFMXfuXBBCZFYMDJBc5C5btqzA+6dPn4a1tTU4HA7Gjh1bqHCRSCRCt27dwOPxCqjxlpQxY8aAxWJV+t+sNMybNw98Pr9m/i0BUVFRYLPZhTpsKpq8vDzs378fQUFB4PF4YLPZaNOmDbZv315uJ/Xdu3fRqVMnUBQFU1NTrFixotzG95EjR5jWjh06dJDQS6jOiEQi9OvXDxRFYeXKlQDyOyO4u7tDTU2tQrVThEIhXFxcYGNjI/F7pmkaHh4esLGxkbqT+8mTJ4XWkwOAoaFhkVk0ly9fhq6uLtTU1EBRFG7fvi2V8YiN4eI0VL5//w6BQIBu3brB19dXQrxYW1sbfn5+mDNnDho0aID79+8z2bjp6elgsVgYN24cRCIR1NTUmP1cXFxkqiVkVaTG6C4nX79+ZR4OhBAYGBhg4sSJ0NHRQadOnWBmZsbUesvLy2P+/PkwNjbGw4cP8ebNG+Zm1tXVxbx580BRVKlb4oSFhYHL5f6RVjoVgVipXZZbOhVGrVq1MGrUKAD5RkRsbCzq1avHOFq6desmMwJZNeSTl5cHCwsLtGvXrkz7i9W6hw4dyiiC6urqYtCgQThx4kSVU5j/8OED5syZw/S/VlNTw8CBA3Hu3DkJL/qGDRvAZrMRHBxcrgXNp0+fGA+8kZER1qxZU+nKqHfv3gWfzy+QsihLCIVC9O7dGxRFYdWqVRLvffv2Df369QMhBG5ubsUueEeNGgVCCDZv3lymcYijSSVVt5cVrly5AkJIgehYDZKsX78ehJStV7u0+fr1KxITExkNCQ0NDQwdOhTXr18vV3runTt3EBQUBEIIzMzMkJSUVK45TSQSYe3atTAyMgKHw0F4eHi1jgiKRCL06dMHFEVh9erVAPIDJ61atYKCggIuXrxY4WO4c+cOuFwuxo8fL7H9+vXroCiKUU+XFkKhEAKBgOk7/isBAQHw9PQssH3z5s2Qk5ODm5sbXr9+DQsLiyJVx0tLZmYm5OTkEB8fX+znwsLCoKCggFu3boGmaWRkZCAnJwdCoRBt2rRhRNXOnTuHYcOGgaZp5jkjLvESC/yKX1WpBFQWqTG6y8natWvB4XCgo6ODXbt2QSgUYu3atZCTk4OpqSl0dXWxadMmzJgxA2w2GxRFwcfHBxcvXkReXp5EirmZmRkCAgJKdf5FixaBEILly5dX0BVWLDRNw9HR8bdp2rKIvLw8/Pz8GE+3goICunTpgp07d1ZKy6caSsaaNWtACMG1a9dK9HmhUIgTJ04gPDycUd/V19fHkCFDcPr06SpnaGdkZODff/9Fq1atwGKxwOPx0KFDB+zcubPYSOD27dvB5XLRvn37UkcMMzMzMXXqVCgpKUFZWRlxcXEy8RvJycmBg4MDbG1tZWI8hZGXl8eoMq9fv57ZTtM0Nm7cCG1tbSgrK2Px4sXFOjDEHTHK2ntcLJwWHBxc5epYc3NzIS8vL9Mq65XNlStXICcnh5CQEJn7+969excjRoxg0s/r1auHOXPmlMu4vX37Njp27Mhk9axcubJc2UlZWVmYMWMGVFRUoKSkhNjY2GoXFRQKhejVqxdYLBYjyiUUCpnMhD+ZHTFx4kRwOJwCGi2hoaFQU1OTeqligwYN0KdPnwLbp02bBmVlZWbupWkaMTExIISgW7duTNBF7LCU1nfk6+sLLy+vYj+Tnp4OTU1NaGho4OrVq8z2/4qq3bt3DyEhIRg4cCAIIbCwsGA+q62tLWF0GxkZVbk1jyxRY3SXg4yMDBgZGcHQ0FBC+Ofly5do2LBhgVpuJycnBAcHg8vlQktLC7Vq1YKTk5PEDX3s2LESn//EiRPgcDgYMmSINC/rj3LmzBkQQnDgwIHKHkqJePbsGeLi4mBvbw9CCHg8HoKDg7F9+3aZXbTXIEleXh5q166NNm3aFPuZY8eOYeDAgcxDx9DQEBERETh37lylR2dLi1AoxJEjR9CzZ08oKiqCEILGjRtjyZIlpaph3rt3L/h8Plq1alWi+10oFCIpKQn6+vrgcrmIiIiQqdZNo0ePBpfLxfXr1yt7KIWSm5uLzp07g81mS0Snnz9/ztSUduzYsUCt4X/Zvn07KIoqc1udqiScVhTNmjVD+/btK3sYMklKSgoMDQ3h4uIi05lZeXl52Lt3Lzp27Agej8cIO+7cubPM6ee3bt1ihHDNzc2xevXqchnfX758QUREBLhcLvT19ZGUlFQtjBShUMj0Q//3338B5BuYffv2BZvNxs6dO//oeLKzs2FnZwcnJyeJv9fHjx+hrKyMwYMHS/V8ISEhcHFxKbD96NGjTKr3z58/0aVLFxBCEBsbK+G8omkaDRs2hKOjo1TWDwsWLACXy/1tO7YRI0aAzWaDzWajS5cuOHfuHEaMGMGIqikqKkJJSYlRKh88eDCaN28OV1dXJgNOLHQo/v+aThBlp8boLgdLliwBi8XC3bt3cebMGSxbtgzTp0+HpaUlduzYgXv37jF1EgDQsGFDZGdnM43pRSIRzMzMmBu5VatWJfYwP3/+HBoaGvDy8qpytaO/EhgYCGtra5k2Yl6+fIlZs2YxaW4CgQC+vr7Ftm2oQbYRp1FeuXKF2Zabm4vDhw8jNDQUmpqaICS//3RUVBQuXLgg0/doUdy6dQv//PMP9PX1QQiBpaUlJk+ejGfPnpX5mEeOHIFAIEDz5s2LNMBomsaBAwdQt25dEEIQHBxcYcI6ZeXMmTOgKEpm0+VycnIQGBgILpeLHTt2AMg3OmbNmgWBQAAjIyPs3r37t8c5e/Ys5OTkEBwcXKZ7WCgUwtfXF2pqauW6byqb6OjoYtv7/K3k5OTA3d0durq6v3XeyBJfvnzBggULmDapmpqaGDZsWJn1Om7cuIGAgAAm0rdmzZpyra2ePXuGzp07gxCCOnXqYP/+/VX23hMKhejWrRvYbDY2btwIIH+Oj4qKAiEEa9asqZRxXbx4ERRFFchgmTVrFthsdpmEIoti5syZUFBQKDCHintaz58/H66urhAIBEUKq4mDTL9mLJWVZ8+egRDyW2eH+HOEEMjJyTEBhPr168PGxgYURYHNZsPNzQ2GhoYwNTWFnZ0dcnNzmTIMQgjTh50QUuO8LAc1RncZoWkadnZ2MDc3h0AgYG5GsbdILIhmYmKC9PR0JCQkQFtbG40bN2ZqQZ89e8Ys7gkhJRbhSE9PR506dWBubl6l1L7/y4sXL8BisbBkyZLKHkoBXr16hfj4eLi6ujKTVYcOHbBp0yb8+PEDZ8+erZJ16DXkIxQKYW1tjVatWuHAgQPo27cv48k1MzPDyJEjcfny5Sq5SHr79i1mzZrF6Atoampi8ODBuHTpktSu5/Tp01BUVIS7uzvS0tIk3rt27Rq8vLxASH47xD9R41da0tLSYGpqCnd3d5mMQmVnZ6Nt27bg8XiMYX358mU4ODiAxWIhIiLitxEOIL97gpqaGpo1a1ZmEbGxY8dWOeG0whC3wXny5EllD0Wm6N+/P3g8XpWud799+zaioqKYrCR7e3vMnTsXnz59KvWxrl+/jnbt2jFOynXr1pVrjrh06RLTvq958+YlLmuSFfLy8tClS5cC2TaxsbEghEi9frq0DB8+HHJychK/65ycHFhYWKBly5ZSe+aJ548XL14UeM/ExASKiorQ19eXcOQXRvv27WFiYiKVjBIrKyv069evyPdpmsbBgwehpKTE2BkDBgzA6NGjMXDgQERERCA+Ph4fPnwAACQkJGDTpk3w9/fH1atXme4lqqqqeP36tYTxLt6nhtJRY3SXkU2bNjEpGwEBATh+/Dhat27NpGrY2NgwAgQKCgpQUlLCnTt3kJGRgTp16oDNZkvUStSrV69Ek4NIJEL79u2hpKQkVS9eZRAZGQk1NTWZqXt68+YN5s6dCzc3NxBCwOfz0b59e2zYsKHAAnfbtm0ghODr16+VNNoaykp2djb27t3LLITEkY0xY8bg2rVrVdLQ/vHjB9asWYMWLVqAoijw+XwEBQVh9+7dFdau7OLFi1BVVYWzszO+fv2Kly9fonv37iCEwNraGsnJyTL7Xfbu3RuKiooy2fIqKysLvr6+4PP5OHDgANLT0zF06FCwWCw4ODj8dlEn5v379zAxMUGdOnWQmppaprGI57kZM2aUaX9ZIjU1VUL8qQZg8eLFIIQgKSmpsociFXJzc7Fnzx506NABXC4XHA4H7du3x65du0o9D167dg1t27YFIQS1a9fG+vXry2x80zSN3bt3w8bGBoQQdO/evUp0msnLy0NwcDA4HI5E9HbhwoUghGDy5MmVOLp8MjIyYGZmxmSPiklOTgYhpETZQCVBbHT+t+1XcnIy2Gw25OXlS9SX/OHDh2Cz2Zg9e3a5xzR8+HDo6+sX+py9evUqmjdvDkII7OzsmLUOi8UqoAF148YNuLi4oHbt2nj58iUsLS2hoaHB7BMVFYX09HTm31wuF7169Sr3+P9GaozuMvD8+XOoqKjAwsJCImVywoQJiI2NlUgpr1OnDnR1dSEnJ8fUTrq7u8Pb25tJ+SSEYOnSpSU69/jx40FRlNT6/VUW6enpUFZWxujRoyt1HO/evcP8+fPh7u7O1Gi3bdsW69evLxDB+5WFCxeCy+XKrFFRgyRZWVlITk5Gjx49oKKiwiykNDU14e7uXiX/jnl5eThw4AC6du0KeXl5EELQtGlTrFixAt+/f/8jY7h+/TrU1dWhpaUFHo8HHR0dLFmyRKZLXnbs2AFCCNPqRpbIzMxEy5YtIRAIcOTIESQnJ8PQ0BDy8vKYPXt2ib/XtLQ0ODg4wNDQEG/evCnTWO7evVtlhdOKok6dOggNDa3sYcgEp0+fBofDkXrtq6zw+fNnJCQkMHWpWlpaiIiIKCC89TuuXr2KNm3aMM7EDRs2lNn4zsvLw9KlS6Grqwsej4d//vmnVJoafxJxejGHw2HKW4D/dZuJjIyUmXlBXFf96zqapmm0aNEClpaW5W43Jz6esrIypk+fzvx7xowZoCgK9erVA5/PL/F5wsLCoKqqWu6gzZEjR0AIwc2bN5ltT58+ZcoabG1tsXv3btA0jdGjR0voR7m7u+Pff/9lMqBomsY///zDRLd/jWo7OjoypWJiI15OTq5KZ9pWFjVGdykRiUSwt7eHmZmZROpSUeJpzs7OePToETgcDry9vZGSkgIVFRX4+/sz/byVlZXx48eP35578+bNIIQgLi6uIi7tj5KQkAA2m13mBWF5eP/+PRYsWIAmTZqAoihwuVz4+/tj7dq1JTZWxo8fD0NDwwoeaQ3l4efPn9i5cye6du3KpFfZ2tpiwoQJuHPnDmiaZn5TVSW1kqZpXLt2DcOHD4eOjg4IIbCxscG0adP+eOQkOzsbc+bMgbKyMiiKgpaWlsyn7n748AGamppo3769zCwYxfz48QPNmjWDgoICtm3bxvQx9/X1LTSlsShycnLQokULqKiolLlf7rdv32BhYYG6detWWeG0wujfvz9sbW0rexiVzqtXr6ClpYVmzZpVWCaMLHHr1i1ERkYy2YX169fH/PnzSyXqeOXKFbRu3ZqZczdu3Fhm4/vHjx+YNGkSFBQUoKamhvj4eJnqIZ+bm8voSezatYvZLo7q9unTR+bmz759+0JZWVliTXnnzh2wWCypRJUBoFGjRujWrRtycnLQu3dvEEIQHR3N1GqXtHQgJSUFioqKiIqKKtd4srOzoaCggGnTpuHjx48YMmQIuFwuDAwMCgj4iduD/WpQE0LA4XCgqakpUSYrfunr60NDQwNpaWkYPnw4s33ixIngcrkYO3Zsucb/N1JjdJcSsWdp7969WLBgATp06IAmTZpATU0NHTt2xNq1ayXSLho2bAggPwpOCIGPjw8aN27MKM8SQrB27drfnvfatWsQCATo2rWrzE12pUUkEsHc3BydO3f+Y+dMSUlBYmIimjZtCoqiwOFw4Ofnh9WrV5cp9TI0NBQNGjSQ/kBrKBeZmZnYtm0bgoODoaCgAEII6tati5iYmELr70UiEerUqYOWLVtWwmhLzuvXrzF9+nTY2tqCEAJtbW0MGzYMV69e/ePzgUgkwsaNG2FmZgYWi4X+/fvj9OnTMDAwgIWFhUQnB1mCpmn4+flBR0enTLWeFUl6ejoaN24MJSUlREZGQllZGTo6Oti0aVOp/r40TaNHjx7g8Xg4ceJEmcZSXYTTCkPcLvBvLgvKzMyEo6MjTExMZKqTwJ8gNzcXycnJCAgIAIfDAZfLRUBAQKnKcC5dugQ/Pz/Gibtp06Yyi2x++PABAwYMAJvNhqmpKTZs2FDpgp05OTlo3749uFyuRGr28ePHwefz0bFjR5nUwUhNTYWenh78/f0l5szw8HAoKytLpXd6aGgo7Ozs0KRJE/B4PKbtVmZmJthsdqn0iSZPngwej1cqh2phtG7dGsbGxlBUVISKikqx7TgfPXpUwLAu7CUQCKCurg4XFxcEBgbi0aNHUFVVZcouP3/+jNatW0NOTq7EWlQ15FNjdJcSPz8/KCkpMVFqbW1t6OrqQktLi9kmEAiwcuVKbNiwAbq6unBzc8O+ffugpqaGQYMGoUOHDlBWVgYhpER9Q8XtPJycnKpFW6rdu3eDEFLhAkufPn3CkiVL4OnpCRaLBQ6Hg1atWmHlypXlXnS1bdsWrVu3ltJIaygPP378wObNmxEUFMSkWdvb2yM2NhYPHz787f7i/plnz579A6MtOWlpaUhKSkKzZs1AURQEAgG6dOmC/fv3V1r69okTJ5g2h23btsX9+/eZ9549ewZTU1OYmprKZK30kiVLGIepLPH9+3c0bNgQSkpKTO1daGhomdJOx4wZA0IINm3aVObxREdHg8Vi4dChQ2U+hqzy9OlTEPL3dp2gaRpdu3aFQCAos8p3deHTp0+YP38+6tevz6zlIiMjcfv27RLtf/HiRSZ4Ymdnhy1btpTZYL5//z4j3ubk5FRmh1l5ycnJYQQcf50nL126BEVFRfj4+MhURP6/7Ny5E4QQRmEdyFe5V1NTQ//+/ct9fPH8qqWlVSA7zsHBAX379i3xsTIyMqCrq4uuXbuWaSy5ublYtGgRk8UXHh5eonVty5YtGeO6du3acHBwgJmZGerUqQNfX19MnToVzs7OTH33zp07GdVzQgh69uwJIN8BoaCgAHNz8z9WzlYdqDG6S8H169fB4XCgqqqKsWPH4u3bt/D394eioiIaNmwIKysreHt7MykccnJyOHnyJNLS0mBiYgJDQ0Pw+XzExcWBEIK5c+f+9pzZ2dlo1KgRdHV1SyTSUBVo3rw53NzcKuTYnz9/xrJly9CiRQuwWCyw2Wy0bNkSK1askGr9iYuLS6km2BqkS3p6OjZs2IAOHTowaVGOjo6YPn16qT2vIpEI9erVg5eXVwWNtuTk5uZi7969CA4OhpycHCiKgpeXF1avXl2sxkBFc+/ePfj7+4MQAmdnZ5w8ebLQz71+/RoWFhYwMDDAo0eP/vAoi+bRo0eQl5fHgAEDKnsoEnz79g2Ojo6Qk5MDm82GjY0NTp8+XaZjJSYmghCC+Pj4Mo9n+/bt1aaEqTBomoaOjs5fmxY5c+ZMEEIkVKhrAG7evImIiAimm4yjoyMSEhJKlAlw/vx5+Pj4gJD81mBbt24ts/F96tQpuLi4gBACf3//PyqWm52dDX9/f/D5fOzfv5/ZfufOHairq8Pd3b1KlJoEBQVBU1NT4m83f/58UBRVLkfTwYMHGaf+sWPHCrwfGhqKevXqleqYy5YtAyEEV69eLfE+NE1j69atsLS0BEVRTBlSSR2t586dA4fDYYzoHj16FNoqcPPmzejSpQsUFRUlRNguXLgAAOjVqxccHR3B5XLL9cz526gxukuIONpsbm4ukQ4yYcIEbN++HQCwatUqLFiwAMD/FkDih7u/vz/mzJnDTMw+Pj6/PSdN0+jduzf4fL5Mtt0pCzdv3pT6Q//Lly9YsWIFvL29wWazwWKx4OXlhaVLl1ZYGqmxsfFfu3CrLL5//45169ahXbt2jNiHs7MzZsyYUe40WLG41qlTp6Q02pJD0zQuX76MIUOGQEtLi5kjZsyYUSmaB7/y/v17hIaGgsViwczMrETpzu/fv4etrS10dHTKXFMsTfLy8uDi4gILC4sSaWf8KT5//gxzc3MmCycmJqbMUaQdO3aAoigMHz68zOMRC6d16tSpypcwFUdAQACaNm1a2cP44xw4cAAsFgtjxoyp7KHILDk5Odi1axfat2/PpJ8HBgZiz549v80uOnfuHLy9vZluNNu3by+T8S3WGqlVqxZYLBb69euH9+/fl/WSSkRWVhb8/PzA5/Nx8OBBZvuzZ8+gp6cHBweHMndA+NOkpKRATU0N3bp1Y7bl5ubCxsYGTZs2LdPctmDBArBYLLRo0QKEEGzbtq3AZ5YtWwYWi1Uqx0ReXh5sbW3h6elZonGdPHmSccr4+voyooB169ZlItAlQVxm82tdd1BQEFauXIldu3Zh7ty5THme+EVRFBQUFODq6sp0LQkMDESXLl1gbm5e6WURVYUao7uE9OzZEzo6Onj16hWA/OjY48eP0bBhQ6YW6FejGwAMDQ1BCMH169fRrVs3JsLN4/Fw6dKl355z3rx5IIRgzZo1FXNRlUDv3r1hZGRU7vTYb9++YeXKlWjVqhU4HA5YLBY8PT2xePFiqdTuFAdN0+Dz+ZXen/JvIDU1FatXr4a/vz94PB4IIWjYsCFmz55d7lqoX6FpGg4ODmjWrJnUjvk7Xrx4gdjYWFhZWYEQAj09PURFReHmzZuVbvSkp6djwoQJkJeXh7q6OubNm1cqg/DTp0+wt7eHhoYGrl+/XoEj/T0xMTFgs9ky5bi8d+8eUyPn5ORUojKIojh37hzk5OTQqVOnMi98UlNTYWlpWe2E0wpj9uzZEAgEf4WAmJjHjx9DRUUFfn5+MlmPK4t8+vQJc+fORb169UAIgY6ODqKion7rSDx79ixjnNnb22PHjh1l+l3m5ORg3rx5UFdXh7y8PCZMmFCgdak0yMrKQqtWrSAnJ4fDhw8z29+9ewczMzNYWloiJSVF6uetSMRG5a8p8gcOHCjSYC6K3NxcDBo0iFFrFwqF0NLSwqRJkwp89saNGyCE4MyZM6Ua6549e35b8nL79m1GxM/Z2RnHjx+XeH/UqFHQ0tIq1X22cePGEtV3iw1uGxsbjB8/HidOnGDU/Hft2oWzZ8+Wu6Tpb6LG6C4Bnz9/Bo/HQ8+ePaGvr88s/sXpFjweD4MGDUJSUhIWLFiA+fPnw8TEBGpqajA0NERoaCj8/f0xbtw4sFgsiX6HRXHo0CGwWCz8888/f+AK/wwfP34Ej8crc89XsQHm5+cHLpcLiqLQtGlTJCYm4sOHD1IebfHjqEnRqzi+fv2KlStXwtfXF1wul2lvMXfu3AoV6dq1axcIIRVaT5eamoply5ahSZMmIIRAQUEBPXr0wKFDh2RiMZybm4vFixdDR0cHfD4fI0eOLHOE4+vXr3B2doaqqmqlGbyXLl0Cm83GhAkTKuX8/4WmacybNw9sNhsURWHKlCnlcrA8fPgQ6urq8PDwQFZWVpmOIRKJ4OfnBzU1NYkWmNWVCxcugBCCy5cvV/ZQ/ghpaWmwsbGBlZVVTe1lGblx4waGDRvGpJ83aNAACxcuLLaG9syZM/Dy8gIhBA4ODti5c2eZfuupqakYNWoU+Hw+tLW1sWjRIqk5jH7+/Alvb28IBAIcPXqU2f7lyxfY2dnByMiICTRVJWiaho+PDwwNDSXKsvz8/GBqalqiufLbt29o0aIFOByORF9rT09PdOzYscDnc3NzIScnhzlz5pR6rE2bNoWdnV2BNcCrV6/Qq1cvUBQFCwsLbNmypdB76NSpU2Wa06KiosDhcBhV//++jI2N4e/vj1WrVjH7DBo0CC1btmSCZzRNQ05ODpqamjInUCqL1BjdJSAmJoapgVBWVkZ4eDg0NTXRrl07jB07loloixWFP378iKdPn0JfXx/Dhw+HQCCAi4sLrK2t4e7u/tvziZUCfX19ZWIhLi1iYmIgLy9fKhGz79+/Y+3atfD392cM7SZNmmDBggUVnnJVFA8fPqy0VOTqyufPn7F8+XJ4e3uDw+GAoih4eHggISHhj2kZ0DQNR0dHeHh4SDXSLE5ZDAwMBI/HA4vFgre3N9atWycz6c40TWPnzp2wsrICRVHo2bOnVBZb379/h7u7OxQVFctcq1xWMjIyYGlpCWdnZ5mIaj5+/Bju7u6M2GZ529S9f/8epqamsLOzK1evX7Ez+Ne00upMTk4O5OTkSqSpUtURiURo27YtlJWVy5VNUUM+OTk52LlzJ9q2bQs2mw0ej4eOHTti7969RWbvnTp1Cp6eniAkv1VZcnJymZ4vr169QkhICCiKgpWVVZmNeDGZmZlo0aIFBAKBRI1yeno6nJ2doaWlVaXvmZcvX0JBQQFhYWHMtocPH4LD4WDatGnF7vv48WNYWVlBXV29gBN+8ODBsLa2LnQ/Nzc3dOnSpdRjvXz5MgghSEpKApDvsBb3zNbW1kZiYmKxz7Dc3FyoqKgUGoEvjg8fPjACeTt37sS8efMQGxuLhIQEJCYmSgiqAfnzidje+bUNm46ODhQUFGRCF0fWqTG6f8OXL1+grKwMJSUlLFu2DBkZGVi7di3k5ORga2uLpk2bYuDAgXB2dmZEFtq0aYMXL16gZcuWjNJvnz59QAjBkSNHij3f9+/fYWVlVe280tnZ2dDR0ZGYAIsiPT0d//77L9q1a8dkFbi7u2P+/PkyISZ38uRJEEJkSiiqKvLx40csWbIELVq0YGrxmzVrhsTExEpzqIhTvQoTSikNNE3j/PnzGDRoEDQ0NJhoR3x8fKVdW1FcuHABjRs3BiEELVq0kHo6+I8fP+Dp6Ql5eXmJaEpFExYWBoFAUOkLx5ycHEyZMgU8Ho+JKpQ3opyeno769evDwMCgXNkf1V04rSiaNGlSaLSqujF+/HhQFCVziv3VgZSUFMyZMwd169YFIQS6uroYMWJEkeJnJ0+eRNOmTRmhtt27d5fJaL5x4wajQN24cWNG2Ko0ZGZmonnz5pCXl5cQxczKyoKnpyeUlZUrvSxIGixYsKBAgGT48OFQUFAo8jl84sQJqKmpwcrKCk+ePCnw/pIlS8Bmswsttxo6dCgsLCzKNNbOnTtDT08PU6ZMgaqqKhQUFDBp0qQSO+Y7deoEFxeXUp/34MGDYLFY8PPzK1SsdfPmzRgwYABomsbo0aNBUZREKRNN05CXl0evXr2YctoaiqbG6C6G3NxcNG7cGGpqahIT6cuXLwut5c7OzkaHDh0gJyeH5ORkBAYGIicnB4QQWFhYwMrKqthJVtwfVVVVtdoZdOIam6IWwD9+/MDGjRsREBDAiGQ1bNgQc+bMkbm+v5s2bQIhpFo5Rf4UHz58QGJiItPGTSx6t2TJEpmoG6NpGs7OznB3dy/Tgujp06eYNGkSLCwsQAiBgYEBRo4cKROCYv/lyZMnCAoKAiH5vcwrMtL58+dPtGrVCnw+/4+0a9q/fz8IIUhMTKzwcxXH2bNnYWtrCxaLBRUVFZiYmJRbiyAnJwfe3t5QVlYucXujwrh37x4UFRURFBRU6RoCf5pRo0ZBT0+vWl+32KHyu6heDeWDpmlcv34dQ4cOZRyszs7OSExMLDSr78SJE/Dw8GD0HPbu3Vum+/DQoUNMvXnHjh0LNRALIyMjA82aNYOCgoKEMZqbm4u2bdtCIBCUui5ZVhGJRHB3d4elpSXTbjc1NRWampro1atXgc8vX74cHA4HLVq0KDJ7SFzDLBYx+5V169aBEFLqzCOhUIgZM2YwJavh4eGlXg+tXr0aFEWVSdOoZ8+eYLPZUFRUxKBBg3Dt2jWIRCLQNI3ly5dDWVmZCSp6eHjg06dP6Ny5Mzw9PZlWdwcOHICOjg4sLS1luq1cZVNjdBfD5s2bGWGE9PR0XLhwAdu2bUO9evUkhAx+FVDLyspCvXr14OHhgcDAQGRkZIAQAi6X+1uP5IgRI6plf1SxSJWfn5/E9oyMDGzevBmBgYFMH0AXFxfMnj2bSWeRRebPnw85OblqvWCTJu/evUNCQgI8PDxAURTYbDa8vb2xbNkymawB2rdvHwghEqIyxfHlyxcsWrQIjRo1AiEEioqK6NWrF44dOyaT5SGfP3/G0KFDweVyYWBggFWrVv2RcWZnZ6Ndu3bgcrnYsWNHhZ3n8+fP0NXVRatWrSrtN5qamoqBAwcySsa6urowNzcvtwORpmn07NkTPB6vgJhOacdnaWmJOnXqyEyJw59k9+7dIITIZD95aXD79u2/Qole1sjOzsb27dvRpk0bJv28U6dO2L9/v0T6OU3TOH78OKPt4ezsjH379pX6byUUCrF69WoYGhqCy+Vi6NChxbY5+/HjBzw8PKCoqChhWItEInTv3h1cLhcHDhwo/YXLMA8ePACPx8OoUaOYbYsXL5aogRYKhYiMjAQhBIMGDSo2lVus6fPvv/8WeO/Ro0elWjvQNI09e/bAzs6O6ZutoKBQJsM5JSUFhBCsXbu21Pu+e/cOLBYLrVq1go6OjoSAmvi/AQEB0NTUxMSJEzF06FAmot2tWzdGvXzSpElgsVho3rx5jeFdBDVGdzE0bdoU1tbW0NHRAYvFKiAyIK6rWbFiBdzd3eHm5gZXV1f8888/IITAx8eHqdX4nXjY2rVrQUjJendXNcTp2IcPH0ZmZia2bt2KoKAgpr+yk5MTZs6cKVU16opkzJgxMDExqexhyDSvX7/GvHnz4O7uDoqiwOFw4Ovri6SkJKn2S68IaJqGq6sr3NzcilwEiRdX7du3B5fLBZvNhp+fHzZu3IjMzMw/POKS8fPnT0yfPp0pl5k2bRrj/f9T5ObmolOnTmCz2diwYYPUj0/TNDp06AB1dfVKSeOnaRpbtmyBrq4uFBUVMW7cOOjr68PKykoqpTFjx44FIQQbN24s8zFEIhFat24NVVXVv0I4rTC+fPkCQgjWr19f2UOROl++fIGZmRns7e2rvRK9LJOSkoL4+HjUqVOH6U4xcuRI3L9/n/kMTdM4evQoo/Xg4uKC/fv3l9r4/nVuV1ZWLnRuT09PR+PGjaGkpIRz585JjCE8PBwURVVbcdipU6eCzWYz/bDz8vJQt25dNGrUCGlpafD39weLxZLoPlQchoaGhbbeE4lEUFFRQWxs7G+PceHCBSbjwdPTE5cvX8aXL1+goqKC8PDw0l3g/+Pk5ITOnTuXad+OHTvC0tISqamp2LdvH5YuXYoFCxZg/fr1TOvShIQE7NixA02aNEG/fv3g6uoKDofD1HeLW68SQkrVwuxvosboLoI7d+4wN4+Ojg7Gjx+PJk2aQF5eHvb29tDV1WWULPl8PoyNjREREYFv377BzMwMHA4H8vLy0NPTg46OTrEtsi5evAg+n4/evXtXS690mzZtYGhoiE6dOjEpKo6OjoiLiyt3f+XKoE+fPnB1da3sYcgcL1++RHx8PBo2bMhkd7Ru3RqrV68ul9BTZXDw4EEmZUoMTdM4c+YM+vfvL9Huad68eTKRGl8UQqEQq1atgqGhITgcDoYOHVqpGQZCoRA9e/YERVESqqjSYPXq1aVuCyMtXr58ybR1ad++PY4dOwYdHR3Y2tpKpbvCokWLCgjYlAVxnW91i2iVFmtr6xJpjFQl8vLy4OXlBU1NzSrjxK7u0DSNq1evYvDgwVBXV2eM60WLFjHPRZqmceTIESZbytXVFQcPHiz1evDz588YNmwYuFwuDA0NmSymtLQ0uLu7Q1lZuUDG5bhx40AIkVDorm7k5ubC3t4e9vb2TBT72LFjIITAyMgIysrKpSqv8vHxQZs2bQp9z8vLC+3atSty34cPHyIwMJDJgjpw4IDE33nGjBngcDhlKjGdMGEC1NTUytSS9+bNm5CXl0ebNm2Qk5Mj8d6NGzfg4uLCiKrxeDwcOHAAtWvXBo/HY55v4ixB8aumvrsgNUZ3IYhEIjRq1AgsFgsJCQnMDThhwgRs374dwP9Syi9evAgTExMYGhri9evXyMzMhIuLC4KCguDh4QGBQFCs1+vt27fQ09NDo0aNqlU6RlZWFnbu3Mn08xMLSU2bNq3EtUeyip+fX7GT6t/E8+fPMXPmTLi4uDAOqLZt22LdunVVuuadpmm4ubnBxcUFDx8+xLhx42Bqasq00Rg7dqxExEJWOXjwIFP3FxQUJDO/PZFIhP79+4MQgkWLFknlmC9evICSktIf97Dn5eVhzpw5UFBQgIGBAXbu3Ilbt25BS0sL9erVk4qDY9euXWCxWBg2bFi5HLPiSMT06dPLPaaqTp8+fVCvXr3KHoZUiYiIAJvNrtC2hzWUnezsbGzbtg3+/v5gs9ng8/kIDg7GgQMHIBQKQdM0Dh06xDiu3dzccOjQoVL/5p8+fcroddjZ2cHGxgbKysoFWjfOnj0bhBDMmjVLmpcpk1y7dg1sNhtTp04FAJw7dw48Hk8iAl5SoqKiYGZmVuh7o0ePhr6+foHt79+/x4ABA8Bms2FsbIy1a9cW2lc7KysLxsbGCAwMLNWYgPwAHiEEZ8+eLfW+wP+eMx4eHrh27ZrEeykpKbC0tISenh54PB5T0qCmpgYXFxesXbsWSUlJEkZ3v379yjSO6kyN0V0IsbGxoChKop92UeJpQH49hImJCerVq4chQ4Zg3bp16NevH9TV1cHn8zF8+HDMnj0by5cvx5YtW3D48GFcunQJN2/ehL29PQwMDGQ6UlZSsrOzsXv3bnTv3h1KSkoghEBTUxPy8vKFik5UVRwdHdG/f//KHkal8eTJE0yfPh0NGjQAIQRycnIICAjAhg0bClW/rIp8+vQJ4eHhzMNDRUUF/fr1w6lTpwp9UMoavyrcuru7l0nhtqKhaRpDhw4FIaTUvU3/i1AoRJMmTWBiYvJHnT3Xrl2Do6MjKIrC4MGDkZaWhmvXrkFdXR3169eXSinF+fPnIScnh6CgoHLde/fv34eioiI6duxYLTOqSktSUhIoiqrSzsFfEYuVljRFtobK5f3795g1axZsbW1BCIG+vj5GjRqFBw8egKZpHDx4EK6uriCEoFGjRjhy5Eipf7dHjx5l1mIuLi64ceMG897y5ctBCEF0dLSUr0x2GTVqFHg8HmbMmAEejwcnJyfweLxSt9patWoVCCGFlm+IBQzfvXsHAEhLS8O4ceMgLy8PdXV1xMfH/7ZPuLjc9NcygJIgFAqhqalZaOp7SbG3t2cyUhs2bIiEhAQkJydj69at6NWrF1RUVJgMYBcXFzRo0IApqWvRogWcnZ2Ze47L5SI1NbXMY6mO1Bjd/+Hnz59QV1fHsGHDkJ6ejnXr1mHChAkwNjbGmDFjGLXYX41uIL8+gxACX19fAPny/2w2GyYmJjAyMmJuwqJePB4P2trasLS0hJOTE1q0aIHAwED06dMHkZGRiImJwbx587B69Wrs3LkTx48fx/Xr1/Hs2TN8+fKlTOkk0iAnJwd79+5Fz549oaysDEII6tSpg8mTJ+PKlStQUlKqdpO6gYEBJkyYUNnD+KM8evQIsbGxcHBwYPoMd+zYEZs2bao2Qkw/f/7E5s2b4e/vDw6HAzabDXV1dZibm//x2uey8urVKyZ1u3bt2uXu5VrRiNuQEEKYCERZmDFjBiiKklDjrUh+/PiByMhIsFgs1K1bl4kgXb58GaqqqnB2dpZKScXDhw+hrq4ODw+P3y7UiuP79++oXbv2XyucVhgPHz4EIaRaCJdeunQJfD4fffr0kenfew0FoWkaV65cQXh4ONTU1BhjZ8mSJfj27Rv279/PZJI1btwYR48eLdHfODU1FS4uLlBVVcXs2bNhZWUFiqLQs2dPLFq0CBRFITw8/K+6XzIyMpgU/5CQEGRnZ2PUqFEQCASlErm8cuWKhBDbr7x+/RqEEGzduhXz58+HpqYm5OTkMHr06BIboCKRCA4ODmjUqFGp/z7du3eHvb19qfb5FXF3nvnz58Pb21vCTqEoCoGBgQgJCYGdnR2UlZVhYWGBNm3aMOn669atw4ABA5h9+vTpU+axVEdqjO7/IPZgaWpqgs1mgxACDofD9IsmhKBJkyYYOHAg/Pz80KRJEzg5OSE8PBwqKipo2bIl8vLyoKurW0CtWygUIjU1FS9evMCwYcNACMGIESOwdu1aLFiwAFOmTME///yD0NBQBAUFwdvbG66urrCysoKuri4jPFbUS0FBAfr6+rC1tYWbmxtatWqFzp07Y8CAARg5ciSmTp2KxMRErF+/Hnv27MGZM2dw+/ZtvHr1CmlpaSWOouTk5GD//v3o1asXU9tqbW2NiRMnSrRWmzt3LjgcDuPxqw6IRCJwOJxKb0X0J7h//z4mT57M9CFVUFBAcHAwtm7dWm0EekQiEU6cOIG+ffsyTiNXV1csXLgQnz9/Zh4ku3fvruyhFktqaipGjRoFPp8PbW1tLFq0qFgFVlmCpmnExMSAEIJx48aVepFx8+ZNcLlcjBw5soJGKMnevXthbGwMgUCAuLg45ns+f/48lJWV4ebmJpXo6YcPH2BqagpbW9tyGfAikQj+/v5QVVWVmfICWYCmaWhqalZ5B+r79++hr6+Phg0bVqsStb+R7OxsbNmyBX5+fmCxWODz+ejcuTMOHDiA3bt3w8nJiVmDHjt2rMi58tu3b3BycoKamhqTJpyXl4fFixczkUpbW9tCW5pVVzIyMphaakIIEhISAOQLzOno6KBr166lOhZFUVi5cmWB94RCIVRUVKCiogIWi4W+ffuWSUTzyJEjIISUutPHhg0bQAgps3BnTk4ONDU14evrC6FQiJycHKSkpODLly+4cuWKRG23OJPr+PHjjM5VVlYW5syZI2Gb/Ik2oVWFGqP7P1hbW4PFYkFbWxvjxo2Dl5cXFBUV0bBhQ9SuXRvNmjWDsbExCCGQl5dHeHg48vLywOVyme1itcr/1kSI2bNnDyiKwrhx40o9vpycHHz69AlPnjzBlStXcPToUWzfvh1JSUmYM2cOJk6ciIiICPTq1QsBAQFo3rw5HB0dYW5uDk1NTXA4nCKNdoqimF6y9erVQ5MmTdCmTRt0794dAwcOROfOneHs7MyknhgYGKB3795ITk7Gu3fvkJmZyTwEhEIhzMzM0K1bt3L9PWQNseqtuLa/OkHTNO7cuYOJEycyKW+Kioro2rUrduzYIbOq3GXh/v37GDNmDPObNTMzw4QJEwqIl9A0DQ8PDzg6OspkRCAnJwfz5s2DhoYG5OXlMX78eKSnp1f2sMqEuE9pVFRUib/rrKws2NnZoV69ehVucHz48AGdOnUCIQTe3t4SIpBnzpyBoqIimjRpIpXvPz09HfXr14e+vn6524xNmDChRjitCNq2bQsvL6/KHkaZyc7OhpubG/T19StFrb+GiuP9+/eYOXMmbGxsmPXW6NGjsWTJEqa0y8PDo0D9/tevX+Ho6Ah1dXWJdHIgf54SCASoXbs2BAIB1NXVMXfu3ALCWdWNt2/fwtHREQoKCkhOTkZYWBgUFBSY1rTiWuTSpHObm5sjMjJSYtuRI0fg6OgIQgi0tLRw7969co3bx8cHlpaWpXKgf/nyBSwWq1zCePHx8aAoCiEhIYWee/PmzRgwYACAfGdOaGgoCCHYtWsXgP9pBYhfbm5uZR5LdaPG6P4FschM586dmVS+wsTTAGD//v1QVFREixYtkJqaCn9/f9y7dw+EENjb26Nhw4aFnuPevXtQUlJCu3btKqU2lKZpZGZm4v3797h//z4uXLiAgwcPYtOmTVi6dClmzpyJsWPHIjw8HF27doWrqyt0dXWZqH9hrdN+fXG5XGhqakJXV5dRdw4ICEDv3r0RERGBiRMnYs6cOVi5ciW2b9+Oo0eP4urVq3jy5Ak+ffok85P/3bt3y1RrI6vQNI2bN29i3LhxsLa2BiEEysrK6N69O5KTk8uV0iprpKSkYO7cucxDUU1NDQMGDMDZs2eLNfJOnDgh8UCRBWiaxqZNm1CrVi2wWCyEhoZWi4yShIQEEEIQHh5eovkxMjISPB6PKfupCEQiEZYuXQoVFRVoaWlh/fr1EvfLiRMnIC8vD09PT6lkgOTm5sLHxwfKysrl1sLYuXMnCCGYNm1aucdVHYmLi4OCgkKllWeVB5qm0bdvX/B4vAICWTVUH2iaxqVLlxAWFsZkFrq5uWHQoEGwt7cHIQTNmjXDyZMn8eXLFzg4OEBDQwM3b96UOM7169ehrKwMT09PZGVl4f379wgNDQWLxUKtWrWwadMmmXQsl5erV69CX18fRkZGzHeSlpYGQ0ND+Pj4gKZpiEQiODo6wsnJqcTr8rZt28Lb2xtA/ncrTsVu1KgR+vbtCzU1tXJ/n7du3QJFUaXOrGzUqBECAgLKfN7nz58zgThnZ2ds2bJF4tm2ceNG6OrqwsrKCsrKyqAoCra2tvjx4wc0NTXh6elZwDaoUTLPp8bo/n/evn0LOTk5dOzYEa9evcK2bdsQFxcHc3Nz7NmzB5mZmQXquI8fPw4WiwVFRUXExsYyNyohpND2A1+/foW5uTnq1Kkjs9GovLw8HD16FP3792daotWqVQtjxozBjRs3mAnq+/fvePXqFW7fvo3Tp09jz549WL9+PRYuXIipU6fCyMgIurq6CA4ORqtWreDm5gYbGxvo6+tDQUGhWMNdIBBAV1cX1tbWcHV1hbe3Nzp16oTQ0FD8888/iI2NxYIFC7B27Vrs3r0bp06dws2bN/Hy5UukpqZWqDPj6NGjIIRU6f62NE3j+vXrGDNmDCwtLUEIgaqqKkJCQrB3795qlaKYmZmJf//9F76+vmCz2eByuQgICMCOHTtKdZ2enp6wt7eXCRG1U6dOMTV+/v7+EiUd1YFly5aBoij07dsXQqGwyM+JU//j4+MrbCz37t1jeuj26dOngDDa4cOHIRAI4O3tLZVMEJqmERISAi6Xi2PHjpXrWPfv34eSkhICAwOr5WJaGpw5c6bYrDRZZuHChSCEYPXq1ZU9lBr+EFlZWdi8eTN8fX3BYrEgJycHDw8PmJubM5lpqqqqBZyQDx8+hJaWFpydnQusPe/du8d0mXF2dv5juhh/gq1bt0IgEMDV1bVA28a9e/eCEII1a9YAAE6fPl2q39PYsWOhq6uLrl27MiWWYg2VAwcOgBAilXKeXr16QUtLq1Q2Q2xsLBQVFcscxHrw4AFT+y4OuGloaEBLSwv6+vrQ09ODtrY2CMkX0tXR0cGtW7cwdepUNG/enMmoFWfFEkIwcODAMo2lulFjdP8/48ePh5ycHFq3bl1oNFdNTQ0+Pj4YP368xH7Dhg2DhoYGHB0dmd6+I0aMKHD83NxceHl5QUNDA8+fP/9Tl1UihEIhTpw4gYEDB0JLS4tJtx01ahSuXbtW6gXb9evXGSGJosjNzcWXL1/w7NkzXLt2DcePH8fOnTuxatUqzJs3DzExMRg+fDj69OmDwMBAeHl5wcnJCZaWltDS0pKosS/spaysDCMjI9SpUweNGzdG69at0bVrV4SFhWHMmDGIi4vD4sWLsXHjRuzfvx/nzp3DvXv38PbtW/z48aPIa/73339BCKlyYkRisZaRI0eiVq1aIIRAXV0dffr0wf79+2U+w6A0CIVCHD16FCEhIVBUVAQh+QreixcvLnMNm/iBXJllBffv30fbtm1BCEGDBg1w/PjxShtLRbN27VqwWCx07dq10ChkamoqjIyM4OnpWSGOkKysLIwbNw5cLhe1a9cutAXT/v37wefz4efnJ7WMkOjoaBBCsGHDhnIdRyycZmdnV+Xmqj9JVlYWeDxelVP8PnHiBDgcDoYNG1bZQ6mhknj37h3i4uKYDDU2mw2KokAIgZeXF86cOQMgX1zTyMgItra2xXZTOHHiBFMz3rZt2yrRErMoaJpGbGwsCCHo0qVLkUKo3bp1g5qaGtM9qFOnTtDT0/vtnPn582e0atUKhOSreC9btkziOfX582epzOMA8ObNG8jJyZWqHFW8Bi+N4zY9PR1JSUmMk/lXDan27dsjPDwcHh4eqF+/Pjw8PDBw4EDcuHEDCQkJ2LFjB9LS0tC5c2c0a9aM2e/XDjB16tQpy+VXO2qMbgAfP378rRH362vy5MkQCoWwtrbGuHHjQAiBlZUVIiIiIC8vX2iK4ZAhQ8DhcGSmf6ZQKMSpU6cQHh4OHR0dEEJgYmKCESNG4MqVK+WKjPTs2RMmJiYVnrKXlZWFDx8+4OHDh7h06RIOHTqELVu2YPny5Zg9ezbGjRuHIUOGoGfPnmjbti2aNm0KBwcHmJqaQk1NrdhUebFytZmZGerXr49mzZqhXbt2cHJyApfLxfjx4xEfH48VK1Zg69atOHLkCC5fvoxHjx7h48ePMhEtpmkaFy9exD///MP0mNbU1ERoaCgOHTpUZYS2Ssrt27cxYsQIGBgYgBACCwsLxMTESNTelgcvLy/UrVv3j0e7P3z4wPT3NDU1xYYNG2Qi4l7RbNmyBRwOB4GBgQWcQt26dYOKigpevXol9fMeP34clpaW4HK5mDBhQqEGdXJyMng8Htq1aye13/rixYtBSPl75tYIp5UONzc3dO7cubKHUWJevnwJTU1NNG/evEqmxdcgXVJSUmBubg6BQMA4mcURxkaNGsHIyAhmZmYlKj8SiUTYuHEjzMzMwGKx0L9//wIRYlknKysL3bp1AyEEMTExxa5lP3/+DE1NTQQFBQHI/23Jyclh7NixhX4+IyMDsbGxUFZWZjI2jxw5UuhnzczMMHz48PJfEIAxY8ZAIBCUuISMpmno6ekhKirqt587c+YMevfuDQUFBVAUBW9vb2zatAkpKSkSWanz58+X2PfGjRsSomqTJ0/G1KlTJdbRjx49Yjo3sdnsalECV17+eqP769evjEEifqmqqoLNZkNXVxempqaoXbs240EUv7y9vWFoaAgLCwsoKyvD1tYWWlpaGDp0aIFzLFu2DIQQLF68uBKu8H+IRCKcOXMGQ4YMgZ6eHgghMDIyQmRkJC5evCiVFMQPHz6Ay+Vi9uzZUhhxxULTNNLT0/HmzRvcvXsXZ8+exb59+7BhwwYsWrQI06dPx+jRozFw4EB06dIFfn5+0NfXB4/Hg6GhIfOAK+rF5/Oho6OD2rVrw9nZGS1btkTHjh3Rt29fREZGYvLkyZg/fz5Wr16NXbt24cSJE7h+/TqeP3+Or1+/lmlBJRKJcO7cOQwfPhxGRkYghEBbWxsDBw7E0aNHq90i7d27d5g9ezZT26ahoYHw8HCp3c+/cvbs2d9mcEiTHz9+YNKkSVBQUICamhri4+NlwpnzJxEbt/7+/ozxK25psn79eqme68uXL+jduzcIyW/NU5QIzrZt28DhcNCxY0epOa527doFFouFoUOHlvu+nThxIiiKwv79+6UytupOVFQUjIyMKnsYJSIzMxMODg4wMzOTSg/4Gqo2KSkpsLW1ha6uLh48eICfP39i06ZN8PHxkViz2tnZ4ezZsyU+bnZ2NubMmQM1NTUoKChg4sSJVSJjJiUlBW5ubpCTk8PmzZtLtM/GjRtByP9UwsePHw8+ny+RkZqXl4elS5dCT08PXC4XERERePfuHTgcTpHr+k6dOqFx48blvyjkZy5paGigX79+Jd6nT58+sLGxKfS9t2/fYtq0aUx5oZmZGSZPnlzAiS12BItfvXv3LlDOtnnzZnTs2BGWlpYSgayRI0eCpmlwuVwQkq8HNXr06NJffDXjrza6hUIhmjZtytwk2tra2LJlC3JzcwsIqE2fPp1J/RO/unTpggULFiA0NBQmJiYghODBgwcS5zh9+jS4XC7CwsIq4xIZI2zYsGHQ19cHIfkqmBERETh//rzUI2YTJkyAgoJCifsRVjV69uwJd3d35t9CoRDfvn3D8+fPcePGDZw8eRLJyclYs2YNEhISMGXKFERFRaFfv34ICgpCy5Yt4eLiAisrK+jo6EBOTq5Yw11RUREGBgawtbVFo0aN4Ovri86dO2PgwIEYNWoUpk2bhoULF2L8+PFo06YNUx6gpaWFfv364fjx48XWxVZFfvz4gbVr16Jly5ZMW5WgoCAkJydXeJq8t7c37OzsKjTSLH7A6+rqgs/nY8SIEVLp+VxVOXjwIOTk5NCyZUs8efIEampq6NSpk9ScKjRNY926ddDU1ISKigqWLVtW5N9306ZNYLPZ6NKli9QcWBcuXIBAIEBgYGC5f6u7du0CIeXref63IRZQLa9KfEVD0zSCg4MhLy9fboG9Gqo+Hz58gI2NDfT09PDw4UOJ9zIzM+Hs7AyBQMCsCQjJ1+fZsmVLic/x7ds3jBgxggkgLFmyRGYd97du3YKxsTF0dXVx6dKlEu9H0zTatGkDXV1dfPv2DRkZGTAwMEDHjh1B0zR27NgBKysrEELQrVs3CWPcxsYG4eHhhR531qxZkJeXl9r3NX/+fLBYrBJruGzbtg2EEGa8OTk52LZtG9OOTiAQoEePHjh+/Hix6xkHB4cC61J3d3cMHjwY/fr1K1SjicPhoG7dupg8eTKzzdTUFJqamn9d4OC//NVGt3iBIq7LEKfivXz5Eg0bNmSiGL8KqK1cuZLZRyAQYPbs2Rg4cCDj/fqVly9fQktLC82aNfujqbw0TePChQsYPnw4DA0NQQiBnp4ehg4dirNnz1aYwZCVlQUtLS0MHjy4Qo4vC3h7e6NDhw5SPWZ2djY+fvyIx48f48qVKzhy5Ai2bduGpKQkxMfHY8KECRg2bBhCQkLQvn17eHp6wsHBAXp6euDz+cUa7SwWC6qqqjA1NYW9vT08PDzQtm1b9OjRA4MHD0Z0dDRmzZqFZcuWYfPmzTh06BAuXryIBw8e4MOHD/j586dMiDDl5eXh4MGD6N69O5M65+HhgeXLl/9RB8+FCxdACMGmTZukfmyaprF7926mRUy3bt2YliZ/OydOnICCggJUVVWhq6srtf6yT58+RcuWLUEIQXBwcLGplOvWrQOLxUKPHj2k5sh69OgRNDQ00KRJk3LXhT948ABKSkro0KGDTPxmqwopKSkghGDjxo2VPZRimT59Oggh2LZtW2UPpYZK5t27d7CysoK+vn6BNpc5OTnw8fGBoqIiLl26BJqmce7cObRo0YKJRKqpqSE6OhppaWklOt/Lly/Ro0cPEJIvGJacnCxTc8zu3buhqKgIBwcHvHnzptT7v3nzBsrKyujbty+A/LmeEMK0TvXx8SlUfTsoKAjNmjUr9JgnT54EIURqnTVycnJgbm6O1q1bl+jz379/B4fDwdixYxEREcEII7u6umLp0qX4/v17iY4jFiwtyYvFYqFx48ZITk5Geno6o7YvLpuqiAy1qsZfbXSLJf4JITA2NoaWlhaUlZXB4/GgpKQEPp+PIUOGYOXKlViwYAFCQkLg5OQkUf/dpUsXtG7dGnp6ehILsYyMDNjb28PMzAyfP3+u8GsRt5WIiopieg/r6upi8ODBOH369B+pARU7JB4/flzh56os7O3tMWjQoEo5d15eHo4dO4aBAwcyypGGhoYYNmwYjh49ijdv3uDevXs4f/48Dhw4gI0bN2LJkiWYMWMGxo4di0GDBqFbt27w9/dH48aNUbduXRgbG0NZWbnYiZTL5UJLSwsWFhZo0KABvLy80KFDB/Tu3RvDhw/HpEmTMHfuXKxatQo7duzAsWPHcO3aNTx9+hSfP38us8OJpmncuHEDkZGRTAs6a2trTJ06FS9evJDul1sKWrVqBRsbG6lmEFy6dAkeHh4ghKB58+ZVUk25oomIiAAhBDY2NuV2tOTm5mL69OmQk5ODiYnJb1OxV65cWSJF9dLw4cMHmJmZwcbGptxOhO/fv8PKygq2trYy2xlDlrGwsMCQIUMqexhFsm/fPlAUVSoxpRqqJ2/fvoWlpSUMDQ0LaDYIhUIEBQWBz+cXKqKVkZGBIUOGMNFJFosFX19fHDt2rERrxOvXr8PLy4txepcmolwR0DSN2bNng6IotG/fvlwtG5cuXQpCCJKSkuDv788E1g4dOlTkPjExMdDQ0CjUAfHjxw+wWCwkJSWVeUz/ZcuWLSCE/FZENTU1FYsWLWLqqbW0tBAVFVWmTic0TTORfnFJ6n/XiIaGhmjdurXEtR4/fpwpcRBHuPX09GBra/tXaNIUxV9rdD958oS5YcQpvuL6bHd3d/Tq1Yupe9bT00O/fv0QEhKCo0ePMpEocd0um83GnDlzmGOLRCIEBgZCUVERd+7cqbBroGkaV69exciRI5m6dG1tbQwaNAgnT578o2nFNE2jXr168Pf3/2PnrAx0dHQQExPzx86Xm5uLw4cPIzQ0lPFUmpiYICoqChcuXJDa5CVuA/fy5UvcunULp0+fxu7du7Fu3TosXLgQsbGxGDFiBPr3749OnTrBx8cHDRs2hLW1NfT09CRaQxT2kpeXh56eHmxsbNCwYUP4+PggODgY/fv3x4gRIxAbG4uFCxdi3bp1WLlyJQYMGMC0QdHU1MSQIUPKLfAnLS5dugRCpKNM+uzZMwQHB4OQfHXP/fv3y8Q1yhr37t2DnJwcOnXqBDU1NTg6Opa5pvXChQuoW7cuWCwWoqKifrtQEy/GBg4cKLXfW3p6OhwdHaGvr19uMTiRSIQ2bdpARUWlWjs8K5KQkBA4OjpW9jAK5eHDh1BRUUGbNm3+6sVqDfkRWQsLCxgZGRVoWyru285ms7Fr165ijyMUCrFw4UKJ1HNdXV2MHz/+t+1QxS2x6taty2QIVUYL1ZycHPTt2xeEEIwZM6bcv41Xr14xzn1TU1NMmTIFhBAsW7asyH22b98OQgijfv5f7OzsMGDAgHKN61domoarqysaNGhQ4HpFIhGOHDmCLl26QE5ODmw2G7a2tuDxeCXOaCgKcXtCQvI7A23ZsgUXL17E+fPnsWvXLjg7OzOCakB+YOLX+u7o6GgAYGyn2NjYco2nKvPXGt2/pol7eXnh8OHDWL16NeTk5GBra4umTZti4MCBaNCgASOYpaOjg4YNG6JFixYSnh85OTmJmstJkyaBEPLbia8siHssjx49mmn9pKmpiQEDBlRq/a44BaW8vWVlGaFQCBaLhaVLl1boeXJycnDgwAH07duX6ZVoZmaGkSNH4vLlyzJrlOXm5uLz5894+vQprl69imPHjmHHjh1YuXIl5s6di0mTJmH48OHo3bs3OnToAC8vLzRo0AAWFhbQ0NBg+kEW9qIoCsrKyjA2NkbdunXRuHFj+Pv7o1u3bhg0aBDGjh2LGTNmYMmSJdi0aRMOHDiA8+fP4/79+3j37h0yMjKk+r21bt0aVlZWZf69ffnyBREREeByudDX10dSUlK1q72XFjk5OXB0dIS1tTUyMzNx69YtaGlpoU6dOkUudgojLS0N4eHhoCgKDRo0KFE2wYIFC0AIkYrAmZjc3Fz4+PhASUkJN2/eLPfxJk2aBIqisG/fPimM7u9k6dKlYLPZMicWJc5gsLGxKffCuYaqzevXr2Fubg5jY+MCHTlomkZUVBQIIVi3bl2JjykUCvHvv/8y2ZHi/spNmjRBUlJSsVkzQqEQK1euhIGBAbhcLoYNG/bHxP2+fPmCpk2bgsfjMX22y0pqaipGjRoFOTk5qKmpgcvlMoLI3bt3h5aWVpGp2I8ePQIhBEePHi30/V69ekndmSduXyp2+r948QITJ05kdKWsra0xc+ZMfPjwAffu3QMhBAcOHCjXOfPy8uDn5ycRbAwNDcWNGzeYz2zevBnBwcGIiIiQEBl2dnZGZmYmAMDY2BjOzs5QV1cvso1bdeevNbrF9SlDhgxhPEZF1XLTNI2RI0eCEIK1a9fiwYMHUFNTY26q4OBg5rhi8QJpenJomsbNmzcxduxYWFhYgJB8lebQ0FAcOXJEJoQt2rRpg7p168qsQSgNxLV/ycnJUj92dnY29u7di169ejH3loWFBcaMGVOmXulVgdzcXOzbtw+dO3eGQCAARVFo1qwZ5s2bhytXruDixYs4dOgQNm/ejGXLlmHWrFmIjo7G4MGD0aNHD7Rp0wYeHh6wt7eHiYkJVFVVi20Dx+FwoKGhgVq1asHR0RGenp5o3749QkJCMGzYMEyYMAHx8fFISkrCtm3bcOTIEVy5cgWPHz/Gx48fJUTarly5UuoFDgD8/PkTM2bMgIqKCpSUlDB16lTmgVRD4YwdOxYcDgdXr15ltt2/fx96enqwsrLC27dvf3uMHTt2QF9fHwoKCpg7d26J5sw5c+aAEIKoqCipirb16tULXC63yIVaaUhOTv7rIwfS4O7du8UunisDoVCI1q1bQ0VFpUDdbg1/F69evUKtWrVgYmJSaGmVuCd1WfvNC4VCrF+/nllfamlpgaIoyMvLo2fPnsWKbWVmZmLq1KlQUlKCiooK4uLiKtSgevDgAczNzaGpqcn0Ii8LWVlZmD17NtTU1CAvL4/x48cjLS0Ns2bNAkVRuHDhAt6+fQt5eXn8888/hR5DKBSCz+dj3rx5hb6fmJgIDodTbr2O/+Lv7w9NTU14enqCkHzB3X79+uH8+fMSzyqapmFiYiKV0pkfP34wPeF/fZmbm8PZ2ZnJDP5vjbeLiwvc3d0Z20j8XF29enW5x1QV+SuN7uzsbCgpKSEwMJCZSL5//47GjRtLqED+KqBG0zR69uwJZWVlZGRkSBjd4hTymzdvQl5eHsHBweVepNE0jdu3b2PcuHGoXbs2CMkXv+jbt6/M9Vh+/PgxKIqSau2KLHLz5k0QQnDx4kWpHC8rKwvJycno0aMHVFRUQAhB7dq1ER0djZs3b1ZLQ5umaVy5cgVDhw5lUtvs7OwQFxcnFfVgkUiEtLQ0vH79Gnfu3MGZM2ewd+9e/Pvvv1i0aBGmTZuGUaNGYeDAgejcuTN8fX3RqFEj2NrawsDA4Ldt4OTk5KCjowMrKyuoqqpCXl4egYGB6NevH6KiojBlyhQkJCRgzZo1SE5OxsmTJ3Hjxg08e/YMixcvhpGRETgcDsLDw/Hx40cpfKPVm7Nnz4LFYhVqVD558gTGxsaoVatWkYJzb968Qbt27UAIgb+/f4lTuePi4pi0RWn+DsePHw9CpCMmUyOcJj1EIhFUVVUxefLkyh4Kw9ixY0FRVLmjVDVUbV68eAFTU1OYmZkVOs+Js3GmTJlS7nPl5eVh3bp1TCspa2trpobXxMQEEyZMKBBlF/Pp0ycMHjwYHA4HRkZGWLNmjdTLIQ4fPgwVFRXY2dlJqIiXBqFQiDVr1sDY2BhsNhsDBw6UENDMy8uDk5MTbG1tkZ2djSlTpoDL5RZZuuPg4FBkK6/Lly9Lbc1I0zQuX76MsLAwpla7Vq1aWL16dbElUmFhYahVq5ZUnhGfP38Gl8uV0LUq6qWgoMCU3T58+BCmpqbQ0tJCdnY2WrRoAScnp3KPpyryVxrd69evZxb7JiYmEgttiqJgZ2eHvXv3IikpCXPmzEH//v3h6emJZs2agaIozJw5k7npKIrCz58/8fHjRxgbG6N+/frlilzdvXsXEyZMYDxKqqqq6N27Nw4cOCBThvavDBkyBJqamlL35skahw4dAiGkXIrSP3/+xM6dO9G1a1dm4rS1tcWECRNw586dart4fvnyJWJjY5n7WldXF5GRkbhx44bMXXNeXh6+fv2K58+f4/r16zhx4gR27dqF1atXY/78+Zg8eTIiIyMZY87W1papadLW1v6toryCggIMDQ1hZ2eHRo0awc/PD126dMHAgQMxevRoTJ8+HYsWLcKGDRuwb98+nD17Fnfv3sWbN2+Qnp4uc99XRZGeno5atWqhUaNGRUamX758iVq1asHIyEhCVEgoFCIhIQGKiorQ09PD1q1bS/y9iducTJw4Uarf9ZIlS0AIwYwZM8p9rLS0tBrhNCnj5+cHHx+fyh4GgP8JJknjXqmh6vL8+XOYmJigVq1ahToMxSrb0szGAfKfgWvWrGEi3x4eHggICGDWLE2bNsWqVasKLcd4/PgxOnbsCEIIHBwccPjwYamMKTExEWw2G76+vmUqtaBpGvv370e9evVACEHHjh2LzCC5desWOBwOJk6ciJ8/f8LExARt2rQp9LPdu3eHm5tboe9lZ2eDy+WWOQMByHdmzJkzB3Xq1AEh+S1/o6Oj0aVLF6ipqf22neiePXtACJFatkxYWBg0NTUxZ84cODk5MUK8ioqKqFu3LuJc/+WFAAEAAElEQVTj4zF9+nSm7zmQr4PD4XAwZswYAEB0dDT4fH6BVnd/A3+l0d2wYUPo6uqCw+FAIBDAyMgIfD6fSVkR19FyuVxGwATIT6FWU1OTWFR7e3sjJycHTZo0gba2dpmidffv38ekSZOY9gQqKioICQnBvn37KrzvcHlJTU2FgoICxo8fX9lDqXDWrFkDQkipnQuZmZnYtm0bgoODGdXQOnXqICYmBvfu3aug0VY+qampWL58OaPKLS8vj+7du+PgwYMyURIhDdq3bw9zc/MC15OVlYXjx4+jcePGjGEeGxuLFStWID4+HuPHj8fQoUMREhKCdu3aoVmzZqhfvz7MzMygrq5ebH07m82GmpoaTE1N4eDggKZNm6Jt27bo2bMnhgwZgnHjxmH27NlYvnw5tmzZgsOHD+PSpUt4+PAhUlJSqoxzrG/fvlBQUPitSM/bt29hZWUFPT093L9/Hzdv3oSLiwsIIQgLCytxaxSapjFu3LgKSdfevXs3WCwWhgwZUu7FsUgkQtu2bWuE06RMbGwslJWVK11bQZwx16VLl7/GwVZDQZ49ewZjY2OYm5sX2gZr165dYLPZ6Nu3b4XdJ3l5eVi9ejUjatq2bVtMnToVXl5eoCgKCgoKCAkJwYkTJwpEtc+fP49GjRqBkPyWW2XVr8jLy8PgwYNBCEFERESZ1g6XL19Gs2bNGAdCSSLP48ePB5fLxe3bt7F582YQQgp1IMTFxUFJSanIv4GTkxN69uxZqvHm5eVh79696NChA7hcLrhcLoKCgnDgwAFmfvrw4QMUFBQwYsSIYo+VkZEBPp+PuXPnlmoMRfH8+XNGcFrsdBFf+40bN+Di4iIhqvbt2zeoqqpCXV0d79+/B5A/1/L5fNSuXbvS59s/zV9ndH///h0sFgt8Ph+zZs3Ct2/fMGHCBGzfvh1Afkp5QkICLl68yPRvbd26NZo2bYolS5Zg7dq1EgvgnTt3IjQ0FDweD+fOnSvxOB4+fIgpU6YwCpBKSkro0aMH9uzZU6Wax8fHx4PL5TI/purMzJkzoaKiUqLP/vjxA5s3b0ZQUBCj7G1vb4/Y2Fg8ePCgYgdaieTk5CA5ORkdO3YEn88Hi8VCy5YtsXbtWpkTKZIG4pKDlStXMtvevHmDXr16gaIoWFpaYvv27aVeFNE0jR8/fuDt27e4d+8ezp07h/3792Pjxo1YvHgx4uLiMGbMGISFhaFr165o3bo13N3dUadOHRgZGTERiaJePB4P2trasLS0hJOTE7y8vBAYGIg+ffpg+PDhiImJwbx587Bq1Srs3LkTx48fx7Vr1/Ds2TN8+fKlwp0mu3btAiEEy5cvL9HnU1JSYGdnB3l5ebBYLNjZ2ZVqPqZpGqNGjQIhBDNnzizrsAvlwoULEAgE6NChg1QWGDExMaAoCnv37pXC6GoQc+LECRBCcOvWrUobw+fPn2FiYlLujLkaqjZPnjyBoaEhLC0tC9WsOHbsGPh8PoKCgv6I0ZKXl4dVq1Yx4r2BgYE4ePAgpkyZwhjkZmZmmDRpkkTaN03T2LFjB2rXrg2KohASElKqPtqpqanw9vYGh8PBkiVLSj3uJ0+eICgoiAl07N27t8TP4uzsbNjY2MDZ2Rl5eXlo0qQJ7OzsCjz79u7dC0JIkaVLgwYNgo2NTYnO+ejRI4wePZqpj65Xrx7mz59fZNvhSZMmgc/n/zb70sfHBy1atCjRGErC0qVLwWKxUL9+fZw5c6bAd7p582b0798fR48ehaamJgQCgYTo2vDhwxnxvt27d0ttXFWBv8ropmkavr6+kJOTYxZkRYmnAfkTjbKyMlgsFo4cOQIPDw8Jo9vIyAjz5s0rsOguisePH2Pq1Kmwt7dn0jG6deuG5OTkKhN9+pW8vDyYmJiU2otXVYmMjISVlVWR76enp2PDhg3o0KEDBAIBCCFwdHTE9OnTq3VEiqZpXLhwAeHh4dDQ0GAcDLNnz8a7d+8qe3gVTocOHWBmZobPnz9jzJgxkJOTg5aWFhYuXFipJSFCoRCpqal48eIFbt68iVOnTmH37t1Yu3YtFixYgNjYWPzzzz8IDQ1Fp06d4O3tDVdXV1hbW0NXV5e5h4tLk9fX14eNjQ3c3NzQqlUrBAcHY8CAARg5ciSmTp2KxMRErF+/Hnv27MGZM2dw+/ZtvHr1CmlpaUXW+6WkpEBLSwtt27Yt8QLp4MGDMDY2BkVREAgEOH/+fIm/J5qmMXz4cBBCihTEKSuPHz+GpqYm3N3dpSIutHv3bqnVb9YgSWZmJjgcDhYtWlQp58/NzYWnpye0tLTK3UauhqrL48ePYWBgACsrq0Kfn5cuXYKCggJ8fHz+eCZkbm4ukpKSYGZmBkIIgoKCcPv2bZw+fRp9+vRhSjWbNWuG1atXM4723NxcJCYmQktLC3JychgzZsxvM5CePn0Ka2trqKqqlrorTkpKCgYNGgQOhwNDQ0OsWrWqTM6J8+fPg6IoxMfH49q1a6AoCgsXLpT4zMuXL0EIKbJ7xKpVq0BRVJEp8enp6UhKSmKy4tTU1DB48OASCej++PEDurq66N69e7Gfmz9/PrhcrtQCHxkZGZCXl2d0eerWrYuZM2di+/btWLFiBbS1tZlsPRUVFYSGhkJPTw9RUVEQCoUwNTVFz549Ub9+fdjb20tlTFWFv8roFnuyt23bBiD/h+ni4oLjx48zdXG/Gt0A4OzsDBcXFzg7O2P06NGIiYlharmnTp0KNpuN4cOHF3nOp0+fYvr06ahfvz6zUO3cuTN27NhR5SXzxWqEJWm9Ux3o2rUrPDw8JLZ9//4d69atQ7t27ZiyA2dnZ8yYMaNIwZHqwrNnzxATE8OIrhgYGGDkyJG4fft2ZQ/tj3L16lXGiSYQCBAdHV1t2vvk5OTg06dPePLkCa5evYqjR49i+/btWLlyJebMmYOJEyciIiICvXr1QkBAAJo3bw5HR0emVEfcgqawF0VRUFFRgYmJCerVq4cmTZrA398fBgYGEAgEGDZsGGbOnImlS5di06ZNOHjwIC5cuID79+/j/fv3yMzMREpKCrp27QpCCJo3b46rV6+iYcOGUFZWLlGkWyQSITw8HIQQJCYmSvW7S0lJQa1atWBtbY2vX7+W+3gPHz6EsrIyAgICavo1VxDOzs6/XcBWFEOHDgWHw8GpU6cq5fw1VD4PHz6Evr4+rK2tC80evHPnDtTV1eHu7l6seFZFk5ubixUrVsDU1BQURaFTp064d+8eMjIysHbtWjRv3pxZ7/bq1QunTp0CTdNIS0vDuHHjIBAIoKGhgfnz5xfqODh16hQ0NDRgaWlZqlrk9PR0TJw4EQoKClBVVcXMmTPLvc4eNmwYBAIBnj59yrRx/XU+p2kaioqKReoviDsjHD9+XGKfM2fOoHfv3lBQUABFUfD29samTZtKHYBbunQpCCG4fv16kZ958uQJCJFuG+PBgwdDS0sL+/btQ/v27SU6x1AUhTZt2oDFYsHIyAhubm7w8fFBVFQUkxlw6dIlrFixokLKuWSZv8roDgoKgrGxMWxsbJiI3K8vCwsLDBo0CPPmzUP//v3RtGlTGBoaMgvHRo0aYfDgwWCz2YiNjYWamhq8vb0LpJs8f/4cM2bMQIMGDZha1k6dOmHbtm3VKmWscePGBYzQ6oyXlxc6deqE1NRUrFmzBv7+/oygXsOGDTF79uxC23lUJ75+/YrFixfD3d2dMTRDQkJw9OjRv642h6ZpbNmyhUmvU1RULLOianWFpmlkZmbi/fv3uH//Pi5cuICDBw9i06ZNWLp0KWbOnIno6GiEh4eje/fujMiNqakpTExMoKKiAoqiio24UxQFbW1t1K9fH82bN4e/vz90dHTA5XIREhKCOXPmYOXKldi+fTuOHj2Kq1ev4smTJ0hJSUHfvn1BURSWLVsm1ev+8eMHGjRoAD09vXIJL4pJS0uDtbU1bGxsaoTTKpCIiAiYmZn98fOuXLkShJBKi7LXUPk8ePAAurq6sLW1lVDTFvPs2TPo6enBwcEBqampf36AhZCTk4Nly5bBxMQEFEWhc+fOuH//PoB81fWYmBgmKl6rVi3ExMTgxYsXePfuHfr16wcWiwVzc3Ns2bKFiequXLkSXC4XzZs3L7GzMjc3FwsXLmSETEeMGPFbgbGS8uPHD5iamsLT0xMfPnyAkpIS08dbjKura5EZn0KhEAoKCpgxYwbevXuH6dOnM4EKMzMzTJ48uVyZLXl5ebCxsYGXl1exkXFLS0v079+/zOf5L+Ie4GKF8ry8PHz+/Blfvnxh1oIJCQmMoNqJEycQERGBhg0bwtHRETRN4/z588xzXFziW935a4zuDx8+gM1mQ1dXF4QQ6Ovrg8PhMEZ406ZNoaqqCkLy+/l27NgRQL4Ag7q6Ong8Huzt7aGpqYmWLVvC1tYWlpaWzA/75cuXmDVrFpydnUEIgUAgQMeOHbFly5ZK9UhWFOI+xb8qFFZnvn79CgMDA5iYmIDL5YIQAnd3d8ydO7fapwJmZ2djx44dCAgIAI/HYxREN2zYUK2cSKXhzJkzcHV1BSEEfn5+2LFjByiKwtKlSyt7aFWWJ0+eQEFBAaGhoRLbxW3gXr16hdu3b2P9+vWws7MDIQSurq4YO3YsRo4ciQEDBiA4OBitWrWCi4sLI1r4OzV5LpcLXV1dWFtbw9XVFd7e3ggKCkJoaCj++ecfTJkyBQsWLMDatWuRnJyMU6dO4ebNm3jx4gVSU1MLOJtyc3Ph6+sLJSUliTq2siISidCuXbuafs1/ALFq+J/UKLlw4QJ4PB5CQ0NrhNP+Uu7fvw8dHR3Y2dkV2kry3bt3MDMzQ+3atWWy1WROTg6WLl3KlPh06dKF0a4RiUQ4deoUE9UVZyWtXbsWly5dgp+fHwghcHFxQefOnUEIwYABA0pUmkXTNDZv3gwLCwtQFIVevXpJpfXofzl8+DCjMTJjxgyw2WwJEdy+ffvC0dGx0H1zcnJga2sLXV1dsFgsyMnJoXv37sX2Pi8t4rKj4toLDhs2DIaGhlKdY4YNGwaKorBhwwaJ7YUJqh06dAiWlpbg8/k4e/YsgP/ZEWKbTFY7NEmTv8boXrp0KdhsNqysrHDixAnQNF1AQG3BggW4ffs2mjdvDi6Xi927d2PmzJlYtGgRBg4cyHjsPDw8oKysjOPHjyM+Pp5ZfMvJyaFDhw7YtGlTtRSN+pXu3bvD1NS0Wkc3P3/+jOXLl8PHx4fJdjAxMUFCQkKh4ibVCZqmcfbsWQwYMIDpSd+gQQPMnTsXKSkplT28SuPhw4do3749U6//a61ZcHAwjI2NZb7jgCySl5eHhg0bolatWkXOndnZ2Zg0aRJ4PB4sLCxw9OjRYo+ZlZXFZKNs374dX758wbNnz3Dp0iW0aNECLBYL/fv3x7x58xATE4PIyEj06dMHgYGBTB9RS0tLaGtr/7YvqZKSEoyMjGBnZwdtbW1QFIXmzZsjLCwMY8aMQVxcHBYvXoyNGzdi//79OHfuHO7du4e3b9/ix48fxS6EaoTT/hzv3r0DIQRbt279Y+fT09NDo0aNauaNv5S7d+9CW1sbdevWxadPnwq8/+XLF9ja2sLIyEjmHfw5OTlYsmQJjIyMwGKx0K1bN4m2UD9+/MDq1asZJXFFRUX06dMHcXFxUFFRYQTPSiI2e/z4cTg5OYEQAn9//wova+vduzeUlZXx7NkzmJubw8fHh5m3586dCzk5OYn18O3btxEREQFNTU1GvHTp0qUl7qZRGmiahoeHB+rWrVvkmlzc8laa35NQKIScnBwIIRg0aFCBFmBiQbXdu3fDxsYGbDYbO3fuZN4XOwv+pmj3X2F0f/nyBVpaWrCzs2PSVYoTUMvJyUFAQAAEAgHq1auHjx8/YvTo0eDz+TAzMwNFUUy/YT6fj/bt22PDhg1/Tdrfu3fvwOVymbSS6sTHjx+xZMkStGjRAmw2GywWC82aNUNCQgIIIUhKSqrsIVYojx8/xvjx4xkHk7GxMcaMGVOtW5uVhJSUFISFhYHNZsPExATr168v4KW+f/8+KIrC4sWLK2mUVZcpU6aAxWIVKYB2+vRpWFtbg8PhYOzYsSWu08vJyUFgYCA4HA62bNmC3NxcBAcHg81mY/PmzaUaY1ZWFlJSUvDw4UNcunQJhw8fxpYtW7B8+XLMnj0b48aNYzKd6tevj6ZNm8LBwQGmpqZQU1OTqHn774vNZkNdXR1mZmZwcHBAs2bN0K5dO6Y2smnTppg9ezZWrFiBrVu34vDhw7h8+TIePXqElJSUKtXxQtYxNTUtVqdFWmRlZcHV1RUGBgaFphPXUP25ffs2tLS0UK9evUIVqtPT0+Hs7AwtLa0q1dM4OzsbixYtgqGhIVgsFrp3714gS+f58+eYNGkSDA0NmTIhd3d3GBgYgM1mIywsrFAH/61bt9CqVSsm0+nkyZN/5Jq+ffsGXV1dtG3bFjt27AAhhHGEHjlyBIQQXL16FYsWLWKcAVpaWoiKisKsWbNACCnUqSItLl26VKyoc1ZWFuTl5REXFyfV83bt2hXq6uqMc8HT0xNjxozByJEjJdqf1qpVC15eXnBzc4O7uztu376NTp06MSrm4n2rO3+F0T116lQIBAKcOHECQ4cOhbW1NbhcLjQ0NGBnZ4fIyEjExcVJCKj9/PkTpqam0NbWBpAvGiCOdrDZbLRp0wbr16+vNoJJpSE6OhpKSkrV5to/fPiAxMREeHp6gsVigcViwcvLC4sXL2Ym/bdv30pMstWJz58/Y+HChUzGhrKyMvr27YuTJ0/+9YJNGRkZmDx5MhQVFaGqqopZs2YVK3TStWtXGBoa1hhBpeDKlSvgcDgYN25cgfe+ffuGfv36gRACNzc33Llzp9THz8vLQ9euXcFiseDk5AQul1shZTFiQZuiFjU0TSM9PR1v3rzB3bt3ce7cOezbtw8bNmzA4sWLMX36dIwePRphYWHo0qULPDw8wGazoaSkBAMDg9+2gePz+dDW1kbt2rXh7OyMFi1aoGPHjujbty8iIyMxefJkzJ8/H6tXr8auXbtw4sQJXL9+Hc+fP8fXr18rvA1cVaFbt25wcXGp0HPQNI1evXqBz+fjypUrFXquGmSTW7duQVNTEw4ODvjy5UuB97OysuDp6QllZeViRbJkmezsbCxcuBAGBgZgsVjo0aOHRCeXCxcuQEdHB7q6umjXrh0jKmZpaQl5eXkoKCggJiYGGRkZePnyJXr06MG8v23btj9ejrF9+3YQQrBp0yY0b94ctWvXRlZWFlOWwuVyGftg586dTFDv+fPnIKRohXNpERwcDAMDgyLL/tq0aSN1HaZz586BkPzWX+vXr4eTkxP4fD64XC6jZ+Xj4wN9fX3w+Xx06NABr169QvPmzcHhcDBv3jxGF4cQUuUFpn9HtTe68/LyoKOjU6hw2n9f1tbWWLVqFVxcXODm5gZLS0uwWCy8e/cOtra2jCdOWgINVZGfP39CQ0MDw4YNq+yhlIt3795hwYIF8PDwAEVRYLPZ8Pb2xrJlywr1Rl67do3xZFYHxA+KNm3agMPhgMPhwN/fH5s3b672k15JyMvLw/Lly6Gnpwcej4fIyMgSibo8fPgQLBarQFuRGgonMzMTVlZWaNCggUQ9F03T2LhxI7S1taGsrIzFixeXywGUmZnJeNTDw8OlMXQJ9uzZAxaLhfDwcKksBMXCadbW1hLOTaFQiG/fvuHFixe4ceMGTp48ieTkZKxZswYJCQmYMmUKoqKi0K9fPwQFBaFly5ZwcXGBlZUVdHR0mFTAol6KioowMDCAra0t3Nzc4Ovri86dO2PAgAEYNWoUpk2bhsTERPz777/Yu3cvzpw5gzt37uD169fFtoGrSiQmJoLD4VSoXsX8+fNBCMHatWsr7Bw1yC43btyAhoYG6tevX+hzJTc3F23btoVAIMCZM2cqYYTSJSsrCwsWLIC+vj7YbDYjcMnn8+Hu7s6suX78+IFVq1ahadOmTEo2RVGQk5MDh8OBjo4OFi9eXKm1v4GBgdDS0sLmzZtBURRTfsdisdCyZctC9SBomoaGhgYmTZpUoWN7+vQpuFwupk2bVuj7ixcvBpvNlqoQH03TMDAwgL29fZH6VQkJCdiwYQMTyaZpGpqamlBQUEBqairatGnDPIPCwsKkNjZZpNob3ePHjy90ccHhcJgf9H+VcJcvXw4AUFJSgpycHPr37w9CCKysrKpkP21psnz5clAUhadPn1b2UErNmzdvMG/ePLi7u4OiKHA4HPj6+iIpKalQT/Ov7Nu3D4QQvHnz5g+NVvqIRCKcPHkS/fr1Y+qnXFxcsGDBggpNe6pK0DSNPXv2wNbWFoQQdO3atdSK5N27d4e+vv5fP1eUhMGDB0NOTo5RvAXyowLi9MGOHTuWu9d7VlYWfH19wePx4O/vD0IIEhISyjt0hosXL0IgECAgIEAqGhcikQjt27eHsrJyhaSUZmdn4+PHj3j8+DGuXLmCo0ePYtu2bUhKSsKcOXMwYcIEDBs2DL169UL79u3h6ekJR0dH1KpVCxoaGsW2gWOxWFBVVYWJiQns7e3h4eGBNm3aoEePHhg8eDCio6Mxa9YsLFu2DJs3b8ahQ4dw8eJFPHjwAB8+fMDPnz8rXUzs5s2bIIRUWNrqsWPHwGazERkZWSHHr0G2uXbtGtTV1dGgQYNCAzgikQjdu3cHl8stVhirKpKVlYV58+Yx/bzNzc2LLF27d+8evLy8JNbompqaSEpKqrQ54ufPn4xT7lc7Yt++ffDw8EBwcHCR+7Zq1Qp+fn4VPsZhw4ZBSUmp0DXdq1evQAjBli1bpHrOIUOGgMViwdPTU8JJ/F9BtXbt2kEoFGLo0KEghGDNmjUAgLZt20rYYFV5nf07qrXRfeLECaaeQPwDj4+Px4gRI5iC/YSEBLRr1w6mpqbM53g8Hk6fPo2mTZuiUaNGMDIyAp/Pr/biWb+DpmnY2dmhXbt2lT2UEvPy5UvEx8fDzc2NSf9p3bo1Vq9eXaqMBXFLl6oodvPgwQOMHTsWJiYmICS/TcX48eOrVI3Yn+DKlSuMwEuzZs3KnPb5+PFjsNlsqRp21ZGDBw+CEMKU9eTl5WHWrFkQCAQwMjLC7t27y32OzMxMtGzZEgKBAEeOHAFN04iKigIhpMi+qqXh8ePH0NTUhLu7u9QyRCZPngxCCPbs2SOV40kbmqaRkZGBd+/e4f79+zh//jwOHDiATZs2YcmSJZgxYwbGjh2LQYMGoVu3bvD390fjxo1Rt25dGBsbQ1lZudg2cFwuF5qamrCwsECDBg3QvHlzdOjQAb1790ZERAQmTZqEuXPnYuXKldixYweOHTuGq1ev4unTp/j8+XO5o2BCoRDKysqYOnWqlL6x//H8+XNoaGigZcuWNen8fyFXr16FmpoanJ2dC4020jSN8PBwsFgsqRtGskBmZiaCgoIY8TMdHR2w2Wz06dMHz549A5D/HFixYgUMDAzA5XIxePBgbN++Ha1bt2Z0MdTU1DBlypQ/0j2FpmlcuXIFYWFhTLCidu3aIIRg1apVUFVVxcCBAzFo0CDY2dkVeZzx48dDS0urwh0GX758gYqKCoYMGVLo+3Xq1EGvXr2kes7ly5czpbdmZmZYsGABIxh36dIlWFpaQkdHB8rKynB1dQVFUeDz+fD29sa7d++Y71P8Gj9+vFTHJ0tUW6P758+f0NbWZv6IXbp0QXZ2dpECaj9//kRAQICEsM3IkSOZdgYVnRZSFRCLRZw4caKyh1Isz58/x8yZM+Hi4sLUOrZt2xbr1q0rs3LktGnToKGhIeWRVhwfP37EvHnzmF7xqqqq6N+/P86cOVPpkSRZ4/nz5+jSpQsIIbC1tcXevXvL/R2FhIRAT0+vJlW/CL58+QI9PT14e3tDJBLh8uXLcHBwAIvFQkREhFREKX/8+IFmzZpBQUFBImpJ0zSTARUTE1Pmv3VKSgpq1aoFa2vr32bKlJQ9e/aAoijExMRI5Xiyikgkwvfv3/Hq1SvcunULp0+fxp49e7Bu3TosXLgQU6dOxYgRI9C/f38EBwfDx8cHDRs2hI2NDfT09CAvL19smry8vDz09PRgbW2Nhg0bwsfHB506dUL//v0xYsQIxMbGYuHChVi3bh12796N06dP49atW3j58iW+f/+Oli1bonXr1lK95oyMDNSrVw+1atUqcf/hGqoPly9fhqqqKlxdXYtch0RHR4MQwmRbVifevXsHJycnyMvLM5oaP3/+xNy5cxnju0WLFkwP686dOxfIqExLS0NERATz++dyuejcuTPOnTsn9XXNp0+fMHfuXNStWxeE5Le0Gjt2LB4/fgyaptGyZUsYGRlh+vTpYLFYGDt2LDgcTpGBGbFSt7iFVkUSFxcHDoeDJ0+eFHhv5MiR0NHRkUopUFZWFjZv3sx8R4QQKCgogM1mQ15eHq1bt0aHDh3g6urK/M0sLCxgY2MDX19fXLp0SSLKLX7p6OhU2/Zh1dboFkcmCSFo2bIlsrKycPz4cdSpUwcrVqzAjRs38H/snWVYVF0XhveZHoZuJCSkREoBEUFFAVsRMVAsFANsRcHu7u7uLux+bcXubmwFFKk5z/fDa/bnvDTMUC/3dc0P5cQ+E+fstddaz8OybCbVcnV1dbqfm5sbnJ2dYWpqWsxXUzJo1KgRXFxcSmTQ9uTJE0yePJkGmSKRCC1atMDGjRsVIvjWt29fVK5cWQEjVR6/fv3Cpk2b0KhRI3C5XPD5fAQGBmLnzp3lwl5Z8PXrVwwcOBACgQBGRkZYvny5wrJPT58+BZfLxezZsxVyvLIEy7IIDg6GlpYWHj58iL59+4LD4cDFxUVholKJiYnw9vaGmpoa9QT9NxMnTgQhBNHR0fm+pyUlJcHNzQ2GhoZ48eKFAkYMPHr0COrq6mjevHmZ6I1WNmlpafj8+TOePn2KuLg4nDhxArt27cLq1asxe/ZsjBkzBgMGDECXLl0QFBSEevXqoVq1aqhUqRL09PTA5/Nz1XkxNTWFo6MjvL290bhxY7Rv3x4RERGIiYnB1KlTsWTJEmzevBmHDh3ChQsXcO/ePbx79w4/f/6U+07JvvMSiaRAYoDllG4uX74MDQ0NeHp6ZhtwyxSuZ8yYUcSjUz5xcXEwNjaGiYlJlqJwJ06coI4pDMMgMDAwx/tqeno6Jk6cSMvUZZWsEydOLFRpcnp6Og4cOICgoCDw+Xzw+Xy0atUKBw8ezNQ69OLFC0gkEvTq1Qu2trZwdXUFISTb33d8fDwIKRo7wuTkZJiamiI4ODjT306fPl0ofaLk5GTs2LEDderUydaRY9myZQgPD4e2tjY0NDSgp6eHbt26oVmzZjAzM4OhoSFu3ryJtLQ0OYFQmep7Tu9jaafMBt1/f3jZ+azq6+sjJCQEU6dOxcmTJ+Hp6Sm3gq6npwcej4dp06YV9+UUOw8fPgQhBGvWrCnuoVAePXqECRMmwMXFBYQQiMViBAcHK8UnvU2bNqhbt65Cj6kIpFIpTpw4gc6dO9Obl5eXFxYvXqyw7FtZ4/fv35g+fTo0NTWhqqqKcePGZSsAUhi6dOkCAwODIimBK02sW7cOhBAMGTIEJiYmUFFRwYwZMxS24PHjxw94enpCQ0MDFy9ezHHbWbNmgRCCvn375jnwTk9PR6NGjaCqqoobN24oYMR/Mjj29vaZhNPKUR4syyI5ORnx8fF48OABLl26hCNHjmDbtm3o378/CCHo0aMHevfujQ4dOqBZs2aoVasWnJ2dYW5uDk1NzRxt4Hg8HnR0dGBpaQkjIyOqodGpUyf069cPo0aNwsyZM7Fy5Urs2LEDx44dw9WrV/H48WN8/PixfKG0jHDx4kWoq6vDy8sr29+2rDx3+PDhRTw65bNz506oqKjA3d09k8jYgwcPEBgYCEIIXFxcsHfvXkyfPp3Ovbt3755jZvjnz58YO3YsRCIRDZIZhkFAQAA2bdqU50qzR48eITo6mv5OnZycMHfu3Cxt3P5GJog4depU+rvfvHlzttubmJhgyJAheRpTYVm7di0IIZmegWlpaVBXV8e4cePyfKyfP39i+/btqF+/fiZNDwMDA0yYMAFbt26l/6elpZUpaJZVGX/69Amenp5ISUlBly5d5I4zYMAA+u9jx44p5H0oaZTJoFsWIMpWzUQiEWrXrg2BQABra2u4urrSfhJC/oi/aGlp4fv379izZ49cvxmfz8/1h/dfICIiAvr6+sU+Ebh//z7GjRtHy1kkEgnatGmD7du3KyVwklG7dm2EhIQo7fj55c6dOzRoka3yjhkzplQK3BUVUqkUGzZsQMWKFcHlchEREZGlD6iiePbsGXg8HmbOnKm0c5Q2Xr58CTU1Naok3rBhQ4VlioE/FmNubm7Q0tLKc9Z80aJFNMDKLcPMsiy6du0KHo+Ho0ePKmLIShdOKyf/JCYmgsPhYNmyZTluJ7OBe/36Ne7cuYNz587hwIED2LhxIxYtWoRJkyahZcuWIITAwcEBDRs2hJeXFypXrgxjY2O5TF1WL5FIBAMDA9ja2sLDwwP+/v4IDg5Gt27dMGjQIIwbNw7z5s3D2rVrsWfPHpw+fRo3btzA8+fP8e3bN4UI+5VTcM6fPw81NTV4e3tn2zIjU8FWlPNBSYFlWUyaNAmEELRu3VouAH737h26d+8OLpcLc3NzbNiwQe7e+/PnTxp88/l89OjRA69evcr2XB8/fkRERAQ4HA60tbVpj7C6ujq6d++OCxcuZHpvk5KSsGrVKnh7e9MWvMjISMTFxeX5c8jIyECNGjVgY2MDf39/cLlcREdHZ7t9ixYtisyLOiMjA87OzvD29s50PcHBwfD09Mxx/6SkJGzZsgWNGzfOFGgLBAK0bt0at27dottLpVKa7SeEQENDA0uXLsXPnz+RkJAAHx8f+nybPn06DA0N5Y65YcMGuaBbGS4jJYEyGXQfPXqUfnCdOnWighWjRo2iAmqysvL4+Hjaty0TrqlQoQLdPyAgoLguo8Tw7ds3qKioFEtfO8uyuHPnDkaPHk0VpVVVVdGuXTvs2rWryLKIdnZ2GDBgQJGcKzvev3+PmTNn0sy+trY2IiIicPHixTL1sFYGJ06cQNWqVUEIQWBgYJEFN926dYO+vr5SF4RKC+np6bC2tgbDMNDT08OWLVsU+r39/PkzXFxcoKOjk+8M9KpVq8AwDDp27Jhjxn306NEgRLFWT+PHjwchRCHCceUoDldX10ILDt2/fx9qamoIDAzMdkEnPT0dX79+xfPnz3H9+nWcOnUKe/bswdq1azF37lyMGzcOgwYNQteuXREcHAx/f3+4u7vDxsYGBgYGEAqFOQbuqqqqMDExgYODA7y8vNCoUSOEhISgZ8+eiI6OxuTJk7Fo0SJs2rQJsbGxOHfuHO7evYs3b94gMTGx/NlSQM6dOwdVVVXUqlUr28q7Q4cOgc/nIzQ0tEy1lKSkpKBjx44ghGD06NH0O/Tjxw8MGzYMYrEYOjo6mD17do6JnJ8/f2Lq1KnQ1dUFn89Hr1698Pr162y3f/jwIYKCgkDIH32W9u3bw9TUFIT8cR+aNGkSdu/ejbCwMOoJHhAQgM2bNxfYbeTevXsQCAQIDw8HwzA5tiFOnjwZampqRfZZHzlyBIQQ7N69W+7/Zc+7fycUExISsHHjRmol++97ibOzMzZs2JDtZyY7398vdXV1mJqaokmTJjAxMaEWa3+/jI2NsWPHDvj6+sq19pSl34SMMhl0T5w4EQzDICIigv7YsxNQA/489LS1tSESiXD+/Hm5h9iKFSuK7TpKCtOmTYNAIFBqVvBvWJbFzZs3MWLECNjZ2dEfbmhoKPbu3VssVkyampoKUTvOLz9//sT69esREBAADocDgUCA4OBg7Nmzp1QqqRc1d+7cQcOGDUEIgaenZ5F7nr548aK8RQXA7du3aXa7cePG+XIOyAsfP36Eo6Mj9PX1C9wLtmnTJnC5XLRu3TpLERdZCejkyZMLO1zKgQMHwDBMuVBnCaR3796wtrYu8P7fv3+HtbU1HBwcFCIMmBMyG7hHjx7hypUrOHbsGLZv344VK1Zg5syZGDlyJPr27YtOnTqhefPmqFOnDlxdXWFhYQFtbW05l5d/v2SVgObm5nB2dkbt2rXRrFkzdOjQAX369MGIESMwffp0LF++HNu2bcORI0dw+fJlPHz4EPHx8f9J68SzZ89CIpGgTp062S64/vPPPxCLxWjWrFmZEo369OkTatasCaFQSEutU1JSMHv2bOjo6EAsFmPYsGH5ErVNSkrClClToKOjA4FAgIiIiBx7t8+dO0cdaxo0aIBp06bBxcWFVrGKxWK0atUKjx49KvT1An8WTrlcLmxtbcEwDOLj47Pc7vjx4yCEyFlkKpuAgADY2NjIfcfev39Ps8s/fvzAunXr0LRpU6pz8Xe1r6amJgYPHpwn69SUlBTo6urmuAj479fcuXPx69cvmlQjhNAKzrJmmQeU0aBbVr6VkZGB1NRUxMbGwt7eHnPnzsXZs2eRnp4uF3QDf36kAoEAVlZWcmUPufUElnXS09NhamqqcIuBf8OyLK5fv46YmBiqXqmpqYlOnTrhwIEDxVrW/vv3bxBSdP3sGRkZOHLkCEJDQyGRSEAIgY+PD5YtW5alzUg5mXn79i3CwsLA4XBgZWWF7du3F1vGpnv37tDV1VW4zkBpIDk5GTExMeByuWAYJkcf04Ly/v172Nvbw9DQsNCTmV27doHP56N58+Zy95wDBw7QlgRFfY8eP34MDQ2NcuG0EsqmTZtACMHHjx/zvW9GRgYaNmwITU3NLBWESxosyyIpKQlv377FvXv3cOHCBRw8eBCbN2/GkiVLMGXKFMTExCAiIgLt2rVD48aN4e3tjSpVqsDU1FROgDarl0AggJ6eHqytreHm5oZ69eqhZcuWCAsLw4ABAzB27FjMmTMHq1evxu7du3Hy5EnExcXh2bNn+PLlS6myVzt9+jQkEgl8fX2zDbivX78OdXV1+Pr6lqlFiTt37sDc3BwGBga4dOkSbekyNzcHh8NBeHg43r17V+DjJyYmYtKkSdDW1oZAIEBkZGS2Vr4pKSkYPHgw1Wnicrlo2rQpBg0aBC8vL1oC3bNnT1y6dKlQ9/XU1FQ4OTnB2NgYhBB07Ngxy+2+f/8OQv7vT10U3LhxAwzDYPHixfT/vn37hooVK6JChQpynuOygJvD4aB+/fpZCsjlRkxMDP3dOzk5QSQSZbofaGhooEOHDggICEBiYiI+fPggV2E8c+ZMmJqaIjw8XNFvR7FT5oLuFy9e0Cy3zOcvqweAv78/JkyYgAcPHsDHxwc1atRA+/btIZFIqOgaj8f7z4tRycQRbt68qfBjy/wPhwwZAktLS1oyHRYWhoMHD5aYTO6rV69ACMHhw4eVdg6WZXHjxg0MGjSIinnY2tpiwoQJCu15LeskJCRg+PDhEIvF0NXVxbx584r9e/Tq1Svw+XxMmTKlWMdR1Bw7dgxWVlbg8/kwMDBAlSpVFL549vbtW9jY2MDY2FhhWYvY2FgIhUI0aNAAycnJuHLlClRUVBAYGKiwHtnExERUrlwZtra25cJpJRTZff/fpZl5ITo6GhwOB0eOHFH8wEooGRkZ+P79O16+fImbN2/izJkz2LdvH9atW4f58+djwoQJGDx4MMLDw9G6dWsEBASgevXqsLOzg6GhIcRicY6Bu4qKCipUqAB7e3t4enqiQYMGaNOmDbp3744hQ4Zg4sSJWLBgATZs2ID9+/fj7NmzuH37Nl69eoUfP34UycLWyZMnoaKiAj8/v2xb3x4+fAg9PT24u7srvQKiKImNjYWamhqcnZ3x6tUrHDlyhLbCBQYG4sGDBwo7V2JiIiZOnAgtLS0IhUL06dOHBvO3b9/GgAEDaMbV3d0dbdq0gba2NsRiMYYPH46EhAQ8evQIw4YNo1lVOzs7TJkypcCLAlevXqXCigzDZKsObmNjg969exf42gtCx44doauri4ULF6JBgwaZKltk465YsSKmTZtWqKrWly9fyr0PS5cuxenTp7F7927ExsZi//79qF69OtLS0rB48WIYGxvLLdqJxWJ8+/YNHh4e0NbWLnPJijIXdMuUDLlcLtTU1ODv7w+hUEhXWCdOnEgDPIZhYGBggMePH2P06NFy0vWEkBKpVl3U1KhRQ6HCDyzL4tKlSxg8eDDMzc1BCIGuri7Cw8Nx5MiREllmdfnyZRBCFKZU/Ddv3rzB1KlTUaVKFRDyRzG/T58+uHLlSnkvXT5IS0vDggULoKenB5FIlO/yNWXTq1cvaGtrl6lJVnZ8+vQJHTp0ACEEtWvXRlhYGAQCgZzoiiJ49eoVrKysYGZmpnABwePHj0NFRQWenp7Q1dWFl5eXwjzXpVIpWrRoATU1NYVORMtRPCYmJhg8eHC+9tm8eTMIKZvWT8omNTUVnz9/xpMnT3Dt2jWcOHECO3fuxKpVqzB79myMHj0a/fv3R5cuXdCiRQvUrVsX1apVg5WVFe37zS5oZxgGGhoaMDMzg5OTE3x8fNCkSROEhoYiMjISw4YNw7Rp07B06VJs2bIFhw8fxsWLF3H//n28f/8ev379yvGZfPz4cYjFYvj7+2d7r3j16hVMTU3h4OBQZhI6LMti1qxZ4HA4aNasGc6ePQs/Pz8QQlCzZk2cP39eaedOSEjAhAkToKGhAR6PB319fTqPGjRoEO7evSu37bBhwyASiaCrq4v58+cjLS0NGRkZOHr0KNq1aweRSAQOh4MGDRpg69at+a5CkLkeGBgYoGbNmll+X9q3b4/q1asX+trzwqdPn7Bs2TL4+PjIZZn/LiHn8/no2LEjzp07p7A555gxY+R+e5GRkXj06JGcoFpCQgJsbGwQGhoqt+3ChQsB/HGg4nK5GD9+vELGVFIoc0G3p6cnCCEIDw+nKyR/C6gBf1Yju3fvjnbt2oEQgvXr1wMAmjRpIteP8F/v57506RIIIdi7d2+hjiOVSnH+/HkMGDCAilro6+ujZ8+eOH78eIkvHdu3bx8IIdn26eSXxMRErF69GvXq1aPq+m3atMGBAwdK5KJDSYZlWezcuZMKdHXu3LlQPp3K4s2bNxAIBJg4cWJxD0VpsCyLNWvWQEdHB1paWli5ciVOnjwJhmEU3tP+/PlzmJubw8LCQmmVIHv37gXDMBCLxXnqZ8srEyZMUMh9tRzl06ZNG3h5eeV5++vXr0MsFiM0NLR80bQYYFkWv379wvv37/HgwQNcvHgRhw8fxtatW7F06VJMmzYNw4cPR2RkJEJDQ9G0aVP4+PjAyckJFStWhKamplw/679fPB4Purq6sLKyQtWqVeHr64sWLVogICAAXC4XVlZWmDJlClauXImdO3fi+PHjuHr1Kp48eYK7d+/C2toaFhYWhSqxLkmkpaUhPDyczrnbtGkDQgjs7e2xd+9epf4GpFIpjh8/Lhcs83g88Pl89OnTJ5M9mYw3b96gS5cuYBgG1tbW2LFjh5zQ27Jly2g/uKamJnr16oXLly/n6VqSk5Ppd4QQgi1btmTaZs6cORAKhUqrwPvw4QMWL16MevXqgcPh0OTi30E2IQSurq6QSCT5XlTMCyzL0hL+v1/a2tqoWbMm9PX1MyU5CSEwNDSEi4sLfv/+DS0tLbi6usLU1LTExwj5oUwF3f/88w8YhpHzXP23gFpqaipq1aqFx48fQyqV0tXRGzduoH379nL93KWhF0uZhISEwMrKqkAllVKpFGfPnkXfvn1pn4uhoSEiIiJw6tSpUmVlsmzZMnA4nEKNOT09HQcPHkRISAjEYjEYhoGvry9WrVpVojKypYnz58/TG3uDBg0UnklVNJGRkdDS0iqT5cSPHz9G3bp1QQhB+/bt8fHjR/z48QNmZmaoXbu2Qn/vT548gampKSpVqpSjkm1h+PnzJ9zd3aGtrQ11dXW4u7vj69evhT5ubGwsGIbB6NGjCz/IcpTOvHnzIBAI8pTx+vjxI8zMzFCtWjWFVUWUU/RIpVIkJCTg9evXuH37Nv755x8cOHAAGzZswMKFCzFp0iQMGTIEPXr0QNu2bVGtWjUwDANVVVUYGRlRHZbsXkKhEIaGhrC1tUX16tUREBCAVq1aITw8HIMHD8b48eMxf/58rFu3Dnv37sWZM2dw8+ZNvHjxAt+/fy8xc6evX7/C19cXfD4f9erVA5/PR4UKFbBixQqlBkkvX77EmDFjULFiRdqGN3XqVLx//x4/fvzA2LFjoaGhAZFIhAEDBmSbLLl9+zYVWa1Ro0amjPzDhw8RExND56/29vb0PDkhC9gdHR1hZmaW6V5w/vx5EEIQFxdXuDfiL96/f48FCxagTp06tCfbzMyMBray1g2GYeDg4EDnSu3atYOrq6vCxvE37969A4fDybH65O/y9pCQEKxevRpjxozB+vXrQQjBzp07C9ziU1IpU0F38+bNqYBaWloa9u3bBzs7O0ybNg2HDx/Gz58/0alTJ7nVJw8PD5ibm6Njx45o0qQJJBIJFV749OlTMV5N8fLmzRvweDzMnTs3z/tkZGTg9OnTiIyMpH3JFSpUQJ8+fXD27NkS87DIL+PGjYO+vn6+92NZFteuXUO/fv1o2VPlypUxefJkpQUL/wUePXpEbUFcXFxw7Nix4h5Snnj79i2EQmGZKpdKTU3F+PHjIRQKYWFhIad70KFDB6ipqeHly5cKO9/Dhw9RoUIF2NraKi1blJ6ejkaNGkFVVRXXr1/H9evXoaOjA2dn50I9E2TCac2aNSsXTislXLt2DYQQnDt3Lsft0tLSUKtWLejr65ff2/9DHDp0CEKhEI0bN5bTq0hLS8OXL1/w7NkznD9/HlWqVIGqqiomTJiAOXPmYOzYsRg4cCDCwsLQsmVL+Pn5wc3NDdbW1tDX16e6Qtm91NTUYGpqiipVqqBmzZpo1KgR2rVrh169eiE6OhpTpkzB4sWLsWnTJhw8eBDnz5/H3bt38fbtWyQlJRU6A/3o0SNUqlQJKioqEIvF0NDQwOTJk5Vm4ZqcnIyNGzfCz8+PLnB07doV58+fz/Javn//jtGjR0NdXR1isRgDBw7Mtk/5+PHj1F86KCgokzaITNi2bdu2EAqF4HA4aNSoEbZt25blYlx0dDQkEgkkEgl4PB7GjRuX6Vq4XC6WLFlSiHfkz3xi7ty58PHxAcMw4HK5sLa2pnNvsVhMv0f16tXD5s2bMX36dHA4HNy7dw8AsGHDBhBClPYsbd26NSwtLTF9+nRYWVll+h7LWktliYhGjRrh3r178PT0hJ+fHwDA0tKyTAmqlZmg+9WrV+BwODkKqDEMA1dXVzx8+BBz586l6n1RUVEQCASwtbUFIQQREREghBSrYnZxExMTA3V19Vx7UNPT03HixAn07NmTBpYmJibo378/zp07VyYml5GRkXBycsrz9i9fvsSkSZNgb29P+3sGDBiA69evl5ccFoKPHz8iMjISPB4PpqamWLduXan7fvXt2xeampplQoX+3LlzqFy5MrhcLoYOHSo34dq2bRsIUaxK671792BgYAAHBwel2ReyLItu3bqBx+PJiWDdvXsXBgYGsLe3zzXTkRV/C6eVV7aUHtLT0yGRSHK1i4yMjASfzy9yS8Jyio8DBw5AIBCgadOm2c4VU1NTUb9+faiqquLy5cv5Ov7v37/x4cMHPHz4EJcvX8bRo0exfft2LF++HDNmzMDIkSPRp08fdOzYEc2bN0ft2rXh4uICCwsLaGlpUTGrrF5cLhfa2tqwsLCAi4sL6tSpg+bNm6Njx47o27cvRo4ciRkzZmDFihXYvn07jh49iitXruDRo0fYvHkzxGIxuFwu+Hw+Bg4cqJT+dJnQbq9evWgfcq1atbBmzZo8i2t9+/YNo0aNosH34MGDs3QjkEqlWL9+PczMzMDj8RAZGZnldt+/f8eSJUtoG6uWlhYiIiJw9epVOreTBbLGxsawsLCAWCzOpLDu4uKCrl275vs9ef36NWbPnk0r/Hg8HpycnKi1Lp/Ph6amJj3/iBEj8OzZM7p/amoqLC0t0bRpUwDA58+fwTAMVq5cme+x5IULFy6AYRgMHjwYUqkUL1++xLVr13D9+nVcuHBBrgr5+/fvqFq1KiZPngxCCGJjYwH8qRzQ1dUtM9VDZSbonjhxIkQiEYRCISQSCerWrQuhUAgbGxt4eHjQD1LW1+Dt7Y2nT5/C398f1atXB8MwsLS0hJ2dHebOnQuhUFjcl1Rs/Pr1C9ra2hg4cGCWf09LS8PRo0fRvXt36OnpgZA/qoeDBg3CxYsXS10glBstW7aEv79/jtv8+PEDK1asQO3atUHIH6XV9u3b49ChQ2WqH6U4+PXrFyZMmAA1NTVoaGhg6tSppdZm5f379xCJRKXal/n79+/o2bMnCCHw8PDI5Gzw7t07aGtrIzg4WGGLTLdu3YKenh6cnJyUWoE0duzYbBcLHj16BGNjY1SqVAmvXr3K8zFZlkVQUFC5cFoppW7dumjevHm2f5f5ty9durToBlVOsbJv3z7w+XwEBgZm25ubkZGB4OBgCIVCnDx5sohH+H8buDdv3uDu3bs4f/48YmNjsWnTJixevBiTJ09GdHQ0evXqhZCQEDRq1Ag1a9aEg4MDTExMsuy5/XcSS0dHB9bW1nB3d4efnx9atmyJrl27YuDAgRg7dizmzp2LNWvWYPfu3Th16hSuX7+OZ8+e4evXr9nOiz59+oTZs2fD0dGRVksOGzYMjx8/LvB78fXrV4wcORJqampQUVFBVFRUls+R379/Y9q0adDQ0ICamhomTJiQbfb+wYMHiI6OplZXDg4OmD59Oo4dOwZCCKZPnw5CCNTV1REaGiq3b3h4OBwdHfM09hcvXmDGjBmoXr06Daw9PDzg4eEBoVBIEzs8Hg88Hg8tWrRAbGxstpWlW7ZsASEEp0+fBvBHB6tly5Z5GktBqFevHggh6N+/Pw2w/xZUk7Fq1SrUqVMHhBC59it3d3cwDIM5c+YobYxFSZkJumUfbNu2bWmpQlYCahERERgyZAgIIRg8eDD9sllaWoJhGCxYsAATJkwoUDlxWWHJkiXgcDhy4kFpaWk4dOgQunbtCh0dHRBCYGFhgSFDhpR5pW1vb2906NAh0//LWhhatWoFoVAIhmHg5+eHtWvX/idUqpVNRkYGVq5ciQoVKoDP56N///5lQvG1f//+0NDQKHXZbpZlsW3bNhgaGkJVVRXz58/P9GBnWRYBAQEwMjJS2GcVFxcHbW1tVK1aVamf/4oVK0AIyVHs7tmzZzA3N0fFihXlMgg5MXHixHLhtFLMyJEjoaenl+Uz7vz58+Dz+ejZs2cxjKyc4mDPnj3g8/kICgrKVviUZVl07doVXC63VP/uMzIy8O3bN2zcuJHO+/T09DB27FjMmzcP48ePx+DBg9GtWze0atUKAQEB8PDwgK2tLQwNDbP0aP77JZFIYGxsDHt7e9jZ2cHAwAAcDgccDge2trbo1KkT5s+fj40bN+LAgQP4559/cOfOHbx+/RoJCQn5TvB8/foVw4cPh6qqKiQSCYYOHYrPnz9n2u7Lly8YMGCAXJ96dkFsRkYGDh06hDZt2tDyc0IIevTogTZt2tAe/4sXL9J9ZDpB2fm4P3v2DFOnToW7uzsI+WNzXLt2bQQEBFCRNgMDA2hra4MQAhsbmzxbfbEsC3d3d7i5uUEqlWLcuHFQU1NTmojvwoUL6WdqZGSEESNGoE6dOpg/fz48PT1RvXp1OT9vOzs71KlTB6NGjUJycjI0NTXh4OAAW1vbMhFnlImg++7du+ByuWjXrh39ET58+BDu7u607OdvATXg/5L2NWvWBPDHO8/AwADJycmIiopCpUqViudiihmpVAo7OzsEBQUhNTUVBw4cQOfOnaGlpQVCCKysrBAdHY24uLgy8QPIC5UqVUJUVBSA/1ue9e7dm978nJycMH369EwlROUUDJZlERsbS23U2rZtm+cApzQQHx8PsViMUaNGFfdQ8szLly/RuHFjEPLHczU7hfgFCxaAEIJDhw4p5LxXrlyBpqYmPDw8lLpIERsbCy6Xi169euV6X3v9+jWsra1hbGwst1Kf3XHLhdNKN4cOHQIhJFOv55s3b2BgYABvb2+lKRGXU7LYtWsXeDwegoODcwy4Bw4cCEL+74xTWrlz5w7q169Pg+R+/frl+xipqan49OkTHj9+jKtXr+L48ePYsWMHVq5ciZiYGNSsWZMGpurq6rC2toaTkxMsLS2ho6MDHo+XY7ZdU1MTFStWhJOTE2rVqoWmTZsiNDQUvXv3xvDhwzFt2jQsW7YMW7duxeHDh3Hp0iVcvHgRffv2pRpO0dHRWQbfz58/R0hICAghqFKlCmJjY3N8Pnz79g2LFy+mAaSmpiZEIhHU1NTg4eFB45MbN26AECLXjvLkyRNMmjQJVatWpT3ZDRo0QOvWrWFtbU3L2S0tLcHhcCAWi9GpUyf8888/+Z6Lnz59GoT8UVeX6VacOnUqX8fIK58/f4ZQKMTAgQMRERFBs/N/Vx5zOByoqakhICBAbh69atUqMAyDTZs2gRCCgwcPKmWMRUmZCLq7d+8OQ0NDXL58GeHh4bT/Q/ahurm5wcvLS65kkGVZuLq60hVsHR0dDBo0CADQo0cPVKtWrbgup1iR2WMFBATQ99HGxgbDhw/HzZs3/zOB9t+oqqpi2LBhGDduHGxsbGjJU1RUVIlXzC5txMXFURXsWrVq5bsPrrQwaNAgqKmpKUQRW5mkp6dj1qxZNCOxa9eubLd98OABRCIRIiMjFXLuCxcuQF1dHTVq1FBqH/SVK1egoqKC5s2b51ns8f3796hcuTIMDAxw586dLLd58uQJNDQ00LRp0zLXcvNf4sePH2AYBqtWraL/9/v3b7i7u8PU1FRp+gLllCx27NgBHo+H1q1b55gVHD9+PAghWLBgQRGOTrG8fv0anTt3puXMKioqchoXhSEpKQmrVq2Ct7c3DUwjIyOzTeTIbODevXuH+/fv4+LFizh06BC2bNmCpUuXYurUqRg2bBgiIyPRvn17NGnSBD4+PlQ9XENDI0cbOFlmmmEYGBoawsfHB0FBQejSpQv69++PMWPGYMCAAVTzycXFBRs2bMDTp0/x+fPnLL8LLVu2RPXq1TFkyBDaY00IQUhICOLj45GWlgaRSITo6GiMHz8ezs7OtC0xMDAQ3bt3pyroYrEYDg4ONPHl5uaGJUuWFPqZ2LRpU1hYWCA5ORkGBgY0saQMOnTogIoVKyI9PR0JCQnYtm0bFixYgPnz52Pz5s2IiorCli1b4OnpiTZt2sDX1xfnzp1DtWrV0KBBAxqjWVlZlXpb3VIfdP/48QMikQgGBgY5lrHIftzu7u6oUaMGqlevjl69eoEQgjVr1oAQghMnTgAA2rZtC19f32K+sqIjOTkZu3fvRrt27cDlcmmJx6hRo3D79u3/ZKAN/Fm1nDt3rlwpVMeOHXHs2LFSq8ReUnnx4gXat28PQv5Yc+zbt69Mf+8+fvwIFRUVDB8+vLiHki1xcXGoWrUqGIZB7969c7Q6S0tLQ7Vq1WBra6sQBduzZ89CVVUVPj4+Sm3VePr0KfT09ODp6ZnvcX/69AnOzs7Q0dHB9evX5f6WmJgIBwcH2NjYlAunlQEcHR2p8BHLsujQoQNEIhGuXbtWzCMrpyjYtm0buFwu2rZtm6NGy/z580EIwYQJE4pwdIrj27dviIqKglAohIaGBlRVVWFpaVloLQqWZXHu3DmEhYVBIpGAYRj4+/tj8+bNRaLPIpVK8ePHD7x69Qq3bt3C2bNnsX//fqxfvx4LFizAsGHD4OHhQfuiLS0t4ebmBnt7exgZGVFHo+xeYrEYRkZGsLOzQ/Xq1WFlZQWhUIjw8HAMHDgQJiYmcoG/qakpFXtWVVVFq1atMHToUAQGBkIgEIBhGDg6OlKBNC0tLfTp0yeTfkphuH//PjgcDmbPno0uXbrAwcFBYcf+N3FxceBwOAgPD880r5PZOr9+/RoikQivXr1CfHw8VWGXudPIEl4FqbYoSZT6oDsmJibbH4GGhgYVOfj71aFDByxbtoz++FVUVOT6BRo1aoTAwMBivjLl8uvXL+zYsQNt27aFqqoqCCGoVKkSCCGYPHlycQ+v2EhJScGuXbsQFBREb36EEMTExGTbf1NOwfn27RsGDx4MgUAAQ0NDLF269D8jPBcVFQVVVdUS16eelJSEgQMHgsPhwNHREZcuXcp1n5EjR4LH4+Hq1auFPv/JkyehoqICX19fpf7mPn36hEqVKsHGxibL0sK88PXrV7i7u0NDQ4O+TyzLomXLllBTU8P9+/cVOeRyiomePXvC3t4eADBr1iwQQrBx48ZiHlU5RcGWLVto+2JOz6Z169aBEIJBgwaVugVjmYCYpqYmJBIJmjdvDj6fjzp16hTq+fTu3TtMmTKFBkzm5uYYO3asQm0kFcmnT58wZMgQqKioQE1NDSNGjMC3b98A/N8G7uHDhxg+fDi0tLTA4/HQoEEDTJo0iWbEw8LC4OHhAUIInJ2dYWVlJVd9m9OLx+NRZXhZ37a/vz+ioqIwdepULFmyBJs3b8ahQ4dw4cIF3Lt3D+/evcPPnz8L9J3r3r07tLW1aeJRmZ+LTCStc+fO9Ln+t6BacnIyqlSpgt+/f9P2jL9jETMzM9rfnpWyfGmhVAfd9+/flxNqsLGxweLFizF06FA5AbVFixbB3t5ebqWpZ8+e8PDwgLe3NxiGkfOjrlmzJjp27Fgcl6RUkpKSsHXrVrRq1Yqu3Dk7O2PChAl48OABevToAUNDw/9cfxrLsjh//jx69uxJS3hcXV0xa9Ys7N+/H4SQbEtIyykYKSkpmDlzJrS0tCCRSDBmzJg824CUFT59+gSJRIKYmJjiHgrlwIEDMDMzg0gkwpQpU/JUynXhwgVwOJxMfqQF4ciRIxCJRAgICFCa5ysA/Pz5Ex4eHjAwMJATjCwICQkJqFmzJlRVVXH27FlMmjQJhBDs2bNHQaMtp7hZv349CCHYuXMnOByOUksxyyk5bNq0CRwOBx06dMixum3Pnj3gcrno2rVrqQq4MzIysHr1apiamoLH46FXr17o3bs3CCHo1q1bgeaCqamp2LlzJxo3bgwOhwORSITQ0FCcPHmy1LTZfPz4EYMHD4ZYLIa6ujpGjRqVSVPk58+fGDt2LCQSCbS0tDBjxgyqIXXv3j0QQhAaGkrL0mWxCofDQfv27aGuri4XcMsCbRUVFVSpUgX16tVDrVq14OzsDHNzc2hqauZqA6ejowNLS0u4urqiTp06CAwMRKdOndC3b1+MGjUKM2fOxIoVK7Bjxw4cO3YMBw8ehFgsRrdu3cDlcrF48WKlvaeTJ0+GUCgEn8+HhoYGevfuDW9vb8yaNQseHh5wc3ODiooKnYMLhULUrl0bR48exefPn+VsoEtzYrBUB90+Pj70Q/Dz80NSUhItVZBNFv8WUJOJYMj2GT58OOrWrQsdHR25EhdHR0f06dOnuC5LoSQmJmLTpk0ICgqCWCwGIQRVq1bFpEmT5CwYvnz5ArFYjPHjxxfjaIuWx48fY9SoUbC0tKQlP9HR0bh79y7dZteuXSCEFDgTVo48UqkUmzZtgrm5ObhcLnr06IH4+PjiHlaxER0dDYlEolQbrLwQHx+P1q1bgxACf39/PH36NE/7JSUlwcrKCp6enoWuUIiNjYVQKESjRo2UWnKYnp6OJk2aQFVVFXFxcQo5ZlJSEnx9falITGkSySsnd549e0ZbjOrXr1/eXvQfYP369eBwOOjUqVOOn/eJEycgEAjQqlWrUvO9YFkWBw4coGKlrVq1wo0bNxAYGAiGYTBr1qx8Lx7cuXMHAwYMoAKzHh4eWLJkSalz6fibDx8+YNCgQbRydvTo0Zmu58OHD+jVqxdV527WrBmsrKxoxW2XLl2wZcsWzJkzh9qwcblcGr/w+XxwOBxUqFABPB4PXC4XzZo1w65duzIterAsi8TERLx+/Rp37tzBuXPnEBsbi40bN2LRokWYPHkyhg4dip49eyIkJAQNGzaEl5cXHBwcYGxsTKtac+pvNzAwoFbL/v7+CA4ORrdu3TBo0CCMGzcO8+bNw9q1a7Fnzx6cPn0aN27cwPPnz/Ht27ccv/9v3rwBl8vF+PHjERMTk6UlHZ/Ph5aWFsRiMfbv30/3nTZtmpwAm7m5eala3PqbUht037x5k34A1tbWSExMxPXr11G5cmVMnz4de/fuxbNnz9CpUyds2bKF7rdw4UK6X+vWrVG5cuVMdlBmZmYlutcyN378+IH169ejefPm9Ivq7u6OqVOnZqsCLVuFKu7Jv7L5/PkzFi5cCE9PTxBCoKamhrCwMJw6dSrLVdhFixaBy+WWmhXakszJkydRrVo1EELQrFmz8tJb/FnsUlVVxZAhQ4rl/FKpFEuXLoWGhgb09PSwYcOGfD3MunfvDhUVFTx58qRQ45DZ8DRv3pxmC5QBy7IIDw8Hj8fD4cOHFXrsO3fugMfjgcPhYN++fQo9djnFS2JiIng8HjQ1NWm5aTlll7Vr14JhGHTp0iXHQOLSpUuQSCRo0KBBqakQvHTpEmrXrg1CCOrUqYPLly/j9evXcHFxgaqqKg4cOJDnY33//h2LFy+m1lZ6enoYOHBgmasMjI+Px4ABAyASiaChoYExY8bgx48fYFkWV65cQVRUFExMTGhsoaurC0NDQ/j5+dFSfS6XC09PT7mKWw6Hg/r169PEw5cvX7BgwQK4ubnR4/Tr1w83btxQ2LWkp6fj69eveP78OW7cuIHY2FhoaGigYsWKEAgEGDlyJAYNGoSuXbsiODgY/v7+cHd3pw5Pfwe/Wb1UVVVhbGwMBwcHeHl5oWHDhggJCUHPnj1hYGAAW1tbZGRkICUlBUePHsX69euxbt06HDx4EDExMdi5cydsbW1Rq1YthISE4MOHD7C0tESHDh3kEq0lXYQ2O0pt0N2jRw/65uvr62fbM2FmZoa9e/di7Nix8PHxgbW1NS3jkGW9N23aJHdsTU1NTJs2rZiurGB8//4da9euRZMmTSAQCEAIgaenJ2bMmIEXL17kuG9aWhqMjY2pUExZ4/fv39i+fTuaNWtGhTKaNGmCLVu2IDk5Ocd9R48ejQoVKhTRSMsmd+/epXZTHh4eOHPmTHEPqUQxbNgwqKioFHmf0r1791CzZk0QQhAWFpbv3j2Z08HSpUsLNQ6ZKnBONjyKYty4cSDkj3imIklKSoKDgwMqVaqERo0agc/n56j0Xk7pQSqVIigoCFwuF25ubsU9nHKUzOrVq8EwDLp165bjYvudO3egpaWFmjVrKrUVRlE8evQILVu2BCEEjo6OOHjwIFiWxeXLl2FoaIiKFSvi9u3buR5HKpXi+PHjaNeuHUQiEbhcLpo2bZplZrasER8fj379+kEgEEAoFFJlcj09PfTo0QNHjhzBnDlzoKenR2OQypUro1u3bggICACXy6Vxh6mpKerWrYvmzZtnea47d+5g0KBBVCTa2dkZs2fPVkpibPHixXS8eVGpT0lJwcePH/H48WNcuXIFx44dw44dO7BixQrMnDkTo0aNQt++fdGpUycEBgaiTp06cHV1hZqaGhiGQZ8+fbIVVJP1zgPAmjVrYG9vDz6fj+vXr6NNmzZ0nLNnz1b4+1AUlNqgW2YKL/sCV6pUCXw+H5UqVYKHhwfmzp0LhmFoH4CxsTG+fv0KCwsLGnTLVmX+vlGwLAsOh4MlS5YU49Xlja9fv2LVqlVo2LAhvU4vLy/Mnj0br169yvNxNm/eDEJInm64pQWpVIozZ87IWci5u7tj3rx5+bpp9ejRA1WrVlXiSMsu7969Q7du3cDhcGBpaYmtW7eW2pIgZfL161eoqalh8ODBRXK+379/Y8SIEeDz+bCxsSmQP+fHjx+hr6+PJk2aFOoz3bx5M7hcLkJCQpQuoLdy5UoQonhlYZZlERwcDFVVVdy7dw9paWlo06YNuFxupgXdckofsoWasLAwiESiMh9Y/JdZuXIlGIZB9+7dcwy4nz59CiMjI7i4uJT48un4+Hj07NkTXC4XZmZmWLt2Lc3eb9myBSKRCDVq1Mh10ffly5cYM2YMKlasCEIIbG1tMXXqVLx//74oLqNYkUqlOHfuHPr3708z2ioqKuBwOFBVVUXv3r0RFRUFc3NzEEJQsWJFKkwsezk5OWHx4sX48uULVSWvX79+rkmdtLQ07N+/Hy1btgSfzwePx0NgYCD27NmjsEXq9PR02NjYQCQSKVUdXKbuL9MMkOn4/C2oJuPHjx80yF63bh0AoHnz5nR/KyurUjmfLJVBd2pqKu2L0NXVxblz5wAAo0aNkhNQO3nyJPr06YNTp05BR0cHTk5OePfuHVUWJITA29tb7thJSUkghGDz5s1Fek155fPnz1i+fDnq168PHo8HhmHg4+ODefPmyZnK5xWWZeHh4YF69eopYbRFj0xZUvZgMDc3x4gRIwpseREYGIiGDRsqeJRlm8TERIwcORIqKirQ1tbGnDlzyiequTBy5EiIxWKl97efPHkS1tbW4PP5GDVqVIF6p1mWRfPmzaGrq1soj+J169blSaRIERw8eJBqCCj6QT158mQQQrB79276fxkZGejUqVMmf+dyShd79uwBIQTjxo3DpUuXQAjJk5p/OaWPZcuWgRCCXr165Rhwv3v3DhYWFrCxsSnRKsoJCQn0OSwT+pLd71mWxZgxY0AIQfv27bN9DiQnJ2PTpk3w8/MDwzBQVVVF165dcf78+VIZ8OSHjIwMnDlzBn369KEuSEZGRujduzfOnDmD+Ph4jB8/Hvr6+iDkj8931apVERUVRcv3ZdV9GhoaUFFRwciRI5GYmIibN2+CYRhaqv3u3bs8jenLly+YP38+bdPT09ND//79FWIlJrvXKbOyc+fOnXKl9WpqaoiIiEDNmjUxdepUuLm5wcnJCZaWllBRUQGfz4enpycEAgHi4uLoey17HT9+XGljVRalMuhOTEwEh8OBpqYmHj16BAA5CqgBf0pcBQIBRCIRwsLC6IfWv39/uWO/ffsWhBDExsYW7UXlwMePH7FkyRL4+fmBy+WCw+GgTp06WLBgQaFXGS9cuABCSL76eEoaHz9+xNy5c2kfjIaGBsLDw3H27NlC92J7enqiS5cuChpp2SYtLQ2LFi2Cvr4+hEIhhg4dWuKzACWFb9++QUNDAwMGDFDK8b98+YIuXbrQhcZ79+4V+FgrVqzIFGTmF1lGqWvXrkoPuK9evQqJRIJmzZopPJt+6NAhMAyDkSNHZvqbVCqlbVCLFi1S6HnLUT53796FqqoqgoKCIJVKkZqaCpFIhJkzZxb30MpRMEuWLAEhBJGRkTkGk1++fEHlypVhamqar2rCoiQ1NRXz5s2Dnp4eRCJRpudwcnIy2rZtC0IIJk6cmOl6WZbFtWvXEBERQcunfXx8sHr16jLvMJKRkYGTJ08iIiIChoaGtEq2X79+OHfuHH7+/ImtW7eiSZMmtFWxWbNmGDZsGBwcHGhcYWlpSRdjDx8+jB8/fiA6OhoikQj6+vpYtGgRVYknpGBOF7du3cLAgQNpIOri4oI5c+YUWPSXZVnY29uDEFJoX/bs+PnzJ608FQqFGDRoUJaCahwOB7q6uvDx8UGHDh3g6+uLqVOnZtquVatWShmnMimVQfeNGzdACMHWrVsBAO/fv4eTkxMWLFiA2NhY3Lp1K5OAGgDqRWdsbEw/tH9Lz9+/fx+EEJo9Ly7i4+OxcOFC+Pr6gsPhgMPhoF69eli8eHGhskv/pnXr1rC2ti51QmHJycnYvHkzGjduDC6XS0WYduzYoVDlY3Nzc0RHRyvseGURlmWxe/du2NjYgGEYdOzYscROSEoyo0ePhkgkUmi5HsuyWL9+PXR1daGhoYFly5YV6rf+9OlTSCQShIWFFfgYS5cuBSF/bBuVfd959uwZ9PX14enpqfC+y6dPn0JTUxONGzfO9jpYlkW/fv1ACMGsWbMUev5ylMe3b99QqVIlVKlSRS7QqFWrFoKCgopxZOUoGpm4blZ9pn+TmJgId3d36Onp0WRPSUIqlWLz5s2wtLQEh8NBWFgY3rx5I7fN+/fv4eHhAbFYjB07dsj97dOnT5g9ezYcHR1pxnPYsGFyLjdlkfT0dBw/fhw9evSgAayZmRkGDhyICxcuID09HadOnUJYWBi1+fL09MS0adMwdepUVK1aVS4L3r59ewgEAmhra4PP52PixIn0XK9fv6YVUJUqVaLH69mzZ4HHn5aWhn379iEoKAh8Ph98Ph8tWrTA3r17811+fvLkSRBC0K5duwKPJzdkz0NCCKKjo5GamorTp09j+/bt2LFjB86ePYvhw4dj586deP78OSIjIxEaGkq93gkh1InJ0tJSaeNUFqUy6JYZujs5OcHIyEhODVD20tXVxdKlS5GUlASpVAo7OzvMmjULOjo6cup7J06ckDv2xYsXi62/+d27d5g/fz5q1aoFhmHA5XIREBCAZcuWKUU84dWrV+ByuViwYIHCj60MpFIpTp48iS5dutDVsRo1amDRokX5FoHKCyzLQiwWY86cOQo/dlnh4sWL8Pb2BiF/rKYUqbL5X+P79+/Q1NRUWE/V06dP4e/vD0II2rRpU+jS9YyMDHh5ecHCwgKJiYkFOoasp6tv375KL0/89OkTrK2tYW1trXDLv6SkJFSpUgXW1ta5VnOwLIvo6Gil9JOXo3gyMjIQEBAAbW3tTG4fMTExMDQ0LPOltf8VZPej/v375/iZJicno06dOtDQ0MD169eLcIR54/jx47TkuGnTpnK2pzJu3LgBExMTVKhQAdeuXQPwJ+CMjY2l/cJ8Ph/BwcE4ePCg0jU2ipO0tDQcOXIE3bp1g46ODm1FjIqKwuXLl8GyLO7du4fo6GiYmprSAG/kyJHYsGEDQkNDqYhc8+bNsX//frn36/Xr1+jVqxctIZ86dSp+/vxJ/37z5k3Ur19fLohUBJ8/f8bcuXPh6upKy88HDBiQr3hGplCem8hwQXn48KFczDZv3jy5v/9dtdyjRw/cv39fThne0dERFhYWIIRAXV1dKWNUJqUu6E5PT4eKigqqV68OQv5YPnG5XFhYWMDNzQ2zZ8+W65WQSCQYP348TExMUKlSJVSoUIF+4DY2NpkyFEeOHAEhpMgydW/evMGcOXNQs2ZNMAwDHo+Hhg0bYuXKlUoJJP9myJAh0NDQKPElQ3fv3sXQoUPpD8/KygqjR48utE1RbiQkJIAQkqliohzgyZMnCA4OpgIheVG8LCd3xo0bB6FQWCB9BhlpaWmYPHkyRCIRKlasiIMHDypkbBMnTgSHwylwFdCsWbNACMGgQYOUHrT8+vUL1atXh76+frY2iQXl38Jped1HJsg1YsSI8qCtBBMVFQUOh4Njx45l+tuBAwdACFH4d6qcomfu3LkghGDgwIE5/h7T0tLQtGlTiMXiYq+A/Dc3btxAQEAATUCcPXs2y+327NkDiUSCatWq4e3bt3j8+DFiYmJor7Kjo2OhSpNLA6mpqTh48CDCwsKoELOVlRWio6Nx7do1sCyL+Ph4zJ49m2avtbS00LNnT+zduxeTJk2CtbU1CPkj3Dx58uRcq9JatWoFPT098Pl86OnpYdq0aXLB99GjR6nbkJubm0KrCm7evIkBAwZQJfWqVati3rx5uX7Gw4YNAyEEY8eOVdhY/o1sgUj2atSoEQ4ePIjv379TQbUbN27A29sbtra2dDtVVVXcuHGDfm/5fH6pe5aWuqD748eP9AMYP348UlJSshVQe/78Odzc3MDlcjFy5EjMnz8fmzZtovtnJTm/bds2EEKU2ov68uVLzJw5EzVq1KBfnMaNG2PNmjVF5gH68+dPaGpqFplicn6Jj4/HrFmz6IqdtrY2evXqhQsXLhTZj+zx48cghBRI3bms8unTJ/Tp0wc8Hg8mJiZYs2aN0nty/0skJCRAS0sLvXv3LtD+Fy9ehKOjIzgcDgYNGiT3gC8McXFx4PF4iImJKdD+U6ZMASEEMTExSv/9pqeno2nTppBIJDSjo0hk11IQS7Bp06YV2cJDOflnw4YN2c4NgD9OA4T8X023nNKJbAEwKioqx9+hVCpF+/btwefzcejQoSIcYc68ePEC7du3ByF/VMR37dqV5XWwLIupU6eCYRgEBgZi8eLFtDJNU1MTERERNOAsi6SkpGD//v3o1KkT7U+3sbHB8OHDcePGDbAsi1+/fmHjxo1o0KABuFwuBAIBgoKCsH37duzcuRPNmjUDl8uFSCRChw4dcPr06Ty/XzNmzICKigqeP3+O7t27g8fjQV9fHzNmzKDtTrKYg2EYcDgc9OnTR6GVrampqdizZw8CAwPB4/HA5/MRFBSEffv2ZVl+/ujRI5p9V9YijKzy698voVAIc3NzSCSSLCuYbWxs6D1a9rp48aJSxqgsSl3QPWPGDDlhmtwE1JYtWwYrKyuoq6tj6tSp2LVrFwghMDExQUJCQqbjy0SCFB1IPH/+HNOmTaPK6UKhEM2aNcP69evx48cPhZ4rLyxcuBAcDgcvX74s8nNnx8+fP7FhwwbUr18fHA6H3vx2795dLOrXZ8+eVaqoRGni169fmDRpEtTV1aGuro7Jkycrrfzov86ECRMgEAgy9ePlREJCAiIjI8EwDKpVq4a4uDiFjSc5ORn29vZwdXUt0O9QluEdPXq00id3LMuie/fu4HK5SpkkHz58GAzDYMSIEQU+hqykNSIiotRpaZRlrl27BpFIhE6dOuX4PbW3t0ePHj2KcGTlKBLZHDI6OjrHz5llWURERIDD4WDbtm1FOMLs+fz5M/r37w+BQABDQ0MsXbo02zLwlJQUdO7cGYT88XhWUVEBwzDw9/fH5s2bFap9U5L4/fs39uzZg9DQUNozbWdnh5EjR+L27dtgWRYZGRk4duwYOnbsCFVVVRBCULNmTSxZsgRXr15FTEwMjIyMaIZ44cKFBUrEHT58WK4y5sWLFwgPD6fB98yZM/Hq1SsaQLq6utI51qRJkxSuQ/Lp0yfMmTMHzs7OIITAwMAAgwYNwp07d+g2LMvC3NwcfD5fafZhMl0uWdIxqwD875eenh527tyJFy9e0HJ/WTIuNDRUKWNUFqUq6JZKpahUqRKCg4MB/Jlouru7Y+PGjTh58iRu3LiBDh060HLgjIwMNG7cGK9fvwaXy0WLFi2oSmV2EvszZ86EqqqqQsb75MkTTJ48mZZSiEQitGjRAhs3bswy4C8qpFIpbGxsSoTyX0ZGBo4ePYoOHTpAIpGAkD/qykuXLi2yrH92yFYgi3scxUlGRgZWr14NY2NjehMuyyVoJYHExERoa2sjIiIiT9vv2rULFSpUgEQiwezZsxXei9e3b18IhcJ8K56zLIsRI0YUaS/z+PHjQQjB6tWrFX5smXBao0aNCr0ou3z5cjAMg7CwsPJKkRLAhw8fYGJiAnd391yDkW7dusHR0bGIRlaOIpEpIA8bNizXBcDhw4eDEIIVK1YU0eiy59evX5g4cSLU1dWhpqaGCRMm5FjFdOfOHZibm9Nsobm5OcaOHVuikiyKJDk5Gbt27UJISAgNoqtUqYIxY8bI9bffunULUVFRtDzZ2toa48aNw71797Bhwwb4+vqCkD8OOJGRkYXu35e5Ie3du1fu/58/f46uXbuCy+XC0NAQ2tra0NDQAMMwOHfuHPr16wc+nw9jY2OsXr1aKc+IGzduoF+/ftDV1QUhBNWqVcP8+fPx5csX9OnTB5qamuDxeHj69KnCzw0AXl5ecoJq9evXp58dwzDQ19dHtWrV5Nwijhw5QsvxhUIh+vXrp1SLM2VQqoLuY8eOgRCCBQsWwMrKClwuN9OKCJfLRd++ffHmzRu0atWKehSKRCIIBAK4uLigatWq2Z5j9OjRMDY2LvAYHz16hIkTJ8LFxYWWaAQHB2PLli0lpnc6NjYWhBCcP3++2MZw8+ZNDB48mN78bGxsMH78eDx//rzYxvRv5s+fD4FAUGZLr3KCZVkcPnwYTk5OIOSPNYOybr7lZGby5Mng8/k5aku8efMGzZs3ByEETZo0UYoOxdGjR0EIybeYIMuyGDp0KAghmDZtmsLHlRWrV6+mbUeK5ufPn3B0dMyTcFpeWb9+PTgcDtq1a1emRYtKOqmpqfD29oahoWGetBRWr14NhmHK7RBLGTILp5EjR+b6TJ8+fToIIZgxY0YRjS5r0tPTsWzZMhgZGeW66J2amopdu3bJeUQHBATgxIkTZbKi5ufPn9i+fTtat25NEzZOTk4YP368XHXiu3fvMH36dDqX0dHRQWRkJC5duoTr16+jd+/etPS8Tp06WL9+vcKq+FiWhaamppyC+d88e/YMYWFhVDiZkD+CbSzL4unTp2jdujW9rsOHDytlLpqamordu3ejefPm4PF4EAgEtAVBX18frVu3Vvg5Aci1+qqoqFBR6/T0dEil0kxVzB4eHnIxX5cuXTBr1izw+fxSVbVRqoLudu3awcrKilp+8Xg86OjowMLCAsOHDweXy6UCCQzDwN3dnZZNxMTE0A9r06ZN2Z6jf//+sLe3z9e47t+/j3HjxlGrBYlEgjZt2mD79u0K66lUJP7+/nB3dy/yYPLt27eYNm0afZ90dXXRp08fqhZZ0hg+fDjMzMyKexhFzo0bN+Dn50erDi5dulTcQ/rPkZSUBF1d3SzLWDMyMjBv3jyoqqrCyMgI27dvV8rv5+vXr6hQoQL8/PzyNWljWRYDBgwoULBeUA4dOgQul4vu3bsr/L1gWRatW7fOl3BaXtm2bRt4PB6CgoKKpYWmHKBnz57g8/l5XoSWaX2UpB7fcnJmwoQJtMUlN5YtWwZCSKFaSAqLzIbTzs4OhPyxcMouIXHnzh05wSwulwtjY2PcunWriEetfJKSkrBlyxYEBwdDRUWFlmRPmjRJzsYtKSkJa9euhZ+fHxVWbtWqFfbt24fPnz9j0aJFtALV0NAQMTExShPm9fb2RkhISI7bREdHg8fj0RilRYsWNJC8dOkSfHx8QAiBn5+fUtXzP378iFmzZlHPcZkgdU4xU0GRSqV0nikrM+/WrRuuX7+OhIQEKqj27t07jB07ltq5EfJHyO7Tp0+YNGkSeDxeqbLjLFVBt7OzM4RCIVxcXHD//n0AyFJErUePHnTSZ2JiAj8/P1y6dAmE/JGYT0lJyfYcYWFh8PT0zHEcLMvizp07GD16NCpXrgxC/qjqhYSEYNeuXQrvw1Akd+/eBSEEGzduLJLzJSYmYs2aNXI3v9atW2P//v359hAsarp16wZ3d/fiHkaR8erVK3To0AEMw8DW1hZ79uwpkYsh/xWmTZsGPp8vVxJ48+ZNqgvRq1cvpelByAJNTU3NfPWWS6VSREZGghCChQsXKmVs/+batWuQSCRo2rSpUjLGspLUv58zimTfvn0QCARo3LhxqVqxLwvI2s2WL1+e531YloWenl6xBmXl5J2xY8eCkLypMW/duhUMw6B3797F9uw7d+4cLb0NCAjIMsj6/v07Fi9eDHd3d5rA8PX1BYfDQZMmTQps6VgSSUhIwMaNG9GiRQuIRCIQ8kfpe+rUqXLVd+np6Th8+DDat29PA/LatWtjxYoV+PbtG86cOYOOHTtCLBaDy+WiWbNm2Lt3r9KrjHr27JlrO8qZM2dAyB9xTlk219DQEPPnz8fv37/Bsiz27t0LOzs7MAyDDh06KNVhiWVZ+Pj4wNjYmI7H3d0dCxcuxNevXxV2nmfPnmXZwy0SiSAWi2m5+d8vhmFw5swZAEDr1q2ho6MDa2vrUlPNUWqC7m/fvkEkEsHV1ZXeUHITUZNlt+fOnSs3Uc2Jli1bIiAgINP/syyLW7duYcSIEXT1UV1dHaGhodi7d2+pmSyFh4ejQoUKSs2qpKen49ChQ2jXrh01sa9Tpw5WrlxZLKJxBaVJkyZo2rRpcQ9D6Xz//h1DhgyBUCiEvr4+Fi9eXF7uWgL4+fMn9PX1ER4ejl+/fiEqKgpcLhcODg5Kbw3ZuHEjCMmfXZ5UKkX37t3BMEy+gpjC8OzZM+jr66N69epKqSo6cuQIOBwOhg8frvBj/83hw4chEong5+dXIqujyiL//PMPeDweIiMj871v8+bN4evrq4RRlaNIRo8enWdNiYMHD4LP5yM0NLRYJvD37t1Ds2bNaPb235Z1UqkUJ06cQPv27SESiWiAvW3bNoSHh4OQP64IZUEj4sePH1i3bh2aNWtGs63Vq1fH9OnT8eLFC7ody7K4fv06BgwYAENDQyqaNnHiRLx8+RLx8fGYMmUKbGxsQMgfi7BJkybh3bt3RXYtsjbFnJJMSUlJ4HA4WLFiBRVzNjIyAofDgbGxMRYuXIiUlBSkp6djyZIl1Et7yJAhSmtzWbRoEXg8HrZs2UKDbpm6e6tWrRAbG6uQeaKfnx8qVKhARe9yeuno6GD06NGIjIxEfHw8+Hw++vTpA0IIjh49qoCrVj6lJuieOXMmeDwe7bn68uUL3N3dsWvXLjx8+BBJSUno1KmT3CSRZVnUr18frq6u1Hdv+/btOZ7H39+fCozJftAxMTHUn09TUxOdOnXC/v37c8yYl0Q+f/4MkUiUbX9JYWBZFnFxcejfvz8MDAxACIG9vT0mTZpUZJ7nisbNzQ3dunUr7mEojZSUFMyePRva2tpQUVHB6NGjy9QKeVlgxowZ4HK5MDExgVAoxMSJE5Vehvzq1StoaGigXbt2ed4nIyMDnTt3BsMwWLNmjRJH938+f/4Ma2trWmqmaJ4+fQotLS2FCKflhVOnTkEikcDHx6f8d6hkXr9+DX19fdSuXbtAFVfTpk2DiopK+eJkCYVlWYwcORKEEEyaNCnX7c+ePQuxWIxmzZoVeQXe27dv0bVrV3A4HFhYWGDTpk1yQf/Lly8xduxYmJubU/2bKVOm4N27d/j27Rvq1asHHo9XIgTfCsO3b9+wZs0aNG7cmCpae3l5YdasWZnmkK9fv8aUKVNoGbS+vj769euHa9euIS0tDfv370dgYCC1+goNDcWpU6eKZTHl1KlTIITQ6tzscHBwQI8ePcCyLPWmXrp0KUJDQ8HhcGBiYoJFixYhJSUFSUlJGD16NFRUVKCtrY3Zs2crPB558eIFjZn8/PxgZ2eHt2/fYubMmahSpQpdGBgyZEih2q727NkDQghOnz6NpUuXolq1anShhcvlQkNDA8HBwXj9+jWA/1tCjx07FmKxGN++fYOxsTGGDBmiqEtXKqUi6JaplgcEBKBq1aowNTUFh8PJVHLg4OCAq1evIiUlBd27d4ePjw88PT3pj5LL5eYqlOLh4YHmzZtj6NChsLKyAiF/ZOnDwsJw8ODBUt13N2HCBIhEInz58kVhx3z16hUmTZpEy+wNDAzQv39/xMXFlfrSZFNT0zJZQsiyLLZs2QILCwtwOByEh4fj/fv3xT2scv7Fx48fqZCKkZERreBRJlKpFL6+vjAxMcmzan96ejrat28PDodTZG0rv379gqenJ/T19ZUi8CcTTqtUqVKRCmadP38e6urq8PT0LBfqUhLJycmoWrUqzMzMCrxYc/78eRBClOIDX07hYFkWw4YNAyEEU6dOzXX7uLg4qKurw9fXt0grFr9//47o6GiIRCLo6upi7ty5NHBKTk7Gpk2baFueqqoqunbtivPnz9N51ePHj2FjYwNtbW2cOnWqyMatSL58+YKVK1eiQYMG4PF4YBgGPj4+mDt3bqa2poSEBKxatQq+vr5gGAZisRghISE04/r06VMMGzaMivO6uLhgwYIFxe4+8+nTJxBCcrWd69y5MxV5lllqaWlpITExEQ8fPkT79u3BMAxMTU2xePFipKam4v379+jevTtdsNmyZYtC592VK1dGWFgYrl+/DoZhsGTJEgD/T7L17t2b6mh5eHhg0aJF+X6/09PToaurCwsLC7n7cUpKCl68eJFlNfOGDRsgEAiopZmzszP8/PwUc9FKplQE3adPn6YKyhwOB0KhEFwuF6ampqhSpQqio6OpsbwsSN64cSOaNm2KmjVrQigUQiKRICgoKMvjsyyLS5cuYfDgwXSFTUdHB+Hh4Thy5EiJ7z3OC6mpqTAyMkL37t0LfawfP35g5cqVqFOnDr35tWvXDocOHSozK/8sy0IgEGDBggXFPRSFcubMGdoH1rRpU4ULQ5VTeFiWxYoVK6ClpQUdHR20a9cOXC63SNTjZ82aBUIIVRLNjbS0NLRp0wZcLrfIvGzT09PRrFkzSCQSXL16VeHHl/WzSyQSObuZouLq1avQ0tKCq6truT2fgmFZFu3bt4dYLMaNGzcKfJzfv39DIBBg7ty5ihtcOYWGZVlER0fnWXn84cOH0NPTg4eHR5FVl6SkpGDmzJm0wmzEiBFISEgAy7K4du0aIiIiqJq2j48PVq9encn55uTJk9DS0oKdnZ3SBMCUxadPn7Bs2TIEBASAy+WCYRjUrl0bCxYsyFT2nZaWhgMHDqBNmzYQiURgGAb16tXD6tWrkZCQgN+/f2Pjxo2oW7cuCPlj9RUREYG4uLhiurqsMTAwwKhRo3LcZuHCheDxeHThJyQkBIQQuWrLBw8eICQkBAzDwMzMDEuXLkVqairu379PWxPc3d1x+vRphYx78ODBMDQ0BMuy6NChAwwMDDJ9F1NSUrBjxw40adIEXC6X6jYdOnQozxVinTt3hlAohI2NDa0I+FtMTUanTp3Qv39/iMVi1KtXjyZBK1euDD6fXyoqxEpF0L1y5Uqa0R47diwSExOzFFDr3bs3duzYAR6PBz09PWp236ZNG3A4HLkeGalUivPnz2PAgAHUbF1PTw8qKiro2LFjmQkeZWzYsAGEkAIHWbKSndatW8vd/NasWVMqvuj55du3b3lqRygt3L9/H02bNqUiJKV1Zbys8+DBA9SqVQuEEHTs2BGfP39GcnIyjIyM0LlzZ6We+86dOxAKhRgwYECetk9NTUVQUBD4fD527dql1LHJYFkWPXr0AJfLxcGDB5VyjmnTpoEQgh07dijl+Hnh1q1b0NPTQ5UqVfDhw4diG0dZY8aMGfnWKsgOLy8vpdnplJN/WJZFVFQUCCF5UjN+9eoVTE1N4eDgoNDqv+zIyMjAunXrULFiRXC5XPTo0QPv37/H58+fMWfOHGppVaFCBcTExMipcf/NsmXLwOPx4O/vX2qqYT58+IDFixejXr164HK54HA4qFu3LhYvXoz4+Hi5bVmWxZUrV9C3b1+qyF6lShVMnTqVZr9v3ryJPn36QEtLiwqmrVu3rsSKGNerVy/bpJ+MK1eugBBC3WI+ffpEhePOnTsnt+39+/fRtm1bMAyDihUrYtmyZUhLS8Pp06cVmlQ5efIkCCG4fv06Xr58CaFQiDFjxmS7fXx8PGbMmEHL/itUqIChQ4fmWlo/ffp0iEQiWl0cEBCAatWqYcqUKfDw8ED16tVhZGREPcUFAgH17/758ydUVVXBMAwWL15cqOstCkpF0B0YGAhCCFavXg0gdwE1c3NzqKiooF69eqhVqxZat24NfX19ZGRk4OzZs+jbty+1HTMwMEBERAROnTqFjIwMSCQSzJ49u5iuVDmwLAs3N7csBeJy2+/y5cvo06cPvfk5Ojpi2rRpefIzLc3cv38fhBD8888/xT2UQvHv8qPNmzeXGpXH/xIpKSkYM2YMBAIBKlWqhOPHj8v9fe7cueBwOEorMU9JSYGzszMcHBzyVGKZkpKCpk2bQiAQYP/+/UoZU1bIrH9WrlyplOMfPXoUHA4Hw4YNU8rx88P9+/dhZGQEW1vbMn+/LQoOHz4MDoeD6OhohRwvKioKJiYmCjlWOYWDZVkMHDgwzzaFHz58gLW1NSwtLZUuqsWyLA4dOkSD6pYtW+Lu3buIjY1Fy5Ytwefzwefz0bJlyxzFqTIyMqgrT0RERIlPDL1//x4LFixAnTp1wOFwwOVy4e/vj6VLl2bZ1vHixQtMmDCB9jMbGRlh0KBBuHHjBliWxY8fP7BkyRK4ublRde/o6OgiabsqLH379oWNjU2O26SkpIDP52P+/Pn0/2R+8RYWFlk+l+/evYs2bdqAYRiYm5tjxYoVSE1NlWsf7N69e4HbB1NTU6GmpkaFCKOioiCRSDItlPwblmVx9epVREZG0oWR6tWrY/HixVkuFL158wZcLhezZ8/G6tWrYWFhkaWQmpqaGipXroxGjRrR92np0qXgcDjw9/dHlSpVSnxba4kPupOTk6GqqkoVRhMSEuDt7Y2LFy/iw4cPSElJySSg5uHhgXXr1oEQgtDQUNSoUQOmpqYwMjKiqy99+vTBmTNn5Mof0tPTlTqhKy7OnTsHQkieM0MvXrzA+PHjqeKj7OZ38+ZNJY+05CBb4SsNN/SskAltSCQSaGlpYdasWaVO+O+/wtmzZ2FnZwcej4dhw4YhOTk50za/f/9GhQoV0KFDB6WMYejQoeDz+XkquU1OTkaDBg0gEolw+PBhpYwnK9asWZNn65+C8OzZM2hpaaFhw4YlRgH4yZMnMDMzg6WlpZx1XDn548mTJ9DU1FToZysTACqtQqFlBZZl0b9/fxBC5AKW7Pj+/TucnZ1hZGSEZ8+eKXVsV69eha+vLy0V37ZtG2JiYmjfsaOjI+bMmZNrG0lCQgIaN24MLpdbolve3r59i3nz5sHHxwcMw4DH46FBgwZYsWJFltUE379/x7Jly2h1l4qKCkJDQ3HkyBFkZGSAZVmcPXsWnTp1glgsBofDQdOmTbFnz55S1fa5bNkycDicXBe03d3d0bFjR/rv1NRUVKxYEQzD5LgQfOfOHbRq1YoG6CtXrkRSUhIVypVIJBg9enSm0vC8EBQUBC8vLwB/Pi9tbW306NEjz/unpKRg+/btaNy4MW0Pbtu2LQ4fPix3Lw4KCoKtrS1NCt26dQu7du3C+vXrsW/fPgwYMIBWN69evRrz58+HVCqFs7MzmjZtip07d5aKOXuJD7pXr15NRRFcXFwgFotp37XsZWxsjK1bt6Jbt26oXbs2TExMIBAIYGFhAUNDQwgEAqirq6N///44d+5ctpk+WUlxcZYVKoOWLVvKfZmz4tu3b1i6dCm8vb1BCIFEIkGHDh1w9OjREjMBLUo2b94MQkipK53/t6VEVFRUsQuJlJM13759Q7du3UAIQY0aNXDnzp0ct1+wYAE4HI5cj5MiOHPmDBiGwZQpU3Ld9tevX/Dz84NYLM6UjVcmhw8fBo/HQ3h4uFJWsn/+/AknJydYWVmVuN/Ly5cvYWlpCVNT01LXv1kSSExMROXKlWFjY6PQclyZQNKmTZsUdsxy8gfLsujbty8IIVi4cGGu2//8+RNeXl7Q1tZWql7DkydPqAimvb09+vXrR+dWmpqaiIiIwLVr1/J0L3vx4gWqVKkCdXV1HDlyRGljLiivX7/G7Nmzqbc4n89Ho0aNsHr16iw9nVNTU7Fnzx4EBwdDKBSCw+EgICAA69evp0Hhhw8fMG3aNJr4sbS0xMSJE0ttxc+FCxdACMl1UTsiIgJ2dnZy/7d//36q5J3b/rdv30ZwcDB9z1atWoXPnz9TS1gDAwMsWbIkX1USK1asAIfDoYsms2bNApfLzbVkPCvev3+PadOmwd7ensZu0dHRePjwIfUqHzx4cKbfxb+rm2VBt8wW+tSpU7h06RIIIahfv36JznaX+KDby8sLXl5e9IZFCIGuri5sbGzQr18/MAwDgUBAA8WjR4/iypUr0NbWhrm5ORVY+7cSYlbIJPJLi99bXnjx4gU4HE6WvQ6pqanYvXs3WrZsCYFAAA6Hg/r162PDhg3/ea/Y2bNnQ0VFpUT/eP+GZVns3buXesh36NChPDNWQmFZFps3b4a+vj7U1dWxaNGiPJX8p6SkwMTEJF9WXrmRkJCAihUrwsfHJ9fFtaSkJNSpUwcSiURhQi15IS4uDhKJBE2aNFFKSSXLsmjTpg0kEkmuCx/Fxdu3b2FrawsjI6Ny8cN8IJVK0bx5c6irq+PBgwcKP761tXWBfL7LKTwsyyIyMhKEEKqqnBMpKSkICAiAqqoqLl++rJQxffz4EZGRkeDxeNDX14ePjw8kEgkYhoGfnx82bdqUZSVTdpw7dw56enqwtLQsUJCjLF68eIEZM2agevXqtMe2adOmWLduXZYLWyzL4uLFi4iIiICOjg5NpM2YMYOW96enp+PAgQNo0aIFeDwehEIh2rVrh5MnT5b6lriEhAQQQrB+/foct1u9ejUYhkFCQgL9P5Zl4efnB4FAAFdX1zw9A2/duoWgoCAQ8sebfM2aNXj27Bk6duwIhmFgZ2eHPXv25Gl+++7dOxBCqDNJSkoKLCws0KxZs1z3zQ5Z3/7fooGenp5gGAaEEPTp04dWZmYlqLZ8+XJaQSITTPznn39ojHjhwoUCj03ZlPigW6bgW6FCBezevRsjRozIJKDWp08f3LlzB/Xr1wePx0NoaCgWLVqEq1evghCSZyn5W7dugRCitBtycTBo0CBoaWnRIJplWVy4cAG9evWiUv+urq6YOXNmuW3UX0RHR8PCwqK4h5EnLl++TMuz6tWrh+vXrxf3kMrJhufPn6NBgwYghCA4ODjf/YSLFi0CwzAKm4B16tQJampqePHiRY7bJSQkoGbNmlBTU8sk6qJMnj9/DgMDA3h4eChtIVAmnFbSRRM/fPgAR0dH6Onp/adafQrD6NGjwTCM0nQHOnfuDBcXF6Ucu5zskUql6NWrFwghWLZsWa7bZ2Rk0MzqyZMnFT6epKQkjBkzBhKJhFqAEUJgbm6OsWPHFmgBfN26dRAIBKhVq1aJcDF49uwZpk6dSoW6hEIhAgMDsXHjRrkg8W+ePn2KMWPGoFKlSjSzOWTIELnFzefPn2PEiBFUZ8nZ2Rnz588vcRVHhcXMzAxDhw7NcZu7d++CEJLpO3rv3j1wOBwwDJMnGzwZN2/eRIsWLUAIQaVKlbB27VpcuXIFfn5+tOVBJtyWEy4uLmjfvj39t6wS9MyZM3keS3b8/v0bW7duRcOGDcHj8agGgJ6eHoYMGQJXV1fY2dnB29sbTZo0wdChQ6nAnI2NDU2oLl++nAbdymrDUwQlOuj+9esX+Hw+zMzM8OrVq1wF1NLT06mcfmxsLBXDyqt37NmzZ0EIUcqKeHGQmJgIDQ0NDB06FE+ePMHo0aOpOqCJiQmGDh1aLJY4pYHOnTujRo0axT2MHHn69CktYXN0dMShQ4dKTWb+v0Z6ejqmT58OsVgMU1NT7Nu3r0DHSUlJgampKdq2bVvoMe3YsUNOoDI7vn//Dk9PT2hoaODixYuFPm9e+fz5M2xsbFCpUiV8/PhRKeeQCafFxMQo5fiK5suXL6hatSq0tLSUYpdWlpD1+E2cOFFp51i+fDk4HE6pa0MqzUilUnTv3h0Mw+RJf4dlWYSFhYHL5WLv3r0KHUtaWhrmzp0LDQ0NGhQJhUK0b98eJ06cKFCGViqV0rLZLl26UFuk4uDJkyeYNGkSqlatCkIIxGIxWrZsiS1btmT7nf/69SsWL15My81VVVXRuXNnnDhxglZT/f79G5s2bUK9evVACIG6ujp69uyZ55L70kijRo3QuHHjHLeRiTlnFVj36dMHfD4fIpEoW2X77Lhx4wYVpLa2tsa6desQGxsLR0dHEELQunXrHC1Jhw0bBh0dHfr5SaVSuLm5wcPDQ6GfV69evaCmpoYbN26gX79+EIvFmcTUeDweeDwezM3N0bp1a2qD7O7uTqueBQJBiVioyooSHXQvW7YMDMPg7t27ciUGsg/53wJqAPDo0SOoqqqifv36tI/i9u3beTrfgQMHQAgpMxnfKVOmgMPh0BummpoaunTpUibKdZRNgwYNEBgYWNzDyJLPnz+jX79+4PP5MDY2xqpVq/6TffelhStXrsDFxQUcDgf9+vUr9AR96dKl9L5YUN6/fw8dHR20aNEix4fm169f4ebmVuRB3q9fv1CjRg3o6ekpzZ/8+fPn0NbWRoMGDUrV70e2CKKurl6kVQeliTt37kAikaBVq1ZKncTLFvb/tiMtR3lIpVJ069YNDMPkulgIyKua51bamx9YlsWMGTNoaSwhBE5OTtmqM+eVnz9/IigoCAzDYPr06cUSgD58+BDjx4+Hs7MzFTdr3bo1tm3blm21UUpKCnbu3InAwEDw+XxwuVw0bNgQmzZtkrPxunXrFvr27UsVrWvVqoW1a9eWWKsvRRIVFQVzc/Nct6tVqxaCg4Mz/f/Xr1+hpaUFdXV11KpVq0Bz+OvXr1M/bxsbG6xbtw4rV66EsbEx+Hw++vXrl2WwKhNj/nvR/dSpUyCEYOvWrfkeR3acP38ehBCsWLECwJ/fw969e7FixQqsWLECbdq0wahRo9ClSxe6j6enJ7Vbk9niEkKwZ88ehY1LkZTYoJtlWTg7O6NmzZqoXr061NTUoKenR0uiZSsegwcPxocPH/DPP//Aw8MDFStWRJUqVUAIQY8ePaCurp7nH/TGjRtBCCnV/cwyo3rZD4thGDRu3BibN2/+T9zYFIWrqyt69uxZ3MOQIzk5GVOmTIGGhgbU1NQwceLE8s+0BJOYmIi+ffuCw+HAxcVFYUGrTNG0VatWBdqfZVk0bNgQBgYGOa4Gf/78GS4uLtDR0cmTqrmiyMjIQPPmzaGiooIrV64o5RwlWTgtLyQmJqJWrVqQSCQ4depUcQ+nRPH161dYWlrCyclJ6c9yqVQKLS2tHL1ry1EMUqkUYWFhYBgGa9euzdM+48ePByFEYYrfP378wIABAyCRSKhoWIcOHRSiBfH27VtUrVoVEolE4Rn53Lh37x7Gjh1L586qqqoICQnBzp07s51jsCyLf/75Bz169KBBdLVq1TBnzhx8+PCBbpeQkIClS5fSsnQDAwMMGTJE4YKgJZ21a9fmSZx30KBBqFixYpZ/mz9/Po1/CuNJfe3aNRqg2traYtWqVZgwYQLU1NSgoaGBKVOmyGkPpKenQ0tLCyNHjpQ7TpMmTWBpaamwaoxbt26BYRhoaGhkyubLKp1Pnz6Nfv360f+vWrUqHBwcYGNjgwULFtD3R9brXdIosUG3TIlu1KhRMDQ0pEG2rq4ugoODweFw6Cojh8OBmZkZbt26hRo1asDLywuampoQi8Xo27dvns+5ePFicLncUlfeIpVKcfbsWYSHh9P3RNZDExsbW9zDK5UYGRmVmImUVCrF2rVrYWpqCh6Ph969e2fpc1lOyWHv3r0wMTGBiooKZsyYoXABMFn/Ul6reP5m0aJFud4bPn78iCpVqkBfX79IxcVYlkWvXr3A5XKVdu9iWRZt27Yt0cJpeeHXr1/w9/cvcuu2kkx6ejr8/Pygo6OD58+fF8k5GzduDH9//yI513+VjIwMdOrUCRwOJ88Z63nz5oEQQj2GC4pUKsWJEyfQqFEjcDgcqkA+btw4hQUbV69ehZGREUxNTYtEr4FlWdy+fRujRo2iStLq6uoIDQ3Fnj17chR7e/ToEUaOHEm9lM3MzDBs2DA5nRGWZXHu3Dl07twZKioq4HA4aNKkCXbv3l2qrL4USVxcHAghufZQb926FYSQLOd46enpqFy5MgwNDaGmpobXr18XakxXr15F48aNqcr+0qVL0bt3b/B4PJiammLt2rW0Cqxt27aoVq2a3P53794Fh8PB3LlzCzUOGbdv36ZK7QYGBoiLiwMgL6Z27949mul++/YtVFRUoKWlhQcPHmDhwoU06Pbx8VHImBRNiQ26V6xYQWvzfXx8cPr0aYwcOTKTiFp4eDimT58OLpcLZ2dnfP/+HbVr10ajRo3y3Z89ZcoUaGlpKeNylMLDhw8xYsQImJubgxCCihUrYvjw4Xjw4AHq1q0LT0/P4h5iqUQqlYLL5RZqJVFRHD16lJZ5tWzZssR7EP7Xefv2LVUNbdiwYa4CZQUlLS0NFhYWaNmyZb72e/ToEcRicY5VHO/fv4e9vT0MDQ2LXDF30qRJcuVlymD69OmlQjgtL/z+/RtNmjSBQCAoseV0RcnAgQPB5XKVIpaVHZMmTYKamlqpalEoTWRkZKBDhw7gcDh51ueRZRWzsh/KKy9fvsTYsWNhYmIi55yzdOlShSZmtm/fDrFYDE9PT8THxyvsuP+GZVncuHEDw4cPh62tLQgh0NDQQMeOHbF//36qFp0Vnz9/xvz58+Hh4UED9K5du+L06dNyZc4fP37E9OnT6fEtLCwwYcKEUmv1pUiSk5PBMEyuz7bnz5/nuCh+5MgREEKgpaWFxo0bK+S7ePnyZRozVa5cGXPmzEHLli2psN3Ro0exbt06EEIyfUe7desGHR0dhdgxvn//nv7W1NTUwDAMGjZsCDc3N+oqlZqaiipVqqB9+/bg8/lQUVHBrVu3AAA9evSg+/P5/BJZxVZig+7+/fuDw+EgODgYqampuYqorVixAgzDQEVFBdHR0ejQoQMqVKiQr3MOGzYsTz0XxcmnT58wb948WqqjoaGBbt264cyZM3Km8oSQTP3u5eQNmf/q7t27i20MN2/eREBAAAgh8PLyKtEWCOX8WahZuHAh1NTUYGBggC1btii9YmbVqlUghOQ5M5KWlgZ3d3dYW1tnW3b75s0bWFtbw9jYON9iLYVFNlFWZoXJsWPHwOFwEB0drbRzFDWpqalo2bIleDwetm3bVtzDKTZk3x9FZV3yisxftlxRXvGkp6ejffv24HK5eZ7P7NmzB1wuF926dcv3Pfj379/YvHkz/P396cSdy+VCW1sbCxcuVGiWlmVZWv4eEhKC379/K+zYf58jLi4O0dHRtPpRS0sLXbp0wcGDB3PM1CcnJ2Pr1q1o2rQpFa9q2rQptm3bJjfWjIwMHDx4EEFBQdTqKyQkpMBCcmUZa2tr9O/fP8dtWJaFjo4ORo8ene02TZo0gZ6eXr6EovPCpUuX0LBhQxBC4ODggAkTJlBBvDp16mSppfDu3TsadxUWWVuxLHAeMWIEKlasmElMTaaer6OjA2dnZwQEBFA9r7+3mTlzZqHHpGhKbNBtZ2cHZ2dnpKSk4OXLl7C2tkb37t3Rt29fDB8+HN7e3nJ9PV5eXliyZAkIIahRowbq1q2LBg0a5OuckZGRcHJyUvSlFJrk5GRs2bIFTZo0oTe/Zs2aYfv27VneqMPCwmBiYvKfLeMpLLISl+IIdF+/fo1OnTqBYRjY2Nhg165dpa7d4b/G7du34enpCUIIwsPDi2x1NT09HVZWVnkW/Bs9ejS4XG62logvX76EpaUlzMzMlCZelh1HjhwBj8cr0EQ5r8iE0+rXr1/mspKy4ITD4WDdunXFPZwi58qVKxAKhejSpUuR3y+Tk5PB4/GwcOHCIj1vWSc9PR1t27YFl8vN82LS8ePHIRAI0KpVqzz/xlmWxbVr1+Q8g83NzSEWi6GqqoqxY8ciKSmpMJeSid+/f6Ndu3YghGDcuHEK/c7KPJCjoqJoCbiOjg66deuGw4cP5zgvlEqlOH36NLp27Qp1dXUQQlC9enXMnz8/U7nz8+fPMXLkSFoJ4OTkhHnz5uHr168Ku5ayRmBgYJ5aURo0aIBGjRpl+/dHjx6Bz+fD0dEROjo6Cm83vHjxIurXrw9CCKpUqYKoqChYW1vTitp/l7WPHDkSIpGo0OXuwB+hWFnQ3K5dO7Asi8uXL2P+/PkYMWIEPDw8sHTpUrx9+xa+vr7077LFgb9febWLLkpKZNAt86ozMzODgYFBlqscsr6a4OBguLq6Ql1dHfv27YOTkxNMTEygrq6OIUOG5Ou8HTp0KDF9AFKpFKdOnUJYWBi9+Xl6emLBggU5ih99/PgRQqEQU6ZMKcLRli2OHTsGQkiR9QQCfwRaoqOjIRKJoKenp/BV9XIUT3JyMmJiYsDj8WBvb4+zZ88W+RjWrFkDQkiu3uyXLl0Cl8vNNov8/PlzVKxYERYWFkoric+O69evQ1VVFY0aNVJ477uMX79+wdnZGZaWlmV2UpiRkYGuXbuCYRgsXbq0uIdTZMTHx8PY2BjVq1fPsURWmXh4eKBdu3bFcu6ySHp6Olq3bg0ej4cdO3bkaZ9Lly5BIpGgQYMGeeq1/vz5M+bMmQMnJycQQmBkZIRGjRrBwMCAaqcow6rww4cP8PT0hEgkUpjys1QqxcWLF6kIFyEEenp66NGjB44dO5brXOL+/fuIiYmBmZkZLQsfOXJkpmqnlJQUbNmyhfo8q6mpoUePHrh69Wp5ciAPjBgxAkZGRrluN3LkSOjp6eX4ng4aNIj2M4eEhChymJQLFy7QissqVaqgWrVq1BYvOjoaP378APBH2FNfXx+dOnUq9DmTkpLA5XJpnDd9+nS5v3fq1Al37tzBpUuX0Lt3bwD/d576W2SbEAIXF5dCj0fRlMigu3fv3lQdMi8voVCIoUOHQk1NjfpQE0Lw5MmTfJ23WbNmufroKZt79+4hOjoapqamIITA0tISo0aNynMv79ixY6GiolJmJ5ZFwfr160EIKRJl8NTUVMydOxc6OjoQi8UYMWIEEhISlH7ecgrHsWPHYGVlBYFAgLFjxxbbZD89PR3W1tZo1qxZttv8/PkT1tbW8PDwyHLy9eTJE5iamqJSpUoKWanODy9evIChoSHc3d2VpjTNsixCQkIgkUgKJDxXmpBKpYiMjAQhBPPmzSvu4SidlJQUeHl5wcjICO/evSu2cQwYMCBbxeFy8kdaWhqCg4PB4/Gwa9euPO1z584daGlpwdvbO8fntqwUOjg4GHw+H3w+H0FBQRg1ahQqV64MQgjatGmjtEqfW7duwdTUFEZGRoV2ZpBKpTh37hz69+9Ps80GBgbo1asXTp48mesC5ocPHzB79mxUq1aNJrF69OiBc+fOZQr2bt++jX79+lH3IG9vb6xZs6ZUO/0UB1u2bAEhBF++fMlxu3379oEQgpcvX2a7zY8fP6Cnpwdvb28QQrBv3z5FD5dy7tw5utAiKzUXi8XQ0dHB3LlzkZqaikWLFoFhGIW02cg0AWQvWaAN/D/o/vz5M6pWrYro6GgqcEgIQUREBPXrtrGxKfRYFE2JDLplAafsJRAI0LBhQxw5cgQXLlzApEmTYGdnB6FQSLdhGAa2tra4c+cOCCFwdXXN93nr1KlTLKvV8fHxmD17NvXT1tLSQs+ePXH+/Pl8rR6mpKTQm245BWf69OlQU1NT6jlYlsW2bdtgZWUFDoeDrl27FuuksZy88enTJ3To0AGEENSuXbtE2J7IFomuXbuW5d979uwJFRWVLHu0Hz58iAoVKsDW1rbIv39fvnyBra0trKyslJJRkjFjxgwQQv4z/c4sy2Lw4MEghGDq1KnFPRylwbIswsPDIRAIclUEVjY7duwAIaRcMKqQpKamIigoCHw+P8/CgE+fPoWhoSFcXFyyFXN6/PgxYmJiYGxsDEIIHB0dMXv2bMTGxsLHxweEENStW1dhto5ZsW/fPkgkEri6uuLNmzcFOkZGRgbOnDmDPn36oEKFCjRD37t3b5w5cybXkvpfv35h06ZNaNiwIbhcLvh8Plq0aIGdO3dmWjhOTEzEsmXLqHiavr4+oqKi8iVOXI48sireM2fO5LhdfHx8nsQ+ZaXYXl5eMDY2pplnZXHmzBnw+Xza8+3n5weGYWBlZYVNmzbB2toa9evXL/R5ZCJu/375+PjA3t4eHTp0QNOmTcEwjNzfW7ZsiadPn9J/51fXqygocUH3v8sEevbsCXd39ywF1L58+ULFBGSvbdu2gRCSowhBdhSlN/OvX7+wceNGNGjQAFwuFwKBAEFBQdi1a1eBs2YyIZnym2LhGDx4MKytrZV2/LNnz6J69eoghKBRo0al2rbovwLLslizZg10dHSgpaWFlStXlphyuoyMDNja2mZZpRMbGwtCsvb0vHfvHgwMDODg4CDnq1oUJCcno0aNGtDT08t3RVJ+kAmnDR06VGnnKImwLIuRI0dSYbqS8l1VJDLru1WrVhX3UKjq7n9lYUcZpKamIjAwEAKBIM9Zu7dv38LCwgI2NjaZFu6SkpKwevVqGlRraGggIiICV69exYMHD6jLhLOzMw4fPqy03wjLspg+fToYhkFQUFC+s8MZGRk4deoUIiIiqH2usbEx+vXrh3PnzuUqVpaRkYHjx4+jU6dOVGjKy8sLixcvzlQRybIszp8/jy5dukAikYDD4aBRo0bYtWtXebubAkhNTQWfz8+T/oOJiUmuLbIZGRlwdnaGq6srVFVV0aNHD0UNNVs6deoES0tL1K1bF4T8sRpzc3MDIYT2fcuUxgvK337bslLx3F6qqqrYtm0bhg0bRv+Pz+crfSEiv5S4oFsWjBBCMHz4cOrNJqNTp05yKpYyf0PZPjLD97yWJf2NlZWVUidnGRkZOHbsGDp27EhvfjVr1sSSJUsKXQ7OsixcXV3RsGFDBY32v0toaCi8vb0VftwHDx6gefPmIISgatWqOHHihMLPUY7iefz4MX3AtG/fXqlZ2YKyceNGEELkRNI+ffoEAwMDNGzYMNOE8tatW9DT04OTk1ORe75nZGQgMDAQKioq2Yq6KYIXL15AR0enTAqn5RWZBdvQoUPLVOB95swZ8Hg89O3bt7iHQrGwsEC/fv2KexilkpSUFDRr1gwCgQAHDhzI0z5fvnxB5cqVYWpqilevXgH4f9DYtWtXOsfy8/PDpk2bkJycjPfv36N79+7gcrmoWLEi1q9fr1SF7dTUVISFhYEQgmHDhuX5XOnp6Th+/Dh69OgBfX19qnE0cOBAXLhwIU/HuXPnDoYMGUKz+5UqVcLYsWOzLJ3/+PEjZsyYATs7OxDyR0hu/PjxBc7Il5M9Dg4OeapGDQoKgq+vb67bnTp1CoQQdO7cGYQQnDp1SgGjzB6Zj/jr169x+vRp1KlThwbcsvZedXV13Lt3r8DnSEhIoC3GKioqmDx5Mv1u/ru1mM/nIzg4GJ8/f4aLiwv9vciC9b8Ft0sCJSrovnbtGn0zxWIxtLS04Orqiq5du8LAwAAikQhisRhRUVH49esX4uPj4e/vD09PT/oByd7ogmQPdXV1MXHiRIVf161btxAVFUXLgaytrTFu3Dg8e/ZMYeeQ2ZYcOXJEYcf8r+Lv74/g4GCFHS8+Ph49e/akD/qNGzeWW2mUAlJTUzF+/HgIhUJYWFjg8OHDxT2kbMnIyIC9vT1ddGNZFoGBgdDR0cH79+/lto2Li4O2tjaqVq2aa2+ZomFZFhEREeByuXmeXBeEX79+wcXFpUwLp+WV2bNngxCCvn37lonA++XLl9DT04Ovr2+Jyr6FhobCzc2tuIdR6khJSUHjxo0hFApx8ODBPO2TkJAANzc36Onp4dGjR3j//j2mTp1Ke0ErVqyIMWPGUFHIhIQEDB8+HCoqKtDW1sasWbOUrsPx5csX1K5dGwKBIE+OAmlpaThy5AjCw8Ohq6tLg9+oqChcvnw5T7/d9+/fY8aMGdR2SUdHBxEREbh48WKm/TMyMnDo0CG0bNkSfD4fAoEAbdu2xfHjx8vnJ0qkTZs2qFWrVq7bTZ48GWpqann6LIKCglChQgV4eXmhUqVKStUj+vbtG7hcrpxY56lTp1CrVi3a7iBr+e3Zs2eBved79uxJ48FatWohKSkJT548wYULF9CgQQPs3r0baWlpaNKkCRITE/Hq1Svo6OjQfdq0aQNNTU1MnjxZUZeuEEpU0N29e3f6htWoUYMq2PH5fDg5OYFhGLp6KRQK4erqitDQUNSqVUuuv9vU1LRA5xcIBFiwYIFCruXdu3eYPn06VcbU1dVF7969cenSJaVMfFq0aAF7e/syMakqbhwdHakqYmFISkrC2LFjIZFIoKmpiRkzZijFi7McxXPu3DlUrlwZXC4XQ4cOLRJRvcIiE2m5ePEiVq9eDUIIdu7cKbfNlStXoKmpCQ8Pj2z7H5XJ5MmTQQjB8uXLlXYOlmXRrl07qKiolHnhtLyyePFiEELQvXv3Uj2h/vXrF1xdXWFubp6ji0dxsHjxYnC53HJxqXzw+/dvNGrUCCKRKM+LmsnJyahTpw40NDQwc+ZMNGnSBFwuFyKRCO3bt5fzh05JScGcOXOgq6sLsViMmJiYIik3ffDgAaysrKCnp4dz585lu11qaioOHjyIsLAwKlJmZWWF6OhoXLt2LU/zuaSkJKxbtw4BAQHgcDgQCoUIDg7G3r17s1Rxf/HiBUaNGkW1kxwdHTF37twiX4D9rzJ+/Hhoa2vn+tkeP34chBDcv38/12M+e/YMAoEAkZGREAqFiIqKUtRws8THxwfNmzeX+z+WZXHy5EnazsHlcqGqqgoVFZUC2e69fv2aCqIRQlCtWjWcPHkSLMvKCastWrQIenp6tNdc1kry8OFDaGtrIygoSFGXrRBKVNAtU1GUvZo3b47Q0FA5MYHbt2+jc+fOGDp0KLhcLuzs7PDq1SvqeUgIgYeHR77P/fv3bxBCCuVxmpSUhLVr11JxAaFQiFatWmHfvn1KXZF/9uzZf84mRpno6elh/PjxBd4/PT0dy5Ytg6GhIQQCAQYNGvSfz7aVFr5//05XWD08PBSixFlUSKVSODg4wMfHB2pqaujcubPc3y9cuAB1dXV4eXkVS5/TunXrCqy3kR9mzpwJQojC7HjKCqtXrwaHw0HHjh2VZs2mTFiWRdu2baGiolIif5e3b98ukvLOssLv37/RoEEDiESiPPeApqWloU6dOuDxeNRT293dHYsXL5ZbRJRKpdi4cSMsLCzA4XDQrVu3IhO5O3LkCDQ0NODg4JCl/WJKSgr279+PTp060WuwtrbGsGHDcOPGjTwF2hkZGThy5AhCQ0NplWetWrWwfPnyLBdTU1JSsHXrVvj7+4NhGKipqaF79+64cuVKeaKmiNm9ezcIIZkq0P7N9+/f81UeHRMTA5FIRNW8lSkKOHnyZEgkkiyrRWT6N7J4zNDQEDweDwYGBli2bFm+nj1NmjSRUyaX9ZA7OTkhKiqK2uz+/XeRSIQTJ07g9+/f4PF4MDQ0LFHf8RIVdFeqVImWJaxYsQIvX76Ep6cnDVh9fHxgYGBAS6gdHR1hbm4OOzs7apNCCEG9evXyfe6PHz+CEIK9e/fma7/09HQcPnwY7du3h4qKCgj5o2q8YsWKIssk9e/fHzo6OkhOTi6S85Vl0tPTwTBMgTJxLMti//791HqkXbt2Re55XE7BkKnJGxoaQlVVFfPnzy+VfcCybLehoaGc9dzZs2ehqqqKWrVqITExscjHdfToUfB4PHTt2lWpD8ATJ06Aw+HkKkDzX2Xz5s3gcrlo3bp1iSrNzgtTp04t0WJlUqkU6urqmDBhQnEPpcSTnJwMf39/iMViHD9+PNftf/z4gUWLFtHyUXV1dQwYMCDLSpajR4/C1dWVJm7ykilUFAsWLACXy0WjRo3k7r+/f//G3r17ERoaCnV1dRBCYGdnh5EjR+L27dt5uieyLIsbN25g4MCBVFDN1tYWEyZMyHaecefOHTo/lGkIrV69urwaoxh58uRJnsXGbGxs8lx1mZiYCENDQ7Ru3RpVq1aFo6NjnvzqC8KtW7dyvYbIyEhIJBKqfi/7Dtrb22P//v15+s5v2rQJhBBqiZfbi2EY2Nvbw8XFhbq6EEJw+vRpRV5+oShRQbeFhQUIIZgzZw4SEhIyiagBwKtXr6jhuZeXFx4+fAgtLS25JvumTZvm+9yPHz/O8yo1y7K4fv06BgwYQG9+dnZ2mDhxYo6+esogISEBampqGDZsWJGet6wiU6HNr+fh1atXUbt2bRBC4Ovrm619Uzklj5cvX6Jx48YghCAwMLBUi8dMnDgRhBC53tKTJ09CRUUFdevWLZbJ1vXr16GqqoqGDRsqNdCTCacFBASUygWTomLXrl3g8/lo3rx5sfnL55eDBw+CYRgMHz68uIeSI/Xr1y8XM82FX79+wc/PDyoqKjh58mS220mlUpw4cQKhoaFy7YODBg3KMpiIi4uDv78/CPmjzp1TWbeiSU9Pp4mf/v37IyMjA8nJydi1axdCQkJoW2SVKlUwZswY3L17N8/HfvPmDaZMmYIqVaqAEAI9PT307dsXV69ezTJwSUxMxPLly6kosZ6eHgYPHlzualNCyMjIgFgsxqxZs3Ldtn379qhevXqejy1rK1u1ahW4XG6hKjZzgmVZGBsbo3///tlu8+nTJ6ipqaFfv344evQoatSoQRfMZJUZuWXjU1JSoK2tjYiICGzevJmWrv/7JZFIYGFhgblz52L16tUYM2YMatSoAT8/P9ja2qJjx46KfgsKTIkKuo2MjGBoaIjq1atDS0sL7u7uGD16NKysrFChQgUYGxtj4cKF8Pb2xrZt26CpqQkbGxuMGDFCrgShILL5MhG369evZ7vN69evMXnyZDg4OICQP76F/fr1y3PvjTKYM2cOeDxeuT+ogrhx4wYIIbhy5Uqetn/+/Dnatm0LQv74FsbGxpaoUpZysic9PR2zZs2CRCKBsbFxgRwPShLXr18Hn89HYGAgCCE4e/Ysjhw5ApFIhICAgGKphHnx4gUMDQ3h5uaW756u/CATTrOwsChv5cgDsbGxEAqFaNCgQYmvkHr06BE0NDTQpEmTEt+PPm7cOGhqapb4cRYXP3/+RN26daGiopJt9unVq1cYO3YszM3NQQiBjY0NfH19QQjBihUrMm3/7NkzhISE0OTHnj17ivQZ/P37d/j7+4PH42HevHnYvn07WrduTcu+nZycMH78+HwFvYmJiVi9ejXq1q0LhmEgEonQtm1bHDhwIMuFS5ZlceHCBYSFhVGrr4YNG2Lnzp1Ky3aWU3CqVq2Krl275rrdnDlzIBQK8/wZSqVSuLm5oVq1aoiJiYFAICiUinhOhIeHw8bGJsdtJk6cCD6fj2fPnoFlWRw+fJguBskqg9u0aYPnz59ne4wmTZpAJBLh1q1bAP48Dw4cOIDNmzejbt262LNnj9z2jRo1wqxZs0DIHxerdu3a5Um4rqgoMUH3x48fwefzMXLkSPTs2ZOqkHM4HFSoUAEqKio0sHZ2dsbq1avx4sULqKmpoVq1anIm6QXpqTpx4gQIIZnsFBISErBq1Sr4+vqCYRiIxWKEhIQgNja22PviMjIyYGlpiXbt2hXrOMoShw4dAiF/7BBy4suXLxgwYAD4fD6MjIywYsWKYv8+lJN34uLiULVqVTAMg969e8uVApZGfv/+jcqVK8PZ2RnJyclwdnaGk5MThEIhGjduXCwCfl+/foWdnR0sLS2VarPGsixt75E9mMvJnePHj0NFRQW+vr5KXRApDAkJCbCzs4OtrW2J81vNCtk8Ij+ZzP8KP3/+RJ06dSCRSHD27Fm5v/3+/RubN2+mPccSiQRhYWE4d+4cbSuYOXOm3D6fPn1C3759wefzUaFCBSxfvrzIn8FPnjyBjY0NJBIJatWqRQMJV1dXTJo0CY8ePcrzsdLT0xEbG4u2bdtCLBaDYRj4+vpi1apV2T6fPn36hJkzZ8Le3p6qto8bNy7X+Us5xUvHjh3zlMG+cOECCCGIi4vL87HPnTsHQgiWLl0KW1tb1KhRQymVX7Le9CdPnmS7za9fv1ChQgW0bduW/h/Lsjh06BDc3d1BCIFAIACXy0X//v2zFPOTJRYrVKiQyZXqb0E14M8CmJWVFYRCIUJCQiCVStG1a9cCi2srgxITdMt6ETt06ED7olu2bCknhhMXF4eGDRtSafoePXqgatWqAIB69erRfoGCrHLKvkCfP39GWloaDhw4gDZt2kAkEoFhGNSrVw+rV68uUZPzPXv2gBCiVK/b/xqy8pzsyi5///6NadOmQUNDA6qqqhg/fnx5f1QpIikpCQMHDgSHw4GjoyMuXbpU3ENSCP3794dQKKQPoOjoaBBC4O3tXSyZjuTkZNSsWRO6urp4/PixUs8lW9XesmWLUs9TFjl79izU1NSKTVwvJ6RSKZo2bUqVaEsDSUlJmex0yvnzvtSqVQuqqqr4559/APyZfMfFxSEyMpIKinl7e2PVqlV0EWjZsmUghGDEiBH0WD9//sT48eOhpqYGdXV1TJo0qcjdJRISEjBixAjw+Xya8HFzc8PUqVOz9MHODpZlcfXqVfTt25f6Czs4OGDKlCnZBs4ZGRk4fPgwgoODqdVXmzZtcOzYsfIKi1LCtGnToKqqmuvnlZycDB6Ph8WLF+fr+G3btoWhoSGOHj0KhmEwd+7cwgw3SxITE8Hn8zFv3rwct1u5cmWW1aMsyyI2NhZVq1alaucSiQRTp06VSxJs3ryZtmaoqalhyJAhNDP+d9B99epVeHt7g2EYtGjRgs7hAwMDwePxikXLJitKTNC9cOFCMAwDLpeLVatW5SqitnLlSnC5XOjp6VEJeS6Xi4ULFxbo/LJgKzIyEnp6evRDnjp1aont8axduza8vLyKexhliilTpkBLSyvT/0ulUqxfvx5mZmbgcrmIiIhQavauHMVz4MABmJmZQSQSYcqUKaVOSCo7ZNYish6xHTt2gMvlQlNTs1jKqjIyMtCiRQuIxWKlL2qcOHECXC5X6RYpZZnLly9DU1MTbm5uJao0f8SIEWAYBrGxscU9lHxRtWrVEtVDWNwkJibC29sbampqOH/+PD5//ow5c+ZQL2kjIyPExMRkygpv2bKFViKxLIu0tDQsWbKEuoIMGDCgSG2ufvz4gXXr1qFZs2a0ElNdXR1jx47Nt2Dqy5cvMXHiRKpFZGhoiIEDB+L69evZJo1evnyJ0aNHU6uvKlWqYM6cOeVWX6WQgwcPghCSp++Ni4sLwsLC8nX8V69eQSwWIzo6Gr1794aKiopSRH3r1auHBg0a5LhNRkYGqlSpgtq1a2f53WZZFgcOHICLiwutVtbX18f69eshlUrx8uVLunAwcOBAaGpqgmEYeHl50Sy57HckFAphZWWF2rVrY9SoUfjx4wdUVFTAMEy+Fy6URYkJumUe3bJscm4iasD/V1C2b9+Odu3aQVdXN9/lRS9evMCECRPoKqORkREGDRqUZ+uG4uL69ev02stRHP3794ednZ3c/x0/fpyqoQYFBZWarEs5f4iPj0fr1q1BCIG/v3++MhElnW/fvsHExAR169aFVCql6tTt2rWj1Ts5iRUpGpZlERkZCQ6Hg/379yv1XC9fvoSOjg78/f3LhdMKyfXr16GjowNnZ2d8+vSpuIeD7du3gxCCyZMnF/dQ8k2fPn1gZWVV3MMoESQkJMDLywvq6uqYNWsWzc7y+Xy0bNky2za9gwcPgsfjoUOHDsjIyMDOnTthY2MDhmEQGhpaZK4g3759w5o1a9C4cWPqA1yhQgUQQhAaGpqvhdvv379j+fLltFJTRUUF7du3x+HDh7Odt6akpGDbtm0ICAgAwzBQVVVFeHg4Ll26VKLnp+XkzOvXr0EIydMzMjw8HI6Ojvk+x+jRoyEQCHDr1i2YmZnB399f4d+ZmTNnQigU5lppIltkyOl6Ze4/Ms0sQggqVaqE48ePo1GjRqhSpQpYlsWvX7+wcuVK6Ovr03uJo6MjNm/eDC0tLTl9q3nz5oHH4yEgIEAudixOSkzQ7eDggFq1aiE9PZ0KQGzZsgULFizAokWLsHfvXrx9+xbe3t5y+8lscJydnfNsgv79+3csW7ZM7ubn7OwMTU3NUjN569SpE8zMzMr7iBVMSEgI6tSpA+CP72qDBg1ACEGNGjWKVA21nMIjlUqxdOlSaGhoQE9PDxs2bChzE5WQkBBoaGjg9evXWLduHfVhzsjIAMuycHNzg7e3d5Fd95QpU2g/mTL59esXXF1dy4XTFMjdu3dhYGAAe3v7XD1klcmtW7egoqKCNm3alMrfq6xV7sOHD8U9lGLlx48fcHV1hVAopNWDjo6OmD17do4LO2fPnoVYLEbz5s1x8uRJeHp6ghCC+vXr48aNG0of95cvX7By5Uo0aNAAPB4PDMPAx8cHU6dOhZ+fHzgcDubOnZun72Zqair27duHVq1aQSgUgsPhwN/fH+vWrctRR+Hu3bsYMGAAtVny8vKSK7svp3TDsizU1dUxZcqUXLddtmwZOBxOvtsYf/36BRMTEwQFBVGtotWrVxdwxFnz4MEDEEJw4MCBHLdjWRZ169aFvb19rjELy7LYu3cvbGxsaPAtc7basWNHpu1lJeZpaWnw9PREmzZt4Ovri4MHD8Lc3BytWrXCnDlzwOfzS8TzpEQE3TLPt0mTJsHExEROFO3vF5fLRUhICPr16wd7e3uoq6vT1cfcbJ5SU1OxZ88eBAcH05tfQEAA1q9fj6SkJERFRcHa2roIr7rgxMfHQyAQYPr06cU9lDKHr68vmjVrhi5duoBhGFSqVAk7duwoET/WcvLOvXv3ULNmTRBCEBYWViZL8GQelhs3bsTKlSvBMAy6du0qt3B44MABEEJw7NgxpY9nw4YNIIRg5MiRSj2PTDhNLBbj5s2bSj3Xf41Hjx7BxMQElSpVwqtXr4r8/J8/f4a5uTlcXFyKvE9XUbx584Yq5/4X+fnzJxYtWgQ1NTVq59OrV69sLa7+Ji4uDurq6qhevToaNmwIQgiqVauWJy/vwvDp0ycsW7YMAQEB4HK5YBgGtWvXxoIFC/Du3Tu8fPkSTk5OUFNTw8GDB3M8FsuyuHTpEiIjI2nQ7OzsjOnTp+Pdu3fZ7peUlIQVK1bQRQZdXV0MGjSoSH3Gyyk6atSogdDQ0Fy3kznqyLQQ8sPGjRtptVvHjh2hqamJ+Pj4ggw3S1iWhYWFBSIiInLdNi4uDoQQLFu2LM/H3r17Nw24ZULW/74XyILu9+/fQyQS4dWrV3jw4AEkEgl0dXXx9OlTrFixAoQQrFmzpkDXqUhKRNA9evRoaGtro2fPnnRVw9fXF8uXL0dKSgqkUimOHz8OMzMzaGlpgc/nY8uWLUhNTYWDgwPU1dWhoaGRKUvNsiwuXryIiIgIevNzcXHBzJkzM63kd+/eHdWqVSvKyy4wo0ePhuR/7J11XBTb+8fPzDbL0t0iKSgKKIggiqLYjYLYYndgdyvqtePa3XHt7s7LtTuwMVAkd+fz+8Pfzte91C5soHffr9f+4TJz5uwiM+d5zvN8PmIxPn36pOup/FakpqbC3NwcHA4HFhYWmDdv3m/T9/tfISMjgxW48fDwKJKTwa/Ay5cvYWJiglatWmHx4sUghKBbt265hFkYhkGlSpUQEhKi0cTRkSNHwOPx0KFDB40nqGbPng1CCDZu3KjR6/xXefLkCVxcXODs7IzHjx9r7bo5OTmIiIiAhYUFnj17prXragInJycMHDhQ19PQGgzD4Ny5c+jUqRNrlcXlcjFx4kSlLenu3r0LMzMzWFhYgKIouLq6YtOmTRoTB3v79i0WLVqEGjVqgMPhgKZpREREYNGiRQqByYULF2BlZYVSpUoVqEr/+PFjjBs3Du7u7mwZ+uDBg5GUlJTvOfI1aqdOnWBoaAiKohAVFYVt27bprb5+c+Lj45Uqec7OzoZQKFTK1/vfMAyDypUro1y5cnj37h2srKzQrFmzokw3X3r16gUXFxelnvutW7eGjY2NSrv2MpkM8+bNAyEEFStWBJfLxZAhQ9gWE3nQnZ6eDh8fH6xevRru7u7gcrk4d+4cgB9l8BwOhy1R1yUlIuju1q0be6NNTEyETCbD6NGjsX37dvaYpKQk9O3bF9+/f0dcXBy7w+Pn5wdPT094enqyxz569Ahjx46Fm5sbCCGwt7dHQkJCLrn5n2nVqhUiIiI0+jnVQUZGBiwtLdGzZ09dT+W3ISsrC/PmzYOFhQUIIahWrVqJUqnXoxzHjx+Hu7s7az2oC5ssbSCTyVCjRg3Y29tjypQpIISgT58++T5M5KVlchFKdXPjxg1IJBJERUVpPEl1/PhxvXCaFnjx4gXc3d1hb2+vNQ2Lvn37gsvl5uvf/CvRqlUrBAcH63oaGuf169eYNm0aPD09QQiBg4MD7OzsYGJiguvXrys9zt9//w2JRAKKomBubo558+ZpJOh8/fo15s+fj2rVqoGmaXA4HERGRmLJkiV5lryvX78eAoEAoaGhef7848ePWLx4MVtVZWhoiHbt2uHo0aMFtip++PABs2bNYvtXnZ2dMW7cOJ1Ul+jRDXPmzIFAIFCqRTQkJAQxMTFFus7ly5dBCMHixYuxZcuWfMu0i4q8X1uZioynT5+Cz+dj3LhxKl0jKysLpqam6NOnD4YOHQpjY2NQFIXIyEgIhUJwuVw0a9aMFTg0MTGBgYEBDh8+DOBHBSuHwwEhJJddobYpEUG33O5r4cKFAFCocjnDMGjTpg04HA769OkDb29vGBsbY8GCBQgJCWFvfu3bt8exY8eU6tOuU6cOGjdurLkPqSZWrFgBQohK/o968oZhGGzbtg1ubm6gKApt27YFIQQrVqzQ9dT0qEBKSgo6dOjAWs7cvn1b11PSKH/88QdrmUgIwcCBAwvM3jIMg+DgYAQFBak9y/vs2TPY2toiICBA4/2Gz549g4WFBWrWrKnXstACr1+/RpkyZWBtbV1gwlodyN1D5s+fr9HraIt58+aBx+Mpvcv7K5GdnY2dO3eiQYMG4HA4EAgEiI2NxY4dO+Dv7w9zc3Ole68zMjIwevRo0DQNiqLQv39/tVv7JCcnY+7cuQgLCwNFUeByuYiKisKyZcvybTuSyWQYOXIkCCFo166dgoVoZmYmduzYgSZNmrDqyXXq1MH69esL3MGTyWQ4dOgQWrRowQpARUdH4/Dhw3qrr/8gx44dAyFEqaRm37594ebmVuRrtW3bFhYWFvj06RMaN24Ma2trtVXKpqenQygUIjExUanjBw0aBLFYrLLmRXBwMCQSCb5//460tDT8+eefMDU1ZatUrK2t0bJlSxgYGKBSpUqsaJu871z+atOmjcqfUZ3oPOhmGAa2traIiooCwzA4cuQIrKys4ODgABMTE1haWsLHxwe9evWCj48Pe96ePXsgEAjQvXt3GBsbszX/derUwYYNG1TuB6tSpQratWun5k+nXhiGQbly5VC/fn1dT+WX5+zZs6hcuTIIIYiKikJSUhLbi1dYz5aekgHDMFi7di0sLCxgbGyMpUuX/vaLl9u3b0MgELDJxWHDhikVSB86dEjt/7c/fvwILy8vlCpVSuOiUenp6fD394eLi8tv2Z9fUnn//j3Kly8Pc3NzXLt2TSPXuHjxIvh8Pjp37qzz0j91IXcXKUofZknl1q1bGDBgACuKVrFiRSxcuBCfPn1CSkoKypcvDwsLC/z999+FjiWVSrFq1SrY29uzYraXLl1S21xfvHiB2bNns/dJHo+HunXrYuXKlYUKL37//h3NmzcHRVGYOnUqGIYBwzA4e/YsunXrBlNTUxBC4O/vj9mzZxd673v+/DnGjh0LZ2dn1od71qxZ+PDhg9o+r55fj3fv3im96yzXSymqaOirV68gFosxYMAAvHr1CsbGxujQoUORxsqLunXrKl0p/OnTJ5iamqJ79+4qXSMyMhKEkDyD+5/9uj09PVG1alXExMQgJSUF7dq1YyupCSEIDAxU6brqRudB94ULF9iyJHkvUEEvc3NzeHp6wsHBAYMHD4aBgQErLe/k5FTkkiRfX1/07t1bzZ9OvRw/fhyEEI2LivzO3Lt3D02aNAEhBBUqVFAQmLpy5QoIISqVxenRDY8ePWJvwi1btlSrOEhJJSsrC+XLl2cXvWPGjFE6SGEYBiEhIahYsaJaApuMjAyEhobC3Nxc41U3DMMgLi5OL5ymIz59+oSKFSvC2NgYFy5cUOvYr169gq2tLSpXrqywm/irk5OTA0NDQ6XUiUsyX758weLFi1GpUiVW3Kt///4KfcofPnyAn58fLC0tC62IYBgG+/btQ9myZdn1nImJSYG90sry9OlTJCYmskJkfD4fDRo0wJo1a/D582elxnj16hUCAwNhYGCAnTt34sGDBxg9ejRcXV1BCIGjoyOGDRtWaDVVVlYWtm7ditq1a4OiKIjFYnTu3BkXLlz4bRJLeoqPhYWFUqXW9+/fL3aL2KRJk8DlcnH//n1WWExefl1c5s+fDx6Pp3RbZmJiIjgcDu7evav0NSIiIkAIAU3T2LVrl8LPfg665Un5VatWsfeCP//8k92ctbOzU/qamkDnQXfPnj3ZL+PnF0VRsLKyAp/Pz/UzHo8HoVDIeie7urrin3/+KZYBupOTE0aOHKnmT6deGjZsWCKEAH5F3r17hx49eoDD4cDJyQlr167NtSu6Z88eEEIKVBjVo1uys7MxZcoUCIVCODs7Y9++fbqektYYOnQoaJoGIQQTJ05U+fyjR48qZe9RGFKpFM2aNYNIJFJ7EJYX8nJ6vXCa7khNTUVoaCgMDQ1x6tQptYyZmZmJ4OBg2NnZ6dSiTFPUqFEDDRo00PU0VEYmk+H48eOIi4uDUCgETdOoV68etm/fnmtT4/379yhbtiysrKwKDZwvXbqE8PBwEEIQFhaGoKAgGBoa4vLly0We6+PHjzFt2jRUrFgRhBAIBAI0btwY69evV1mX5dq1a7Czs4OdnR2GDBmCoKAgEEJgZGSEjh074sSJE4VWUt2+fRsDBgxg9WEqV66MZcuWqb1kXs/vQbVq1dCiRYtCj5PJZDA2Ni7Sc19ORkYGXFxcUL9+fdbCy8XFRS1tYY8fP1bJsSEzMxMuLi4qtfQ2aNCAjQ1pmsbo0aPx7t07AIpBNwA8fPgQbdq0YTcnZDIZ2+8tFAp1GkPpPOiWB87yl52dHXr37s32QiUlJaFTp04YN24cbG1tFQLvmzdvQiwWIzY2FsAPZTxbW9si9VEZGxtj+vTpav1s6uThw4egKArLli3T9VR+KdLS0jBhwgQYGhqyv+P8BLaWLVsGiqL0iuUllAsXLqBs2bKgaRoDBw5U2bfyV+b06dNseVRR71MMwyAsLAwBAQFFfugwDIPevXuDpukCLRrVhVw4bdCgQRq/lp6CSUtLQ0REBEQiUbEt6BiGQceOHSEQCNRaVlySGD16NMzNzX+ZJPnz588xfvx41qLH3d0dU6ZMyTcJ/e7dO/j4+MDa2rrAnd8HDx6gefPmIITA19cXf/31F5o1awaBQIDjx4+rPM+HDx9i8uTJ8Pf3ByEEIpEIzZo1w8aNG4sc3G7cuBF8Ph8mJibgcDjgcrmoX78+Nm/eXOh68tu3b1i+fDlbym5hYYEBAwb89toieopPr1694O3trdSxNWrUQKNGjYp1va1bt4IQgoMHD+Lx48cQiUTo27dvscaU4+Xlhc6dOyt9vNzOTNkWnN69e7PxX926dSEUCsHj8dC8eXOIxWLweDwkJCSwFZAGBgagKAr//PMP214nf6krcVwUdBp0P3/+nN25IYSgZ8+eBQqoff78GS4uLuzxFStWhImJCSZMmADgx82Yy+Wq7F/NMAwoisKSJUvU+wHVSO/evWFhYfFbCrNoAqlUimXLlsHOzg48Hg/9+/cvtBd04sSJsLCw0NIM9ShLamoqevbsCYqiEBAQoLHe0pLKly9fYGRkBEJIkWxDfkbeorJ79+4inT99+nRWCVXTPH/+HBYWFqhRo4ZeOK2EkJ6ejjp16kAgEBSrYkJuAbN69Wo1zq5kIV/oqVJCqW0yMjKwceNGREZGsmXQHTt2xJkzZwpMFrx9+xZlypSBjY1Nvp/vzZs36N69O7hcLhwdHbFq1SpkZ2ejQ4cO4HA4KiXt7t27h4kTJ8LPz49dUEdHR2PLli1FTr7KZDKcPHkSgYGB7JoyMDAQ8+bNy1Op/GfkXtzx8fGs1Vft2rWxZcuW36pNQo9mWbx4MTgcjlL/Z4YOHVrs0miGYVC1alV4e3sjOzsbs2bNAkVROH/+fLHGBYABAwbAzs5O6SSjTCaDv78/goODlTpHrsIu11NISUnBzJkz2RZj+S64gYEBPDw8YG9vj8qVK+Off/5Bw4YNFYLuoirBqwOdBt3Dhw9nv4T27dsjLCwM9+7dA8Mw+Pr1K9LT0/H8+XMFL7vU1FR4eHiw53E4HFb1HAC6du0Kc3NzlUqLvn79WqLLFz9//gyxWFziy99LAvKeMbkVR6tWrfDkyROlzu3duzd8fX01PEM9qrBjxw7Y2dlBLBZj9uzZ/7ngSyaTwcvLC4QQlW028qNatWqoUKGCyjtw8sy0Nu5DeuG0kktmZiYaN24MHo+nYOupLPLqhf79+2tgdiWH1NRU0DSN5cuX63oqCjAMg2vXrqFnz54wMTFhXR9WrFihVKnp69ev4eXlBVtb2zyVl79+/YrRo0dDLBbD1NQUM2bMQEZGBhiGQf/+/UFRFNatW1fodW7fvo1x48bB19eXdaSJiYnB9u3bVRbK/Zm7d+9i+PDhcHJyYteRYWFhSiVHPnz4gNmzZ7NzcnJywtixY395X3k9uuHs2bMghCglPrh9+3a1tD9ev34dFEVh7ty5kEqlqFSpEry9vYudLJK3rynrXAD8bxNg69atSh0v17MhhGDz5s3s+zKZDK1bt2a1Jp48eYKePXuiXbt2WLVqFbu5K68WLI4SfHHRWdCdmZkJKysrtjHeyMgIpUqVgr29PVt7L/+ZmZkZ/v77b/Y/hfyGJ389ePCAHffly5cQCAQYO3as0nNJTk4u0arVM2fOBI/H+y373tTJ1atXUb16dRBCEB4ernKvWIsWLVCzZk0NzU6PKrx8+RKNGjUCIQT169f/T/qXymQytlRKnc4Kp06dAiEEO3fuVPqco0ePgsfjoX379hovl5VbQopEIpUe4Hq0R3Z2Nlq1agUOh4P169crfd7Tp09hbm7+n7F98/PzQ8eOHXU9DQA/BIbmzJnD7hbb2tpi6NChKgkhvnr1Cp6enrC3t1dYdwE/xMPmzZsHS0tLCAQCJCQkKNgSjR8/HoQQLFiwIM+xGYZBUlISRo8eDW9vbxBCIJFI0Lp1a+zatatYVX7v3r3DnDlz2F1tIyMjWFtbg8/nF/r/VyaT4fDhw2jZsiX4fD54PB5atGiBgwcPKmVHq0dPfnz+/BmEEGzYsKHQY+XuOv8WESsKnTt3hqmpKVJSUvDPP/+Ax+Nh1KhRxRozMzMThoaGmDRpkkrn1a1bF25ubkqJYMt1FuT6DT+vYX7u6+7atSuePn2KqKgoSCQS9hy584AuK1p1FnTv27eP/SLc3d3ZDASPx0PlypXh5eXFZlN5PB4IIXBxcYGPjw+MjY1Zo3OapnNlaAYMGACJRKL0Dsnt27dBCMHZs2c18VGLRU5ODpydnXXuLVeSefr0KWJjY0EIgbe3N/bs2VOkwCAsLAytW7fWwAz1KItUKsXcuXNhaGgIW1tbbN269ZfpiVQnUqkU0dHRrMq+ur+DiIgIlCtXTimLtZs3b8LIyAi1a9fWit7BnDlzlF6I6NEdUqkU7dq1A0VRSu3mpqWlwc/PD6VKlfrPVC90794dnp6eOru+VCrFgQMH0KJFCzZgbNasGfbu3aty0iM5ORnu7u5wcHDAw4cP2fdlMhk2bdqE0qVLg6ZpdOjQAS9evFA4V/43/e8FOcMwuHnzJkaMGAFPT08QQmBsbIy2bdtiz549xdp9+/79OzZu3Ii6deuCw+GAx+OhcePGmDlzJpycnGBtbY2LFy/me/6LFy8wbtw4tqWxTJkymDlzZqGl53r0qIK9vT2GDx9e6HEMw8DGxkapYwvj7du3MDIyQq9evQAAY8eOBZfLVWrHvSAaN26MKlWqqHTOP//8A5qmMXfu3EKPjYuLyyWsHRUVhT179qBt27b4559/8PDhQzRo0IC1/ZMfV7t2bVYXTJcK5joLuhctWqSQsQgODsaZM2cwatQohZK1pKQk9O7dG1u3boW9vT0MDAywfPlyuLm5secnJycrjP3+/XsYGhpi8ODBSs1FbltWmN2FLpCXlFy9elXXUylxfPz4EQMHDgSfz4eNjQ2WLl1arN0TDw8PDBw4UI0z1KMKN2/eZK1punfvji9fvuh6SjohJyeHTSIZGRmxCp3q5MyZMyCkcI/Q58+fw87ODv7+/mpROS2MEydOgMPh6P8OfxFkMhm6detW4A4m8GPB2KJFC4jFYgW7qd8dub+utj2ZHz58iOHDh7M+2L6+vpg9e3aRA8aXL1/Czc0Njo6OePToEfv+sWPHEBAQAEIIGjRokOcaavXq1SCEYNCgQazn9bVr1zB06FB2HWdqaooOHTpg//79RbZ9BX78fzx27Bjat2/P7nBVrlwZCxcuREpKCvbu3QtDQ0P4+fnlSgwAP3brt23bhjp16rA97p06dcL58+f/k8lfPZqndu3aaNiwoVLHNmjQAJGRkWq57owZM8DhcHDr1i1kZWXB19cXgYGBxVpDL126FDRNq+wn3qlTJ1hYWBS65ktISMgVdP/7lZfjVUBAAG7cuMH+28nJqcifsbjoLOieNWsW25Ndu3ZtpKen49mzZwUKqW3duhWmpqZwcnJS6Ov+d5kTAIwaNQpCoVCp/oeDBw+CEFIiS1jDwsIQFham62mUKDIzM5GYmAhTU1OIxWKMGzdOLUrWRkZGJVrB/nfl+/fvGDx4MDgcDnx8fHDu3DldT0lnZGdno2XLlmyGds+ePRq7VmRkJHx9ffPd7f748SO8vb1RqlQprfigP3/+HJaWlnrhtF8MhmHQr18/EEIwc+bMPI+ZPHkyCCFF6gH/lXn69CkIIVpR+k9LS8OqVatQtWpVdse4e/fuuHLlSrECxhcvXqB06dJwdnZm9VFu3ryJ2rVrgxCC4ODgfNWAd+7cCQ6Hg06dOuHSpUtISEhgPa/Nzc3RuXNnHDx4sNgVNP/88w+GDBkCBwcHEEJQunRpjB07lk0QMAyDWbNmgaZpNGrUKFcC8c6dOxg4cCDbMxocHIw///xTb/WlR+MMHDgQrq6uSh07fvx4mJqaqiUBlJWVBTc3N0RGRoJhGFy6dAk0TassRP0z8hJ4VfWxkpOTIRKJCt3Fv3LlChv32dvbw9nZucAAXCgUok2bNoiIiMDAgQPZ962trXWWRNNZ0C03Z3dycsK3b9+QmprKCqn9zM9Cak2bNsWVK1dA0zRbm08IyXMn6MuXLzA1NUWPHj0KncuWLVtACClxO2tXr179Ty5U8kMmk2H9+vVwcXEBh8NBt27d8PbtW7WMnZ6eDkII1qxZo5bx9CjHwYMHUapUKQgEAkyaNKlYuxy/OllZWWjatCm4XC4EAgG6dOmi0eudP38+lyCJnIyMDISFhcHc3Fylns+ikp6ejoCAADg7O2t9V1BP8WEYBsOGDQMhuT3k9+7dC4qiit0z+CvCMAzr+6yp8c+dO4fOnTvD0NAQhBDUqFED69evV4vTybNnz1CqVCm4uLjg6dOnePr0KeLi4kBRFDw8PLB9+/Z8F6+HDx8Gj8eDh4cHK1pmaWmJrl274siRI8UOtF+/fo2ZM2eifPnyIITAzMwM3bt3z7UrnZWVhfj4eBBCkJCQwCYZ09LSsGLFClSpUoVNAvTv379Qv3E9etTJypUrQQhRauPowIEDIIQotHcUh927dyskBQcMGAChUFis8cuVK1ekdtgRI0ZAKBTi5cuXBR5XsWJFNvbbvXs39u7di8aNG8Pb2xsGBgZwcXFBVFQUNm3ahKysLNZ2Wh4zytuVf67Y0SY6C7r3798PiqLQr18/BAUFwcTEBG5ubggJCYGhoSFEIhEMDQ3RqVMnBAcHY8yYMRAKhTA1NYVAIFDIWOS3UzNt2jRwuVw8fvy4wLn8+eefIISUOFGMuLg4uLi4lLh56YLjx4+zZWyNGjVSuw2LfEfi8OHDah1XT968e/eOLaGOiIjIs1rlv0RmZiYaNGgAHo8HT09PuLm5aaWcu3bt2ihTpozCPUYqlaJ58+YQCoVqsRIpDIZh0LZtW71w2i8OwzCsWNaIESPAMAzu3r0LIyMjNGzYUCn9gN+R5s2bIzQ0VK1jvnnzBtOmTWP7oJ2dnTF27Fg8ffpUbdd4+vQpXFxcUKpUKdy4cQP9+/dnW7kWL16cZ9Ask8lw9uxZhWodKysrdO/eHcePHy92BUtaWhrWrl2L2rVrg6Zp8Pl8NGvWDLt27cozYfvx40dUq1YNPB4PK1euZHf0unTpAolEAoqiUKtWLWzevFlv9aVHJ8h3b5UR/v3w4YNa9U4YhkHNmjXh7u6OrKwspKWlwdXVFeHh4UW+Xw8dOhQWFhYqn5+amgpLS0t06NChwOPk7SpyocWftbh+FlMDflQKW1paKlhNN2jQAISQAvUcNInOgu5JkyZBIBDg8uXLCAsLU/gSa9asCQcHB9bOgs/nw9/fn92RmT17Nnt8QfY1379/h42NDdq2bVvgXBITEyGRSNT6+YrLq1evwOPxiu3L+6tz69Yt1K1bF4QQBAUF4fTp0xq5jryvv7hCEnoKhmEYLFu2DKampjA3N8fq1av/871y6enpiIqKYkuhaJrGhQsXtHLtixcvKpSDMQyDPn36gKZptaikKsPcuXNBCFFJBVtPyWXGjBkghKBnz55wd3eHt7e3ShaevxuzZ8+GQCAodlCXnZ2NnTt3okGDBuBwOBAIBIiNjcXRo0fVntB48uQJnJycUKpUKSQkJMDIyAgSiQQTJkzItSMnlUpx6tQp9O7dG3Z2diDkhzWPra0tDh06VOxNA6lUisOHD6NNmzYQi8Ug5IfF19KlSxXU0f/NvXv34ObmBnNzc+zZswdz5sxB2bJlQQiBo6MjxowZo7f60qNz0tLSQAjBypUrlTq+VKlSarVblAuZJSYmAvih00AIwZIlS4o03unTp0EIwaVLl1Q+d/78+aAoqkDdD6lUygppyzXBevbsiVu3bikE3e/evcOUKVNYlyxCCEqVKsV+vqLMTx3oLOiOjo5G5cqVUbZsWRgbG2PSpEkYMGBALhG1zp07Y+LEiRAIBBAKhQgODsbRo0fB5/NBUVSeYhg/M3/+fNA0jdu3b+d7zOjRo2Fvb6+2z6YORo4cCUNDwxJX8q4tXr16hU6dOoGmaZQuXRpbtmzRaHC2a9eufFsV9KiHu3fvsv2Gbdu21ZcR40disGbNmhCJRJg/fz44HI7Wy3Dr1q0LLy8vSKVSNmBatGiRVq598uRJcDgcDBgwQCvX06Md5GrVfD4/Ty/n/xKXL18GIaTIVSO3bt3CwIED2cVjYGAgFi5cWGDAWRwePXoER0dHWFlZwdraGjweD3369FEQYZNKpThx4gR69OgBGxsbtseyXbt2MDc3R4UKFYq9drl58yYGDhzIKg57eHhgwoQJbF95QRw5cgQmJiZwdnZG/fr1WeX25s2b48CBA/rqQT0lCldXV6XFQ1u2bKn2ypkePXooiLZ27twZRkZGhZZ650VOTg5MTEwwZswYlc/Nzs6Gu7s7oqKiCjyuVKlSrH7Dzy9TU1MEBwcjODiYLSP/WTzt/v372Lp1q06T/DoLuiMjI2FmZgZbW1vcunWrUBG1c+fOwdbWFn5+fihTpgxMTEzYXu+CyMrKgouLC5o1a5bvMX379kWZMmXU88HUQHp6OiwsLNCnTx9dT0XrfP36FSNHjoRIJIK5uTnmzJmjlT7fxYsXg6Zp/cNYA2RmZmLs2LHg8/lwc3PD0aNHdT2lEsG3b99QrVo1iMViHDx4EB4eHggMDNSKLdfPyIOCHj16sKXB2kAunBYREaEXTvvNGDZsGCiKAkVR6NChw3/6vpqdnQ0DAwN2J0kZvnz5gsWLF7O+tObm5ujXr5/GK7EePHgAc3NzVgE4NjaWbc/LycnB0aNH0bVrVzYB4OTkhAEDBuD8+fN48eIFXFxc4OHhUeTkdXJyMqZNm8buSFtYWKB37964fPmy0kn3yZMng6ZpiEQiEPLDRjQxMVGfUNdTYmnYsCFq166t1LGJiYkwMDBQ6zMzJSUFpqamrI7M58+fYWtri/r16xdps6tly5aoWLFikeYid2w6cuRIvscMHToUhoaG6NOnD/t3XtDLyMiILd+vXbs2DA0N0bRp0yLNr7joLOguW7Ys+Hw+bty4oZSIGgDcuHEDfD6fPXfatGlKXUsuVJCf7VaHDh0QHBxc9A+jZpYtWwaKotQmlvArkJ2djQULFsDS0hJCoRBDhw7V6i7/uHHjYGNjo7Xr/Vc4ffo0vLy8wOVyMXz4cLWI+/wOpKamokqVKmxPUo8ePSASiXS2KxgcHAxCCNq0aaOVcn+9cNrvy6ZNm0AIwfTp07F27VrQNI3Y2Nj/dGKlWrVqaNKkSYHHyGQyHD9+HHFxcRCJRKBpGvXq1cO2bdu0knjeuHEjG2yHhYXh2rVryM7OxqFDhxAfHw8LCwsQQuDi4oLBgwfj0qVL7L3iw4cP8Pb2hpOTU6HVh//m69evWLVqFWrUqAGKoiAUCtGyZUvs2bNH6QRkdnY2tmzZwvZucrlctGvXDufOnfvPty/pKfnI7f2U4dSpUxpphZwzZw4oimJ1VeTVn6oqkQP/67suitAxwzCoXLkyKlSokG/bjFyDaenSpfj8+TP++OMPeHt7KwTa1tbW6N69Ox49eoSDBw+iZ8+eePjwIQghaN26NTgcjlZ0c/6NToJuqVQKc3Nz1KlTB0FBQTA1NUWlSpUwZMgQODk5wdLSElZWVhgxYgSqVKkChmHQv39/REREwNLSElwuF4QQHDx4UKnr5eTkwMvLK9+ShaZNmyqdZdI0DMPAx8dHad++Xx2GYbBjxw54eHiAoii0a9dO5Ye2OujevbtSlRN6lOPTp0/o3LkzCPnhk5qXf+t/lc+fPyM4OBjGxsa4ePEi9u/fD0II5s+fr5P5/P3332yv5IoVKzR+PYZh0K5dOwiFQly/fl3j19OjPW7cuAGRSITY2Fg22Nm6dSu4XC6aNm36n3UnGD58OKysrPIMAJ8/f47x48ejVKlSIITA3d0dU6ZMUcruVB3cuXMHERERbH/k2rVrsX//fnTs2BFmZmasBdfQoUNx9erVXJ8hNTUVgYGBsLKyUtrpICcnB/v370dMTAy7U1WtWjUsX75cpWT7vXv3MHjwYDYhIF9Q/5c1BPT8emzYsAGEEHz+/LnQY799+waaprFs2TK1ziE7Oxve3t4IDw9n/8ajo6NhYWGhcmL83bt3IIRg9erVRZrLuXPnQAjB2rVr850rRVGwtLRUaDeRSqWIiYnJta44fvw4evTogapVq8LKygp79uwBIUSpVhV1o5Oge9++fSCEYO/evejduzcbRNM0DVdXVxgbG7MK5VZWVoiJiUFQUBAqV66MMmXKsFkMVUrW5LZgeflJ1qxZEy1atFDnRywyR44cASEEx48f1/VUNM758+dZu47atWvj5s2bOptLkyZNSkzi5VeGYRhs3LgRVlZWMDIywsKFC/+zqsV58fHjRwQGBsLU1BRXr15FSkoKbGxsULt2bZ3syDx//hx2dnaoUKEC6tWrBzc3N43vSM6bNw+EEKxbt06j19GjXd6/fw9nZ2f4+/vnqmj566+/wOfzUa9ePWRkZOhohrpDvuaRV69lZGRg06ZNqFWrFiiKglgsRocOHXDmzBmt3QeSk5PRuXNnUBQFDocDc3NztGjRghWwdXd3x/Dhw3Hjxo1855Seno7w8HAYGxsX6jzAMAyuXr2Kfv36wdraGoQQlClTBlOmTMHz58+VnndaWhpWrlyJ0NBQEPLDj9zMzAwSiaTAklQ9ekoqf//9NwghCkrcBeHj44OuXbuqfR5yS7Jt27YBAN6+fQszMzO0bt1a5bEqVqyIli1bFnkuTZs2hZOTU57PC7nFr42NDZydnRU0u/6tYJ6VlYUqVaqgSpUqEAqFOHfuHE6cOAFCiE5cc3QSdCckJMDR0REjR44EIQQhISFo2rQpNm3axB6TlJSEmJgYVkzLxsYGISEhGDNmDKytrVGtWjWVrimTyVChQgWEhobmeoBUrFgRnTt3VstnKy716tWDn5/fb10S9eDBAzRr1gyEEPj5+ZUIm66QkBC0a9dO19P4pXny5AmioqJACEHz5s21tlPzq/DhwweUL18eFhYWuHnzJhiGQbNmzWBmZqaT7+rTp08oU6YMXFxc8ObNG9y4cUMlFdWicOrUKXC5XLWqr+rRPdnZ2QgPD4elpWW+AdShQ4cgEolQs2ZNpTxpfyc+ffoEQgjGjx+PXr16sZ6xoaGhWLFihVbLHL98+YJhw4ZBJBLBwMAAXC4XNE2DEAIvLy+MGjUKSUlJha5BsrOzUb9+fYhEogKDhefPn2Py5Mls+ae1tTX69++Pa9euKb3OYRgGV65cQdeuXSGRSEAIQWRkJMaMGQNzc3O4ubn95wX79Py6ZGZmgsPhYPHixUod3759e/j7+2tkLnXr1oWLiwsb7K5Zs4bdJFWFMWPGwMTEpMhJ/Pv374PL5WLGjBl5/lwkEmHo0KHw9fUFn89H69atce7cOYWg+/Hjx/D19YWhoSGMjY1x7NgxAMD69esVkqDaRCdBd5cuXVhriSlTpuDp06cFiqgFBwfD0NAQAQEBaNq0KVxdXdG+fXuVrysv4zxw4IDC+56eniVCPff+/fsaX/Tqkvfv36NXr17gcrlwdHTE6tWrS4zAjqurKxISEnQ9jV+SnJwczJgxAyKRCI6Ojvjrr790PaUSx7t37+Dr6wsrKyv2gSDve9q6davW55ORkYGqVavCzMxMYbHapEkTuLq6akTM7cWLF3rhtN8U+X29MEvHkydPQiwWIywsDF+/ftXS7HRLSkoK5syZA6FQCEIIbG1tMXToUK0HiZmZmZg2bRoMDQ3B4XDYCkOBQIDBgwfj1q1bSo8lk8kQGxsLHo+XZ5vfly9fsGzZMoSHh4MQwrYcHDhwQKW//Y8fP2Lu3LkoV64cCCFwcHDAqFGj8OTJE6xcuRI8Hg/VqlVDSkqK0mPq0VMS8fb2Rq9evZQ6dsGCBeByuRqpGrp37x64XC4mT54M4EfCKyoqCg4ODiq1bVy6dAmEEJw5c6bIc+nZsydMTEzw8ePHXD9r0qQJa0eZmJiI0qVLs3aFhBBYWlqyFdQikQhjx45lz42KigKXy8XMmTOLPLeiopOgu1WrViCEYMyYMayI2q1bt/Du3Ts8fvwYHz58wNOnT9ke2+joaKxfvx5isRg1a9aEjY0N+vbtq/J1GYZBlSpVcjXo29jYYNy4cer6eEWmZ8+esLKy+u3K775//45JkyZBIpHAyMgIU6dOLXGCWmKx+D/viV4ULl++jPLly4OmafTt2/c/s5BWhdevX8Pb2xu2tra4e/cugB9CIBKJBG3bttX6fGQyGVq0aAGhUJjLxkhe5rZ8+XK1XjMjIwOBgYFwcnJSsB7S8+uzbNkylWzmzp07ByMjIwQFBSnVw/grIpVKceDAAbRo0QJ8Ph9cLhcuLi5wcnLSesLp69ev6N27NwwMDBT8asViMTw9PVXu12QYBt27dwdN0woJw+zsbPz111+Ijo6GUCgERVGoWbMmVq9erdJzQSaT4dixY4iJiYFAIACXy0WzZs2wf/9+SKVSyGQyJCQkgBCC+Pj4/6xOgJ7fixYtWihdwSt3HLl48aJG5tK/f3+IxWK8fv0aAPDs2TMYGhqie/fuSo8hk8lgaWmJYcOGFXke7969g6GhYZ6bort37wYhhE30ymQyBAQEwNDQECKRCBUrVgRN06hUqRI8PT0RGRkJ4IclIiEEQUFBOnGt0knQHRQUBDMzM1SqVAlGRkaws7ODoaGhgvKcRCKBg4MDevfuDTc3N3h4eLAPLx6PV+QMhVz57+eHhYGBAWbPnq2mT1c0Pn36BAMDgyJ525VUpFIpVqxYAXt7e/B4PPTt27dEKhV/+/YNhBBs2LBB11P5Zfj69Sv69OkDmqZRvnx5XLlyRddTKpG8fPkS7u7usLe3Z/uHpFIpwsLC4OTkpFWFfuDHgrlv376gaRo7d+7M85jmzZvDxcVFbbvdDMOgffv2EAqFuHbtmlrG1FMyOH/+PHg8nsr9hVevXoWZmRkqVKhQIp8JReXhw4cYMWIE7O3tQQiBr68vZs2ahffv32PVqlUghGjMX/tnvn37ho0bNyI0NJTd+TE2Nka/fv2we/duWFhYoHz58kXaIR42bBibmGMYBpcuXUKvXr1YMbOyZcti+vTpSE5OVmnc5ORkTJw4kRWU8/LywowZMxSsvr59+4ZGjRqBpmnMnj37t27D0/PfYty4cbCwsFDq2MzMTPD5fMybN08jc/n8+TMsLCwUKornz5+fry5WfrRp0wZ+fn7FmsuECRPA5/NziZ7duXMHXC4XwcHBuTYq/93XvXLlSsybNw9SqRSNGjWCmZkZEhMTIRAIijW3oqD1oPvz588QiUTo3r17Lon3vF4URaFJkyaoV68eq3LJ4XDw5s2bIs+hdu3a8PLyglQqRXZ2ttZUewti+vTp4PP5xfpcJQWGYXDgwAHWazM6OhqPHj3S9bTyRW4jIO/30FMwu3fvhoODA+s9qy8Vzptnz57B1dUVTk5OCv//p0+fDoqicPLkSa3PKTExEYQQLFy4MN9j/vnnH1AUhaVLl6rlmnLhtPyUSPX8miQnJ8PGxgahoaFF2m38+++/YWlpCV9f3yJZy5QU0tLSsGrVKlStWpUNbrt3744rV64oBIXy58y+ffs0Mo/U1FSsX78eTZo0Ya2/5BZfW7ZsAfBDXd7c3Bz+/v55lmwWxrRp00AIwfDhwzF+/Hh4eHiAEAI7OzsMGjRIZRuj7Oxs7Ny5E/Xq1QNN0zAwMED79u1x9uzZXAH1ixcv4OfnB4lEonJ/qR49JR25P7WyfvIVK1ZEmzZtNDafRYsWgRDC+lvLZDJUqVIF7u7uSleqbty4EYQQvHz5ssjz+P79O+zs7BATE6Pw/vXr10EIgVAoRN26dRV0QvIKuv/44w+0b98eNE3jr7/+Yiu0tP3s0XrQvXXrVvYm/XNwLRAIULduXbRs2RLBwcGssIf85eTkhJ49e6Jq1apK+9nlx5UrV0AIwapVq/Dx40cFtT5dkJOTA0dHx99CyOv69euoUaMG6/WpqfIXdXL27FkQQhQUEPXkJjk5GU2bNgUhBHXq1MHTp091PaUSy5MnT+Ds7IxSpUopfE83b94Ej8fD4MGDtT4n+QNQmXKv6OhoODk5Fbt0Uy6c1q9fv2KNo6dkkZGRgUqVKsHBwaFYi5Y7d+7A1tYWHh4exVqYaRuGYXD+/Hl07tyZFfaqUaMG1q9fn++ClGEY1gpVXXz58gVr165Fw4YNWccXuc2Xu7s7/vrrLzZ4vXbtGszMzBAQEFCk3fZZs2aBEAJHR0cQQiAWi9G2bVscOXJEZW2W+/fvIyEhgVUxr1ixIpYsWZJvz+ilS5dYpWK9/aSe35F79+6ptPnTo0cPeHl5aWw+OTk5KFu2LEJCQth7yL179yAQCDBkyBClxvj48SNomi52Al8eIP9cUfn48WMQQjBp0iQYGhrC3d0d8+fPR2pqqkLQnZ6ejk6dOsHBwQE8Ho91TZk+fTo4HA7bu64ttB50T58+XSGYtrW1hYuLC1vmJBdR27x5M6ZMmcI+QAgh8Pb2RmxsbLHLFYAfcvQuLi7sf3RdWk3I7cwKs9woyTx79gxxcXFsWdju3bt/mdKvbdu2gRCiF2PJB5lMhgULFkAikcDKygqbNm36ZX63uuDhw4dwcHCAm5ubgud8RkYGfH19Ua5cOWRmZmp1TsePHwefz0fbtm2V+t3dvn0bFEUpraaaFy9evICVlRWqVaumr4b4jfjZZ10dbSUPHz6Ek5NTrgRVSeTNmzeYPn06vLy82M2AMWPGKD3vJk2aqOy88m8+ffqEVatWoV69euyOdmBgIEJDQ8HlcmFvb4/ly5cr/M1dvXoVJiYmqFixokp99FlZWdi5cycqVarErsNq166NdevWqaxA//37d6xevRphYWFscqBPnz6F7o5v3LgRQqEQISEhSu8C6tHzq5GTkwOBQIA5c+YodfzKlStBUZRGPemPHTuWq/Vy8uTJ4HA4uHr1qlJjVKlSBY0bNy7WPKRSKXx8fFCtWjV2/ZKTkwMjIyN069YNSUlJaNasGTgcDsRiMXg8HjgcDisWKxdzDAgIYJO7gYGBoGkaTk5OWhV01nrQLS/Bkns0BgcH51LxfP78OSui9uDBA4Vd8QoVKiAsLKzY85AvKuX9SZcuXSr2mEUlJCSk2A9iXfHp0ycMHjwYAoEA1tbWWLx48S+3wF6wYAF4PJ7eTzoPkpKSEBwczIrWaKMf8Vfm7t27sLW1haenZy4bsIEDB4LP5yMpKUmrc0pKSoKRkREiIyNV2rmOiYmBo6NjkRIEGRkZqFixol447Tfkjz/+ULvP+rNnz1C6dGk4OjrqxDu1IOQl0A0bNgSHw4FAIEBsbCyOHDmi8jND7vKgql5CSkoKli9fjjp16oDH44GiKISFhWH69OkYOHAga4mTl0jp5cuXYWJigqCgIKU0JBiGwblz59CtWzeFTY/AwECVrQ3lVl/dunWDkZERWxGwcePGQgVjGYbB6NGjQQhBXFzcbycwq0fPvylfvjzi4+OVOvbWrVsghOD48eManVPjxo3h4OCA79+/A/hxPyxfvjz8/PyUuo/Jd6KLu9Gwb98+BesyhmEgFoshFArZxENycjLc3NwgEAjA4/Hg5eWFoKAgCIVCeHh4IDo6Gl26dMG1a9cUNn/zcmDQFFoNur98+cLaZojFYlSvXh1Hjx6FVCrFgwcPcP78efz999948OABQkND2fN+3h3n8/lo2rSpWubTpk0b9qGiK49Huaz+rl27dHL9opKZmYlZs2bBzMyMFYD7VZWrR40aBQcHB11Po0SRnp6OYcOGgcvlwtvbu1ArID0/HoLW1tbw8fHJVXJ7/PhxUBSFxMRErc7pxYsXsLe3R/ny5VX++7x79y5omsaCBQtUOo9hGHTo0EEvnPYbcvToUXA4HAwcOFDtYycnJ8PLywu2trYlotXn9u3bGDhwIKysrNigc+HChcVKPJ4/f16hT7IgPnz4gKVLl6JWrVrgcrmgKArh4eGYP38+nj17hoULF8La2hp8Ph8DBw7Ms0f74sWLMDY2RuXKlQvdEXv48CHGjBnDWu84OjoiNjYWAoEAjRo1UimZ/unTJ8ybNw9+fn4ghMDe3h4jR47E48ePlTo/PT0d0dHRbPmovrJKz3+BuLg4VK5cWaljpVIpxGIxpk2bptE5PXr0CHw+X8Fy69q1a+BwOJg0aVKh59+4cQOEEBw9erRY82AYBtWrV0eZMmWQk5OD1NRUVvdr1KhRuY6Xl5jfuXMHHTp0YN8PDg5Go0aNYG5uzsaVc+fOLdbcVEGrQbdcUIcQAiMjI3C5XIjFYgXRD/krJCQES5YsQUhICCwsLFjPNUKI2vyUHz9+DA6HA0IIK42vbWJiYuDq6lpi/KoLQyaTYePGjShVqhRomkaXLl109t2pi/j4eAQEBOh6GiWGI0eOoHTp0uDz+Rg3bpzWS6F/RW7evAkLCwuUK1cu187u58+f4ejoiGrVqmm1muLz58/w8fGBs7Nzkf9GW7duDXt7e5V2meQqp2vWrCnSNfWUTB4/fgwzMzPUqlVLY9VMb9++RdmyZWFhYYGbN29q5BoF8eXLFyxZsgRBQUEghMDc3Bz9+vVTWSAsPzIzMyEQCPDHH3/k+fN3795h0aJFqFGjBjgcDmiaRkREBBYtWoQ3b96AYRhs3boV7u7uoCgKbdu2xbNnz/Ic6/z58zAyMkJISEi+AXdKSgoWLFjAVjNJJBJ06NABx48fx5UrV2BkZISIiAil/v5lMhmOHz/OBupcLhdNmjTBvn37VFrfvH79GhUrVoRIJNKp1o4ePdpm6tSpMDIyUjrJVLVqVTRv3lzDswKGDBkCkUik0C43dOhQ8Pl81gY1PxiGga2tbZ62X6py9epVEEKwbNkyvHz5UiFm/PPPPxWOlQfd586dYy2mZTIZrK2tQVEUhg4dyp47ceLEYs9NWbQadEdERLAfctCgQeDz+eBwOKhevTr27t2LGzduYOfOnfDy8kL58uVByA8/yWfPniEyMpI9V53etnLRL10Eji9fvgSXy833AVzSOHnyJCpWrAhCCBo0aIA7d+7oekpqoWHDhqhXr56up6Fz3r9/jzZt2oAQgvDwcJ1Vf/xqyAWK/P3989QFiIuLg5GREZ4/f661OWVmZiI8PBxmZmaFPhQL4v79+6BpWmlrktOnT4PL5bIPOT2/B9++fUPZsmVRunRpjbeYpKSkICAgAKampkrtCBcXmUyGEydOoE2bNhCJRKBpGnXr1sW2bds04gEdGhqKFi1asP9+/fo1FixYgGrVqoGmaXA4HERGRmLJkiUKCbyTJ0+yvdV16tQpMBFw7tw5SCQShIaG5qpwycjIwNatW9GoUSO297FevXrYtGkTW5p+9+5dWFhYoFKlSoVWyLx69QqTJk2Cq6srCCHw8PDA9OnTiySwd/36dTg4OMDOzk5fJaPnP8eePXtACFEIbgti0KBBcHZ21uyk8MMi1traGrGxsex76enp8PDwQEhISKGbCZ06dVKb6FtsbCxsbW2RnJzMxoRyi8b4+Hg2LpEH3bdv32YdEerWrcu6t6xdu5Y9/+ddfE2j1aDbx8cHhBDweDwQQtC7d28MHjwY27dvZ49JSkpC3759wTAMBg0aBEtLS9jY2CgE7OoMkCZPngxCSJ7lCZpm2LBhMDIyKvFl2bdv30b9+vVZlVFdWB1pkkqVKqFjx466nobOYBgGq1atgrm5OUxNTVn/VT2Fc+nSJZiYmKBSpUp5ChRt3rxZ63ZZMpkM0dHREAqFOHv2bLHHa9u2Lezs7Aq1CXn58iUrnKYuj289uodhGDRr1gyGhoa4deuWVq75+fNnVK5cGUZGRmr5P5wXz58/x/jx41lfaHd3d0yZMkVlf2lVkat2z5kzB2FhYaAoClwuF1FRUVi2bFmuxF1SUhK7WKxYsWKhPZxnzpyBoaEhqlatim/fvgH4cU84ffo04uPjYWJiwo41d+7cXOJkz549g4ODA3x9ffO1FcvOzsauXbtQv3590DQNkUiEdu3a4cyZM0V+duzcuRMGBgZF6h3Xo+d34OnTpyCEYP/+/UodL19faENgcPny5SCE4Ny5c+x7p0+fBiGk0KS83A5N2faSgnjy5AlbhSlvDxYIBJg0aRJbEV29enX4+fmhX79+KFOmDOuGZW9vj1q1agEA275CCEGrVq2KPS9l0WrQLfd0JIRgwoQJePbsGYKDg9kFmly5/NChQwB+lLM5OzuDx+PB0NCQPTcyMlJtc5oyZQqEQiEMDQ3x4cMHtY1bGN+/f4eZmRn69++vtWuqyuvXrxEfHw+aplGqVKnfVrXa2dkZw4cP1/U0dMKDBw/YhFbr1q316rAqIN9NCgkJyVOgKDk5GaampmjRooVW/2769+8PiqKwY8cOtYz38OFDcDicAity5BZSjo6O+v9DvxkTJkzQie7I169fER4eDrFYrDaxoIyMDGzatAm1atUCRVEQi8Xo0KFDsYJFZXnx4gVmz57NKp9zuVzUrVsXK1euzDO4ff78Odq1aweKouDm5oYtW7YUOsdTp05BLBajWrVqSEtLw7179zBixAi4uLiAEAJnZ2eMGDEi3+qXt2/fws3NDa6urnlW/z148ABDhgxhrb4CAwOxePFipQTa8oNhGEydOhUURaFFixasYJMePf81ZDIZDA0NMX36dKWOf/LkiYK4mCaRyWTw9/dHYGCgws52jx49IBaL821zAYDU1FTweDzMnz9fLXMZMGAADA0N0apVKzYuTExMRGZmJjZs2AAzMzPQNA2KoiAUChEYGAgrKyuUKVMGL168wOvXr8HlctlzbWxstNbiq9Wgu1KlSuyD5suXLwgLCytQubxly5Y4ceIEbt++rVC7Hx0drbY5DRs2DI6OjpBIJBoRh8mPJUuWgKZpPHnyRGvXVJavX79i9OjRMDAwgJmZGWbPnv3b9vUyDAOBQKBVIYWSQFZWFiZMmACBQIBSpUppVb3xd+DUqVPsblJelSoymQyRkZGwtbXNd7dIE8ycOROEELU93OS0b98eNjY2ee52MwyDjh07QigUKm0joufXYPfu3Vovv/uZ79+/o1atWhAKhThw4ECRx7l+/Tp69eoFU1NTEEJQpUoVLF++XONVZk+fPkViYiLbM83n81GrVi0QQrBkyZI8z/n48SMGDRoEgUAAKysrLFiwQKnKkZMnT8LAwAChoaFITExkW8GMjY0RHx+P06dPF1gG+unTJ5QrVw52dnYK65Lv379jzZo1rPOMqakpevfurZae+8zMTLRr146tNtQ7iOj5rxMUFKR0Cy3DMDA3N8eYMWM0O6n/R76zvWrVKva91NRUODo6onbt2gUmBSMiIlC3bl21zOPjx48wMTFBlSpVFOyn/12lNHXqVFYX4siRI+jZsydreflvHbGCkgbqRKtBd4sWLUDID79tU1NThISEYMyYMRCLxWxWwtjYGFZWVli7di0sLCzg7++PTZs2wdXVFRRFgRCi1h7oHj16wM/PD2PGjIFAINB4aRnw4w/F29sbTZo00fi1VCEnJweLFi2CtbU1BAIBEhISVPL0/BX5/PkzCCHYvHmzrqeiNc6ePYsyZcqAw+EgISFBv7OgIseOHYOBgQEiIiLy9aqdO3eu1q0oNm3aBEIIhg4dqvaxHz16BA6Hg1mzZuX62YIFC/TCab8hd+7cgUQiQZMmTXQaDGVkZKBBgwbg8/kq7banpKRgzpw5rIK2ra0thgwZonGtisePH2PatGls0CsQCNC4cWOsX7+eFTTz9PREjx49FM5LT0/HtGnTYGJiArFYjLFjx7Ll4YVx4MABCAQCWFhYgKZpcLlcNGzYEFu3blVKBC0tLQ2VK1eGmZkZ20Jw7do1dO/enbX6ioiIwIYNG9Rm3fX+/XuEhoZCIBBg/fr1ahlTj55fnU6dOsHf31/p46OiotQWzCpDdHQ0bG1tFe5Ncjuv1atX53teYmIihEJhoW1qyjJjxgw2JpS/vLy8FILnv/76i73PDhkyBDExMejVqxd7vFxImxCiNeFOrQbdDRo0gLOzM+bPnw+BQMDKvVepUgWlS5eGs7MzBAIBbG1tWRG1cuXKwdjYWOEBpk4hl7i4OISFhSE1NRVmZmbo1q2b2sbOj4MHD4IQglOnTmn8WsrAMAx27doFT09PUBSFNm3aaFX0SZfcu3evRP0uNMnnz5/RrVs3EEJQqVIlnagD/+ocOnQIQqEQtWrVyvfhcefOHQiFQvTq1Utr8zpx4gT4fD7i4uI0VibbqVMnWFlZKSQazpw5Ay6Xiz59+mjkmnp0w6dPn+Du7g4fH58SoTmSlZWF5s2bg8vlFpgglUqlOHDgAFq0aAE+nw8ul4umTZti7969GlNcB360YEyePBn+/v4ghEAkEqFZs2bYuHFjnt9fx44d4efnx855xYoVcHBwAJfLRc+ePZUSIZOrhdeuXZtdOFaqVAkLFixQqVUuMzMTkZGRMDQ0xNGjRzF//nxWyNbOzg4jRoxQSy/mz9y6dQulSpWClZUVzp8/r9ax9ej5lZk1axZEIpHS5c6jRo2CpaWl1lrYnj17BqFQmKslMy4uDqampvneu+7cuaNSv3phZGRkKNh+yV8GBgbo3Lkzrl+/DoZhMGDAAISGhqJKlSowNjZWOFZevUMIKZbgrCpovbw8Li4OgYGBMDQ0RK1atRR2R+QiajKZDO7u7vD394dYLEaNGjVw9OhRNtuqTho0aID69esD+JE54XK5ePTokVqv8W+ioqJQoUKFEtEfffHiRYSFhYEQgpo1a+L69eu6npJWOXnyJAjRnU+7NmAYBlu2bIGNjQ0MDQ0xb968X8airiSxb98+CAQC1KtXL9/dnqysLPj7+8PLy0trFQRJSUkwNjZGzZo1NaK2LOfp06fgcrmYMWMGgB/CadbW1ggPD9cLp/1GSKVSREVFwdTUVOPPQlXIyclBXFwcaJrOtaPy8OFDjBgxAg4ODiCEwMfHB7NmzdKovsC9e/cwceJEdifdwMAA0dHR2LJlS74VMHKWLVsGmqaxefNmVmA2OjoaDx8+LPS6t27dwtChQ+Ho6MhuXLi5uRVJ5C4nJwfNmjUDj8dDzZo1IRQKweVy0bhxY40lKvbv3w+JRIKyZctqraRTj55fhcOHD4MQotS9APixm6vN8mjgR6AvEAgU2lA+fPgAS0tLBWeGn2EYBi4uLmrdjBgyZAgbNEskklwBuEAgyPN9LpeL5cuXo3Tp0ux7mnblkKPVoLtMmTJwdHSEqakp9u7dW6CIWtOmTXHy5ElERESAoii2hFHdOyrh4eGsDH56ejpsbW0RFxen1mv8jDzbo+tSzEePHrHl/mXLlsXBgwdLRBJA28jVH4sjBFOSefbsGerVqwdCCBo3boyXL1/qekq/JLt27QKPx0Pjxo0LDGxHjBgBLpeLK1euaGVeL1++hL29PcqXL5+vF686iY+Ph6WlJVJSUvTCab8pCQkJoGkahw8f1vVUciGVStG5c2dQFIW5c+di9erVCA8PByEERkZG6NatGy5fvqyxZ9nt27cxbtw4+Pr6ghACQ0NDxMTEYPv27Sol2TZu3Mgu9qpXr16oNdqbN28wa9YsVKhQAYQQmJmZoV69euDz+ahbt26RSr5fvnyJgIAAdh7u7u6YNm0a3rx5o/JYysAwDP744w/QNI369euXiAoKPXpKGq9fvwYhBDt37lTq+Ddv3oAQgq1bt2p2Yj+RlpYGe3v7XB7h8ha3/ERce/ToAVdXV7Xdn79//84KonG5XHTq1CnPIPvnV82aNXHmzBkcOHCAfc/CwkIt81EGnaiX7927t1ARtcePH6NOnTqoVasWxGIx2zDP5/OxZcsWtc2pfPny6N69O/vvhQsXgqIojVmjdOvWDTY2NjoTJvvw4QP69OkDHo8He3t7rFy58j+96zlnzhwIhcLfLuGQk5ODWbNmQSwWw97eXm1K1v9Ftm3bBi6XixYtWhS4o3vu3DnQNI0JEyZoZV6fP3+Gr68vnJ2dtWax8+zZM/B4PAQGBkIgEGgtuaBHO2zYsAGEEMycOVPXU8kThmFYTQr5gqlGjRpYt26dRipLGIZBUlISRo8eDW9vb3ZHpXXr1ti1a5fK/Yn37t1D06ZN2X7C1q1b5/vsSUtLw7p16xAVFQWapsHn89G0aVPs3LkTu3fvhkAgQP369VVaS+Tk5GD37t2oX78+2w8ZGhqK06dPa/QZmJ2dja5du4IQgkGDBv2n1xx69BQEwzAwMzNTaR3h6OiIhIQEDc4qN3Kf658thBmGQcOGDWFjY5PnzvHevXvVXlnasmVL9lkwcOBAfP36FYsWLULNmjXh5uYGiUSC4OBgtGjRgt2Fz8nJYZO18pe6es0LQ6tBt6OjI3x9fWFiYoKyZcuiSZMmmDRpEho2bIjKlSuDoihYWlri5s2buHv3LsLCwhAUFIRSpUqxD4gGDRqoVenS1dUVQ4YMYf+dlZUFFxcXjYicffz4ESKRCOPHj1f72IWRnp6OKVOmwMjICBKJBJMnT9YLaOGHer2zs7Oup6FWrl27Bn9/f1AUhV69emllB/R3ZePGjeBwOIiNjS2w1PLr169wdXVF5cqVNdo7KiczMxPh4eEwNTXFnTt3NH69n5G3oyxevFir19WjWa5duwahUIg2bdqUuCTkmzdvMH36dNZuy9HRESEhISCEYOrUqWq9FsMwuHnzJkaMGAFPT09WAbxt27bYs2dPkRLmr1+/RteuXcHhcODk5IQ1a9agfv36qFmzpsJxUqkUR44cQdu2bVmb1NDQUCxZsoRdxO7duxd8Ph8NGzZUei4PHjzA0KFDYWNjw4rKyW12NM2nT59Qo0YNcLlcLFu2TOPX06PnV6dq1apo2bKl0sc3bdoU1apV0+CMciOTyRAUFAQ/Pz+FJFpycjKMjIzQqVOnXOd8//4dAoEgT0HWonLz5k2F4HnOnDnsz969e4eWLVuCYRjs3r0bw4YNQ3Z2toJ6udzbWxsi2oAWg255WXW7du1YhXJCCGiahqmpKdtLJG90F4vF8PT0RLVq1eDr6wuxWAx3d3cwDIPJkyeDoig0bty42CVK5ubmmDx5ssJ7q1evBiGk0JIvVZk6dSoEAoFWyzGlUilWrVrFirT07t0b79+/19r1SzodO3ZEUFCQrqehFr59+4YBAwaApmmULVsWFy9e1PWUfmnWrFkDmqbRtm3bQndmOnfuDLFYrHQfVnGQyWRo2bIlBAIBzp49q/Hr/cyZM2fA4XBA03Su+6aeX5d3797B0dERgYGBWsv4F0Z2djZ27dqFhg0bgsPhQCAQICYmBkeOHIFMJgPDMBg9ejQIIRgzZkyxEgUMw+DatWsYOnQo3NzcWGusDh06YN++fUXWSkhNTcXIkSNZ+82ZM2eypeBTpkyBoaEhcnJy8Pfff2PQoEGws7NjS73Hjx+fy1L0r7/+UqrNBfiRaF+7di27o2NiYoJevXph8ODBIIRg0qRJRfpMqvDgwQN4eHjAzMxMYUdMjx49+dOjRw/4+PgoffyUKVMgkUi07jJx8eJFEEKwdOlShfeXLl0KQgiOHj2a65yoqKhcycbiIN9x//nVuHFjHDt2DFKpFHFxcfDw8ICjoyPmzZvHinITQsDj8TB58uTfM+hes2YNqxJtYWEBR0dH1KxZE6tWrcKTJ0/Qs2dPtGvXDtevX8e2bdvYuvyZM2eifv36iIqKQkBAADveX3/9BYlEAl9f3yIrazIMk6dhu1Qqhbe3N2rVqlWsz/wz2dnZsLe3R8eOHdU2ZmEcOnSIFXlp3ry5VgKCX426deuiYcOGup5Gsdm7dy+cnJwgFAoxdepUvbBVMVm+fDkoikLnzp0LfZDJvYz//eDRFAMGDABFUdi+fbtWricnOTmZFU7r1q0bzMzM9FUUvwFZWVmspkpJ0Hy4ffs2Bg0axCbmAwMDsWDBgnyFbuSLpoSEBJUCb4ZhcPnyZSQkJMDV1RWEEJibm6Nz5844ePBgse6hWVlZmDNnDiwsLCAUCjF06NBc9pvbt29nA2x5X2GvXr1w6dKlPD+HXFeiadOmBc7t+vXr6NGjB7uBUb16daxfvx7p6elYtWoVCCEYPHiwxqsZjh07BlNTU3h5eZUoQT49eko6CxYsAJfLVTrZJxea1nbVG/BDtdzS0lJBF4lhGFSvXh2lSpXKJSo5d+5c8Hg8pe0QC+Lbt29wcHAATdOIiIjIFXzb2NjA1tYW1atXh4mJicLP+Hw+tm7divnz5/+e5eXz5s0Dl8uFqakpKleujBs3brBCal27dsXTp0/Rrl07/PPPPwCAihUrYujQoSCEICgoCE2aNEFwcLDCmLdv30bp0qVhZmaG48ePqzyn9PR0EEKwdu3aXD/btm0bCCE4ceJEkT7vv5ELpyQlJallvIK4efMmIiMjQQhBlSpVcOHCBY1f81clICAAXbp00fU0isybN28QHR0NQggiIyP1ixs1sHjxYhBC0L1790ID7rdv38LS0hINGjTQSknu7NmzQQjBvHnzNH6tn8nMzERQUBAcHBzw7t07vHz5Enw+HxMnTtTqPPSon+7du4PH42m9auJnvnz5giVLliAoKIgNfvv164e///5bqfPlfxd9+vQp8O+QYRhcuHABAwcOhLOzM1te2LVrVxw5cqTYyUqZTIYNGzagVKlSoGkanTp1UthB+fr1K1avXo2aNWuyi78KFSpgz549BV57x44d4HK5aN68eZ7Hff78GQsWLGCF1mxtbTF8+HCF58GOHTtA0zTi4+M1fq9asmQJuFwuatWqlSvZoEePnoI5deoUCCFKa0t9/vwZhBTsk60pkpOTYWBggEGDBim8//DhQ4hEIvTv3z/X+6oIxRXE4MGDIRQKERUVBVdXV6xYsYJtoSno5ePjgzNnzoBhGJQvXx4UReH27dvFno8yaC3oXrFiBWiaZs3L5UJqV65cQXR0NG7cuIFmzZqx3sFBQUFgGAbdunUDRVGoVatWniUJHz9+RM2aNcHhcDB//nyVHiZv374FIQR//fVXrp8xDIOAgACEhISo5QEVFBSEGjVqFHucgnjx4gXatm0LiqLg4eGBnTt3lrjevJKGvb09Ro8eretpqIxMJsOSJUtgbGwMS0tLrFu3Tv+7VgNz584FIQR9+/Yt9PtkGAYNGjSApaWlUr66xWXz5s2gKEpBg0IbMAyDTp065RJO6927N0xNTX9b5f//AkuWLNFqlcbPyGQynDhxAm3atIFIJAJN06hbty62bdtWpHLuRYsWgRCCLl26KCTLZDIZzp49i379+rE2W9bW1ujevTuOHz+uNg2GI0eOsD7dDRs2ZBdxOTk5OHDgAGJjY2FgYABCCMLDw7Fs2TJUrFgRMTExBY4rF3KMjo5WCLgZhsHJkycRFxcHoVAIDoeDRo0aYc+ePbk+05EjR8Dn8xEdHa1RETOpVIp+/fqBEIKePXtqRd9Cj57fjZSUFBBCsGnTJqXP8fDwUKsdlypMmDABPB4PDx48UHg/MTERFEXl2vjz8PBAfHx8sa75zz//gMvlYuLEiRg2bBhbzp6dnY0tW7agWrVqoGmaDbQpioKNjQ3mzJnDru3k5fFGRkZaE6LTenm5m5sbTE1N4ePjk0s9Tl5jHxkZCaFQiNq1a+P58+egaRrGxsbo1q1bnmPn5OSgb9++IIQgPj5e6Qf2/fv3c6nv/czBgwdBCMG+ffuK/LkB4MKFCyCEYM+ePcUaJz++fPmCIUOGQCAQwMrKCgsXLtSXFyuBTCYDl8vFggULdD0Vlbh9+zar5t+xY0ekpKToekq/BTNnzmTVdZVJYPz5558ghGD37t0an9vJkyfB5/PRunVrrfdtyYOZlStXKrz/6tUrCIVCjBs3Tqvz0aMezp49Cx6Pp+DeoQ1evHiBCRMmsCXdbm5umDx5slp66lauXAmaphEXF4fjx4+jd+/ebJ+0ra0tevXqhVOnTqk18Lx+/TpbWRYSEsLuoFy7dg39+/eHtbU1CCHw9vbG5MmT8fz5c/bcgQMHwsnJKd+xt2zZAg6Hg5iYGDaAff36NaZMmcKWpbu5uWHq1Kl4/fp1nmNcuHABYrEYderUKXJvujKkpqaibt267AaIHj16io6trS1Gjhyp9PGtW7fWmT5Reno6nJ2dc7Vq5uTkoGLFiihTpoyC6GO/fv1gb29f5I0ihmEQFhYGT09PZGZmYvz48RAIBPDx8VGorJHJZPjy5QvS0tKQmZkJb29vdv2UlpaGgIAAuLm5oWrVqqx1tKbRWtDdvXt3mJmZoU+fPqwSeUEviqIgFAoRHByM2rVrg8vl4tKlSwVeY/ny5eDxeAgNDVVKrOzKlSsghODGjRt5/lz+iy1fvnyxFrotW7aEm5ub2hfLWVlZ+OOPP2Bubg4DAwOMGjVK732pAvJsorZ7Y4tKRkYGRo4cCR6PBw8PD7W1Puj5IURCCMHw4cOVehA8fPgQYrEYnTt31vjc/vnnHxgbG6NGjRoaXTTnhTwwyy+D3rdvXxgbG+tLSH8xXr58CWtra1StWlUr/6cyMjKwadMm1KpVCxRFQSwWo3379mq1qpJKpThx4gQbABNCYGdnh759++Ls2bNqsLPqGwABAABJREFUf/4+efIEsbGxIITAy8sLO3fuxPPnzzFlyhTW0szKygp9+/bF1atX8/yc8r7uvHrpN23axNqKZWRk4K+//mJF5eQq86dOnSrw+0tKSoKJiQlCQ0M16lby5MkT+Pj4wNjYGIcOHdLYdfTo+a8QGRmJxo0bK338nDlzIBAItL5GkLN582YQQnD48GGF95OSksDlcjFmzBj2vcOHD4MQonT70L+Ra1PIhdoGDRoECwsLmJiYoFKlSnnGf/v27WPXMZ8+fULVqlVhaGiIGzduoFatWmjatGmR5qIqWgu6XV1dERUVxRqZy1+lSpWCl5cXPDw8EBoaCg6Ho/Dz2rVr49ChQ0r3Q587dw7W1tZwcnLKN5iWIxcfKEiI7fTp0yCEFNkb/MWLF+BwOGrtwWQYBps3b4arqytomkbnzp215tP7O3Hr1i0QQnDu3DldT6VQjh8/Dnd3d/B4PIwaNYpVwNVTfMaNGwdCCMaOHatUAJCTk4PKlSvD1dVV40muly9fwsHBAX5+floXLZMLp1WtWjXfypnXr19DKBQqPFD1lGzS09MRGBgIR0dHjTtpXL9+Hb169YKpqSmrMbJ8+XK1/d3k5OTg6NGj6NatGyu85uTkhAYNGoDL5apkq6UsHz58QN++fcHj8WBra4s5c+Zg6dKlqFatGiiKgkgkQkxMDPbv319oebW8xe3fZaTr168HTdNo3LgxhgwZwlp8+fv7Y8GCBUoluR4+fAgbGxtUqFBBoy0gZ8+ehYWFBUqXLq0TISc9en5H+vXrB3d3d6WPP3/+PAghuHr1qgZnlT/yTUofH59c973Ro0eDx+OxMVxmZiYMDAwwZcoUla/z8eNHWFhYKLTlhIeHQygU4uLFi7C2toaZmRkGDRqkoGnRvn17bN68GcOGDYOlpSXMzc1ZHRNfX180b968KB9bZbQWdIvFYoX6eiMjIxw8eBBdunRREFFLTk7GqFGjwOfz2WPr169fYBn4v3nx4gUCAgIgEokKDJZ37NgBQkih5bl16tSBp6dnkfqTEhISYGxsrBalPuBHEqBSpUrs96Ks0IKe3Bw7dgyEkBItPpaSkoIOHTqAkB9+rdoSe/gvwDAMRo4cCUJUs8+ZOHEiaJrWeLLmy5cvKFu2LJycnLSeVMvMzERwcDAcHBwK7VcfMGAAjIyM8lWX1lNyYBgGcXFxEIlEuHbtmkaukZKSgrlz56J8+fKsguyQIUNw7949tYyfnZ2NQ4cOIT4+HhYWFiCEwMXFBYMHD1ZQ/t63bx8EAgFq166tll3etLQ0TJw4ERKJBEZGRmjTpg2aNWsGoVAIiqJQo0YNrFq1SuWEQunSpdGnTx/233LnBLkgkLGxMXr27Inr168rPWZycjKcnZ3h6emp0cTKmjVrwOfzUbVqVX2bkx49amTZsmWgKEppVe309HRwuVwsWrRIwzPLn2vXroGiqFztJZmZmShTpgwqVqzItvY0bNgQYWFhKl+ja9euMDIyYttpHj16xG7m7tq1C8nJyRg4cCBMTU1ZfSt/f3/2GA6Hg7p16+Lp06cAgHv37oEQgrp16xbvwyuJVoJumUymsINtY2OD27dv49GjR+jatSsAKCiXAz9KFf69662Kuur379/RqlUrEEIwcuTIPEvLVq5cCUJIof3P165dAyEEK1asUPr6wI+HtImJCQYOHKjSeXlx9+5dNGzYEIQQBAQEFEmtXY8i69evByFEbQkRdcIwDNauXQsLCwsYGxtj6dKlWu/l/Z1hGAYJCQkghGDGjBlKn3flyhVwuVyMGDFCg7P78ZCqXr06TE1NdbJ7FB8fD4FAgMuXLxd67Nu3byESiVTqP9OjG+S6BRs2bFDruFKpFAcOHEB0dDT4fD64XC6aNGmSp6hXUcjKysL+/fvRsWNHmJmZgRCC0qVLY+jQofmWbgM/qtkMDAxQrVq1It/nc3JysGTJEtja2oLL5aJ8+fIwNzcHIQS+vr6YNm1asazW2rZti4CAANy4cQM1atRg1zvh4eFYu3atylY2Hz58gLe3N5ycnPDixYsiz6sgZDIZK17UsWNHnZW06tHzuyIX+VIlOVq+fHmt2hLnhfwe/fHjR4X3L1y4AIqiMHPmTAA/XGI4HI5KyfqLFy+CoijMnTuXfa9p06ZwcHCAoaGhgth2eno6Vq9ejYEDByIyMhJGRkZYvHhxrudAv379IBaLYWpqqpX7mFaC7iNHjrAPEhMTE7bnZ8uWLfD390elSpVgYWGBwMBAtmz26dOnCAwMVAi6VfXjZhgGU6ZMAUVRaNSoUa4M9Jw5cyASiZQaq3nz5nB2dlapVG3hwoWgaRrPnj1Tad4/8+bNG3Tt2hUcDgcuLi7YsGGDPvhSEzNnzoRYLNb1NHLx6NEjti+xZcuWePPmja6n9FvBMAyrsPvHH38ofd7379/h5eUFf39/jd6cZTIZWrVqBYFAgDNnzmjsOvkht0z7t3BaQQwaNAgSiSTXg1ZPyeHw4cOgaVqtKq2PHj3CiBEj4ODgwFqxzJo1Sy27q5mZmdi7dy/atWvHeqy6u7tj+PDhuHHjhtK94GfOnIFEIkFISIhKZdYMw2DHjh2s4JtEImEF2QYOHMg6rRSHz58/IyYmRmGd4+fnh/v37xdpvNTUVAQEBMDKyqrIYxRGWloamjRpAoqikJiYqHfN0KNHA3z9+lVlG7D4+HiULVtWg7MqnDdv3kAikShU78jp168fRCIRHj16hOfPn4MQgs2bNys1bk5ODipUqIAKFSqwu+Vya7U1a9awWmFHjhzJde6xY8fQokUL1KpVC40bN2bX1Pfu3YNEIkGLFi1ACNFYkvJntBJ0N2nShH2g0DQNiUTCZhb+LaAWGhoKHx8fSCQScLlchR7won4he/bsgUQigY+Pj0LgPn78eFhbWys1xp07d0DTtNK92TKZDJ6enkXuE/j27RvGjh3Lfk8zZ85Ue2/af52EhASULl1a19Ngyc7OxpQpUyAUCuHs7Fxs1Xw9uZHJZOjRowcIISqr1vfu3RtCoVDjO8+DBg0CRVHYtm2bRq+TF4UJp+XH+/fvIRaLMXz4cA3NTE9xePToEUxNTREVFVVs5e60tDSsXr2adR8xMjJCt27dcPny5WIHYBkZGdi9ezfi4uJgZGTEipSNGjUKSUlJRR7/0qVLMDExQWBgoFKJof3797PBNiGEFS47fPhwsb8/hmFw6tQpBas0+XXi4+OLnFRPT09HeHg4jI2N1ZIQyIuXL1+iQoUKMDQ0zNNqVY8ePepD3jajLEuXLgVN00hLS9PgrApn2rRp4HA4udZKaWlpcHFxQfXq1cEwDHx9fdGuXTulxpw7dy4oimIFtWUyGQICAhAYGIi0tDQQQlCuXDkYGRnl2qzYsGEDKlSogKysLOzbtw9du3bFw4cP4eLigjJlyuDAgQMghGilfVPjQbdMJmP7sy0tLTF79mzweDxwuVzUqFEDJ06cQGxsLCpVqoQZM2agevXqrBjKmTNnWLsPQgiWLFlS5Hncvn0bbm5uMDMzY0uzBw0aBA8PD6XHaNeuHaytrZX6D71//36VS+KB/5Wy2djYgM/nY9CgQfpeSQ3Rtm1bVKlSRdfTAPCj9KZs2bKgaRoDBw7U+U3zd0QmkyE+Ph4UReHPP/9U6Vy5mOPPZU2a4I8//tDKdfLi1atXsLGxQVhYWJEsB4cMGQJDQ0N8+PBBA7PTU1S+fv0KHx8fuLu7F1llnmEYXLhwAfHx8eyOb0REBNatW1fsfun09HTs2LEDsbGx7Ng+Pj4YO3asWjVLbty4AQsLC5QrVy7PnfisrCzMmzePFS0jhCAwMBBr165Vy/34zZs3mDp1Kjw8PNjy+ClTpmDatGkghKBixYpFDrizs7NRr149GBgYqLzmUJbLly/D1tYWTk5ORVYd1qNHj/LUr19fpV7jGzdugBCikwq5n8nMzETp0qVRu3btXIlSeeXzn3/+iSFDhsDKyqrQ+97r16/Z5K4cuYK53KKRw+Fg5syZCA8Ph0AgwODBg9lN1v3797MbCS9evICzszPMzc3h6emJ58+fs/HagQMH1PxN5EbjQffnz5/ZB5jcV7JHjx5ISEjA9u3b8eTJE/Ts2VOhp/v27duoUKECJBIJnJyc2PMnTpxYrLl8/PgRNWvWZH0kO3fujMDAQKXPf/LkCXg8HqZOnVrosZGRkQgMDFQ6M88wDP766y94e3uDEILWrVuzjf56NEPt2rW1ZhOQH6mpqejZsycoikJAQIDGxI3+60ilUrRv3x4URWHVqlUqnZuSkgJbW1tERkZqtLVj69atoChKpcy2upALp9nb2xcqnJYfHz58gKGhIYYMGaLm2ekpKjKZDI0bN4ZEIilShcbbt28xY8YM9rnk5OSEMWPG4MmTJ8WaV1paGrZu3YqWLVtCLBazuxQTJkzQaCXJrVu3YGNjA29vb7x69QoMw+D8+fNo06YNuznA5/MRFxenFt/wnJwc7NmzB40bN2atvuLi4nDixAkwDMO2cjg5OSEqKqpI15BKpYiJiQGPx8PBgweLPee82LJlC2vhWtT7gx49elRjyJAhcHJyUvr47OxsiEQizJo1S4OzUo6dO3eCEIK9e/fm+lnHjh1hZGSEbdu2gRCCK1euFDhWTEwMLC0t2Q3ItLQ02NnZoUWLFuwx5ubmqF+/PjIzMzFkyBCYmJiAoijUrFkTzZs3B03TrB4ITdPo0KEDK/7Yt29fcLlcdOrUSY3fQN5oPOiWeyHLXyNGjMDTp08RHByM7OxsdO3aVUG9XM7Xr19hZWUFQ0ND9tyxY8cWez45OTlsP6erqyuqV6+u0vk9e/aEqalpgTsGciuqdevWKTXm5cuX2VK9iIgIfeClJfz8/NCjRw+dXX/Hjh2ws7ODWCzG7Nmz1SI4pCc3OTk5iI2NBU3TWL9+vUrnMgyDFi1awNTUVC2L8Pw4deoUBAIBYmNjdaLZ0KVLFwgEArZ0q6gMGzYMYrEY79+/V9PM9BSHsWPHgqIolUqBs7OzsWvXLtYTWiAQICYmBkeOHCnW/81v375h06ZNaN68OQwMDEAIQYUKFTB58mSN9R/nxf3792FjYwMzMzM4Ojqy6wuRSIShQ4eqRa/h0aNHGD58OFupV758+VxWXwsWLAAhBH369MGECRNgbGys8vfLMAy6desGmqaxdevWYs87r/HHjx8PQghiY2P1VpV69GiRtWvXghCikl1oSEiIgp2WrmAYBhEREfDw8Mh1T/306RNsbGxQv359GBkZYdy4cfmOI98Z/7m3ffTo0eDz+Wzy9/3796BpGhRFsRpa379/x4oVK1CrVi14e3tDKBTC2NgYrq6uCrZqaWlpbJxpYGCgcRtYjQfdOTk5oCgKHA4H4eHh+PLlC8LCwnDv3j1WvZxhmFxB9/Lly9GuXTsF6zB1llyuWLECFEXB3NxcJdGX169fF6rUGx8fD1tb20If3o8fP0bLli1ZFdT9+/frRUm0iLW1dYF/7Jri5cuXaNSoEWv79vz5c63P4b9CdnY2oqOjweFwCrQPzA/5Q09ZsY+icOvWLZiYmCAiIkInKsBLliwpkjtDXqSkpEAikehkt16PIvKdhgkTJih1/O3btzFo0CDW7zogIAALFiwoVntTamoq1q9fjyZNmkAoFLIl21OnTtW6VWNKSgoWLlyIypUrK2wE8Pl8jBgxQqWFbV5kZGRg/fr1iIiIYK2+evTokWcSfd68eSCEoF+/fmAYBsePHwchhPWxVRa5gvjy5cuLNfe8SE9PZ0XeJkyYoF+b6NGjZeTl4ufPn1f6nL59+5YYraKkpCTQNJ3nzrvcsjk4OBhBQUF5np+ZmQkPDw+EhYWx95+XL19CJBIpVNTJ7X85HE6eejRPnz6FjY0NQkNDMWzYMIV72cyZM1kRNmV23YuLVoTU5H6dU6dOhYmJCXx8fBAcHAxPT08FERGRSISFCxciLi4OpqambJO8XExN3X1EZcuWhVAohJOTE27cuKH0eQkJCRCLxXkG6x8+fIBQKCzQ9zclJQX9+vUDj8eDnZ0dli9fXmxxFj2qIZVKQdN0sXQCinLNuXPnwtDQELa2tti6dat+IaNBsrKy0KRJE/B4POzYsUPl858/fw4jIyO0bt1aA7P7QXJyMhwdHVGuXDmVlJXVxblz58Dj8dCzZ0+1jTly5EiIRCJ9GaoOuXXrFgwNDdG8efMC7zGpqalYunQpgoODQQiBubk5+vbtWywhri9fvmDt2rVo2LAhBAIBCCEICgrCjBkztN4ylZmZiW3btqFx48bg8XigaRrlypWDhYUFaJqGsbExbGxsiuUhfvPmTfTq1YsVhg0PD8eaNWvy7XWX6zYMHDiQ/d2kpaWBw+Go5LEr7wXXRCnpmzdvEBQUBJFIVKRkpR49eopPRkYGaJrG0qVLlT5n3bp1IISUGCeRbt26wdjYOM/qt+bNm7M6Hnn9fMKECeByuQraHnFxcbCyslJIksoDePnr3/fRzMxMpKWlgWEYdOrUiRWp3bNnDzgcDgICAthz81I/VydaCbpr1qwJW1tbzJ49GwYGBmwQ7ejoiBkzZiA8PBwSiQQBAQGgKAoURcHe3h5Vq1aFSCRihVXUjY+PDzp06ICAgACVHi4pKSkwMjJC//79c/1s0qRJEAqFeYoJpaenY9q0aTA2NoZEIsHEiRP1glk64u3btyCEYPfu3Vq53s2bN1GpUiUQQtC9e3edBFj/JTIzM1G/fn3w+Xzs2bNH5fNlMhmqVasGR0fHIotPFcaXL19QtmxZODo6arR0PT/kwmmhoaFq3WH/9OkTjIyMMGDAALWNqUd5Pn78iNKlS6Ns2bJ5elPLZDKcOHFCQT27bt262LZtW5EdMj59+oRVq1ahXr16bHVaSEgIZs2apfVKHoZhcObMGXTp0oW1GgsICECXLl3Y3vRmzZrh/v37eP36NcqUKQMrKyuVdpm/fPmCRYsWsbamNjY2GDp0KB48eFDgebNmzQIhBIMHD86VDAkMDESbNm2Uur68OmXUqFFKz1lZbt68CUdHR9ja2mp810ePHj0F4+npmaf9Vn7cv38fhBDWmlnXvH//HiYmJgoiaHLevHnD3qPXrl2r8LPHjx9DKBQqWFxeunQpT1FtuRAaIYRdZ/fr1w+vXr3Kdc19+/Zh0KBBmDhxIjgcDpo0aYK+ffuy52tKiFKOVoLuyMhINGvWDKNGjQIhBO3bt0ePHj3yFFJ78uQJevfuDUIIOnXqhHr16oGiKJQpU6bY5V//xtHREaNGjVIooxo5cqRSfVXjxo2DQCDAy5cv2feysrJgZ2eH+Ph4hWNlMhnWrFkDR0dHcLlc9OzZUy0+pnqKzt9//w1CCC5evKjR63z//h2DBw8Gh8OBj48Pzp07p9Hr6fmR3IqKioJQKCyysFBiYiIIIazTgbrJzMxE9erVYWJiohWbiryuX7ly5WIJpxXE6NGjIRKJ9B7zWiYnJweRkZEwMzPLJXb24sULTJgwgbXCcnNzw+TJk4uc8ElJScHy5ctRp04d8Hg8UBSF0NBQzJkzR+G5qC3u37+PkSNHwsXFhRUnGz58ODZv3oxq1aqBEIKqVaviwoULCue9f/8e5cuXh5mZWYF6KgzD4PTp02jXrh2brGjQoAF27dqllNr/jBkzQAjB0KFD86w+6Nu3L1xdXQsdZ+PGjaAoCr1791Z7pdTu3bshFotRoUIFnfwO9ejRo0jTpk1Ro0YNpY+XyWQwNjYutvC0Opk9ezZoms6zWlmuQh4eHs6+xzAM6tatC0dHRzZxzDAMqlSpgrJly+aqDL558yYbNFetWhXTp0+HWCwGh8NB8+bNsWDBAmzfvh3dunUDh8MBj8cDj8fDgAEDkJOTw1ZjE0IUbKU1gVaC7rCwMDb7MG3aNDx79qxQIbWaNWuywmJCoZAtxd6+fbvaHjRGRkaYMWMGgB+/0KlTp4KiKDRq1KjQZvqvX7/CwsICXbp0Yd+Tl3X8XApx5MgR9hfatGlTrQrG6MkfuQWUXHRBExw8eBClSpWCQCDAxIkTddKv+1/j+/fvqFGjBkQiEY4ePVqkMZKSksDn8zW2UyuTyRATEwOBQIDTp09r5BqF0aVLF/D5/GILp+XH58+fYWxsjH79+mlkfD15M3DgQHA4HPb/fmZmJjZv3ozatWuDoigYGBigffv2OH36dJGeox8+fMDSpUtRq1YtcLlcUBSF8PBwzJ8/P89dBU3z/v17zJ07l11fGBsbo3Pnzjh16hTu3buHFi1asJope/fuzfczf/r0CZUqVYKxsXGuoPzt27eYPn26gtXX5MmTVfq88lLwESNG5DuHzZs3gxBSYKJq37594HK5aNu2rVoFFxmGwfTp00FRFJo2baqvwNOjp4QwevRoWFtbq3ROjRo10KhRI81MqAhkZ2fD09OT9ef+GYZh4OrqCoqi2KpCebn4zp072eO2bNkCQggOHz6ca3yGYeDl5cUGzrdu3cKXL18wb948lClTRqH0nKZpTJgwgd34vHDhAvszOzs7jX0HcrQSdEdFRUEgECA+Ph6pqam5hNQA5Aq6gR+90/IG9+nTp6NBgwas+FRxgyWZTAaKonL1SuzZswcSiQQ+Pj6FZjwSExPB4XDw8OFDMAyDwMBAREZGAvixk1q7dm0QQlC5cmX9DmcJY/Xq1SCEaESN9d27d4iNjWWTRoWVHOpRD9++fUN4eDjEYjFOnjxZpDEyMzNRtmxZ+Pr6akypd/DgwaAoSiNqw8ogL03VhPjSz8irgXQRjP0XkYv+/fHHH7h+/Tp69erFWqSEhIRg2bJlRVJmfffuHRYtWoQaNWqAw+GApmlERERg4cKFOqlkSE9Px+bNm1G/fn1wuVxwuVw0bNgQW7ZsQUZGBt6+fYsePXqAy+XCwcEBK1euVEozJTU1FaGhoTA0NMTx48exd+9eNGnSBFwuFwKBAK1bt8bx48dVDnYnT57MloIXlOhITk4GIYTtN/w3p06dglAoROPGjdXqdJGVlYUOHTqAEILhw4frxD1Bjx49eSMPNlVxBBk6dKhWAkhV2LdvHwgheerryIPspk2b4tu3b3B0dES9evXY+2VGRgZcXFxQr169fMcfNGgQGzxHR0cr3GuzsrKwcOFCrFq1CgEBAez7MpkMdevWZc9zdHRU4yfOG60E3XKl5vLly8PU1BTVq1fHxYsXERUVBSMjI1ZB1MXFBS9fvkR6ejq8vb0xZcoUNui+c+cOGIbBjh07YG9vDwMDA0yfPl2psq68SE1NBSEEmzZtyvWzO3fuwM3NDWZmZjh27Fi+Y6Snp8POzg6xsbE4e/YsK2sv9wN2d3dX6868HvUxffp0GBsbq3VMhmGwbNkymJqawtzcHKtXr9b/7rVEamoqqlSpAolEUqyenMGDB4PP5xdLSKog5syZA0II5syZo5HxC+P8+fPg8Xhascr78uULTExM0Lt3b41f67/OlStXIBAIUKlSJfj5+bF9xkOGDMHdu3dVHu/169dYsGABqlWrBpqmweFwEBkZiSVLlujEDk7ehy73d5WLs82fP5/VT/n69SvGjBkDsVgMExMTTJ8+Henp6Spd59atW3BxcWHXHX5+fpg3b16RFdwnTJgAQpS3O3V2ds5TK+bq1auQSCSIiIhQazLww4cPqFq1Kvh8fq6eSj169OieO3fugBCCEydOKH2OPIjVhVZMQURFRcHV1TWXdohUKmVtJGNiYiAUChXao6ZOnQoul1vgs2z79u0KO9r9+/dnE4hSqRQNGjSATCZjg+6cnBzEx8ezxxsYGMDW1lYDn1oRrQTd5cqVQ0REBJYtWwaJRMIKrZiZmcHFxQVWVlawsLBgM8o2NjYwNjaGi4sLgoKCIBaLFbKvX79+Rd++fUHTNMqWLauSnL6cly9fghCCAwcO5PnzT58+ITIyEhwOB/Pmzcs3eFq8eDEoikL16tVhZmYGgUAAS0tLzJ8/v8gJAT2aZ8CAAfD09FTbeHfv3kXVqlVBCEHbtm3zFNLToxk+f/6MoKAgGBsbF6tH/+TJk6AoCtOnT1fj7P7Htm3bQFEUBg0apJHxC+P169ewtbVVu3BaQUyYMAECgaDEPfx/F6RSKTZu3AiRSMRaczZp0gR79uxReTc0OTkZc+fORVhYGCiKApfLRVRUFJYtW4aUlBQNfYKCuX37NoYNGwYnJycQQuDq6orRo0crVA9lZWVh/vz5sLKygkAgwODBg1UKkjMyMrBhwwbUqFEDhBBIJBI4OTmBz+er5G/+b8aNGwdCCMaPH6/0ObGxsbnsc+7evQsLCwsEBQWp1UP2zp07cHV1haWlpb4ST4+eEkp2djb4fD7mzZun9Dny+Obn8uySwJ07d8DhcDB16tRcP4uJiWGFs8eMGcO+//btW0gkkkKT9/KW0Z/tvypXroyNGzdi2bJlbFLR398fq1evVlAs53A4iImJgb29vVo/b15oPOiWSqUghGDx4sWYMmUKCCFwdnZGQkICHjx4oCCi9v79e0yePBlCoRBGRkZISEhgMzZ5ZdevXbuGwMBAUBSFrl27qvSgvXXrFgghBT5scnJy0L9/fxBC0Llz5zwXqmlpaaxVCI/HU4vfpx7N07p1a1StWrXY42RmZmLs2LHg8/koXbq0xu0G9Cjy8eNHBAQEwNTUFFevXi3yOF++fIGTkxOqVq2qEfu+06dPQyAQoFWrVjop38zKykJISAjs7e21WhKcmpoKMzMztVqS6QEePXqEkSNHwt7eHoQQcLlcjB49WmWBzhcvXmD27NmoUqUK+wyrW7cuVq5cqTPLmbdv32L27Nnw9/cHIQSmpqbo1q0bzp49q5D8ZhgGmzdvRunSpUFRFNq3b48XL14ofZ2///4bffr0YZ/fVatWxerVq/H9+3dkZmayNmP5lXvnB8MwGDNmDAghKosZLViwADwej92hf/r0Kezt7eHr66vW38fBgwdhZGQEX19frdu46dGjRzXKlSuXp/p3fjAMAxsbGwwfPlyDsyoaffr0gaGhYa51iFwTS+7uIKdLly4wNTUtNPEr9zQfOHCgghU1IYSNKeVVUj+/eDweNmzYgNjYWHh4eGjkM/+MxoPuL1++gBDC9gz16dOnQBG11atXY+HChShVqhTEYjHbp/bo0aM8x5d7H0skElhbW2PDhg1KlfSeP38+l+hZfqxcuRJ8Ph+hoaHsooZhGGzduhVubm7sL09XPZp6VKdGjRqIjo4u1hinT5+Gl5cXuFwuhg8frnIpo57i8eHDB5QvXx4WFhbFLgdv27YtJBKJRhagt2/fhomJCapXr15kS6bi0rVrV/D5fI2r9efF5MmTwefzVQqI9OQmLS0Nq1evRnh4OAghMDIygre3N3g8nko7lc+ePUNiYiLrzc3n89GgQQOsWbNGY/Z4hfH9+3esX78eUVFRrLpskyZNsGPHjjz/Zo4fP87addWvX19pu6/U1FQsXrwYFStWBCEE1tbWSEhIyNOnOzs7G61atQKHw8H69euVGp9hGIwcORKEEEyZMkWpc35GvnA8deoU3rx5Azc3N7i6uuL169cqj5Uf8+bNA03TqFevnn6DQI+eX4CYmBiEhoaqdE6DBg1YjamSxKdPn2Bubo6OHTsqvD9//nwQQlClShVwOBxcv34dSUlJoGkas2fPLnRcmUwGc3NztGrVCgcPHmTtIQt6+fn54eTJk/j06RP4fD7Kli2roU/9PzQedGdnZ7OKcV27dlUQUWvfvj3u3r2Lhg0b4siRI8jOzka9evUglUoxb948WFhYsNnuwnZnkpOT0bx5cxBCEBkZiYcPHxZ4/IEDB0AIUXoheP78edjY2MDR0RHLly9nFyyRkZEwNDSEhYUFatasqfT3oke3+Pj4FLnX9NOnT+jcuTNbvvJvAUA9mufdu3fw9fWFlZVVsb//rVu3snoM6ubVq1dwcnJC2bJldebNvnTpUhBCsGzZMp1c/+vXrzA3N1cpU6/nBwzD4MKFC4iPj4dEImHFGdetW8fqAygjiPf48WNMmzaNDTYFAgEaN26M9evX6yzwkkqlOHr0KNq1awdDQ0N2wbV48eJ8d3Vv3ryJqKgotqdbGcFEhmFw9uxZtG/fHgYGBqBpGvXr18fOnTsLbQGTSqWsRkth3zPDMBg+fDgr/FoUpFIpJBIJRo0ahXLlysHOzi6X9VtRyc7ORo8ePdh+R01U9OjRo0f9TJo0CSYmJippBI0fPx6mpqYlUldowYIFoCiKrU78+PEjLCwsYGFhgcaNG6NcuXIoX748IiIi4O7urnQ7nLGxMbhcLt69eweGYXDy5Em0aNGCFRQlhMDc3BzBwcGIj49nv5tZs2axopxyizJNoZWebhMTEwgEAhgbG8PX1xchISF5ZiHs7OxgYGAAiUQCAwMDthRAIpEo3R+9d+9eODs7QyAQYMKECfnuLMntOVRZcJw8eZI1cndxccHRo0cxb948cDgcVhFYU76+etSLhYUFJk2apNI5DMNg48aNsLKygpGRERYuXKhXetUBr1+/hre3N2xtbYskEvUzr169gpmZGZo1a6b2h9OXL19Qrlw5ODo66qyn+cKFC+Dz+ejevbtOri9n6tSp4PF4GrXo+514+/YtZsyYwT4nHR0dMXr0aDYAO336NLhcLnr16pXvGA8fPsSUKVPYxLVIJEKzZs2wceNGtfYGq0pSUhIGDx7Mlsa7ublh3LhxBbqFPHv2DG3atGEFSrdt21bo3+u7d+8wY8YMeHp6sv3gEydOVPlvUSaToVu3biCEYP78+XkewzAMhgwZAkIIEhMTVRr/30RERMDExATm5ua4fft2scaS8/nzZ9SsWRNcLjeXY4sePXpKNrt371ZZGE2+sVjYBqQuyMnJga+vL6pUqQKGYdC1a1e2pVgikeDChQtsifiuXbuUGlMmk7Gl5I0aNcqVVJRKpex6fe7cuayK+r1792BmZsbaVOdXVa0uNB50Z2VlwcjIiLXikIuoFfTicrmoU6cOEhMTYWJiAn9/f5WumZaWhoSEBHC5XHh5eeWZDV+6dCkoilIqaHr79i26d+8ODocDBwcHhISEsPYapUuXZuXpAwMDUbly5RKZWdLzP+TVF6pYJj158oTdYWnevLneBklHvHz5Eu7u7nBwcCi2FRvDMKhduzZsbGzULnyXlZWFGjVqwMTERKkWFk0gF06rUqWKzj3iv337BktLS3Tp0kWn8yjJZGdnY9euXWjYsCE4HA6rAXD48GGFBcTz589haWmJatWq5UpG37t3DxMnTmQVzA0MDBAdHY0tW7bo1Hv51atXmDFjBjsvc3Nz9OzZExcvXizweZmSkoIBAwaAz+fD2toaixYtKjABL5VKsX//fjRt2pQVZo2NjcWxY8eKlSBlGAb9+vXLM6hmGIa1q5k1a1aRrwH80AhxdXUFIURtrSAPHz6Ep6cnTE1N9ZsCevT8gjx+/BiEEBw8eFDpcz58+ABCCDZs2KDBmRWdI0eOgBCCCRMmgKIozJ07F9euXQMhP7y4zczMQNO00hsrmZmZIISgX79+oGkaLVu2zOX0cOPGDVSqVAkeHh549uwZ/v77b9jb26NMmTLYv38/CCFqS3Tmh8aD7itXroCQHx6VHA5HIbguVaoUPD094e7ujqCgIAXVOXkZXXx8PEqXLl2kayclJaFy5cpsT/nPC+vExEQYGRkVeH5aWhrGjx8PQ0NDmJiYYMaMGcjIyADDMJg2bRo736NHjwIADh8+DEII9uzZU6T56tEOr169AiEEe/fuLfTYnJwczJgxAyKRCI6OjsVSs9VTPJ49ewZXV1c4OTkVuCumLAsWLCjQwaCoyGQytG7dGnw+v8h+4cVFLpxmZ2enEy/lvJgxYwa4XK7aymV/F+7cuYNBgwbBysoKhBAEBARgwYIFeQqDfv/+Hf7+/nB2dmafZ7dv38a4cePg6+sLQggMDQ0RExOD7du34/v379r+OCzfvn3DmjVrEBkZCZqmIRAI0KJFC+zevbvQJND3798xZcoUGBsbw9DQEOPHjy+w7O/JkycYNWoUHBwcQAhBuXLlMHfuXLWKj/1cPj5hwgT2vQEDBoCQ4tsA5uTkoGnTpuDxeCDkh01qcTlx4gTMzMzg4eFR7CSlHj16dINMJoOBgQFmzpyp0nmurq55WhCWFBo0aAAejwc/Pz92J9rGxgYRERFshVdoaKjSCVORSITp06dj27ZtEAqFcHR0xMSJExXWQAzDYPz48XBzcwOfz0eFChXw6tUr1nJMnfoZeaHxoFsu4/5zwG1sbIxDhw6hS5cuCkJqT548Qa9evcDlctljAwMDYWVlVeTry2QyLFmyhC3XWrlyJRiGYR/QeZGTk4M///wTtra24PP5GDBgQJ4Pbz8/P3A4HPj4+ODRo0dgGAbh4eEoV66cvuy4BCPPphWmdn358mWUL18eNE2jb9++Oi3J/K/z5MkTODs7o1SpUmopUb537x5EIpFG/KoTEhJAURQ2b96s9rGVpVu3buDz+bhw4YLO5vBv0tLSYGVlhU6dOul6KjonNTUVS5cuZbVBzM3N0bdv3wIFARmGYW1Vtm7ditGjR6NMmTJsC1br1q2xa9cunQo65uTk4ODBg2jdujXruxoeHo4///xTKZG2nJwcLFu2DPb29uDxeOjdu3e+iuyZmZnYtGkTWxYokUjQtWtXXLlyRaPVZnLv7eHDh6NPnz4Flp0ri0wmQ/v27cHhcLBp0ybQNI0///yzWGMuW7YMXC4XNWvWLLLPuB49ekoGgYGB6NChg0rntGzZElWqVNHQjIqPXHTy5wq41q1bg8PhoFOnTjh58iQIIViwYIFS44WEhKBcuXJgGAa3bt1Cp06dIBKJwOVyYWtrC5FIxFZbGxsbY8aMGWwyt3nz5pBIJBqvVNZ40C3f/ZW/bG1tcefOHTx69Ahdu3YFAAX1cuCHncXPZegWFhbFnsfbt28RGxvLLgLatGkDHx8fhWMYhsHevXvh4+MDQn6YtOe3K5OUlMSWmrm5ucHMzAxHjx7F2bNnQQjBpk2bij1nPZph3759IITg5cuXef7869ev6NOnD2iaRvny5XHlyhUtz1DPzzx8+BAODg5wd3fP93emCtnZ2QgMDISHh4fadwLnzZsHQohSapua4s8//wQhpNiLdk0wc+ZMcDgctVQq/GrIhV3atm0LkUgEmqZRp04dbN26tVBV+5/Lm21tbdlFQ9u2bbFnzx6dqeLL53b9+nUMGDAANjY2IITAy8sLkyZNUjpBxjAMdu/ezSYRWrVqlW9vXVJSEvr27cuK44SGhmLVqlVaLZ+fPn06uz5RdkGYH/LfLUVRrEp6+fLl0b59+yKNJ5VKMXDgQBBC0L17d6X1cPTo0VNyad++PSpWrKjSOYmJiRCJRMjJydHQrIrO69evYWRkBD8/PxgYGLD96vXq1QMhBJcvXwbwYwPB0NAQz58/L3TMGjVqgBCCS5cuse99+vQJixYtQrNmzWBrawtnZ2fY2Nhg8eLF7DGvXr1iN3s13QOv8aB74cKF7MPJzMwMhw8fBgBs374dFStWRHBwMCwtLeHv74/09HRW2Gzq1KkKanPq4vDhw3BzcwNN07C3t2d3Ba5cuYJq1aqBEIJq1aoVGmh17NgR9vb2yM7OxqdPn1CrVi1wOBzMnTsXdevWhbu7e4n8j64HWLFiBQgheZY47t69Gw4ODjAwMEBiYqL+d6hj7t69C1tbW3h5eamtj17e6iK/qauL7du3g6IoDBw4UK3jqoJcOK2kKoV///4dNjY2Kmfsf2VevHiBCRMmoHTp0qxw2OTJkwsVxWEYBteuXcOwYcPYQFsoFKJDhw7Yt2+fzvv0X758ialTp7JJaisrK/Tt21flneZz584hNDQUhBDUqFEjzwokeWVApUqV2GsNHjy42EKKRYFhGPTs2ZNdn3Tv3r1YlW3jxo0DIQQLFy5k3+vZs2eRPGO/fv2K+vXrg6ZpzJ07V68vo0fPb0JiYiIMDAxUutecOnUKhBD8/fffGpxZ0YiJiYGlpSWePXsGKysrxMXF4f79++BwOKBpmr0fpqamwsHBAXXq1Cn0fubv7w9jY2PUqFGjwGTj6NGjsX37dgA/7ucdO3ZkK7N2796tvg+ZBxoPuuXiU4T8sA0zMjKCRCJR8LeWvzw8PODt7Q0rKytIJBI288DhcPD+/Xu1zSkjIwNeXl6gKArOzs5ssF2mTBns3btXKVVUgUCg4MOZk5PD9nY1adIEhOjOokdPwUyePDlXIic5ORlNmzYFIQR16tTRiF+zHtW4desWrK2t4ePjg7dv36plTLkq5rhx49QynpwzZ86wwle6ai158+YN7OzsEBISovOArCD++OMPcDicEqmqqi4yMzOxefNm1K5dGxRFwcDAAO3bt8fp06cLfL4wDIPLly8jISGBFdQyMTEBn89HpUqVcgnDaJvU1FSsWLECERERoCgKQqEQrVq1wr59+1TeUb179y4aN24MQgjKly+PQ4cOKXw3cquvDh06sFZfdevWxY4dO3S2e/uzkvnSpUuxbNkyUBSFDh06FMmC648//gAhBJMnT1Z4f8OGDSCEqLTuefbsGcqWLQsjIyO161To0aNHtxw8eBCEEJWqxL59+waapktcLCIXUZPbtMqr88LCwuDk5ISqVauifv367PF79+4FIQRr164tcFwPDw80b94cXC4XMTExea6Dnj17huDgYGRnZ4NhGAwdOhSEECxatAiEEKxbt069H/ZfaDTozsjIYGXf7e3tcfLkSdYmxNfXF5s2bUJ0dDQqVqyIhQsXolWrVqzgytatW9kSKWW+bFWpWrUqXFxcWDG0SpUqKS3HP378eIhEojz7vFetWgU+nw8LCwvY2dnptOxPT9706dMHZcqUAfBjEbVgwQJIJBJYWVlh06ZN+t2BEsDNmzdhYWEBPz8/tSXcvn37Bjc3NwQFBam1guHOnTswNTVFtWrVdPb3npWVhSpVqsDOzk7jQiDFJT09Hba2tmjbtq2up6J2bty4gd69e7OlzyEhIVi2bFmBehByL+6BAwfC2dkZhBBYWlqia9eu2LVrF7y8vODp6akzn/fs7Gzs3bsXrVq1glAoBEVRiIiIwMqVK4vk8f3q1SvEx8eDpmm4uLhg3bp1Comqd+/eITExEV5eXqzg6oQJE9TSWlIcZDIZunTpksuze+3ataBpGjExMSolA1atWgVCCAYPHpzrmfPs2TMQorxdzrlz52BlZYVSpUppXH1Xjx492ic5OblIO7E+Pj5sK29JIDMzEx4eHggLC2Pve1KplN2IXbduHaZPnw6RSKSQZI6NjYWZmVm+Gh8A4Obmhs6dO2PLli3g8/kIDAzE5s2b2eA7NTUVYWFhuHPnDg4ePIhatWqBEIKZM2fi9evXIIRg1apVGv38Gg265SrR8gyGgYEBgoKC0KNHD2zfvh1PnjxBz549FXq6w8LC2IdtWFgYe766eiQzMjIwY8YMcDgccLlcjBs3DkuWLIG5uTlMTEywePHiAneqMjMzYWNjU2D55oULF2BhYQFCCAYNGqSWeetRHy1btkRERASSkpJYIaP4+Hi92EwJ4dq1azAzM0NAQIBa1Ye7dOkCAwMDtar4vnr1Ck5OTvD19VVKKEpTdO/eHTwer0QJpxXE3LlzQdM07t+/r+upFJuPHz9i3rx5qFChAgghsLGxQUJCQoGlzzKZDGfPnkW/fv3g6OgIQgisra3RvXt3HD9+HDk5OZDJZGjYsCGMjIxw7949LX6iH4mAK1euoE+fPrC0tGQT5dOmTSty8PvlyxcMHz4cIpEI5ubmmD17NpukkkqlOHDgAJo1awYejwc+n49WrVrh6NGjJUKUVCaToXPnzqAoCitXrsz1861bt4LL5aJJkyZKVZns2LEDNE0jPj4+zyQvwzCwt7fH4MGDCx1r3bp14PP5CA0NVWtFoB49ekoODMPAxMQkV1VMYbRv315l22VNMnHiRHC5XAUrValUyrZfrV69Grdu3cplkfb+/XtYWFigZcuW+Y5tbW0NBwcHSKVSnD17FlWrVmWfydHR0eDz+aBpmnW58PPzYxOb8iRov379NPfhoeGg+8WLF2zQLBQKERYWhrt377Jb+127dlVQLwd+lAds2rQJnTt3Vig9nzFjRrHmIpPJsG7dOjg7O4PD4cDY2FghcP7w4QM6dOgAQggqV66MpKSkPMdZs2aNUnYeycnJbOCt6cyJHtUICwtDmTJlwOVy4e3tjdOnT+t6Snr+n0uXLsHExASVKlVSaxC7Z88eEEIUxDOKS2pqKvz8/ODg4KDTXbhly5ax5a6/ChkZGbC3t0dcXJyup1IkpFIpDh48yD7I5QHXnj178q2ikEqlOH36NHr37g07OztWFK1Xr144depUrvLkUaNGgaIopawN1cWzZ88wceJENvFtY2ODAQMG4MaNG0WuAMrMzMTs2bNhbm4OkUiE4cOHs7v2T58+xejRo9nEQ9myZTFnzhykpKSo82MVC6lUig4dOoCiKLYcMi/++usv8Pl81KtXr8A2gCNHjoDP56Nly5YFlqRHR0cjJCQk35/LZDKMGDEChBC0a9dOX1WnR89vTpUqVRAbG6vSOQsXLgSXy9V5axLww29cKBQiISFB4X35GqZ69eqws7PD169f4eTkhD59+igcJ2+7yasC6Pbt22y8+PMz859//kHPnj1RunRp0DQNLpcLc3NzjBs3TuGZ5u/vz2p9aTLRq9Gg+9u3b+yXIBaL8fTpU4SFheHevXv5qpdXqlQJKSkpyMnJYTPshBCFci5VOXbsGPz9/UEIQePGjXHv3j3Y2Nhg/PjxuY49deoUvL29weFwMHjwYAVFVIZhUKFCBURFRSl13Xv37rHl6yNGjCgRGfv/OkeOHAGPx2P7evULlZLDuXPnIJFIEBISotZS2vfv38PKygr16tVTW+tAVlYWatasCWNjYwXnBW1z8eJF8Pn8ElU+piwLFiwATdM6EcMqKo8ePcLIkSPZTHmZMmUwc+bMfEvepFIpTpw4gR49erDK3vb29ujbty/OnDmT7zNh27Ztefb6aoLPnz/jzz//ZHcFDAwMEBcXh0OHDhWpT1mOPNHt4uLC7uq+evWK7XePjIwERVGQSCTo0qULLl++XOJae6RSKdq1aweappXq9Tt06BBEIhFq1qyZp5r6hQsXIBaLUadOnUJ3xOfMmQM+n5/nM+r79+9o3rw5KIrCtGnTStz3pkePHvXTtWtXlCtXTqVzrly5AkIILl68qKFZKQfDMKhbty4cHR1Zmy7gh/ijtbU1YmJi8PTpUwgEAowcORLdunWDm5tbrjHq168POzu7XJsy8g1RDoeDqlWr5vvs+rdbFgCcOHFCYZP3Z19vdaNxITU/Pz9wuVw0a9YMJiYmKFu2LBo2bIimTZtCKBSyPd9cLhedO3eGu7s7ypUrh/DwcDZgJYQUqQzxn3/+QZ06dUAIQXBwMM6cOcP+TCQS4Y8//sjzvKysLEycOBFCoRDOzs7Ys2cPgP8pAf5c8lAYPXv2ZPvgGjZsWKQeOD3F5/3792jTpg37f01f9l+yOHXqFAwNDVG1alW1+qEzDINGjRrBwsJCbTdShmEQFxcHPp+PkydPqmXMovCrCKflR2ZmJhwdHRETE6PrqRTI9+/fsWbNGlZw08jICF27dsWlS5fyDHZycnJw9OhRdOvWDVZWViCEwMnJCQMGDMD58+cLTb4mJSVBLBYjOjpaY8FUVlYWdu/ejebNm0MgEICmaURGRmLNmjUKC6KiwDAMDh06hPLly7OJ7rt37+Kff/5Bv379YG5uDkIIqlSpgpUrV2rV6ksVpFIp2rRpA5qmsWHDBqXPO3nyJMRiMcLCwhSe93///TdMTEwQFhamlFWhfLF87tw5hfeTk5MREBAAsViMnTt3Kj0vPXr0/NrMmzcPfD5fJe2IrKws8Pl8zJ07V4MzK5wdO3aAEJLrnjV8+HAIhULWEmzEiBEQCoXs7ve/2wFfvnwJiUSC+Ph4hffnzp2rINqdn6vEv4Pu27dvw9zcnE2KE0I0uhGg8aBbrvQ5bNgwmJiYsLvXPB4PXbp0QUhICCQSCRo2bMjaopiamsLHxwfOzs6QSCQoVaqUStdMTk5Gx44dQdM0Spcuja1btyosXrKzs0EIybM362cePXrENto3a9YMUVFR8Pb2Vmkh9ObNG4hEIkRHR8PIyAhlypTJ139Uj/phGAarVq2Cubk5TE1NsXjxYn3Jfwnj2LFjMDAwQEREhNoX4MuXL8/zRl8c5GqXmzZtUtuYqpKVlYXQ0FDY2tqWeOG0gli0aBEoiipx4k9ycbP4+HhIJBIQQhAREYG1a9fmGTBlZ2fj0KFDiI+PZ9uKXFxcMHjw4HyD87xISUlBqVKl4Ofnp/a/Bfln6tGjBxv4+vn5ITExUW12fFevXmW9UqtUqYIjR47gzz//RFBQECsQN2jQoBJf3ZCTk4PY2FhwOJwi/Z2fP38eRkZGCAoKwufPn/Hw4UP8H3tnHRZV+v7/Z84kQwzdICElISEpoIAioSB2dxe6Cha6rmJ3d2J97F5jXWtXxTXXtTsBMUCk4bx/f/ib812WkIEpdF7XxXXtMuec5x6cOee5n+e+328jIyN4eHhUu4qnqKgIQqEQc+bMYX539epVmJqawsLCAjdu3JA4LhUqVNRdxDuy32pv/S/e3t7o3r27jKL6Njk5ObCwsChXbfj8+XPw+XxMnDixzLEmJiZo06YNeDxehXpe4nn86dOnmd+tWbOGSZq7d+8OFouFuLi4cn8rcdKdn5+PTZs2MZvBsbGxzPmydC+SedI9depUaGpqIi0tDU5OTtDV1UVUVBS2bt1aTkitqKgIu3fvhr29PYRCIcaNG4egoCAEBgZWa6zs7GxMnDiREWpZsmRJhTtA79+/ByGE8WmrCpqmsWPHDmYi9a0+rIoYN24c1NXVceHCBdjZ2UFHRwe//fabRNdQITkPHz5EaGgoCCHo2rUrMjIy8OLFC4mrFVTIjhMnTkAgECA8PBx5eXlSvfaTJ0+goaGBPn36SO2ay5YtAyEECxYskNo1a8KQIUPA5XJx8eJFhcZRWwoLC2FpaVmlOIo8SU9Px9y5c+Hk5ARCCCwsLDB58mQ8ffq03LGFhYU4duwY+vTpw6iV29jYYOzYsbh69arEu9TFxcUICwuDvr6+VB/6jx8/xi+//AI7OzumvD0xMbFS3ZKa8OTJE3Tq1AmEEDg5OWHWrFno3bs31NXVQVEUIiMjsXfv3jpRkVFcXIxOnTqBzWZj165dNb7O1atXoaurCxcXF5ibm8PBwUFiobOQkBDExsYC+NpyoKamBh8fH5mWP6pQoUI5effuHQgh2L17t0TnDRkyBI6OjjKK6tskJCRAIBCUe4526tQJxsbG5aqrNm/eDEIIvL290bx583LXKy0tRZMmTWBjY8Msgot1ewgh6NatG/bt28ds8gYHB2PkyJHw9vaGmpoazMzMmGd269atkZmZyeissFgsmVZfyTzpnjx5MoyMjODl5QUTExOcPn26SiE14KsarLq6OgwMDBASEoJWrVpVOUZRURGWLVsGAwMDCAQCjB8/vsrV5KdPn4IQIlHiO3jwYPD5fLBYLHh5eeHq1avVPvfDhw/Q0tJCfHw8Pn78iBYtWoDNZmPx4sWqXiwZUFhYiGnTpoHP58Pa2rpMgp2amgpCiGqXQAk4cuRItYSHakJJSQkaN24Ma2trqZWr79u3DywWC6NGjZLK9WqKePe+LgmnVcWaNWvAYrEU1htfVFSEgwcPIjY2Fmw2m/FbP3nyZLkF1oKCAhw5cgQ9e/aEtrY2CCGws7PDhAkTaiU2BgAjR44Em83GmTNnavmOvj5zVq5ciYCAABBCoKGhgZ49e+K3336rVZ/2f8nIyMDw4cPB5XIZhVixCFu9evUwdepUvHz5UmrjyZqioiJ06NABHA4He/bsqfX1zp49CzabDS6XK9GcQUxSUhIMDAwwbdo0EELQqVMnqS9OqlChou5gaGiIn3/+WaJzNm7cCBaLpZD21tu3b4PD4SA5ObnM7y9evAhCSIUe4qWlpfDx8YG5uTm4XG6FLU8PHz6EQCDA6NGjAZR1y+LxeHj37h3+/vtvREREgMfjlenZFh+TkJCA9+/fY+/evczvNTU1ZZqXyTzpnj9/PiNcdf78+W8KqQFfFU0DAwNhbGwMIyOjSssiaJrG3r17YWdnBxaLhV69elVLRfjGjRsghODKlSvVeg/Z2dnQ1NTE+PHjcenSJbi5uYGiKMTHx1d7Qj9t2jTweDy8ePECxcXFjAd53759VWJeUuSPP/5AgwYNwGazkZiYWK4U9NChQzIXSlDxbQ4cOAAul4vWrVvLZPdrxowZoCiqjI5Dbfjjjz8gEAjQoUMHhQoipqamgsfjYcCAAQqLQdoUFRXBysoK7dq1k+u4d+/exZgxY2BkZARCCDw9PbFs2bJyNnX5+fk4ePAgunXrBi0tLRBC4OjoiEmTJuHvv/+WygNavLK/dOnSGl+joKAAe/fuRVxcHHg8HthsNiIjI7F9+/Zq9RBLQk5ODqZOnQoNDQ2oq6vDxcUFHA6HUeU+depUnRMOLSoqQtu2bcHhcLBv375aXy87OxteXl7Q1dWFoaEh7O3tJXY5OHjwIDMZnDJlimqRXoWKH5zQ0FC0bdtWonPEFly///67jKKqGJqmERQUBAcHhzJ5Dk3T8PPzg7u7e6WLwOKknJDKvcnnzJkDiqKQmppaZqf735bT+vr6GDduHCZNmoSVK1ciMzMTa9euhb29PXg8HkQiERwcHMqc+/r1a5n8PQA5JN3nz58Hm81GUFAQUzvfqVMnTJs2DSYmJkxvmY6ODtavX4/ffvsNFhYWsLGxQWBgINhsNmbPnl3uun/++Sezit+iRQvcunWr2jGJBdGqK862aNEicDgc5oFZVFSEuXPnQigUwszMDHv37v3mw/Dz588wMDBAv379mN9t3rwZPB4PAQEBSE9Pr3b8Ksrz6dMnRj/Ax8cHN2/erPC4NWvWgKIoqe72qJAMsadt+/btJRIEqS7Xr18Hh8PB+PHjpXK9e/fuQUdHB02aNFHoAllaWhrMzMzg7+//3S3UiUVTJLmP14Ts7GysWbMGfn5+IIRAT08P8fHx5e4XeXl52LdvH7p06cL0dDs7O2PKlCll/EWlQWpqKvh8Pvr06SNxUkXTNP744w8MHDgQOjo6IITAy8sLixYtkskzpaioCCtXroS+vj7YbDY0NDRAyFcP70WLFimV1ZckFBYWIi4uDlwut9IJniTk5eUhODgYIpEIN2/exOPHj2FpaQlra+tqtw6kp6fD29sbhJAy9qYqVKj4cRkxYgQcHBwkOqekpATq6uoV5lKyROx9/d+qYrH117cWAcS6Gr17967w9eLiYnh5ecHFxQVr164tt5s9ceJEZq40ffp0Rtvn0aNH6Ny5MzIyMtCsWbMyot2ynofIJekmhGDIkCHQ0dGBo6MjuFwuIzRjaWkJPp+P+vXrMwJrhoaGePLkCRo3bgyKosp8UB4+fIg2bdqAEAJ3d3ecPHlS4pgk2e0sKSmBjY1NhQq7z58/R6tWrUAIQcuWLfH8+fMqr7VgwQKw2ewyanyXLl2CsbExzM3Nce3aNYnfy48OTdPYtWsXjI2NoaGhgaVLl1aZUE+dOhWGhoZyjFDFv9m+fTvYbDa6dOlSqZ9xbcjLy4OTkxPc3d2lsoP+9u1b1KtXD87OzlL1DZcUsXCasbGx1ESvlImioiLY2NigTZs2Ur82TdM4e/YsevToATU1NabHePfu3WUWL3Jzc7F792507NgR6urqIITAzc0N06ZNk1i4prq8ffsWpqam8PPzk2gh5eHDh5g0aRKsra0ZdfTx48fLLE6xtolY7FRsLda/f3+JhOKUkcLCQsTGxoLH4zFOJbWhqKgI0dHREAqFZZTHnz9/DltbW5ibm5dT5P0vf//9NywtLWFsbAxbW9syi/UqVKj4cRFvHEnaktekSRO5VpN9+PABBgYG5XKnvLw8WFhYMFoVVfHy5UtwOJwqS75v3rwJDoeD1q1bl0mc/7vAsHz5cmzevBnAV72NoUOHAvh6vxa3/H4XSff8+fOhpqaG4uJiDBs2jOmBS0pKwuPHj8sIqT148ACNGjWCmpoaXF1d4e/vj0aNGqF79+7IyMjA0KFDweFwYGFhgS1bttS4fG3r1q0ghFSrN+rAgQMghCA1NbXC12maxr59+2BmZsYojVa2e5efnw9zc/NyH8LXr18zDf6KVESuazx//hzR0dGMGEJ1SveGDh0qsc+hCumwefNmUBSFHj16yKzSID4+Hnw+Xyq7kdnZ2XB3d4eZmZnC+1KHDh0KLpdbzj7oe2Ljxo1S1Vt49eoVkpOTYWtrC0IIbG1tMX369DL3iZycHOzcuRPt2rWDUCgEIQQeHh6YMWNGjWwqJaGgoAD+/v4wNTWtlgJ9ZmYmli5dyiiBa2lpoW/fvjh79qxMS7k3bdpUxk6lYcOG2LBhQ62txZSBgoICtGrVCjweD0ePHq319UpKStC5c2dwuVycOHGi3Otv3ryBo6MjjI2NK1XsP3z4MDQ0NODu7o6XL19i4MCBcHJyqnVsKlSoqPuIy64lfU6OGTMGlpaWsgmqAgYOHAgtLa1yz7bk5GRwudxvLjyKEVv9Hjt2rNJjkpKSmKSZzWYjLCysXJJ+48YNplV5+vTpZWwgs7OzmaqtOl9ePnnyZJiamiIhIQEsFgvTp0+vUkgtNTUVRkZGYLPZMDAwQHh4OBwdHaGpqQmRSITZs2fXWkhk+fLl4HA41Vqdb9q0KQICAr553OfPnxEfHw+KouDm5oZLly5VeJxY1r6icsZu3bqBEIIJEybUuX44eVJcXIwFCxZAXV0dpqamEvXftW3btkI1RBWyZd26dWCxWOjXr5/MPtunTp0CIQSLFi2q9bUKCwvRrFkzaGlpSVXluSZs2LABhBCsXr1aoXHImuLiYtSvX79aK+CVUVBQgF27diEiIgIsFgtCoRC9evXCuXPnmPv958+fsX37dsTFxUEgEIAQgkaNGmHWrFlys3OkaRp9+/YFj8fD5cuXKz0uPz8fu3btQqtWrcDhcMDhcNCqVSvs2rVLpoJaOTk5+OWXXxixOHE7iKx20hVBQUEBoqOjwefz8euvv9b6ejRNY9CgQaAoqkoRtoyMDLi6ukJfX7/MxJmmacyfPx8sFgutW7dmFjW2bNkCQkg5rQEVKlT8eGRlZYEQgq1bt0p03v/+9z8QQpCRkSGjyP6Py5cvg8VilfMGf/v2LdTV1SUSo/3w4QNYLBacnZ0rPaagoIDR9iKE4NChQ9i+fTv09fUBAPPmzUNAQACsrKzg4+ODLl26oLCwEKWlpXBycsLSpUsxYsQIsNlsODo61m0htVmzZjErCDNmzCgjpNavXz+8fPkScXFxOHPmDEpLSxEQEIDHjx8zincGBgZgsVgYOXKk1PrFZs6cCT09vW8eJxZck8Q25OrVq/Dy8gKLxcKgQYPKlaQWFRXB1ta2QkV2mqYxZ84csFgstGrVSiFKg8rOtWvX4OnpCRaLhWHDhkn8NwoMDFSoX+GPyMqVK0EIweDBg2WWcH/48AFmZmYICwur9Rg0TaN79+7g8XhyFx75L2LhtP79+ys0DnkhFhSTVOn5xo0bGD58OGMDEhAQgHXr1jFCl1lZWUhJSUFMTAz4fD4IIfD19cXcuXNl6slZGWLruU2bNpV7rbS0FGfPnkXfvn0Z4TYfHx8sXbpUYsspSRD7eHfs2BEcDocpIf/pp5+k7i6gaPLz8xEZGQmBQFDhjnRNGDduHAghWL9+/TePff/+Pby8vKCtrY0rV66gsLAQ/fr1AyEE48aNK3MPe/z4MQghOHLkiFTiVKFCRd3GwsIC48aNk+gcsWuTrO8jxcXF8PDwgIeHR7mKxj59+kBPTw8fP36U6Jqenp7fdJz6888/QQiBqakpo9Hh4eGBtLQ0hISEgKZppKamYvDgwcw5W7duRYsWLbB06VLcu3cPhBCZz7VknnSLpdhNTU0hEong6uqK0NBQ+Pv7l2teNzY2hoGBAdzc3BAYGAhra2uw2WypK/WOGzcO1tbW3zyuV69esLCwkLj3tKSkBEuWLIGmpiaMjIywffv2Misn27ZtAyGk0t3wo0ePQktLCw0aNMCjR48kGvt7JScnBz/99BMoioKrq2uVu0NVUb9+fSQkJEg5OhWVsXjxYhBCEB8fL9PVw06dOkFbW1tideCKGD9+PAgh2LFjhxQiqznp6ekwMzOTuN+3LlNcXAx7e3u0bNnym8d++PABS5cuhYeHBwghMDIyQmJiIu7duwcA+PjxIzZt2oTo6GjGMiQgIAALFizAixcvZP1WKuXMmTPgcDiIj48v8/u7d+9iwoQJqFevHgghsLa2xqRJk3D//n2ZxpOZmYkFCxaUUXBVV1fH1KlT64SvtqTk5+ejRYsWEAgEOHXqlFSuOWvWLBBCsGDBgmqfk5WVBX9/f2hoaMDDwwNcLrfCRRiapmFkZCQ1YUgVKlTUbSIjI6v1jPw3NE1DT09PYrsxSVmyZAlYLFa5ltwbN26AxWLVyKFjxYoVIISgQYMGVeZjpqamaNmyJVJSUrB9+3Z4eXnh8uXLGDZsGICv8wsXFxcAX/O02NhYrF+/nomJx+PJXGxO5kn3q1evQFEUWrduDS0tLUag5ls/hoaG0NfXByEEM2fOlGpMQ4YMgbu7e5XHpKWlgcfjYc6cOTUe5/Xr12jXrh0IIQgPD2dKF0tLS5nFh8q4d+8e7OzsoKOjI7WJQV3lyJEjsLS0hEAgwKxZs2qleK2hoYF58+ZJMToVlTFv3jwQQjBmzBiZJtziRSxpJMnLly8HIQTz58+XQmQ1p7CwEEFBQd+tcFpViDU3KrJ0LCkpwfHjx9GxY0fweDxGQOXQoUMoKirC+/fvsX79ekRGRoLL5YLFYiEwMBCLFy+WyoJMbXn+/Dn09fURGhqK4uJiZGRkYNGiRfDy8gIhBNra2hgwYAAuXLgg0+9MaWkpTpw4gfbt24PD4YCiKHC5XAgEAkyePFlq3vbKRl5eHpo3bw41NbUqd00kYdWqVSCEYPLkyRKfe/XqVabFoaq2mDZt2iA4OLg2YapQoeI7ISEhAVZWVhKfFxERgaioKBlE9JW3b99CS0urnNsCTdMICQmBo6Njjebvz58/Z3LDFStWVHpcaGgo2rVrh1atWqG0tBReXl7IzMxkNi5+/fVXmJqaAvhaVbd161Zs3LiRSbrFLcyyROZJt1ga/vDhw0ypnPhHV1cXNjY2sLGxga+vbxn1OLFQjK+vL1q3bi3VmLp27frNB9jPP/8MoVAocRlERRw5cgT16tWDQCBAcnIyCgsLGYG2qh78Hz9+ZFT1Fi9eXKcVYmtCWloaOnToAEIImjdvXut+yy9fvtSoF0aF5MyYMYPRJ5Dl5/bly5cQiUQVugtIyv79+5lWFkUzbNiw7144rTJKSkrg6OhYZnLw5MkTJCUlwdzcnFnxnj9/PjIyMpCZmYk1a9YgPDwcHA4HLBYLTZo0wbJly5RqwSI3Nxfu7u6wsrLC6tWrERkZCTabzfjV7927V+YVDS9evMCUKVOY3XRTU1Noa2uDw+FgyJAh37V1ZW5uLsLCwiAUCqXWNrJjxw6wWCwMHz5c4vvcqVOnIBKJ4OjoiKCgIAgEgkp7y+fPnw+BQCATi0UVKlTULcRtWJKKWU6aNAkGBgYym5N17twZBgYG5fImcb5Tm9J2Z2dn1K9fv0x5elFREW7evIn169djyJAh0NXVhb29PVJSUgAAXl5eAL7+vYKDgzFixAiEhoaipKQE0dHRKCkpYZLugoICUBQlc+0cmSfdS5cuBYfDYQRZCCFQU1PD5s2b0a9fvzJCaq9evYKFhQWz8ive8Q4MDJRqTK1ataqwp1pMfn4+DA0NMWTIEKmN+eXLFyQmJoLNZsPJyQlnz56Fj48PfH19q/wCFBcXY/To0SCEoE+fPj9EmWlpaSlWr14NkUgEAwMDbN26VSo3iSdPnoAQ8sNXDsiaX375BYQQTJkyRea7daGhoTA3N6/14tiff/4JgUCA9u3bK1zEUKzivWrVKoXGoUh27NgBQgh+/vlnNG3alFmEHThwIFJTU5Geno5Vq1YhLCwMbDYbFEUhNDQUK1asqJYVpLwpLi5G06ZNweFwGJX0gIAArFy5Uube1oWFhdi9ezdatGjBiMuFh4czqu7t27evtpJsXeXLly8ICQmBuro6zp49K5VrHjlyBBwOBz169JD4nrFixQqw2WxEREQgKyuLUVHncrk4cOBAueMvX75cpYuKChUqfhyuXbtWo/vB4cOHQQj5pr1xTRAL2YptucQUFhaifv36aN68ea3mgz/99BN0dHTA5/Ph5uYGHx8fRp+FxWLByckJTk5OIIQgODgYbm5uzIKoWEitUaNGSEhIwOvXr2FqagodHR2oqanByMgIU6dOBSGEaU+TFTJPusUiSuIfbW1tXL9+HY8fP8bAgQMBoIx6+dWrV9GoUSPGy5sQInW7jODgYHTt2rXS18WTXllYxvz999/w9/cHIQQtWrQAIQQHDx785nmbN28Gj8dDQECAUk4qpcWdO3fQuHFjZpFBmhNSsdWC+LOmQrrQNI2kpCQQQjB9+nSZj7dgwYJvVotUh/v370NXVxfBwcEKF4y6cuUK+Hw++vXr98NVtgBfP0OXL19Gv379QFEUCCEICQlBSkoKnjx5guXLl6Np06agKApsNhvNmzfH6tWrZSowVhtu376NxMREpsrL2NgYU6ZMkYtK+p07d/DTTz8xbVr+/v6YMGECc39t2rTpD5HEffnyBU2bNoW6ujrOnz8vlWueO3cOAoEArVu3lkjz5d/WqfHx8WXOLSwsRLt27cDhcMpZhxYWFkIgEEjUM65ChYrvk9zcXLBYrGqJNv6b9PR0EEKwe/duqcZTUFAAe3t7BAUFlZu3LFiwABRFSTTvLioqwo0bN7Bu3ToMGjQI3t7eZXJCQghatWqFhQsX4vz580w7VLdu3cDhcDBp0iTExcVBTU0NaWlpMDQ0REhICKKjo9GvXz8AYPRK1q1bByMjI/j7+4OiKDx58kRKf5WKkXnSLe6RFO9wHzp0CMBXgbWAgAAEBgbCwMAAnp6eZSwxxDsdhBBG9l1auLu7V7qLTdM0GjZsiOjoaKmO+W/EO7na2trgcrkwNzevlm/xpUuXYGxsDHNzc4nVfZWd/Px8JCUlgcvlwt7eHmfOnJH6GPv27QMhBJmZmVK/9o8OTdNITEwEIQRz586V+Xi3b98Gn8+vdSl4WloarKys4OzsLJVWktqQnp4Oc3PzH0o4TUx6ejrmzp2LBg0agBACCwsLtGnTBoQQjBo1CsHBwWCxWOBwOIiIiMC6deuU9nv89u1bzJs3D+7u7iCEMO4dvXr1kvlCSk5ODtavX88s7Orr6+Onn37CkSNH0LZtWxBC4OrqimPHjv0Qizo5OTkICgqChoYG/vjjD6lc8+rVq9DU1ERYWJhEi3RZWVlMu1hlVSzFxcXo1q0bKIoqJ6oWFBSEtm3b1ip2FSpUfB/Ur19fIustMRYWFlIXE05OTgaHw8E///xT5vfv37+HtrY2s8FaEYWFhbh+/TrWrl3LJNj/3sFu0KABunfvjvnz50NNTY0Rwq6oN71Ro0ZwdHSEhoYGli5dWqWQmpgvX77A29ubyTfFOaqskHnSPXz4cObNUBQFkUgEXV1dtGjRgtnJEP9oaGjAzc0NGhoa0NbWZvr3CJHcCL4qrK2tK5XbP3PmjNxKkNPT0xEeHs70KFanrOH169fw9vaGQCBQuLqytPj9999hZ2cHLpeLSZMmyWy3UVzSp+jy4e8NmqYxcuRIEEKwePFimY9XUFCAhg0bokGDBrX6rHz+/BkeHh4wMzPDy5cvpRih5BQVFSE4OPiHEk4rKirCwYMHERsbCw6HAz6fj06dOmHr1q2YP38+AgICmAdvVFQUNm7cqLRexV++fEFKSgrCw8NBURT4fD7atWuH5cuXQ0tLixF2kQX/rg7Q0NAAi8VCixYtsGvXLjx79gyDBg0Cm82GpaUlNm/eXK0F3u+Bz58/IzAwEJqamlLTRrh79y709fXh6+srUT/l48eP4eTkBG1t7W9W5pSWljL2Yf/uLxw3bhyMjY1/iMUSFSpUVE3r1q3RvHlzic9r06YNmjZtKrU4njx5AoFAgMTExHKvDRs2DFpaWow3uDjBXrNmDQYOHIhGjRoxziIURTEJ9qJFi3DhwoVy99i2bdvC39+fccU6duxYmdcdHBzQv39/qKmpwcnJCW5ubpUKqQFAfHw89PT0wOVyER0dLRfNJ5kn3TY2NiCEgMfj4enTpxgwYACTYBsbG+PMmTO4du0azp07h59//plZ4WjTpg2sra2ZpFuaMvd6enqVKqLHxMTA2dlZrg82X19fcLncaiedeXl56NatGwghGD9+fJ1NIt+/f4/evXuDEILAwEDcuXNHpuP9/PPPZb5wKmpPaWkphgwZ8k1VSWkyduxYcLlcXL9+vcbXKCoqQnh4OLS0tPD3339LMbqaMXz4cHC5XKntxikzd+/eRUJCAoyMjEAIgaenJ6ZOnYqpU6fCz8+PeV60atWKWbS9cOGCosMuR0lJCU6cOIFu3boxrhxBQUFYs2YNPn36hKysLDg4OMDJyQnZ2dlSHz8zMxMLFy6Es7MzCCGwtLTElClT8Pz5c2RnZ2PSpEkQCoXQ0dHBvHnzFN46IU+ys7MREBAALS2tSq05JeXZs2cwMzODi4uLRIs/586dg56eHuzs7Kpt/1ZaWsqUoYsXMsX9mE+fPq1R/CpUqPh+SEpKgomJicTnzZw5E5qamlLJG2iaRlRUFCwsLMolyLdu3QJFUWjTpk2FCbazszN69OiBxYsX448//sCXL1++Od769evBYrHw7t07NG3atJwaupeXF5o0aYLZs2fDwsICXC4XS5YswcqVK8sIqQFfFwsSEhLA4XCgqamJS5cuVbvdtzbIPOkWl9Y5OjoiJiaGKQ/csWMHHBwcEBwcjM6dOzMPMR8fH2zatAlCobCM2vm/Dc1rA03T4HA4WL58ebnXHj16BBaLhbVr10plrOpy8+ZNEEIQHR0NLpeL+vXrf3OnnaZpzJkzBywWCy1btpTJpE5W0DSNlJQU6OvrQyQSYc2aNXJZOBg4cCA8PDxkPs6PQmlpKfr37w8Wi4V169bJZczz58+DxWLVykaQpmn06NEDXC5XairGtUGsIbFy5UpFhyIzsrOzsXbtWqbsWVdXFz179kR8fDxT2sXn89G6dWts3bqVuZ+VlpbCzc2tSntFeULTNG7cuIGffvoJJiYmIITAwcEBycnJePbsGXOcWB1VJBJJVRuktLQUJ0+eRIcOHcDj8cDlctG+fXscP34cJSUlKCwsxJIlS2BgYACBQICxY8fi06dPUhu/LpCVlQU/Pz+IRCKp9aynpaWhfv36sLW1xdu3b6t93oYNG8DlchESEiJxlQZN00hISAAhBLNmzcL79+9BCGGUeVWoUPHjsnPnThBCJL6v/PbbbyCE4O7du7WOQdyyuWvXLly7dg2rV6/GgAED4OXlxVQy/zfB/vPPP6uVYFfEmzdvQAjBtm3bcPPmTVAUVcZqMSwsDJqammjWrBkjqsZiscDlcqGvrw8jIyN4enoyFcZsNhsmJiZwdnZmrB8fPXpU679LVcg86RbvXOvp6YHD4WDjxo3w8/NjPFWBryJh4pp7b29vAF/VhP9tISZufq8teXl5lZYQjBgxAvr6+sjLy5PKWJLQqVMnmJub48aNG2jSpAkIIejSpcs3LVyOHj0KLS0tODk5yfzDIg0eP36M5s2bgxCCjh07ylUUrnXr1oiMjJTbeN8zJSUl6NWrFyiKKqdWKSuys7NhZWWFwMDAWpXITpgwAYQQbN++XYrR1Yy//voLfD4fffv2/e7KRmmaxtmzZ9GjRw8IhUJQFIUmTZqgS5cuTL+zmpoa2rZtix07dlTqDS1+sJ87d07O7+D/ePXqFWbPng0XFxcQQmBgYIARI0bgr7/+qvDfbcKECaAoqlILKEl5+fIlfvnlF1hZWTHtSAsWLGAE5EpLS7Fjxw7Y2NiAoij06dNHKXzJ5c2nT5/g4+MDbW1t/PXXX1K55sePH+Hq6gpTU9Nq7zKXlJQwCXP//v1rbPVF0zQmT57MVPs5ODiU88BVoULFj8ft27dBCJFYHPLTp08VqoxXl8LCQly9ehWLFy+Guro6RCJRmR1sFxcXZo4/bdq0GifYleHh4YEuXboAAAYMGABtbW1G30W8qH/kyBFGSO3mzZtQV1eHlpYWhEIhtLW1ERYWBl9fXwQFBcHb2xv16tWDr68vNDQ0ZD4Pk3nSLd4NoCgKkyZNQlBQULkSq9zcXAQFBQH4Wmotxs3NjUm6K+oXqAlpaWkVNstnZWVBQ0MDSUlJUhlHUh48eAA2m42FCxeCpmls3LgRenp60NbWxurVq6vcCb537x7s7e2ho6OjtHZYRUVFmDlzJgQCAerVq4ejR4/KPQY/Pz/07t1b7uN+bxQXF6NLly5gs9nYtm2b3Mbt1asXNDQ0alVeKXZTkIfY27fIyMiAubk5fH19vyvhtFevXiE5OZmxpLK0tCyz8iwUCtGhQwfs2rWrWn2xNE3D3d1dqn1o1eHz58/YuHEjQkNDwWKxIBAI0LFjRxw5cqTKJGrXrl0ghGD27Nm1Gr+wsBB79uxBZGQkWCwW1NXV0bdvX1y8eLHMxOC3336Dl5cXo+j6XzGbH4VPnz7B29sbOjo6uHbtmlSumZOTA39/f+jp6VW7/SknJwcxMTGgKIp5nteWmTNnMiJ4/xUCUqFCxY9HYWEhOBxOjdr67O3tmY3OqigoKMDVq1exatUq9O/fH56enoyKOIvFAovFQtu2bbFkyRJcvHgRubm5jFhZYGCgTBLYiRMnQldXFyUlJXj37h1EIhEjjC0QCGBubo4GDRpg69at1RJSy83NZeYmhBCJKplqgsyT7nbt2jHb+CKRCK6urujUqRMuXboELS0t8Pl8UBQFLpcLV1dXGBsbw8TEBLGxsUyJmDQV5R48eFDhrsmCBQvA5XIVKmLUt29fGBgYMBPRzMxMpuc5ICCgyt7TT58+MeJ0ixYtUqpds0uXLsHV1RUURWH06NFSX/mqLlZWVpUK6KmoHkVFRejQoQM4HA527dolt3HFwhkbNmyo8TUOHDgAiqIQHx+v8O+HWDjNyMgIr1+/Vmgs0qCgoAC7du1CREQEKIqCmpoa3N3dGV0ODQ0NdO7cGXv37kVubq7E1z948CAIITJvByguLsbRo0fRuXNnqKmpgcViISQkBBs2bEBWVtY3z7958yaEQiE6d+5c48/Y3bt3MXr0aBgYGIAQAj8/P6xbt65cJcCNGzeYMjl/f3+p2WHVRT58+AAvLy/o6urWSuvh3xQUFKB58+bQ1NSs9q75ixcv0LBhQ2hqakp9YXnhwoXMxFDRTgsqVKhQPM7OzpU6MVVFt27dymxwAl/vd3/99VeFCTabzYarqyt69eqFpUuXIiUlBWw2G8nJyeWuLS7TvnLlSo3fV1X8+eefIITg4sWLAID58+eDoijGu3zEiBGMJaOXl1eVQmoA0L17d2hpaTFVbLLWlpJ50n369GlwOBz4+PhAR0cH3t7eTCkCi8WCmZkZ7OzskJiYiK5du4LD4TD9fYcOHUJiYiK4XK7URGCuXLlSTg29pKQEVlZW6Natm1TGqCkvXrwAj8cr90E+e/YsHB0dweFwkJiYWGnSWlJSgtGjR4MQgt69eyt89yw7OxtDhw4Fi8WCl5eX1HYfagJN01BTUyvT/6FCMgoLCxEXFwcul4v9+/fLbdy0tDTo6ekhLi6uxonMxYsXIRAI0K5dO6UQHhwxYgQ4HI5SCoRJwo0bNzBixAjo6uqCEAJzc3OmuklTUxNdu3bFgQMHat2yQ9M0vLy8KvQBrS00TePq1auIj4+HoaEhU749c+ZMiVTtMzMzUa9ePXh4eEi8sPDlyxds2LCB8dDW09PDqFGjKty1fvbsGbp27cr0k+/bt0/hi0iK5MOHD/Dw8ICenh5u3rwplWsWFxejTZs24PP51bavvHTpEoyMjGBlZSWRJ60k/PLLLyCEIDIyUinuYypUqFAcHTt2RHBwsMTnzZ8/HxwOB0uXLkW/fv3g4eFRaYJ96dKlMs8zmqYRFBQEBweHcjlGVlYWDAwM0L1791q/t8ooKSmBrq4uU5VcWFgIe3t7piKtV69e6NGjB6Md8+TJE2zevLmckFpRUREGDRoEPp8PR0dH7NmzB4QQPH78WGaxA3JIugsLC5kdqosXL0IkEsHAwABjxoyBvb19OSG1zMxMjB07Fmw2G76+voxYgLR6f8UiAv8uURXvoimD9/WIESMgEonKrWQXFBRg2rRp4PP5qFevHo4cOVLpNTZv3gw+nw9/f3+59kz/m3379sHU1BTq6upYuHAhiouLFRKHmOzsbBBCvhubNXlTUFCAli1bgsfj4fDhw3Ibl6ZpREZGwsjIiOlflZT79+9DT08PQUFBSqHgvHnzZrmqvUubDx8+YOnSpfDw8AAhBOrq6kzSLRKJ0KNHDxw+fFjqi35i9eZvWS5Vl+fPn2P69OlMaZmRkRFGjRqF69evS5zEFhUVISQkBAYGBnjx4kW1zqFpGqmpqejfvz80NTXBYrEQHh6O//3vfxX+7TIzMzFy5EjweDwYGxtj9erVCr+vKpr379/D3d0d+vr6uHXrllSuWVpail69eoHD4VT7Xrd9+3bw+Xw0btyYsceRBTRNM7Zw3bt3/+H//VWo+JGZNm0adHV1q3xe5efn48qVK1i5ciWTYIs3N9lsNtzc3NC7d28sW7YMly5d+uYC+aZNmyp9DicmJkJNTU3meiKdO3eGp6cn8//iuYGmpiY8PDzQvHnzMu3JkZGR2LRpE2bNmoVOnTph8uTJzJylefPm+PDhA+bPnw8ulyuRFWRNkHnSnZWVBUIIFi5cCF1dXXh7e8Pb27tSITXg60p+aGgotLW14enpKdXVB3GCLR4bAIKCghAYGCiV69eW9PR0CIVCjB8/vsLXHz16xIgUtG3bttLS1MuXL8PExATm5uZyXUx49eoVYmNjQQhBy5Ytqz0BlTUPHz4EIaTauxYq/o+8vDxERERAIBDg+PHjch1b3INd1SJTVaSlpcHKygoNGjRQipLMuiqcJrbH6tixI7hcLiiKYmyytLW10bt3bxw9ehSFhYUyi4GmaXh7e6Nx48Y1/ttlZWVh3bp1jFilUChE165dcfz48VolMOLKheqIvb1//x6LFi2Cq6srCCGwsLDAzz//jOfPn1d4fG5uLqZPnw4tLS1oamoiOTlZYS06ykRmZibc3NxgYGAgtZ1lmqYRHx8PFotVLb2K0tJSRuise/fucqkuE9uastlstG/fvsYibSpUqKjb7N+/v8ymZH5+PlJTU7FixQr07dsX7u7uZRLshg0bok+fPli4cCHYbDZjR1hdPnz4AAMDA3Tu3Lnca0+fPgWPx5OqvXNlpKSklOm/pmkazZs3B5vNhrq6OnJycrB9+3ZwOBxs2LABampqTAIu3ijg8/mMqnmLFi1gbW0NNzc3mccu86S7pKQEhBA0atQI9erVg7+/f5VCasDXpLtt27Y4ffo080eq6S7XfxHb84gfVFevXgUhBHv27JHK9aXBhAkTIBQKK92lpmka27dvh5GRETQ1NbFkyZIK1ZzfvHkDb29vCAQCmSs1l5SUYMmSJdDQ0ICJiQl2796tVEnF+fPnQQjBvXv3FB1KnSI3NxdhYWFQU1OT2g5jdXnw4AGEQmGN1Xo/f/4MT09PmJqaKsXiT0ZGBiwsLODj46MUO+7V4cmTJ0hKSmI8tcUlaDo6OujXrx+OHz8u10n/sWPHQAjByZMnq31OUVERDh06hPbt2zMaIs2bN8fmzZsrVUyXhA0bNnyzcqG0tBSnTp1Cp06dGKuvdu3a4ddff61Uib+4uBhr1qyBiYkJuFwu4uPjGZXWH513797B1dUVhoaGUhWOmzJlSrWrUHJzc9GhQwcQQjBjxgy5Pe9mz54NdXV17NmzB1wuFzExMQpvJVOhQoV8yc/Px+7du0EIQURERJkEm8PhMAn28uXLcfny5XI72O7u7ujTp49EYw4cOBBaWloVio21b98epqamclkQfvfuHVgsVhmNH3F5OEVRWLZsGeLi4uDh4YG0tDSEhITg8+fPOHToEHr16oXi4mJkZGTg8ePHaNu2LU6cOAFCCOzs7GQeu8yTbgBwdXUFi8WClZUVnJycEBQUhA4dOuDChQvQ1tZmBNWaNWuGzZs3o0OHDtDV1YWvry+cnZ0hFAql1r+0aNEiqKmpMf/fvXt3WFlZ1cqCSNp8/PgRIpEIw4cPr/K4T58+YdCgQcyiRkU903l5eejWrRsIIRg3bpxM3ufNmzfh4+PD+KlXR3BI3ogVhZVht7OukJOTgyZNmkBdXR1nz56V69hFRUXw9vZG/fr1a3QTLyoqQosWLaClpSW1stPaUFRUhCZNmtQJ4bTc3Fxs3ryZUcRmsVjMjvaAAQNw6tQphe2u0TQNX19f+Pn5VZnk0DTNqJbq6+uDEAI3NzfMnTtXqmKZly5dAo/HQ//+/SuM59WrV5g2bRpj9eXk5IT58+dXuYhM0zT2798PR0dHxjqyNor93xvp6elwdnaGkZGRVEVvFi1axCTQ3+Lt27fw9vaGUCjE3r17pRZDdfjjjz9ACMG1a9dw7NgxCAQCtGjRokYChSpUqFB+8vPzcfnyZSxfvhx9+vRBw4YNmQSbEAIzMzP07dsXK1asQGpqarUW9fv37w9XV9dqx3D58mWwWCwsWbKk3GsXLlwAIQSbNm2S6H3VBl9fX7Rr1475f3HiHBsbCz6fjxkzZnxTvfzZs2eIioqCmZkZLCwsyomsyQK5JN2xsbHgcDgQiUQIDAxEgwYNoK2tzUzodHV1ERYWBm9vb6YMQigUIiAgADY2NlJVlJs6dSqMjY0BfH1wcrlczJ8/XyrXlibTp08Hj8ertOTw31y8eJFRB4+Pjy+3e0PTNObOnQuKohAdHY3s7GypxJibm4uEhASw2Ww4Ozvjzz//lMp1ZcHSpUvB4/GUavddmcnOzkbjxo2hqamJP/74Q+7jT5kyBWw2G5cvX5b4XJqm0bNnT3C5XJw+fVoG0UlOfHw8OByO0ipM0zSNixcvIjY2lhG6JIRAS0sL/fr1w++//640/aPHjx8HIaRCD+ynT59i6tSpsLe3ByEEpqamSEhIkMnCy5s3b2BiYoLGjRuXKasvKirC3r17ERUVBYqiIBQK0adPH/z555/fvP/88ccfCAgIACEE4eHhUlPi/l5IS0uDk5MTTExMpFq1JK6AS0xM/Oa/0fXr12FmZgYzMzOFiIPm5+eDx+Mxk9/Tp09DKBSiadOmMu9HVKFChWzJy8srl2Cz2WxmB9vd3b1Mgi3+f0lZs2YNKIqq1qZGcXExPDw84OHhUW7jrrS0FI0aNYKXl5dcxR2nTp0KLS0tZgNAnHTfvn0bIpEIIpEIdnZ2VaqXHz16FEKhEJaWlhg1atT3k3RHRkYiMjISNE1j/PjxIITA2toaiYmJcHBwKCOm9vDhQ/z000/Q1NSEo6Mj0wxfG6ugfzN69GjY29sDAJKSkqChoaGUO7M5OTkwNDSsdvlHUVER5syZA6FQCDMzM+zdu7fc5OHYsWMQiURwcnLCw4cPaxXf8ePHYW1tDT6fj+TkZJn2ckqDiRMnwsLCQtFh1Ak+ffoEX19fiESiGiW9teXy5ctgs9k17g1KSkoCIUSuHuJVsWXLFhBCsHz5ckWHUo43b95gyJAhjKiI2N6re/fuOHfunFJVAImhaRr+/v7w8fEBTdP4+PEjVq1axSh/q6uro0ePHjh16pTM4s/Pz4evry/MzMyYNqD79+8jISGBUUD39fXFmjVrqrXIeefOHcTExIAQAg8PD5w6dUomcddl3r59C0dHR5iamuLBgwdSu+7evXtBURQGDBjwzYR73759EAqFaNSokULtRf39/dGxY0fm/y9cuABNTU34+/sr5XxGhQoV5cnLy8OlS5ewbNky9O7dG25ubmUSbA8PD/Tr1w8rV67ElStXKtzB7tGjRzn7r+pw8+ZNEEKq5aCyZMkSsFgspKamlntNPL+R94aCuDVYXIUptgwbP348Vq1ahbCwMKYKuF+/fvD398fQoUMRFBSEvXv3Mq9raWnh5cuX6NmzJxo2bCjzuOWSdAcFBaFbt26YNm0aCCGYMGEC/Pz8qhRTu3fvHjQ1NWFiYiJVq6f+/fvD29sbeXl50NfX/2YJtyJZtGgRKIoq1wNfFc+fP0fLli0ZIbP/7pTfv38f9vb20NbWlqgvUkxGRga6dOkCQghCQ0NrnbzLi379+sHb21vRYSg9Yr9bHR0dhaj5f/nyBXZ2dozYoqSIPSLnzJkjg+gk5+rVqxAIBOjTp4/SVFkUFBRg+vTpjIc2IQRqampo3bo1zp49WyesiI4ePcr4U/N4PFAUhYiICGzbtk3mPWU0TaNXr17g8/k4f/48Nm7ciMDAQMaiJD4+Hn///Xe1rvXq1Sv07dsXFEXB2toa27dvrxN/f3nz5s0b2Nvbw8zMTKrPnFOnToHH46Fjx45VLtDQNI2ZM2eCEIIOHToovJR7zJgxMDc3L/O71NRUaGtro1GjRowbjAoVKpSDqhJsLpdbrQS7IubMmQMNDQ2J5xfFxcVQU1P7ZqXv27dvoaWlVaG2zpcvX2BmZoa2bdtKNLY0KC0thZGRERITEwF8zX04HA5cXFzg6uoKLpcLoVDIVFX/90dLSwtWVlZo3LgxsrKyIBAImGvJErkk3S1atGBWFcaPH4+goCAmkSwtLUVaWhrTFyz+oK1fvx5dunRhdmDWrFkjlVg6dOiAsLAwrFu3DiwWS6mTxvz8fFhYWJRZ0a4ONE1j7969MDMzg1AoxNy5c8skMJ8+fUJERAQoisKiRYuq9WWlaRrr1q2Djo4O9PT0sHnzZqVJIqpDy5Yt0apVK0WHodRkZmaiYcOG0NfXl5rfraQMHjwYampqEi00iTl48CAoisLw4cOV4rP57t07pRFOKy4uxvr169GwYUNQFMU86ENDQ3H8+PE6kejRNI0///wTgwYNYh6kQqEQCxYskKs1orj3NyQkBJqamoztyM6dO6staPXp0yeMGzcOAoEA+vr6WLx4sUoMqxJev34NOzs7mJub49GjR1K77sWLF6Guro7IyMgqK7UKCgoY39fJkycrxXdFrFr8Xx/5GzduQF9fH25ubjK1LlOhQkXl5Obm4uLFi1i6dCl69eoFV1fXMgm2p6cn+vfvj1WrVuGvv/6q1b1fvABdnVbU/xIQEIBOnTpVeUznzp1hYGBQoR7SlClTwOPx8OTJE4nHlga9evVierRnzpwJLpcLPp+P6OhoeHh4wM3NDSEhIYiOjoatrS2MjY2xbds2hIWFYcGCBfDz8wOXy2Xa0aZPny7zmOWSdA8ePBjq6urQ09ODSCSCq6srYmJimH7gf68+8Hg8WFtbQ1NTE15eXkxf3IEDB6QSS0REBNq0aQMXF5c6kYStXbsWhBDcuHFD4nM/f/6M+Ph4UBQFNzc3XLp0iXmtpKQEY8aMASEEvXv3rvJLf+/ePQQHB4MQgh49etRJBV1xiYmKiklPT4eLiwsMDQ2lZr8jKeKHR038qy9dugQ1NTW0bdtWKUqii4qK0LRpUxgaGsrcs7KqGPbt24egoCBGdIWiKHh6eiIlJUUpFiaqw8OHDzF58mRG38PCwgLjxo3D+vXrQQjBoUOH5BLHhw8fMHToUOZZZW5ujkmTJkkkcpafn4/58+dDV1cXQqEQSUlJUtPY+B559eoV6tevD0tLS6lO7G7dugVtbW0EBQVVuWv97t07NG7cGHw+X+YOIJKQkZEBQgh27NhR7rV//vkHxsbGcHR0VGgJvAoVPwL/TbBdXFwqTbCvXr0q9cXVFy9e1NhWNT4+Hra2tpW+furUKRBCsHnz5nKvvX79GkKhEAkJCRKPKy3EAskvXrzAoEGD4OzsDC6XC39//ypF1P5djh8aGgp9fX1oaGh8PzvdZ8+eBZvNRmRkJHR0dBj7mW/9qKurQyAQMDuy0sDf3x8tWrQAIQS///67VK4pS4qKimBnZ4fo6OgaX+Pq1avw8vICi8XCoEGD8OnTJ+a1LVu2gM/nw9/fv9xuUUFBAbOSZWtrW6f7DC0sLJCUlKToMJQSca+ktMWJJCEzMxNGRkaM9oMkPHjwAHp6eggMDFT4jrIYRQmnFRYW4tixY4iKiiojiGZtbY1Zs2Ypzd/nW2RmZmLZsmXw8/NjSsH69OmDM2fOMDuNNE0jODgYnp6eMltAKC0txenTp9G5c2fm72loaIjDhw9LtLhTUlKCLVu2wNLSEmw2GwMHDqzQdkXF//HixQvY2NigXr16UlVvf/ToEYyMjODp6Vll//Pt27dhZWUFIyOjMgvWykL9+vXLtOT9m4cPH8Lc3By2trZKYZeoQsX3QG5uLv78808sWbIEPXv2hIuLS5nKMS8vLwwYMACrV6+WSYJdETRNQ1NTE7NmzZL43K1bt4IQUmE7SkFBAezt7REUFFTh87Vnz57Q19dXqIbEp0+fwGazsWrVKvTq1Qve3t6M64q+vj7evn1boYiauNX0wYMH0NDQgIWFBRwcHOTSbiyXpPvgwYMghODWrVvMJOrfPzo6OrCyskLLli2hp6dX5jUOhwM/Pz80b95cKrE4OzszJuh1Zadnx44dIITUSh28pKQEixcvhqamJoyMjLB9+3bm/aempsLExATm5uZMH+/58+fh6OgIDoeDCRMmlPP4q0vQNA0ej4elS5cqOhSl49WrV0zppqJaLWiaRlxcHPT09CRORNLT02FtbQ0nJyel6WMUC4ssW7ZMLuMVFBTgyJEjaNeuHQQCQZn76tChQ+vMpFvsOxoTEwMOhwMOh4OWLVti586dld5/zp49C0KI1CqhxLx+/RrJyclM37u9vT1MTExQr149iT5nNE3j119/ZQRB27ZtW6PWiR+N58+fw9raGlZWVnj27JnUrvvq1SvUq1cPjo6OVdq2HT16FJqamnBzc1Pa70/Pnj3h4eFR6etPnz6FtbU16tWrh8ePH8sxMhUq6j7iBHvx4sXo0aMHnJ2dmQSbx+OVSbCvXbumUDFhf39/dOvWTeLzHjx4AEIITpw4Ue615ORkcDgc/PPPP+VeE4uY1aQqUdoEBwcjJiYGQ4cOhZ6eHlJSUrB582YQQuDg4ICuXbsiICAAI0aMQGhoKICvNtaDBg2Curo61NXVcfXqVRgZGWHSpEkyj1cuSfeGDRsY4S3xhJCiKPz888/MP6hYSC0/Px8pKSll1HT5fD6cnZ2lEouxsbFU1dDlQWlpKdzc3NCkSZNaLxS8fv0abdu2ZSxpxA/jN2/ewMfHBwKBACEhIYxIkaJKjaXJx48fQQjB7t27FR2KUvH8+XPY2NhIvXRTUsR2PZL63ebk5MDLywsmJiY16meSBdeuXYNAIEDv3r1luqiXn5+PgwcPokuXLhAKhcy9ksvlIiYmBmfPnq0Ti4qlpaU4d+4c+vXrB5FIBEIIvL29sWTJkiqTon8TEhKChg0b1rrXtqioCPv370d0dDRj9dW7d29cuHAB7dq1g7q6ukT3wytXrjD30qCgIKXcLVVGnj17BisrK1hbW0s14X337h0cHR1haWlZrhdaDE3TWLhwISiKQqtWrcrZbyoTYsufqmJ89eoV7O3tYWpqqrAqJhUqlJ0vX77gjz/+qDTBbtSoEQYOHIg1a9YoPMGuiP79+8Pd3V3i80pLSyESiZCcnFzm90+ePKlUWIymaQQFBcHZ2VkpbERnzZoFoVCIfv36gRACPz8/ZpHbzs4OFEWBxWKBx+NBV1cXdnZ2zIauubk56tevj/Pnz4MQIpdqXrkk3eJVh3/vXv93ZyI3NxdBQUHM/3/+/JnpIyaEQFtbWyqx8Hg8qKur15kySzGHDh0CIaRGiuMVceTIEdSrVw8CgQDJyckoKCjA5s2bmZ2y8PDwGqlHKyN3796ttjXCj8KTJ09Qr149WFtbKzRhffr0KTQ1NdGzZ0+JzisqKkJERAQ0NTUVJvr2X969ewdLS0t4e3vL5P6Sl5eHffv2lUm0xb1jDRs2xNq1a+tMf/C9e/cwceJE1KtXD4QQWFlZISkpqUa7wOIHpqSLNmIePHiAxMREpu3Jx8cHq1evZv6WycnJIIRg37591breo0eP0KFDBxBC4OzsjMOHD9eJBRBl4MmTJ7C0tIStrW2liXFNyM7OhpeXF4yMjCqt6CkqKsKAAQNACEFCQoJSaENUxZ07d0AIwW+//VblcWlpaXB2doahoWG1VfVVqPheESfYixYtQvfu3dGgQYNKE+zr168rXYJdEYsXLwafz6/RPatZs2aIjY1l/p+maURFRcHCwgI5OTnljt+zZw8IITh+/HhtQpYaf//9NwghqF+/PtTV1dGvXz/ExcVBTU0NAKCpqQkbGxvY2dlBV1cXI0eOhJOTEzw9PeHn5wdXV1e0a9cOPB5PLu0Ackm6jx8/Xibpnjt3LoCv/YcFBQVIT0/HsmXL0LJlSzx8+JApJfz06VOZvsTalpm9f/+esdKqa9A0DT8/P3h7e0ttAvflyxckJiaCzWZDXV0dhBC0adMGkyZNAkVRiI6OrjOT+Kr4/fffQQhRaqV6eSLu97Ozs1OYyBfwteUhKCgI9erVk+hzJrZs4nK535xwyovi4mKEhIRIXTgtNzcXu3fvRseOHZlEW01NDYQQ6OnpISEhAXfv3pXaeLIkIyMDixcvRqNGjZiF1AEDBuD8+fO13qUOCwuDq6trta+Tm5uLzZs3IygoiLH6GjFiBG7dulXmuMOHD4PFYlXLMz4jIwNDhw5lVtA3bNig9ImbMvH48WNYWFhI/b6Ul5eH4OBgaGtrV7pA9+HDB4SGhoLL5WL9+vVSG1uWlJaWQltbG7/88ss3j83MzIS7uzt0dXVx7do1OUSnQoXiycnJwYULFypMsPl8Pry9vTFo0CCsXbu2ziTYFfHbb7+BEIIHDx5IfO748eOZXmcA2LdvHwgh2L9/f7ljCwoKYGNjg8jIyNqEK1VomoaZmRkoikLLli3B4/EwZ84ceHl5AfjqXPT582ekp6cz5eWNGjVizo+MjGQ2L+QxH5ZL0n3hwoUySbdIJIKBgQFGjhwJFotVrsdbU1MT1tbWEAgEcHFxYX4/bty4WsUh9glfvXq1lN6ZfDl9+nSlX4aaUFxcjLlz54LP5zOLG71798b79+/x66+/QiQSwcnJqc4nq+KeeGUuFZQX9+7dg4mJiVIo286aNQssFgvnzp2T6LxJkyaBEIKtW7fKKDLJGTlyJDgcjsTvpSJycnKwc+dOtGvXjkmwtbW1mT7n1q1b4+DBg3WiEiUvLw87duxAdHQ02Gw2uFwuYmNjsWfPHqlWA/zxxx/fbCGhaRp//fUXBg0aBC0tLRBCEBYWhh07dlQYy927d6GpqYnWrVtXmcx//vwZU6ZMgYaGBrS1tTF79uw6rYGhCB49egRzc3PY29vj9evXUrtuUVERoqOjIRQKK9VEefDgAezs7KCnp4ezZ89KbWx5EBUVhfDw8God+/HjR/j4+EAkEuHixYsyjkyFCvkiTrAXLlyIbt26wcnJickv/p1gr1u3Djdu3KgTz8/qkp6eXuNqL3GS/fr1a+Tk5MDCwgLR0dEVbu7NmTMHbDZb6Rb6+/TpA0IIVq1aBU1NTVhYWDBK5StXroSZmRmMjY1x9OhRAECbNm2QmpqK1NRUsNlsWFpaghCCO3fuyDxWuSTd48aNYxLnlStX4v79+9DR0WEUyjdu3IgrV67gxo0b+PXXX9G9e3ew2WywWCzExcUxdjeOjo41jqG4uBimpqYghODXX3+V4ruTL2FhYXB2dq71DsqVK1fg7u4OiqIQHx+PrKwsrFq1Ctra2tDX18emTZtw7949ODg4QFtbW2pl7Ypg4cKFUFNT++FLPG/fvg1DQ0M4OzsjPT1dobHcuHEDXC5XYouG1atXgxCC2bNnyygyyUlJSQEhpFZCfZ8/f8b27dsRFxfHtHiYmJgwfc5OTk6YN2+ewv/dqkNpaSl+//139O7dm/Gx9vf3x4oVK/D+/XuZjRseHg5nZ+dyCfLHjx+xdOlSNGzYEIQQmJmZISkpqUodg0+fPsHOzg7Ozs6VLtYVFRVh+fLlMDQ0BJ/Px5gxY5RGzK8u8fDhQ5iamsLBwUGqiu4lJSXo1KkTuFxupc+v06dPQ0dHB05OTnVSbGz69OnQ1NSs9nwgOzsbgYGB0NDQkMoCoQoViiAnJwfnz5+vNMH28fHB4MGDv8sEuyJomoa+vn61ql7+y6tXr5jNvISEBAgEggrdIjIyMqClpYWhQ4dKI2SpsmrVKrBYLPTo0QOLFy+Go6Mj2Gw2pk6dCmdnZ+Tl5SErK4txOklNTYW9vT04HA60tLQwe/ZsEEKk2tJUGXJJusWrEOK+OF1dXejr62POnDlwcHBAcHAwOnfuzExYSkpKEBERwfR0i0XV9PT0ahzD7t27mRjq8irv5cuXa7XL9/nzZ4wYMQIURcHd3R1//fVXmdfT09PRpUsXEELQtGlTpKamIiIiAhRFYeHChXUycR03bhysra0VHYZCuXnzJvT19dGwYcNqC1TJivz8fDg7O6Nhw4YS9dAcOnQIFEVh2LBhSvM5FAun9erVS+KYsrKykJKSgpiYGPD5fBBCYGtrC1tbW6biZ8CAAbh8+bLSvN+q+OeffzB27FiYm5sz7+Xnn3/Go0eP5DL+pUuXQAjBzp07GauvLl26gM/ng8PhIC4uDkePHv1mglJSUoLIyEhoa2tXGDtN09i1axfq168PFouFnj17Kq3CtbJz//59mJiYwMnJqZxlZW2gaRoDBw4ERVHYs2dPhcesXr0aHA4H4eHhCrW9qQ1i9f7/tkVUxZcvXxAWFgY1NbU6vZiu4sdAnGAvWLAAXbt2haOjY5kE29fXF0OGDMH69etx8+bN7z7BroymTZuiffv2Ep9H0zSMjY3Rv39/cDiccqJqYgYPHgyRSITMzMzahip1xJWGdnZ2cHV1BZfLBZfLZT4nOjo6aNmyJfT19dGsWTOwWCywWCzY2toiKioKP/30EwQCgVzaC+SSdPfo0YNJeE1NTeHo6IhGjRqhqKiI2fkQq5eL/3vr1q3YsGEDmjdvzpyrpaVV4xgCAgLg7u4OQkiFEvh1iZiYGNjY2Eh8czl48CDMzc0hFAoxd+7cKpUHT548CVtbW/B4PEycOBGjRo0CIQS9evWSi9iANOnVqxf8/f0VHYbCuHbtGnR1deHl5aUUO3GjRo0Cj8eTSAn68uXLUFNTQ1xcnNL0yWZmZsLS0hKNGjWqdqn0x48fsWnTJkRHRzMtHa6urvD392d2hUNCQrBlyxbk5ubK+B3UnrS0NMyfP5+5t+rq6mLw4MG4ePGiQhYKQkJCYGBgwFh9OTg4YM6cORJVCIwbNw4URVVoo3LmzBl4e3uDEIKoqCiVMFUtuHv3LoyNjdGgQQOpV3CIq+sqcikpLi5GfHw8CCEYNmyYUijw1pTc3FxwOByJrXvy8vIQFRUFHo+Hw4cPyyg6FSok4/Pnzzh37lyFCbZAIFAl2FUwbNgwNGjQoEbntmrVCtra2nBwcKhwfv/PP/+AoijMmzevtmFKnaKiIsZqmsViISIiAh4eHvDy8oKDgwMiIiKgrq4OFosFAwMDGBsbo0mTJggMDISpqSlWrlzJtJt9Nzvd4gecWG3X29u7nEqtWL28pKQE0dHRKCkpwcaNG7FkyRIEBweDzWajXr16NRo/NTUVhBCmF1SR4lHS4NatW2CxWNXuTX/9+jXatGkDQggiIyOrLUiXl5eHpKQkcLlc1K9fH2PHjgWfz4e/v79UdyVkTUREBFq3bq3oMBRCamoqtLW14evri0+fPik6HEbwY/78+dU+5+HDh9DX10fjxo2Vple2uLgYoaGhMDQ0/OaN+v3791i/fj0iIyOZ1VcfHx/ExsbC3t4ehBBYWFhg0qRJCrVuqy5fvnzB1q1b0aJFC1AUBR6Ph7Zt22L//v0KEaIpKirCgQMH0LJlS2aCFhQUhAsXLkic+Iv1H/47ubh16xYiIyMZdfMzZ85I8R38eNy5cwdGRkZwcXFBRkaGVK89a9YsEEKwcOHCcq9lZWUxwjnLly+X6riKwtvbG127dpX4vMLCQqZ9r7JqABUqZEV2djbOnj2L+fPno0uXLnBwcCiTYPv5+WHo0KHYsGEDbt26pUqwv8HKlSvB4XBqtCkWFxdXpWVWixYtYGtrq5Qbbg8fPiyTX0ZFRVUporZy5Urs3LkTANCuXTskJSUx5//XVUsWyCXpFpd2s9ls6OrqwsnJCUFBQWjfvj2OHj0KDQ0NRj2Oy+WCz+dDU1MTAoEAQqEQUVFRIIQgIiKiRuN36dIF1tbW2L59Owgh34Uid5cuXWBmZlZlElJaWorly5dDU1MThoaG2LlzZ412n+7evcuU+kdERMDIyAhmZmblStOVFQ8PDwwaNEjRYcidP//8E5qamggICFCKz/zHjx9hbm6OkJCQaqtMp6enw8bGBo6OjkqxSy9m1KhRVQqnZWZmYs2aNQgPDweHwwGLxUJwcDAGDhyIiIgIcDgc8Hg8dOzYESdOnFCa3fvKKCkpwcmTJ9G9e3fG6SAwMBCrV6/Gx48fFRLTw4cPMXbsWMbqy9vbG6tWrUKLFi3g4OAg8d/0+vXrUFNTQ7du3Zj75IsXL9CjRw+wWCzY2dlh9+7ddaLUX5kRa0u4urpKvdVl1apVIIRg8uTJ5V57+vQpGjRoAJFI9F2VVY8cORJWVlY1OreoqAidOnUCm83Gtm3bpByZChVfkTTBrsvVJ4pCLFgtafXVhw8fGO2Yitqpjh07JpFlprwRb6qKBWfFFqRAxSJqT548gY2NDRwcHBASElLGIWvTpk0yj1cuSXdRURHTl62hoYHAwEC4u7tDQ0ODKQmwsbFBcnIyFi5ciJ49e4KiKFAUhYCAAOTk5MDExKRGu5WvX78Gh8PBwoULsWbNGrBYrFrb0ygDjx49ApvNrnTH8O+//4afnx8IIejfv3+tJ8Y0TWPjxo3Q09ODSCSClZUV+Hx+nXhQm5iYVMvy53vi3Llz0NDQQHBwcIVei4qgS5cuEIlE1e5/zcnJQaNGjWBiYqJQL/H/snXrVhBCsGTJkjK/z8jIwKpVqxAWFgY2mw2KohAaGorJkydj6NChMDY2BiEEHh4eWLp0qVItIlTGzZs3MXr0aJiYmIAQAnt7e0ybNq1CoRV5kJubiy1btjCLgDo6Ohg+fHgZK6i//voLhBCkpKRU+7oZGRmwtLSEl5cX8vLy8P79e4wePRp8Ph9GRkZYsWKFaqdFCvz999+MtoS0ewO3b98OFouFESNGlFsYuXDhAvT19WFra4t79+5JdVxFI97UqKkbRUlJCXr16gUWi1Vn7NJUKC/Z2dk4c+YM5s2bh86dOzPVXGK7S39/fwwbNgwbN27E33//rUqwpcTHjx9BCMH27dslOm/gwIFMLvbfc4uKiuDk5IQmTZoo7WLzzZs3mc9XkyZN0K9fPxBCMHr06ApF1Dp27Ihjx45h4cKFoCgKFhYWzPk7duyQebxySbqBr33IhBAUFRXh0KFD4PP5sLCwwJQpUyoUU+vcuTMsLS0Zwa+4uDg0a9ZM4nEnTJgATU1NZGdnY+7cubXqC1c2+vfvD319/TLqunl5eRg/fjw4HA4cHR1x/vx5qY6ZmZmJ3r17gxACAwMDEEIwduxYpd2pKy0tBZvNxsqVKxUditw4ffo0hEIhwsLC8OXLF0WHA+D/ynarKwBYVFSEyMhIaGpq4saNG7INTgKuX78OgUCAnj17gqZppKWlYfny5WjatCkoigKbzUbz5s2xaNEiLFiwAP7+/mV8oJXpvVTG69evMWfOHLi6uoIQAn19fQwfPhypqakKe/Beu3YNgwcPZnqvQkNDsX379kp76Vu1agU7O7tqTeiKiooQHBwMQ0NDPHz4ELNmzYJIJIKGhgZ++eUXpVm0quvcvHkTenp68PDwkLqK/ZEjR8DhcNCzZ89yi+qbN28Gj8dDkyZNZKqeryjevHnzTbu8b1FaWorBgweDEIJly5ZJMToV3zNZWVnVTrBv376tSrBljJmZGSZMmFDt4y9fvgwWi4UlS5bAxsYGI0eOLPP6smXLwGKxcP36dWmHKjUyMjKYz5xQKGTmLWI/dl1dXdjY2MDAwAC7du2Cjo4O8xpFUXBycmLOl0fbmNyS7pkzZ4LD4SA1NRUCgQARERHw9fWtVExN/LsdO3YwqxG+vr4SjZmbmwtdXV3mg5SUlAQLCwspvivF8vLlS/D5fEydOhUAcOrUKUb87JdffpFp/8XZs2fh6OjIfHgjIiKUUgH23bt3UvU2V3ZOnDgBgUCAFi1aKE3/86tXr6CtrY2OHTtWK2mjaRp9+vQBh8NRqjLQzMxM1KtXDw0bNsT8+fMRHBwMFosFDoeDiIgIrF27FgcPHkTPnj0hFAoZUY9du3YpZS/Uv/n8+TM2bdqEsLAwsFgsCAQCdOjQAYcPH1bYDu/Hjx+xbNkyRqTN1NQUEydOrFbf+/Xr10EIwebNm7957NChQ8HlcjFu3DiYmZmBw+Fg2LBhUu81/pG5ceMGdHV14enpKfUKj7Nnz0IgEKB169ZlJvWlpaWMoFrfvn0VojcgL6ysrMpNmCWFpmlGMFUZBZNUKJasrCz8/vvvmDt3Ljp16gQ7O7syyU5AQACGDx+OTZs2qRJsBdGiRQvExsZW69ji4mJ4eHjAw8MDJSUl6NixIxo3bsy8/vHjR+jp6aF3794yilZ6iDcAxW1vampqePfuHdTV1cuUj4ur48zNzdGoUSNGYE08v5DHXEduSfeWLVuY7X9XV1c0bty4UjG1/+Lg4ABCCNMcX11Wr14NFovFTNJGjBgBZ2fnmr8JJWTkyJHQ1NREhw4dmL/vf/+usqKgoADTpk1jxKHMzc3x8OFDuYxdXf7+++86bxNXXY4cOQIej4eWLVtWW01b1pSWliIsLAxmZmbVnmxPnjwZhBBs2bJFxtFVn6dPn8LOzg5cLpfRnoiKimJK5KZPn4769euDEMK0yshDCbM2FBcX49ixY+jSpQvU1NQYm8D169crbAFN7PHdtWtXCAQCcDgctG7dGkeOHJF4Ete6dWvY2tpWed6aNWtACGHK5zt27Cg3i7MfhWvXrkFHRweNGjWSev//1atXoampibCwsDL3vC9fviAuLg4sFgvz589X2tJIadG1a1d4e3vX+jo0TWPChAkghGDatGlSiExFXUSSBPuff/5R2krHH43Ro0fD1ta2WscuWbIELBYLqampAIB58+ZBTU2NeV6OHj0a6urqNW5bkRfialbx57NBgwZlhNSys7Px4MEDBAQE4P3790wl1K5du+Dh4cGcN3HiRLnEK7ek++7du+VKADp16oQvX77AwsICZmZm0NDQgLa2NiIjIxEfH4/OnTujcePGEIlEcHFxgb29fbXHo2kaTk5OZfrAe/bsiYCAAFm8PYVA0zSWLFnC+BWuX79eIZOLR48eoXHjxkwyImlPiSw5deoUCCEK60GVFwcOHACXy0VcXJxS7egsXrwYhJBq71iLk6CZM2fKOLJv8/z5c8ybN4/RRiCEwN/fH1u2bEF6ejp27dqFyMhIUBQFNTU19OjRA2fPnlVqzQiapnHt2jWMHDmSESBr0KABZs6cqVCv6Tdv3mDGjBmMR7mdnR1mz55dK5cEca9XRbZRwP8tyorL1euKMGRd4urVq9DW1oaPj4/U3RPu3r0LPT09+Pr6lmkBePXqFaMZ86PYYa1YsQIcDkdqNoPTpk0DIQQTJkz47hcsfnQ+ffqE06dPY86cOejYsSOzeCyeqzdu3BgjRozA5s2bVQm2krNhwwawWKxvthW+ffsWWlpaZQSGz507B0IIbt26hUePHoHL5TJVtMpMVlZWGRE1Qgj09PRQXFxcoZAa8HUeJC5DF/9cvXpVLvHKLekGvvYbCIVC6OjooEmTJjA0NISZmRmTrBkaGqJNmzaIjY1lypa1tbWxevVqRgStuhPDEydOgBCCs2fPMr+Li4ursQK6svHw4UOEhoaCEAJnZ2eoqanh7du3CouHpmmsW7eOKeWIi4tTivKilJQUEELqhOdxTdm9ezc4HA7at2+vVGJPd+7cgUAgwIgRI6p1/OHDh0FRFIYOHaqwid6TJ08we/ZsxouZz+fDy8sLhBDMnj0bN2/exIgRIxhhSH9/f6xdu1Yp1OGr4sWLF5gxYwYaNGgAQgiMjIwwcuRIXLt2TWF/6+LiYhw8eBCtWrUCm81mFi7Onz8vtZjatGkDa2vrMt+L+/fvIyIiAoQQqKur4/Dhw6rEQgZcuXIFIpEIvr6+Uq+cePbsGczMzODi4lKmgubKlSswNjaGpaUlbt26JdUxlZlbt26Vm+/Ulnnz5oEQglGjRqm+H98J/02wxYucFSXYd+7cUSXYdYwrV66AEPLNBeTOnTvDwMCgTOVRTk4OKIrCunXrEBcXB3Nz8zoxbxYn3a1atWLyRkIIPD09YWlpiU+fPjFCaiUlJTh27BjCw8PLJNyEELx+/Vou8co16XZ0dET37t0BAOvXrweLxUL9+vVhamqKoKCgMkJqTZs2RXh4OIRCIbhcLqMYXN3e3MjISLi7u5d5WISGhqJjx45Sf1/ypLCwENOmTQOfz4e1tTWOHz+OT58+QVtbG0OHDlV0eMjMzETDhg2Z1aZLly4pNJ558+ZBU1NToTHIku3bt4PNZqNLly5KscghprCwEB4eHnBycqpWb3lqaiqEQiHi4uLk/qB/9OgRZs6cCU9PT0YApm3bttixYwf++OMPqKmpwcfHhylFMjIyQkJCAu7evSvXOCUlKysL69evR9OmTZn31aVLF/z6668K/aw8fPgQ48aNY9Tcvby8sHLlSpmUtIvbS9auXYs3b95gwIABjLe4np6eQhcqv2cuX74MLS0t+Pv7S31BKi0tDba2trC1tS3z7/e///0PAoEA/v7+SE9Pl+qYyk5JSQm0tLQwffp0qV532bJlIIRg8ODBSl3Bo6I8Hz9+xG+//YbZs2ejQ4cOZRJsdXV1BAYGIj4+Hlu2bFEl2N8JX758ASEEGzdurPQYcfVnRXonzs7OaNWqlUSit4qGpmlQFIXg4GC4ubkx1Wv/3vUOCgqCurp6GaVy8U+rVq3AYrHkpoEk16Tb2dkZw4cPx549e0AIgaGhIWPPApQVUrO3t8euXbuQnZ0NPT098Pl8EFI9H7V79+5V+KFq1KgR+vfvL/03Jif++OMPNGjQAGw2G4mJiWVWoWbOnAkul4tnz54pLsB/MXnyZObD379//zIK6/JkzJgxsLOzU8jYsmbz5s2gKAo9evRQugfmhAkTwOFwcO3atW8e++jRI+jr6yMgIEBuN7779+8jOTmZWSASCoXo0KEDdu3ahZycHJSUlGD37t2MIBpFUYiNjcXBgweVqprgvxQVFeHw4cPo0KEDBAIBWCwWmjVrhk2bNinsOwh8dVVISUlBkyZNmAqmYcOGyUXNvXXr1hCJRBAIBExvsUAgkFs52Y/GxYsXoampicaNG0v9M/fx40e4urrC1NSUedbRNI0pU6aAEIKuXbsqjZ6FvAkPD0dUVJTUr7tu3TqwWCz06tVL6Z4zKr7y7wS7ffv2sLGxqTDBTklJwd27d1X/jt8xNjY2GD16dIWvFRQUwN7eHkFBQRVWr/Tq1YvZZKgri2xXr14FIQT169fH1q1bmWf9f5Pr//5wuVxs3LgRLi4uiIyMlFu8ck26fXx80KNHD2hpaUFfX7/MThFN07h79y7c3d1x4cIFuLq6Mg38Y8aMgbOzM9hsNnbt2vXNcQYNGgQjI6NyisF2dnYYM2aMdN+UHPj06RMGDRoEQgh8fHzKeNKK+fLlC4yMjNCrVy8FRFgxFy9ehJaWFlgsFgwNDbFv3z65l6l169YNgYGBch1THognQv369VO6m+Mff/wBiqKqteuSkZEBW1tbODg4yNzO586dO/jll1+YXh4NDQ106tQJe/fuZRawnj59ismTJzMromw2GxMnTlTqnTOappGamophw4ZBX18fhBC4urpizpw5ciuZqozr169jyJAhEIlEIIQgJCQE27Ztk8viSkFBARYtWsSMHRERgenTp4MQgm3btsl8/B+RP//8E5qamggKCpJ6wp2TkwM/Pz/o6enhzp07AL4u5nTq1AmEECQnJ//QZdC//PILtLW1ZfI82Lp1K9hsNjp37qzUi44/Ah8/fsSpU6cwa9ascgm2hoYGgoKCMHLkSFWC/YMSExNTaRttcnIyOBwO/vnnnwpf7969Owgh+P3332UZolSJj49n5j2NGzeGh4cHaJqGlZUV2rVrB6FQyHw/OBwOHBwccODAARQXF+PSpUsghCAxMVFu8co16e7atSsMDQ2ZVYmgoCC0adMGS5cuZXay/7sSYWFhAZFIxKgGr1q1qsoxPnz4ADU1Nfzyyy/lXjMyMqoTwgBiaJrGrl27YGxsDA0NDSxdurTKG+iSJUtAUZRSlb2+ffsW7u7uTK9Fq1at8Pz5c7mN37x5c7Rr105u48mDlStXKm3J3+fPn2FtbY2AgIBvljDn5OSgUaNGMDY2lkmFBk3TuH37NiZPnsz0MmtqaqJr1644cOAAk/jl5uYiJSUFISEhzDFubm5gs9lK/fB5+vQppk2bxnijmpiYYMyYMRUuysmTT58+Yfny5Uw5vomJCSZMmIDHjx/LZfzS0lJs27YN1tbWoCgK/fr1Q0xMDAwNDcFisZCQkCCXOH40Lly4AA0NDQQHB0vd27ygoADNmjWDpqYm06+YlpYGX19fqKmp1cqj+nvht99+AyGk0gl1bdmzZw84HI7SiXV+z3z48IFJsNu1awdra+tyCfaoUaOwdetW3Lt3T5Vgq8D48eNhbm5e7vdPnjyBQCCoNMHMycmBnp4eCCEKbwuVhDZt2iA8PByWlpYwMzODu7s7gK/K5Z8/f0Z6ejqaNm2KL1++oHv37vjpp5/QpEkTTJgwAV5eXuDxeJg1a5bc4pVr0n3mzBnG1zYwMBANGjQAh8P5ZhmAeOL2XzXyipg1axZ4PF6FHqsCgQCLFy+W1duTKs+fP0d0dDQIIWjdujVevXr1zXMKCgpgaWmJ9u3byyHC6pOfn48ePXowDwqhUIi5c+fKZcXc1dVVKXrdpYVYDTw+Pl4pd3X69u0LDQ2Nb3opFxcXIyoqChoaGrh+/brUxqdpGjdv3kRSUhJjNSgSidCjRw8cOnSIqX4R7w4PHDgQWlpaIOSrXdaWLVuwYcMGEEKwaNEiqcUlLT5+/IjVq1cjMDCQKR3s3r07Tp48qdAJF03TOHv2LLp16waBQAA2m43Y2FgcPnxYrv3jJ06cYHy9Y2NjmQXI48ePgxACJycn1cRUBpw7dw7q6uoICQn5pnKupBQXFyMuLg4CgYARCrt58yYsLCxgamqqUp3//4iFkNasWSOzMQ4fPgwej4eoqKgftoxfVnz48AEnT57EzJkzK0ywg4ODyyTYyrbgrkI52LZtGwghZdwiaJpGVFQULCwsKl0QTUpKAo/HA4/Hw5IlS+QUbe2JiIhAdHQ0QkJCoK2tDaFQiIyMjAqVy8PDwzFnzhx8+PAB+vr6EAqF0NXVlas9olyT7oyMDBBCsHPnTma37t8/GhoasLe3x+DBg9G2bdtypub169eHQCCo9PpFRUUwNzev0My9sLDwmwIDykBxcTEWLFgAdXV1mJqaYt++fRKdv379ehBCqtVLK09omsaCBQvAYrFgZWUFiqLg5uYm8xU1Q0PD78ZvVKwmO2bMGKVMuPfv3w9CCNatW1flcTRNo2/fvuBwONW2EvvW9a5du4bx48czdic6Ojro3bs3jh49WmZXJiMjA/Pnz4ezszMIITA3N0dSUhKzC3vjxg1GRVtZ/saFhYXYv38/c0+kKAotWrTA1q1bpZ7gSMrbt28xc+ZM5u9ev359zJo1S+4CZdeuXUOzZs1ACEFAQAD++OMP5rWcnBy4uLhAQ0MDpqam5dqOVNSOM2fOQCgUIjQ0VOpqt6WlpejVqxc4HA5j/3Xw4EGoq6vD09NT4e0TyoaHhwd69uwp0zFOnjwJNTU1hIWFKfz+U1d5//49Tp48iRkzZqBt27awsrJi5rmampoIDg7GTz/9hG3btuH+/fuqBFtFtRE7Gfz7Gbhv374qhahfvnwJgUCAcePGwdvbmxG8rgv4+vrCysoKKSkpuHbtGjgcDrS1tWFgYIDbt28zyuU0TSM6Ohq9evWCvr4+1NXVkZiYCB6Ph6VLl8otXrkm3ffv3wchBNOnTy+jMBcbG8tMvv8tppaRkVHuWEJIpf2AO3fuBCGkQquQzMxMEEIkTmLlybVr1+Dp6QkWi4Vhw4bVSPW1uLgY9vb2chUGkITjx49DW1sbVlZWcHZ2BovFwuDBg6Xu4Qp8/VuwWCysXbtW6teWNzNmzAAhyuubmp6eDn19fcTExHwzPrHoUUXqmdWFpmlcuXIFiYmJTE+bnp4e+vXrh+PHj5epoiguLsahQ4fQunVrcDgc8Hg8dOzYESdOnCiz6/n+/XtYWVnB09NTboJulUHTNC5evIjBgwcz9mQeHh5YsGCBwhW3xX/PmJgYsNlsCAQCdO/eHefOnZP7Z/PJkyfo3LkzCCFwdHTEgQMHysRQWlqKNm3aQENDA0eOHAFFUVi2bJlcY/yeOX36NNTU1NCsWTOpJ9w0TSM+Ph4sFgvbt28HTdOYPXs2WCwW2rZtq0r4KmDYsGGoX7++zMc5e/YsU96s7HaJiub9+/c4ceJEpQl2kyZNVAm2CqlRUFAANpvNtOLm5OTAwsIC0dHRlT6fxa2/2dnZGDJkCBwdHeUZco2haZrR32ncuDGjXu7i4sK0tPJ4PHC5XGZjgMViwczMDI6Ojpg0aZJMW3IqQq5J95MnT0AIgYGBAXPT6du3b5kPQm5uLoKCgpj/f/bsGby8vKCurs6cc+LEiQqv7+fnh9DQ0CrH/u2336T7pqRATk4OfvrpJ1AUBVdXV1y+fLlW1/vf//4HQgguXLggpQily4MHD+Dg4ACRSIRBgwZBQ0MDxsbG2LFjh1Qn7W/fvgUhBIcOHZLaNeXNv5V5p0yZopQJN03TaNmyJQwNDSts6/g3a9euBSEEM2bMqNE4ly5dwujRo1GvXj3mXjJw4ECcOnWqXLvCvXv3kJiYyFhTeXh4YOnSpWV8fcUUFxcjLCwM+vr6ePHihcSxSYtHjx7h559/ZuxdzM3NMXbsWLk+FKqKbfz48TAxMQEhX30wV6xYIZMFs2/x7t07jBgxAlwuF6ampli7dm2FZexTp04FIQQHDhwA8FUoxtTUVFUaKwV+++03qKmpITw8XCaLVOL73sqVK1FYWIjevXuDEIKJEyeqEpNK2LFjBwghchF+vHjxIkQiEXx8fMr4/f7IiBPs6dOno02bNsxzSpxgN23aFKNHj8b27dvx4MED1edYhUxwcnLC8OHDAQAJCQkQCAR4+vRphcempqaCEMK0pWzcuBEsFqtOLKb99ddfzHdr9OjRiIuLg5qaGoCvVa42NjYwMjKCuro6Ro8ejaioKPj5+SE4OBj9+/dH48aNK+x/lyVyTbrFPUfim5CXlxdomkZhYSEKCgpQWFiIuXPnIiQkBHv27MG5c+cwa9YsrFy5Eps3b2bOa9OmTblri1XoKkuwrl+/DkK+bRovb44cOQJLS0sIBALMmjVLKn3OpaWlaNiwIYKDg5UySQO+eghHRUWBoihMmjQJbdq0ASEE4eHhUhNcunHjBgghuHLlilSuJ29omsbEiROZ6hBlZfXq1dVa3Dhy5AjYbDYGDx5c7c9laWkp/vzzT4wcOZJZ0TQyMsLgwYPx+++/l0u0Pn/+jHXr1iEgIIApMx8+fPg3+8bHjBkDNpuNM2fOVCsuafL+/XusWLEC/v7+zAOkd+/e+P333xU+KcvLy8PWrVsZr2+RSIShQ4dKtQ9fEr58+YJp06ZBU1MTWlpamDFjRqU7rAcOHAAhpIx45sOHD8Fms+uMtoeycuLECQgEAkRERMhkAWPRokUghGDmzJnIzMxEUFAQeDweUlJSpD7W98TLly+rLCOVNteuXYOuri7c3d2RmZkplzGVhczMTBw/frzCBFtLS0uVYKtQGO3atUNISAhu374NDoeD5OTkCo+jaRoBAQFwc3Njqv7++eefOqNgvmXLFhBCMGLECKipqWHBggXw8vICUFZITbwZ+/PPP8Pd3R3BwcGMk4mzs7NcY5Zr0g2AUS8nhEBNTQ0ikQheXl4wMjKqUECNzWbD2NgYnp6ezG43m80uJyzWsWNH2NraVnpjO3v2LAghePDggTze5jdJS0tDhw4dQAhB8+bNpa7se+TIkSqrApSBkpISjB07FoQQ9OzZE3v37mUWIJKTk2utkPrrr7+CEKLQncuaQtM0EhISQAjB3LlzFR1OpTx69AhCoRD9+/ev8rgrV65AKBSidevW3xSyKikpwfnz5zF8+HCYmpoyQorDhg3DuXPnyp1P0zTOnTuHnj17Mr7aERER+N///lethGD79u1yF04rKCjAnj17EBsbCy6XCzabjejoaOzcuVPqZbo14caNGxg6dCi0tbUZkbmUlBSFld0XFRVh1apVMDY2Bo/Hw6hRo6q0mPvnn3+goaGBNm3alHsm9OzZE8bGxgpvIairHD9+HHw+X2ZiWhs3bgQhX21c7ty5AxsbGxgaGuLixYtSH+t7xMLCQq7WqH///TcMDQ3h7OyMtLQ0uY0rT969e4dff/0VycnJiIuLg6WlJTNHFYlECAkJwZgxY7Bjxw48fPhQlWCrUChTpkyBgYEBgoKC4ODgUKmOibgl998VwCUlJdDQ0MDs2bPlFW6NWbFiBdhsNt69ewd1dXVYW1vDxcUFACoUUhNXOe7evRssFguWlpZo1KiRXGOWa9JdWFjI7HRbWFjgy5cv2Lp1KyiKgkAggIGBAa5evYr379/j/fv3+Ouvv1CvXj0IhULweDzGi40Qgg0bNjDXffnyJdhsdpWKewcPHpRb2VVVlJaWYvXq1RCJRDAwMMDWrVtlshstXsESVxMoM1u3boVAIICvry8eP36MhIQEsNlsODk54fz58zW+7qZNm0AIqXPCSeJeRkKIUu/IFRcXw9fXF7a2tlVaBD169AgGBgbw9/evNNEpKSnBmTNnMGTIEKYc3MzMDPHx8bhw4UKFk5jXr19j+vTpTK+OjY0NkpOT8fLly2q/h5s3b0JNTQ3dunWT+fektLQU58+fR//+/ZlktlGjRli8ePE3y/LlwadPn7BixQp4enqCEAJjY2OMHz8ejx49UlhMNE1jz549sLe3B4vFQrdu3b5pL/fx40fUr18fLi4uFX4uHz9+DDabjYULF8om6O+YY8eOgc/no2XLljK5r+7duxcURWHAgAE4duwYtLS04OLiIlebybpOx44d4e/vL9cx7927B1NTU9jb21fLaUWZkSTBfvTokSrBVqF07Nmzh/nMVtZSm5+fj3r16qFVq1blXmvSpAnatm0r6zBrzZIlS0AIwerVq7FgwQLY2dmBw+EwNrF5eXllhNTu37+P+Ph4cLlcGBkZoXnz5mjWrJlcY5Zr0p2WlsZ8EGJiYrBu3ToQQtCwYUNs3boVDg4OCA4ORufOnZkVibFjx+L06dOMabv4Z86cOcx1x44dCy0tLXz+/LnSsVNSUqoUYZMHd+7cQePGjUEIQZ8+farcqZEGZ86cASEEe/fulek40uDKlSswNTWFqakprly5glu3bsHPz69Wf6tZs2ZBR0dHBtHKjtLSUgwePBiEEKxYsULR4VTJ1KlTQVFUlTtQGRkZsLW1hYODQ7l/w+LiYvz2228YNGgQUwFjaWmJn376CRcvXqxwMlNQUIDdu3cjMjISFEUxSuNnz56VePIjFk7z8PCQ6X3h/v37SEpKYgR06tWrh4kTJ+LevXsyG7O6iKsEunfvDjU1NbDZbMTExODgwYNytfqqiPPnzzP3gBYtWuDGjRvfPKekpATh4eHQ1dWt0rauT58+MDIyUoqqgrqC2C4qJiZGJgn3yZMnGZHDRYsWgaIoREdHV/lcV1GeJUuWgMfjyV234PHjx7C0tIS1tfU3F8aUhYyMDBw7dgzTpk1D69atmRYmcYIdGhqKhIQE7Ny5U5Vgq6gzXL58GYQQhISEVHrMjBkzwOFwKqz+HTNmDCwtLWUZolQQz5VjY2Ph6uoKLpcLLpfLiG+LRCI0a9YMOjo6CA4OBiEEXC4X3t7ecHZ2hra2NkaPHi3XmOWadL9584a5oQUHB4PNZqNr167w8/NDUVERMyn/t4J5amoqzMzMYGNjA3d3d+aPKS59+PLlC3R0dL75h1u2bBm4XK5Cdn3z8/ORlJQELpcLe3t7ufaNNm/eHA0aNKgT3rRv376Fr68v+Hw+tm7ditLSUqxcuRIikQj6+vrYtGmTRP9+I0eOrDMqjMDXhLtfv35gsVjftN1SNFeuXAGbzUZSUlKlx3z58gXe3t4wMjJiRDyKiopw4sQJ9O/fn6lcsbKyQkJCAlJTUyv997158ybi4+Ohp6cHQgj8/PywZs2aGot9FBcXo1mzZtDX15fJLtq7d++wZMkSeHt7Mzf//v3749y5c0oxcUtLS8OsWbNgZ2cHQghsbW0xc+ZMhSujA8Dt27fRsmVLRvdDEvHLhIQEUBSFU6dOVXnc06dPweFwMG/evNqG+0Nw6NAhcLlcxMXF1brtpyIuXrwIoVCIyMhIDBgwAIQQ/PTTT3XiuaVsXLt2TWFCqi9evICtrS3Mzc3x8OFDuY9fFVUl2Nra2mUS7MePHyt9haAKFZXRv39/EEIqtctNT0+HhoYG4uPjK3xdLMasDBV4lVFcXAwTExOYmpqiadOmiIuLg4eHB7y8vODg4ICoqChoamoyZeTR0dHw9PSESCSCsbExk7DL+z4l16Q7Pz+/jNBE/fr1ERgYiPv375c57u3bt/D29saLFy/g5+eHx48fo7S0FDExMTA3NwchhLGBWrlyJSiK+ubK6owZM6Cnpyert1Ypv//+O+zs7MDlcjFp0iS5rz5fuXIFhBBs2bJFruPWlPz8fPTs2ZPp6SspKUFaWhpjC9S0adNq7xB27twZTZs2lXHE0qGkpAQ9e/YERVG1stKSB7m5uXBwcICXl1elwn/FxcWIjo6GhoYGLl++jF9//RV9+vRh7K9sbGwwduxYXL16tdLJzcePH7Fs2TKm3NnQ0BAJCQm4e/durd+DuIVBmmIheXl52LlzJ6Kjo8Fms8HhcBATE4Pdu3crhVp2cXExDh8+jNjYWMbqq1u3bjhz5oxSTDBfvnyJ3r17g6Io2NjYYOfOnRItUGzduhWEkGqXjffr1w8GBgYq66lvcODAAXC5XLRt21YqQp//5datW9DW1oa/vz9CQkLA4XC+C5tHRVFcXAx1dXWF9WS+efMGjo6OMDY2xp07dxQSQ3p6Oo4ePYqpU6ciNjaWmTeKE+ywsDAkJibif//7nyrBVvFdcfnyZcYWa8CAARUe079/f+jo6FTo5AJ8XZQmhODIkSOyDLVWiB2pxLpQU6ZMqVJEDQA6dOiAw4cPIz4+ntkZlzdyF1ITqwqLd7icnJwQFBSEtm3bYu3atRAIBOXE1Pz8/ODk5ARDQ0O0a9cOLBaLKT91cHCoVu/B2LFjYWNjI4d3+JX3798zFieBgYEKe/gAQOvWrWFtbS2THQpZQNM0FixYAIqiEBUVhaysLABfFXNtbW3B4/EwefLkbyYyISEh6NSpkzxCrhXFxcXo0qUL2Gw2tm3bpuhwvsnQoUOhpqZW6eIHTdPo3bs32Gw2mjVrxvQv29nZYcKECbhx40alk5zS0lKcPHkSnTp1Ap/PB5vNRmxsLA4ePCi1Cb/YVkcaPb2lpaX4/fff0adPH2hpaTH3q+XLlyuNmu/jx48xYcIERpTOw8MDy5cvV4jVV0V8/PgRiYmJjK7H0qVLJb5XXb16FQKBAD179qz2BPrZs2fgcDhlWpVUlGXv3r3gcDho3769TBLuhw8fwsjICM7Ozqhfvz50dHTqhGqushMaGoqYmBiFjZ+RkQE3Nzfo6+tXqy2kNkiSYD958kSVYKv4bikuLoaHhwc8PDzQpUsXBAQElDvm1q1boCiqSuFYmqahp6eHn3/+WYbR1g6xI9X58+eho6MDAwMDRom8IhG1c+fOYfr06Th58iTs7OzA4/FACJF75aHck27xbgSHw4FIJEJgYCDc3NyYPwCbzYazszO2b9+OEydOYPDgwUxJuba2Njw9PcHn8zF//nwcO3as2mVUgwcPhru7u8zfH03TSElJgb6+PkQiEdasWaPwctLbt2+DxWJh5cqVCo1DUo4fPw5tbW04ODgwfSd5eXlMqb6dnV2VpacNGjSotHxGWSgqKkL79u3B4XCwa9cuRYfzTcSK8MuWLSv3Wn5+Pg4ePIiGDRsykx5HR0dMmjQJt27dqnKy8/TpU0yePJkRrXFycsLcuXOlroYrFk7r2rVrrSZfd+7cwbhx45gSRRsbG0yePFlpSirz8/Oxbds2hIaGMuXtQ4YMwbVr1xQdGkN+fj7mzp0LHR0dqKurY/LkyTXq301PT4e5uTm8vb0lrigYOHAg9PX1qxQC/FHZvXs32Gw2OnbsKJP+/levXqFevXqwtLSESCSCg4OD0nx/6jqTJk2Cvr6+QhPMDx8+wMvLC9ra2khNTZXKNdPS0nDkyBH88ssviImJgZmZGfOs0dHRQbNmzTB27Fjs2rVLlWCr+OFYsmQJWCwWUlNTMXPmTGhpaZX5DtA0jbCwMNjb239zETUiIgJRUVGyDrnG3L17F4QQjB8/HsuXL4ezszPYbDaWL18OV1fXciJqbdq0wW+//YaGDRuCoij069cPAoFA7nHLPekuKCiAQCCAvb09gK8qexwOB7a2tli8eHGFYmqNGjXC2bNnYW9vDw6HAwsLC8THxyM8PLza6txdunRBkyZNZPnW8PjxYzRv3hyEEHTs2FGp7DO6desGExOTOmeT8+DBAzg4OEAkEuH48ePM7+/evcsII3Tt2rXC3hNdXV3MnDlTnuFKRGFhIVq3bg0ulys3X9Xa8P79e5iYmKBFixbMdy4vLw/79u1Dly5doKmpyUyAQkND8c8//1R5vdzcXKSkpCAkJITxp+7fvz8uXbokk8nS+/fvYW1tDQ8PjxoJaKWlpWHBggVMubuOjg4GDRqEP//8U2kmdzdv3sSwYcOgo6MDQgiaNGmClJQUpRIMKykpwaZNm2BhYcH4ttf0XllYWIjAwEAYGxvj9evXEp//4sULcLlcpb5PKIL//e9/YLPZ6Ny5s0wS7nfv3sHR0RF6enpMRczHjx+lPs6PyvHjx0EIKde6J2+ysrIQEBAATU1NiXvM/5tgiyt1/p1gjxs3Drt378bTp0+V5h6sQoUiePv2LbS0tDBo0CAAX4UvCSFl3FwOHToEQggOHTr0zetNnjwZBgYGSvu9OnjwICiKQpMmTZhScQ6Hw9wjDA0NMXDgQJibm6N9+/aMc5bYhjo4OBgNGjSQe9xyT7qBr3L0bm5u+Ouvv8Dn89GqVSv4+vpWKqbWuHFjvHjxAnfv3gVFUeDz+YiNjQUhBCkpKdUas2XLlhVK40uDoqIizJw5EwKBAPXq1WPKGZSJx48fg8PhKLXnc2VkZWUhKioKFEVh/vz5zE2Apmls2LABenp60NbWxurVq5mqgsLCwnLWcspEQUEBWrZsCR6Pp9R9M2Jomkbbtm2hq6uLx48fY/fu3ejYsSPU1dVBCIGbmxu6d+8ONpuNQYMGVXqjpmkaqampGDhwIFOO3bRpU2zZskWmvbXFxcVo3rw59PT0JBJO+/LlC7Zt24aIiAiw2WzweDy0adMG+/fvVxoruqysLKxcuRKNGjVirL7GjRundLuGNE3j6NGjcHV1BSEE7dq1q1A5VRIGDRoELpeLP//8s8bXGDx4MHR1dVUq2f+fHTt2MCKnski4xbsPQqEQhBAMGTJEJqXrPzJZWVlgsVhYv369okNBTk4OmjZtCqFQiNOnT1d4zNu3b3H48GFMmTIFrVq1KpNg6+rqonnz5qoEW4WKKujcuTMMDAyYxctnz56BEIJjx44B+Dontre3R1hYWLW+P+KkXVmdCOLi4qCtrQ0rKyu0bt2aEVGrX78+goKCyiTgXC4X0dHROHbsGBo2bIju3buDw+Fg/vz5co9bIUl3YmIizM3NERsbCwcHBzRu3Ljcimxubi6CgoIAfO3XCw0NRdu2beHt7Q0OhwMTExOYmJhUu/cvKCgI3bp1k/p7uXTpElxdXUFRFEaPHq3UojwDBw6Enp5ejRWfFUlJSQkjmNCjR48yZaSZmZno1asXCCEICAjA33//jVevXpW54SgTeXl5iIiIgEAgKLN7r8ysWbOG6VcWT5Y9PDwwffp0PHjwAFeuXIFQKERMTEyFisMZGRmYP38+nJ2dQQiBubk5kpKS8PjxY7nEn5iYCDabXemk79+UlJTg1KlT6NGjBzQ0NBhdhlWrVlUqPCJvaJrG+fPn0aNHD6ipqYGiKLRq1QoHDhxQygTm8uXLaNKkCbP7fvny5Vpfc9WqVSCE1Frp/9WrV+DxeJg+fXqtY6rrbNu2DRRFoUePHjJRDs/Ly0Pjxo3B4XDAYrGwdOlSqY+h4itubm7o27evosMA8HU+Fx4eDoFAgG3btjEJdsuWLWFiYlIuwR4/fjz27NmDZ8+eqRJsFSq+walTp0AIKSPCW1paCg0NDWajTWzDeOvWrWpdMz09HYQQpW17VFNTw5AhQxini4pE1EJCQpCXl8fcQ4qLi9G6dWtMmDABFEXh0aNHco9bIUn30aNHQQgBi8WCtbU1I6bWoUMHXLx4EV26dAGPxwOLxYJAIICLiwvGjx+PgIAA6OnpMQ/tqVOnVnvMhg0bYsiQIVJ7D9nZ2Rg6dChYLBa8vLyUqleyMl69egU+n48pU6YoOpQas3XrVggEAvj6+uLNmzdlXjt79iwcHR3B4XDQo0cPEEJw/fp1BUVaMbm5uQgLC6ty1V9Z+Pz5M7Zv344WLVowk6JGjRph1qxZZZLlx48fw8DAAH5+fmXKmMVq2XFxceBwOODxeOjQoQOOHz8uVyugnTt3ghCCBQsWVHncrVu3kJCQwOyy2NnZYerUqVX6Pcub9PR0zJ49G/b29ozV14wZM8p9F5SFBw8eoF27diCEwMXFBUePHpXKJPrChQvgcDgYOnSoFKIEU5JfFxckpUVKSgooikKvXr1k8v0sLCxESEgIWCwWhEJhnVlwrKsMGjRI4ZaZb968waFDh/Dzzz8jKioKfD6feZbo6ekhPDxclWCrUFELCgoKYG9vj6CgoHLfHx8fH/Ts2RMfPnyAjo4O+vfvL9G1LSwskJCQIM1wpUJeXh4IIdi4cSP09fWhq6tbpYgaAMycORNWVlaIjIwEm81WiF0YoKCku6SkBNra2uDxeIyYmre3N9OHSFEUTE1NkZSUhFmzZsHDw4O5Ubdp0wYNGjQAIQQ7d+6s9phWVlYYP368VOLft28fTE1Noa6ujoULF8qkBE9W/PTTT9DU1GTK+OsiV65cgampKUxNTXHlypUyrxUUFGDatGngcrlKZ5WWk5ODJk2aQF1dHefOnVN0OBWSlZWFlJQUxMTEMBMkTU1NaGtr4+bNm+WOf/fuHerXrw87OztGrfvevXtITEyEsbExsyO+dOlShXzmbt26BaFQWKlw2ps3bzB37ly4ubmBEAJ9fX0MGzYMly9fVpoJYHFxMY4cOcIsXvD5fHTt2hW///67wkUaKyMtLQ2DBw8Gm82GhYUFNm3aJLVE7uXLlzA0NESTJk2ktqv/5s0b8Pl8iRZyvyc2bdoEFouFPn36yOQzVVJSgmbNmjHtD4p08/hRSElJASFEbvfdfyfY0dHRzP1fnGC3aNECY8eOhb+/PyiKwo4dO+QSlwoV3zPJycngcDgVauj06dMHXl5eiI+Ph4aGhsTaKW3atFFK292ioiIQQtC3b1+sWrWKEVHbs2cP3Nzcyomoic9ZuXIlWCwWU3H59OlTuceukKQbAFxdXRESEgLga4m2trY29PX1MWrUKPj6+qJjx44ICQlhevV8fHwwZ84caGhowNDQEDweTyLLH2mIar169YrpJW/ZsiVevHhRq+spgnfv3kFDQ0MpV68k4e3bt/Dz8wOfz6+wr3/69OnMA79du3YK3wnMzs5G48aNoampWav+U1nw8eNHbNq0iekxJ4TA398fCxYswIQJE8BisXD27Nly53358gU+Pj4wMjLCrVu3sG7dOsYSUEdHB8OHD1dopcGHDx9gbW0Nd3f3MjvwOTk52Lx5M5o1awYWiwU+n4/27dvj0KFDSlWa/fTpUyQlJTEKvQ0bNsSyZcuUWnDq8+fPmDx5MtTV1aGjo4O5c+dK1aM8Ly8Pnp6esLS0xLt376R2XQAYMWIEtLW1lcZKTV5s2LABLBYL/fv3l0nCTdM0o6Lv5OSkNFZ63ztir93qiCZJAk3TeP36NQ4ePIjJkyeXS7D19fXRokULTJgwAXv37sXz58/LLGAWFxeje/fuoCgKmzZtkmpsKlT8SDx58gQCgQCJiYkVvr5gwQIIBAKw2WzMmDFD4uvPnDkTmpqaSre4L7b79PHxQfPmzREaGsrsXgsEAixevBhXr16Fvb09UlNTMXHiRKaNxdraGmPGjAGbzVaIa4nCku7w8HDExsbi0aNH0NPTQ6NGjeDt7Y2XL19CIBDgxYsXSEtLQ6NGjQAA3t7eAL56swkEAnC53Gp7yNE0DTabjRUrVtQo1pKSEixZsgQaGhowMTHB7t27lWYXrCZMmjQJAoFA4YlobcnPz2d6uRMSEsrspCUnJ0NPTw/btm2DoaEhNDU1sXTpUrmWNYv59OkTfH19IRKJpGadUls+fPiA9evXIzIyElwuFywWC4GBgVi8eDFevXoF4OsuMY/Hw5gxY8qdX1xcjJYtW0JNTQ0tW7aEUCgEi8VCixYt8L///U+qiVZNKCkpQXh4OPT09PDs2TMUFxfj119/RdeuXZme9CZNmmDdunWMD7wykJ+fj+3btyMsLAyEEGhpaWHw4MG4evWqUt9zCgsLsXTpUhgYGIDP5yMxMVHqiwM0TaNr165QU1OTiffv27dvIRAI6nT7jaSsW7cOLBYLAwcOlMnEqrS0FP7+/iCEoHHjxkojPvgjQNM0TExMMG7cuFpdQ5xgT5o0CVFRUTAyMmISbAMDA0RERGDixInYt28fXrx4Ua37VGlpKfr16wdCCFatWlXj+FSo+FGhaRpRUVGwsLCoNHk8efIkCCEwNTWt0Zzst99+AyEEd+/erW24UmXgwIHgcrkwMDDA5s2boa+vDy8vL4wYMQJqamrM/enfP1wuF/Xq1cPEiRPh6OiINm3aKCR2hSXdHTp0QEhICDp37gwLCwv4+/vj/v37yMvLg4uLC3Ocv78/iouLERAQwEwK4uLiQAhB9+7dqzVWbm4uCCHYunWrxHHevHkTPj4+IIRg8ODBSjVBrylZWVnQ0dHB4MGDFR1KraFpGgsWLABFUYiMjGR2qYYPH858jj5+/IiBAwcyPcny7L8Xe5Xq6uoqvO8/MzMTa9asQXh4OCNk1KRJEyxbtqzcAkx+fj5cXV3h6upabqL86tUreHt7MzczGxsbTJs2rYw1haIZO3YsKIrCypUrMWrUKGYnxtHREdOnT5dIwVwe3Lp1CyNGjGBabIKDg7F582alsvqqiNLSUuzcuRO2tragKAq9e/eW2edg3rx5ErcVScqoUaMgEomUuppAWqxevZp5rski4f7y5QtcXFxACEGrVq2UetHoe6Vt27aMIO23oGkar169woEDB6qVYL98+bJW/6alpaUYPnw4CCFYtGhRja+jQsWPyL59+0AIqdJu9n//+x8IIRVunFSHrKyscgJtyoCOjg46d+7MzOk9PDwAAA0aNEBxcTGeP38OBwcHnD59GgcOHMDnz59RWFgIFxcXnDlzBoQQbNu2TSGxKyzpnjFjBgQCATgcDurVq8eIqXXq1AkBAQGYNGkSDA0NQVEULC0tYWdnhw4dOsDOzg7q6uoICAiAm5tbtcZ6+/YtCCE4fPhwtePLzc1FQkIC2Gw2nJ2dla4kuLbMnj0bHA5HqUSiasOJEyegra0NBwcHPHjwAO3bt0ezZs3KHHPx4kVGaX7kyJEytwjKzMxEw4YNoa+vX2E/tDzIyMjAqlWrEBYWBjabDYqiEBoaihUrVlTZ3zN69GjweDxG6bKgoAC7d+9GZGQkWCwWoxR/9uxZpSs9Wr58OQghzITR0NAQ8fHxSrdbnJ2djVWrVjELGEZGRkhMTFS4t251OX36NLy8vJh2m9u3b8tsrOPHj4OiqFrt2lWH9PR0qKmpYdKkSTIdR9GsXLkShBAMGzZMJt+J169fw8LCAoQQdOzYUerXV1E9xOWl/3V5+XeCnZSUhMjISBgaGpbxuI2MjERSUhL2799f6wS7MmiaRmJiIgghtW7/U6HiRyEnJwcWFhaIjo6u9HtZUlICV1dXcDgcTJs2rcZjOTg4MPbNykBGRgbYbDYWLFiAhg0bQktLi9lg+7dyeWhoaJnzaJqGs7MzbGxswGazFVZ1qrCkOy0tDRRFgcvlMmJqjRs3hrW1NdNXqqGhgdDQUHTr1o0ROuJyudDR0WEUiasz0bt//z4IITh//ny1Yjt+/Disra3B5/ORnJxcbVuyukRubi6MjY3Ro0cPRYciNR4+fAhHR0eIRCK4uLiga9eu5Y4pKirCnDlzoKamBnNz8ypXCWtDeno6XFxcYGhoKNNkpCLS0tKwfPlyhISEgKIosNlsNG/eHKtXr65WH+zvv/8OFouFuXPn4tatW4iPj4eenh6zq00IQVJSkhzeSfXJzs7G+vXrmQSWzWajU6dOOHbsmFIJHdI0jQsXLqBXr14QCoWgKAotW7bE/v37laqfvCpu3rzJKNr7+fnJXBTw0aNH0NbWRmRkpFzaQ0aPHg1NTU2lsYeTNsuWLQMhBCNGjJBJInX16lVoa2uDEILOnTsr1ULXj0ZqaioIIThw4AD2799frQT71atXcv03o2kaP//8MwghmDx5surzokLFN0hISIBAIKhSCExs8+ru7o5OnTrVeKxu3brBx8enxudLm6SkJFAUhfnz56NFixawtbUFl8vFzZs3K1UuF59nYGAAXV1dEEKkYltaExSWdAOAmZkZwsPDAXxdGXd2dgafz0dcXBw8PT3Lialdu3YNffv2BSEEMTExIIRg7dq13xxH/OD51m5jRkYGunTpAkIIQkNDFSInL0+WLVsGiqK+KyXZrKwsREdHMz27lT3Anz17xhwXExMjVVG8t2/fwtHRESYmJrh3757UrlsVr1+/xpIlSxAcHAwWiwUOh4OIiAisW7dOIuGirKwsmJmZwc7ODp6ensykbMyYMVi1ahXYbDYGDhyoFBOjoqIiHDlyBB07doRAIAAhBGpqarC0tJRYpVPWpKenY86cOXBwcGAWL5KTk/H69WtFh1Ztnj17hm7duoHFYsHe3h579+6V+efg8+fPaNCgAezt7eUmcJaRkQGhUIiJEyfKZTx5smTJEhBCMGrUKJn82+3evZux++zQoYPSVcF879A0jZcvX2Lfvn2YOHFiGbtHcTVNVFQUJk2ahAMHDsg9wa6KmTNnMvosyhKTChXKxu3bt8HhcJCcnFzpMdnZ2TA0NETXrl0xePDgMi27krJ48WLweDyl2HzMycmBSCQCl8tFeHg4UlJS8ObNG6aPW0tLC/v378eHDx/g6emJ0tJSnD9/Hk2aNAGLxYKVlRVWrFgBQkgZ21t5otCk28fHB507d0ZWVhZcXFxgYmKChg0bViqmJqZ+/frg8/ngcrmYM2fON8cRG8c/e/aswtdpmsa6deugo6MDPT09bN68+Ye46RcWFsLKygpt27ZVdChSpaSkhKmW6N69e6UCEjRNY8+ePYz927x582q9K/rq1SvY2dnB3Nxc5os2L1++xMKFC9G4cWOmCiQqKgobN26UeJeutLQUJ0+eRL169RjbvpiYGBw4cABFRUX466+/oK6ujlatWil055imaVy5cgXDhw+HgYEB4/88c+ZMBAcHQ1dXt9LvubwpKSnB0aNH0aZNG8bqq0uXLjh9+nSdSkbev3+PUaNGgcfjwdjYGKtWrZLLrnxpaSliY2OhpaUlt8UrMYmJidDQ0KjT1or/ZdGiRSCEYPTo0VJ/vtE0jWnTpjFVJjExMUpVYfI9QtM0Xrx4wSTYERERzD3x3wm2paUl/Pz88Pr1a6Wf14g/o8OHD69T90gVKuQBTdMICgqCg4NDlaKU48ePZ3Ko5cuXg8Ph1DhpvnjxIgghuHr1ak3DlhoLFy4ERVGgKApCoRAuLi7gcrnQ0tKCjY0NKIpi7n8URTGtkCwWC7NmzUJWVhZat24NZ2dnhd0LFZp0R0VFITY2FgkJCdDQ0ICXl1eVYmpivLy8sGvXLhBCMGjQoG+Os2fPHhBCKkxE7t27h+DgYBBC0KNHjx/OzmTjxo1K84WSFnl5ecxnQyAQwMfHp0ql9uzsbIwYMQIURaFhw4Y1Ljt5/vw5bGxsYGlpKbNe+efPn2PevHnw8/MDIQQ8Hg+tWrXCli1barQT+PTpU0yePBmWlpbMzapTp05ldoqfPHkCQ0ND+Pr6KkzY69mzZ0hOTmZ2ik1MTDB69GjcvHkTNE1j3LhxoKj/x95Zh0W1tW187elhmBm6G2lQEBQkRMVEwcRuRcxjdyd2d3frsY7dncc6ttgdSCg9+/7+8Jv9itTADMyA87sur/c9zN5rPxtm9qx7ree5HxaOHTumlvh+5dmzZxg9ejSsrKxACEH58uUxf/78Upeu/OPHD0yZMgUSiQRisRgTJ07E9+/fS+z6Y8eOBUVRhfLiUBWfP3+GSCQq9hrykmLWrFkghGDIkCEqn2ykpqYyGWJ8Ph81a9bUupSrGLnA3rVrF0aMGIE6derAyMiIeWabmZmhfv36GDNmDPbu3ZtNYA8fPhympqYaL7jlLF26FIQQdO3aVS3dRrRo0VTWrl0LQgiOHz+e5zHPnz8Hn89nSgDPnDkDQkiufbwVISUlBRwOB0uWLCnS+aoiIyMD1tbWMDQ0RHh4OAghqFSpEnx8fODr6wt3d3dMmTIFbm5u4PF4aNy4MaZPnw5vb28IBAKEhoYiICAAFEWp1T9CraK7T58+MDc3h76+PszNzbOZqYWEhGD79u1Mvn7FihUxcuRIxMTEQCQSwd/fH3Z2dvD19S3wOqtXrwYhJJtwT0tLw7hx48Dj8eDo6KgRk3V1kJmZCVdXV9StW1fdoaiM58+fgxCCo0eP4tq1a7C0tIS5uXmBxgnXrl1DxYoVQVEUevToUSgRGxcXB1tbW9jb26vcGTsuLg7Tpk1j6pX5fD4aNWqEjRs3IjExsdDjpaSkYOPGjUzvXLFYjNatW0MsFiMqKirb5OzTp09wcnKCk5OTyvsiF8S3b9+wfPlyhISEgBACkUiEdu3a4ciRI9kmY/IFuJkzZ5ZofL+SlpaGrVu3ombNmkyaU/fu3XHt2rVSM9mVk5mZiRUrVsDCwgJcLhd//fVXif/td+3aBUIIJk+eXKLX/ZVhw4ZBJBKV+L2rmhkzZoAQguHDh6v8vfjhwwcEBASAx+NBLBYjICBALb1PyxI0TePFixcKCex9+/YV2PrzwIEDak2nLApr164Fi8VC27ZttRkTWrTgZyccY2NjtGrVKt/jWrRoAXNzc+Y5/OXLFxBCsG3btiJf29vbG507dy7y+apgw4YNzHx12rRpcHd3h7GxMSpUqAAgfxM1X19fZGVloWHDhmCz2cXuQ5MfahXdN2/eZL5IJBIJgoODERoaiooVKzK7RGw2G46OjvD19YVUKmXSBtzc3Jhm5wWl8c6ZMwc6OjrMf589exaurq7gcDgYMWIEUlJSivtWNZodO3aAEKLWN6IquXz5MgghjPP2u3fvEBAQAD6fj/Xr1+d7bmZmJubOnQtdXV2YmZlh69atBU5UHz9+DCsrKzg5OTE9rpXlyZMniI2NZeqqhUIhmjZtii1bthTJdZ2maVy5cgUxMTHM5yg0NBTr1q1DUlISateuDXNz82zptD9+/IC/vz9MTExKzOU+PT0de/bsQbNmzcDn88FisZjandwm83fu3IGOjo7aDJvu3LmDvn37MuYcISEhWLt2bYnuCKsKmqaxZ88euLm5MSZY6uhucPfuXYhEohwLQCXNly9foKuriyFDhqgtBmWZOnUqCCEYOXKkyn+Xt2/fho2NDYyMjGBsbAwvL69Sl82hbuQCe+fOnRg+fDhq167NmFbKM3oaNGiAsWPHKiSwc+Pr168a2fanILZu3Qo2m42oqKhSYzKpRUtxERMTA4lEgnfv3uV5zIULF0AIwerVq7P93MzMTKmOHNHR0fDy8iry+cpC0zS8vLwQHh4OLpeL2bNnIywsDCYmJhAKhXj79m2+JmoVK1ZE27ZtmfTzixcvqulO1Cy6AcDY2JjZrc7IyED79u2ZlEwXFxemn/eFCxeQmZmJPXv2oFatWiCEQF9fHywWC4sXL873GuPHj4e5uTni4+PRtWtXEEJQpUqVEneV1lRkMhl8fHwQHBxc6nblcmPPnj0ghODjx4/Mz9LS0tCxY0emZ2FBaWuvX79GkyZNQAhBnTp18hQfDx48gLm5OVxdXYs0IfqVhw8fYtKkSahQoQIIIdDR0UHz5s2xffv2Iu8effz4EbNmzYKHhwcIIbCyssKoUaOy7XosWLAAhBAcPnyY+VlmZiYiIiIgEolw7do1pe6rIGiaxqVLl9CzZ09mwunt7Y1Zs2bl+wXz9etXODg4oEKFCiWa9p6YmIjly5ejcuXKjNHc4MGDS02rr9w4f/484w1Qs2ZNtfWUl/9Ny5cvrxELFyNHjoSOjk62Z0lpYfLkycXmCL1v3z7o6urCw8MDtra2cHR01DjzQk2Dpmk8f/68QIE9btw47N+/P99nX2Fxd3dHTEyMysYrKf7++29wuVxERETk6c2iRUtZ5/Lly6AoCvPnz8/zGJlMhsqVK8PHxyeHH0LNmjXRuHHjIl9/xYoVYLFYavtOPnjwIAgh2Lt3L7hcLho0aIANGzbg7t27TEcrY2Nj3Lt3DwkJCahYsSJomsa3b98wb9488Pl88Hg8jBw5EoQQ3L9/Xy33AWiA6K5UqRIiIiJA0zQ6dOgADoeDcuXKFWim1qZNG7BYLAgEggJ70PXv3x8WFhYwMTGBRCLB4sWLtSYdvyF/Ux86dEjdoSjN0qVLwWKxcghrmqYZI4a6desqlD6+f/9+2NjYQCAQYPLkydnMKO7evQsTExN4eHjgw4cPRYr13r17GD9+PLy8vJg2eS1btsSuXbuKLCQzMzOxf/9+NG7cGBwOBzweD82bN8fhw4dz/E4ePHgAgUCQrQ8jTdOIiYkBm83GwYMHixSDIjx9+hTjxo1DuXLlQAiBpaUlhgwZotBiWFZWFurUqQMDA4N822aoCpqmcf78eXTq1Ilp9RUeHo7du3eX6l2Y+/fvo2HDhiCEwMfHB0ePHlVbLJmZmahZsyYMDQ1L5G+qCF+/foVEIsHAgQPVHUqhkJuajRs3TqXj0jSNmTNngqIohIeHw8PDA5aWlhpjXqgp0DSNZ8+eYceOHRg2bBhq1aqVTWBbWFggIiKiWAR2bnTt2lUpB2N1cujQIQgEAtSuXVttniJatKiLzMxM+Pj4wMfHJ9/Noo0bN4IQgtOnT+d4rV+/fnBycipyDLdu3SpU22VVExoaCn9/f0ybNg1sNht6enqMiZpYLIaZmRnzbLWxsYFIJEKFChWYnW2RSITr168jOjoalpaWai1ZUbvobtSoEerWrYvNmzeDEAIXF5cCzdSOHDmCxo0bY/369SCEoHXr1nmO/+zZMyZVvWnTpkrvRpZVaJpGcHBwrqtkpY3x48fDzMwsz9ePHDkCPT09ODs7K7Q7+f37dwwaNAhsNhvu7u44e/Ysbt26BSMjI1SoUKFQNZ80TePu3bsYM2YM3N3dmRqVNm3aYM+ePUqVOjx8+BBDhw5lHkDe3t6YP39+ng7M6enp8PX1hYuLS7bJzKRJk3JNUVIFX79+xeLFixEYGMgsMnTs2BEnTpwolGlOSRmnffz4ETNnzoSrqysIIbC3t8fEiRNVVkagLt68eYOuXbuCxWLBzs4OmzZtUvvnfsCAAWCz2Th58qRa4/id0aNHQygUlpqd3HHjxoEQggkTJqh03PT0dKZl58CBAxEQEABDQ0O17hpoArkJbHm5ya8Ce/z48Thw4IBa3kdr1qwBRVEl1nZP1Zw4cQI6OjqoVq2a1jNAyx/F/PnzQVFUvp5EP378gJWVVZ672StXrgRFUUWeX2ZmZkIoFGLWrFlFOl8Z5OWiu3btgpOTE2rXrg1CCIKCgrKZqI0fPx52dnbgcDjw8/ODh4cHwsPDERQUBDabjZCQEPD5fIwdO7bE7+FX1C66e/XqBVtbWwQEBEAikeQwU7t27Rp8fHwYV9SxY8fCzs4OVapUgb+/P6ytreHi4pJj3MzMTMyYMQNCoRBCoZAptteSN3KXwx07dqg7FKXo0aMHvL298z3m8ePHcHNzg1QqVXh3/9atW9lcwytUqKBQDSNN07h16xZGjRrFuG9LpVK0b98e+/btU8rpNykpCatWrWJSg/X19dGnTx/8+++/BZ47atQocDicbOnjcjd7VU7Y09LSsGvXLjRq1AhcLhdsNhvh4eHYvHlzkXYu5MZpM2bMUFmMv5KVlYWDBw+iadOmTKZAy5Ytcfz4cbULU2X59u0bhg8fDqFQCENDQ8ydO1cjnKbXrVsHQki+6XPqIj4+HlKpFP3791d3KPlC0zTGjBlTLAZ0X758QWhoKHg8HlauXImwsDCIxeJiLz3RNGiaRlxcHLZv346hQ4eiZs2a2QS2paUlIiMj1Sqwc+Px48cghBRr5lJxc/78eYjFYlSpUgUJCQnqDkeLlmLn3bt3jClrfkycOBFcLhdPnjzJ9XW5cFVkXpgXgYGBaNmyZZHPLypNmjSBs7MzMjIyQFEUli1bBmtrazg6OqJixYoAcjdRCwwMZOZrvXv3Rps2bUBRlNo7NalddF+6dIn5wtLR0WHM1MLCwhAYGMj0WePxeJBIJMyxBgYG8PLyYkTMrVu3mDGvXr0Kb29vsFgs9O3bF2FhYWWuF3VxUadOHbi6upbqVh1NmjRBnTp1CjwuMTER9evXB4vFwsyZMxWqe7x48SIEAgHYbHa+Pd1pmsaNGzcwfPhwJn1aX18fnTp1wj///FPknonysc+ePYuOHTtCJBKBoijUqVMH27ZtU7ju7eLFi2CxWNlKMw4dOgQ2m43o6Gila0Bpmsa5c+fQrVs36OnpgRACX19fzJ07t8ip+MD/TLZatmyp8jrV58+fY8yYMUxmjJeXF+bNm1cmejWnpaVh9uzZMDAwgFAoxMiRIzVm4nr16lXw+Xx06tRJYz0lxo0bB4FAUOxpwEWFpmmMGjUKhBBMnTpVpWM/ePAAjo6OMDIywqlTp9C4cWMIBIJc0xjLEr8L7LCwMOjr6zNzECsrKzRs2BATJkzAP//8o9RzrbihaRrGxsYYOXKkukNRiqtXr0JfXx++vr5l4rmsRUt+tGrVCsbGxoiPj8/zmLdv30IkEmHAgAF5HpOUlARCSIFGwvnRt29fODo6Fvn8ovDo0SNQFIXly5fj+/fvzD0EBweDz+dDKpUiJSUlVxO1SpUqAfj57KtevTrz3Fa3947aRTdN0zAzM4O+vj6TPr5z506w2Wzo6urCwsIC9evXZ8zUvn//jpUrV8LHxweEEFhbW0NPTw9jx45FUlIS02/Z29ubWYUPCAhAp06d1HmbpYZr166BEIK1a9eqO5QiExgYiA4dOih0bFZWFoYNGwZCCNq1a5evaJWvtAcGBuLx48do1aoVCCGoXr06Hj58CJqmcfXqVQwZMgQODg4ghMDQ0BBdu3bF4cOHla79ffPmDaZMmcKIeAcHB0ycOBGvXr0q1DjJyclwdHREQEAA85m7fv06RCIRGjRooFS9y6NHjzB69GjY29sz9TUjRoxQSQpqfHw8HB0dVWqylZaWhm3btqFWrVqgKApisRjdunXD1atXNVYAFgaZTIYNGzbA1tYWbDYb3bp106gSm/fv38PS0hL+/v4aseOeFwkJCdDT08Nff/2l7lByQNM0hg8fDkIIpk+frtKxjx49CqlUCg8PDzx9+pTxXTlw4IBKr6NuaJrG06dPsW3bNgwZMqRUC+y8aNSoEapXr67uMJRGXtrl5eVVKg0OtWhRhOPHjyvUdaBTp04wNDQssHTE1tZWqU4c8prxkuxQER0dDTMzM6SmpuLp06egKApt27bFhg0b8M8//4CiKHh6esLGxgbfvn3LZqIWGBiIkydPolGjRoxBLCFE7QvnahfdABAWFgYPDw8APwW3XKw8fvw4TzO1KVOmwNjYGCwWC3p6eqhbty6srKygo6ODGTNmZBMO7u7u6NevX4nfV2mlSZMmsLOzU2o3Vp04ODgU+uGyefNmCAQCVK5cOVdRcubMGYhEIlStWjVbTdnhw4dhaWkJNpvNtOIyNjZGt27dcOzYMaWFdlpaGnbs2IHw8HCwWCwIhUK0a9cOp06dKnKqc3R0NEQiEZOK9OzZM5iamqJy5cpFErOfPn3CggULGDdvqVSKrl274vTp0ypLx87KykLdunVVZpx29+5d9OvXjzE3Cg4Oxpo1azTCMVsV0DSNw4cPM074jRs3xoMHD9QdVjbS0tIQGBgIc3NzjVoIyIsJEyaAz+fjzZs36g6FgaZpDB06FIQQldfbLVy4EGw2G/Xq1UNCQgL++usvUBSFzZs3q/Q6Jc3vArtGjRpMNo58Ib9Ro0aYOHEiDh48WGaE3fTp06Gjo1OqjR/l3Lt3D2ZmZirpGqJFi6aRlpYGZ2dnhISE5Lv4f+PGDVAUhYULFxY4Zv369REeHl7kmB49egRCCI4cOVLkMQrD+/fvwePxEBsbCwAYMmQIeDwe7O3t4eXlBS6XC5FIBB6Px7SX1tPTg6GhIRo3bgw2mw1CCMzMzODk5IQOHTrAyspK7Vm8GiG6u3fvDi8vLzx//hx8Ph/Gxsa4f/9+rmZqv9aAZmVloVKlSsyXZb169XJ1UbW0tMSYMWNK4lbKBPfu3QNFUVi0aJG6QykSIpEIs2fPLvR5165dg6WlJczNzbOZVhw/fhxCoRBhYWH4/v07ZDIZLly4gH79+sHa2ppxR2SxWLCyslLJQ+n27dvo27cvIwoDAgKwfPlypVOC9+3bB0IIli9fDgD4/PkznJ2dUa5cuUIZwqWkpGDbtm1o0KABOBwOOBwOIiIisH379mJp7TJ8+HCwWCyl3LWTkpKwYsUK+Pv7M4sjgwYN0jgxqizXrl1DjRo1mMUEdfakzAuaphEdHQ0ej4fLly+rOxyFSExMhL6+fjanf3VC0zQGDRoEQgjmzJmjsnEzMzPRq1cvEELQr18/ZGZmYuzYsSCEYMmSJSq7TklA0zSePHmCrVu3YvDgwX+MwM4NeQ/fslKH//jxY6a288WLF+oOR4sWlTFp0iRwOBz8999/eR5D0zRCQ0Ph5uamUHbi0KFDYWNjU+SYZDIZ9PT0MGnSpCKPURiGDRsGsViMb9++IT09HYaGhoyJWu3atRkTNQAYOHAgJBIJuFwuzMzMIJVKERYWBh8fH0gkEqZtWEGdrkoCjRDdY8eOhYGBAQYMGAAOh4P9+/czr1WpUgUjR45kUmp/NbGaP38+mjZtisjISIjF4jzfeGKxWC2ue6WZdu3awczMrNS16EhOTgYhpMi7Me/fv0eVKlXA5/Oxfv16HD58mGlXcuzYMfTp0wcWFhZMX9XevXvj9OnTyMrKwv379xESEgJCCNq2bVvoCVx8fDwWLVoEX19fpv/zoEGDcO/evSLdy+98/PgRJiYmaNCgAWiaxo8fPxAQEAATE5NsfbvzQiaT4fTp0+jSpQvjr+Dv74+FCxfi8+fPKokxN3bs2FHk1FmapnHhwgV07tyZWRipV68edu3aVWozOfLi6dOnaNGiBQghcHd3x759+zQ2RX7x4sXF5pBfnEyePBk8Hq/QJR2qhqZp9O/fH4QQzJs3T2Xjfvv2DbVr1waHw8HSpUsBAHPmzAEhhNlx0FR+FdiDBg1C9erVmewjealL48aNMWnSJBw6dKhQi4xlgbS0NPD5fMydO1fdoaiM58+fw97eHjY2Ngp9h2nRounExcVBIBAUmK25e/fuQpkjbtiwAYQQJCYmFjm2mjVromHDhkU+X1ESExMhlUoxaNAgAP/bZf/nn3+go6OD0NBQRnDLCQ8PZ8oYf82KbtOmDaKjo0FRlEYYW2qE6L59+zYIIRAKheDxeBCLxZBIJEz6uPxLM7d/FEUx7Xz27duXY+ysrCwQQrBixQo13FnpJS4uDhwOB9OmTVN3KIXiyZMnIITgxIkTRR4jLS0NnTp1AiEELBYLtra2MDU1Zdxp+/bti3PnzuWaOi2TybBq1SoYGBhAX18fy5cvzzfFWiaT4dixY2jVqhX4fD7YbDYiIyOxZ88elaYB0jSNyMhIGBsb48OHD8jMzERkZCR0dHRw9erVfM+9f/8+hg8fDhsbG6Zt1pgxY/Do0SOVxZcXcuO0Fi1aFEpAfvr0CbNmzYKbmxsIIbC1tcWECRPULpaKg48fP6J3797gcDiwtLTEqlWr1NqHsiDOnDkDDoejkfXRBZGUlARDQ0P06NFDbTHQNI2+ffuCEKJQWqGiPH36FK6urtDT02Oen6tXrwYhBEOHDlXZdVSBTCbD48ePsWXLFq3ALgRBQUFo3ry5usNQKa9fv4azszMsLCzKXNaSlj8LmqYRHh4Oa2vrfFvjpaWlwdHRUSHDYDk3b94EIQSXLl0qcnzDhw+Hubl5kc9XlBkzZoDL5TKlXO3bt2diL1++PDMXl88Jv337xjiZAz9LZK9cuYLv37/DxMSE+V5Qd2o5oCGiGwDTs/jMmTOIi4uDp6dnDoFdvnx5BAUFMRPpX//p6uqiSZMmOcZNSEgAIQTbt29Xw12Vbnr06AEDAwONcTlWhPPnz4MQUuTd4czMTBw/fpxJYyGEQCAQoGfPnrh48aLCNcqfPn1Chw4dmH6Cd+/ezfb6s2fPMGbMGEbIurq6Yvr06cW2ErdixQoQQrBnzx7QNI3u3buDzWYzTo+/8+HDB8yZM4fZddfX10dMTAzOnz9fYrunhTVOy8rKwqFDh9CsWTNwuVzweDy0aNECx44dK/WtvnIjOTkZ48ePh66uLqRSKaZOnapUn/eS4MWLFzA2Nkb16tVLbW1pbGwsuFwuXr58WeLXpmkaffr0ASEEixcvVtm4Z86cgaGhIZycnJjFtF27doHFYiEmJkatGRNygb1582YMHDgQ1apVy9bJxNbWFk2aNMHkyZNx+PBhrcDOh8GDB2ebrJYV3r9/Dw8PD5iYmODOnTvqDkeLliIh373++++/8z1u1qxZYLFY+aaf/05qaipYLJZSG5Dy+IrT1yQ9PR0WFhaM+fWXL1+Yuu2hQ4diw4YNTLlThw4d8ODBA6xduxbjx49nxoiLi0O1atVgZ2fHaEeBQFBsMRcGjRHd3bp1A0VRSEhIYMx/5G3ELCws0KBBA8bBHPi5A+bo6Agul8sc+6sDupyXL1+CEILDhw+r47ZKNW/fvoVAIChV9fByI77CtBPJyMjAkSNHEB0dDSMjI+b95OLigjlz5kBfXx/Ozs5FajVw6tQpuLi4gMPhYODAgVi1ahVTbysWixEdHY2LFy8W6yTo6dOnEIlE6NKlC4CfKbKEEKxatSrbcT9+/MDmzZtRr149sNlscLlcNG7cGLt37y5xZ+msrCzUq1cP+vr6iIuLy/fYFy9eYOzYsUx9vaenJ+bOnVtmW8pkZGRg8eLFMDU1BY/Hw8CBA0vUUbSo/PjxAz4+PrCzsyvWcoTiJjk5GUZGRoiJiSnR68pkMvTs2ROEECxbtkxl465evRpcLhc1atRg3kdHjx5l+tOX5O6ATCbDo0ePFBLYR44cKdXvI3WwZ88eEELKZA3058+f4ePjAwMDA7X34tWipbAkJyfD2toa9evXz3c++PnzZ0il0gJ7d+eGs7Mz+vbtW+QYX79+rdCigDLIs6vkqeIzZ85kjNICAwMZEzWBQMBkQrPZbBgbG2P58uUYOnQo03mCw+HAzc0NDRo0gLe3d7HFXBg0RnQvWrQIHA4HAwYMyFa7febMmVwdzM+cOYPJkydj0aJF4PP5zDm/m3/dvXtX6ZSKP5lBgwZBV1e31ExuFi1aBC6XW+DOZnp6Og4dOoTOnTvDwMCAacEVEREBFouF1q1bMws4T548gZubG6RSqcL1M3Jomsb58+ezGf55enpi3bp1JeKUnZmZiSpVqsDBwQFJSUlYu3YtCCHMqmBWVhaOHz+ODh06QFdXl9mZX7JkiVqF3IgRI/I1TktLS8P27dtRu3ZtUBQFXV1dREdH48qVK2VuF0cOTdPYsWMHnJycQFEU2rdvX2omzzRNo2XLltDR0cHt27fVHY7STJ8+HRwOJ1fjzuJAJpOhe/fuoChKZaVSWVlZjBFbTEwMk3lw8eJF6OjoIDw8vFizEeQCe9OmTRgwYABCQ0OzCWw7Ozs0bdoUU6ZM0QpsFfHp0ycQQrBp0yZ1h1IsxMfHw9/fH1KpVCMNJLVoyYvBgwdDIBAU2J2lV69ekEgkRcroadKkCcLCwooaItPiecSIEUUeIz9kMhnc3NwQGRnJ/MzJyYn5TjAzM0PDhg0ZE7W0tDSsXLkSfD6f2Q3ncDgwMTGBs7MzzM3NMX36dFAUxdSHqxuNEd1bt25l2g3Ja7UPHjyYzcE8KysLPj4+uHTpEsLCwvD8+XOcOnUKUVFRzB/Fzc0t26Rb2XTjP53Pnz9DLBZj4MCB6g5FIUaPHg0rK6tcX0tLS8OBAwfQsWNHxsHWyckJI0aMwM2bN7F27VqwWCx06NAhx+5OYmIiGjRoABaLhRkzZhQo7D59+oTZs2czZRKWlpbo0aMHAgMDQQhBVFRUibQ6mTRpElgsFs6fP48jR46Aw+EgOjoat2/fZlINCSEoV64cxo8fX+Cuckkgz1bIzU/gv//+Q//+/RlX98DAQKxevTrf+qeywKlTp5iWbPXq1St1wnXatGllqsxHXivWtWvXYr+WTCZjjGB+z04pKsnJyYiMjASLxcLcuXOZ59nt27ehp6eHqlWrqtREUyaT4eHDh9kEtlgsziGwY2NjcfTo0TKbpaIJODs7o2fPnuoOo9hITExEcHAwdHV1cfr0aXWHo0VLgdy9exccDqdAZ/B79+6BzWYXyVQWAMaMGQNTU9MinSsnIiICtWrVUmqMvNi7dy8IIUxG8/fv37NtVhFC0L179zxN1GQyGZYsWYKtW7cCAJo1a4aOHTuCzWZjxowZxRJzYdEY0f3x40emr5pcfIeEhKBly5YICAhA3759IRAIctRys1gscLlcZreSEIJTp04x4x48eLDYaxDKOmPHjtW4/rR5ER0dne0DmZqair1796Jdu3bMgo6rqytGjx6N27dvM5PNlStXgqIodO3aNc9d8qysLAwfPpxxJ/+9NVZmZib279+Pxo0bg8PhgMfjoXnz5jh8+DAj4mmaxsaNG2FiYgKJRIIFCxYUW/rm9evXweFwMGLECNy4cQMikQhubm6MEYWhoSF69eqFS5cuaczu8H///QeRSITmzZszMSUnJ2PlypUICAgAIQRGRkYYOHAgk35Ulrlz5w7Cw8NBCEGlSpVw8uRJdYdUaA4ePAiKojBy5Eh1h6JSZs6cCQ6Ho5K+8Xkhk8nQpUsXUBSFtWvXqmTMly9fonz58hCLxdkydx4/fgxTU1NUrFhRKYdbucDeuHEj+vfvj6pVq2YT2Pb29mjWrJlWYKuJTp06aUyqZXHx/ft3hIWFQSgUllhfYS1aigJN0wgJCYGLi0uBZXz16tWDg4NDkcv9tm/fDkKIUllDEyZMgL6+frHMGYOCghAUFMT899u3b5nvjcjISFhYWEAoFMLV1ZU55ncTtbi4ODg4OMDFxQVVqlRhzteEdmGABoluADAzM2N+Qd7e3ggNDYWXlxeTt6+vr49x48bhxo0buHjxIsLDwxlXaQcHB+bcX2vttmzZAkIIkpKS1HhnpZvExEQYGBgUqYakpImMjETdunWxe/dutG7dmpnseXh4YNy4cbkaTyxZsgSEEPTs2VMhw63NmzdDIBCgcuXKePv2LR4+fIihQ4cy7195O7v8JpPx8fHo1q0bI6b+/fdfpe77d1JSUuDq6gpvb29MmzaNSb3h8Xho1qwZ9u7dq3Ets+Lj41GuXDl4eXkhOTkZly5dQpcuXSASiUBRFOrWrYudO3dqXNzFwcuXL9GhQwdQFIVy5cph+/btGrMwUhgePXoEqVSKBg0alDkzux8/fsDU1BSdO3culvGzsrLQsWNHsFgsrF+/XiVjXrp0CSYmJrCzs8v2LHz9+jVsbGzg6upaqLRFmUyGBw8eFCiwp06dimPHjpUK74GyzooVK8Biscr8nCg1NRXh4eHg8XjZ2tBq0aJJyEv+jh8/nu9xhw8fBiEEO3fuLPK17t+/D0KIUhkg8jiePHlS5DFyQ56V/GsXqq9fvzLfJR4eHli5ciWCg4PBYrGwatUqpKWl5TBRa9GiBfbv349x48Zl26CdOXOmSuMtKholuu3t7UHIz9ZhADB+/HgQQlC3bl34+fmhRYsW2czUxo4dC29vb1SoUAEmJibgcDgghCAiIoIZc9myZaAoqlROWDWJGTNmgMPhaGwvzB8/fmDHjh0wMDBg3gfly5fHxIkT890RnTdvHggh6Nu3b6HeI2fOnIG+vj5j5Kevr4/evXsXWjxfuHABnp6eYLFY6Nevn0omQllZWYiMjASbzWb8DgQCAWbNmoVv374pPX5xIDdO09PTw8iRI5luBra2thg/frxanKLVwdevXzFo0CDw+XyYmJhg0aJFpdblOzExEa6urnBxcSlVHRAKw5w5c8Bms1U+AcnKykL79u3BYrGwceNGlYy5adMm8Pl8BAUFZRPWnz59gqurK2xtbfH69es8z5cL7A0bNqBfv34ICQlhfCDkC99RUVFaga3hyCfeeflllCXS09OZzLMdO3aoOxwtWrLx9etXGBsbo1WrVvkel5mZCXd3d1StWlUpLZORkQEul6tUq8kvX74Uiy9EZGQk3N3dsy3O//jxg/l+4XA4jOEnRVHMz3g8HpYvX46OHTvC09OTyYhmsVjZNnI3b96s0niLikaJ7nLlyjECRl7jbW1tjVevXuVqpib/Uv/w4QNcXV1hbW0NNpuNGjVqMGNOnz4dUqlUHbdTpkhJSYG5uTnatm2r7lAYkpOTsW3bNjRr1gw6OjrMTm5oaKhCPaTlroiDBw9W6EFG0zTOnj2LTp06QSQSgRACPT09cLlcrFy5ssj3kZGRgWnTpkEoFMLKyqpIzpA0TePmzZsYMGAA49xobGwMGxsbGBoaqlwUqBKZTIZWrVoxLpRcLhfNmzfH0aNHy9zuaF6kpKRg2rRp0NPTg0gkwrhx40p1nbpMJkNERASkUmmRXP9LC/LnYocOHVQ2ZlZWFtq2bQsWi6WSiYJMJsPo0aNBCEH79u2zpSYmJCSgYsWKMDU1xePHj7PFcP/+/XwFdvPmzTFt2jQcP34c8fHxSseppWSQyWQwMDDA2LFj1R1KiZCRkYFWrVqpdAFLixZVEBMTA4lEgnfv3uV7nDwbUxWu/F5eXkpnrTo4OKBfv35KxyLn3r17IIRgzZo12X6+efPmbLvVNjY2AABfX1/cv38f1apVYwS4/J+hoSG4XC78/PyYkmVdXV2NyezRKNEt7wksT6k0MDDAgwcPspmpAUBAQAA+fPiADx8+MBOIqKgopn67cuXKzLGjRo1i/lBalGPx4sWgKKpQvQFVTVJSEjZv3ozGjRszK1p+fn6YOnUqnjx5Aj6fj/nz5xc4zpQpU0AIwciRIwsU3G/evMGUKVMYF0V7e3tMnDgRL1++RFpaGjp37gxCCAYOHKhUffbz58+Z+t3IyEiFdndfv36NqVOnwsPDg3ngiEQiVK5cGQ0bNoSOjg6uXr1a5JiKk5cvX2LcuHFMmzYTExPMmTPnj3IpzsrKwurVq2FlZQUOh4NevXrhw4cP6g5LaUaNGgWKovLsA1+WmDdvHlgsVjbRWlQyMzPRunVrsNlsbNu2Tenxfvz4wRiNxsbGZnvW/fjxAyEhIZBKpdi9ezfWr1+Pvn37Ijg4mFlUJITA0dFRK7DLGA0aNCg2MyRNJCsrC506dQJFUUotkGvRoiouX74MiqIKnK8mJCTA2NgY7du3V8l1W7VqheDgYKXGaNGiRbbaa2Xp1KkTLC0tc5QOduzYES4uLsx3EZ/Pz+Y3Eh4ejlu3buHVq1e4f/8+3r59i61bt2LIkCEYNWoUc54mGUdqlOiW17jK/9na2jJmaiEhIdi+fTusrKxymKlZWVmBz+cjODgYoaGhsLW1Zcbs06dPNsGupeikp6fD3t4ejRs3LtHrJiQkYMOGDYiMjGTSpf39/TFjxoxsJkbfvn0DISTfySpN00ytx691IL+Tnp6OnTt3Ijw8HCwWC0KhEO3atcOpU6dy7L7SNI158+aBzWajbt26SqVwy9tCWVhYQCQSYebMmTl6zycmJmLNmjVMmo1AIEDLli1x4MABNGvWDPr6+mjfvj3YbDYOHDhQ5FiKg/T0dOzYsQN16tQBRVHQ0dEBl8tFWFjYH7OrDfz8O+/bt49ZLGnevLlGZyMUhh07doAQgqlTp6o7lBIhNTUVFhYWaNeunVLjZGZmomXLlmCz2SpJhX379i38/Pygo6OD3bt3A/gpPu7du4fVq1fDzs6OebbJv0vLlSuHFi1aYPr06Thx4oTGlqNoUY4pU6ZALBaXaA92dSOTydCjRw8QQpRKr9WiRVkyMzPh4+MDHx+fAj+DgwcPho6OjsqMjCdPnqy0EdrMmTMhFApzzE2LwuvXr8HlcnOtua5WrRrq1q3LZG8SQlCtWjUkJCTkMFCTExUVhcGDBzPHq3uj8Hc0SnTfuHEj2y9KLqLr1KkDOzs7EELA5XLRpk0b7Nq1C3Xq1IGJiQkjxMzNzTF27FgQQnD37l0AQIcOHVS6IvOns27dOhBCin33ND4+HmvXrkWDBg0YE7AqVapg9uzZee4AP3z4EIQQnDlzJtfXaZrGyJEjQQjBlClTcj3mzp076NevH7P76u/vj2XLlilUk3rs2DHo6+vD2dlZ6ZTaxMRE9OnTBxRFoUKFCjh//jz++ecftGzZEkKhEBRFoUaNGli9ejWz8rdx40YQQtCyZUsQQlTWz1cV3Lt3DwMGDGB+r1WqVMGCBQvg6OgILy+vEulZrilcunQJISEhIISgevXqGpuJUBRu374NHR0dtGzZ8o/y0Vi4cCFYLFaRP/cZGRmIiooCh8PBrl27lI7nxo0bsLCwgKmpKSZMmIC//voLQUFB2XawCSEIDQ3VCuw/kDNnzoAQgps3b6o7lBKFpmn0798fhBCNaSGk5c9j/vz5oCgKV65cyfe4uLg48Hg8jBs3TmXXlrflUqZlrfz5oYrWpYMGDYJUKs3RMYOmaUgkEri7u2PatGnZhLetrS1atGiBoUOHMsdnZWVhx44d2cqg5J5gmoRGiW4A8Pf3Z3oJA8CrV68glUoZMdO8efNsZmrt2rXDgAED4OfnB0dHR8ZES76y36hRI9SrV09t91PWyMrKgpubG2rXrq3ysb9+/YpVq1ahXr164HK5zMLLvHnz8jX4kXP69GkQQnKd+NI0zax+/f5lGx8fj0WLFsHPz49Jcx40aFCRers/efIE7u7ukEgk2drxFAWaprFu3ToYGxszDxBXV1dMnToVr169ynbsy5cvIZVKmRYJmlCvl5ycjFWrVjExGRkZYcCAAbh37x5kMhnCw8Ohr6+vseZ8qubhw4do0qQJY/J36NChMiVMP3/+DDs7O3h7e6u0x3NpIC0tDVZWVmjdunWhz83IyEDTpk3B5XKL5OcA/Hwu//fff1i3bh2TnSPv+kEIgZOTE1q2bInp06ejQYMGoChKJeJeS+kkJSVFaUOl0sqvi++a0kZIy5/Du3fvIJFIFKqrbtq0KSwtLVW6KfH06VMQQpRqpZecnAwWi6V0qca3b98gFosxfPjwHK+dOnWKqcf29PQEh8PJUb9NCIGXlxcqVqzI+Dr9/k9VrTZVhcaJ7gMHDoDL5aJv37748eMHnJ2dwefzcenSpVzN1GrXrs00io+KikKtWrXAYrEY0VGjRg20bNlSXbdTJtm5cycIyd4Pvah8/vwZy5cvR+3atZkPVWhoKBYsWFDolbht27aBEJJjV5qmafTt2xeEEMybNw/Az1SzY8eOoVWrVuDz+WCz2YiMjMSePXuUdotOTExEREQEKIrC9OnTCy2sXrx4gcmTJ8PV1RWEEJiamqJatWrQ0dGBmZkZtm7dmm1MmUyG6tWrw8jICGw2G126dFGbmKNpGpcvX0bXrl2hq6sLiqJQp04d7NixI1u9jrzm9/Dhw2qJsyR59+4dYmJiwGazYWNjg/Xr15e5tM7MzEzUqFEDRkZGePHihbrDUQtyz4vC9I+XuytzuVzs3btXoXMyMzNx9+5drF27Fn369EFgYGCOCYe1tTWmTJmCkydPZnseDh06NFfDGi1/Hv7+/gW6JpdlJk6cCEIIRowYUaYWP7VoNq1atYKxsXGB3hjy3WRVtYuUI5PJIBQKMWvWLKXG8fT0zNaeuSjExsaCz+fj/fv3OV6LioqCra0tkxnp4+MDT09P1K5dO1dx/bvhWqNGjSASiTSuc4rGiW4AsLOzQ4cOHZh2Tvv3789hplalShVkZmYiKiqKcfRbunQpli5dCk9PTybX39fXF926dVPLfZRVaJqGr68vAgMDi/Rl9fHjRyxduhRhYWFgs9lgsVioUaMGFi9enOuHT1HmzZsHgUCQQ5DK67gWL16M58+fY+zYscyH2dXVFdOnT1fqurkhk8kwYsQIEELQtm1bpKSk5Hv8t2/fsGLFClStWhWEEOjo6KBNmzY4fPgwUzfz+vVrNG7cmEmZiYuLAwDMmjULhPxsCxYeHq6SOpvC8vnzZ8yZM4epUbaxscG4ceNyFWC7du1ijJ3KMomJiRg1ahR0dHRgYGCAWbNmITU1Vd1hFQt9+/YFh8NRqv9naSctLQ02NjYKL/Kmp6ejYcOG+fYRzk1g/1qD7ezsjFatWmHq1KmoVasWk+WS23M5NjYWhBDMnTtXqfvUUjYYMGBANv+bPxF5B5N+/fpphbeWYuf48eMghGDdunX5HieTyeDr6ws/P79i8brx8/NDp06dlBqjU6dO8PHxKfL5qampMDU1zVWf0TQNPp+P2NhY2NnZoXz58vD19WVef/ToEezt7WFubs6UF/P5fBgYGKB169ZITU2FiYkJOnfuXOT4iguNFN29e/eGkZERxGIxPD09ERAQgJCQEBgbG+Pt27eMaZU8fY7D4cDY2BgSiSRbn7YnT57AyckJgwcPVvctlTkOHz4MQojC7sTv37/HokWLUL16dbBYLLDZbNSqVQvLli3Dx48fVRLT8OHDs00iZDIZunbtCoqiEB0djbCwMBBCIBaLER0djYsXLxb7F+2WLVsgFApRqVKlHEYY6enp2Lt3L5o1awY+nw8Wi4VatWph/fr1+baL2rdvH2xsbCAQCNCnTx9wuVzo6OjAz8+vRNtMyWQyHD16FM2bNwePxwOXy0VUVBQOHz6c507uvXv3oKuri6ioqDI7yUlLS8O8efNgZGQEgUCAYcOGlel62TVr1mjNif6fZcuWKWTckpaWhoiICPB4POYZmpmZiTt37mDNmjXo3bs3qlSpkqvAnjlzJk6fPs3UwH38+BGBgYHg8/nYsmVLrteTt5zRhLITLZqBPGNNVQZNpZVFixaBEILu3bv/UWaeWkqWtLQ0ODs7IyQkpMC5z9q1a0EIwblz54ollo4dO2br8lQUFi9eDA6HU+SNhOXLl4OiqFzb+yYlJYGQn73AK1asyGzkyPndRO3XjOfmzZszJVTKpNAXFxopuv/7779sNazBwcHYunUrQkJCmJptJycnzJgxA4sWLYK3tzeMjY0ZJ2dDQ0Po6+tjyJAhMDEx0dbtFAM0TSMkJATe3t55flG9ffsW8+fPR9WqVUFRFDgcDurUqYOVK1cWS1uozp07w9/fH8DPCWz9+vVBURQzcQ0NDcW6detK3LTrxo0bsLKygrm5OS5duoRLly6hV69eMDQ0BCEEFSpUwMyZMwuVTp+cnMwYwlAUBXNzc5UtXhTEq1evMH78eCZbwN3dHbNnz8anT5/yPe/bt29wcnKCp6dnqe5BnRcymQybNm2Cvb09WCwWunTpopAXQWnm8uXL4PF46Nq1a5ldRCkM6enpsLW1RVRUVJ7HpKamMr4VAwYMQK9evRAQEMA8pyiKgouLC1q3bo1Zs2ZlE9i/c/fuXdjZ2cHU1BSXL1/O9ZjNmzeDoij07dtX+zfSwvD+/fsCu338KaxatQoURaFjx45lrvRHi2YwadIkcDicAhdkv3//DgsLCzRr1qzYYpk5cyZEIpFSi0zXrl0DIQSXLl0q9LlZWVlwcnJC06ZNc3395MmTzELY+vXr8ddff4EQgpkzZ0Imk2Ht2rXZug81b94c169fR2pqKuMhRAjJ4X2kCWik6AYAZ2dnEEKYVFl5qnnlypVRvnx5tGjRIpuhGvDzS6Rp06agKAoWFhaoU6cOBAKBQn2btRSes2fP5vjSfvXqFebMmYOgoCDGbT48PBxr1qzB169fizWe8PBw1K1bFzNmzIBUKgUhBPr6+hg5cqTa2zFduXIF1tbWjBGEhYUFBg8ejDt37hR5zAEDBoAQAjabDUIIunTpgi9fvqgw6v8hb6FWt25dUBQFkUiELl26KJwtIJPJUL9+fejp6ZVJ47Rjx44xK7KRkZFFMuErbbx9+xbm5uaoUqUK0tLS1B2OxrBixQoQQpjPdmZmJm7fvo3Vq1cjJiYGenp62bp0yAX27NmzcebMmTwF9u/8888/EIvFqFChQp4dHfbv3w8Oh4OOHTtqd/G05MDBwQF//fWXusPQCDZt2gQ2m42WLVsq7euiRcuvxMXFQSAQYMiQIQUeO3bsWPB4PKZ8sDg4dOgQCCHZWu4WlvT0dPB4vCLpK3mJYV7u7a1atQKHw0FwcDBq1aqF2rVrM1529c0AAQAASURBVF2MHB0d4ebmhgsXLoCmadA0jdGjR6Nu3bowNDQEi8VC7dq1wWKxNNLQVWNFd//+/SEQCAD8r++rubk5Xr58mauhmpyoqCjMnj0bbDYbpqamGuleV5aoV68eHBwcMG3aNAQEBIAQAh6Ph4iICKxbt65E0mozMzNx4MAB6OnpgaIo5t+IESPUumr99etXLFmyhFmAEIlEcHJyYmrIlKm9PnHiBLOocenSJSxZsgRSqRRGRkZYt26dyna07t+/j4EDBzIO6gEBAVi5ciWSkpIKNc7o0aNBURQOHTqkkrg0hRs3bjC1tFWqVCm2dDBNIy0tDQEBAbC0tMS7d+/UHY7GkJmZievXr8PIyAgODg7w9/dnyp3ki1UsFgvdu3fHmTNnCv05An5mGc2ePRssFguRkZF5Zo2cPn0aAoEAjRs3VovPgxbNp127djnmUH8yO3fuBJfLRePGjbULiVpUAk3TCA8Ph7W1dYEZfq9fv4ZQKFRInCvD69evQQjBvn37lBqnUqVKaNeuXaHOoWkalStXRrVq1XJ9/ePHj+ByuahUqRJsbW2xceNGGBkZMX3N5W1n5XXcvzqa6+rqonnz5vDy8kJkZKRS91ZcaKzoXrlyJQghSEtLg7W1NQwNDfHgwYNshmrytN3OnTujQ4cO6NWrF2xsbJCeno4FCxYwf4iitmHRkjdxcXGYPn063N3dmbr6Ro0aYePGjQrv1CjLw4cPMXToUJibmzMxmJiYKNV6R1nS0tKwe/duNG7cGDweD2w2G/Xq1cPmzZvx48cP0DSN+fPng81mo06dOgU6WObGt2/fmF6Ee/bsYX7+/v17pkd3jRo1itwz+Pv371i9ejWzWGBoaIj+/fsXmBaVF7t37y5zxmnPnj1D69atmRKYv//++49J3aVpGp07dwafzy9TPcYLS0ZGBm7duoVVq1ahZ8+eOQQ2IQTh4eGYM2cOjh49iurVq0MoFOLEiRNKXTM6OhqEEAwePDjPRcVr165BLBajZs2aWvGgJU+WLFkCNptd4iVXmsz+/fvB4/EQHh5eoAGqFi0FIZ//KDInbdeuHYyNjYt9Dk3TNKRSKaZMmaLUOD179oSrq2uhzpG39s2rpe7MmTPBYrFw7NgxZqPnd8O2+fPno2nTpliwYAHq16+PESNGMLvaFy5cACFEYzvjaKzovnz5MgghGD16NAghsLe3R0hICFq0aAEXFxeUL18+T7t4LpcLT09PJo1PmUmOlv/x5MkTxMbGMmm0QqEQTZs2hb+/P2xsbEpkcpeUlIRVq1YxglBfXx+9e/fGhQsXQFEU2Gw2Dhw4UOxx/ApN0zh//jxiYmKgr68PQgh8fX0xZ84cfPjwIddzjh07Bn19fTg5OeHBgweFup7895/XA/Pw4cNwcHAAj8fD2LFjFTK6oGkaV65cQXR0NMRiMSiKQu3atbF9+3al/q7379+Hrq4umjVrViZE6adPn9C3b19wuVyYm5tj+fLlf9wuonxBsyAH1rKEXGCvXLkSPXr0QOXKlbMJbDc3N7Rt2xZz5szB2bNnER8fD0dHRzRq1Ag/fvxAWFgYdHR0lGqz+PXrV1SvXh1cLherV6/O87h79+7B0NAQAQEBZdI7QYvquHPnDgghOHnypLpD0SiOHj0KoVCIGjVqaBcktBSZ5ORkWFtbo379+gXOf65evQpCCJYuXVoisQUFBaF169ZKjbF27VpQFFWoRYJ69erBy8sr199HSkoKLC0toa+vDwBwdHSEiYkJKlSokO248PBwpjXn2LFj4e3tjapVq2Lv3r1wd3eHVCrV2HIqjRXdNE2jQoUKkEgkYLFYCA4ORnBwMJMyrsg/gUAAFouF8+fPq/t2Si0PHz7EpEmT4O3tzbSyat68ObZv385M6O7fvw8Wi4UFCxYUSww0TePcuXPo1KkTRCIRIwi3bt2K1NRUpKSkoHr16iCEYNSoUcUSQ248fvwYY8aMgYODAwj52Rt3+PDhCtfzPnnyBO7u7pBIJAq7wPfp0weEEDRs2DDf41JSUjBy5EhwuVw4OTnlufD05csXzJ07F15eXsw9jB07ViW9lhMSEuDs7AwPD49SP/n//v07Jk2aBLFYDIlEgsmTJ/+Rk7GTJ0+CzWajf//+6g6l2MjIyMDNmzezCWx5WxK5wG7Xrh3mzp2Lc+fO5fneljvQ+vn5QSQS4cyZM0WO6dGjR3BycoKhoWG+4zx79gwWFhbw8vIqUhaNlj8LmUwGqVSqNZvNhTNnzkBXVxfBwcEllr2npWwxePBgCASCAmunaZpGUFAQPD09S2wRPyYmJoeYLSz37t0r1KLd7du3QQjBhg0bcn19+vTpzGZaVlYWwsLCYGJiwpQUAzmdy+VeUXfv3oVQKASPx0ONGjWUuq/iRGNFN/DTUp7D4WDcuHFIS0tDaGhoNlEtlUrh4uKCdevW4f79++jduzcCAgIYh3P5v3nz5qn7VkoV9+/fx/jx4xkhpquri5YtW2LXrl15GhN06NABpqamKhUib968wZQpU5g6aHt7e0yYMCGbadD3799Ro0YNZtepuBdYPn/+jIULF8Lf3x+EEEgkEnTp0gWnTp0q0spaYmIiIiIiQFEUpk2blu9q6JYtW0AIga2trcLXunfvHkJCQkDIz37hHz9+hEwmw7Fjx9CiRQum1VezZs1w6NAhldXAy2QyNGjQAHp6emo3sVOGzMxMLF26FGZmZuByuejXr1+xOO+XBp4/fw5DQ0PUrFmzzOzuywX2ihUr0L17d1SqVIkR2CwWC+7u7goJ7Nz49u0bhEIh2Gw2zp49W+QYjx8/Dj09Pbi5ueVrrvPu3Ts4OjrC0dER79+/L/L1tPxZ1K1bF3Xr1lV3GBrJpUuXIJVKUblyZe0ilpZCcffuXXA4HEyaNKnAY7dv3w5CCI4ePVoCkf1kwYIF4PF4Sn2XZ2VlQVdXF1OnTlXo+LZt28LGxiZXo0KZTAZ7e3vGHHjJkiXYsGED7t+/Dx6PBx0dHURHR2P8+PHZnMvl2k8sFkMgEMDKygpdu3Yt8j0VNxotun/8+AE2m425c+eiZ8+ejIgWi8Xg8Xh48eJFNjO1uLg4ODg4wNHRkTF+ktekalcq84amady9exdjxoxharTFYjHatGmDPXv2KFTX9OzZM3C5XIU/fHkhd8kODw8Hi8WCUChEu3btcPLkyRxCMykpCVWrVoVIJMKcOXNACCkWZ+zU1FRs374dERER4HA44HA4aNCgAbZt26aSmi+ZTIYRI0aAEII2bdrkOua///4LNpsNPp9faOMqmUyGVatWQU9PD0KhkGlV5ubmhlmzZhXY6qsojBkzplQbp9E0jd27d8PFxYX5uyjj9Fna+f79OypUqAB7e/tic8gvbtLT0/Hvv//mKbA9PDzQvn17zJs3D+fPn1dqATE5ORkhISHMYuC1a9eKNM7SpUsZ/4eEhIQ8j/v69Ss8PT1haWmJ58+fFzFqLX8iEydO1Oh0THVz48YNGBoawtvbu1i+K7WUPeQtdV1cXAosz0tNTYW9vT3q169fQtH9RN6Wq7Dljb8TGhqaZ+uvX3nx4gWj53Lj4MGD2bp6eHl5gcvlombNmmCz2RCLxeByuSCEwMjICM7OzrCwsGBKXQcPHgw7OzsQQrB//36l7qk40WjRDQAGBgYYPnw4s3vN5/Nx+vRpxkwNAKpUqYLMzEy0aNGCqZmLiYlhJsyEECxcuFBNd6CZ0DSNW7duYdSoUczvSSqVon379ti3b1+R6nh79eoFfX39IjmW37lzB/369WOcCf39/bFs2bI8J5qJiYkIDAyEWCzGhQsXsGnTJhBCVJbGLJPJcPr0aXTt2pVpP1a5cmUsWLCg2L54t2zZAqFQCD8/P7x584b5+fPnzyGRSEAIwa5duwo1ZkZGBnbt2oXw8HCm5p0QgvLly+Pu3buqvgUAwN9//51vzbmmc/bsWcaJv3bt2vj333/VHZJaoWkaUVFREIlESrW4K0nkAnv58uWIiYmBn58f03JE1QL7d5KSkhAUFASxWIxz587BxcWl0BOqzMxMpjdpnz598t2NSE5Ohr+/PwwNDZk6Ny1aFEXeCaO4vg/KAnfv3oWJiQnc3d21WSRaCkReWnT8+PECj502bRrYbHaJP7s/ffoEQgh27Nih1DiDBg2CjY1Ngcf17dsXBgYGeX7XxsTEMHqtcuXKkEgkjIGar68vgJ8Gavr6+hg/fjwGDhyITp06wcDAAObm5qhcuTJCQkKgo6Oj1q5FBaHxojswMBDlypVj/hgWFhYICQmBsbExPn36hKNHj4LH40FXVxccDgc2NjaoVKkSDAwMYGtry5zn7u5eJoyclIGmady4cQPDhw9nUrb19fXRqVMn/PPPP0hPT1dq/Hfv3kEoFCpcV/3t2zcsXrwYfn5+IITA2NgYAwcOLNAl+9u3b6hcuTKkUinT52/WrFkQiURKxQ8ADx48wIgRI5j3jp2dHUaNGlVkJ/DCInfkNzMzw6VLl/D161fY29uDoih06NBB4XEePnyIwYMHw8TEhFnEWLFiBZKSknDq1Cm4uLiAw+Fg2LBhKu1leP/+fYjFYjRt2rTUfd7+++8/REREgBCCihUr4tixY+oOSSOYMmVKkRZ8Sor09HTcuHEjT4Ht6emJDh06YP78+bhw4UKx1uInJiaiSpUqkEgkuHTpEgAwC4J59ST9nYSEBNStWxdsNhuLFy/O99jU1FSEhYVBLBbj+vXrSsev5c/j+/fvYLPZJWbgVFp58OABLCws4OzsjNevX6s7HC0aytevX2FsbIxWrVoVeOzHjx8hFovRu3fvEogsJyYmJhg7dqxSY2zbtg2EEHz8+DHPY758+QIdHR2MHj06z2MaN27M6DV5ZrO1tXW2Y341UAOA5s2bY//+/Rg4cCDjN2NgYKDU/RQ3Gi+6V69ena0+u1KlSti6dSsaNmwIHR0dxtyrS5cu6Ny5MywsLJgUBKlUyqQPEkL+mB66v0LTNK5evYohQ4Ywhl+Ghobo2rUrDh8+nGtthTIMGTIEIpEozw+gTCbD8ePH0bp1awgEArDZbERGRmLPnj0KxfL161dUrFgRBgYGuHHjRrbrOjo6Finmjx8/Yu7cufD19QUhBHp6eujWrRvOnTunFuH44cMHBAYGgsfjwdHRERwOB/b29gWKhe/fv2PNmjUIDg4GIQQGBgbo169frjsYaWlpmDBhAvh8Puzt7fNs31AYSqtx2uvXr9G5c2ewWCw4ODhgy5Yt2lTL/+fAgQOgKApjxoxRdygAfgrs69evY9myZejWrRt8fX3VJrB/JyEhAQEBAdkWA4GfdW9ubm6oV69egWPExcUx7qsF1fdlZmaiUaNGEAgEOH36tNLxa/lz8fX1LXS/3T+Rp0+fwsbGBvb29n90uZGWvImJiYFEIlGoDDAmJgZ6enpqK9mqUaMGmjVrptQYz549AyEk365BEyZMgEAgyDdLVN6RSJ5h2K9fPxBCsGTJEgA5DdTOnDmDyZMn49SpU0wmHovFUmjXXZ1ovOj+8OED84cICgoCAFy5cgVCoRBmZmZwdHREs2bNUL16dVy4cAEA4Ofnh6dPn2LgwIHZGqcvWrRInbdSYtA0jcuXL2PgwIHMjq2xsTG6deuGY8eOqVxo/8qXL18gkUhyuBs/f/4cY8eOZeJxdXXF9OnTC5Wq9enTJ1SoUAFGRka4detWttfat2+PwMBAhcf68eMHtmzZgvDwcLDZbHC5XDRq1Ai7du1SqMVWcfPjxw/md0VRFPPe/h35okpMTAzEYjEIIahVqxa2bt2qUInA48ePERYWBkIIoqKi8Pbt2yLFKzdOk0qlePz4cZHGKGni4+MxdOhQCAQCGBkZYf78+Upne5QlHjx4AIlEgoYNG6plESItLS2HwJYvqLJYLHh5eaFjx45YsGABLl68qNKMjcIiz77R09PLtX5769atIITg4sWLeY5x9uxZGBkZwdHRscA6O5lMhg4dOoDD4ZR4i0QtZY+//vqryIvWfxovX76Eo6MjrKys8OjRI3WHo0WDuHz5MiiKwvz58ws89s6dO2CxWJg9e3YJRJY7f/31V6H7bP8OTdMwNDTMc8c8JSUFRkZG6NmzZ77j2NjYMFptzJgxkMlkTKZmWFgYevfune0aTZo0waFDh1C9enVQFAUWiwVCSI6e3pqGxovuV69eMX+IJk2a4OnTp9DX14euri7u3LnDWMn/aqjWpEkTXLlyBd+/f4e5uTlTxzp58mQ1303xIZPJcOHCBfTr1w/W1tYghMDU1BQ9evTAyZMnS9RtePz48eDz+Xj8+DE2bdrEiDpdXV107doVFy9eLPQO8ocPH+Dh4QFTU9Nc08/r1KmDJk2a5DuGTCbDiRMn0LFjR0agVqlSBYsXL9YocyiaptG7d29GcMtbpP3qnvr161fMmzeP6VdvZWWF0aNHF2n1naZpbNy4ESYmJpBIJFi4cGGha2LGjh0LiqJUsmNe3KSmpmLGjBnQ19dnUp60RovZ+fbtG5ydneHm5lYiv5u0tDRcu3YNS5cuRXR0NCpWrMgIbDabrVEC+3fi4+Ph5+cHfX39bNk3vyKTyeDh4YHatWvn+vratWvB5XJRrVq1Ap9FNE3jr7/+AkVR2Lx5s9Lxa9EiXxT68OGDukMpFbx9+xaurq4wMzNTuEWolrJNZmYmfHx84OPjU+D8iaZp1KpVC05OTmpd6F+2bBnYbLbSG0316tVDeHh4rq8tWrQILBYr384br1+/zrZBymKxGAM1AwMD6OrqMlm6jo6OkEgkzPF8Pp/JepZ7oGgyGi+6P3/+zPwy69ati8jISPD5fFy+fBkpKSm5GqrFxcUxb4IGDRogNjYWhBD06NFDjXeierKysnD27Fn06dOHcfEzNzdH7969cfr0abWYCdA0jVOnTkEgEDBpn1WrVsXatWuLnOop/4IzNzfPcweoQoUKea6k3b17F0OGDIGVlRUIIXB0dMS4ceOKxelcFUybNg2EEJiYmKBy5co4cuQI9PX14eTkhFWrVqFVq1bg8/ngcDho2rQpDh48qJK/dXx8PLp168aUcShqILZnz55SsaiVlZWFdevWwcbGBmw2G927d9ea4uRCVlYWwsPDoaenVyxZCwUJ7PLly6NTp05YuHAhLl26pJIOAcXF169f4evrCwMDgwI/L/K2ML9mrchkMgwdOhSEEHTt2lWhCdjYsWNBCNHW4GpRGa9fv9Zo3wZN5OPHjyhfvjyMjIxw8+ZNdYejRc3Mnz8fFEUp5N1x4MABEEKwZ8+eEogsby5cuABCSI7M0cIyZswYGBkZ5dhMy8zMhIODA1q0aJHv+TNmzIBQKGQ2wyiKwufPnxkDtUWLFsHY2BhDhw5Fu3bt0LZtW/Tt2xfly5fHpk2boK+vz+hETTcT1XjRnZWVxaxiiEQiEEJgZmaGkJAQtGzZEkFBQQgKCkL58uXBZrMhFArh4uKC8uXLw9zcHBKJBGvXroWLiwv8/f3VfTtKk5WVhVOnTqFXr14wMzMDIQSWlpbo27cvzp07p7Za1E+fPmH27Nnw9PRk+ldTFKWQe2N+vH79Gk5OTrCysspXAJiammbr3ffu3TvMmjUL3t7eTH1zz549cenSJY02+Nq4cSNj5KWjo4NHjx7h9evX6N+/PyNMrKysMGPGjHyNK5Th/Pnz8PT0BIvFQv/+/fOtz37w4AHEYjGaNGmisb9Xmqbxzz//MH3nmzZtqk0LzIfhw4eDxWLh8OHDSo+VlpaGq1evYsmSJejatSt8fHzyFNjyhdTSwpcvX+Dj4wNDQ0OFJi0ymQxeXl6oWbMmgJ+u440aNQJFUZg9e7ZCnx95a0RlWzNq0fI7NjY2GDBggLrDKFV8/foVfn5+0NPTU9goUUvZ4927d5BIJOjevXuBx2ZkZMDV1RXVq1dX+5wpISEBhBBs3LhRqXH2798PQkiOdpXyDJq8MsDkdOzYEeXKlUPt2rUZ8Vy9enVmPvC7gRrwP0+TLl26ZDtH09F40Q0AnTt3zmamVqVKFYSGhqJhw4Zo164dI8YlEgl8fX1Rp04diEQiZnInEonQvXt3sNnsUuk6mZmZiePHj6N79+5MjYP8C/LixYtqE9qZmZk4cOAAmjRpAi6XCy6Xi6ioKBw6dAjJycmwsLBA69atizz+ixcv4ODgAFtb23zTprOyssBisTB//nxs2LABtWvXBovFAo/HQ7NmzbBnz55SUat7/Phxpi8hIQQxMTGoX78+WCwWdHR00KZNGwQFBYGiKEydOrVYH9gZGRmYOnUqhEIhrKys8Pfff+c4JiEhAS4uLnB3d0dSUlKxxaIMV65cQbVq1ZiMC7mjtJbckX9JTp8+vdDnpqam5hDY8laPbDYbFSpUQOfOnbFo0aJSJ7B/5/Pnz4y/xO3btxU+b9euXUybFm9vb+jq6ipcky03FR06dGhRw9aiJU9atWpVJjYmSpqEhASmfemfaNar5ednx9jYOFsJYF4sWLAAFEVpTHaEtbU1hg0bptQYcu+t7du3Mz+jaRoVK1ZkFpnzIjMzE/r6+nBzc0PNmjVhaGjIaL3AwECcPn06m4EaAMTGxsLKygqOjo7ZUtLPnz+v1H2UBKVCdF+/fp35pf5at1uvXj2myP7QoUOoV68esxoSGBiIjIwMHDhwABYWFkz+v7I96UqKjIwMHDlyBNHR0Uzvajs7OwwaNAhXrlxR6wrZo0ePMGzYMJibm4OQnz2f582bh8+fP2c7bunSpaAoqki9fePi4mBrawsHBwe8ePEiz+OysrIYoSB3qg8JCcHy5cuL1C9cXdy6dQtisRj+/v7Q0dFhUvMrV66MZcuWMXW1MpkMI0eOBCEErVu3Lnbh8uzZM4SHh4MQgoYNG+LVq1dMHBERERprnPb48WNERUWBEAJPT08cOHBA7avKms7NmzchFArRunXrAn9XqampuHLlChYvXowuXbrA29ubEdgcDiebwL5y5YpGmBOqik+fPqF8+fIwNjYudG9jmUwGJycn8Hg82NraKvxs3LlzJ1gsFmJiYrTvYy3FwsKFC8Hlckv1Ypi6SE5ORrVq1aCjo4MTJ06oOxwtJcjx48dBCMG6desKPDY+Ph4GBgbo3LlzCUSmGPXq1UNERITS41hbW2Pw4MHMfx87dgyEkAJbr8rLEyUSCdavX49Lly4xpmjyf5aWlpg9ezbWr1+PRYsWMXPSX//Vr19f6XsoCUqF6AZ+imgul4uYmBgAP+sn5EXzMpksh518pUqVmP8/fPhw5o+kyXXd6enpOHToEDp37gwDAwMQQuDg4IChQ4fi+vXrap1sJSUlYdWqVUw7Kj09PfTq1Qs3btzIM66MjAw4ODigYcOGhbrW48ePYWVlBScnpzwzE27duoWBAwcywl++M1wa23g8ePAAenp6TMYGRVHo2rVrvhPyrVu3QigUws/Pr9izN2iaxo4dO2Bubg6RSIRZs2Zh9OjRoCgK//zzT7Feu7B8+PABPXv2BIfDgZWVFdasWaMWb4PSxqdPn2Bra4uKFSvmmHT/LrArVKiQTWB7e3ujS5cuWLx4cZkT2L/z8eNHeHp6wsTEJFdDx4LYsmULk4G1e/duhc45cuQIuFwuWrZsqX0vayk2/v33XxBCcPbsWXWHUir58eMH6tSpAz6fXyoMRbUoT1paGpydnRESEqLQ/Lx///4QiUQKtRMrKQYPHgx7e3ulx2nSpAmqVavG/HetWrXg4+NT4O+ldu3acHNzAyEE9vb24HK5TPuv34V1bv/km20FtdjUFEqN6H7y5AkEAgE6dOiA9+/fg81mo379+swfdO3atdlqegMDA5m06969e+PKlSto2LAhpFKpQq2USoq0tDQcOHAAHTt2hJ6eHgghcHJywogRI/Dvv/+qVWjTNI1z586hU6dOEIlEjIv21q1bFZ5Yb9iwAYQQXL58WaHjHzx4AHNzc7i6uuZ4ML1+/RrTpk1janONjY3Rp08fZgEmvx1xTYOmaVy7dg0dO3ZkHi5OTk4ghGDr1q0KjXHjxg1YW1vDzMysRNKmExIS0Lt3byZrRJH6pZIiKSkJY8aMgUgkgp6eHqZPn67dsVGQjIwMhIaGwsTEBI8ePcLly5exaNEidO7cOV+BffXq1TItsH/nw4cPcHd3h5mZWaHNWmiaZgzQWrduDW9vb1StWrXA5/uFCxego6OD+vXrF2urRy1aMjMzoauri9jYWHWHUmpJS0tDZGQkuFxuriVZWsoWkyZNAofDUWgB9vHjx+ByuZg0aVIJRKY4a9euBSEkX+8eRYiNjYVYLIZMJsONGzcUmsu+ffsWhBCsXr0arq6usLCwgI+PD3x9fZGcnIy5c+cyi9S//6MoCtWqVUPDhg3h7OystjLbwlJqRDcA1K1bF87OzoxZl4+PD2OoVqdOHfj5+cHDwwP6+vrgcDiws7ODq6srOBwOPD09cf/+fRBC1N5mJTU1FXv37kW7du0glUpByM++1aNHj8bt27fVnj749u1bxMbGMiLQ3t4eEyZMwMuXLws9VlZWFjw8PAqs6wB+uoybmJjA09OTaV2SlJSENWvWICwsDBRFQSAQoEWLFjhw4AAzCV23bh0IIaVCAMTHx2PBggWoUKECCCHg8XgQCoVYv349dHV10alTp0KN9+HDBwQFBYHH42HNmjXFE/QvPHjwADo6OpBKpaAoCj179kRCQkKxXzcv0tPTsXDhQpiYmIDP52Pw4MEK1VVp+dk/8/Lly6hatSooioKjoyPTXpHD4cDHxwddu3bFkiVL/jiB/Tvv37+Hm5sbzM3N8fDhw0Kdm5KSghYtWjAO/zRNY9++fSCE5JuKeuvWLejp6aFq1araBSQtJULNmjXRoEEDdYdRqsnIyEBUVBTYbLbCC+haSh9xcXEQCAQYMmSIQsc3bNgQNjY2Gvcsl5fvKmsEeOLECcY9vGXLlrC3ty+wVfHFixdBCMHNmzfRvn17UBQFFxeXbMeEh4dj27ZtWLduHRYsWIDVq1fj+PHjqFChAi5cuAA2m63WXueFpVSJbnmNAIvFgp6eHoKDg7F161b069cPhoaGTH9qe3t7eHl5wdraGvr6+kx9bOPGjREQEIDg4OASjz0lJQW7d+9G69atGVt8Dw8PjBs3rkhpiqomPT0du3btYoy7BAIB2rZti5MnTyq9grR7926FJphGRkaoUKEC3r9/j4MHD6JVq1YQCoWgKArVq1fHqlWrchV406dPh1QqVSrG4kTeH7x169ZMq69GjRohKCgIQqEQ58+fR1BQEOzs7IrUEzktLY1xcOzfv3+x9WRPTExkjNPi4+MxZ84c6OrqwszMDFu3bi3RxSKZTIatW7fC0dERFEWhY8eOTL25lpykpKTg0qVLWLhwITp16sR0e5CvGltbWyM6OhpLly7FtWvXNCobSN28e/eOWYUvrOv9u3fvULlyZQiFQuzcuZP5OU3T8PPzQ3BwcK6fm8ePH8PExAS+vr7aHvJaSoyxY8fCwMBA7Qv/pZ3MzEy0a9cOLBYLa9euVXc4WlQMTdMIDw+HtbW1QjvEJ0+e1IgNv9z48eMHKIrCqlWrlBpH7oQ+Y8YMsFgsLFq0qMBz5IvRd+/eRf369REaGgo2m81kbv5eNixn9uzZiImJgYGBAbhcbqnaEChVolsmk6FcuXLZTAuysrKYXcOOHTvi+vXrOezlk5KSYGNjAzs7O0bwlkSq3o8fP7Bjxw60aNGCqdctX748Jk6cqDG95O7cuYN+/foxZm3+/v5YtmyZSncv5RPMgICAXL/Mr1+/zrgXxsTEMA7t7u7uiI2NLVBMDRgwAM7OziqLV1W8efMGkydPhoODAwghcHFxwfTp0/H+/Xv06dMHLBYLe/fuRWxsLCiKUsr5lKZpzJ8/H2w2G7Vq1VL5bq9MJkNkZGQO47TXr1+jcePGIISgbt26iIuLU+l1c+PEiRPw8/MDIQQNGjQoklFfWUYusBcsWICOHTvCy8uLEdhcLhcVK1ZEdHQ0hgwZAjabja5du6o7ZI3l7du3cHZ2hqWlZaENA2/evAkrKytYWFjg+vXrOV6X92r93Wjm1atXsLGxgauraw5zSi1aipMjR46AEIIHDx6oO5RSj0wmQ3R0NAghWLp0qbrD0aJC5BtJipQQyDVKXvNfTaBcuXIqaRfo4uICLy8vGBkZ4cePH/ke++3bN6Yee9iwYdiwYQO+ffsGkUgEgUCA/v37Y+rUqdnKhgFgzZo1cHJyYjrrmJubKx13SVKqRDcAzJw5E4QQxqiiY8eOIIQwq4l5rYz4+vri8+fPqFy5MthsNq5evVos8SUnJ2Pbtm1o1qwZ01/cx8cHkydP1pjewN++fcPixYsZ4WJsbIyBAwcW64770aNHQQjB/v37s/18z549EAgEEAgEIITA1NQU/fv3L1Q9e5s2bVC1atXiCLvQZGRk4O+//0aDBg3AYrEgFArRoUMHnDt3jrmf6dOnM1/E//77L7hcrtItG+QcP34cBgYGKFeunEoXdsaPHw+KovJsb7Rv3z7Y2NhAIBBgypQpxdKi7datW6hbty6zOHT69GmVX6O08ePHD1y8eDFPge3r64tu3bph2bJluH79OrOD/ebNG5iZmSE4OLhUtNNTB2/evIGTkxOsra3x9OnTQp27Z88eiEQi+Pr64s2bN7keQ9M0KleujCpVqjDPhk+fPsHFxQW2tralsr2lltJNYmIiWCwWVq5cqe5QygQ0TaNPnz4ghGDOnDnqDkeLCkhOToa1tXU2T6n8WLVqFQghuHjxYglEVzQaNWqE2rVrKz1Os2bNwGKxMGHChAKPnTt3LthsNkxMTGBnZ8e0y2Wz2dDV1WXmMX5+fggNDYVEIoFQKAQhBPr6+hg8eDDs7OzQtm1bpeMuSUqd6P748SOzwnTq1CkQQjBy5Ejm9d8N1eT4+voCAL58+cJ8YFRFUlISNm/ejMaNGzPi0c/PD1OnTi30ZK24kMlkOH78OFq3bg2BQAA2m42IiAj8/fffJbLrT9M0QkNDUb58ecTHx2PlypXw9vZmygXk/b2LkhodFhaG5s2bF0PUivP48WMMHToUpqamIISgUqVKWLp0aY6MgU2bNjHv2ZSUFLi7u8Pb21ulwufp06fw8PCAWCxWuAdwfsjrTydOnJjvccnJyRg4cCDYbDY8PDxU1rP0xYsXaNeuHSiKgpOTE3bu3KmxK8bFiVxgz58/Hx06dICnpyfzxcTj8fIU2L+TmpqKypUrw8rKivFO0JKdV69ewdHRETY2NoXK3qBpGtOmTQNFUWjWrFmBq/2HDh0CIQSHDx9GQkICKlasCFNTUzx58kTZW9CipUhUqFCh0N4iWvKGpmkMGTIEhBBMmTJF3eFoUZLBgwdDIBAo1CknKSkJZmZmaNmyZQlEVnRGjhwJCwsLpcepU6cOCCEFurPTNA1zc3NERUVh5MiRYLPZqFChAoD/abW5c+dCT08PkZGR8PPzg7+/P9hsNiwsLBASEsIYKpeEibAqKXWiOzMzEyKRCKNGjYKlpSX09fXh7++fzVDN19cXLi4ukEgkEAgE8PLyAo/Hg42NDXx9fdGpUyewWKwiGYPJSUhIwIYNG9CwYUMmRcLf3x8zZszQqLZVz58/x7hx42Bra8ukOE+bNq3EWxZkZGRg6tSpjEkTIQRsNhsuLi5Kx+Lh4YE+ffqoKFLF+fHjB9avX4+qVasyq299+vTBrVu3cj3++PHj4HK56NChA2iaRr9+/cDn84slwyApKQmRkZGgKApTp04tskh9+PAhJBIJGjdurHBt/61bt+Dv7w9CCLp06YKvX78W6dpfvnzBgAEDwOPxYGpqiiVLlvwxDs4/fvzAhQsXsglsucs9j8eDn58fYmJisHz5cty4cUPhRRuaptGhQwcIBAJcu3atmO+idPLy5Us4ODjA1tYWz58/V/i8tLQ0JvNq1KhRCn1eaJpGQEAAKlWqhODgYOjp6eH27dtKRK9Fi3L07NlTI8u1SjM0TWPcuHEghGDMmDF/5KJxWeDu3bvgcDgKO5CPHDkSAoFA4zvrbNmyBYSQIs/VAOD79++QSCQghORaTvUrM2bMAIfDwdSpUzFv3jxQFAUzM7Nsx/xeJgz8T5CnpKSgYsWKcHFxKXWfpVInugGgW7dujOu3tbU1Y6jWp08fSKVS6OnpgaIouLu7w8XFBVZWVmCz2aAoCnw+n+mJPGLEiEJd99u3b1i7di0aNGjAmLNVqVIFs2fPVkrAq5qUlBRs2rQJYWFhIIRAV1cXXbt2xcWLF0v0DUrTNK5cuYLevXszNeNisRhSqRR8Ph9hYWH4/v270tcxMjLC5MmTVRCxYty4cQM9evRgHjBhYWHYvHlzvmYOt2/fhkQiQZ06dZCRkcGYAhZnyplMJsOoUaOYNkWFdc1MTEyEq6sr3NzckJSUVKhzs7KysHjxYkilUhgZGWHdunUKv/d+/PiB2NhYSKVS6OrqYsKECUq3s9Bk5AJ73rx5aN++PTw8PFQisHNj7ty5IIRg48aNKryDssOLFy9gb28POzu7Qk2UPn36hJCQEPD5/EL/buW13Xw+X6NTELX8GcizsbR+AqpHvvEwePDgUicW/nRomkZISAhcXFwUMhp9+fIlBAJBoXWGOrh79y4IITh79myRx5g3bx7YbDbYbDaWLFmS53EPHz4Ei8UCi8XC7NmzERERwXwuZs6cCSD/MuEfP34w5ZvLly8vcrzqolSK7lu3bjGuu/Jd5cTERNjY2IDD4WDw4MGIi4vLsVLy4cMHTJo0CWw2G1KpNNc/6u98/foVq1atQr169cDlckFRFIKDgzFv3jyNqrmT933u0aMHsyBRtWpVrF27ViXCtjA8e/YMEyZMgLOzMwghsLCwwKBBg3D79m0sWrSIcW5XReuEjIwMEEKKvQYtPj4eCxcuZFLiLSwsMHLkSIVST1++fAkLCwtUrFgRSUlJiI+Ph6WlJcLCwkqkt+C2bdsgFArh6+ur8HtWJpOhYcOGkEgkSnkRvH//Hi1btgQhBDVq1Mh3rMzMTKxcuRKWlpbgcrno06cPPn78WORrayLfv3/H+fPn8xTYlSpVQvfu3bFixQr8+++/Ki07OH78ONhsNgYNGqSyMcsSz58/h62tLRwcHAq1iPrff//B3t4eJiYmhRbNWVlZaN68OSiKgrOzs3YirkXtPH/+HIQQ7N27V92hlEnmzZsHQgh69+5danoLa/lfP+vjx48rdHyrVq1gZmZW6A0LdZCeng4Oh5OvWM6PjIwM2NjYoG3btvD29kbnzp3zPLZv375MxmtERAQ2bNgAmqZhZmYGQgiaNGmC4cOHY9y4cdnOS0tLg729PcqXL8+U8WpC56fCUipFNwCUL18ehBB8//4dGRkZCA4OBpvNxpkzZwDkbzXfr18/WFtbQ0dHJ1eX7s+fP2PFihWoXbs2OBwOKIpCaGgoFixYgLdv3xb7vRWGT58+Yc6cOUx9g4WFBUaMGFFop11liY+Px9KlSxEcHAxCCEQiEdq3b49jx44hKysLALB//37weDyYm5vDyspKJW2J3r59C0KISmqXf0cmk+HkyZNo06YNBAIB0+rrwIEDCteex8fHw83NDXZ2dnj//j2Anw9jPT29El20+ffff2FtbQ1TU1OFhMGECRNAUVQO47uicvjwYTg4OIDH42Hs2LHZsgJomsbevXvh7u4OQghatmypMV4IypCcnIxz585h7ty5aNeuHdzd3RmBzefzswnsmzdvFmvqfFxcHAwMDFC7dm3m86jlf8TFxcHGxgaOjo6Faj136NAhSCQSeHl5FTqFkKZpdOvWDSwWC2PHjs3VaFKLlpKGpmlYWFgo3H9YS+FZtmwZKIpC165dtc/jUsDXr19hbGyMVq1aKXT8pUuXSmQzSJV4eHigV69eRTp348aNIITg9u3b6NatG7y8vHI97vv378ymIJvNhkgkymagpq+vz5TrOjk5oU2bNrCxsYGxsTHTeSosLAzNmjWDmZlZqSw3LLWie82aNSCEID4+HosXL87mYA7kbqh25MgRpjb1/v370NHRYUzYPn78iKVLlzJ/fBaLhRo1amDx4sWMWNIUMjMzceDAATRp0gRcLhdcLhdRUVE4ePBgiT7A09PT8ffff6NJkybg8XhgsVioW7cuNm7cmGN3/e+//waXy0Xjxo1x584dsFgszJs3T+kYbty4oVANSWF4+/YtpkyZAkdHR+bDP23atEK/D1JTUxESEgJDQ0M8fPgQALB582a19Wv88OEDgoKCwOPxsHr16jyP279/PyiKUsiBsjCkpKRgxIgR4HK5cHZ2xokTJ3DhwgUEBQUxD1NV/h1LktwENkVRjMCuXLkyevTogZUrVxa7wM4tNi8vLzg6Oqq8lVxZ4OnTp7C2toaTk1OeTuO/Q9M05s2bBxaLhQYNGhRpN0NurrRmzRomddHX11e7261F7URFRSEoKEjdYZRp1q1bBxaLhbZt2xbJQFZLyRETEwOJRKKQ/5Dcp8Pb27tULai0aNECoaGhhT6PpmmUL18e9erVAwCsWLECLBYr1wzbXbt2MVnK9erVAyEE5cqVA/C/eu0FCxbA0NAQzZs3h4mJCWxsbODm5gYejweRSIRq1apBIBBg+PDhRb9ZNVJqRfeVK1eYHqdSqRRubm4ICAjIZqjm4+MDBwcH6OrqgsfjQSgUoly5cnBwcICfnx8qVqwIqVSK0NBQsFgspsfxsmXLNDKt9dGjRxg2bBjMzc2Znt/z5s0r0dormqZx4cIFdO/eHQYGBkxLtNmzZ+cpSrdv3w4Oh4OoqChGbHTq1AkmJiZKp77/888/IIQovWuckZGBPXv2ICIiAmw2G0KhEO3bt8fZs2eLNAmWyWRo1qwZBAIBs7P86tUr6OnpqdXJMj09HV27dgUhBP369cvxZS83TmvUqFGxpb7du3cPvr6+zMPXw8MDR44cKTViIzk5GWfPnsWcOXPQtm1buLm55Smwb926pdbVWJqm0bRpU+jq6pbKVKzi5smTJ7C0tISzs7PCWUwZGRno3r07CCEYOHBgkSZWsbGxIIRg7ty5zM9OnjypTevVohHMnTsXfD5fJdloWvJm27Zt4HA4aNasmbZ1o4Zy+fJlUBSF+fPnK3S83JTsxIkTxRyZapkwYQIMDQ0LPQ+Td+A4deoUgP+V/+ZWH75gwQJm3tetWzdYWVlBJBJle878WhYcGBjIzEN79+6Na9euYcSIESCEFFvb5+Km1Ipumqbh6uoKDw8PxpVbbqjWo0cPiMViCAQCppWORCKBgYEBIxSFQiGMjY0Z8bpy5UqNNA5JTk7G6tWrmbRtPT099OrVCzdu3ChRkfLkyROMGTMGDg4OjIHdsGHDCpzIb9q0CSwWC61bt84m8F68eAEul6t0C43Vq1eDEFLkL6zHjx9j2LBhTD2Jr68vlixZkmvZgaLQNI2//voLLBYLe/bsAfBThIeFhcHS0lLtu400TWPBggXMIpPcsVJunObq6orExMRiufbbt28RHR0NiqJgaGgIXV1d6OvrY8WKFRpZ35afwBYIBPD390fPnj2xatUqtQvs3Jg4cSIIIcz7UMv/ePToESwsLArVQSE+Ph5hYWHgcDhFTh2UZ2b9XrMGANWqVYO3t3epWYDSUja5evWqxvcWLivs2bMHPB4PERER+Zqxail5MjMz4ePjAx8fH4UWV1NSUmBjY4PIyMgSiE617N69G4SQQmd0VqtWDZUrV2a+szIzMyEUCjFr1qwcx/bq1YsR3b6+vjhz5gwoikLTpk2RlpaWoyy4UqVKzP8fOXIkevTowZxfmFaemkSpFd0AmPQ+XV1d5gPx9u1bGBkZQSQSITY2Fh8/fsxhqPb27VuMGTMGbDYbOjo6aNeunbpuIVdomsb58+fRuXNniEQiUBSF2rVrY8uWLSX6UP78+TMWLVqEgIAAxnm8c+fOOHnypEICae3atWCxWOjQoUOuD6zevXtDT09PKRE6ZcoUGBgYFOqclJQUbNiwAaGhocxCRu/evXHz5s0ix/ErM2bMACEEixcvZn42Z84cJjNDUzhx4gQMDAxQrlw5/Pfff2jUqBEkEgmTCq9KEhISMGLECAiFQhgaGmLOnDlIS0vDp0+f0KFDBxBCEBQUpNbd2KSkJJw5cwazZ89GmzZt4OrqmqfAvn37tsYJ7N/Zu3dvnuLuT+fBgwcwNzeHm5ubwpOMx48fw9nZGQYGBsyqfmHZtGkTKIpC3759cxXWZ86cASEEu3fvLtL4WrSogoyMDOjo6GDGjBnqDuWP4NChQxAIBKhduzZ+/Pih7nC0/D/z588HRVG4cuWKQsdPnjwZHA5HKfNZdfH48eNCz1HlGcc7d+7M9vPAwMBcMzrlRsTyjjoA4OjoCD6fD19fX/Tq1QtjxozJNk5WVhYuX74MJycn5lxl25upk1Itur99+wYdHR1YWloC+Dlpluf+37lzhznmd0O12NhY2NnZoWnTpjAwMICxsbFGrDC+ffsWsbGxjOu3nZ0dJkyYUKLtyFJTU7Fjxw5ERkaCw+GAzWajfv362Lp1a6HcxlesWMEYheQl0N+/fw+hUKhUS4W+ffvC3d1doWP//fdf9OzZkzFyqF69OjZt2qQSF3U58prtX+/pv//+A5/PR9++fVV2HVURFxcHDw8PxrxC1UZOaWlpmDNnDgwNDZm/dW5ZBCdPnoSzszM4HA6GDRtW7BOPggR2QEAAevXqhdWrV+P27dulrubu/v37EIvFheqv/qdw//59mJmZwcPDAx8+fFDonJMnT0JfXx+urq548uRJka67f/9+sNlsdOzYMd+/SY0aNVC+fHnt302LWqlWrRoaNWqk7jD+GE6cOAGRSITQ0NBS4Xhd1nn37h0kEgm6d++u0PHv37+Hrq4u+vXrV8yRFQ9ZWVkQCATZSp4KomnTpnBycsqxqda3b184Ojpm+9nr16+ZOZb8X506dSAWi2Fubs7My42NjdGsWTMm9dzU1JTp7iI/z87OrtRmg5Vq0Q0A0dHRMDQ0BACMGDECLBYL+/btY17PzVAN+PkGi4iIwMqVK8Fms1Vi6lUU0tPTsWvXLtSvXx8sFgsCgQBt27ZVeDdZFchkMpw9exbR0dHMG79SpUqYP39+kWrb5emTPXv2LPAehg0bBpFIpPDk93datGiBGjVq5Pn6t2/fsGjRIvj4+IAQAnNzc4wYMaJY3LFPnDgBLpeL9u3bMw+E9PR0eHt7w93dXaXiXpVs27YNhBBQFIWpU6eq5GEmk8mwceNG2NnZgcViITo6usCa2bS0NIwfPx58Ph/29vY4dOiQ0nEAP9PmT58+jVmzZqF169ZwcXHJVWCvWbMGd+7cKXUC+3fi4+Ph5OQEDw8P7eTtN+7duwdTU1N4enoq/Gxbvnw5OBwOatWqhW/fvhXpuqdOnYJAIECTJk0KfH+dO3cu190DLVpKkpEjR8LY2LjUTm5LI+fPn4dYLEaVKlWUKnHTojytWrWCsbGxwpmYXbp0gYGBgdrLB5WhYsWK6Nq1q0LHPn78GBRFYdmyZTlek7uZ/7obHRsbC5FIxMzF5eUr+vr6ePPmDRISEuDu7o7u3btDIpHA2toaLi4u4HK5cHFxQd26dZnzYmNjVXbPJU2pF92rVq0Ci8VCXFwc+Hw+AgMDcxiqVahQATY2NhAKheBwOLCysoKvry8qVKiASpUqwcnJCa6uriX65XLnzh30798fRkZGIISgcuXKWLp0aYk+aB8+fIiRI0fCzs4OhBDY2tpi5MiRePDgQZHHnDt3LggheaZP/s7Xr18hkUiKvAscGhqao40DTdM4ffo02rZtC4FAADabjYYNG2L//v3FJqhu374NiUSC2rVrZ0s7HjZsGLhcLv79999iua6yPHr0CBKJBJGRkRg5ciST9lPUBQKapnH48GFUqFABhBA0atQoW2mHIjx+/BhhYWEghKB58+YK19sCOQW2s7MzI7CFQiGqVKmC3r17lxmB/TtZWVmoW7cu9PX1y0TbNVVy9+5dGBsbo3z58vj06VOBx2dlZaFfv37MAmJR3yvXrl2Drq4uatWqpbAxVa1ateDp6and7daiNg4ePAhCSJEzO7QUjatXr0JfXx++vr748uWLusP5Izl+/DgIIVi3bp1Cx9+8ebNQZmuaSrt27RAQEKDQsd26dYOpqWmuWcLyVPUjR44wP6tWrRo8PT0RHR3NiGd3d3f4+fmhRYsWqF69Oi5cuAAA8PPzY85r06YNli1bxux083g8jTS6VpRSL7oTEhKgo6MDf39/xhRNbqjWrVs36OjogMViQSwWIygoCLa2trCxsYGRkRFYLBYoioK9vX2JuA1++/YNixcvhp+fH5NGMWDAANy9e7dYr/srHz9+xLx585gYpFIpoqOjcfbsWaUnePJa5sGDBxdqAWPixIng8XhFSqN3dXVF//79AfxMB4qNjUW5cuWYVgRTp04tlGgrCi9fvoSFhQV8fHyy7SyeO3cOFEUpbRZXXMjLMX41Ttu+fTuEQiF8fX0L7Qh//fp1RiwHBQUxD9CiQNM0Nm7cCBMTE0gkEixcuDBHClNiYiJOnTqFmTNnolWrVkxZhlxgBwYGok+fPli7di3u3r1b5gR2bgwZMgQsFkujvAM0gTt37sDIyAje3t4KGWYmJiYiPDwcbDYbCxcuLPJ17927B0NDQwQEBCA5OVnh8y5evAhCCLZt21bka2vRogzx8fE5WrFqKRlu3boFIyMjeHl5lWqBURpJS0uDs7MzQkJCFJrH0jSN6tWrw9XVVeN9Xgpi2rRp0NXVLfC+379/Dz6fn+fclqZp6OnpYeLEiQB+tvalKAqVKlVCeHh4tvpsiqJw7NgxvH//nhHbTZo0wZUrV5CYmAhTU1Om/FG+oVeaKfWiG/i54iISieDk5MT87MmTJ5BKpdDT08OSJUuQlJSUw1CtYcOG6NixI3g8Hvh8PgYOHKjy2GQyGY4fP47WrVszu64RERH4+++/S6xFREpKCrZu3Yr69euDzWaDy+WiYcOG2Llzp8pq2SdPngxCCEaOHFnojIGkpCQYGxsrnNbyK3p6eujQoQMiIyPBZrMhEAjQrl07nDlzpkQyF+Lj4+Hu7g47O7tshkyJiYmws7NDUFCQRvZqlMlkaNy4ca7Gaf/++y+sra1hamqqkHvt06dP0bJlSxBC4Obmhr1796rsd//161dmZVS+wNKyZctsD20dHZ0/UmD/jtxPIDfX0D+ZW7duwdDQED4+PgrtHD1//hyenp6QSCTZVuoLy7Nnz2BhYQEvL68ipRzWqVMH7u7uGvn80PJn4OHhgejoaHWH8Udy7949mJmZwdXVFW/evFF3OH8MkyZNAofDUdjUVW5YeuDAgWKOrPiRt+B98eJFvscNHz4curq6+X6v1axZk3Fxb9euHSQSCYyNjbFhwwY8efIEHA4nW3139erV4eTkhNOnT2PTpk1wcXGBUCjMdoyjo2OpX9goE6L7v//+A4vFgr+/PwDgy5cvsLGxgUAgYGzlfzdUO3PmDCZPnoxTp06hQ4cOMDIygrm5ucrqbl+8eIFx48bB1taWaWk2bdq0Yt91lSOTyXDy5El06tQJYrEYhBBUqVIFixYtUmnKEk3TGDt2LAghudbOK8rs2bPBZrMVdn188uQJBg8ezHwYK1asiMWLFxe55rIopKamomrVqjAwMMghXDt16gRdXV08e/asxOIpDPJWUr/6H/zKx48fERwcDB6Ph9WrV+d5TJ8+fcDlcmFhYYGVK1eqROwmJCTg5MmTmDFjRg6BTQiBhYUFevTogXXr1uG///7TihL8XEmWLzhpazD/x7///gsDAwP4+voq5HZ6/vx5GBsbw8HBodBlEb/y7t07ODo6oly5coVuwSLn8uXLIIRgy5YtRY5DixZl6Natm8JGpVpUz+PHj2FtbQ1HR8cChZAW5YmLi4NAIMCQIUMUOj49PR1OTk6oWbNmmfjeffnyJQgh+Oeff/I8JikpCVKptMBNyuHDh8Pc3ByfP38Gj8djutRwOBzUqVMHIpEoh/Au6N/BgwdVfcslTpkQ3QAQFhYGLy8vAD+d89hsdrYUy98N1Zo0acKkpw4cOBDXrl1TOpUwJSUFmzdvRs2aNUFRFHR1ddGlSxdcuHChxD6Q//33H4YOHQorKytmZWjs2LHFUpdF0zTTqF7ZFOrU1FRYWVnl2mZATkpKCjZu3Ihq1aoxLcwIIUr9zYqKTCZDVFQUBAJBjjRqeb/DvMSqujlw4AAoiiqwlVR6ejqzy9yvXz9GUCcnJ2PChAnQ1dWFVCpFbGxskd3GfxXYLVq0YEoD5DvYQUFB+Ouvv7Bu3TrcvHkTU6ZMgVAohLW1tbb39P/z8eNHWFtbw8/PT2PN+tTBjRs3oK+vj0qVKim007x+/XrweDxUrVpVoRT0vPj69Ss8PT1haWmJ58+fF3kcAAgPD4erq6t2YUmLWli3bl2pbs9TFnj+/Dns7e1hY2Oj9ekoRmiaRnh4OKytrRUuBZozZw5YLBbTLam0Q9M0xGIxpk2blucxM2fOBJfLLbD8UD4Pnjx5MrhcLt68ecO0jAUAfX19PHjwAH/99RcEAkGeQjsgIABBQUFwdnYuEwsbZUZ0T548GSKRCO/fvweXy0X16tVzGKp5eXnB0tKSKchnsVjMPycnJ5QrVw7u7u6F+sPSNI1r166hR48e0NPTAyEEVatWxdq1awtVw6cM79+/x+zZsxlXQAMDA/To0aNYxT5N0xg0aBAIIZg5c6ZKxly+fDkIIbh161a2n9+8eRO9evVifr/VqlXDxo0bmZ62quqvXRj69esHFouFv//+O9vP379/DyMjIzRq1EgjHxCPHz+GVCpFZGSkQjX8NE1j4cKFYLPZqFmzJmbOnAlTU1PweDwMGDCgUFkT3759w4kTJzB9+vQcAlskEiE4OBh9+/bF+vXrce/evTyFxrNnzxAeHg5CCBo2bIhXr14pHENZIz09HSEhITA1NS10DX5Z5tq1a9DT00PlypULzH6RyWQYPnw4CCHo1KmTUmU/ycnJ8Pf3h5GRkVI75XKuXr0KQgg2btyo9FhatBSWJ0+eFLjzpaX4ef36NZydnWFubq6U0a2WvJGLxN/ndHnx5csX6OnpoVu3bsUbWAlTpUoVtGvXLtfX0tPTYWlpiY4dOxY4zuvXrxmfLUtLS2zYsAFRUVGgKAo3btxAQEAAY6B27tw5HD9+HA0aNEC9evUwZMgQlC9fHocPH8bVq1fBZrML1cpMkykzovvly5dgsVgICQkBIQTe3t6MoVrXrl2Z2gAjIyPUqlULdevWxZw5c+Dq6goulwtCCGPGdvr06QKv9+nTJ8yZMwdeXl5MyuuIESPw+PHjErhb4Pv379i4cSPq1KkDFosFHo+HJk2alEitOE3T+Ouvv0AIUalbY0ZGBhwdHREREcGYzlWsWJFp9TV8+PBsO/b79u0DIaTI6ZtFZdasWSCEYNGiRdl+Ll8pNTU1VcgduaRJSkqCu7s7XFxcGOM0RaBpGmPGjAGLxQIhBJGRkQWmuskF9rRp09C8eXM4OjrmKbDv379f6J08mqaxY8cOmJubQyQSYdasWX9kHXePHj3A5XJx/vx5dYeiMVy5cgVSqRQBAQEFdoP4/v07mjRpAoqiMH36dKUWylJTUxEWFgaxWIzr168XeZzfadCgAZydnf/I97cW9ULTNExMTDBixAh1h/LH8/79e3h4eMDExKTM7KxqCsnJybC2tkb9+vUV/g7o06cPxGJxkdvdaipdu3aFj49Prq+tXbsWhBDcu3evwHFomoaBgQGTcRsREYHExEQIhUKYmZmBz+fj5cuX2QzU4uLi4ODgABcXF7Rq1Qo3b96EoaEhTE1Ny0wWX5kR3cBPYzQDAwOUL1+e+dnDhw8hFothZGSEjRs3Ii0tLZuh2tixY1G+fHm4uLjA0NAQXC43z1qFzMxM/PPPP2jatCm4XC64XC6aNWuGgwcPlkj6X1ZWFo4ePYp27dpBJBKBEILg4GAsW7asxHoDymQy9OjRA4QQLFmyRKVj0zSNUaNGgRACPp8PNpuNyMhI7Nu3L9cJ5/Lly0FRVIlORrds2QJCCIYPH57jtaVLl2qsoYbcOE0sFhdqpfzMmTPMYlTVqlVRrlw5iMVi7N+/nzkmPj4ex48fz1Vg6+rqIiQkBP369cOGDRuKJLDzIyEhAb179wZFUfD29saVK1dUNrams2zZMhBCsHz5cnWHojFcvnwZEokEgYGBBS4svXnzBhUrVoRIJMLevXuVum5mZiYaNWoEgUCAM2fOKDXW79y4cQOEEKxfv16l42rRogiNGzdGaGiousPQAuDz58/w8fGBgYGBShf2/nQGDx4MgUCgsAfPgwcPwGazMXXq1GKOrOSZO3cu+Hx+jnmaTCaDu7s7IiIiFB7L0tISBgYGEIlETPu18uXLw83NDSwWC5MnT8aHDx9QpUoVZGZmokWLFjh16hTevn2LSpUqQSAQQEdHp0yZOZYp0X3u3DkQQpgviE+fPsHKygpCoZBpR/W7oZq8VunDhw9wcXGBnZ0dDA0Ns4nYx48fY/jw4bCwsGDSJebNm6dU3V9huH37NgYNGsRc39nZGRMnTixxky6ZTIauXbuCoiisWrVKZeO+f/8eU6dOZQyzeDweHB0dCzSdmzhxIkxMTFQWR0GcOnUKPB4vV7OqR48eQUdHBzExMSUWT2GYNGkSCCEKi4s7d+6gfv36IITAz8+Paaf38uVLBAYGghACLy8vODg45CmwHzx4UGK1qFevXoWPjw8oikKvXr1KtN+9Ojh//jy4XC569uyp7lA0hosXLzKtIX9t3Zcb165dg7m5OaytrXOUsxQWmUyG9u3bg8PhFNuCW8OGDVGuXDntbreWEmfmzJkQCoWl3jW4rBAfHw9/f39IJBKFuotoyZ+7d++Cw+Fg0qRJCp9Tv3592NnZqaz7jyYh71H+u6nx/v37QQjBuXPnFBrn7du3YLFY6Nu3bzYDNbFYDBsbG/B4PLBYLHA4HPD5fEarsdlspsuSfMNH0ZT/0kCZEt0AEBAQgEqVKgEABgwYADabna3/9q+GajRNIzk5GYmJiYwx1okTJyAUCjF69GisXr0awcHBIIRAT08PvXr1wo0bN0qkVvfNmzeYPn06k75uZGSE3r1748qVK2qpFc7KykKHDh3AYrFUsuOSmZmJ/fv3o2HDhkyrr7Zt2+LUqVP4+++/QQjB8ePH8x2jV69e2bIaipM7d+5AKpWiZs2aOdL3MzMzUblyZZQrV67E6vgLwz///AOKojB27NgCj3358iU6duwIiqJgZ2eHkSNHIjY2FlFRUdkEttwXwcXFBatWrcKDBw+U7vOuLJmZmZgzZw5EIhHMzc2xbds2jayrV5bXr1/D1NQUVatW1U6E/5/z588ziz4FCe7t27dDIBAgICBA6dIUmqbRp08fUBRVrC7jN2/eBCEEa9asKbZraNGSG5cuXQIhBFevXlV3KFr+n6SkJISEhEAkEilUDqkld2iaRkhICFxcXJCWlqbQOUePHgUhBNu3by/m6NTDhw8fQAjB7t27s/08ODgYgYGBCo1B0zQCAwPB5XLx+fNnSCQSSKVSAD8N1N68eYMLFy4gICAANjY2cHd3h6urK2xtbcFisVCuXDmEh4ejffv2sLa2LlOLzWVOdI8fPx5isRgfP34Ej8dDaGhoDkM1d3d3mJmZMTWqclM1Ho+H8uXLw8zMjLGyr1WrFrZs2VIiK1pJSUlYt24d437O5/PRvHlz7N+/X62T68zMTLRu3RpsNhubN29WaqynT59ixIgRzK69j48PFi1alM3siKZpVK5cGf7+/vmKpqZNm6JWrVpKxaMIr169gqWlJby9vXNNWR0/fjzYbDYuX75c7LEUFkWN0+Li4hAVFQU2mw0ejwdDQ0PmsyEWi1G1alX0798fGzduxMOHDyGTybB9+3bo6OjA19dXo0y8Xr16hUaNGoEQgrp16zJtA8sCKSkp8PPzg7W1NT5+/KjucDSCc+fOQVdXF6GhofkuetE0jQkTJoAQglatWqnkmT5mzBgQQrB06VKlxyqIxo0bw8HBQbvQoqVESUtLA5/Px5w5c9QdipZf+P79O2rWrAmhUIgjR46oO5xSibxGuaANHjlZWVnw8vJCUFBQmVzQB35+TxoZGWHChAnMzy5cuABCiMIdY8aNGwdCCKytrbFhwwZ06dIFhBCcOHEim4Ha751/tm/fzrRru3nzJvh8PiZOnKi6m9MAypzofvHiBSiKQtWqVUEIQYUKFbIZqsmt6a2trdGwYUPY29vD2dkZhoaGjDu2vLf2smXLij3ezMxMHDp0CK1bt4aOjg7jzr1y5UqNSJHNyMhAVFQUOBwOduzYUaQxUlNTsWnTJlSvXh2EEEilUvTs2RM3btzI8xx5ikt+6dDBwcF5uiyqim/fvsHDwwO2tra5prtfuXIFbDYbY8aMKdY4isKvxmm/vpe+fv2Ko0ePIjY2Fo0bN2bMLuQ72MHBwRgwYAA2bdrECOy8uHnzJmxsbGBqaprjAapu9u7dC2trawgEAsTGxpZ6sULTNNq2bQuhUJjvZ+dP4syZMxCJRKhevTq+f/+e53Gpqalo3bo1CCGYMGGCSiZMs2fPBiGkxOr6bt++DUKISkt7tGhRhODgYDRr1kzdYWj5jdTUVNSvXx88Hg/79u1Tdziliq9fv8LY2BitWrVS+By5j0pZz/oIDQ1F8+bNmf9u2LAhXF1dFcpmfPHiBbOhaWdnh4iICKSmpkIsFkMqlYLH4+UwUJMTFRWF69ev4+7duzAxMYGRkZFGZo8qQ5kT3QAQEREBIyMjODs7Mz97+vQpY6i2Z88eZGZmZjNUa9euHfr37w9vb29YWlqCzWajdevWxRIfTdO4ceMG+vXrB1NTUxBC4ObmhilTpjC155pAeno6GjVqBC6XW6SeyLdu3ULv3r2hr6/P1Npv2LBB4Z7O1atXh5eXV54f9HLlymHQoEGFjktR0tLSEBoaCgMDg1zNx75//w4nJydUqlRJ4wQdTdNo0qQJdHV1sXLlSkyZMgVNmzaFnZ0dI7AFAgF4PB4oikKtWrVw4cKFIqWIf/z4ESEhIeDxeBonCJKTkzFw4ECw2Wx4eHiUapdvuWu+stkmZYVTp05BR0cHYWFh+T5T3r9/D39/fwgEAmzbtk0l1161ahUIIRg2bJhKxlOUZs2awc7Ortg7VGjR8itDhw6Fubl5md3dK82kp6ejSZMmSm2M/InExMRAIpEU6B0kJzExESYmJmjbtm0xR6Z+evXqBXd3dwA/TeMKs9grb79JCIFQKGQM1Ly9vREQEACKojB48GDExcUxBmoA8OPHD7i6umLMmDGQSCQQCoVlykBNTpkU3efOnQNFUcwqSkJCAuzs7CAQCPI0VKtduzamT58O4Gfasp+fHwQCgUp7Ir58+RKxsbFwd3cHIQQmJibo169fidWJF4ZfV1ALYw6UkJCAJUuWwM/PD4QQmJmZYdiwYUVqpXbx4sV8RYZYLFZZj/DfkclkaN68OQQCQZ5CrUePHhAKhXj48GGxxFBYvnz5giNHjmDKlCnw8PBgHnyEEEgkElSrVg0DBgzA4MGDGdO6qKgolbS5S09PR7du3UAIQd++fTWuBufmzZuoXLkyCCHo2rUrY6BYWjh69ChYLBaTevWnI/feqFWrVr6tRG7fvg1ra2uYm5urbHdi586dYLFY6N69e4k/t+/evQuKorSO9VpKFHl7zpI2b9WiGJmZmWjVqhVYLBY2bNig7nA0nsuXL4OiqEK1vB06dCiEQqFGldIVF0uWLAGHw0F6ejo6d+4MCwsLhWre09LSYGxsDEII2Gw2879yAzU7Ozvw+XzGE0gsFsPb2xsWFhbQ1dVlDHmbNm0KQggOHTpUAndbspRJ0Q0A1apVg6urK4CfLtcUReHo0aPM678aqiUmJqJevXrYvHkzXrx4gcWLF2PBggWwtrZWelUrMTERq1atQrVq1UBRFIRCIVq3bo2DBw9qnDCRk5KSgjp16kAgEODw4cMFHk/TNM6ePYv27dtDKBSCxWIhIiICe/fuVXoHuEGDBihXrlyOcb5//w5CCDZu3KjU+HkxYMAAUBSVw0xCzsGDB3Pt1V1SfP78GYcPH8bkyZPRpEkTpiSCEMKUKVSpUgVbtmzB48ePIZPJcOnSJabsolq1aipvr0XTNBYtWgQ2m42aNWtqnLDNysrCokWLIJFIYGxsjPXr12vcYlduPH36FPr6+qhbt26JucFrMseOHYNAIEDt2rXzFdz79u2DSCSCj4+PyiZKR44cAZfLRatWrdT2t2jevDlsbGy0u91aSozPnz8X6/etFuXJyspCp06dQFEUVqxYoe5wNJbMzEz4+PjAx8dH4Wf4s2fPwOPxNLKMsDiQd4I6ceIEuFwusyFZEOfPn2fmoU2bNoWenh4kEgmA7AZqgYGBsLe3h729PaysrODj4wNTU1MMHToUiYmJaNOmDWxsbNRuzlsclFnRPXfuXPB4PLx58wZCoRB+fn45DNVcXV2ZVZlf/7HZbJibm4PH44HD4RS6NVhGRgb279+PFi1aQCAQgKIohIWFYe3atQU666qb79+/o0aNGtDR0cnm+p4bHz58wLRp0+Ds7AxCCBwdHTFlyhS8fftWZfHcunUr117EcXFxIITg2LFjKruWHHmt5oIFC3J9/fPnzzAzM0PdunVLRLTlJ7ClUimqV6+OQYMGYcuWLTh27BikUikiIiKYB9bDhw+ZlUMvLy8cPHiwWOM+efIkDA0N4ejoiHv37hXbdYrKu3fv0KJFCxBCUKNGjRytMTSJpKQkeHh4wMnJKZvZ4J/KkSNHIBAIUK9evTyN0GiaxowZM0BRFBo3bpxvrXdhuHDhAnR0dFC/fn21lpPcu3cPFEWViHmbFi1yXFxc0KNHD3WHoSUfZDIZevToAUIIFi5cqO5wNJL58+eDoqhCbTpERUXBwsJCZd8lmk58fDwIIWjQoAEkEkmuBsK5sXXrVmZuGhUVxWQ/HjhwIFcDtXbt2mHAgAEIDQ3FuHHjAPzMcGWz2ejVq1ex3Z86KbOi+8uXL+Dz+czOnqenJ2Oo1q1bN/D5fKbndcuWLdG2bVvUqFEDnp6ecHJyYmpd2Wy2Qqs8NE3j6tWr6NOnDyPkvby8MH369FKTjpKUlISqVatCJBLhzJkzuR6TmZmJAwcOoFGjRkx/vTZt2uDkyZPFtirVsmVLWFlZZZtky1PP7969q9JryR8aQ4cOzfV1ea20gYGBwrVAheHTp084dOgQJk2ahMaNG8PGxiaHwB48eDC2bt2KJ0+eZPudywWas7MzEhIS8O7dO3Tv3h1sNhs2NjZYt25die3OPXv2DJ6enhCLxRpr8HL48GE4ODiAx+Nh3LhxCrcMKSlkMhkaNWoEsVjMeE/8yRw6dAh8Ph/169fP828lT4cjhGDEiBEqeybdunULUqkUVatWzXd3vaRo1aoVrKysNO49q6Xs0rlz5xJr0aml6NA0jQEDBoAQghkzZqg7HI3i3bt3kEgk6N69u8LnyHd9165dW4yRaR5mZmbg8Xh5zoVzo2HDhsx81c3NDenp6ZBKpdDR0cnVQO3Xst7mzZtj5cqVkEqlYLFY2TKTyxJlVnQDQIcOHaCvrw+xWMzs7L19+xZ6enrQ09PD4cOHQdN0NkM1OatWrYKvry8jnvPi+fPnmDhxIlxcXEAIgbm5OQYOHIhbt24V672pmsTERAQGBkIsFufqQh0XF4eRI0fC0tKScYVfuHAh4uPjiz22R48egc1mZ2tZsnv3bhBCCp2FkB+nTp0Cj8dD27Zt85ysy1tM7Ny5U+nr/S6wra2tmQeWnp4eatSokU1g57c7TdM0mjZtCrFYjKtXr2L06NHQ0dGBvr4+Zs6cWSIt734nKSkJjRo1AkVRmDJlikamcqekpGDEiBHgcDhwdnbGyZMn1R0Sw7hx40BRlMYuWpQk//zzD/6PvfMOa+p8//9zskNCWAl7y1Q2CooMAVFBEHEh7mrde+9VrdVarXtbB9a6R7WOj6tabdVat1arqLiKAwVkQ87794e/nK8UVEZCApzXdeVqTc45z/1ASM79PPf9fgsEAsTFxX000Xz16hVCQ0MhEAiwefNmtY39zz//wNTUFP7+/uVe8dc0f//9NzgcjtbaW1jqHuvXrwdFUTrhqsLyaWiaxuTJk9Xq1lAbSEpKgkKhKPd9q1KpRKNGjeDn51crS50/hbOzMzgcTrk3l3Jzc5m+bEII+Hw+AKBBgwaQy+UghMDPzw9Xr16FtbU1GjRoAIVCga5du+Lvv/9GeHg4eDweo3yu7g01XaFWJ903btwAj8eDubk5gPdl3w0aNIBAIMC9e/cAlBZUo2ka+fn5jHT93LlzQQgpcRP35s0brF69GsHBwSCEQCKRoHv37vjf//5XI3su3759i4CAABgYGJQoucnLy8PWrVsRGRnJiHENHDgQly5dqvYP8T59+kChUDD2AStXrgSXy1XbB+GNGzdgYGCA5s2bf7RX8uHDh9DX10fPnj0rfP0XL17g0KFDmDVrFtq2bVsqwY6MjMS4ceOwfft23L9/v8I/3zlz5jAiYXK5HCKRCOPHj9d6SbJSqcTUqVNBCEHnzp3LrVxf3dy8eZP5e+7evTtevnyp1Xj27t0LQkit86isDAcOHIBAIEB8fPxH/zZv374NR0dHKBQKtSrUP378GLa2tnB3d1frAp866Nq1K6ysrLSyoMZS97hz5w4IIawndA1i9uzZIIRg4sSJdT7xVtnQqtS0y0NycjIIIR+t/Kyt5OfnQyKRQF9fv9znqDakxGIxc28bGRkJPp+Pnj17wt7eHubm5iCEgMfjISQkBH5+fnB0dAQhhKk+Vgkw65ojkLqo1Uk3APTo0QNSqRQAsHnzZhBCStjGbNy4ERMmTMCCBQvQoEED8Pl85hfv6uqKb775Bq1bt4ajoyP27NmD9u3bQyAQgMPhoGXLltiyZUuN7vNIT0+Hn58fjI2NGe/fa9euYdiwYYzVV2hoKDZv3qzVhCk1NRUCgQCzZ88GAEyfPh2WlpZqufaTJ09gZWUFb2/vj+5kFRcXIyQkBHZ2dp9d6f8wwY6Pj4e1tbVaE+z/cvDgQVAUBUNDQ3A4HPTu3VvnWhp27NgBPT09+Pn54fHjx9oOp0yUSiXWrVsHY2NjGBkZYe3atVpZ3b558yakUik6dOhQ52+U9u/fDz6fj4SEhI8m3EePHoWBgQEaNGiAhw8fqm3sly9fwtXVFXZ2djr39wS8rwDicDgf1Z5gYVEnNE3DxMSkzohJ1RZUVpMjRoyos98n+fn5cHFxQUhISLl/Bjk5ObC2tka7du00HJ3usXbtWlAUBUJIue/7mzZtipCQEERERDD3uwsWLIBEIkFiYiL8/Pzg6ekJJycn2NraQiqVQiaTQS6Xw83NDd7e3sx5U6dO1fAMtUetT7oPHjwIQgjOnz8PExMTODg4MIJqHTt2hI2NDfPm+thDVe5ACIGPjw8WLFigkX7e6ubly5fw9vaGXC7H2bNnsWrVKjRq1AiEEEZJUJdEpoYNGwYDAwOkp6ejf//+8PX1rfI13759Cw8PD9ja2n5SAG7evHmgKKrUimdaWhp++eUXfPXVV6USbCMjIzRv3hzjx4/Hjh07kJKSovYvvY0bNzLWDLGxsbh586Zar69Orly5AltbW5iZmZXZwqArvHz5Ej169AAhBMHBwdX6M01PT0e9evXg6enJVHXUVfbu3Qs+n4/27dt/dNV76dKl4HK5iImJUWvpd0ZGBqOoqqqK0kV69OgBCwsLnegzZ6n9xMXFITIyUtthsFSQ5cuXgxCC/v3717kyaeD9jj+Px6vQd/nMmTMhEAhw//59DUameyiVSri4uKBZs2YghODSpUufPeevv/6CQCBA9+7dERYWxtwDq+zB/tvLrXK2SUtLg4eHB/bt21fCYkwXF7nVRa1PuouKimBjY8Mkk05OTggODsa6deuYUocPHwqFAnK5HAYGBqVe09fX13rZqbpIS0tDgwYNYGxsjPj4eOjp6YHD4SA2NhZ79+7VydKOtLQ06OnpYcKECWjbti2io6OrdL38/Hw0a9YMRkZGnxSqunr1Kvh8PgYPHswk2G3atGH628tKsB88eKDRVeXLly8zK4oikQiHDh3S2Fjq5MWLFwgJCQGfz8f69eu1Hc4nOXnyJFxcXMDj8TBx4kSNV3oUFRUhKioKxsbGdd4Pd/fu3eDxeOjYsWOZn0VFRUUYNGgQs4OjzraenJwchISEwNDQENeuXVPbdTXBvXv3wOVysWjRIm2HwlIHmDt3LiQSic7anbJ8HFVPfq9evWpkG2RlSUlJgUgkwrhx48p9ztOnT6Gnp4cxY8ZoMDLdRKWXdOrUqXIJyNE0DR8fH8hkMjRt2hTJycno1asXc29MURSWLVuGd+/eoUmTJiU+O96+fQtPT08m4SaEYOzYsZqeolap9Uk3AHz99deMGfvjx4+Rn59fYjVGT08Pw4cPR2hoKJN8rVy5EosWLcLo0aPB4/GYYwMDA3W2L7W8XL16Faampswb3dHREbNnz8bTp0+1HdpnmTRpElOm/MUXX1T6OkqlEomJiRAKhfjtt99Kvf7vv//i4MGDmDp1KvT19Uu0HRgbGyMqKgoTJkzAzp07NZ5gf8iDBw/QtWtXEEIglUohEol0ene7LAoKChgriWHDhun0DVx+fj6z4u3g4IDDhw9rbKzRo0eDy+Xi+PHjGhujJrBz505wuVx07ty5zPfG27dvERUVBR6Ph9WrV6t17IKCAkRHR0MikeCPP/5Q67U1Ra9evWBubl7jv5dYdB+VkrOqFY2lZvHjjz+Cy+UiMTFRJzdW1I1KKNnGxqZClWM9e/aEXC6vc6KBNE0jMDAQoaGhAAAHB4fPLjycO3cOhBAEBQXB2NgYfD4fUVFRJRJp1aalXC7H4sWL4ezsDA8PjxL936pr1PYFoTqRdL9+/RomJiYghCA9PR3z5s1jfslyuRyXL18uJaiWkpICR0dHuLq6IiYmBhYWFsw506dP195kKklxcTF++eUXtGrViplHbGwsTpw4UaPKjd68eQMDAwPIZDJMmDCh0tcZPXo0KIrC7t27mQR7xowZiIuLg6WlJfMzUvms9+nTBzt37sTDhw+10hf16tUrjBgxAgKBAObm5khISAAhBHv37q32WNQBTdNYvnw5uFwumjdvzpQb6Sp3795lKgs6deqk9vYSlWBLXd+x3L59O7hcLrp06VJmwn3v3j24ubnByMgIJ06cUOvYxcXFSExMhEAgwLFjx9R6bU2SkpICLpeLBQsWaDsUllpObm4u+Hw+qyNQg9m1axf4fD7atm1b6y0HVbu2FblPunTpEgghWLFiheYC01FOnz4NQgh++eUXAO/bSVq1avXJc7p27QoHBwds2rSJsQoDACMjI3To0OGTrbsfPgQCQZ1Y5KgTSTcArF69GoQQ/PPPPyX6bs+fPw/gfW/szJkzAbxX6fTz80OvXr0wZ84cREZGYv78+czKjbm5+UdFfXSNBw8eYMqUKcycBQIBjI2NcfnyZW2HVmlUipyVEXR5/vw5vvzySxDy3rv9wwTbxMQELVq0wMSJE7Fr1y78+OOPjBiEtsjOzsbs2bMhk8mgr6+P2bNnY+/evaAoqlaITZw8eRImJiaoV6+ezu/Y0zSN5ORkKBQKyGQyLFu2TC2rsn/++SeEQiF69epVZ4VuAOCnn34Cl8tFt27dyvy5/vrrrzA2NoaLi4vatSZomkbfvn3B4XCwZ88etV67OujTpw9MTU1rtKgnS82gcePG6Ny5s7bDYKkCBw8ehFAoRHR0dK3Vg3j37h1sbGzQunXrcn+v0jSN0NBQ1K9fX6cr8DRF69at4eHhwfy8Jk6cCGtr648eX1xcDD09PUydOhU//PAD9PX1YWpqisLCQjRu3BiJiYlo2LAhYmNjS+1qq3a/BwwYAGNjYwwdOrS6pqlV6kzS/e+//4LH46FPnz4llKRDQkLQuXNntGjRAk5OTjA0NCyRhKl6uymKgkKhYF77UAFd18jLy8NPP/2E5s2bg5D3Vl9dunSBubk5HB0d8ejRI22HWCWePXsGQgiaNWv22eN+/vlnTJ8+HbGxsSWqFcRicYkE+9GjRyU+mN++fQsbGxuEh4drpRKgqKgIa9asgYWFBfh8PoYPH45Xr17h/v37MDQ0ROvWrWtUhcKnePDgATw8PCCVSmuEJ3V6ejr69u0LQggCAgJw5cqVSl8rLS0N1tbWCAgIqNPWT1u2bAGHw0GPHj3KTLjXr18PPp+PyMjIcnuslheapjF27Nhy9a/pKg8fPgSPx8P8+fO1HQpLLWf06NGwsbHRdhgsVeTYsWMQi8WIiIiolYt148aNg0gkqpA+yu7du0EI0Wgbma5y48YNEFLSHlm18fSxHejhw4eDEIJly5YhLi4OkydPBkVR2Lt3L0QiUQkBtTdv3mDevHno2LEjJk2ahPbt2yMzMxNDhgwBh8PB33//XV1T1Sp1JukGgI4dO0IkEjGJV/369bFt2zYMHTqUMXUPCgpCv3798OWXXzI9CsHBwZg0aRLTF04IQUJCgranU4rr169j+PDhMDY2BiEEISEh2LhxI65evQorKys4OzvXClXAf/75h1GVv3PnDoBPJ9hyuRwtW7ZEt27dwOPxEB8f/9kdyq5du8LAwACpqanVMSUGmqaxZ88euLq6ghCCLl26MF8a7969g4eHB5ydnbXuv61usrKy0LZtW1AUha+//rpG7PiePXsWDRo0AJfLxahRoyqsNl5QUICmTZvC3Nz8k8r5tZ3NmzeDw+GUKfBTXFyMMWPGgBCCAQMGaKQPUeVxX9NL+/v27QuFQlHnVe9ZNIuqZFdXrR9Zys/p06chlUoRHBysVvcHbXPjxg3weDzGYrY85Ofnw9HR8bPl1LWVHj16wMbGpsR37LVr10AIKdNt5tatWyCEgM/no2vXrkhOTkZ+fj5jBebg4MAcqxJQa9euHTIzM3Hq1CmMGjUKo0aNAiG12yLsv9SppFulxqd6vHv3DsXFxXBzcwOPx8OOHTsAADExMYygmkriHgCSkpLQpk0bEEJQr149rczhv2RmZmLNmjUICAgAIQSmpqYYN24ck4zevn0bFhYWcHNzqxU2Z8D/felLpVJYWFiUUKFXJdiTJ0/Gnj17kJqaCpqmcfPmTcYj+3OtAdu2bQMhBFu2bKmmGb3nt99+Q5MmTUAIQVRUVIkWAJqm0aFDB0ilUty6data46oulEolpk2bBkIIEhMTa4QwVEFBAb755huIxWLY2Nhg37595T63X79+EAgE+P333zUYoW6zceNGRjPhv5UbWVlZiI2NBYfDweLFizWyELNixQoQQjBjxgy1X7u6efToEfh8PubOnavtUFhqMWlpaSCEYNu2bdoOhUUN/PHHHzAwMEBAQIDaq4i0AU3TCAkJgaura4V61lUtpLX1/upTpKamgsfj4fvvvy/xfH5+PrhcbpmCpT179oSJiQns7e1hZ2cHPp+Pli1bMgK/qjxp3759sLW1RXBwMPT09GBnZwdbW1vw+XzGrrm2uEKVhzqVdNM0DSMjIyZBKyoqwqRJk0AIYfr4/iuo1q5dO1y4cAHZ2dmoV68ejh49il69eoHD4WjNw5qmaZw9exZffPEFY/XVunVr7Nmzp8Qq1Y0bN2BqagoPDw+kpaVpJdaqQNM0nj59iv3792PatGlo3bp1iQRbVZ3w5Zdflkiw/8uTJ09gbW0NLy+vzwo1PH36FEZGRujUqVO17bbeunWLWczx9fXF//73v1LHzJ07t8T7tDazc+dORqG+puymPHjwANHR0SCEID4+/rNxr1y5EoQQnbdN0yQqC5u+ffuWSrgfPXoET09P6Ovra8wO78cffwRFURgxYkSNqKwoDwMGDICJiQmysrK0HQpLLaZevXp1pgezLvDXX3/BxMQEPj4+NT4B2rhxIwghFXIBefnyJWQyGQYNGqTByHSXkSNHwsjIqMwqKTc3t1J/66dOnQKPx8PkyZMxadIk8Hg8eHt7A3gvoPbw4UOMGzcOenp6TO92/fr14eTkBIqiwOFw4OLiAnd39zpXWVCnkm4AaNGiBZO0Xbt2DUKhsESp+IeCaleuXEHv3r1hbm4OU1NTWFtbY/bs2Xj79i2MjIwwYsSIao39xYsX+O677+Dm5gZCCBwcHDBr1qwyS8avXLnCfIi+evWqWuOsDKoEe9++fZg6dSpiYmJgZmbG/K4UCgVatWqFKVOm4MsvvwSfz0dBQQGcnZ3RunXrj143IyMDnp6esLW1/WwJr1KpRFRUFCwtLatFTfvJkyfo06cPOBwOHBwcsHXr1jL7tI8cOQKKojBlyhSNx6QrXLlyBba2tjA1NcXZs2e1HU65oGkaO3bsgIWFBSQSCRYuXFimGMuZM2fA4/EwZMgQLUSpG6xdu5YpGf/ve/7333+HqakpHBwcNCau9/PPP4PL5aJXr161RhsBAB4/fgyBQIA5c+ZoOxSWWkyPHj1KbE6w1HxUmzT169evsVWR6enpUCgUSEpKqtB5AwcOhIGBQY24V1Y36enpkEgkH72/7NChA8LDw5l/X7t2jUmmL1++jEWLFoGiKNja2pYQUAsPD8fZs2dx9uxZzJgxA8OGDcOoUaPg6emJ+/fv4+LFiyCE1AgdH3VS55LuKVOmMImcSrl648aNaNy4MUJCQmBpaYlFixbBwcGB6Vfw9PREy5YtIZPJQAgBj8eDo6MjZDKZxgUoiouLcejQIbRv3x48Hg8CgQCdO3fG8ePHP3qzeOnSJRgZGcHf318nrZhomsaTJ08+mmCbmpoiOjoaU6ZMwd69e/H48eMSO1GTJ09mhFx++umnj/ac5OfnIzw8HIaGhuUqGVq8eDEIIWXuNKuTt2/fYvz48RCJRIxv4cfKoFTCaTExMbXev/C/vHjxAiEhIeDz+Vi3bp22wyk3GRkZGDJkCCiKgo+PDy5evMi8lpqaCoVCgWbNmtUJn9SyUDlJDBo0qNQO85YtWyAUChEcHKyxHZdTp05BKBSiXbt2tVKhdtCgQTA2Nq5VPZosusXq1avB5XJZ/YBaxp07dxj9n5pSZfYh/fv3h0wmq9Ciwc2bN8HhcPDdd99pMDLdZfbs2RCJRHjx4kWZr8+YMQOmpqYA3rfTqXIjQggePHiAuLg4JCYmgsvl4tSpU6UE1FR88803sLe3R79+/fDmzRs4OzvDxcWlzt3X1rmk+9GjR0wfgapEuXHjxti8eTPevn0LiUQCQgj09PSwY8cOLF++HFKpFM2bN0dSUhI2bNiAESNGgMvlgsPhYOXKlRqJ8+HDh5g2bRpj9eXp6YnFixfj9evXnzzv/PnzMDAwQGBgoE6IbakS7L1792LKlCmIjo6GqalpiQQ7JiYGU6dOxb59+/DkyZPPlnp++eWXaNSoEYD3u9NeXl4ICwsrcZ5SqURSUhKEQiHOnDnz2Thv3boFkUik0ZK5vLw8LFiwAMbGxtDT08OUKVM+eWOcnZ0NT0/PWimcVl4KCgrQv39/EEIwdOjQGpUkXbhwAT4+PqAoCoMHD8bz58/h5+cHOzu7OrmiDvxfD/WQIUNK/b2qFkR79uypMf/YixcvQiqVIioqqtZ61D558gRCoRCzZs3SdigstZSbN29WuISXpWaQkpICOzs72NvbV0j5W9ucP38eFEVhyZIlFTqvVatWqFevXq39PvgUubm5UCgUGDhw4EeP2bVrFwghePHiBaN3pHp88803SE5ORmZmJsRiMeRyORwdHZlzVQJqKoqLi9G8eXPUq1cPfD6f0Z6qS9S5pBt4b/iuUr/+0G9SpWLbvXt3xMbGIisrC2lpaYiIiAAABAUFMbvLXbt2hampKczNzdW2m5yfn49t27YhKioKFEVBX18f/fr1w8WLF8vVc3j27Fno6+ujadOmWtnloGkajx8//miCbWZmVuEEuyxiY2MRFxfH/Pvnn38utUM9ZswYUBSFnTt3fvZ6BQUF8PPzg5ubm0bEu4qLi7Fp0ybY2tqCy+Wif//+n12JpWkanTp1qtXCaRVhxYoV4PF4iIyM/OzCky5RVFSEhQsXQiKRQCwWQyAQlBDIq0ssW7YMhBAMHz68xN99Tk4OOnToAIqiMHfuXI31V9+6dQvGxsZo0qRJrbTI+ZChQ4fC0NDwsxoWLCyVQalUwtDQEF999ZW2Q2HRAKmpqXBycoK1tbXWtIsqQlFREXx9feHr61uhndPDhw+DEILdu3drMDrdZeXKleBwOLh///5Hj7lz5w4IITh58iTCwsJKJN0CgQBRUVEICwtjKnEJIQgLC0P79u2hp6eHwMBArFu3Dr/99huSkpJAURTEYjH8/f2rcaa6Q51Muv/44w/weDxwuVx07doVwP951FlZWaGwsBArV66ElZUVzM3N8csvvwAAs7sKvC9x/uGHH2BsbIwvv/yySvHcuHEDI0aMgImJCQghCA4OxoYNGyp0Y/jrr79CIpEgLCysWkq+aJpGamoq9uzZg8mTJ6NVq1YlfMzNzc3RunVrTJs2Dfv378fTp0/VdjPdqFGjEj9zmqbRuHFjNGrUCDRNY9GiRSCEYPHixeW6nkoI4tKlS2qJ78O4Dh06BC8vLxBC0K5du3Kv7M2bN69OfxmUxalTp2BiYgJHR0eN9fpqCpVgIyEE0dHRNWoHQR0sWbIEhBCMHDmyxOfAs2fP0LBhQ+jp6WHv3r0aG//BgwewtLSEl5dXrVDo/RzPnj2DSCRi9ElYWNRNdHQ0WrZsqe0wWDTEs2fP4O7uDjMzM53/vl2yZAkoisKFCxfKfU5RURHq169fqkqyrlBcXIx69eqhU6dOnzyuqKgIAoEAU6dOZe5hXF1doVAoIJFIAACdO3eGl5cXCgoKMG3aNOjr6zPHqvq/CSEQiUQICgpi2nrrInUy6QaADRs2MF7WANCnTx9wuVx4eXkhKCgIBgYGyMzMxLfffguRSAQTExPw+XyYmJhALpeDx+PBwsIC06dPh1gsrvCNXFZWFtauXYvAwEBGKGzMmDGVMog/fvw4xGIxmjdvrpGd2oom2Jr2HLaxsSkl+nDixAkQQjB27FhQFIWxY8eW61pnz54Fh8OpkJ9jebh48SLCw8OZ99gff/xR7nOPHj0KDoeDyZMnqzWm2sCDBw/g6ekJqVSK/fv3azuccnH48GFwOBxMnDgR+/fvh42NDcRiMb755ps60df9/fffgxCCMWPGlLi5+euvv2BpaQlra2uN7v4/f/4cjo6OcHJywr///quxcXSN4cOHw8DAoM62prBoltmzZ0Mmk9W5nsy6xIsXL+Dl5QW5XI4rV65oO5wyef78OWQyGQYMGFCh85YvXw6KovDXX39pKDLdZseOHSCElGuzydvbu4QIdVxcHEaOHMnoKX0onqbSV7p69SrWrVuHBQsWwNraGidOnIBSqcSwYcNgYGCAvLw8TU9RJ6mzSTcA9O3bl/mj43K5aNeuHXJzc/Hu3TtYWFhg5syZjN+cra0txGIxvvjiCwwfPpwRVTM2NgaHw8HChQs/Ox5N0zh37hx69+4NiUQCDoeDmJgY7N69+7Pe0R/jyJEjEIlEaNWqFXJzcyt1jf/G+OjRI+zevRuTJk1Cy5YtIZfLmT82CwsLxMbGYvr06fj55581nmCXFZ9AIMDSpUtLvebv7w+KopCYmFguReKsrCw4OjoiKChIbb3C9+7dQ6dOnUAIQYMGDXDgwIEKraKmpKTAyMgI0dHR7M3MR3j37h0SEhJAURRmz56t06vU//zzDwwMDNC6dWvm9/nu3TuMHj0aXC4XDRo0qDHq7JVhwYIFIIRg/PjxJX5Pu3btglgsRkBAgEaVctPT0+Hh4QErKys8evRIY+PoIv/++y/EYjGmTZum7VBYaiGnTp1iXGBYai/p6elo2LAhDA0NK7STXF0kJSVBoVBUaOPr7du3MDExQa9evTQYme5C0zT8/f0RGRlZruO7du0KAwMDJg9wd3dHQUEBRCIRrK2tPyqeBgALFy5k9EV27NgBiqLwxRdfqH1ONYU6nXTn5ORAJpOhYcOGIIQgICAAYWFh2LZtGzw9PUEIAZfLRd++ffH8+XMEBwejefPmaNKkCTZt2oQGDRpgyJAhTDL6sSTp5cuXWLBgAdzd3UEIgb29Pb766qsqq0MeOHAAAoEAcXFxlRKB+G+C3aJFC51KsMvizZs3IISU6tW+desW49u9YcOGcl2rT58+kEgkn+xnKS9paWkYNGgQeDwerK2t8cMPP1Q4aVYJpzk5ObG7U59BqVRi+vTpIIQgMTFRIxUeVSUzMxPu7u5wdXUts7f2ypUrCAgIACEEffv21Umngarw7bffghCCiRMnMgk3TdOYPXs283tTx0Lhx3j37h0CAwMhl8tx+/ZtjY2jy4waNQoymaxOlNSzVC85OTngcrkaE5Nl0R0yMjIQFBQEfX19/Pbbb9oOh+H48eMghGDTpk0VOm/06NGQSCQ6cU+rDVSVoUePHi3X8RMmTCjRy63SVPL09ISFhQX4fD7+/PNPACXF044ePYqEhATk5eVh8eLF4HA4oCiqQpWftY06nXQD703hVbvZqsRVtRrTsWNHLF26tFRvtwqVEMBPP/0EDodTwre7uLgYhw8fRocOHcDn8yEQCJCYmIhjx46pxRd279694PP5SEhIKNcuOU3TePjwIXbt2oWJEyeiRYsWTA+5yj4tLi4OM2bMwIEDB3TWp/H27dsghJT44H/69ClsbGzg6emJ6OhoODo6frZsd9++fSCEYO3atVWKJysrCzNmzIBUKoWhoSHmzZtXqURCJZwmkUh0vn9Kl9i1axf09PTg6+uL1NRUbYfDoFQq0aZNG8hksk/28RcXF2P58uWQyWRQKBRITk7W6Z378vLNN9+AEIIpU6Yw88nLy0O3bt1ACMH06dM1Os+8vDxERkZCX19f7VoNNYm0tDSIxeKPerCysFSFhg0bolu3btoOg6UaePfuHcLDw6Gnp6cTqvX5+flwcXFBSEhIhb5L7t27Bz6fX6dFAFu0aAEfH59y/9w6d+4MoVBYIvFu2bIl9PX1YWNjAw6Hw2xcKhQK2Nvbw9nZGb6+vhg/fjzMzc2Z8yiK+qg9WV2gzifdWVlZsLW1BSEEOTk5yMjIgEQiga+vL169egUvLy/k5uYiIyMD3t7eWLJkCZo1awY3NzcIhUI0bNgQQ4YMwdixYxkLjenTp8PGxgaEEHh4eGDRokVqVVzesWMHeDweOnbsWGZy+d8EOyoqqkYm2GVx8uRJEELwzz//AHi/Auvl5QUbGxs8ffoU165dA0VRWLVq1UevkZaWBoVCgTZt2lT6xr+wsBDLly+HqakphEIhxowZU6WdStWu4K5duyp9jbrK1atXYWdnB1NTU51ZhZ86dSooisLBgwfLdfzz58+RmJgIQggiIyNrhGLsx/j6669LJdYvXrxAUFAQRCIRfvrpJ42OX1RUhLZt20IkEuH06dMaHasmMGbMGOjr69co1X+WmsHw4cPh4OCg7TBYqonc3Fy0bNkSQqGw1CZUdTN79mzweLwKb1IkJCTA2tpaJ6vjqoMrV66AEIKtW7eW63iapiGVSjFw4EAEBwczecSpU6dgZGSEp0+f4vTp03B3d2fabj98cDgcGBkZMf9u06aNhmeo29T5pBv4P0GBixcvokmTJiCEwM3NDUFBQTAxMcGzZ8/QtGnTUm+m/z54PB7j/d23b19cuHBB7bs5P/74IzgcDrp06YKioiLQNI0HDx5g586dmDBhAqKiomBsbMzEZGVlhTZt2mDmzJk4ePBgjRcS+umnn0AIQVZWFgoKChAREQFDQ8MSH7xdunSBlZVVmTvONE0jNjYWCoWiUqttNE1j+/btcHJyAkVR6NmzZ5V3WP/3v/+Bw+Fg0qRJVbpOXebly5cIDQ0Fn8+vcvVCVVH5Ws6ZM6fC5x4+fBgODg4QCASYMWNGjfMO/eqrr0AIwYwZM5jnrl+/Djs7O5iZmeH8+fMaHV+pVKJHjx7g8XhavynUFV6+fAmJRIKJEydqOxSWWobq3qkmLdyzVI38/HzEx8eDz+djz549WokhJSUFIpEI48aNq9B5v/76KwghSE5O1lBkuk9SUhLs7e3LrWOkUi1fv349Bg0axOQWDRs2REBAQCkBtYcPH+LXX3+Fk5MTzp07hydPnqBBgwbMeUeOHNHk9HQeNunG+11LMzMzREREQCAQQCgUIjg4GNu2bUNgYCCTTH/44HK5H02+v/vuO43EuWHDBlAUhbCwMIwdOxbNmzf/aIL9yy+/IC0tTSNxaJPvv/8eYrEYxcXF6NKlCwQCQandrHv37oHL5WLBggWlzl+zZg0IIfj5558rPPbJkyfRqFEjEEIQExOD69evV3oeKljhNPVRUFCAAQMGgBCCoUOHakUZ/Pr165BIJEhMTKz0gltOTg4mTpwIHo8HFxcXnDx5Us1RaoYZM2aAEMKIpgDAwYMHIZVK4e3tXWUNi89B0zSGDh0KiqI0vpte0xg/fjykUilevXql7VBYahHPnj0rU2OFpXZTWFiITp06gcvlVvtnLU3TiImJgY2NTYXscZVKJfz8/NCoUSO1tHjWRB48eAAul1umEHFZqBYpCCHYsmULWrduzVQGq3axr1+/XqaAmr+/P16+fMlsZKrEhevqz14Fm3T/f6ZNmwapVAoHBweMHj0awHv11w8V+yQSCXr16oXAwEDmvIyMDCxZsqRUv8OWLVuqFA9N00hJScGOHTswfvx4RoRN9bC2tkZ8fDy++uqrWptgl8WECRPg4ODAWIPt2LGjzOP69u0LuVyOrKws5rl79+5BIpGgb9++FRrz2rVriI6OZnpWTp06VZUpMGRnZ8PLywv16tVjhY7UyIoVK8Dj8RAREVGtJbWvX7+Gg4MDvL29kZ2dXeXr3bx5kynn6tGjB16+fKmGKNUPTdOYNm0aCCH4+uuvmecWLlwIDoeD+Pj4Ct0cVRZVDKtXr9b4WDWNV69eQSqVYvz48doOhaWWYWdnh5EjR2o7DJZqpqioCN27dweHwym3eK062LNnDwgh2Lt3b4XOU9kE12a3kM8xZMgQmJiYlLu0PiEhAa6uruDxeOjatSuSk5Nx5coVpoebEAIDAwOMGDECPj4+yM/PR3FxMa5duwaFQsGIG6ucnmpy25y6YJPu/8/Tp08hFoshFouZslCVzzIh772oVY//li0uXLgQX331FUaNGsUcLxAI8PDhw3KNrUqwt2/fjnHjxiEyMrJED4ShoSGT8B08eLDOJNhl0atXL9jb24MQgkWLFn30uMePH0MoFDJiGUVFRWjcuDEcHR3LnQA8evQIPXr0AEVRcHZ2xs6dO9XWLkDTNBITEyGRSHDjxg21XJPl//j1119hYmICR0fHavn5FhUVITIyEnK5vNx/9+VBqVRi3bp1MDIygrGxMdatW6dTK8U0TWPy5MkghGDu3LkA3lcc9O3bF4QQjBs3rlriXbhwIQghmDdvnsbHqqlMmjQJEomkTovYsKifLl26ICAgQNthsGgBpVKJfv36gRBSLSr27969g42NDVq3bl2hezGVDXCnTp00GJ1u8+rVK4jF4hKtX5/iyZMn4HA4WL58OcLCwmBsbAw+n4+WLVtCT0+vROL9uQeXy8Xly5c1PMOaAZt0f8CePXvA5/MxdepUXLp0qUTC7e7uzgiq+fn5MYnyqFGj4OnpicWLF2Pv3r3o1asXc15Zuwo0TeP+/fsfTbBtbGzQtm1bzJo1C4cOHcKsWbNACMHw4cNrhapxVfHx8QEhhKlG+BQjRoyATCZDeno6Zs2aBQ6Hg99///2z571+/RqjR4+GQCCAmZkZVqxYofZS5fnz57NleRrmwYMH8PT0hFQqxb59+zQ61ogRI8DlctVWBfFfXrx4ge7du4MQguDgYJ1QuKdpGhMnTgQhBPPnzwfw3tO1WbNm4PP51bb7sX79ehBC2J7lz5Ceng59fX2MGTNG26Gw1CKWL18OHo9XZ4Wp6jo0TWPYsGEghOD777/X6Fjjxo2DSCTCgwcPKnTe1KlTIRQK1bogXtOYPn069PT0yl39l5SUBB6Ph8zMTEZLyd3dHQBgZGSE33//HTExMaAo6qPJtsoibPr06RqcWc2CTbr/Q/369REREcHspqoSYX19fXTu3Bk5OTkwNjYuVXau6vH+sP9bLpfj1q1b2LZtG8aOHcuIfv03wZ49ezYOHz5cagdClZiNHTuWTbgBnDlzBhRFwcnJqVy7Zy9evIBEImGElT5nm5Obm4u5c+fCwMAAUqkUM2fO1EhZrEo4jU0SNM+7d+/Qrl07EEIwe/Zsjfwdbdq0CYSQcvdJVYUTJ07AxcUFPB4PEydO1NqNLk3TGDduHAghjHbCnTt34OTkBBMTE5w5c6Za4ti5cyc4HA4GDhzIfkaWgylTpkAsFtfpaikW9XL16lUQQvDrr79qOxQWLUHTNMaPH19pAdHycOPGDfB4PMyePbtC5z1+/BhisRgTJkzQSFw1gezsbJiYmGDo0KHlOv7gwYMg5L3TEfC+NN/AwACGhobIz89H48aNGQG1w4cPY8GCBTA0NESjRo0QGBgIOzs7jB07Fn369IFYLGbbJz+ATbr/g6rv48PVmxUrVmDevHmwsLBgehT8/Pzg6uoKkUiEsLAwhISE4OLFixg+fDi4XG6p1R9bW1skJCQwCfbn+jNVtjuTJ09mbyYB3Lp1C0ZGRhAIBJg8eXK5zxs/fjwoioKXl9dHd6uLioqwfv16WFlZgcfjYciQIRorwXzw4AGMjY3RqlUrVjitmlAqlYzIV6dOndTSb63iwoULEAqF6N27d7X9nebn52PGjBkQCARwcHDA4cOHq2VcFTRNY/To0SV2No4dOwYDAwPUr18fKSkp1RLHkSNHwOfz0aVLF50quddl3rx5A5lMhlGjRmk7FJZaQnFxMfT19TWWbLHUDGiaZr5np06dqtbvQ5qmERISAldX1wo7enTt2hWmpqbIzMxUWzw1jSVLloDL5ZZrp7+goAAKhQL16tWDnZ0diouLERcXh507d4IQgi+++AIikQipqaklBNQaNWrEXGPSpElM1e/y5cs1Na0aCZt0/4fc3NwS5d4REREA3n+xqAQF/Pz8kJWVhbS0NOZ1FUVFRYiNjUWrVq1AURSio6MrJIBE0zSmT58OQghmzpyp1rnVVJ49ewZbW1s0aNAAXC63Qr1Dqt7SLl26lHqNpmns378f9evXByEEiYmJuHfvnjpDLwErnKZddu3aBT09Pfj4+FTZ5g14761taWmJxo0ba8Xa6+7du4iIiGDeu9Vh20PTNEaOHAlCCJYsWQLgvXAdl8tFq1atkJGRofEYAODcuXPQ09NDbGysVlTqazLTp0+HSCRibZ5Y1EZUVBRat26t7TBYdIB58+aBEIIxY8aoLfHeuHEjCCE4fvx4hc67cOECCCFYs2aNWuKoiRQVFcHOzq7Me+Cy2LZtG1Nhy+fzIZVKkZycDCcnJ0YwWiQS4fjx4zhx4gSkUimaNm0KDw8PFBcX448//kC9evUYHSqWkrBJdxmoyiYJIYiPjwcAjBkzBoQQ7N+/HytXroSVlVUpUbVvvvkG9vb26NevH4qKihAdHQ2hUFhub2yapjFp0iSNlujUNDIzM+Hl5QVra2umjK28qpVHjhwBIQRxcXHg8/klVvl+//13Rhk6IiICf/75p2Ym8P+haRqdO3dmhdO0zNWrV2FnZweFQoHffvut0tfJz89HkyZNYGlpqdXkhaZpbN68GQqFAjKZDMuXL9dYBQVN0xg+fDgIIVi2bBmKioowdOhQEEIwbNiwcvt+VpWrV6/CwMAAYWFhyM3NrZYxaxNv376FgYEBhg8fru1QWGoJM2bMgJGREVtxwgIAWLx4MQghGDx4cJXfE+np6VAoFEhKSqrQeTRNo2nTpvD09KzTVYU//vgjCCG4evVquY53d3dHcHAwbt++DUIIZDIZoqKiIJPJIJPJEBcXBz09PRBCIBQKIZfLMXHiREilUjg5OYEQAj6fD0IIjh07puHZ1TzYpLsMMjMzmaQ7JCQEr169Ap/PR1JSEpMEfiiqdvPmTYwYMQItW7ZE06ZNYWpqil69euH69esQiUTl6kGhaZpJ7DXl813TKCgoQGRkJAwMDHDz5k1cv34dhJByi6FZWFigRYsWyMrKgpmZGXr16oW///4bCQkJIITA29sbR44cqZayYFV//scszliqj5cvXyIsLAx8Pr9SK+A0TaNPnz4QCoW4cOGCBiKsOOnp6fjyyy+Z1eUrV66o9fo0TWPIkCGMSm1GRgZatmxZ4cqTqnL37l2YmpqiYcOGdbpcsKrMnDkTQqEQz54903YoLLWAY8eOgRCCW7duaTsUFh1h9erVoCgKffr0qVLS279/f8hksgovbm/fvr3OJ340TcPb2xstW7Ys1/H79u0DIQSrVq1CcnIyPDw8IJFIAACurq6QSqVISkrCoUOH4OnpCS6XC2tra1haWkIoFMLExATu7u4ICAiAi4sLuwhXBmzSXQY0TcPa2ppR31OVH3t7eyMoKAgmJiYoKCjAkCFDGNl8mUyGhIQEdOvWDZaWloywmp2dHczMzD65C/Sh+qOqZLOuo1Qq0bVrVwgEAkagRfXF/jnlSpqm0aFDBxgZGeHp06cAgFmzZoGiKHA4HNjZ2SE5ObnaPhCOHTsGDodTp4U8dI3CwkIMHDgQhBAMGTKkQiXKy5YtAyEEGzdu1GCEleO3335j2jBGjx6tFiFApVLJ/KxWr16NlJQUuLu7w9DQsFpvaB4/fgxbW1u4u7vj1atX1TZubSQjIwOGhoblFtZhYfkUWVlZ4HA4dbqMl6U0mzdvBofDQdeuXStVCXX+/HlQFFXh++K8vDzY29sjNja2wmPWJlTVnidPnvzssVevXoVIJAIhBLt27UJcXByThP/www+M6vmmTZswZMgQAEDTpk2RmpqKtLQ0GBgY4J9//sHRo0fB5XI/aelbl2GT7o+g6qtWJd5SqRTBwcHYtm0bmjVrBlNTUyap3rhxI8zNzREWFoamTZuiZ8+eaN68OaKiouDq6goOh/NR/9gPb2irc8dI11EpYW7fvp15Ljk5GYSQzyo2b968mdlVzsjIwOTJkyESicDhcODt7V2t/bcq4bSWLVvW6RInXWXlypXg8XgIDw8vl5XGqVOnwOPxdLo0t6CgAN988w3EYjFsbGywf//+Sl9LqVSif//+oCgK69atw5kzZ2BiYgInJyfcuXNHjVF/mhcvXsDV1RX29vbMQhpL1Zg9ezaEQiGePHmi7VBYagE+Pj7o1auXtsNg0TG2b98OHo+HDh06oKCgoNznFRUVwdfXF76+vhW+d/rmm2/A4/Gq9TtKF4mIiEDDhg3LVc3ZoUMHxrVp0KBBSE5OBk3TkMvl4PF42LRpEwAgJycHISEhAIBLly4hIiIC7du3R3BwMPbt2wexWIzmzZtXW7tZTYNNuj/C06dPmd1qoVCIvn37Mq916NCBSbjfvn1bSlCtU6dOOHDgAEaPHo2cnBzExMRAIBCUKotWKpXo06cPKIrC+vXrq21uus7SpUtBCMHChQtLPP/dd99BX1//k+c+evQIMpkMSUlJWLRoEUxMTCAWizFx4kTmun/99Zcmw2fIycmBt7c3HB0dkZ6eXi1jslScX3/9FXK5HA4ODp/st3/06BHkcjkiIiJqxBdKSkoKWrVqBUII2rZti8ePH1fofKVSiS+//BIUReGHH37Ahg0bwOfz0axZs3J7faqDjIwM+Pr6wtzcXKNCh3WNzMxMGBsbY9CgQdoOhaUWMHjwYDg7O2s7DBYdZN++fRAIBIiLi0NeXl65zlmyZAkoiqpwC1daWhr09fUxbNiwyoRaa/jzzz9BCMHOnTs/e+yzZ8/A4XCwePFiiMVi8Hg8REVFQU9PD1wuF2KxGIQQREdHo3fv3pDL5WjSpAkmTJjACBLb2NiAy+WCx+Ph7du3mp9gDYVNuj9Bz549GVGAgQMHAnhvXcXlctGhQwcsX768lKDa6dOnMWvWLOzbtw8DBgxAXl4e8vLy0KRJE7i4uDArTsXFxejRowc4HA42b96stTnqGrt37wZFUWVa2owZM+aTX+pKpRJhYWEwMTGBra0tOBwOvvzyS2ZnrKioCC4uLoiOjtZY/CpomkZSUhIkEgmuX7+u8fFYqsbDhw/h5eUFqVSKffv2lXo9JycHPj4+cHBwqNaEs6rQNI3t27fD3NwcUqkUCxcuLNeCgVKpRO/evZmEWyUu2bdv3wrtVlSVnJwcBAcHw8jIiP070gBz5syBQCCo8IIMC8t/2bp1KwghGrPbZKnZHD58GCKRCFFRUZ+tVnz+/DlkMhkGDBhQ4XH69u0LIyOjOr/R0bFjRzg5OZWrSqBbt24QiURIT0+Hg4MDeDweCgoK4O/vD39/f/z777+wt7dnLJNNTEwQHBwMkUjEKJrb29vDwMAAffr0qYbZ1VzYpPsTvHv3Dg0bNgSHw0F8fDwyMzMZdT4vLy9IJBJ07NgRr169go2NDerXrw+BQMAo96keBgYGaNKkCSPqUFRUhKSkJHC5XGzdulXb09QZfvvtNwiFQiQmJpbZb92tWzcEBwd/9HyVkJRKdf727duljlGJa1RFubo8fPfdd6xwWg3j3bt3aN++PQghmD17NrNARtM0EhMToaenh2vXrmk5ysqRkZGBwYMHg6Io+Pr64uLFix89tri4GL169QKHw8HatWsRHx8PDoeD77//vtq8yIH3ZfLR0dGQSCT4448/qm3cukRWVhZMTEwqdXPLwvIhqampFXIXYal7nDx5EhKJBGFhYcjKyvrocUlJSVAoFBW2Vr127Ro4HE6d7ye+d+8eOBwOVq1a9dljjxw5Aoqi0KxZMyQnJzOWb1u3boWrqytCQ0ORlJSE9PR00DSNHj16ICkpifE/79evH44fP874eKtbxLW2wSbdn+H169ewt7cHj8dDZGQkHBwc0KJFC7x8+RKBgYEYP348VqxYAYqiQAgBj8eDUCiEk5MT9PT0EBMTg5CQEKZMvUmTJujQoQN4PF65yj7qCrdv34aRkRGaNWv20Z7rqKgodOjQodTzly5dQmBgIAghsLS0xNmzZz86jlKphLe3N0JCQjSWQKiE08aPH6+R67NoDqVSiRkzZoAQgk6dOiE7OxvffPMNIy5S07lw4QJ8fHxAURSGDBlSylf7wwqcxYsXw9vbG/r6+jh48GC1xllcXIxOnTpBIBBU2JuVpWLMmzcPfD4fjx490nYoLDUca2trjB07VtthsOgwZ8+ehb6+Ppo0aVJmGfLx48dBCGF6iMsLTdNo3rw5nJ2dq7UaSxcZMGAATE1NP2up+e+//0IqlUKhUCA+Ph5xcXFQKpWQyWSQy+VMaf+H4mkXLlyAlZUVHB0dMXHiRADvW9nkcjkiIyM1O7FaAJt0lwNVf7eqr6F+/frYtm0b5s2bBzMzM/B4PPB4PPz000949uwZIiIicOrUKTRp0gQ+Pj4IDQ3F2rVrERUVBYqiwOVyyyxhras8e/YMtra28PDw+GQviKenJwYPHsz8OyUlBUlJScyChp2dXbn6hQ4ePAhCCI4cOaKO8Evw8OFDmJiYoEWLFqxwWg1m9+7dkEgkcHR0BCEEU6ZM0XZIaqOoqAgLFy6ERCKBhYUFduzYAZqmUVxcjG7duoHL5WLWrFkwMzODnZ1dtfvK0zSNvn37gsvlYs+ePdU6dl0kOzsbCoWihG4JC0tl6NSpE4KCgrQdBouOc/HiRRgZGcHPz69Eu1Z+fj5cXFwqtSly4MABEEKqJBxaG0hLS4NQKMTXX3/92WO/+uoriMViJCQkwN3dHcnJyQAAb29vuLq6wtzcHOfPny8hnhYUFIT79+9DqVQiPj4e27dvh5mZGUxNTfHy5UuNzq02wCbd5aRHjx4wMTEBIQRnzpwB8H53ViwWw97eHnPmzCnV3/369Wu8ePECZ86cgbOzM548eYLExEQIBAKcP39em9PRGTIzM+Ht7Q1ra+vPquiamppi1qxZePnyJYYNGwY+nw9LS0u0aNECAoGg3KW/NE0jKCgI/v7+at3tVvX9ssJptYP9+/eDoigIBAKcPn1a2+GondTUVMTHx4MQglatWiEuLg5cLhfDhg2DUChEUFBQtfdn0jSNsWPHVmqng6XyzJ8/Hzwe77N2jCwsn2Lx4sUQCATlFstiqbtcvXoVCoUCnp6eSEtLA/DeUYHH4+HmzZsVulZhYSFcXV0RERFRrS1QusjkyZMhlUo/W5pfVFQEExMT9O3bF7NmzQKXywWfz0fLli3B4XBgZmbG9HB7eXnBwsICwcHBkMlkEAqFjGsTIQRcLhfbtm2rphnWbNiku5ykpaXBysqK8bxT9XdTFIWLFy/Cy8sLubm5yMjIgLe3N5YuXcr4e3/4CAgIgI2NDVq0aKHtKWmdgoICNG/eHAYGBp/dTSsqKgJFUYiPj4e+vj5kMhnmzJmDw4cPg6IofPvttxUa+9SpUyCEYPfu3VWZAgNN0+jSpQv09PRYwadaQEZGBlxdXeHs7Izg4GDw+fxa60G7e/du6OnpgRACDw8PEELQrVs3rdw4z5kzB4QQLF68uNrHrstkZ2fD1NSUFcFhqRKXLl0CIeSTLV4sLCpu3boFCwsLuLm54dy5cxCJRBg3blyFr7N48WJQFIWrV69qIMqaQ1ZWFgwNDcsUIv4vI0eOBCEEly5dwuPHj0FRFKytrQEAenp6SEtLg6+vL9zc3GBoaFgqlyGEwNTUFE2aNEG9evXK1GFiKQ2bdFeAy5cvg6IoLFq0CNHR0XBwcEBYWBgaNWoEfX19JCYmYu7cuWW+Oct6fP/999qektagaRrdunWDQCDAqVOnPnlsYWEh83Pl8XgYOXIkXr16hYyMDNja2iIsLKxSpdxRUVGoX7++WsrAFyxYUMpXnKVmUlxcjNatW8PAwAB3795FYWEhBg0aBEIIhgwZgsLCQm2HqDYKCwvRsWNHcLlcWFhYMF+kmhYaLIsVK1aAEIKZM2dW+9gswMKFC8HlcnH//n1th8JSQykqKoKenh7mzZun7VBYagj//PMPbGxsoKenBwsLC7x7965C56enp8PIyAhffvmlhiKsOSxcuBA8Hu+zbhQq0TNCCPLy8pCcnIyAgAAIhULk5OSUElAD3i+QbNu2DR06dEDv3r1x48YNpKSkgM/nY8GCBdUxvVoBm3RXkJiYGFhaWkImk4EQAnd3d2zevBlz585ldos+fHA4HMjlcri5ucHS0rLU6/Pnz9f2lLTChAkTQAj5ZEkKTdPYtWsXXFxcmJ/Xh73w3bt3h76+fqUFgC5evAhCSJUt206cOAEOh1OpFVoW3WPSpEngcDg4fPhwiedXrVoFHo+H8PDwGmUb9jEKCwvRvn178Pl8ODk5QSwWY/78+QgICGDswaqrTWLLli2gKAojR46s8+WB2iI3Nxfm5ubo1auXtkNhqcGEh4cjPj5e22Gw1CBWrVoFQggUCgXu3btXoXOHDx8OqVSKf//9V0PR1QwKCgpgbW2Nnj17fvK47OxsGBoaomHDhiCEoKCgAHFxcbhy5Qo4HA7i4uLw7NkzACUF1FQ0btwYL168wL///gsnJyc4OTmVEmRl+Ths0l1Bjh07BkIIxowZA4qimF3S2bNnl0ime/TogVOnTiEiIgLA+wRx5MiR8PX1hbu7e4lj65pP97Jly0AI+eTq2OnTpxlF8pYtWzLnpKamAgB27Nihlr7Ptm3bwsHBodJql6xwWu1C9b762E7N6dOnIZfL4eDgUO0CY+qkoKAACQkJ4PF4MDExgaWlJf766y8A73f6ly9fDplMBoVCgeTkZI0mwj///DO4XC6++OILNuHWMosWLQKXy63wjS8Li4opU6ZAoVCwf8ss5eLdu3ewsbFBZGQkXFxcYGFhUabda1ncvXsXPB4Pc+bM0XCUus+mTZtACPlsP3yfPn1AURRWrlwJQggkEgmSk5OZhXeKouDp6YlLly7hzZs3MDc3R3h4ONq0aYOHDx8iPDwcBw8ehLW1NcRiMf75559qmmHtgE26K4jKcsrExARSqRTA+8RLZRmmSrj/K6rWokULpu+4U6dO6Nu3L3O8TCarcElNTWXPnj3MjlZZ3LhxA7GxsSCEwN/fn7EL2rhxIwghyM/Px7Nnz2BsbIwOHTpU+Yv9xo0bzAdQRVEJpzk4OLDCabWAq1evQk9PD0lJSZ98Xz18+BBeXl6QSqU10oWgoKAA8fHxjL2hv78/s7L9Ic+ePUOnTp1ACEFkZCTu3r2r9lhOnToFoVCI9u3bo6ioSO3XZ6kYubm5sLCwQI8ePbQdCksN5fDhwyCEaOTzgqX2MW7cOIhEIjx48ABpaWnw8PCAQqEolzBumzZtYGtr+1lrrNqOUqlEgwYNEBsb+8ljRowYAS6Xi5iYGKSlpYHD4UAqlSIqKgoymQwymQxt27aFra0tCCGQy+VwcXHB3r17sWvXLrRq1YoRlObxeJg8eXI1zrJ2wCbdleDBgwfQ19dndrpVggSEEIwcObKEqJqfnx/u3r0LFxcXuLi4wM7ODqampnB1dWXKOAkhWL16tbanpXHOnj0LkUiETp06lRJdePz4Mb744gtwOBw4Ojpi27ZtJY6ZO3cujIyMQNM0WrRoAQsLC7WV+Hbr1g0WFhYV+uCmaRpdu3aFnp5euVXTWXSXV69ewc7ODr6+vsjJyfns8dnZ2Wjfvj0IIZg1a1aN2dXJz89HbGwseDweCCHo0KHDZ+d7+PBhODg4QCgUYubMmcjPz1dLLBcvXoRUKkWLFi3Udk2WqrN06VJwOBzcuXNH26Gw1EAyMjJAURR++OEHbYfCouPcuHEDPB4Ps2fPZp579eoVfH19YWxsjEuXLn303BMnToAQgp9++qk6QtVpVDa4KmelslC1dBJCsHXrViQnJyMkJAQCgQBKpRKurq6QSqVo27YtvLy8UL9+feY+QfWgKAqdOnXCoEGDIBQKa0WbXXXDJt2VZNu2bUyPMZ/PZ2TzfXx8oK+vj86dO+Pq1asQCARMb7ebmxsmTZpUQopf9fD09KwxN+6V4e+//4aRkRFCQ0NLqCK/efOGWelUKBRYunRpmaXeI0aMgJubG1Nm/t9+26pw//598Hi8CvXXL1y48LM96Sw1g8LCQoSHh0OhUDDtC+VBqVRi5syZIISgY8eOyM7O1mCUVScvLw+tWrUCh8MBIQRTp04tt+JoTk4OJk6cCB6PB1dXV5w8ebJKsdy8eRPGxsYICgrS+Z9bXSMvLw9WVlbo2rWrtkNhqaF4enqywlYsn4SmaYSEhMDV1bXUouvbt28RGBgImUyGc+fOlTq3uLgYXl5eaNKkSa2+by4vISEhn/xZ/O9//yuRbxw7dgxxcXH4/fffGbcQVQL9YR+3i4sLtm7dimfPniEoKAiPHj1CamoqzMzMWO2PSsIm3ZWEpml4eHjAycmJeSMbGxtj8+bNmDdvHuRyOTgcDrhcLtavX4/U1FQYGhoiNDQUffv2BQBcv34dJiYm4HA4oCiq1pZjPX/+HHZ2dmjQoAHjHZiXl4dvv/0WhoaGkEgkmDZtGjIzMz96jaSkJAQEBEAkEmHw4MFqj7F///4wMTH5ZAwqTpw4AS6Xi7Fjx6o9DpbqZ+jQoeDxeJX24t6zZw8kEgl8fHwqLeqnafLy8hAREQEOhwM+n48ff/yxUte5efMmgoODmTaaly9fVvgaDx48gKWlJby8vD7rJcqiHZYvXw4Oh4O///5b26Gw1ED69+8Pd3d3bYfBosOoWgZVLYT/JSsrC6GhoZBIJKUcbtauXQtCCM6fP18Nkeo2qsR57969Hz0mJiamRNI9evRoJCcnAwBMTU3B4XCwYcMGAO8X2ENCQgAAAQEBTDI+YcIE/Pjjj3BycoK9vX2dF66rLGzSXQVWrVpVopdbtVN67949iMViuLq6omXLlsjKykJaWhojqqZix44dGDduHH755RfweDy0atWq1q3aZWZmwsfHB1ZWVnj8+DGKi4uxceNG2NjYgMvlYuDAgeX6423WrBmMjIzg6uparvLfivL06VMIhULMmDHjk8c9evQIcrkcUVFRrHBaLeCHH34AIQQrVqyo0nWuX78Oe3t7KBSKT5Z4aYPc3FwEBQWBoigYGhri999/r9L1lEol1q1bByMjIxgbG2PdunXl3jF//vw5HB0d4eTkhLS0tCrFwaI58vPzYWNjg6SkJG2HwlID2bx5MwghrNYJS5mkp6dDoVB89vMlJycHzZs3h0gkwtGjRwG8T8bNzMzQpUuX6ghV52nbti1cXV0/+h2ckpLC5CnW1tbgcrng8/mIioqCnp4euFwu47zUsWNH+Pv7w8TEBGFhYQgJCcHx48fx77//wtnZGYaGhhAIBLV2g7A6YJPuKpCdnQ1ra2sm6V64cCEAoGXLlhAKhUhLS8PKlStLiaq9ffsWJ06cQFBQEJYsWYLbt29jy5YtIITgxIkT2pySWikoKGAEGq5du4aDBw/Cw8OD6SWtyB+uXC4HRVH4888/NRbvqFGjoK+v/9E+lZycHPj6+rLCabWEP/74AwKBAH379lXLYterV68QFhYGPp+PNWvWqCHCqqMS+yOEwMHBQa078S9evED37t1BCEFISAhu3br1yePT09Ph4eEBa2trna0IYPk/VIvKn1PDZWH5LykpKSCE4MCBA9oOhUUH6d+/P2QyGZ4/f/7ZY/Py8tC6dWsIBAL8/PPPmDhxIkQiUYVawWorf//9NyiKwrp16z56zLhx45gcZfbs2bC2toZQKIRSqYS/vz/8/f3x77//wtbWFmKxGIQQ2NraIjExER07diwhnCYUCtG/f/9qnGHtg026q4hqRZcQgiFDhuD27dsghMDKygpBQUEwMDBAZmYm5s+fD5FIBLlczvR5f/iQy+UwNzdHQkKCtqekFmiaRvfu3SEQCLB8+XKEhYWBEIKwsLAKlwSpymeaN2+uoWjf8/LlS0il0jLLxlXCaWKxGFevXtVoHCya59mzZ7CwsEDTpk0rbRdXFoWFhRg0aBAIIRg8eDAKCwvVdu2Kkp2dDWdnZxBC0LhxY2RlZWlknBMnTsDFxQV8Ph+TJk0qU5AwKysLAQEBkMvlbMlyDaGgoAB2dnbo1KmTtkNhqWHQNA1zc3NMmDBB26Gw6Bjnz58HRVFYsmRJuc8pKChA+/btwePxwOPxMGXKFA1GWHPo06cPLCwsPipEmpWVBWNjYybPmDNnDqZNmwZCCI4ePQpXV1eEhoYiKSkJ6enpoGkaLVu2hFwuh5GREXx8fBAXF4dFixZh+fLlIISwFmFVhE26q0h6ejqEQiEIITA0NISjoyOEQiFevHiBd+/ewcLCAj/99BOMjIxACIGFhQUsLS2xaNEieHl5ITk5GXv27IGlpSWzmqRr5amVYeLEiSCEMF7bHh4e+OWXXyq8o/ju3Ts4OjqCEIK1a9dqKNr/Y+rUqRCJRKUslL7//ntWKbOWkJeXh8DAQFhZWWmsL2nVqlXg8XgIDw/Hq1evNDLGp3j79i3zmZKYmKjxVoi8vDzMmDEDAoEAjo6OOHLkSInXIiIiIJPJGC9wlprBmjVrQFFUjfakZ9EO7dq1Q2hoqLbDYNEhioqK4OvrC19f3wp/JxUVFcHOzq7a7gV1nWfPnkEgEGDevHkfPWbgwIElFMgjIyNRXFwMPT092NraMp/rH4qnqSo9//77bwQEBAAA7ty5AwMDA8THx2t2UnUANulWAz169GDe1BwOB3K5HGFhYdi2bRsiIyMZpfL27dvj6dOniIiIQKdOnTBx4kRG/bpDhw44cOAAnJycYGBgUKN7JubOncvYC9jY2GDjxo2Vvunv168fRCIRCCE4dOiQmiMtTUZGBoyMjDBw4EDmuZMnT4LL5WLMmDEaH59Fs9A0jV69ekEoFGq0VQEATp8+DblcDgcHB1y/fl2jY33I48ePYWhoCEIIxo8fX23jAsDdu3cRERHBJPuPHz9GfHw8RCJRrVhMrGsUFhbC3t4eHTp00HYoLDWMBQsWQCQSqbWSiKVms2TJElAUhQsXLlT4XFXFY3BwMCiKqvOJ97hx4yCTyZCRkVHm6xkZGdDT04Ofnx+Tn3z11VcA3rsLWFtbw9HREbdu3SohnvYhgYGBOHfuHExMTCASiVjhUzXAJt1q4Pz588ybWigUMgnbo0ePYGNjA0II+vbtW6q3OyUlBY6OjnB1dWUEJV6/fg0XFxc4OTnVOO/arKwsdOzYkfk5fPvttyXswSrKzz//DEIIs2teXbtk8+bNA4/HQ0pKCiOc1rx5cxQVFVXL+CyaY/HixSCEYPPmzdUy3sOHD+Hl5QWJRPJJdVF1cfnyZaYva9myZRofryxomsbmzZshl8vB5/PB4XDY3s4azPr160EIYdtqWCqE6r6IVZhmAd6LaMpkMgwYMKDC5yqVSgQGBsLHx6dEC9fSpUs1EKnuk5GRAZlMhnHjxn30mCFDhoDL5TLl5IQQ2NvbM+JppqamsLa2BkVRCAgIQPPmzeHm5oZ58+YhOzsb69atYzYMuVxuKSFolsrBJt1qgKZptGvXjikP/+KLL5CZmYmmTZvC0NAQ/fr1g5eXF3Jzc5GRkQE/Pz/QNI02bdqgZ8+eiIqKgqmpKTw8PNCrVy/GSmHr1q3anlq5KCgowNKlS5ndNVdX14+KkZWXFy9ewNTUFLGxsThw4AAIIaVKvjVFTk4OzM3N0bVrV/j5+cHe3r7K82HRPiqrt1GjRlXruNnZ2Wjfvj2z0qwph4IDBw6Ay+WCw+Fgx44dGhmjvNA0jb59+zJf9oGBgWzSVkMpLCyEo6NjrdEbYakeCgoKIBKJsGDBAm2HwqIDJCUlQaFQVGq39McffwQhhLEOo2kao0ePBiEE3377rZoj1X3mzZsHgUDw0XviXbt2gcvlIi4uDs+fP2fUy01MTODn5wd/f3+kpaXBx8cHzs7O0NfXL6UzRQiBgYEB8/+7du2q5lnWTtikW01kZ2ejSZMmIITAzc0N0dHRmDBhAggh8PT0hL6+Pjp37ozc3FyYmpoyPd4CgQBt27aFm5sb9PX1mVJqmUwGV1dXbU/rkyiVSvz0009wdHQERVEQCoUIDAys0u428P4DNT4+HnK5HGlpaVi3bh0oiqpWUaqlS5cyO/ZsslDzefDgAYyNjREVFaWVigWlUomZM2cyyv3Z2dlqvf6iRYuYRb9jx46p9dqVYerUqSCEYM2aNfjtt9/QoEEDcLlcjB49Gu/evdN2eCwVZMOGDSCE4MqVK9oOhaUGERoainbt2mk7DBYtc/z4cRBCsGnTpgqfm5OTAxsbG7Rt27bE8zRNY8qUKSCEYObMmbXObvdj5Ofnw8LCAn369CnzdZUri7GxMYYPH47k5GQEBQUxybORkVEJ8TTgfb98aGgo+vTpg44dOyI5ORlLly4Fh8MBIQSWlpZspaeaYJNuNfJh4i2TyWBoaAiZTIbNmzdj3rx5sLCwgJWVFSiKgoODA0aNGgU9PT2EhobCzMwMN2/eRGFhIby8vNCqVSsQQjBgwACd/DA5fvw4/P39GVVxKysr1K9fXy09H+vWrQMhhCnHnT17NuRyeZWvWxG+++47EEIYIQmWmkt2dja8vLzg6Oiodau3PXv2QCKRwNvbWy22WcXFxRgwYACzgHfu3Dk1RFk1FixYUGoHoqCgAHPmzIFIJIKNjQ1+/vlnLUbIUlGKiorg5OTECumwVIgJEybA3NxcJ+9hWKqH/Px8uLi4ICQkpFLvg1mzZoHP5+PevXtlvj579mwQQjBhwoQ68T5bv349KIrCnTt3ynw9MjISvr6+cHd3x9ChQxEXF4eLFy+W2MEeM2YM1q9fz4inbdq0CVu2bMGGDRuwZMkS7Ny5k9kAJITgu+++q84p1mrYpFvNFBcXw9raGh07dkS9evVK9FwMHDgQenp6MDY2RmpqKtLS0pg+iYYNGzLHde3aFRcvXsT8+fNBCPmkOmF1c+XKFbRs2ZKxITp8+DB8fX1haWmpFt/E+/fvQyKRoHfv3sxzQ4cOhYeHR5WvXV5UwmmqhY9Lly5V29gs6oWmaXTo0AESiURnFJivX78Oe3t7KBSKKomLZWZmonnz5iCEQCwWa1wYrjyo+n8nTpxY5uspKSnM31VCQgKePHlSzRGyVBaVPSb7echSXlStYSkpKdoOhUVLzJ49GzweDzdv3qzwuc+ePYNEIvlsS9jChQtBCMHw4cNrdeKtVCrh6upaatdfxY0bN0AIwZYtW+Du7g4ul4vk5GQ4OTkxLkuqh0QigVAoRIMGDeDq6oqHDx+iV69esLa2LnFcYmIilEplNc+09sIm3RpAtVNrbGyMadOmAXgvqiaTyeDm5oaFCxeWElVr164dTp06hWPHjsHCwgLz5s3DvXv3MGHCBHA4HDx8+FCLM3ovCNWtWzdQFAUXFxfs3r0bBQUFaNGiBWQyGa5du1blMYqLixEUFAQHB4cSnsIdO3ZEZGRkla9fHlJTUyGXyxEZGYm8vDy4ubmhVatW1TI2i/pRrYLv2bNH26GU4NWrV2jWrBl4PB5Wr15d4fMfPHgANzc3cLlcSKVSnbDi2rlzJzgcDgYOHPjJGx+aprF9+3aYm5tDKpXi+++/Z0vXagBFRUVwcXFBbGystkNhqSGkp6dXq3Ali26RkpICkUj0ScGvT9G7d2+YmJjg7du3nz12xYoVIISgf//+tTZJ3LdvHwgh+OOPP0q9lpWVBTs7OxgaGiInJwdeXl4ghCA0NBQymQwymQyhoaFMf3d5Hl27dmXdB9QMm3RrAJqmMXToUPD5fAwcOBCZmZlMKbajoyMkEgk6duyIV69ewcrKCj4+PrCwsGD6Jz581K9fH2KxGGPHjtXKXF69eoURI0ZAIBDA3Nwcq1atQmFhIWiaRo8ePcDn83HixAm1jPX111+Dw+Hg7NmzJZ4PDQ1F165d1TLGp8jNzS0lnLZz504QQnD69GmNj8+iXg4cOACKojB9+nRth1ImH6qwDho0qNyaBWfPnoWxsTEEAgEMDAxw+fJlDUf6eY4cOQI+n48uXbqU+4YnIyMDgwcPBkVR8PX1xcWLFzUcJUtV2bJlCwgh7O+Kpdy4u7ujf//+2g6DpZqhaRoxMTGwsbGplI7H5cuXQVFUhRTKVaXXPXv2rLRNra5C0zSaNGlSprVXfn4+wsPDIRAIkJiYiOTkZKxduxYcDgdfffUVXF1dIZVK0bZtWzg5OcHExOSTyTaHw0GbNm1qddWAtmCTbg1B0zT8/Pwgl8vRqlUrxMfHw8TEBE+fPkVgYCDGjx+PDRs2gM/nM+IGfn5++OOPP2Bqaopjx45h48aNkMlkTL9mdZbH5uTkYM6cOZDJZNDX18esWbNKiD9NnjxZrQrrf/31F3g8XpllqS4uLhg9erRaxvkYqkUEsVhcQixIqVTC19cXwcHB7AdQDeL27dvQ19dH27ZtdX7Ve/Xq1eDxeGjWrBlevXr1yWM3b94MPp8PiUQCY2NjnRD5O3v2LMRiMWJjYysldnjhwgX4+PiAoigMGTLko76jLNqnuLgYbm5uiImJ0XYoLDWEPn36wNPTU9thsFQze/bsKaHNUxFomkazZs3g5uZW4e+UrVu3gsvlIjExsVrFdzXNb7/9BkIIDh48WOq1yZMnQyAQwM3NDX369EFcXByUSiUUCgVkMhnTxrZp0yamj/vJkydo3LgxRCIRnJyc0K5dOwwbNgxxcXHg8/lqaRdlKQ2bdGuQa9eugRACqVQKsVgMS0tLbNu2DfPmzYOVlRX09PRACMH8+fOxatUqSCQSNG/evET/cmxsLE6fPg0nJycYGRnh7t27Go25qKgIa9asgaWlJfh8PoYNG4aXL1+WOGblypVqtWrIzc2Fu7s7fH19yyxlkclkGreFUPk3l7WIcOjQIRBCcPjwYY3GwKIe3r59C2dnZzRo0KBEm4Iuc/r0acjlctjb2+P69eulXlcqlYxfvbGxMeRyeZnHVTdXrlyBgYEBwsLCkJubW+nrFBUVYcGCBZBIJLCwsMDOnTvZRS4d5aeffvpoiSMLy3/54YcfQFFUuUqEWWoH7969g42NDVq3bl2pz/G9e/eCEMK0X1aU3bt3g8/no23btsjPz6/UNXSN2NhYNGjQoNQmwpkzZyASiTBixAiEhYWhcePGSE5OBgD4+vrC29sb5ubmuHz5MnJyckrtlOfl5cHf3x9PnjzBwIED2XYQDcMm3RomODgYPj4+MDMzw1dffQXgfX+3nZ0dCCGoV68e8vPzcfjwYVhaWgIAGjVqxJzftWtX3L17F69fv4abmxvq1atXZUuusqBpGnv37oWbmxsIIUhKSipT/GTfvn3gcDgYNmyY2m6Khw0bBqFQiFu3bpV6LTc3V+MfAqdOnWLsjMqCpmkEBwfD19dX53dN6zrFxcWIjo6GoaHhR9VOdZVHjx7B29sbEomkRA96dnY2EhISQAiBubk5FAqFTojC3b17F6ampmjYsCEyMzPVcs3U1FTEx8eDEIKYmBita1mwlKa4uBj169dHy5YttR0KSw3g7t277KJ1HWPcuHEQiUR48OBBhc8tKCiAk5MTWrRoUaV7zIMHD0IoFCI6OrpKC8K6wM2bN8u0XNu4cSPTlnr37l1ERkYyjkJ6enrgcrkwMzODk5MTBAIBLC0tYWhoiMDAQGbH/O3bt6hXrx6cnJxAURQmT56sjSnWGdikW8P89ddf0NPTg1QqxZQpU5CZmYng4GCYmpqid+/e2LRpE0JDQzFs2DBGydzPzw+zZs1CSEgIpFIpPDw8EBMTw6iZqzsBPXv2LOPj17x584+KMv3+++8Qi8Vo37692vpl/ve//4EQgkWLFpX5+sOHD0EIwdGjR9Uy3n9JTU2FQqFAZGTkJ8WcTp8+DUIIdu7cqZE4WNTD+PHjweFwNPZ+0TTZ2dno0KED4z2ampoKX19f6Onpwc7ODmZmZmUuTlU3jx8/ho2NDerXr//ZkvjKsHfvXlhbW0MsFmPu3Lm1qkywNrB9+3YQQvD7779rOxQWHYemaSgUCkyZMkXbobBUAzdu3ACPx8Ps2bMrdf6CBQvA4XDUsrB87NgxiMViRERElGiPrGn07NkT1tbWJSpBf/zxRxBCQFEUgoODUVxcjPDwcKak39/fH/7+/khLS4OPjw8cHBwYBXNra2vweDzo6emBw+GAw+HAwsICbm5uWpxl3YBNuquB//3vfxAIBGjdujWio6Mxbdo0EELg5eWFkJAQdO7cGceOHUNYWBjkcjnTw922bVump1r1vFgshrW1tVqS3lu3bjG7Sr6+vvjf//730WPv3r0LExMThISEqG2nPT09HZaWlmjevPlHd5DPnz8PQoha1NH/S25uLvz9/WFnZ1euxKFly5Zwc3OrdQIdtQVV2WtN95SkaRpfffUVCCEQCoWwsLCAo6MjzM3N8ffff2s7PLx48QKurq6wt7fH06dPNTZOVlYWRo4cCQ6HAw8PD53wIGd5j1KphIeHB6KiorQdCksNID4+HuHh4doOg0XD0DSNkJAQuLq6Vqqs+9WrVzAwMMCAAQPUFtOZM2cglUrRtGlTtVVkVSdPnjwBj8fDwoULmefu3LkDgUAAQgh4PB769OmD5ORkbN26FRKJhPkdhIaGIikpCenp6QDef24fOnQII0eOhEKhwLBhwzB//nycOHECFEXhhx9+0NY06wxs0l1NTJgwARRFwdDQEMbGxpBKpdi8eTMSExNha2sLf39/CAQCWFhYoEePHjAzM0OTJk2wfft23L9/H+3bt8etW7cwePBgcDgcREREVLpX5enTp+jTpw84HA7s7e3x448/frJs+t9//4WDgwPc3d2ZP96qQtM0OnXqBENDw0969aosEl68eKGWcT8cvyzhtE9x6dIlEEKwceNGtcbCUnUuX74MsViMbt261Ype4O3bt4PP54PD4UAgEEChUODOnTvaDgsZGRnw9fWFubk57t+/Xy1jXr58GY0aNQIhBH379lXbZxBL1di1axcIIfjtt9+0HQqLjjNv3jzo6emx1oC1nI0bN4IQguPHj1fq/CFDhkAmk6n9fu+PP/6AgYEBGjVqVOO+P0aNGgVDQ8MS+jSDBw9mlMbNzMxKiKc5OzuDw+GgT58+oGm6hHiaimHDhjF930+fPoWdnR3q169f48vwawJs0l1NZGZmMiXm7u7uGD58OPPayJEjYWBgAGNjYzx79gxFRUUlxNQePnyI9u3bM//+5ZdfIBQKkZSUVKEE4+3bt5g4cSLEYjFMTEywaNGizybuWVlZ8PPzg6WlpVrVDFWlMdu2bfvkcatWrQKHw1H77vKSJUtACMGPP/5YofPatWsHe3t71rtQh3jx4gWzcFXTvzRomsbMmTNBCEFCQgLs7OzA5XJhZGSkddu6nJwcBAcHw8jIqNpF3IqLi7Fs2TLIZDIoFAps2bKlViyu1GSUSiW8vLyYtigWlo9x9uxZEEJw6dIlbYfCoiHS09OhUCiQlJRUqfNv374NLpeLefPmqTmy9/z1118wMTGBt7d3KXFgXeXNmzeQSqUl+qyzsrIglUpBCIGenh4aNGgALpeL5ORkODk5QSqVwtnZGYQQdO7cGRMnToRQKGRyiPXr12PQoEFQKpU4fPgwoxPz6NEjbU2zTsEm3dXIqFGjGDGDCRMmAHgvnqRQKKBQKODn51dKVA14L6LQpEkTrFmzBmvWrMHevXvxww8/gBCCQ4cOfXbc/Px8LFiwAMbGxhCLxZg8eXK5bHkKCwvRsmVL6Ovrq9WaKDU1FQYGBujSpctnj505cybMzc3VNjYA/Prrr+ByuRg1alSFz7116xYoisLy5cvVGhNL5SgsLERoaChMTU3x+PFjbYdTJXJzc5GUlARCCMaOHQsXFxdYW1vjwoULCA8PB4/Hw6pVq7QSW0FBAVq1agWJRILz589rJQYAePbsGTp16sToT/zzzz9ai4Xl/2yBtL0gxKLb5OXlQSAQYPHixdoOhUVD9O/fHzKZDM+fP6/U+TExMXBwcNCo2viNGzdgZmaG+vXrVzrO6uTrr7+GUChEWloa85xqUZ4Qgj59+sDb2xuEEISEhEAmk0Emk2HgwIFITk5mLIctLCwQEBCA+fPno1GjRpg7dy6cnJyYVlZNuyKx/B9s0l2NFBQUICIiAgKBAH379kVmZiaaNGkCgUCAgQMHol69epDJZHBxcUGzZs0wduxYmJubg8vlMoIJH5rXy2QyNGvW7KPjKZVKbN68mdkt69evH549e1auWGmaRs+ePcHn8ytdKvSxmMLDw2FtbY03b9589viBAwfC29tbbeM/fvwYCoUCERERlS516969O8zNzZGTk6O2uFgqx+DBg8Hn82t8ieu///6LwMBAiMVirFy5Ek5OTrCxsWFKuAsLC5mSsoEDB1arsFhxcTE6deoEgUCg1s+CqnDo0CHY29tDKBRi5syZtcYWpqZB0zR8fX0/+T3EwgIAQUFB6NSpk7bDYNEA58+fB0VRWLJkSaXOP3r0aLUJ1d65cwdWVlZwdnbW6YX6vLw8mJqaluhvv3//PsRiMZMHjB07FuvXrweHw8G0adPg6uoKqVSKtm3bwtvbG0FBQXB3d2cSbNWDoihYWFjAyMgIgwYN0uIs6x5s0l3N5OTkwMHBAUZGRmjZsiUGDBgAPp+P69evM6WxXbp0YVavFAoFOnToABsbGyiVSty7dw8PHz7E6NGjwePxQAjBjBkzSoxB0zQOHz7MXCMhIaHCAkxTpkwBIQRbtmxR29wBYOHChSCE4MSJE+U6vl27dmqzpsnNzUXDhg3LLZz2MVJSUsDj8TRWBsVSPtauXQtCCFavXq3tUKrE1atXYWNjAwsLCxw4cAD16tWDra1tmZZ9q1evBo/HQ7NmzTSiGv5faJrGl19+CS6Xi71792p8vIqQk5ODCRMmgMfjwdXVFadOndJ2SHWS/fv3gxCCkydPajsUFh1mzJgxsLa21nYYLGqmuLgYvr6+8PX1rVQbYFFRERo0aICQkJBqaxlKSUmBvb097O3tK2VrVh2oWis/tD4NCgqCgYEBkzyHhIRAqVRCoVDAwMAAZ8+eBYBSfdwPHjxAXFwc7t27h9TUVOTm5mLixIkghODmzZvVPre6DJt0a4EbN26AEAKpVAoTExMYGRlh27ZtSExMRHh4OCwtLUEIgbe3N5KTkxEUFAQul4vIyEhG8CwnJweNGjXCqFGjQAjBggULAAB//vknIiIiQAhBcHBwpSxdVq1aBUKI2pPKGzduQCgUYuTIkeU+JygoCD179qzy2Kqde5FIhMuXL1f5egMHDoSxsXG5yvRZ1M+5c+fA5/PVqnKqDfbv3w+JRAJfX1+cP38ejo6OsLOz+6Q/9ZkzZ6BQKGBvb68RVX8VNE1jzJgxZfqD6hI3btxA06ZNQQhBjx49aky/Xm2Bpmn4+/tX600zS81j7969IISoVRuGRfssWbIEFEXhwoULlTp/5cqVIITgzz//VHNkn+bx48dwcnKClZWVzpVXFxcXw8nJCR07dmSe+/PPP0EIQbt27Zike/z48Uwft0QigbGxMa5du4bLly9DJpOhSZMmOH78eAldqA/dUebPn6+tKdZZ2KRbSzRr1gxeXl4ICgpCt27dmOd37NgBQgiGDBmCxo0bl9njDQBDhw7Fhg0bAIBZsWrWrBkIIahfvz5+/vnnSt0A7d+/HxwOB0OHDlXrDVR+fj68vb3RoEGDClmOOTo6Yty4cVUef+nSpWrduX/27BlEIhGmTZumluuxlJ8nT57AzMwMISEhNVbQjqZpfPvtt6AoCu3atcOtW7dgb28PBweHcgmaPHr0CD4+PpBIJNi9e7dGYvz6669BCKl0yWB1olQqsXbtWhgZGcHY2Bjr169nE8Bq5MCBA1VSLWap/bx48QKEEGzdulXbobCoiefPn0Mmk1V68TsjIwMKhQI9evRQc2Tl4/nz53B3d4eZmZlafMHVxc6dO0ssRLx58waWlpawsLDAsmXLmKTbxsaG6ePu2bMnvL29IRaLYWZmhsjISGRmZiIoKAgPHz5EQkICfvzxR8YJxNTUlP2O1AJs0q0lLl++DIlEArlczqxmZWZmwsTEBM7OzlAqldi0aRNCQ0MxbNgwRERE4MmTJ5g2bRpMTEyYPzqJRILWrVvDxsYGIpEI69evr3Sv8h9//AGxWIx27dqpXS18/Pjx4PP55bbnUiGRSEr4E1aG06dPg8fjVWiHvTyMGTMGUqmU3VmrRvLy8tCoUSPY2Nio3VakuigoKMAXX3wBQggmTZqE+/fvw87ODo6OjhXaBcrOzkbHjh2ZFpNP2f5VlOXLl4MQgq+++kpt16wOXrx4ge7duzOld7du3dJ2SHUCmqbRqFEjNG3alL2RY/kozs7OGDx4sLbDYFETSUlJUCgU5dLnKYuxY8dCLBbj6dOnao6s/Lx48QLe3t4wMTFRSxVkVVF9lqpcId68eQNPT0/w+XxMmTIFq1atAp/PByEEMpkMzs7OTB+3h4cHbG1tGf2n+vXrQyqVQiqVMs+p/svucmsHNunWIv/73//A4/FQr149FBYWIjw8HBRFYdy4cWjcuDFCQkLQuXNn/Pzzz0zJOYfDgZWVFZYtW4aEhATY29szwgo8Hq/CFlgq7t69CxMTEzRt2lTttkunT58GRVGYO3duhc579+5dpWy9PkQlnBYeHq52j9BXr15BX18fo0ePVut1WcqGpml0794dIpGoxlrPvHr1CiEhIRAIBEhOTkZKSgpsbW1Rr169Som60DSNWbNmgRCC9u3b4927d1WOccuWLSCEYOTIkTU2gTp+/DicnZ3B5/MxadKkGm8lVxM4dOgQCCE4evSotkNh0VF69eoFHx8fbYfBogaOHz9epdajlJQUCAQCTJ8+Xb2BVYL09HQ0atQIhoaGWnXnAICTJ0+CEIIjR46Apmk0b94cRkZGIIRgzZo1iIuLQ+/evZmNN9Ui1od93A0bNsTOnTsxcOBA2NnZoW3btujbty/09PRACIFIJMLr16+1Oc06C5t0a5k1a9aAEIIJEyZAT08PHA4HAQEB2Lx5MxITE2FtbQ2pVAoOh4PFixfDwsICcrkcYWFhaNGiBYD3ysb29vZo1qwZuFwutm/fXqEY0tLS4ODgADc3N6Snp6t1fpmZmbCzs0NISEiFd8/v379fIdG1/5KXl4eGDRvC1tZWY7vR06dPh1AoxJMnTzRyfZb/QyXCV5VFGG1y69YtODo6QqFQ4Ny5c7h//z6sra3h7Oxc5ZX+vXv3QiqVwsvL65P94J/j559/BpfLRe/evWtswq0iLy8P06dPh0AggKOjI44cOaLtkGo1NE0jMDAQjRs3rvHvHRbNsGbNGnA4HGRlZWk7FJYqkJ+fDxcXlyrpOHTo0AGWlpbIzs5Wc3SVIyMjA0FBQdDX18eZM2e0FkerVq3g7e0NmqZx7tw5EEIYa8YvvvgCycnJuHbtWgk18mnTpiE7OxshISEAgMDAQOZ6sbGx+PXXX5mNO0II+vXrp63p1XnYpFvL0DSN+vXrIyEhAcOGDUP9+vWZ15RKJRwdHSESiRirjaKiInh4eJS4RnZ2NmJjY1FYWIikpCQIBIJyWyi9e/cO/v7+sLCwKFcvaUXp2bMn9PX1K5UInD17FoSQSpWI0jSNXr16QSQS4a+//qrw+eUlMzMTxsbG6N+/v8bGYAGOHTsGDoeDsWPHajuUSnHkyBHIZDJ4eHjg4cOH+Oeff2BlZQUXF5dy2/h9jhs3bsDBwQFyuRy//vprhc8/efIkhEIh2rdvr/b2Em1y584dhIeHgxCCzp07499//9V2SLWWI0eOgBCCw4cPazsUFh3k1q1bIITg2LFj2g6FpQrMnj0bPB6v0srXZ86c0UmBznfv3iE8PBx6enpa0ae4evUqs7FQUFCABg0awM7ODkqlElKpFDweD1FRUWjZsiWEQmGJxFuhUEAqlaJx48YIDg7GP//8g0OHDsHExIRxOiKEwN/fXy0VcSyVg026dYCNGzcyPYgfll5t2LABhBD89NNPZYqqvX79GiEhIRCLxWjQoAF69uyJr7/+Gr6+vggODv7suIWFhWjVqhX09fUr3GtdHnbt2gVCCCP4VtnzK1MGoxKbSE5OrtTYFWH+/Png8XiMpzKLerl//z5jsVcTk8GlS5eCw+GgdevWyMzMxJ07d2BpaQk3Nzc8f/5crWO9fv0a4eHh4PF4WLlyZbnPu3jxIqRSKVq0aFErPa9pmsbmzZshl8thYGCAFStWqLUHnuU9NE0jKCgIAQEB7G43SymUSiWMjIxK2Zyy1BxSUlIgEokqLXCrVCrh7++Phg0b6uRncG5uLlq1agWhUIhffvmlWsfu2rUr7OzskJGRgdDQUHA4HMyfPx/FxcWwt7cHn89HYWEhADAOJh8m3h/6cJf1fEBAAKtBpGXYpFsHoGkaw4YNAyEEZmZmoGma2UF1cHBA48aN4eLiAoVCgcGDB8PW1hampqbgcDjg8/kICAiATCaDv78/KIoCh8MBIQS7du365JhffPEFeDyeRladnz9/DhMTEyQkJFT65mv58uXg8/kV/mBWCaeNGDGiUuNWlNzcXFhYWJRQoWdRD+/evYOHhwecnJwqLdaiLQoLCzFo0CCmP7q4uBh///03LCwsUL9+fY3tuBYWFmLIkCEghGDgwIHMl/THuHnzJoyNjREUFKQzpX6aIj09HV9++SUIIQgMDMTVq1e1HVKt49ixYyCE4ODBg9oOhUUHad26NaKiorQdBksloGkaMTExsLGxqfRu6aZNm0AI0WoJ9+fIz89HfHw8+Hw+9uzZUy1jPnz4EFwuF4sWLUJsbCyj1XT+/HkkJyfjm2++Ye7rHzx4gMGDB6Nnz55YvXo1QkJCykyyP3y0a9cOOTk51TIXlo/DJt06Ak3T6Nq1K1N6pbL/+u677xgRoAkTJqBbt26MmFq/fv3Qq1cv0DSNkJAQrF69GhEREUhISICtrS0EAgEOHTpU5nhTp07V2E4wTdOIjo6GmZkZXr16VenrTJ06FVZWVhU65/HjxzA1NUWzZs3ULpz2KVasWAGKoipdbsVSGqVSiYSEBEil0hqnQv327Vs0b94cPB4Pa9asAQDcvn0bZmZmaNCgAdLS0jQew5o1a8Dn8xEWFvbR1e2UlBRYWFjA29sbb9++1XhMusKZM2dQv359cLlcjB49mi23UyM0TSM4OBgNGzZkd7tZSvH1119DX1+/RlYt1XVUXut79+6t1PnZ2dmwtLREhw4d1BuYBigsLESnTp3A5XKrxeZu2LBhMDExYSpfFyxYAEIIrly5gri4OKbE3N7eHj169MDDhw/Rs2dPxurM19cXPXv2RMOGDcHhcNCgQQPExMQwXuSfW3xnqR7YpFuHoGkajo6OaNiwIfT19UEIQZMmTbBt2zYkJibCwsICHA4HlpaWyMjIQN++fSGRSNCkSRMsXboU8fHxWL9+PZYuXYrs7Gy0bt0aQqGwVH/36tWrQQipsJp4eVmxYgUIIVUuzenXrx/8/f3LfbzKTkqTwmkfo6CgAA4ODkhISKjWcWszM2fOBCEE+/fv13YoFeLevXtwdXWFkZERTp48CeD9brKpqSk8PT2r1erst99+g0KhgJ2dHa5du1bitefPn8PR0RHOzs7VsgigaxQUFGDOnDkQiUSwtbXFzz//rO2Qag0nTpwAIYT9mbKU4tdffwUhhK0yqWG8e/cONjY2aN26daUX01TClikpKWqOTjMUFxejR48eoCiq0m2S5eH169fQ09PD1KlT4e7ujuDgYEb/QCwWM5tjrq6uIIRAX18fqampaNWqFTw8PNCkSRP06tULERERaN++PYKDg/HkyRM0a9YMYrEYFy9e1FjsLBWDTbp1jKVLl4LL5WLy5MkghDC73A8ePIBIJIK3tzcCAgJK9Xdv2rQJ69atw6hRo9CzZ09s374dx44dQ2hoaIlVrgMHDoDD4WDw4MEa2YW4e/cuxGIxBg4cWOVrtWnTBq1bty7XsapyeU0Lp30KVdkU+wFXdfbt21cjfaJPnToFY2NjuLi44J9//gHwXuBMoVDAy8urSpUflSU1NRU+Pj6QSCTYvXs3gPdf8g0aNIC1tbVGBBRrEikpKWjVqhUIIUhISGCdCNQATdMICwuDr68vu9vNUoKcnBzweDwsX75c26GwVIBx48ZBJBLhwYMHlTr/6dOnEIvFle4F1xZKpRL9+vUDIQQrVqzQyBgzZ86ESCRC06ZNQQjB9u3bkZ2dDT6fDz09PUY8TSAQQCwWQyAQgMvlgsvlwt3dHXl5eYiIiMCzZ89w+fJluLm5wcTEBEKhsFKiqiyag026dYz8/Hw0a9YMEokEhBC8evUKmZmZ8PT0ZMzuP+zvdnJygo+PD0QiEePB9+FDtWO+bt06nD9/HmKxGAkJCRop7SosLESjRo3g7Oyslt7QgIAA9O7du1zHqoTTNm/eXOVxK0txcTHc3d0ZKzeWynHz5k1IpVK0a9dOJ4VWPsa6devA4/EQGRnJ9J9fu3YNcrkcPj4+WvXFzM7ORseOHRl7wkaNGkEul+Pvv//WWky6BE3T2L59O8zNzSGVSvH9999Xa3tKbUS1o1nZUlSW2ktAQAC6dOmi7TBYysmNGzfA4/Ewe/bsSl+jR48eUCgUyMjIUGNk1cOHuksLFy5U67VzcnJgYmLCtITy+XwUFBQgOTkZMTEx4HK5yM3NxYMHD6BQKNCzZ0+cOXMG06ZNY1TJbW1twefzGUVzVS6wdu1atcbKUnXYpFsHefv2LXx9fZkVr+joaAQHB8PV1ZURQpgwYQImTpwIIyMjEELA5XIhk8ng7OwMmUyG9evX48KFC+jTpw+EQiH4fD5kMhmaNm3K7J6rm+nTp4PL5eLChQtquZ6dnR0mTZr02ePOnDkDHo+H4cOHq2XcqrB7924QQnDq1Clth1IjefPmDZycnODh4VFj+myLi4sxatSoUsJlV65cgYmJCXx9fZGenq7lKN/fOMyYMQOEEPB4vHLbCtYl3r59i0GDBoGiKPj5+eHPP//Udkg1mvDwcHh7e9eoxTMWzTNy5EjY2dlpOwyWcqDSDHJ1da20s8Wff/4JQkiFHDV0DZqmMWHCBBBC8PXXX6vtusuWLQNFUeDz+ejduzcUCgWKi4sRFxeHu3fvMv3d/fv3L9XHfe7cORgbG8PQ0BB+fn4YP3481q5di5iYGNjZ2bG6CToIm3TrKHl5ebCxsYGbmxuMjY1BURQcHR2Z/m57e3uYm5uDEIIpU6YgJycHHh4e2LBhAwIDA9G4cWM0b94cV69eRXp6OmJjY0FRFH788UeNxHv+/HlwuVy1WYHQNA2hUIjFixd/8rgnT54wwmm6IBRB0zT8/f0RFBTEllVWkOLiYrRo0QLGxsY1pucrKysLsbGx4HA4WLJkCfM7v3z5MoyNjeHv768zqutFRUWMIqtYLIaXlxcePnyo7bB0kvPnz8Pb2xscDgdDhw5FZmamtkOqkaj8eFVtDSwsALBz504QQvD06VNth8LyGVTCXpX1rVYJKzZo0KDGVw/RNM1ozUydOrXK93hFRUWwtbWFSCTCsGHDMH/+fMhkMmzcuJHp4zY1NQVFUYzi/4dJd1BQEO7fvw+lUon4+HjcuHEDI0eOBEVR7GeujsIm3TrMjz/+CEIIfvvtN2bXGwAePXoEFxcXpqykLP9u4L1asr+/P168eIGcnBy0bdsWenp6ak9osrOz4ezsjICAALUlvhkZGSXmXBZ5eXkICAiAjY1NtYpTfY4jR46oRUiurjF27FhwOByNWNhpgkePHsHT0xMymQyHDx9mnr906RKMjIzQqFEjnVEEVyqV6N69O3g8Hg4dOoQbN27A0dERcrmc7fn6CEVFRViwYAEkEgksLS2xc+dOdiGtEjRv3hweHh7sbjcLw/Pnz0EIwY4dO7QdCssnSE9Ph0KhQFJSUqWvoVpgOXr0qBoj0y7z5s0DIQRjxoyp0nfC+vXrGU/tO3fuYOjQoSCEoF+/foiKikJoaGiJNlGpVMpUrQqFQgQGBjJVdLGxsQgODgYhBMuWLVPXVFnUDJt06zD5+fnw9PSEtbU1CCHYunUrMjMzERISAi8vL0RERGDjxo0IDQ3FsGHDEBERAQC4f/8+xowZAxMTkxL93X5+fpBIJBg6dKha4xwwYAD09PRw9+5dtV3zzp07IITg9OnTZb5O0zR69+4NkUiES5cuqW1cdaAqx/Lx8WFvNMvJli1bQAjB999/r+1QysW5c+dgamoKBweHEnZmf/75JwwNDREYGKgzCTdN0xgyZAgoisK2bduY51+/fo2IiAjweDyNCcTUBlJTUxEfHw9CCGJiYtjqgApy7tw5NsFiKYWDg4NOtISxfJz+/ftDJpPh+fPnlTo/Ly8PDg4OiImJUXNk2mfJkiUghGDw4MGVus97+/Ytk0SHhISguLgYbdq0AZfLxdixYwEAgwYNgr6+Pq5du4bp06dDKpUyrkb16tXDkCFDYG1tzTzP5XIxf/58dU+VRY2wSbeO8/jxY9jY2IDL5WLatGmIjo7GypUrQQjBvHnz0LhxY4SEhCAiIgITJ06Ej48P07PZvXt32NvbY+fOnQgLC4OxsTHzmroEFn755ReN9OqoRHju3LlT5uvLly/XunDap1CVVX5qp57lPZcuXYJIJELPnj1rxE7ili1bIBAIEBwcXMKa7sKFCzAwMEDjxo11Sixm6tSpIIQwfuEfUlhYyKyuDxgwAAUFBVqIsGawd+9eWFtbQywWY968eTrRzlJTaNGiBRo0aMAuQrIwdOvWDQ0bNtR2GCwf4fz586AoCkuWLKn0NebNmwcul4vbt2+rMTLdYc2aNaAoCn369Klw/3SjRo0glUrh6emJL7/8EsnJydi6dSvMzMxgbGyMmzdvYvDgwSXKybOysrBixQpYWVlBJBKBy+XC2NgYLVu2hKenJxo3bqyJabKoETbprgE8e/YMCoUChoaGMDY2hpWVFQQCAZYtW4b27dsjPDwc9evXh729PbhcLjw9PeHh4QEzMzOcOHEC8+fPx759+wC83wXv0qULI85QFV6+fAkzMzNER0erPVnavn07CCFlJi+//fYbeDwehg0bptYx1U10dDRcXV1rfB+TJklLS4O1tTUaNWqEvLw8bYfzSZRKJWPl17NnzxKiMn/88QdkMhmCgoJ0qv93wYIFIITg22+//eRxa9euBZ/PR2hoaLV73NcksrKyMHLkSHA4HHh6euLcuXPaDqlG8Mcff4AQUqLSgqVus2LFCnC5XLU4nbCol+LiYvj6+sLX17fSYlwvXryATCbDkCFD1BydbrF582ZwOBx07dq1XPd6b9++Rf/+/UEIwc6dO+Hv74++ffsiLi4OSqUSHh4e0NPTg729Pe7du1ci6VbRuHHjEi2V33zzDQgh2LNnj9rnx6Je2KS7hnDx4kUQQrB//34kJCSgVatWzGs0TcPJyQlCoRCJiYkA3vcjenh4AAAiIyMxZswYhIWFYdWqVaBpGuPHjwchBLt27apUPDRNo23btjAxMal06dGnWLx4MYRCYalk/smTJzAzM0NYWJjO7zT99ddfIITghx9+0HYoOklBQQGCg4Nhbm6u84I6OTk56NChAyiKwrx580q8L3///Xfo6+sjODgYWVlZWoyyJOvWrQMhpFwOAMD7xSxTU1PY2dnh6tWrGo6uZnP58mU0atSI6b/TFbE8XSY6Ohpubm6soi4LgPd2iqzTh26yZMkSUBRVJSeaAQMGwMDAAK9evVJjZLrJjh07wOPx0L59+09Wi927dw9OTk4ghMDKygrFxcXw8PAAl8tlhNM8PT3B5XJBCEFcXBw6deqEDh06IDw8HG3atMHDhw+ZVtL8/HxMmjSJEXZj0X3YpLsGERQUBHt7e0RGRiI+Pp55/qeffmJKrRs3blxKWM3BwQFt27ZFQEAAxGIx3NzcEBMTAz8/Pzg5OVWq5G/Dhg0aVaWdNGlSKUuR/Px8nRRO+xQdOnRgxO5YSjJgwADw+Xyd3y18+vQp/P39oaenV8pz+OzZs5BKpQgJCdEpi7OdO3eCw+Fg0KBBFapCSU1Nha+vL/T09Cq9IFdXKC4uxrJly6Cvrw9TU1Ns2bKlRrRHaIsLFy6AEKIxBw2WmkVxcTFkMlmVvJ9Z1M/z588hk8kwYMCASl/jxo0b4HA4Va6mrEns378fAoEAsbGxZVbtPXr0iHEc4nA4mDNnDoqLi+Hl5QVCCEJDQ9GyZUsIBAJIJBLUq1ePSb4NDAxw6tQpvHnzBrNmzcK0adMwYcIERrdp5syZ7HdPDYFNumsQqampsLCwgEwmQ5MmTQAAmZmZkMvlsLS0ROPGjeHi4gKFQoHBgwfDzs6O8fGWSCTo3r07FAoFTExMYGBgwAgv9OnTp0KJ94MHD6Cvr49evXppaqro3bs3AgMDmX/TNM14jtck79zbt2+Dw+Fg6dKl2g5Fp1i1ahUIIVi3bp22Q/kkly5dgqWlJaytrXHlypUSr505cwYSiQRhYWE6lXAfOXIEfD4fXbp0qdSCWk5ODjp16gRCCKZPn8724X6GZ8+eoWPHjiCEoHnz5vjnn3+0HZLO0rp1a7i6urK73SwAgJYtWyI6OlrbYbB8QFJSEhQKRaWrd2iaRosWLeDk5FTnNEKOHDkCkUiEqKgo5OTkMM8XFxfD29u7hLDxmTNnkJycjLVr14LD4WDmzJl48OABFAoFU1L+4sUL6OvrQyKRlDhXlYjr6ekx1a0sNQM26a5h3L17F3K5HBRF4d69e4iIiACHw8GsWbOQm5sLAJgwYQK++OILcDgcODg4oFGjRswXW3R0NFJSUvDw4UMEBARg4MCBoCgKnTp1Kle5dnFxMYKDg2Fvb6/R3tWYmBi0adOG+feKFStACMGmTZs0Nqam6NmzJ8zMzNjetf+Pqid/8ODB2g7lk+zcuRNisRgBAQH4999/S7z266+/QiKRIDw8XKd+r2fPnoVYLEZcXFyV2i9omsbXX38NQgjatWunU4sKusqhQ4dgb28PoVCIr776iq1uKYM///wThBCmlJKlbvPVV1/B0NCQXdjTEY4fP17l+yyVuO5/q8LqCidPnoREIkFoaCjTbnbgwAEmWbaxsQEhBBcuXGD6uOVyOQwNDZGYmIiHDx+W6ON2cXHBtm3bcOrUKbi7u2PZsmU4evQoJkyYAEIIrl+/rs3pslQQNumugTx58gR6enqIjY2FTCYDIQSNGjXCtm3bkJiYCCsrK3C5XJiamuL169d4+vQppFIpgoKCMH36dADAt99+y9gE7dmzBzweD3369Plsico333wDiqJw5swZjc7R398f/fr1A/B/SZq6rc6qiwcPHoDP5+Obb77Rdiha5/HjxzA1NdXpnnyapjF79mwQQtC5c2dmMUvFqVOnoKenh8jIyBKr2drmypUrMDAwQLNmzUrFXFn2798PqVQKLy8v1iqrHOTk5GDChAng8XhwdXVl+1XLoE2bNnBycmIFJlmYJO/mzZvaDqXOk5+fDxcXF4SEhFS6VLmwsBBubm5o1qxZnS53PnfuHGQyGRo3boy3b9+icePGTNL95ZdfghCCcePGITk5GY8ePQJFUYz1l0orqWHDhvj2228REBCA169fA3i/oXbs2DHMnTsXhBDMmTNHyzNlqShs0l1DGT58OIyMjLB27VoQQhgxs0ePHsHY2Bg2NjZo2LBhqf5u1THW1tZITExEYmIi+vXrh969e4MQgt9+++2jY16+fBl8Ph/jx4/X+PysrKwwbdo0PH36FGZmZggNDdXZJK08DB48GEZGRjrj3awNcnNz4efnB1tbW51VyM7Ly0PXrl1BCMGMGTNK3TgcP34cYrEYUVFRakts1cHdu3ehUCjQsGFDtYu53bx5E46OjpDL5fj111/Veu3ayo0bNxAUFMQo3dcFMaHycvnyZRBCsHHjRm2HwqJl3r17By6Xi9WrV2s7lDrP7NmzwePxqrQAsnTpUlAUVaoVqy7y559/wsjICFZWVkzCbWtrizZt2oDH48HPzw9RUVGMJbCDgwP09PRAURTEYjH8/PyQl5eHkSNH4vjx4ygsLISvry8aNmzICKfV5YWNmgqbdNdQXr16BWdnZ1haWoIQgrt37yIzMxMBAQGgKAoODg4l+rudnJzg6ekJhULB9HI3aNAAMpkMenp6IIRAIBDA3d29zBvEvLw81K9fH97e3hovm1QqleDz+Vi8eDECAwNhbW1dY4TTPsbz588hFosxZcoUbYeiFWiaRteuXSEWi3X2CzktLQ1NmjSBSCQq09ro2LFjEIlEaNmypU4l3KmpqbCxsUH9+vU1lty9fv0aERER4PF4TIUMy6dRKpVYs2YNjIyMYGxsjPXr17M3Sf+ftm3bol69euxuNwv8/PzQo0cPbYdRp0lJSYFIJMK4ceMqfY03b97AxMQEvXv3VmNkNZtFixaV6MNu3bo1tm7dCnNzc8hkMty4cQODBw+GiYkJbty4gYyMDHh6eoKiKBBC4OrqivDwcBgbG4PP5zP37lX5PbFoFzbprsGkpKTA1tYWFEVhyZIliI6ORrdu3aCnp4e0tDQA78tRJk2aBLlcDg6HAycnJzg6OmLRokWIi4vDnTt3ALz3/evXrx+kUins7e1LiQGNGDECQqGwlF+gJnj9+jUIIYiMjKxxwmmfYty4cZBIJDV+AaEyzJ8/X6d9eq9fvw5bW1uYm5uXaZNy9OhRiEQiREdH65Sf+IsXL+Di4gJ7e3uN264VFRVh2LBhIIRgwIABdU4kp7K8ePEC3bp1YxRqb9++re2QtM7Vq1dZO0UWAMDQoUNRr149bYdRZ6FpGjExMbCxsamSdseoUaMgkUg0YiFbE8nNzYWxsTGzM00IQf369aFUKpnEulGjRqV6uF+/fo38/Hx8++23kMvlSEhIQOfOnTF69Gg0b94clpaWNbrqs67DJt01nBcvXsDOzg7m5uYwNjaGgYEBFAoF099tb28PBwcHEEIwaNAg5OfnQywW4+XLlxg/fjzOnz+PoqIihIWF4e3bt3j48CFcXFxga2vLfHiq+q4WLlxYLXO6efMm8yG1YcOGahmzOnj9+jVkMhlGjhyp7VCqlSNHjoDD4WDChAnaDqVMDhw4AKlUCh8fHzx+/LjU64cPH4ZQKETr1q11Shzr7du38PHxgbm5Oe7fv19t465btw58Ph+hoaE62yagixw/fhzOzs7g8/mYPHmyTlVLaIP27dvDwcGBvYGs46gsT1UbBSzVy969e6ssfPbPP/+Az+dj1qxZ6gusBlNcXIw+ffqAEILVq1cz97Pt2rUD8N6Lm8PhMBaKPXv2xLVr1+Du7l7C6SYwMBDFxcWgaRrjxo0DIQQ//fSTtqbFogbYpLsWoEqKf/nlF3h5eTGq0I8ePYK/vz8EAgHkcjny8vJK9HdfuHABVlZWsLW1RYsWLTBz5kzMnj0b8+fPh5mZGRISEvDmzRtYW1sjIiKi2hRGFy9eDEIIunfvXi3jVSczZ86EUCjEkydPtB1KtXDv3j0YGhoiOjpa52yCaJrGggULQFEU2rZtW+Yq/y+//AKBQIC4uDidSrhzcnIQHBwMIyOjaqk++S9nz56Fqakp7OzscPXq1Wofv6aSl5eHadOmQSAQoF69ejh69Ki2Q9Ia169fByEEa9eu1XYoLFrk8ePHIIRgz5492g6lzvHu3TvY2NigdevWVWp9adu2LWxsbOr8QiLwfoc7ISEBXC4XLVq0wF9//VXC5utDL25jY2PG0tfBwQHNmzfHt99+C+D9hpqvry/++usvJCQkMDozLDUbNumuBdA0jaioKBgaGsLDwwN9+vRBZmYmQkJCMHLkSAiFQjg4OEAmk8HFxQXNmjXD/PnzIRaLGR9viqIgk8nA4/GYvhGKohAaGgoDA4MydwA1wbNnzxgP8cr6ROoyWVlZkMvljDJ7bSYrKwv169eHi4uLzgnIFRQUMCqi48ePL3NB6cCBAxAIBIiPj9epUuqCggK0atUKEokE58+f11ocqamp8PX1hZ6eHnbt2qW1OGoid+7cQbNmzRiF/P9a0tUVOnbsiP/H3ntHV1G979v79JPee4VUEpIQQnqlhhYQ6U3pvTcr8KGKNJEmIgoYDTZEQEABURApAiJFQKWXgLRQE0KSc71/8Mu85qsgkJOcJMy11lmulczsuedIZvaz9/Pcj4+PT4X6+5Ipf7y8vBg5cqSpZTxzjBkzBr1ez8mTJ596jC1btkg7ts86hYWFZGRkYGZmhhCCjz76iA8//BBPT08p8P7666+lXtwHDx5kypQpUr12eHg4rq6uVK9eHS8vL4KDgxFCoFarqVmzpqlvT8YIyEF3FeHGjRvUrl0bjUZDrVq1aNKkCd9++y3e3t60b99eWoHs1KkTrVq1kgzY/P39SUtLo3PnztSsWZOcnBxOnz4t/dELIejSpUu53MO9e/eIi4vDxsYGc3PzcrmmKZg1axYqlYo///zT1FLKjKKiIlq2bIm1tTVHjx41tZwSXL16lbS0NDQazUMdlFevXo1Go6FVq1YVKiAoLCykbdu2aLVaNm/ebGo53L17l3bt2iGEYPz48XK/3SfAYDCwfPlyHB0dsbGxYeHChc/c93f48GEUCoXsXv2M06FDB+Li4kwt45ni0KFDqNVqJk+e/NRjFBYWUqtWLWJjY2WTSGD27NmoVCqWLFmCEIKNGzeSkZHB/PnzSziYHz9+vEQd9+LFi+nZsyfVqlXDzMwMtVqNg4ODtCkmhGDlypUmvjsZYyAH3VWIW7duER8fjxACa2troqKipMlw+/btqVu3LhEREURGRqJQKBg+fDjR0dGYm5vTs2dP6tSpI40VHx/PoUOHGDZsGEII3nrrrTLX37t3b3Q6HV27dq3Sxiq5ubm4u7vTqVMnU0spM8aPH49CoWDt2rWmllKCo0eP4ufnh6Oj40Pb461atQqNRkObNm0qVL2pwWCgV69eqFSqUtXfGRuDwcCUKVMQQtCqVatSmfE8i1y9elWq/4uLi+PAgQOmllSudOjQAS8vrwpVviFTvsybNw+NRiOnJ5cTBoOB5ORkgoKCSvV39/777yOEYMeOHUZUVzk5d+4c9vb2dOnShdOnTyOEYNSoUWRmZnLr1i1UKpUUQHfr1o2uXbty6NAhCgsLadasGYWFhSxdupR58+Zx9+5dWrRoIR3v4+Mjd3qoIshBdxWjsLAQT09POnfuzLfffosQglOnTgEParz9/PykHe7/28M7OjqaESNGlOgrKISQWoqVZc3VokWLJOO0F154gYSEhDK7VkVg0aJFKBQKDh48aGopRmflypUIIZgyZYqppZRg48aN2NjYEBISwokTJ/71mC+++AK1Wk27du0qXMA9atQohBAsX77c1HL+ldWrV2NpaUlYWFip0hWfVbZt20ZISAgqlYpRo0Zx584dU0sqF44cOYJCoZBb0T3DFNe9PmwhVMa4LFu2DCFEqbKlbt26haurKx06dDCissrJli1bpHnyzp07Wbp0KUII6tWrR8OGDUlJSSkxpy7+6HQ6Xn31VaKiokhPT6dGjRo4Ozvj5uYmHWNmZvavHVVkKidy0F0FKU5lGT16NEIITpw4IdV4BwYG0qJFC5YvX05KSgpDhgwhNTWV7t27l1iJe9inRYsWRm95tX37djQajWQAl56eLrk8VlXu379P9erVadmypamlGJWDBw9iYWFB27ZtK1S62YIFC1CpVDRu3JgbN2786zGfffYZKpWKDh06VLhV5eKd5Llz55payiM5fPgw1atXx8HBge+//97Uciod+fn5TJkyBb1ej7e3N2vWrDG1pHKhU6dOeHp6yrvdzygFBQVYWFgwbdo0U0up8ly7dg0nJyc6duxYqnFef/11dDodp0+fNpKyysnWrVvRarW4u7sTEhJCQUEBrVq1wtbWlho1amAwGBgwYABWVlbMmjULrVZbYk6tUCjw9vbG29v7H3NwKysrNm3aZOpblDEictBdBSlOQy3+w12/fj1NmjRhzpw5Uq/k+Ph4UlJSCAsLw9XV9R/BtYODA/Xr18fW1haFQlHid35+ftLueWm5cOECrq6uJCcnSzuLERERDBgwwCjjV2QyMzMRQpjUDMuYXLt2jerVqxMeHl5hdukKCgoYNGgQQgiGDh360GD6k08+QaVS0alTpwoXcBcvok2cONHUUh6Lq1evUq9ePdRqtbx7+ZQcP36c9PR0KWW/qnc7OHbsGEqlkvnz55taioyJqF+/PhkZGaaWUeXp27cv1tbWpeqnfebMGfR6Pa+88ooRlVU+Tp48iYWFBampqTRt2pTmzZuTmZlJVlYWgYGBksHcwIEDpRrunTt3PnTn+++f5ORkk3QmkSlb5KC7ilJUVMTw4cNRq9XUqVMHe3t73N3d0el0fPTRR7Rr147U1FSsrKykP3KNRoOHhwf29vacOHGCYcOGsWnTJrKzs/H29sbZ2Vk6NigoiGvXrpVKY7FxmoeHR4kena6urkyYMKG0X0GFp7CwkNDQUBo0aGBqKaWmoKCABg0a4ODgYLQFmdJy48YN0tPTUalULFq06KHHZWVloVQq6dKlS4Vra1a8MDNixIgKlTnwXxQUFDBkyBCEEPTt27dCmdFVFgwGA5988gmurq5YWlry1ltvVbgFIWPStWtX3N3dycvLM7UUGRMwbtw4HBwcKtVzrrKxa9cuFApFqTOmOnXqhIuLC7du3TKSssrFvXv3GDJkCBqNBrVazcWLF2nevDnNmzcnIyODoqIioqKiiIyMxMrKij179pQwTgPo0qUL5ubmODo64uTkhIuLCwEBAZiZmZGammq6m5MpU+Sgu4ozZswYVCoVFy5coE2bNjRs2FD63cyZM0sE3MUPhNjYWAASEhIoKirit99+IyMjg1dffVVyNBdCMHjw4FJp69OnDzqdrkS9SmFhIUql8plxs/3yyy8RQvDdd9+ZWkqpGDFiBCqVii1btphaCvBgp7BGjRrY2to+sm7to48+QqlU8uKLL1a4gHv16tWoVCp69OhRaSeiS5YsQaPRkJyczOXLl00tp1KSk5PDgAEDUCgU1K5dmz179phaUpnwxx9/oFKpePvtt00tRcYEfPPNNwghOHbsmKmlVEkKCwuJjIwkMjKyVO+6Xbt2IYTgvffeM6K6ysPNmzdJTU2VWnkV17SnpKSgUCjIzMwEICwsDI1Gg06nIzg4GF9fXyIiIoiNjWXjxo0A5OXlERUVRXZ2Nvv378fd3Z2AgACuXLlisvuTKVvkoLuKc+PGDWxsbGjcuDGtWrWicePGwAPjEp1OJwXQKSkp0jmJiYncuHGDatWqERMT84+0l+K6E3Nz86d2Kn733XcRQvDBBx+U+PmlS5cQQvDVV189/U1XIgwGA3Xq1CEuLq7SBlbLly+vUPXGW7duxcHBgYCAgEdO4D788EOUSiXdu3evcAH3li1b0Ol0tGnTpsJpe1K2b9+Os7MzPj4+/Prrr6aWU2nZtWsXERERKJVKBg8ezM2bN00tyei8+OKLuLq6yi7WzyA3btxAoVDw/vvvm1pKlWTu3LkoFIpSmXIZDAbi4+OJiIio9O+lp+H+/fs0atSoxHz4+++/p7CwkLi4OIQQxMbGkp6ejlarxcLCgpCQEKlvt4ODA1988QVRUVHSeMXZjgqFgrCwsFKl/ctUfOSg+xlg06ZNqNVqfHx8qFmzJgAbNmyQHhparRYbGxvq1q1LdnY2fn5+UkAeHx/PV199RVpaGp6enoSGhjJx4kRcXFwQQlC3bt0nfvj+9NNPJYzT/s6BAweqVJ3z47Bx40aEEBWuvdbj8PPPP6PT6ejevXuFWDT44IMP0Gg01K1b95HlD0uXLkWhUNCzZ88K1xt59+7dWFpa0qhRoypjLHXmzBkiIyMxNzfn888/N7WcSktBQQEzZ87E3Nwcd3d3Pv/88wrxd2csjh8/jkqlKpcWlTIVj/DwcHr06GFqGVWO7OxsrK2t6devX6nGWbFiRZXIzHtaFixYIM2bLSwsEEJw+fJlMjMz+eijj9BqtfTo0YOTJ0/i5OQkpZTfvHmTmJgYqlWrJp2vVCpLdAiKjo6WFxufAeSg+xlh3bp1UiC9a9cuqS+sEILmzZuTnJzMggUL6N69O0IIatSowfPPP09MTAwFBQXUqVOHGzduSCt0BQUFzJ07F6VSSdeuXR974ldsnJaUlPSvdZ7Fbc6eJUdMg8FAamoq4eHhFS4AfBQXL17Ew8OD2NhYkweHhYWFklt/7969H9nu6/3330ehUNCnT58K930fPnwYe3t7EhISKowZnbG4e/cu7du3RwjBuHHjKtx3X5k4c+aM1Me1adOmFcZHwRj06NEDFxcX7t69a2opMuVM//79CQoKMrWMKkfHjh1xcnLi+vXrTz1Gbm4u3t7etGjRwojKKg8GgwF/f39p3jxu3DiEEFy5ckWq4/bw8ECj0ZCRkcGpU6f+UcdtMBho3bo13bt3Z+bMmSxevFgyepXb5T0byEH3M8SRI0ewsbGhRYsW2NvbSw+PgwcPsnXrVnx8fFCr1ej1enJycqTV0fj4eKk3cFRUFPv37+fbb79lw4YNTJ48GSEEM2bM+M/r37t3j/j4+H8Yp/2dDz/8ECHEM2ems337doQQrFixwtRSHot79+6RkJCAm5sbFy5cMKmW27dv06JFC5RKJW+99dYjF4Dee+89hBD069evwgV9J06cwM3NjYiICHJyckwtp0wwGAxMmTIFhUJBq1atnro8ReYBq1atwtPTEzMzM958880K1Vv+aTl58iRqtZqZM2eaWopMOfPRRx9JgYyMcdi8eTNCCGkO97RMnToVtVrN77//biRllQeDwUDfvn1LOIu/+uqrCCGYMmUKmZmZnD59GoVCQWRkpJTJaWFhUcIo9/333y/RmWf27NkIIXj99ddNcVsyJkAOup8xpkyZgk6nIzo6WnqAbNu2jZiYGKl1WP369aXjExMTyc/P5/r168yePbtEHXjxx9raGktLS86ePfvIa/ft2xetVvvI1PHp06djY2NjrNutVDRr1oyAgIAK71Bc3JLuv/5flgdnzpwhPDwcKysr1q1b98hjFy1ahBCCAQMGVLiU3AsXLlC9enUCAgIeuiBVlVizZg2WlpaEhYVx8uRJU8up1Ny6dYvhw4ejVCoJCwtjx44dppZUanr16oWTk1OVy/aQeTQnT55ECPHM9Kcva+7du0dgYCDJycmleuddvHgRS0tLhg4dajxxlYjiXe3iz8cff0xGRgZKpZK4uDgaNmyIl5cXKpUKPz8/bG1tEUKg0+mwtrYmNzeXTZs20bRpU+7cucPHH38s1YC/9NJLFW4+IlN2yEH3M8a9e/dITk5Gq9WW2OkG8PPzw83NDWtra1JSUqhbty6RkZHMmDEDpVKJQqHA2tqazZs3M2zYMCIjIwkJCSElJQWtVotGoyErK+tfr7t48WKEEP9pkjJixAgCAwONft+Vgf379yOEYMmSJaaW8kiK65r+rwleebNz505cXFzw9fX9z36WCxculBz3K9oL7urVq4SGhuLp6cmZM2dMLafcOHz4MH5+fjg4OFQY1/vKzL59+6hTpw5CCPr06VOqVFJTc+rUKTQaDdOnTze1FJlyxGAw4ObmxksvvWRqKVWCyZMno1arOXz4cKnG6dWrF3Z2dqVuE1sZ+eyzzxBCEBISIs2Z3377bbKysnB2dsbZ2ZmjR48ycOBAHBwcOHToEPfv32f+/PlSS15PT090Oh3m5uao1WrJkHjp0qWmvj2ZckYOup9Brl+/XsLQYcSIERw+fBghBBkZGSQlJZGTk8OsWbNwc3NDCEF6ejp79+7F2toaeJAKC5Cfn0/NmjW5evUqXbp0+dfAeseOHWg0mhJpNQ+jc+fOJZzUnzXatWuHl5eXyWukH8bWrVtRq9UMGTLEpDqysrLQ6XQkJiby119/PfLY+fPnI4Rg6NChFS7gvnXrFjExMTg5OXH06FFTyyl3rl27Rv369VGpVCxYsKDC/f+pbBQWFjJv3jysrKxwdnbm448/rrTfad++fXF0dJRLEJ4x2rRpQ1JSkqllVHpOnDiBXq9nzJgxpRrn119/RaFQPJOt/K5evYqnpyeNGjWicePG0pw5PT2doqIiQkNDEUIQFRX1rzXcJ0+eJCUlhVGjRtGjRw/69u3LiBEjcHFx4fnnnzfhncmYCjnofkY5f/58iRW34ofHvn372Lp1K/Hx8Xh6eqJWq3FycmLz5s3Ur18fpVJJ/fr1pTrevLw8/P39WbNmDevXr6dNmzYolUopxTE7Oxs3N7eHGqf9X+rXr0+7du3K9N4rMseOHUOpVFbIF9zp06dxcnKibt26JqsdLSoqklK9unbt+p+LE2+//ba0sFTRgo+8vDzq1q2LtbU1v/zyi6nlmIyCggKGDBki7dA+znNC5tFcuHCBtm3bIoSgQYMG/Pnnn6aW9MScOXMGjUbDG2+8YWopMuXIW2+9hU6nq7ALz5UBg8FA06ZN8fLyKtWilcFgoF69egQFBVUJv4gnYd26dZibmyOEYP369cTHx0tB95QpU6Qa7uLNppdffhlnZ2ciIiLYvHkz8CBjp3Xr1tKYFy5cIDQ0FHd39/8sx5SpmshB9zPMiy++KD1EEhISEEJw9epV9u/fT0xMDDY2Njg7O9O8eXPpnOIa71OnTvHyyy9LbRP+/jE3NyciIoIrV66QkJCAu7s7Fy9efCxNoaGhDB48uKxuuVLQvXt3nJ2dK1Q94927d4mMjMTX19dkJjd3796lXbt2CCGYOnXqfwbRxSYlo0ePrnAB9/3792nZsiVmZmZs27bN1HIqBO+//z4ajYbk5OT/zF6QeTzWrVuHr68vOp2OiRMnVrpApn///tjb21fJnuQy/87u3bsRQrBz505TS6m0rFq1CiEEq1atKtU4q1evrrTtTEvDqlWrUKlUeHt7U61aNe7fv09YWJg0x/Xx8ZFquAMCAvD09JTa7wYHBxMXFwf8/0H3pUuXmDJlCo6OjlhZWf1nOZxM1UUOup9hjhw5Iq3kFX+KU1xv3LiBTqcjLCzsHzXexbtSSqUST09Pfv75Z2bNmkV0dDTBwcEEBQWhVCoxMzNDrVY/kdmWo6MjU6ZMKatbrhScPn0ajUbD1KlTTS0FeLDa3aFDB8zNzTlw4IBJNGRnZxMdHY25uTkrV678z+NnzpxZYU1KioqK6NKlC2q1mvXr15taToVi+/btODs74+3tzf79+00tp0pw9+5dXnrpJdRqNcHBwfzwww+mlvTYnDt3Dq1Wy+TJk00tRaacuH//PmZmZrJ7/VNy+/ZtvLy8aNasWaneffn5+QQEBNCgQYMK9w4tS44cOYJer6dt27Y0aNCA1q1bk5mZybvvvotCoUAIgZWVFX379pVquAH8/f2xs7OTNp4iIyNxcnJCq9WiUCikczds2GDiO5QxJXLQ/Yzz9ddfS2nmSqWS8ePHAw9aKymVSnr27FmixtvBwQEhBO3bt6d27do0atQIoERKaGpqKlu2bCExMRGNRsP333//WFru379fKYzEyoPBgwdja2tbIcyQ3nzzTYQQfPbZZya5/i+//IKHhwceHh7s27fvP4+fPn06QgheffXVCjdZMBgMDBo0CIVCwaeffmpqORWSs2fPUrt2bczNzU32b64qcvDgQSmjqVu3bpWmLdOgQYOws7Pjxo0bppYiU06kpqbSqlUrU8uolIwZMwa9Xl/qrhBz5sxBqVRKRrvPAjdv3iQxMREXFxfy8vJITk6mU6dOUh/u4vmvEIIWLVrwwgsvSEF3dHQ0BoOBn376CT8/PxITE0lJSSEoKEg6JzY21sR3KGNq5KBbho0bN2JtbY0QAnt7e5KSkvD29kav15OdnS3VeDs7OyOEwNfXl3r16hESEoKVlRWpqalkZ2ezZMkSyT23+KNWq9FqtWzcuPE/dVy4cAEhBF9//XU53HXF5uLFi5iZmfHqq6+aVMf69etRKBS89tprJrn+l19+ibm5OXXq1HmsfuBvvPGG1PeyogXcAK+//jpCCBYvXmxqKRWau3fv0qFDB4QQjB07tsL1VK+sFBUVsXjxYmxtbXFwcOCDDz6okH8nf+fChQtSerzMs8Grr76Ks7Nzhf+3WdE4dOgQarW61Jkh165dw87Ojt69extJWcVn165dODg4oFQqmTBhAllZWWi1WsLCwqhTpw4pKSmYmZmh0Wik+W1xNugnn3xSIqBu3rw5J06cYMSIESXmw//V1lSm6iMH3TLAgyCvf//+CCGYP38+I0aMIDg4GECq8dbr9cTFxdGyZUvpvMTERCZNmiT1JXzUJzk5mWPHjj1Uw759+xBCsHfv3rK+3UpBcc28qfo2//7779jY2NC8efNyD3oMBgNTp05FCEG7du24e/fuf54zefJkhBCMHz++Qk7WilPeZ8yYYWoplYLifwMKhYLnnnuOW7dumVpSleGvv/6SDIBSUlI4cuSIqSU9kiFDhmBra0tOTo6ppciUA+vWrUMIUSkNAE2FwWAgOTmZoKCgUns3DBkyBCsrK5PNPcqbHTt2YGZmhp+fHyqVirNnz9KqVSvc3d1RqVSkpKSQnp6OlZUVer3+H3NbR0dH6tSpw8cff8ynn36Ki4vLP/yO5HIJGZCDbpn/Q//+/VGpVLRt2xYnJycpePnll1+kCVpxjXdaWhr29vb/eABZWloSHR1NUlISKpWqxO/s7OweapBS/KI9d+5ced5yheXatWvY2NgwdOjQcr/2zZs3CQ4OJjg4uNzTOu/du8cLL7yAEIJx48Y9VsA/ceJEhBBMmDChHBQ+OUuWLJFS3mWejDVr1mBlZUXNmjWlVoUyxmHTpk0EBASg0Wh47bXXyM3NNbWkfyU7Oxu9Xi+VP8lUba5du4YQguXLl5taSqVh2bJlCCEk5+yn5dixY6jV6meia4DBYOCbb77B3NychIQERo0ahY+PD5mZmWRlZREREYFWq5UWykNCQhg6dChff/01SqXyPzeaiss2FyxYYOI7lakoyEG3TAkKCwvp3Lmz9MD47rvvgAc1xg4ODgwePFiq8S6uDyz+tG7dmoSEBDp06MCBAwfYvn079evXp379+vj7+0vH2dvb8/vvv//j2h988AFCCLll0N+YNGkSWq2WM2fOlNs1i4qKyMjIwMbG5l//P5Ully9fJjExEZ1OR1ZW1mOd87///Q8hBJMmTSpjdU/HZ599hlKpZMCAARVyB74y8Ntvv+Hn54e9vT1btmwxtZwqRV5eHuPGjUOr1eLn5/dYpUCmYPjw4VhbW1cInwuZsickJIQ+ffqYWkal4Nq1azg5OdGxY8dSj9W8eXN8fX3Jy8szgrKKy2+//UZ0dDRCCDQaDX/99RfDhw8nKChIquGOioqiS5cueHp6EhcXh4uLC99++y0ATZo04cUXX8TR0fGhAXd6ejqHDx828Z3KVCTkoFvmHxQVFTFt2jR0Oh3169cnOTkZBwcHnJycpBrv4r7eQggUCgXt2rUjNTUVS0tLXn/9dQDatWvHvHnzaNCgAf/73/9KBN5paWn/uO7UqVOxt7cv79ut0Ny6dQsnJyd69epVbtd8/fXXUSgU5V5/dOjQIXx9fXFxcXmsdjEGg4GxY8dKLcQqIhs2bECj0dC5c2e5LrmUXLt2jQYNGqBSqZg/f768gGFkjh49SlpaGkIIOnbs+NhtHsuLS5cuYWZmxtixY00tRaYc6N27N6GhoaaWUSno27cv1tbWZGdnl2qcTZs2IYSo8iaf27dvx8bGRvIdeuGFFwBo3bo1Qgg+/PBDnn/+eSwtLYmIiMDOzo7o6GhWrVqFhYUFycnJtGrViiZNmtC4cWNq167NwIEDGTVqFN26dUOr1ZKenk5hYaGJ71SmoiEH3TIPZcaMGajVan755RcaNmxImzZtgAc13sWtEYQQhIeHS+ckJiZy584dxo4di7e3d4m08uJamGK39P+7YzV06FBCQkLK9R4rA7Nnz0alUpXLrvPnn3+OEIJp06aV+bX+zrp167CysiI8PPyxdvUNBgOvvfYaQgjefPPNclD45Pz444+YmZmRkZHB/fv3TS2nSlBQUMDQoUMRQtC7d285K8bIGAwGli9fjqOjIzY2NrzzzjsVarFo5MiRWFlZce3aNVNLkSljitOl5cyGR7Nr1y4UCgVz584t1TiFhYWEhYWRmJhYpRc0jx49+g8Pol27dlFYWEhiYiJCCOrUqUPDhg2xtrbmhRdeoE6dOlKPbQ8PD3Jzc+nRowc//fQTd+/epUWLFpw+fZrXXnsNrVZL3bp1uXPnjqlvVaYCIgfdMg/l7t271KlTBzc3N9LT06Xd6fPnz0u12nq9vkQf7/DwcKKiohBCYG1tTf/+/Rk+fDjjx4+nZs2a1KlTh4iICMzMzDAzM+PHH3+Urte+fXvq1atnqtutsOTl5eHp6UmHDh3K9DoHDhzA3NycDh06lNtL12Aw8NZbb6FUKsnIyHgssywr0OJFAADXQUlEQVSDwcDLL79coU3J9u/fj42NDWlpaVU+Tc8UvP/++2g0GpKSkvjrr79MLafKcfXqVXr06IEQgri4OA4cOGBqScADAzhzc3PZG+EZ4I8//kAIwfr1600tpcJSWFhIZGQkkZGRpd5VfffddxFCsHv3biOpq5jUrVtXCrZDQkIQQnD//n0yMzP56KOP0Ol00lwrKiqKPXv24OHhQUxMDGZmZtImkqOjI+7u7vj6+pKcnIxSqUStVjNs2DB5MVjmochBt8wjuXTpEmFhYZiZmaFWqzl9+jTz58+XHlrFhmk5OTlMmzYNvV6PSqXCx8eHlJQUbGxs8PX1pUOHDqxdu1Ya99q1ayQnJ6PX66VU4tTUVKPUJFVFFi9ejBCCX3/9tUzGv3LlCr6+vtSqVeuxnMKNwf379+nTpw9CCEaPHv1YkwaDwcDo0aMRQjB79uxyUPnk/P777zg5OREdHS07bpchP/30Ey4uLnh7e7N//35Ty6mSbNu2jRo1aqBSqRg9enSF2L0ZM2YMlpaWlabPuMzTYTAYcHJyMlm7ysrA3LlzUSgUpQ6Ub968ibOzM507dzaSsorJ+vXrpblr9erVeeutt1CpVBQUFEh13J6enlKGZ3Jycok67hMnTuDl5YW9vT02NjZ4eHhQrVo1oqKi0Ol0jBw50sR3KFPRkYNumf/kxo0bdOzYEZVKRZ8+ffDy8pIeXFlZWVIfbysrK9RqNVFRUdK5NWrUYOTIkYwfP56IiAhq1KhB69at6d69O3379sXX1xcHBwdu375NcHAww4cPN+GdVlzu37+Pn58fGRkZRh+7oKCAevXq4ejoyOnTp40+/r9x7do16tWrh0aj4f3333+scwwGAyNHjkQIwZw5c8pY4dNx5swZvLy8CAkJ4erVq6aWU+U5e/YsUVFRmJmZ8dlnn5laTpUkPz+fKVOmoNfr8fHxKbF4agquXLmChYUFL7/8skl1yJQ9zz333L/6v8g8cPS3tramX79+pR7r5ZdfxszMjLNnzxpBWcVk3bp1Umlj8Rxi0KBBCCFYsGCB1Ivb3NycwMBA3Nzc6N+/P7GxsVhaWmJlZUV6ejrff/89AAMHDmT9+vWcPn0af39/AgMD5bIXmf9EKWRk/gMbGxuRlZUlOnXqJFatWiWaNWsm/c7d3V1YW1uL/Px8cefOHTF06FDh6ekp/d7e3l6MGTNG5OXlicuXL4ujR4+KtWvXisOHD4udO3eKS5cuievXr4v69euL8+fPCxcXF1PcYoVHo9GIiRMnirVr14pdu3YZdexRo0aJbdu2iS+++EL4+PgYdex/448//hBxcXHiwIEDYtOmTaJHjx7/eQ4gRowYIWbNmiXmzZsnhg4dWuY6n5TLly+Lhg0bCrVaLTZu3CgcHBxMLanK4+XlJbZt2yZatmwp2rVrJ8aOHSsMBoOpZVUptFqtePXVV8Xhw4dFUFCQyMjIEK1btxbnz583iR5HR0cxePBgMW/ePHHlyhWTaJApHxITE8Xu3btFQUGBqaVUOEaOHCl0Op2YOnVqqcY5ffq0eOutt8SoUaOEl5eXkdRVLDZv3ixatmwpVCqVEEIIMzMz0aVLF3H8+HEhhBCrV68WNjY2wszMTKhUKnH79m1hb28vVqxYIZo2bSpq1KghvL29hY2NjXB0dBRCCGFlZSU+++wzERMTIwwGg9iwYYOwt7c32T3KVBJMHfXLVB7Onz+Ph4cHrq6u0mphZmYmgFSXW2zAU7duXbKzs/H390ev16NUKmnbti0HDhygTZs29OvXj3r16pGYmMibb75JtWrVUCgU9O3b18R3WXEpKioiLCzMqHXvxW3ayquP5ObNm7G1taVGjRocP378sc4xGAwMGTKkXHU+KTk5OdSqVQtXV9fHvi8Z42EwGHjjjTdQKBS0bNlSTusvIwwGAytWrMDFxQVLS0vmzJljEofeq1evYmlpyejRo8v92jLlx44dOxBC8PPPP5taSoVi8+bNRutj3q5dO9zc3Lh9+7YRlFU8bty4gbW1NY0aNZJ6a9euXVvqxW1jY0N4eLjkYxMSEsLAgQNJTEzExcUFhUKBSqWiRo0a9OrVC09PT1xcXCRfo4yMDNlXROaxkYNumSfi0KFDJZzLiwPA6OhoEhMTGTZsGMnJySxYsIABAwagVCrx8fFh3bp1NGnShLt37+Lt7f0PA6z8/Hy6du2KQqFg1apVJrizysFXX32FEILNmzeXeqxdu3ah1Wrp1atXuRinLVq0CJVKRaNGjbhx48ZjnWMwGBg4cCBCCBYtWlTGCp+Ou3fvkpiYiJ2dHYcOHTK1nGeatWvXYmVlRWhoKCdOnDC1nCpLTk4O/fv3R6FQULt2bfbs2VPuGl577TXMzc3lCW8V5t69e+h0ugpbTmQK7t27R2BgIMnJyaV+b2/fvh0hBEuXLjWOuArG+vXr8fPzQ6VScebMGWneGhsbK9VwBwQEIITgk08++UcNN8Dly5cJCwsjODgYT09PPDw8CA0NxdrampYtW5ru5mQqJXLQLfPEnDx5EnNzc+kBVmwi4efnJ/Xx9vX1xdLSUjJf69OnD5aWlsTExJCcnMyIESOIi4sjJSWFtLQ0atWqRVxcHF5eXuh0Oi5fvmzq26yQGAwGYmJiiI2NLdUL98KFC7i5uREfH8+9e/eMqPCf/L3N06BBgygoKHis84qKiujfvz9CCBYvXlymGp+W/Px8GjdujIWFBbt27TK1HBngt99+w9/fH3t7e7777jtTy6nS7Nq1i4iICJRKJUOGDOHmzZvldu1r165hbW0tmxdVcRITE2nbtq2pZVQYJk+ejFqt5vDhw6Uap6ioiOjoaGrXrl2h2gIai+nTpyOEwNLSUmp3W9y21tbWlqioKKmGu169euh0OjZs2ED//v2xtLQkNTWVvLw87t69S1hYmDTu5cuXqV27Ni4uLpw6dcpEdydTWZGDbpmnYubMmVLQXadOHVxcXJgwYQL79+8nJiaG6tWrI4TA3NxcaicWHR3Nli1bsLKywtzcXGqx4Ovri7u7O66urlL6j5OTE4sXL67S/SKfluLUstWrVz/V+ffu3SMuLg4PDw+ys7ONrK4kN27coEmTJqhUqidKDS8qKqJv374oFAqWLFlShgqfnsLCQtq2bYtOp5ODuwrGtWvXaNCgASqVinnz5snPkTKkoKCAmTNnYm5ujru7O1988UW5fd9jx47FzMyMixcvlsv1ZMqfMWPG4O7uLv8N88A9W6/XM2bMmFKPlZmZiRCCrVu3GkFZxWLBggUIIejduzdCCL799lsKCwtxdnaW5q21atUiPT1d6r3dtGlTlEolCQkJJcyAP//8c1566SVu377Nu+++i5eXF3Z2dvzyyy8mvEOZyoocdMs8FTk5OSVczC0tLUvUYz///POoVCqSk5MBWLp0KZ6enkRGRqLRaHB2diY0NJQ5c+ZIQdXdu3cJDQ3lp59+ol27dgghGDhwYJVchS0tdevWJSws7Im/G4PBQI8ePdDpdGVeJ3fy5ElCQkKwsbFh48aNj31eUVERvXr1QqFQVNi0N4PBQM+ePVGpVHz11VemliPzLxQUFDBs2DCEEPTq1UvunVrGnD59moyMDIQQNGvWrFx2ga5fv46NjQ3Dhg0r82vJmIbVq1cjhHjmdxUNBgNNmzbFy8ur1PXXd+/exdPTk+eff95I6ioOhw8fljJvNm3ahBCCkydPkpmZKb0PhBA0b94c+P9ruFNSUrCwsEChUEgtxYYNG0ZQUBDNmjWTfmdhYcGff/5p4ruUqazIQbfMU3Po0CFsbGykh5iVlRW5ubkA+Pj4EBoaSnJyMjk5OUyYMIHg4GBpZ/vtt98mNjaWfv36sWXLFgCWLFlCWloazz//PPXq1SMkJAQhBK1bt37slORnhWKDmaysrCc6b968eUYzYHkUP/74I46Ojvj5+XH06NHHPq+oqIgePXqgUCjKXOPT8vfWZR9++KGp5cj8Bx988AFarZakpCS5/reMMRgMfPnll3h4eGBubs6bb77J/fv3y/Sa//vf/9Dr9WWetSNjGi5fvowQgo8++sjUUkzKqlWrEEIYxfNm4sSJaDSaKhU83r9/n1GjRqHRaDA3N+f27du8/PLLCCE4fvw4rq6uJCUlSUG1EAI7OzvUajVhYWGMGDGCRo0aMWXKFJYvX46zszO+vr5Ur14dKysr6Zzp06eb+lZlKjFy0C1TKg4dOlRixzswMJC0tDS0Wi2jR49myZIlWFpaotfrqV27NhYWFpw7d442bdpgbW1Njx49OHr0KC+88IKUWv5vHxcXFyZPnszdu3dNfcsVhoyMDPz9/R97UrtlyxZUKlWZ90Jfvnw5Wq2W1NTUJ+pVXVhYSLdu3VAqlZIrfkVk8uTJCCGYN2+eqaXIPCY7duzAxcUFLy8vOS2wHLh16xbDhg1DqVQSFhbGjh07yuxaN27cwNbWliFDhpTZNWRMS2BgIAMGDDC1DJNx+/ZtvLy8aNasWanT7C9cuIC5uXmV8kLIzc2lUaNGqNVqrKysGDRoEIWFhdStWxchBK+88oqUNefh4VFibpmRkSHVbLdr1469e/cCD4xfx40bR61ataRjvb29ycnJMdFdylQF5KBbptTcuHGDt956C0tLS7y8vLh8+TKurq5MmDBBOubtt99GCIGZmZlU4x0ZGcmMGTMeGWz/30+dOnW4dOmSCe+24vDrr78+tsnYqVOncHBwoEGDBmWWNVBUVCStLPfs2fOJ0nkLCwvp2rUrSqWSjz/+uEz0GYP58+cjhGDSpEmmliLzhJw7d46oqCjMzMz49NNPTS3nmWDfvn3UqVNHagd5/fr1MrnOxIkT0el0nD9/vkzGlzEt3bt3JyIiwtQyTMaYMWPQ6/WcPHmy1GN169YNR0fHKhM8ZmdnU7NmTXQ6HXPnzkUIwe7du8nMzOSjjz5Cq9USFhZGw4YNSU9Px9LSEicnp3/MLTMyMnjxxRcZOHAgCxcuLFH/XbwrXlrzOhkZOeiWMRrHjx/Hzs6OWrVqUaNGDbp06SL9rnXr1mi1WhISEsjJyWHWrFl4eHiUSPVRKpWMGDGCTp06sWrVKq5fv06jRo1ITEwscVxYWNhjt5yq6nTo0AFPT0/y8vIeesydO3cIDw+nevXqT7Tz/CTcvn2b5557DoVCwcyZM59oNb6goIDOnTujUqlYsWJFmegzBsXGMyNGjJBNfSopubm5dOzYESEEr732muwXUQ4UFhYyd+5crKyscHZ25uOPPzb638/Nmzexs7Nj4MCBRh1XpmKwZMkSlEplubrjVxQOHTqEWq1m8uTJpR5r3759KBSKJzI1raicOnWKDh06SP2yP/vsM9auXYsQgrNnz0otwdzd3dHr9Vy/fp3k5GTUajVr1qyhWrVqj73ZU61aNY4cOWLqW5apAshBt4xR+fXXX3Fzc8PS0hKdTkd8fDxpaWlYWVnRvn17tm7dSnx8PN7e3lL7BiEEHh4ehISEAPDOO+/wySefAA8M2ZYvX87MmTOxt7eXjm/fvr0pb7PC8Pvvv6NSqXjrrbf+9fcGg4G2bdtiYWFRZj2kz549S61atbC0tGTt2rVPdG5BQQEdO3ZEpVLx2WeflYk+Y7B69WpUKhU9e/aUA+5KjsFgYNq0aSgUClq2bMmtW7dMLemZ4Pz587Rp0wYhBA0bNjR6PemUKVPQarWcPXvWqOPKmJ6jR49KLtTPEgaDgeTkZIKCgkrd2tNgMJCSkkJISEil98jZs2ePtBOtUCgIDg7GYDDw0ksvIYRg1qxZ1KlTh5SUFMzMzNBoNLz44osYDAbOnDmDlZUVI0eO5NChQ1KLsH8Ltq2trVm0aBF37twx9S3LVBHkoFvG6Jw9e5YOHTqgUCikuldfX19efvllqaWYo6Oj9GBr2rQpBQUFJCYmkp+fz4kTJ/D29sbBwQGdTvePB6FarUYIIfdF/n/07NkTJyenf3U0nTp1KkIIVq5cWSbX3r17N66urnh7e3PgwIEnOregoID27dujVqv54osvykSfMdiyZQs6nY42bdpQWFhoajkyRmLt2rVYWVkRGhrK8ePHTS3nmWHdunX4+vqi0+mYOHFiqYOJYm7duoWDgwP9+/c3yngyFYeioiLs7e0ZP368qaWUK8uWLUMIwebNm0s91sqVKxFCsGHDBiMoMx3Hjh0rsQGjUChYuHAhhYWF1KtXDyEE7dq1o379+lJLsOLjBwwYwNq1a7G1tWXkyJFS5sTFixfx8vJi2rRpjBw5EhcXF1xcXLhw4YKJ71amqiEH3TJlxvPPP4+DgwN//vknQUFBjBgxAniQbvj3mprIyEhSUlKwtrYmOzubGjVqIIRApVIREBDA3Llz+fHHH4mLi6NWrVrUr18fvV6PWq2WazOBM2fOoNVq/5F+9vXXX6NQKBg3blyZXPeTTz5Br9cTHx//xHX29+/fp02bNqjVar788ssy0WcMdu/ejaWlJenp6UYLDmQqDkeOHMHf3x97e3ujTGxlHo+7d+/y0ksvoVarCQ4O5ocffjDKuG+88QYajYYzZ84YZTyZikPz5s1p0KCBqWWUG9euXcPJyYmOHTuWeqx79+7h5+dH48aNjaDMdBgMBiIiIqS5Y/Fc8eLFi2RmZvLxxx+j1+tp27atdE5xS7DAwEBpXvn8888zZMgQ+vTpQ3x8PDExMcyePZsRI0ZgbW1N9erV+eOPP0x4pzJVFTnolikzrl27RlBQEF5eXsTFxVGvXj0AqXeiEAJbW1uuXbvG2bNnCQsLk/q8Nm/eXJoQr1ixgmbNmvHnn39SWFhIamoqly5dkmozZ8+ebeI7NT1DhgzBxsaGa9euAQ/S8aytrWnZsqXR61YNBgP/+9//EELQuXPnR9aT/xv379/n+eefR6PRVOge14cOHcLe3p7ExEQ5vawKc/36dRo2bIhKpWLu3Lly+UA5cvDgQRISEhBC0K1bN65cuVKq8W7fvo2joyN9+vQxkkKZisIbb7yBpaVlpU+Nflz69u0rbUSUlpkzZ6JSqSq1EVhxWVDx3DEkJIQFCxYghCAvL0+q4fby8kKtVnPhwgWSk5NxcXGRyhLmzZtHcHAwQgi0Wi3x8fHUq1dPcihXq9UMHjyYy5cvm/huZaoqctAtU6acO3eOsLAwKSW8Tp06BAQESA/OMWPGEB8fT0JCAp07d0ahUODs7ExCQgIpKSnY2dmRl5dHnTp1gAc14zVq1CA9PZ02bdpIq5edOnUqM5OwysClS5cwNzfn5ZdfJicnh8DAQGrUqGF045nc3Fw6dOiAEILJkyc/cYCSn5/Pc889h0ajYc2aNUbVZkxOnDiBm5sbtWrVqjIurzIPp6CggOHDhyOEoFevXk/kvC9TOoqKinj33XextbXFwcGBDz74oFQLH9OnT0etVnPq1CnjiZQxOdu2bUMI8Uy0/Nu1axcKhYK5c+eWeqzLly9jY2NTqcsuCgoK6N+/f4kyw8GDB0v9s2vVqkVQUBAxMTH4+/tjZ2dHjRo1SExMpFatWjg7OwMPsi9v3rzJihUriI+Pp1u3brRv355WrVqh0Wjo16+fie9UpqojB90yZc6tW7eYPHkyGo2GYcOG8cYbb0gPzpUrV0p13paWlgQEBNCiRQvp3OI677i4OMLDw6X0oOIWEGFhYdIKpU6nY8KECeTm5prwbk3Hq6++irm5OfXr18fW1tbo6VEXL14kNjYWMzMzPv/88yc+/969e7Ro0QKtVsvXX39tVG3G5MKFC1SrVo2AgAC5Pd0zxtKlS9FqtSQmJsr/78uZS5cu0blzZ4QQpKSkPLVb8J07d3B2dqZXr15GVihjSnJzc9FoNJJPTFWlsLCQyMhIIiMjjeIhMmDAAGxsbCrt7q3BYKBXr14olUqpvayzszMtW7YkKCgIIQStW7emYcOGpKSkoFKpaNWqFSqVisaNG3Pq1Cmsra05d+4c4eHhpKenEx0dja+vL2vWrOH777/H1taWuLi4Z3buKFN+yEG3TLkxbtw4VCoVffv2lYLuZcuWAQ92xBUKBdHR0VhbW5fo5R0XF4cQAr1eT+3atWnatClbtmyhYcOGJCQkMHXqVPr37y/Vebu6uvL+++8/M2loxVy/fl0ynvvmm2+MOvavv/6Kl5cX7u7u7Nmz54nPv3fvHs2bN0en07F+/XqjajMmV69eJSQkBC8vL7ku9Bllx44duLq64uXlxb59+0wt55lj06ZN+Pv7o9FoeP31159qIjxz5kzUajUnTpwoA4UypiI2NtYoNc4Vmblz56JQKNi9e3epx/rtt99QqVTMmDHDCMpMQ7EZbPF/hRAkJCSQlZVFVFQUNWvWpFWrVsCDchVnZ2fy8vIIDw9HpVKhUqlwd3fn119/lcbcvHkzLVu2lIzX6tevL7ehlSkX5KBbptwoLCykZcuWUqq5EILnnnsOeFCvpdfr6d+/P0lJSVIvbwcHB4QQ9OvXjxEjRnD37l1atGjB0KFD2bRpEwUFBcTFxXH79m22bduGq6urdE5ISAirV69+Zmo0P/nkEykT4PTp00Ybd/Xq1VhYWFC7dm3Onz//xOfn5eXRtGlTdDqd0RcDjMmtW7eIjo7GycmJY8eOmVqOjAk5d+4cUVFRmJmZyWaNJiAvL49x48ah1Wrx8/Nj48aNT3T+3bt3cXFxoXv37mWkUMYUjBgxAm9vb1PLKDOys7OxtrY2Wppz48aN8fPzq5QmoL/88gtpaWmoVCqaNm3K3r17pXmjj48PRUVFREVFsXDhQpRKJdHR0SXqtwFeeuklbGxspM0IKysrnJ2d0Wq1CCGwsLBg+fLl3L9/34R3KvMsIQfdMuVKfn6+ZIAmhECpVBITE4O7uztWVlZkZ2dLvbzd3d0RQjBp0iReeuklPD09adCgAXv27CEhIYG//vqL6dOnY2NjU6LWR6vVEh0dTUpKCkIIkpKS2LFjh6lvvUzZv38/ZmZmtGvXDmdnZ3r06FHqMQ0GA2+++SYKhYLnn3/+qczE8vLyaNy4MXq9/oknzuVJXl4edevWxdra+pmoGZT5b3Jzc+nUqRNCCF577TWjGxLK/DdHjx4lNTUVIQQdO3bk4sWLj33uW2+9hUqlMno/cBnTUdz26ty5c6aWUiZ07NgRJycnrl+/XuqxNmzYUKbtQsuSjRs3YmFhQfXq1aU2Z7Nnz5bmeHZ2dqSkpGBubs6GDRvw9vbGxcWFsLAwzM3NyczMlMYqLCykWbNmTJkyhRkzZjBx4kRatWpVItNSRqa8kINumXLHYDDQtWtX6QHaqVMnunXrRnx8PIBU421tbY2Li4tUz+3l5UV2djajR49GqVSiUqnQarXUrFmTZs2a4ebmho+PDy1btkShUGBlZUXfvn2lWvBWrVpx9OhRE9+98bl8+TI+Pj7Url2b3Nxc5syZg1KpLNVu7b179+jWrVupAo7c3FwaNWqEmZlZhW7HdP/+fVq0aIGZmRk//vijqeXIVCCKHXMVCgUtW7bk1q1bppb0zGEwGFi2bBkODg7Y2NiwaNGix3oe5ebm4ubmxosvvlj2ImXKhYsXLyKE4JNPPjG1FKOzefNmhBAsX7681GMVFBQQEhJCSkpKpcv027t3L+bm5jRu3Jj+/fvj7e0tvaOLa7qVSiX169fHysoKT09P9u/fj7W1NUFBQdSqVYuaNWuW6KrSoUMHDhw4wJ07d3jttdcQQjB69GgT3qXMs4ocdMuYhPPnz2NmZiYF3uHh4fj7+0u/v3btGhqNhjp16lBUVMT3339Peno6EyZMkNqKxcXFcfnyZQYNGsSmTZvIz88nKiqKwsJCduzYQfv27RFCMGDAADIzM/H19UWlUtGnTx8uXLhgwrs3Hvfv3yc1NRVnZ2epBjkvLw8vLy/at2//VGNeuXKF5ORktFptiRXjJ+Hu3bs0aNAAMzMztmzZ8lRjlAdFRUV06dIFjUbDhg0bTC1HpoKydu1arKysCA0N5fjx46aW80xy9epVevTogRCC+Ph4Dhw48J/nvP322yiVSrnnbhWievXqDBkyxNQyjMq9e/cIDAwkOTnZKEHywoULUSgU7N271wjqyoeioiI2bdqEo6Mj4eHh3L17l3bt2lG/fn0yMzPJysrCyclJmjMuWLBA6sGdmppKdHS0lEZuYWFB69atiY6OJioqim7dujF06FAsLS0RQjBlypRKtxghUzWQg24Zk/HFF1+gUChKpIbv2rULgM8++wwhBL179wbg+++/p27dujRv3hylUklcXBxt27aloKCA+Ph4cnNzOXPmDK6urri4uJQYUwhBcHAwK1eulOrEzczMeO211yq9ecagQYNQq9Vs27atxM+XLFmCEIL9+/c/0Xi//fYb1apVw9nZ+alT8u/evUu9evUwNzfnhx9+eKoxygODwcDAgQNRKBRy3a7Mf3LkyBH8/f2xt7ev0JkbVZ2tW7dSo0YNVCoVo0ePfmTZS15eHu7u7nTp0qUcFcqUJV27diUqKsrUMozK5MmTUavVRumjnZOTg6OjY6XK8Che6C+er3355ZdkZWWh1Wpp2LAhrq6uJCcno9frpWOKTdICAgKkcfLz8+natSs+Pj7/mAOqVCqEEMycOdOEdyrzrCMH3TImJTMzE41GI7X9ysjIIDk5Weq/feHCBUaNGoW5ublkwPbmm2/yxRdf4O3tTXx8PEuWLKF3795S6tGjPtWqVeObb77h1VdfxczMDAcHB+bMmVMpjUaKA+t33nnnH78rKCggICCAZs2aPfZ4GzZswNrampo1az61EdudO3dIS0vDwsKCrVu3PtUY5UVxmtl7771naikylYTr16/TsGFDVCoVc+fOlXdLTER+fj5TpkxBr9fj4+PD2rVrH3rs/PnzS11uI1NxWLRoESqVitu3b5tailE4efIker2eMWPGGGW84vlSZcnmO378OF5eXjg6OtKkSRM8PDy4d+8erVq1wsHBAXd3d5YuXQpAWFiYZJQrhMDDwwO9Xi+N9e2339KqVSuKioo4efIkX331FaGhodLxvr6+JdLOZWTKGznoljE5O3bsID09XTJBO3jwIO+++y4KhaJE7d5zzz2HWq0mJiZGqvE+fvw43t7e/1jR9Pf3x8nJCUdHRxwdHUv8XqfTsWbNGs6fPy8F676+vnz00UeVxixpx44daDQa+vbt+9BjVqxYgRCCn3766ZFjGQwG5s6di1KppFmzZk9dt3r79m1SUlKwtLSs8LXRM2bMQAhRqVupyJiGgoIChg8fjhCCXr16kZ+fb2pJzyzHjx+nUaNGUq/ef+uucO/ePTw9PenUqZMJFMoYm0OHDiGE4LvvvjO1lFJjMBho1qwZXl5eRllEOH78OBqNhgkTJhhBXdmyd+9eunfvjkajwdbWlt9//53AwECGDBkipZP7+fkhhCA2Npb09HQsLS0JDQ0lICCgxJyuSZMmzJ07l5iYGI4fP862bdvo2rWrlG4uhMDGxoZDhw6Z+rZlnnHkoFumwvDLL7/g6uqKm5sbCxYsQAghpVsVFBRgY2NDREREiRrvGjVqSA9VtVqNm5sbFy5ckPqz5ufnU7NmTdauXUtCQoJ0rF6vl1LZjxw5wnPPPYcQglq1apVoOVEROX/+PK6uriQlJT1ywl9UVER4eDipqakP3ZG7f/8+/fv3RwjBiBEjKCwsfCpNt27dIikpCSsrq/8M8k3Ne++9JxnEycg8LUuXLkWr1ZKYmMilS5dMLeeZxWAwsGLFClxcXLCysuLtt9/+x3PsnXfeQaFQcOTIEROplDEWRUVF2NjYMHHiRFNLKTWrVq1CCMGqVauMMt7zzz+Pp6cnd+/eNcp4ZUFBQQH9+vUrETSvWbMGAGdnZ8m3p7glmLe3Nz169CA5ORm1Ws3atWuJj4/HwsLiPzMbiz+urq6Vqr5dpuoiB90yFYoLFy4QGhqKra0tFhYWdOnSheTkZOLj4xFCkJmZyZw5c6hdu7ZkilG8Q1486apfv76UWnXmzBlcXFzw8/PD0tISjUYjpakHBweXCEa3b98uBeYNGjRg3759pvoaHkpeXh7R0dF4eno+1kR/zZo1CCH+tV3X9evXadCgAWq1ulQp1jdv3iQxMRFra2t27tz51OOUB59++ikKhYKBAwfKqcEypWbHjh24urri5eVVIZ8XzxI5OTn0798fhUJBVFRUiUl2fn4+3t7eT20uKVOxaNy4MY0bNza1jFJx+/ZtvLy8aNasmVHeRT/88IM0R6qoFBYW0rp16xIBsbe3N0VFRWRlZaFUKsnIyKBOnTpSS7DevXuj1WpZs2YNSUlJWFhYkJmZyZ07d3jjjTekntv/9rG0tGTkyJGVJtVepuojB90yFY6cnBx69uyJSqXCxsaGvLw8jhw5ghCCH3/8UWopZm5uLj1c//e//zFy5MgSY7Rv3x6FQoFWq6VPnz7MmjWLOXPmMGrUKJydnaWd7d9//106z2AwsHr1amkHvWPHjtKuuakxGAy8+OKL6PX6x161NRgMxMXFER0dXeLF/scffxAUFISdnV2p3MVv3LhBfHw81tbWUuZARWXDhg1oNBq6dOlSacoIZCo+586dIyoqCjMzsyrZyqiysXPnTsLDw1EqlQwZMoSbN28CSCVLxjCrkjEtkyZNwsbGplI/x8eMGYNer+fkyZOlHquoqIjatWsTHR1dob+T0aNHl8hMVKvVTJ8+ncLCQlq1aoWFhQXVqlWjfv36pKenY2VlhYeHB0lJSeh0OqZMmUJiYiJxcXFSbXZUVBRr1qyhT58+tGrViqioKBQKBcnJyY80WZSRMQVy0C1TYdmzZw8qlYoePXpw5swZhBBSW6fff/+9RI323/t4Fzt6azQaIiIiuHHjBu+//z5JSUnExsby8ssvc//+fb744gsCAgKwt7f/RxBbUFDAkiVLcHd3R6PRMGTIEC5fvmyKr0Fizpw5CCH46KOPnui8LVu2lEhh27JlC3Z2dgQGBpaqlc6NGzeIjY3F1taWn3/++anHKQ9+/PFHzMzMyMjI4P79+6aWI1PFyM3NpVOnTqXqay9jPO7fv8+MGTMwNzfH3d2dlStXcu/ePXx8fGjbtq2p5cmUkuJ32sGDB00t5ak4dOgQarWayZMnG2W8ZcuWIYRg+/btRhmvLNi9e7dkdlucXSeEYNu2bVINt4+PDwqFQlqIKG4JlpiYiEqlQqFQ0KxZM9q3b8+iRYukXt3169dnxYoVUplg165d5fe8TIVEDrplKjQffvghQgh69uyJnZ0dI0aMAGD27NlS0D1t2jSpxnvcuHFERERgbW2Ni4uLZE7y99rn1NRUMjMzmTFjBmPGjMHLywsbG5t/3dG+e/cub7zxBtbW1lhZWTFp0iSTrJ5u3rwZlUrFqFGjnur8+vXrExoayqJFi1Cr1TRo0IDr168/tZ6cnBxiYmKws7Or8LVSv/zyC9bW1tStW1d2LpUpMwwGA2+++SYKhYIWLVpIO6wypuP06dNkZGQghKB58+a8+eabCCEeq8e3TMXlzp07qFSqf+3cUdExGAwkJycTFBRklK4pd+7cwd3dvcIuJhkMBsaOHVuiPewrr7zClClTJEM8BwcHkpKSsLS0xMrKilGjRhEWFoZGoyE0NJStW7cSFRXFlClT8PT0lJzImzRpQqNGjahWrRpCCLy8vFi8eLFcOiZTYZGDbpkKzwcffIBarcbKygorKysSExNLOJYPGDCA2rVrY2dnh5+fH0qlkqCgIOzt7UlNTSU1NZUbN26Qk5PDG2+8IaWlF6cuWVlZSe6W06ZN+9dg9OrVq4wYMQKtVourqyuLFi0qt5XUEydOYG9vT6NGjZ7a6Oynn34q8X2VRvv169epU6cOdnZ2Fb6O9dixYzg5OREdHf3UruwyMk/C119/jbW1NSEhIRw/ftzUcp55DAYDX375JR4eHpibm2Nvb89zzz1nalkypSQqKoquXbuaWsYTU7wrvXnzZqOMN27cOLRarVHS1I2NwWCQjFqL51lKpZJTp05JXQeGDRvG3LlzAQgICKBOnTrSHO7gwYOSGWxCQgJFRUUUFBTQtGlTWrRoQcuWLWnevDm2trZSqzEZmYqMHHTLVAp+/fVXyYBj4cKFJWqD3nvvPWJiYggMDCQ4OJj09HRCQ0Px9PSkbt26ZGdn07t3b2mlNSAggJ07d0qroenp6XTq1IkXXngBnU6Hr68vR48e/Vcdp06domvXrigUCgIDA/niiy/KdFX19u3bhIWF4efn99Q70zdv3qRZs2YIIXB0dCxVwH3t2jVq166Ng4MD+/fvf+pxyoMzZ87g5eVFSEgIV69eNbUcmWeII0eO4O/vj52dndEm1zKl49atWwwdOlR6DyxbtszUkmRKwZAhQ6hevbqpZTwR165dw8nJiY4dOxplvHPnzmFmZsZLL71klPGMicFgYODAgQghmDx5sjRfa9q0KZmZmWRmZqLRaKhVqxYNGzYkPT0dCwsLwsLCaNGiBQqFgrlz55KUlERiYiJ9+vThu+++o6CggPj4eHJzczl69Cg1atTA0dGxhDePjExFRQ66ZSoVnTp1QqfT0bt3b+kh/v777wMwceJEhBCsX7+e7777jpEjR7J06VJGjhyJs7MzXl5e9OzZk4yMDMlle/v27aSnpzNy5EgKCwv59ddfCQ4OxtnZmVOnTj1Ux6+//krjxo0RQhAXF8e2bduMfq8Gg4HWrVtjaWn51OY/p06dombNmlhbW7Nw4UIUCgWLFi16qrGuXr1KrVq1cHR0rPDpmZcuXSIwMJBq1arJzqUyJuH69es0atQIlUrF22+/Lac8VhB2794t9e/t27dvqcpsZEzHp59+ihCCixcvmlrKY9OvXz+sra3Jzs42ynhdunTB2dm5QpWyGAwGPvjgAwIDA1Gr1fTs2ZPdu3eXyLQrbgnm5uaGhYUFN2/eJD8/H0tLSw4dOkRKSgoajQYhBM7Ozuj1ej799FPS0tKIiopi6NChNGjQACEE1atXlwNumUqDHHTLVCru3btHw4YNpQeyEIL4+HgA+vbti1qtlvp4jxw5krfffpvAwEB8fHxYuXIlI0eOpEOHDlLQ2LZtWyZNmoS/v7/USqw4Bcre3p5t27Y9crL83XffERUVJdUMHjp0yGj3OmnSJIQQfPXVV091/k8//YSTkxPVq1fnt99+Ax4sWnh4eJCbm/tEY125coWIiAicnJwqvHlNTk4OERERuLm5VRjneZlnk4KCAkaMGCH5UsjpjxWDpUuXIoTAwsICFxcXsrKy5EWRSsa5c+cQQvDFF1+YWspjsXv3bmn31ljjCSF49913jTKeMTAYDAwZMgQhBLGxsQghOHToUImdbltbW4KCgqhbty7BwcGoVCpeeOEFHB0dCQgI4OWXXwYeGOkW9+n+ez148cfMzIwPPvjgiecyMjKmRA66ZSod9+7do3v37iUewFFRUfj7++Ps7MycOXMIDg5Gq9VK9dsdO3YkIiICd3d3Xn/9deBBrbiTkxNCCBwcHJg1axZffPEFn3/+OdOmTcPX1xchBJGRkY90+S4qKuKTTz6R6sm7d+/O2bNnS3WPq1evRgjBhAkTnur8zMxMtFotycnJXLlyRfr5n3/+iUqlYtasWY891uXLlwkLC8PZ2bnCt9u5c+cOiYmJ2NnZGXUBREamNCxbtgytVktCQgKXLl0ytZxnnoKCAgICAmjQoAFt2rRBCEHDhg35888/TS1N5gnw9vZm+PDhppbxnxQWFhIZGUlkZORT+7L8HYPBQGJiImFhYUYZz1gMGzYMIQTvvPMODRs2JDk5mcLCQikrUAiBk5MTDRs2JCoqCq1WKwXndevWBaBevXolstOuXLlCixYt+Pbbb1mxYgVNmzYt1WaEjIwpkYNumUpL8U6wEAJ/f3/Gjh2LjY1NiWNSUlKwsLAgLi6uRFuxLl26SDXOc+bMYcSIEYwfP56aNWuSmprK8OHD2bZtG6NHj8bZ2RlLS0syMzMfuRuSn5/P/PnzcXJyQq/XM2bMmKdKXTxy5AhWVla0atXqiVsPFRUV8eqrryKEoFu3bv+6s9a7d28cHR0fy1jsr7/+ombNmri4uEi75RWV/Px80tPTsbS0ZPfu3aaWIyNTgp07d+Lq6oqnp2eFNyB8FsjMzEQIwZ49e/j666/x8fFBp9MxadIkOSOhktCxY0diY2NNLeM/mTt3LgqFwmjvpc8++wwhBJs2bTLKeKXBYDCwbds2KbCeOnUqANWqVePll18mMzOTjz/+GDMzM2m+tmfPHrZs2YKzs7PUDlYIgaurK66urpLpbVpaGk2bNuX48eNs3bqVhg0bolQqWbx4sYnvWkbm6ZCDbplKS25uLjVr1pQe2M7OzgghJIOvoqIiNBqN5HpZ3FZsxIgR2NnZodfr8fb2Jjo6Gl9fXzp06MCKFSuYPXs2AQEB/0hnEkIQFBTEggULHhmw3rp1i3HjxmFhYYGdnR0zZsx47FZV169fJyAggNDQ0Cd2275z5w6tW7dGoVAwffr0hy4QnD17Fp1Ox8SJEx853qVLlwgJCcHV1fWhxnIVhcLCQtq0aYNOp+O7774ztRwZmX/l/Pnz1KlTBzMzMz755BNTy3mmKSwsJCgoiGbNmgEPnp9jxoxBrVYTHBzMDz/8YGKFMv/F/Pnz0Wg0FTrFODs7G2tra/r162eU8fLy8vD19ZX+3ZqSgoIC+vTpI3V/cXZ2Jj8/n6ysLBQKBa+88orUDqzYR0EIQbVq1bCxsSE6Ohq9Xs/GjRuxsbFBpVIhhCAtLY2xY8cybdo0Xn75ZYKCgqRNkrVr15r6tmVknho56Jap1Jw9exYvLy/pYa5Wq2ndujXJyckkJSUhhGDx4sXMmTNHaitWvJq6Zs0aRo4cKdV/d+3aVXro/9fH2dmZHTt2PFLbxYsXGTBgAGq1Gi8vL5YtW/bIVLDiNCw7O7snbjV0/vx5ateujYWFxWOlXQ0bNgxra2uuXbv2UO01atTAzc2NY8eOPZGW8sZgMNCzZ09UKpWcciZT4cnNzaVz584IIXj11VefOJtFxnhkZWUhhGDXrl3Szw4ePEh8fDxCCLp3716iPEemYrF//36EEGzdutXUUh5Kx44dcXJyMpph37Rp01Cr1SZdCC8qKmLdunVUr14dlUrF3LlzsbS0ZOzYsRQWFtKqVSt0Oh0NGjSQatj9/PzQarXSHKp169acPHmSunXrkpCQwPHjx8nLy6NOnTrExsbi6emJpaUlGo1GqumWWzDKVHbkoFum0nP+/HkiIyNLGGxcuXKFy5cvI4Tgyy+/ZP/+/cTExODv74+5uTkjR44s0VZs2bJl/zDrSEtL46233qJp06YEBARgbW1d4vd6vZ7vv//+P/X98ccftG3bFiEEYWFhrFu37l93oceMGYNSqXzilLE9e/bg5uaGl5fXY7fx+uuvv7CwsPjXViMXLlwgKCgIDw+PR9ayVwQMBoNkVJWZmWlqOTIyj4XBYODNN99EoVCQkZFRodyHnyUKCwupUaMGjRs3LvHzoqIi3n33XWxtbXFwcGDp0qWy0VoFpLCwEEtLSymluaKxefNmhBAsX77cKONdunQJKysrBg8ebJTxnpT8/Hxmz56Nn58fQggUCgWfffYZmzZtQgjB0aNHyczMJCsrC3t7e2xtbWnQoIHUDszb27vEHCo0NJQRI0aQmJgobQC8+OKLZGZmluhQUxp/GxmZioQcdMtUCQoKCvjyyy9JTk5GpVIRHx/PjRs3UCgUzJs3TzquV69eKBQKzpw5I7UVmzBhQgnn8mrVqpGens6JEyf4/PPPmTNnDgB3797l7bffllKdhBBYW1s/tvnO7t27SU1NRQhBampqid2V4h2XJzE4A/j8888xMzMjNjb2iVunvP7665iZmZVoX3L+/HkCAgLw9PSsFKZCxXX9f/9/LCNTWVi3bh3W1taEhIRUir+3qsgnn3yCEOJfM5cuXbpEp06dpGd2RS+zeRZp0KABzZs3N7WMf3Dv3j0CAwNJTk422oJNnz59sLOz4+rVq0YZ70nIycmhbt26JbIKu3fvDvz/NeZXr16V2oEVz5O+/fZbqR3Y1q1bUSqV/8gc9PHxwcHBAScnJ8nc9u+fAQMGyIteMlUCOeiWqXJ89tln6PV66tSpQ3JyMrVr15Z+16xZMxwdHQGktPKwsDDp4V6vXj0GDx5MWFgYubm5dO3ale7du+Ph4YFer//Hy0ClUlGjRg2OHDnyWNoMBgPr1q2TrtmmTRu+/PJL9Ho9Xbt2fewXi8FgkALOjh07PlVNW05ODra2tgwcOBB40ILF398fLy+vSpHGNW/ePIQQTJo0ydRSZGSemqNHjxIQEICdnV2FMEZ61igqKiI0NJRGjRo99JiNGzfi7++PRqPh9ddfr9A1xM8a48ePx97evsKVaUyePBm1Wm20jh8HDx5EqVTy1ltvGWW8JyE3N5eEhIR/zH/2799PVlaWlAUYEBAgtQMLCwsjIiKCpKQkAgICCAkJoUWLFsCDhS47O7v/LOOzsLBg5syZcsAtU2WQg26ZKsm+ffvw9PSUHt61atUiLS0Nd3d3YmNjpbZif+/3rVQqMTc3R6vVsnDhQl566SVpB9zR0ZHg4GDatGlDSkoKKSkpWFpa0qtXL+zt7Z+4/2ZhYSHLly/Hw8NDaqNx8uTJxzo3Ly9P2n2ZMGFCqV5Ib7zxBhqNhp9++gk/Pz+8vb0rRW/rDz/8ECEEI0eOlF/IMpWe69evk56ejkql4u2335b/TZczn3/+OUIItm/f/tBj8vLyGDt2LBqNBj8/PzZu3FiOCmUexsaNGxFCPPbCd3lw8uRJqYOJMTAYDDRo0ICAgADy8/ONMuaT8PcWrY6OjqSkpBATEyPVbxfvardo0aJEO7BWrVqhUCjw9fWloKCgxJhTp06lW7duxMXF/SPYtrW1Zf78+XLZjUyVQw66Zaos9+7dIzMzE3Nzc+Li4sjLy6N///7UqlVLOmbs2LHSg378+PGSw/mkSZOYOnUqQggCAwPJy8tj0aJFLFmyBHiQah4aGkpRUREXLlygR48eCCF48803H1tffn4+iYmJWFpaYmNjg4WFBePGjXuka/mlS5eIi4tDr9fz6aefPv2X8/+4c+cOjo6OWFpa4uvry6lTp0o9Zlnz1VdfoVKp6NmzpxycyFQZCgoKGDlyJEIIevToIbetKkeKiooIDw+nfv36/3ns0aNHpTKhTp06yX3XTczNmzdRKpW89957ppYCPAiQmzVrhpeXF7dv3zbKmF9//TVCCFavXm2U8R6XEydO0Lp1a2mOZG5uzr59+4iOjqZXr15S/XZUVBRBQUG0a9cOQGoHdvbs2RJZgdHR0dI7Oz4+nsuXLwNw6NAh+vXrh1KpJD093SQLCzIy5YEcdMtUeXbs2IFer6dJkybMmjULtVrN6dOnAUhLS5NeCufPn+f777+nbt26vPHGGyiVSiIiIqS0w379+rFlyxYAlixZQmpqKtWqVftHunnr1q35/fff/1NX//79pV3m69ev89JLL6HX63FycmLevHn/ePEcOHAAb29vXF1djdbv89SpU9jb2yOEYPPmzUYZsyz57rvv0Gq1tG3b9pFO8DIylZXly5ej1WpJSEh4Yp8Gmadn5cqVCCHYtm3bfx5rMBhYtmwZDg4O2NrasmjRogqX3vwsERERQbdu3UwtA4BVq1YhhGDVqlVGGe/+/ftSynZ5LjL//PPPODo6YmtrK81vhg8fTlZWFiqVih49ekjtwKysrBg/frzUPcbS0pLo6GimT59OYGAgr7/+OoGBgVIK+tixY5kzZw5vvPEGrVq1QqlUYmlpycsvvyy/12WqNHLQLfNM8O2330q7uTqdjj59+pCcnIyFhQVCCLRaLaNGjcLc3By1Wo2bmxvBwcGsW7eOgIAAUlJS6N27NwaDgSlTpqBUKtFoNLzwwgt88cUXbN68mTVr1jBmzBipVulRtdbvvvuu1M7s75w9e5YePXqgVCrx8/Pjk08+oaioiDVr1mBpaUmtWrU4d+6cUb6TkydP4u3tTbVq1fDw8KBt27ZGGbes2LVrFxYWFvJKuEyVZ+fOnbi6uuLp6cnevXtNLeeZoKioiIiICOrWrfvY51y5ckVKvY2Pj+fgwYNlqFDmYQwYMIDAwEBTy+D27dt4eXnRrFkzowXIc+fORaFQPHZnEmOwbds2LC0tiY2NlYLl4hT+Vq1aYWlpSe3ataWSuoCAAHr16oWjoyN6vb6Em3xMTAxXr17FYDDQsWNHkpKScHV1Ra/XY2VlhVqtpmnTpnIqucwzgRx0yzwzHD58mI4dO6JQKHB2dubGjRtSqzG1Wi29JN955x0UCgWTJ08u0VbswoUL1K5dW2pLVuwgevToURISEkhOTuaFF14gNzeX9957D3NzcxITE7l7924JHdu3b0ej0TBgwICHaj106BAZGRkIIaTa9Oeee447d+4Y5bs4ceIEXl5e+Pv7c+7cOT744AOEEOzbt88o4xubQ4cOYWdnR2JiotG+AxmZisz58+eJjo5Gr9ezYsUKU8t5Jvjqq68QQjxWK8i/s3XrVmrUqIFKpWL06NHyM6qc+fjjjxFCSOnKpmLMmDHo9frH9mf5L65fv469vT09e/Y0ynj/xbZt22jTpg0qlQo/Pz+uXr0quY1HRERI6eTu7u6o1Wrq1q0rtQMLDw+nZ8+eKBQKrKysSElJ4ddff2X48OFSFl2TJk04ceIEBoOBFStWoNPpyMjIkHe3ZZ4Z5KBb5plj586dmJubU7duXRo0aCCt4h44cACA3r17o1KpuHbtmtRWbOnSpTRp0gQhBM2aNSM6Oloab/DgwXzzzTfcvn2bxMREatasibu7O7a2tmi1Wnx9faXdqnPnzuHi4kJKSgr3799/pM78/HyaNm0q6WvUqJFRVrv//PNPPD09CQgI4Pz588CDetKgoCCaNGlS6vGNzfHjx3Fzc6NWrVrk5OSYWo6MTLmRm5tLly5dEELwyiuvyCnMZYzBYKB27dqkpKQ88U5lfn4+kydPRq/X4+Pjw9q1a8tIpcz/5fTp0wgh+Oqrr0ym4dChQ6jVaiZPnmy0MYcNG4alpWWZl5n8vRtK9erVEUKQlZUlLcYLIbCxscHe3p60tDSCg4NRq9XMmTOHvLw8lEolQ4YMQaVSERYWhlqtRqlU4ujoyPr160lPTychIYExY8bwzjvvEBISInkiyN4VMs8SctAt80zyww8/YG5ujq+vr/RScXNzIy0tDV9fX/z8/JgzZw61a9fG29ubWrVqYWlpSf/+/UlLS6NLly7SWPPnz+e5556T2makpaUxbtw4pk6dyvDhw3Fzc0MIQZ06dahRowZeXl789ddfj9R39epVUlNT0Wq1LFu2jJUrVxIYGIhCoaBLly5PbXj2xx9/4OHhQVBQEBcuXCjxu08//RQhBD/++ONTjV0WXLhwgWrVqhEYGPif35mMTFXEYDAwffp0FAoFzZs3l9Mwy5g1a9YghOC77757qvOPHz9Oo0aNEELQunVraWFTpuwwGAx4eHgwevRok10/OTmZoKAgowWRv//+O2q1milTphhlvEcxdOhQhBBMnDiRQYMG4ezszN27d3nuueek+ZGnpyeZmZl88803ODk50b59ezw9PYmNjSU8PJx58+ZJ412+fJk33ngDrVZbwu9GCIFCoSA1NZVvv/1WNkKVeeaQg26ZZ5a9e/eWCLotLCy4cOECgwYNIiwsDID9+/cTExODq6srQggiIyMJDw/Hy8uL7OxsRo0aJb1Y7O3tadGiBQcPHiQpKYnk5GQ++eQTCgoKWL16NbVq1UKlUpV4Of0bR48exc/PD0dHxxIBcEFBAYsWLcLV1RWtVsvw4cO5cuXKY9/vsWPHpFr17Ozsf/y+uKYxOTm5QrwMr169SkhICF5eXpw5c8bUcmRkTMq6deuwtramRo0a/Pnnn6aWU2UxGAzUqVOHpKSkp34OFqfPuri4YGVlxdtvvy2n0JYxbdu2JTEx0STXXrZsmdHNSFu0aIG3t3eZ9YTPz89nxYoVhIWFSQE3QFBQEAMHDpRSyf8eOCcnJxMdHY1Wq6Vbt25YWlqi0+mYPXu2NK8pXhT866+/iIyMZPPmzXzwwQe8+OKLKBQKunfvXib3IyNTGZCDbplnmsLCwhIp3LVq1WLEiBE4OzuXmHAFBATg4eFBUVGR1FZs4sSJtGnTBoVCQXJyMgADBw4kOjqaP//8k8LCQpKTk3nvvfdo1aoVSUlJODk5oVKpmD59+r+ml3/77bfY2NgQGhr60LqwO3fuMGnSJKysrLC2tmbq1Kn/qBv/vxw9ehRXV1dCQkIe2eKmuDXJN9988zhfX5lx69YtoqOjcXJy4tixYybVIiNTUTh69CiBgYHY2dmxadMmU8upsqxbtw4hRKl7cefk5NCvXz8UCgVRUVGyKV4ZMmfOHHQ6XbmnK1+7dg0nJyc6duxotDG/++47hBBl5uVw9uxZatasiRACJycnQkJCpPmOs7MzEyZMICMjg6KiItzd3aX50csvv0xKSgo1a9bk7NmzKJVKVCoVKpWKwMBArl27RkZGBomJicTFxbF582Z27dpF586dEULQvXt3efFJ5plGDrplnnn++uuvEjvexbvaGzZskI4xNzcnKSkJQGorNmXKFIQQBAcH8+KLLwIwfvx4qlevzt27dxkzZoy0SpycnEznzp3p1KkTUVFRCCFwd3dn8uTJUvA9f/58VCoVTZo0eawU0suXLzN06FA0Gg3u7u689957FBQU/OO43377DRcXF0JDQ/8zRdtgMJCQkEBUVJTJdrtzc3NJS0vD2tqaX375xSQaZGQqKjk5OaSnp6NUKpkzZ06FyEqpahgMBmJjY4mPjzfK97tz507Cw8NRKpUMHTqUW7duGUGlzN/Zs2cPQgh++umncr1uv379sLa2/tfssaehsLCQiIgI4uLiyuRv+9SpU7i7u+Pt7c2GDRtQqVQsWLCArKwsHB0dcXV1xdHRUWpTVly/XZwa7uXlxdy5cyksLKRZs2acOnWK2NhYlEoler2e5557jr59+9KtWzdpF93W1pZ58+bJzyqZZx456JaR4cEO0t9XdNVqNampqSQnJ0u9vKdOnVqirZiHhwe+vr5Ur14drVaLjY0N6enpODk5YWZmJvWeXLp0KRcvXqRhw4YkJCSQmZnJr7/+Sp8+fVCr1aSnp9OnTx+EEAwbNuxfA+dHceLECTp16oQQgho1avDVV19JL7fDhw/j7OxMWFjYYzu7fv/99wghWLly5RN/j6Xl/v37ZGRkYGZmVqFqy2VkKhKFhYWMHDlS2j2SzYiMz4YNG4ya9XP//n1mzJiBubk5Hh4erFy5Ug5CjMj9+/cxNzdn+vTp5XbN3bt3o1AopNZZxmDJkiUIIdi5c6fRxoQHJq6vv/46er0eNzc3zp8/z9tvv41Op+P69eu0atWKyMhIateuTfXq1WnYsCFRUVFotVqCgoKkuZG3tzd+fn6cOXOGqKgo0tPTqVmzJgEBAfTr148GDRrg4eEhBepKpZJDhw4Z9V5kZCorctAtI/P/OHv2LElJSdLLRalUsm3bNgBsbW154403pGPfe+89lEolM2bMKOFwPm7cOGrUqIFWqyUyMhJnZ2cOHjzIsGHD2LRpEwUFBcTExLB48WJ69+5NSkoKKpUKhULBpEmTSqV/3759kht7QkICy5cvx8nJifDw8Ceq/QZo2LAhNWrUKNdUsKKiIjp37oxGoymRZSAjI/PvLF++HJ1OR3x8fJk7HD9rGAwG4uLiiI2NNWpwfPr0aakdZPPmzTl9+rTRxn7WSUtLo2XLluVyrcLCQiIjI4mMjDTae/LWrVu4uLgYNVXdYDAwYcIEVCoVer2+REu8V199FR8fH6l+Oyoqijlz5qBWq7l48SJbtmzB2dmZw4cPS/Oi4k/Xrl3ZuXMnBoOBpUuXMn36dObOnUtwcHCJ49577z2j3YuMTGVHDrplZP4PP//8My+88AJqtRpra2t27txJWlqaVLcNMHnyZIQQnDx5ku+//56RI0cyd+5cOnfujE6n4+eff5bSuouKikhISODixYuMHDkSnU4n1Y/Xr1+f+Ph4LCwsUCqVZGRksH379lLp37hxo/Tis7a2ZseOHU/1HQgh+PDDD0ul5XExGAwMGDAApVLJZ599Vi7XlJGpCuzatQs3Nzc8PT3lmmEjs3HjRoQQrFu3zqjjGgwGvvzySzw8PKTd2f9qISnz37z22ms4OTmVSwbB3LlzUSgU7N6922hjvvrqq+j1eqMZhxoMBvr164cQgtdff53mzZtTs2ZNDAYDWVlZmJmZ4ePjg4ODA0lJSVhZWXHgwAHMzMyoXbs2VlZWREREsHHjRi5cuICjo+M/gm+NRoOlpeU/fq5QKP7TNFZG5llDDrplZB7CxYsXqVOnDmZmZjRr1gwhBFFRUaSlpREREYEQgmnTphEcHIxWq8XKygp3d3diYmKwtrZGo9EQFBREdnY2VlZW6HQ6qY/l0qVL+eyzzwgMDCQqKoo7d+6wePFiwsPDUalUpVod3r9/P/b29vj4+ODt7Y1SqaRXr15P3Lrmueeeo1q1auTn5z+1lsfltddek1fFZWSekgsXLhAdHY1erycrK8vUcqoMBoOBxMRE6tSpUyaB3K1btxg6dChKpZLw8HCjpxQ/a6xfvx4hBH/88UeZXic7Oxtra2v69etntDFPnz6NTqfjtddeK/VY9+/f5/PPPycgIAAhBIsWLeLatWsolUrmz59PYWEhrVq1wsPDA61Wy+zZs4EHhrEDBw5k8ODBKJVKJk6cyPXr14mOjgYe/HsdOXKk1P7rYZ/U1FSjOrnLyFQV5KBbRuYR5OXl8dJLL2FnZ4daraZLly4YDAapl+vfncDHjBmDEIJdu3YxduxYpk+fztKlSxk9erQUgH/33Xf4+PiwZ88erl69Sn5+PlFRUdy8eZN33nmHwYMHS7vUffr0+U9X8v/Lvn37sLe3JyoqiuvXr3Pv3j3mzJmDg4MDZmZmvPLKK+Tk5DzWWIcOHUKhULBw4cIn0vCkzJgxAyEEM2fOLNPryMhUZXJzc+nSpYvkMiy7BBuHzZs3I4Rg7dq1ZXaNvXv3EhUVhUKhoF+/fo/9jJYpSU5ODgqFgqVLl5bpdTp27IiTkxPXr1832pgdOnTA1dWV27dvl2qcH3/8EU9PT4QQ6PV6evToAcDBgwcRQrBjxw4pnTw0NBQhBDVr1iQ9PR0LCwvCw8N5/fXX8fb2xsrKiq+++oqYmBjJN6J4IWrBggU0adKEsLAwycOmffv2HD58uNTfhYxMVUUOumVkHoPc3Fx69OghGaoV1zh98cUX0jEZGRnY2tqydOlS6UU3d+5coqOjsbS05NNPP+WPP/7Azs5O6r35559/4uTkhIWFBSqVipCQEGJiYggICEChUGBra8uIESMea5d679692NnZER0d/Y9J240bN3j99dcxNzfH3t6e2bNnP5b5UpcuXXBzcyuzXqGLFy9GCGGU1X0ZmWcdg8HAjBkzUCqVNGvW7LG6IMg8GoPBQHJyMrVr1y7TtOXCwkLmzp2LlZUVLi4uZGVlyUZrT0HNmjXp1atXmY1fvAizfPlyo425Y8cOhBC8//77T3X+3bt3WbJkCXFxcahUKpKTk5k+fTpCCA4dOkRWVha2trZStp69vT1paWmEhYVRr149qlWrhre3N2q1mq1bt6JSqUhKSsLe3h4hBP7+/tSrV4/k5GTi4+OZP38+u3fv5oUXXkCn0+Hs7MzPP/9stO9DRqaqIgfdMjJPwPjx4xFC0KtXLyIiIoiNjZUczt3c3IiLi0Oj0RAREYGVlZVU6+Tj44OtrS1qtZrBgwdLtVUqlQq1Ws348eMZMWIEsbGxxMbGkpmZyYkTJxgzZgz29va4urqyb9++h+r6+eefsbW1JTY2lhs3bjz0uOzsbPr27YtKpZIMVIqKih56/PHjx1Gr1cyYMaNU39u/8emnn6JQKBg4cKA8uZSRMSLr16/HxsaGGjVqlHmq7bNAcUeHr776qsyvdf78eVq3bo0QgkaNGnH8+PEyv2ZVok+fPoSEhJTJ2Pfu3SMwMJDk5GSjvbOK29PVqlXribNTrl27xvDhw6WAunix7d69ezRo0IDk5GQplTwkJAQhBP369SMzM5NvvvkGJycnVq5ciRCCOnXqEBMTU2L89957j8aNG1O/fn0pdVyv16NQKBBC4OjoyLRp057YqFVG5llFDrplZJ6QRYsWSS85IQRHjhwB4MUXXyQhIaHEsS1btkSj0XDr1i3GjRtHu3btmDRpEl9++SVmZmbEx8djbW0NPGj9BZCfn0/NmjU5f/48b775Jt26dcPR0RG9Xs+CBQv+0VJs165d2NjYEBcX98iA++8cPXqUVq1aIYQgIiKCDRs2PHQS0bdvXxwcHIy6a7Z+/Xo0Gg1dunR5ZNAvIyPzdBw7dozAwEBsbW3ZuHGjqeVUetLS0qhVq1a5LRB+/fXX+Pj4oNfrmTx5crl4a1QFli9fjhCCa9euGX3syZMno1arjZpCnZWVhRCCLVu2PNF5x48fl2q2/97Oq7gkzcfHh1dffbWEM7mXlxdhYWE0bNiQ6OhotFotgwYNolatWiiVyhJB96ZNm2jatKk03zh27BhLly5lwIAB6HQ66tSpQ15entG+BxmZZwE56JaReQru3r3LO++8g7m5Of7+/ly9epVXXnkFR0fHEjVZ3t7e1KxZU0o5nzt3Lp9//jne3t7Ex8dz5MgRbGxsSoy9Y8cObGxsUCqVmJubSzvq3t7eCCHw8vJi8uTJ3Lp1i507d2JtbU1CQsJTBcU7duyQ2qTVq1ePPXv2/OOY8+fPo9Pp+N///vfE4/8b27Ztw8zMjBYtWsiOvTIyZUhOTg6NGzdGqVTy1ltvyRklpWDr1q0IIfjyyy/L7Zp37txhzJgxqFQqatSowdatW8vt2pWV48ePI4Tg66+/Nuq4J0+eRK/XM2bMGKONmZubi5eX1xO3OcvOzsbLy0sKtotNWmfNmkVWVhaOjo44ODjg6+tbIpV88uTJ6HQ6YmNjsbKywtfXl7Nnz6JSqSRncn9/f7755huqV69O7dq1SU1NpXHjxvz000907twZtVpNenp6qWvPZWSeReSgW0amFPz+++84OTkRGBjIF198gRCCyZMnSynnWq2WUaNGoVarsbS0lHa3hRD4+fmh0WhQKpUkJSXRoEED/P39EUJga2vLvHnzmDdvHklJScTGxvLyyy+zd+9eevTogV6vJyAgAAsLC5KSkrh169ZT30OxMVxx+ln79u35888/SxwzYsQIrKysuHr1aqm+r3379mFtbU3dunXlVXIZmXKgsLCQUaNGIYSgW7duj+XlIPPv1KtXj/Dw8HLPzjl48KD03ujevbuczvsIDAYDLi4uvPLKK0Yds1mzZnh5eRk12Jw8eTIajeaJSkD279+Ph4eHFHCHhITwyiuvoNfruXz5Mq1atSIyMpJq1apRt27dEqnkly5dQqFQ4O/vzwcffFAiM+/kyZNERUURHh4u7ZqnpaVRr149qlevLgXks2fPlhfLZWSeEjnolpEpJX/++SeBgYEIIbCzsyMxMVHaUXJ1dS2xQ/zpp5/i4eFBXFxcCYfzSZMmMWvWLIQQeHh40KRJE4ASKYWpqamsW7eOESNG0KRJE3Q6HRqNhvfee+8fKedPQ2FhIe+//z4eHh6o1WoGDRrEX3/9BcDly5extLRk9OjRTz3+sWPHcHJyIjo6ulSLBDIyMk/Ohx9+iE6nIz4+nosXL5paTqXkxx9/RAjB559/Xu7XLioq4t1338XW1hYHBweWLVsmZy48hFatWpGSkmK08VatWoUQglWrVhltzOzsbCwsLBg+fPhjHX/9+nUaN25cIp3c09OT7OxsXnzxReLj40ukkrdv3x57e/sSqeSDBw/GxsYGIQTTp0+nefPm0gLOqVOnaN26NQaDgZ9++okhQ4bQrl07vLy8UCqVvPnmm3IpmIxMKZGDbhkZI1DcFzMsLAwhBG+++SYAERERdOzYUTruyy+/lHac/u5w/t5776FWq3F2dubgwYNkZGRI5xgMBj766CPs7OwQQuDu7k5aWhr169eXgn1PT08mT55sFJfx3Nxcpk2bho2NDZaWlkyYMIHbt28zbtw49Ho9Fy5ceOIxz5w5g5eXF6GhoaXeLZeRkXk6du/ejZubGx4eHv9aSiLz3zRs2JCaNWuaLAC5dOkSnTp1QghBWloaR48eNYmOiszMmTPR6/VG2ZG9ffs2Xl5eNGvWzKiLHD169MDBweGx2o6dOHECf39/7OzsaNCggRR0L1y4kKysLLRaLQ0aNMDT0xMHBwe8vLz44YcfEEIwbdo0rKysMDc35/PPP5d2sYUQWFlZkZWVRVZWFomJiTg7O1O/fn3y8/NZuXIlMTExaLVakywyychUReSgW0bGyAwcOBAhBBMnTmTSpElotVri4+NJS0sjNTUVIQRqtVpyOLe2tmbo0KEoFArMzMykVPRjx47RrFkzrKysEELg7OzM6tWrJYfT9PR0Ro4cyb59++jZs6e0i2WsoPbatWuMHDkSrVaLi4sLs2bNwtbWlv79+z/ROJcuXSIgIIBq1ao9VcAuIyNjPC5cuEBMTAx6vZ6PP/7Y1HIqHcXtnT799FOT6ti4cSP+/v5oNBrGjh0rl+v8jZ07dyKEYPfu3aUea8yYMej1ek6ePGkEZQ/45ZdfUCgUzJs376HHGAwGduzYIdVR29racuDAASwsLBBCYGlpSU5ODq1atcLe3p7q1aszd+5cli5dipeXFwaDgdDQUCkb7s6dO6SmphIbGws8yHwxNzdHCEF4eDgDBgxg9OjR9OrVCxcXF4QQJCQk8OOPPxrtvmVknnXkoFtGxsgYDAYmTpwo7UAXG5zAg7opIUQJN+GPP/4Yc3Nz+vTp84+U8169eqFQKBg/fjzOzs7s3LkTgO3bt5Oens7QoUPJzMykZcuWhIeHo9frsbOzY+HChZKLaWk5ffo0L7zwAgqFAgcHB5RK5WO3scnJySEiIgI3NzfJnV1GRsa05OXl0bVrV4QQvPTSS0/cquhZp3HjxoSEhJj8e8vNzWXs2LFoNBr8/f3ZtGmTSfVUFPLz89Hr9cyePbtU4xw6dAi1Ws3kyZONpOzB/KBu3boEBwc/dCf+xo0bpKenI4TA1dUVIQSbN2/m7Nmz0i73c889J6WTe3p6olQqSU1NpWbNmuj1egYPHkyXLl2kFqeFhYUkJibStGlTjh8/zq1bt0hISODbb7+lTZs2RERE4OHhgVarJTAwkP379xvtnmVkZB4gB90yMmXE3r176d69OyqVCisrK3777Tdu3bqFEIL58+dLxxXXco8bN65EyvmkSZMQQjBnzhxOnjyJu7s7Bw4cAKBNmza0b98eMzMzhBAkJyfTrVs3unfvTlpaGgqFAltbW0aMGMGdO3eMcj8HDhygUaNGUn/O77///pHH37lzh4SEBOzt7Tl06JBRNMjIyBgHg8HAzJkzpd6+j9tuUOZBmr4QgqysLFNLAeDIkSNSFlWnTp24dOmSqSWZnOTkZFq3bv3U5xsMBpKTkwkKCjKq+eBXX331SHf1PXv2UL16dWxsbPjyyy9p1qwZkZGRGAwGpk+fLgXd1atXR6vV8vbbbxMREYFer6dPnz5Uq1YNrVbLgAEDUKlU0hzB29sbS0tL1q1bR1JSEvHx8dLi/8WLFxk/fjxqtZpmzZrJ7elkZMoIOeiWkSljTp06hY+PDy4uLuzdu5f09HRCQkIkh/PatWsjhECj0ZRIOW/WrBl2dnZYW1ujVqtxcXEhOzubmJgYdDodCoWC4OBgjh07xvjx46lZsyapqakMGzaMxYsXExUVhUqlwt7enj59+rB+/Xqj1CEOGTJEevE3bdpUWgj4O/fu3aNRo0ZYWloaJcVPRkambNiwYQM2NjYEBwc/kYvys07Tpk0JDg42+W53MQaDgaVLl+Lg4ICtrS3vvvvuM2189dJLL+Hq6vrUddjLli2TdpiNRX5+Pv7+/jRs2LCErvv37/Ppp5+SmpqKUqnE0tKSgwcPcu7cORQKBe+99x6FhYUljNRq1qxJ7969mTdvHlFRUXTv3h29Xs+4ceOYN28e9erV48KFC+zdu5eIiIgSqeSTJ09m4cKFzJo1i3bt2qHRaDAzM2PUqFFGMWWVkZH5d+SgW0amHLh06RLR0dGoVCqp9UuxkVHxynexUzjAokWLUCgUvPXWWyVSzv/3v//h4OCAlZUVr732GtWrVwdg/PjxfPrpp0yZMkUySfm3T/Xq1Zk+fXqp2p7k5+fj4+NDbGws/v7+KBQKXnzxRc6cOQM8cEFv06YNOp2OLVu2lOJbk5GRKQ+OHTtGUFAQtra2fPvtt6aWUyn4+eefEULw0UcfmVpKCa5cuUL37t2lmtyDBw+aWpJJWLNmDUKIp6rFvnbtGk5OTiVMUI3B7NmzUSqVJTK//vrrL2JiYhBCEBkZiRCCzz77DIDNmzcjhOD48eNkZmby4YcfolQqpUX64OBgatSogbW1NV27dkWn0+Hj48P06dNJTU0lJyenxHWSkpJo3rw5dnZ2KJVK1Go1ZmZmTJky5bEM3WRkZEqHHHTLyJQTubm5zJ8/nxo1aqBSqahduzZ37tzhp59+QgjBtm3bpGNHjBiBEIIFCxaUSDnv378/Qgiio6MJDw/HzMyMNWvWMGTIEHQ63UOD7f/7CQsL4+zZs099L0uXLkUIwc6dO1mwYAHOzs7odDpGjhxJ586dUalUrF69utTfmYyMTPmQk5ND48aNUSqVzJ49W25H9RhkZGQQEBBQIXcHf/jhB4KDg1Gr1YwZM8ZoZUaVhatXryKEIDMz84nP7devH9bW1mRnZxtVj62tLX379gUeLF6/9957ODk5SX4t3bt3x9vbm8LCQrKysrC2tkYIQevWraVUcicnJ+k97uzsLC18X79+XaoDF0IQHByMwWDgjTfeIC0tjaZNm3LixAkKCwtZs2YNPj4+uLm58fvvvxvtHmVkZB6NHHTLyJQzBoOBxYsXo9PpSE5O5vLly3h6etKiRQsp5TwoKAhLS8t/pJyHhITQqFEj4uPjsba2xtnZmb179/4j4G7SpAlfffUVffr0IS4ujtDQUOrXr1/iGG9v76eu/SsoKCA4OJj09HTgQVuV8ePHo9FoEELQvn17o7Qvk5GRKT8KCwsZNWqU1NbQmLWsVZF9+/YhhGD58uWmlvKv3Lt3j0mTJkk7oA+rI66qBAcH069fvyc6Z/fu3SgUCubOnWtULYMGDcLa2ppDhw7x6quv4uzsjFKpxM7Ojj///JPbt2+j1+uZMmUKhYWFtGrVCn9/f4QQvPrqq1IqeUhIiPQOL/ZtqVu3LgAJCQmsXr2aoKAghBD4+fkxY8YMPvnkEz7++GMmTJiAu7u7lAVRnJ0mIyNTPshBt4yMidi+fTv29vY4OjqSnJyMmZmZlA42a9YsLCwsShxfbKy2du1aKeX8/fffl16ixenjTk5OnDhxgs8//5w5c+aQm5vLsmXLpBS2v3/s7OxYsWLFUxmnFPf83Lp1awl9KSkpqNVqPDw8eP/99ytMzaOMjMzj8eGHH6LT6YiLizPqbl9VpGXLlvj7+1fI3e5i/vzzTxo2bCjtmp4/f97UksqFHj16EBYW9tjHFxYWEhkZSWRkpFHfW0eOHEGlUjFs2DA8PDywtramQ4cOJVLJf//9d4QQ/PDDD5IreXh4OGq1mvr16xMaGiqlkv+9hMzS0pKJEycCkJiYyLVr1zAYDDRq1Ii0tDRpIVwIgVKpRKvVymVfMjImQilkZGRMQmJioti3b5/o3Lmz+PXXX0V+fr7o16+fMBgMwtXVVdy9e1ecPn1aOv6PP/4QOp1OXL58WVy4cEGMHj1a7Nu3T2RnZwshhKhevbpYtmyZuHfvnnBzcxNr1qwR27dvF9bW1qJbt27Czs5OfPLJJ2Lnzp1ix44d4sMPPxShoaGiY8eOws/PT+zZs+eJ9D///PMiMjJSvPbaa2Lu3Lli7NixYvLkyWLr1q3i6NGjIjExUfTs2VNERESItWvXCsCYX5+MjEwZ0bVrV7Ft2zZx5swZER0d/cTPhmeJ//3vf+L48ePio48+MrWUh+Lv7y++/fZbkZWVJbZv3y5q1Kgh5s2bJ4qKikwtrUxJTEwUhw8fFjdv3nys4xcuXCh+/fVXsWjRIqFSqYymo0+fPkKv14t33nlHODg4iGPHjglra2vh7u4uWrVqJVasWCFiY2OFEEJMmzZN9OzZU1y5ckVoNBrRqlUrce7cOeHo6CgKCwuFQqEQP//8s7CxsRFCCHHnzh0xfvx40blzZ/H888+Lxo0bi6SkJGFtbS2io6OFlZWVpEOlUolNmzaJunXrGu3eZGRkngBTR/0yMjIP2msNGDBAMiW7cuUK5ubm9O7dW0o59/X1xc/Pr0TKuVqtllax9Xo9arUaX19fsrOzpXowW1tbEhMT2blzJ+PGjSM1NZXU1FSsrKzYsmULkyZNwtvbG41GwyuvvMKVK1ceW/f69eul648cOfIfdaA///wzdevWldqa7dixw9hfnYyMTBlx4cIFYmJi0Ov1fPzxx6aWU2F5/vnnqVat2kP7LlckcnJy6NevH0II6tSpw759+0wtqcw4duwYQgi++eab/zy2+J35pOnoj2LLli1SOrher8fPz4+rV69SUFCAhYUF48ePl1LJQ0NDEULQr1+/Eq7k33//vdQpZN68edLYp06donr16o/t42JpacmGDRuMdm8yMjJPjhx0y8hUID766CM0Gg3VqlUjJiYGd3d3KW1xzJgxkls5PJgkKBQKhBC4u7vz2muvSS7ngwYNQqlUkpaWxqFDhwgLC2PJkiXSud999x02NjZoNBqpp7eVlRVCCHQ6HV27dn2sVl+rVq1CCIGDg8ND0/EMBgMbNmwgPDwcIQTPP/88x44dK+U3JSMjUx7k5eXRtWtXhBC89NJLcrnIv3DgwAGEECWesRWdHTt2EBYWhlKpZOjQody6dcvUkoyOwWDA0dGRsWPH/uexHTt2xMnJqVQu3kVFRWzcuJGOHTtSvXp1lEolsbGxTJ06tUTwf+XKFYQQrFq1Skolr127Ni4uLkRGRpZIJR80aBAODg6oVCo8PT1ZtGiRdL0JEybQsGFD7O3tHxpsazQaOnXqxG+//fbU9yUjI2Mc5KBbRqaCsX//fl544QUpIB46dCjwwL1cq9Vy8eJF4EHgXPxibdSoUQmX85SUFOzt7Vm4cCEnT57Ex8eHLVu2YDAYGDdunLQDPnv27BKTjCtXrjB9+nSqVauGEII33njjoS7GmzdvRqvVkpaWhhCCzz///JH3VVRUxIcffoi3tzcqlYq+ffvK9aIyMpUAg8HAzJkzUSqVNGvWjBs3bphaUoWjTZs2+Pr6PpU/hqm4f/8+06dPx9zcHA8PD1auXFnlXOtbtGhBvXr1HnlMcWuupzXEKyoqYuHChQQEBEjvZIVCQY8ePSgoKKBz5874+flRVFREVlaWFCTXrVtXciWPiori9ddfR61W4+3tjb+/Px4eHgDY2tqi1WpRKBTY2NhIi9bx8fFcvnyZ3Nxcli9fToMGDXBwcEAIQWhoKFOnTn1qs1QZGRnjIwfdMjIVlCtXrtCuXTuEEAwbNowLFy6g0WgYOnQoycnJ1KxZU3rBq1QqKeXcyspKShW3t7dHrVbj4OBAdna25IZqbm4utVI5evQoCQkJJCcn06lTJ95//30aN26Mh4cHarWagIAAFixYUGInZNeuXVhYWNC4cWPy8/NJT08nODj4sXbB8vLymDVrFvb29pibm/P6669z8+bNMvseZWRkjMOGDRuwsbEhODiYP/74w9RyKhSHDh1CoVCwePFiU0t5Yk6fPk3z5s0RQtC8eXNOnz5taklGY9q0aVhYWDzU6O7evXsEBgaSnJz8VAsO+fn5dOrUqcTuskqlomnTphQWFmIwGNDpdCVcySMiIhBC0LFjxxKp5GfPnkUIQb169UqkksfExHD27Fkp48TMzIyBAweybNkyPvnkE+bPn09ycrLURuy/FsBlZGRMgxx0y8hUcBYsWIBSqaRatWrUqlULf39/CgsL+eabb6SX/GuvvSYd37VrV5RKJX/99Zfkcr506VLphT158mQCAwNp1qwZAIMHD2bNmjWMGTMGrVYrvfT79OlD3759adSoESqVCktLSwYNGsTOnTuxs7MjMTGRu3fvArB3716EECxbtuyx7ysnJ4eXX34ZvV6Po6Mjc+bMkVsUychUcI4dO0ZQUBC2trZ8++23ppZToWjfvj3e3t6Vare7GIPBwMqVK/Hw8MDc3JwZM2ZUihr1/+LHH39ECPHQ2vXJkyejVqs5fPjwE4+dn59PSkpKiYC7uDb70KFDZGVlSTvPycnJWFpa8uKLLxIVFUV0dDTVqlUjJCQErVaLXq9n8ODBUhmWq6srv/76KwDDhw9n8+bNAKSlpTFgwADc3NxKXLdGjRpP3YlERkamfJCDbhmZSsCePXtKpJwPGjSI3377TXrhRkVFScc2bdoUZ2dnli5dWiLlPDw8nLi4OD777DP69u1LRkYG8KA9WVBQEHq9nsDAwH9MpLOzsxk5ciRubm5SDblOp+PFF19k//790nHPP//8U6VXnj9/np49e0oLCx9//DFFRUVP+U3JyMiUNTk5OTRu3BilUsns2bOrXEry0/Lbb7+hUCh45513TC3lqbl16xZDhw5FqVQSHh7Ozp07TS2pVOTl5aHVav+17/bJkyfR6/WMGTPmica8ePEi48aNk8xKi43SVq1aRWpqKikpKdKudnEQvWDBAmrVqiWlki9duhQhBO3btyc4OBgvLy8AhgwZgq2trZSRduLECS5dukTjxo1JSEhg/PjxwIOF7pYtWyKEYNasWaX+nmRkZMoeOeiWkalEXLlyRUpl69OnD5GRkdJLv1atWqSlpeHu7k5MTEwJl3NLS0uEEMyfPx8HBwdsbW2JjIzk9OnT0gtep9ORnp4OwMGDB4mOjsbR0RGlUvlIV9S4uDi2bNkiTTgXLFjwVPf222+/0aJFC4QQ1K5dm02bNhnzq5ORkTEihYWFjB49GiEE3bp1k7NU/h8dO3bE09Oz0n8fe/fuJSoqCoVCQb9+/cjJyTG1pKcmPj6e9u3bl/iZwWCgWbNmeHl5cfv27cce6+eff8bZ2RkLCwvp3VlsilZYWIhCoWDhwoWSQVpUVBQajYZ27dqVSCXPzc3Fzs4OW1tbOnbsWCKd3GAw8Oabb6JSqRBC0KRJE6ZOncrcuXOZOHEitWvXRgiBt7c3n376qdG+JxkZmbJFDrplZCohS5YsQaVSYWFhIb3009PTKSgoYMCAAYSFhZU4vk2bNmi1Wu7cuVMi5bw4yJ0zZw7Hjh3Dx8eH9evXk5SUJKXF/d0YxtXVFU9PT/6/9u47LKpr+xv4mj5Mp/feQVCkSZFmA2zYjQU7omIlYoktGjWWqGA3KpbEEnvHbowVjcYeewyCXcGCSJnv+4c/9utcc3PvTVSSuD/PM38wzJzZ58wwnHXW3mvJZLK31rAtXLgQycnJsLKyYtPO/4gffvgB4eHhICLUq1fvH93ShuP+7pYvXw6ZTIZatWrxwoh4XSNDKBT+4YuPfyXl5eXIzMyEWq2GpaUlVqxY8bec1ZCeng47OzuD+yo7b2zYsOE/Pv/Zs2eYP38+/Pz8IBaLERwcjHXr1rH/f9HR0W9NJX+zQFrLli1hZGQEhUIBuVzOppKnpaWBiODh4YHMzEwAYPVN7t27h+rVq2Px4sWoVasWTExMIBKJIBaLUbNmTWzatIl3EuC4vxkedHPc39Tly5fRp08fNuWbiNChQwfMmzcPAoEAly9fZo9NTEyEubm5wZTzzMxMODo6wtLSEtWrV0dISAiMjIwwZswYg22KxWJ06dIFly5dQrNmzRAREYGxY8fi888/h7m5uUHw3aFDB4hEIkyaNOlP7Zter8eGDRvg5eUFIkK7du1w48aNP7VNjuPej+PHj8PGxga2trbIzc2t6uFUuQ4dOsDGxgYvX76s6qG8E7dv30aLFi1Yp4xr165V9ZD+J+vXrwcR4ddffwXwOoi2t7dHw4YNf/ciQnl5OUaOHAmNRgOBQACVSoUaNWrg2bNnrEYKEWHFihUGBdI6duz4m722hwwZghkzZkAul+PVq1dwdXVla7O1Wi02b96MRo0aISIiArVq1cLevXtRVlaGDRs2ICIiAiKRCIsXL/5Qh43juHdMAADEcdzf1tatWykpKYkqKiqIiMjNzY0KCgqoZcuWdPPmTRKJRHTt2jUyNTWlixcvko+PD924cYP0ej29ePGCsrKyaOXKlXT16lXS6XRUXFxMBQUFREQUFBREZ8+epa1bt9LFixdJqVSSk5MTtW3blh49ekQmJibk4+NDcrmc7t69S+fPnycjIyMCQJcuXSInJ6c/tW/l5eWUnZ1No0ePpocPH1Lv3r3ps88+I3Nz8z972DiOe4cKCgqoWbNmdPbsWVq0aBG1a9euqodUZa5cuULe3t40Y8YM6tu3b1UP553Ztm0b9enTh+7du0cjRoygwYMHk1Qqreph/Uf37t0jKysrWrlyJbVt25aGDBlCWVlZdPHiRXJ2dn7r8SUlJbRjxw4aN24cnTlzhtLT08nV1ZVSU1Pp9OnTVKNGDYqMjKTDhw8TEdGiRYvIyMiIvvrqK7px4wa5u7vTixcvSK/XU35+PiUnJ9OBAweoqKiIevbsSceOHaN58+ZR06ZNyczMjC5fvkx3796lkpIScnR0pLi4OFKr1fTs2TPKycmhO3fuUGhoKI0fP57q1KnzoQ8fx3HvShUH/RzHvQPr16+HXC43yDprtVrW0zsjIwO2trYGV/Vbt24NmUyGiooKjBo1CpMnT8bAgQPZ85VKJaKjo2FjY4OzZ8+idevWGDFiBIgI9vb2SEtLeyuTc/nyZaSlpcHIyAjGxsbYv3//O6mm+uLFC4wfPx4ajQZqtRpffPEFnj9//qe3y3Hcu/Py5UskJyeDiJCRkfFRT39NTk6GtbU1iouLq3oo79Tz58+RkZEBkUgEb29vfP/991U9pP+Km5sb0tLScO7cOYjFYnzxxRdvPebmzZsYMmQIzMzM2CyvLVu2AADq1KmD8PBwAMCKFSvYemsiMphK3r9/f8jlcri4uMDR0RHu7u4AgG7durEZZMHBwQavm52djZkzZyI3NxfdunVDcHAwtFotpFIpmjVrxpdYcdw/BA+6Oe4fIjc3F9HR0QbrrP39/fHw4UM2ve3NyuTNmjWDsbExsrOz0bRpU4SEhECtVrPnq1QqSCQSqFQq3L59G8bGxqyVSUpKCubPn4+DBw/Cx8cHlpaWOHv2LFJTUw3WmRMRTExMkJGRgevXr//pfXzw4AEGDBgAiUQCKysrzJs379/2X+U47sPT6/X46quvIBQKkZiYiMLCwqoeUpW4evUqRCIRZsyYUdVDeS/OnDmDWrVqgYjQpUsXPHz4sKqH9Ls6deqEgIAA1K5dG56enigpKUFZWRnWrVuHPn36ICIiAmKxGGq1Gp988gmIiPVcv3//PogI2dnZrCr5m//nunTpwqaS//zzzyAidO/eHZMmTTIIsI8ePQpTU1OIxWL069cPt27dMhhjfn4+xowZA2tra+h0Ouzfv/9DHiKO494zHnRz3D/MhQsXkJaWBicnJ0gkEjg7O2PdunXw8fFBXFwcateujZiYGLi4uMDe3h4SiQTh4eGoXbs2uxKvUChQu3ZtREdHw8TEhGXAO3fujKKiItjY2GDNmjUoLCzEgwcPWEBubW2N0aNHY//+/cjNzcWePXswcOBA6HQ6CAQC9OvX751kv27cuIH27duDiODp6Yn169f/LQv8cNw/VU5ODrRaLby8vAzqS3xMunTpAktLyz9VWPKvrKKiAvPmzYNOp4OZmRmWLFnyl/0enj9/Pvv/tmHDBnz++eewsbExuEDcqlUrPH/+HF27doWDgwPKy8uxYsUK9v8tPj6e9dquzIZXXuBWq9XQaDTo27cvmjRpAoVCgYyMDISEhAAAq2Z/8+ZN2NjYQKVSQSgUws/PD+Hh4fD29oZIJIJCoUBKSgquXr1alYeL47j3gAfdHPcPdu3aNURERLDp5iKRCHv27AEAzJo1CxKJBPn5+QCAW7dusZOIpk2bAnh9omBnZ4dmzZpBJpPB2dkZtWrVglQqxcmTJ9GzZ0/WqzQtLQ2lpaVYsGABQkJCUKtWLUyePBn5+fkYMWIEvL29IRaLYWVlhdTU1HcyZe7UqVNo0KABa1128ODBP71NjuPejcuXL8PT0xM6nc5gls3H4vr16xCLxf/4Psp3795lrSxjYmJw6dKlqh7SWw4fPgwiQmhoKFxcXAyCbaFQiNatW6OiogKPHz+GXC7H+PHjWVa7sqDnpk2bWK9tT09P9nx7e3tUr14dgYGBAIABAwZAJpNBIBCwoLtnz56Ijo5GWFgYZs+ejadPn2L+/PmssrlWq8WXX3750c4M4biPAQ+6Oe4jcOrUKXTr1g1yuRxKpRL79+/HgwcPIJPJkJaWhtq1ayMkJMTgJCIwMBAqlQrW1tYwNjZGz549YWNjA4lEgqCgIIwbNw6tWrWCQqGAu7s7qlevDuB1Flqv1+PSpUswNTWFUCiEUqlEo0aN0LFjR7Ro0YJlGIKDg7F8+XI8fPjwT2XA9+zZw3qXNm7cGOfPn39HR47juD+jsLAQCQkJEAqF+Oqrr/6ymdD3pVu3brCwsPgoalDs2rULrq6ukEqlGDly5F+qentKSgqICBKJxCDYdnV1hbGxMZuNcODAARARLl68yHpt+/n5sQvLb1Ylr6xWTv/XM/tNM2bMgJWVFYgI4eHh+Oabb/DgwQO8evUKDx8+xOrVqxEZGQkiQmBgIKu/wnHcPxcPujnuI/L06VPUqVMHEokE3bt3R8OGDeHi4oKysjLk5+ezE4iEhAT2nNGjR4OIcOrUKQDA48ePYW5ujhkzZoCIsHjxYvj7++OTTz5hz/nhhx+g0+kgl8sxceJEg6v3xcXFWLRoETw8PAyyDRKJBElJSdi9ezcqKir+532rqKjAypUr4eLiAqFQiK5duyIvL+9PHC2O496F8vJyZGRkgIjQqVOnv1Qw9r7dvHkTYrEYU6ZMqeqhfBDFxcUYMWIEJBIJ3NzcsHv37iofz4ABAwwKnxER/Pz8cO7cORgbG2Pw4MEAXhdIq5y51aJFC4MCaTVq1ICDgwPrta1QKFC/fn2DbS5atAh6vR67d+9GYmIiXr58iXXr1qFOnToGj6u8+fr6YtWqVe+k2CjHcX99POjmuI/Mq1evMGHCBNjZ2YGIIBAIkJKSgrKyMpiamrIA+N69ewCAkSNHgoiQn5+P06dPIzg4GDKZDMnJyTAzM2PP8fb2RkFBAdq2bQuRSAS5XI6oqCgAwPbt2xEeHg4XFxdIpdLfPAF58+bp6YkDBw784f3LysqCmZkZ5HI5hgwZgsePH7+z48dx3B+zfPlyyGQyhIaGoqCgoKqH88GkpKTAzMwMz549q+qhfDAXL15EVFQUiAjt27fH3bt3P+jrFxYWYu/evfDx8YFIJGJZZSKCh4cHHj58iLVr14KIcP36dTaV3M3NDUSEkSNHGmS158+fz3ptT5kyBUqlEnq9ns2wqrz5+/vDzMwM/v7+qF27NmJjYzFr1iy4uroaPK5z584f9HhwHFf1eNDNcR+psrIybNy4EWFhYawC64ABA9hJgZOTE2JiYthJRXx8PFuT1r9/f0gkEvTo0QNxcXGs0nlqaipCQkLg7u6O8PBw+Pn5AXi9NvzNdmSVN29vbzRq1Ajx8fFsKl7lTSwW49tvv/3D+1dUVISRI0dCoVDA2NgYU6ZM+agybBz3V5SbmwsbGxvY2NggNze3qofzQdy6dQsSiQRffvllVQ/lg9Lr9cjOzoapqSl0Oh3mz5//h2Yx/S9yc3PRqVMnSKVSiEQimJqa4sSJE4iPj2f/WwYPHgwzMzNkZmZCIpEgLCwMPj4+mDlzJqpVqwYigrGxMRQKBRwdHaHRaJCamgqRSISAgABkZmaiUaNGePDgAcrLy9GpU6f/eCH5zdvgwYPf+3HgOO6vhwfdHMdh2bJlrD1Y5YmBTqfDxYsXcfToURCRQfuSZcuWgYiwefNmAP+/4NqUKVNARJDL5QgMDISFhQUKCgoQGhpqcNLRpEkTHD58GHq9Hj179kSLFi1w9OhRxMbGQiwWGzy2Zs2aWLdu3R9uDXbnzh12wuTg4IClS5d+1P2DOa6qVX4nyGQyfPPNN1U9nA8iNTUVpqamePr0aVUP5YN78OABunTpwtY3nz179p2/xvPnz9GsWTMQERwdHREaGgq1Wo2zZ88aFAl1dHREUlISAgICMGnSJAiFQhQXFyMiIgI9evRAYGAg1Go1wsPDMW/ePLi5ubECaZVVzDUaDTw9PXH58mWsXLkSERER0Gq10Gq1vxts165dGxs2bHjn+85x3N+DkDiO++h17NiRrly5QmlpaSSVSomIqLCwkOLi4qiiooIcHR1p6tSpFBUVRbGxsbRgwQIiIpo8eTIFBQWRmZkZ6fV6OnHiBCkUChIKhXT27FkSCoU0dOhQOn78OHstuVxO3333HYWHh9OtW7foxo0bdODAAQoLC6Pr16/TqFGjaO3atbRx40aaO3cuSSQSatGiBTk5OdG+ffv+532zsrKiuXPn0sWLFykkJIQ6depEAQEBtH37dgLwbg4gx3H/NWtrazpw4AC1bduWOnToQEOGDKGKioqqHtZ7NXz4cHr27BnNmjWrqofywZmZmdHixYvpwIED9PjxY6pZsyYNHTqUiouL/9R2Hzx4QJMmTSIfHx8yMTGhnJwcWrVqFf3444909uxZysjIID8/P7p48SJ7jp+fH7Vu3ZqEQiGVlpaSXq+n5cuXU2pqKp07d46IiMzNzenIkSN09+5d0uv1lJOTQ0REHh4etHLlSiopKaH8/HzavHkzNWzYkA4dOkSFhYVUWFhIu3btolq1apFMJiOxWEwRERE0YMAAOnPmDB08eJCSkpL+1D5zHPc3VtVRP8dxfy0PHjx4a/2Zs7Mz5HI5Hj58CAC4ffs2iAhbtmxhz1u9ejWUSiUrSlNZcK1hw4ZsO/3794e7uztWrlwJAOjQoQMsLCwgl8uxcePGtzLQer0eBw4cQEJCAnQ6HaRSKVxdXdGtWzecOHHiD+3fsWPH2FrDmJgYHD9+/A9th+O4P0ev12PatGkQCoVITEz8x7dL6tOnD4yNjVFUVFTVQ6kyJSUlGDduHGQyGZycnLBt27b/eRvFxcXo2bMnpFIpa2VpZGSEY8eOAXhdOVwsFuPOnTtYsWIF1Go1+x9kZGSE2NhY+Pn5Yd26dSxzrdVqIZPJoNFoYGVlBXd3d5iYmEAul+PKlSsAgKSkJFy7dg379u2DiYkJhEIh1Go1oqOjkZCQgJCQEIjFYhgZGaF79+64cePGOz12HMf9vfGgm+O4tzx8+JD19668CYVCNG7cGOXl5SgvL4e1tTV69OjBnpOTkwOJRIJJkyYZFFyrrAYrEAggFothYmICPz8/7Nu3D1KpFFKpFFqtFmvWrAEAZGdnw83NDb6+vmy6nqenJ1JTU5Geno4ePXrA3t6etRzbu3fv/7x/er0eW7duZev3WrVqxU6sOI77sHJycqDT6diU3X+q27dvQyaTYdy4cVU9lCp39epV1KtXD0SEli1bIj8//3cf/+LFCyxevBhNmzaFsbExZDIZJk2ahNzcXBARFixYwB4bGRmJpKQkVhztzb7cTZs2xaFDh2BmZoYLFy5ALpfDy8sLer0eGo0G/v7+OHnyJGxtbSEQCCAQCNCiRQsAwIULFxAZGYmwsDDs2rULv/76Kz777DPWOszd3R3Tp0/nhTs5jvtNPOjmOO43lZSUICsrC15eXuyERSAQoFmzZiguLsbo0aMhl8sRHh6OmJgYxMfHQ6vVwsfHhxVcS0pKYs+1sLBArVq1oNFosHDhQjg4OICIsHv3bjRp0oT1+c7OzmbPS0hIwN69e9/q7VtcXIyMjAxYWVlBIBAgPDwcw4YNw6VLl/6nfSwvL0d2djbs7OwgFovRu3fvD15ll+M44PLly/D09IRWq0VOTk5VD+e96du3L3Q63T8+q//f0Ov1WLFiBSwsLKBWq5GVlfXWbKeioiKkp6ez9dQmJiZQqVRshlJ6ejpMTExQXFyMFStWwMzMDB4eHmjUqBHc3Nzg4+MDd3d39n9IJBKxbXXp0gUmJiYgIgwfPhzW1tZ48uQJe+1Tp06xC78hISHIzs7GuXPncPXqVRw9etRgXMOGDePF0TiO+1086OY47nfp9Xrs27cP/fr1Q+3atSEWi2Fubo5+/fpBJBJh7Nix7LE+Pj5o3749+7l///7sZGf+/PkoKSlBzZo1kZmZCZlMBjMzM2g0GojFYqjVahQUFLAgXyKRoH///mxb06dPR1RUFBwdHWFmZgYiQrVq1RAbG4uwsDDWuqxWrVqYPn06Dh06hIsXL6K0tPQ/7mNxcTEmT54MnU4HpVKJUaNGfZQFjziuKhUWFiIxMRFCoRBfffXVWxfb/gny8/Mhl8vx+eefV/VQ/jIeP36Mnj17gogQFBSEw4cPY9myZUhNTYW5uTlbtjRv3jwQEXbs2AHg9UVTExMTpKens6x2QEAA3N3dYWVlhYYNG+LgwYMwMzMzyHZv27YNQqEQADBu3DgIhUIQERo0aAAAmDhxImJiYpCYmIgrV65g06ZNaNCgwVuF0YyNjfHpp5/i2rVrVXbsOI77++BBN8dx/5PLly+jT58+bJ2cQCDA8uXLAQATJkyAVCpFWFgYYmJi4OPjY9B729/fH+7u7mx6eE5ODho2bAiZTIZu3brhs88+g5GREbp06YLbt2/DyMgIBQUFOHnyJHr06AF/f38oFAr07t0b586dY2N69uwZZs2aBUdHx7dOjCwsLDB8+HDcunXrP+7b48ePMXjwYMhkMlhYWGDWrFl49erVezuWHMcZKi8vx5AhQ0BESE5O/ke2+RswYAC0Wq1BVpUDNm3aBDMzM4hEIrb+2srKin3XN2jQACEhIQCAFStWsAut6enpLKvt5+eHGjVqwMTEBLGxsYiNjYVIJMKoUaPY/wQvLy84OTkBAMLDw3Hp0iW0bt2addY4fvz4Wxd88vLy0K9fP6hUKtjb22Pr1q0oLi7+sAeI47i/NR50cxz3hzx9+hSLFy9mfbwHDRqEH3/8ERKJBFOmTAHw+sSo8kTnzcxO9+7dQURsOl5l0bWuXbtCKBQiMDAQtWrVgkKhwHfffYeAgACIxWIIBAJERESgvLwcc+bMQXR0NLy9vSEQCP5jb1ShUIi0tLT/qvXYr7/+is6dO0MgEMDV1RWrVq3iUwc57gP65ptvIJfLERoa+h/X+/7d3LlzB0ZGRhg1alRVD6XKPX78GNnZ2ejTpw80Gg10Oh2r3aFSqVjAfe3aNRARlixZwrLavr6+7ILum1ntPn36gIjg6+uLBg0aQCQSoVu3biyYJyK4uLigtLQUERERePToESoqKhAcHAwrKysQEWrUqIFPPvkEycnJiIuLg1AohEqlQu/evfHo0aMqPmocx/0d8aCb47g/Ra/X44svvoBarYZQKISjoyMUCgVOnjzJTpSICE5OTixw7d69O6RSKUpKSgyKrrm5uaFJkyZo3bo1LCwsYGlpiUGDBsHLywtSqRQnTpyAubk5q34+ffr0t4Lr0NBQpKWlYcCAAWjatKnBiRYRwcfHB9u2bfuvguizZ8+iUaNGbNrjHynaxnHcH5ObmwsbGxvY2NggNze3qofzTg0aNAgajeajLbp15swZdO/eHUZGRiAiiMViBAQE4O7du3j58iVMTU0xcOBAtk575cqVrHimj48PZs6ciRo1aoCIIJPJ4OXlhcmTJ0OpVOLw4cMgIkRFRSE6OhpSqRQAMGzYMIP/BZ6enujVqxcCAwMRERGBbt26oaCgAJ06dYJCoYBQKIRIJIJIJEJGRgZfcsRx3J/C+3RzHPenCAQC+uyzzyg/P5/mzJlDOp2OysrKKDY2lm7dukX169cnIqJffvmF/P39KTY2lo4ePUplZWXUunVrGjBgAInFYurSpQtdu3aNZDIZ3bp1i+zs7OjFixdUo0YNunr1KqnVaurbty+VlZXRsWPHKD4+ngYOHMjG0bp1a9q1axcZGRnRuXPn6Oeff6aoqChycXEhIiKJREI6nY6uXbtGDRs2JHd3d5o6dSo9efLk3+6bn58fbdmyhQ4cOEAikYjq1KlDCQkJdObMmfd7UDmOo+DgYDp58iQ5ODhQ7dq16ZtvvqnqIb0zGRkZVFZWRtOmTavqoXwwly5donnz5lHLli0pICCAduzYQcOHDyc/Pz9yd3envXv3kqWlJa1Zs4YePXpEPXr0oDVr1pC9vT09fvyYiIgOHDhAxsbGdPbsWRKJRKRQKEgqlZK9vT3t3buXSkpKaPny5SQSiejkyZPUvXt3MjExodu3b9OECROoY8eOJBaLiYjo8uXLNHfuXDp37hzl5eXRrl27yMHBgZYuXUrFxcWk1+tJoVDQzp07adKkSaRWq6vy8HEc93dX1VE/x3H/PE+ePEFcXBzLLNP/ZRbs7OyQl5eHQ4cOGRTEAYCFCxeCiLBr1y6D7PeYMWMgEAjg7u4OCwsLBAcHo0mTJjA3N2fb1Wq10Ov1+OqrrzBv3jz88ssvMDc3h0AgQMuWLbFv3z62Rk+v1+PIkSNo3rw5q2Sbnp6O7OxsPHjw4N/uk16vx9q1a+Hu7g6BQICOHTvi5s2b7/tQctxH7+XLl+jcuTOICIMHD36rwvXf1eDBg6FSqfDw4cOqHsp7U15ejjVr1iAmJobVACEipKSkoLS0FD/88AP73q/Url07hIaGYvny5VixYgUCAwMxceJE1hps+fLlqFWrFgIDA+Hn5wciQu3atfHTTz9BqVQCAJycnCCXyyGTydCmTRvs2bMHABAWFoYdO3YgOjr6d5cjCQQCJCQk4Pz581Vy3DiO++fhQTfHce9FWVkZ1qxZ89bJjb29Pfbu3QtfX1/ExMSgdu3aiImJYY8LCwtjLccGDRoEW1tbJCYmonv37ggPD4dUKkVaWhrbnlKpRKtWrQAA27dvx2effQZHR0doNBp8/fXXb43r4MGDaN26NVsjrtFooFarIRAIIJPJkJyc/LtTWUtLSzF37lxYWlpCKpVi0KBB/+iTZo77K9Dr9Zg2bRqEQiESEhL+EUXI7t+/D6VSiWHDhlX1UN6ply9fYvXq1Rg7diw8PT1BRIiMjMTUqVMhFouRkpLCLoJ+8skncHd3R0VFBZtKnpCQgKCgIBgbGyM2NhZ+fn6YP38+iAitW7eGUqmEXC6HRqNBu3btIBQK0bZtW3h7eyMlJQUAMHDgQKxatQr+/v4QCoVo3bo1fvzxR4NxHjt2DFFRUZDJZCAiaDQaVKtWjVck5zjuveBBN8dx7933338PCwsLg+Db2toaIpGI9dYuLi6GTCbDuHHj2PNycnJgbm6OHj16GGS/g4KCDDISnp6eiI2Nxfnz5yGRSEBEUCgUWL16NYDXlWfr1KnDqqZ7eXkhMzPT4MT9/v37+OKLL1g7sujoaIwdOxbbt2//zczas2fPMHbsWKhUKmi1WkycOBEvXrx4vweS4z5yO3fuhE6ng6enJy5fvlzVw/nThgwZAqVS+buzbP7Knj9/jmPHjmHHjh349ttv0blzZ1ZVXCqVwsjICNu2bQMApKWlwcLCgnWE0Ov1kMlkmDBhgkHLr4YNG0KhUCA7OxuHDh2CmZkZzp8/D51Oh+DgYDRo0ABOTk4IDAwEACQnJ7O13ZWzj+7evYv4+HiEhoYiNjYWdnZ2ICK4uroiJCQEvr6+UCgUEIlEaN68OQ4fPlwlx4/juI8HD7o5jvsg7ty5YxAsExFEIhEcHBxw+/ZtAK9PnmxsbBAZGYmYmBjEx8fD398fjo6OLPv9Zpbb2NgYixcvhru7OxYtWoSAgAAQEdasWYNx48bBzs4OANCnTx/WEsbHx4e9XqW8vDxkZGSwk0VLS0s4ODjAxMQERAQHBwd07doVCxcuxOrVq7F//37WyujevXvo27cvJBIJbG1tsXDhwv+qQjrHcX/MlStX4OXlBa1Wa7BE5e/owYMHUKlUyMjIqOqh/E/Onz9v0Dqy8vtco9Fg0KBB6NmzJ6RSKfbv3w/g9UVKtVqNzz77DIBhy6/+/fsbtPxq3bo1hEIhdDodNBoNBAIBUlNT4eTkBCJCr169EBERAQAoKiqCXq9Hv379WJu5N9tJViorK8O0adNY5j04OBgTJ05EXl7eBztmHMd93HjQzXHcB/Pq1St8++23iIiIMDhRs7a2xubNm1nV2c2bN7PnJCQkIDo6mv28ZMkS9tw2bdqgpKQENWvWRFZWFpycnKDT6VCrVi24urpCpVKhoKCABeNKpRKtW7fGmjVrcOfOHdSrVw9+fn5QqVTQ6XQYOHAgrly5AuB1FubYsWNITEyEUCh8a82fmZkZhgwZghs3bgB43dKmbdu2ICJ4e3tj48aNb/V65Tju3SgsLETDhg0hFAoxderUv/Xf2vDhw6FQKHDv3r2qHsp/9PLlS3Ts2PE310DXrVsXRUVFePHiBXQ6HQYPHsye991334GI8Msvv7CsdvXq1UFEcHNzM2j5NXv2bBARdu/ejbKyMggEApSXl6N79+4Qi8WQSqVsSn7jxo0RERGBWrVqYeDAgbC0tGSVy8eOHYvp06fj888/R1hYGIgINjY2WLJkSVUdPo7jPmI86OY4rkqcOXMGs2fPxuDBg+Hs7Mwyyi4uLrCwsGDBbGWQHRQUhJiYGERFRbETPXNzc/j7+8Pd3R0eHh5QKBSwt7eHmZkZJBIJ2rdvj3HjxsHW1hbm5uaoX78+vL29sWDBAgwYMABz5syBQqGAWq026AX84sULtGzZ8j/2/qb/6//9+eefs5P+kydPok6dOiAiRERE8GmLHPeelJeXY8iQISAidOzYkc0++bt59OgR1Go1Pv3006oeyr/1008/ITU1lc3+qbwZGRnByMgIsbGxbNr4okWLIBAIcP36dbZOOysrC2KxGGFhYazlV2BgIAQCAaRSKVxdXbFr1y4olUo2lTwpKQnPnz+HTqdDeXk5GjZsiLNnz0KpVMLS0vKtNdrA6wu7q1evRu3ataFSqSAUCqHRaFC3bl2sXbsWpaWlH/rQcRzHAeBBN8dxfxG5ubno3LkzZDIZxGIxLCwscPToURQXF8PExASDBg0C8LoyeuUJX82aNdnzly9fDiLC8uXLAQCPHz+Gubk5pk2bxqaiy2QyaDQa+Pn5ITAwEPb29ggMDIRcLse0adMAAMuWLYNcLjc4sTQ2NkZaWhqmT5+OqVOnom3bthCJRBAIBJBIJJBIJLC2tkZqairOnDkDvV6PnTt3sj6ySUlJuHjx4oc/qBz3Efj2228hl8sREhJicPHs72TEiBEwMjLC3bt3q3ooBrZv347w8HAQkcH3okKhwLRp0zB58mSIRCKDJTt16tRB/fr1DdZpT506FUKhEMXFxYiIiECPHj0QGBiI8PBwyGQyxMTEQKPRQCQSITU1Fa6urmx2UlBQEG7fvo3AwEA0aNAA7u7ukEqlrPDm0qVL8eOPP+LcuXPYs2cPunTpAiMjI0gkEsyaNasKjx7Hcdz/x/t0cxz3lxAcHEzZ2dn0/PlzOnPmDFlZWVFYWBjVq1ePIiMjadasWfTDDz+QTqejGjVqEBHRqVOn6OTJk0REpFQqiYgIAP3000/UoEEDevr0KV2/fp0UCgWtWbOGBg8eTL6+vtS7d2+6efMm5eXlUXh4ONnY2NCzZ88IAK1atYpKSkqIiEitVtPXX39Nt2/fppkzZ9KAAQPIysqKfvzxR6qoqCBvb2/q3r079evXjxITE2nDhg1UvXp1ioyMpLKyMtq5cyctXbqUfvrpJ6pWrRqlpKRQQUFBlRxfjvunateuHf3www+Un59PQUFBlJubW9VD+p8NGjSIJBIJTZo0qUrH8eOPP1K3bt3I3t6epFIpJSYmklAopDFjxrDvRZVKRfv376cBAwbQkiVLKCkpiWxtbWnlypVkbm5Od+7cIZFIRF5eXnT58mUqLy+nsrIy0uv1ZGdnR6WlpXTu3DkiIkpNTaVXr15Reno6eXl5kVwup7lz59IXX3xBlpaW9OLFCyooKCCBQEAnT56knJwcGj58OE2ePJnWr19PSqWSOnXqRIGBgeTn50d169alPXv20IgRIygvL4/69OlTlYeT4zju/6vqqJ/jOO63lJaWYu3atazft1AohFKpxO7du7FgwQKWcbGwsGBF18RiMXx9fQ1ajrm7u0OlUiEmJgZOTk4YPXo0srKyYGRkhJo1a8LU1BRqtRpubm5Yv369QYZ7xowZAIAxY8YgNDQUtra2LHN98OBBg3Wk5eXl2LBhA1s/XnmTSqVo06YN+vbtCxMTExgZGWH48OEoLCysqkPLcf9IBQUFqFWrFmQyGZYtW1bVw/mfjR49GnK5HAUFBR/sNe/cuYPjx49j8eLF8Pf3Z20d4+PjQUQYMmQI9Ho9WrRowb7TKo/t2bNnQUTIyckxyGq7u7vDysrKYJ325s2bIRAIEBYWBgsLC2g0Gmg0GvTs2RMKhQLGxsYYPHgwa/lVUlKC8vJy9O3bF0QEd3d3ZGZm4vHjxwBe19y4ceMGhgwZAmNjY4hEIowaNQoXL17khSw5jvtL4kE3x3F/eVeuXMGqVatY4Z06depAoVCwk8D58+cDAJo0aYJq1aqxYDgnJweWlpZQqVRo0KAB7OzsoFAo4OjoyNZc79u3D3Z2dujTpw+qVatmUBjI19cXsbGxOHr0KGbMmMHu37RpE4DXaxcjIyPh6+sLrVYLIkJgYCBmzpyJjRs3Yt26dZg4cSLc3NxARHB0dETt2rUhkUig1Woxffp0lJSUVNlx5bh/mpKSEnTu3BlEhE8//fQ32/39VT158gRarRb9+/d/59suLCzE0aNHsWPHDuzZswcLFixAw4YNIRAIWEFLX19fbNq0Cfn5+ZBKpejZsyf0ej1u374NkUgEIoKVlRWWLVsGMzMz7Nq1iy3zeXOdtpeXFyQSCdzc3LBnzx4olUpcuHABzs7OcHZ2RosWLVCrVi3W8qtNmzYQCARQq9VsnXbPnj3ZxdMBAwagdevWEIvFbJp7ZWtIrVaLAQMG/CPax3Ec98/Gg26O4/42ysrKkJ2djeDg4LcKmqWnp+Pbb78FEaF69eos+92jRw84OTlBr9dj9OjR2LJlC6ZOncrWaoeFhSEpKQkdOnRgVcqlUiksLS2xZcsWZGdnY8iQIZBIJAgLC4NarWbV1V+9eoVdu3ZBLpdDo9Fgy5YtBuMtLi7G4sWLDVqlvVkJvTJ736pVK0ycOBELFizA1atXq+LQctw/hl6vx/Tp0yEUChEfH48nT55U9ZD+a59//jlkMtk7W5t+4sQJdOnSxWA9dmUA7e/vj3HjxkGj0SAmJgZPnz4FAEyYMAEymQzBwcGIioqCt7c3e661tTXMzMzg7e2NrVu3sqBbrVYjLi4OgYGBcHR0hEAgQO3ataHT6dg6bV9fX1atvDKjvXv3biQmJuL48eOwsrKCsbEx0tPTce3aNYP9uHXrFvr16we1Wg2FQoGBAwdizZo1eP78+Ts5ThzHce8bD7o5jvtbOnHiBGrXrv1WJXGtVotatWqhuLgYAFg2Zt++fey5c+fOBRHB19cXYWFhkMlkLHNCRPjkk09gbW2NLVu2ICsrC+3atYNMJoNCoYBWq4W/vz8KCgpw8eJFKJVKSCQShISE4MWLF+w1oqOjYWpqCoFAgMTERGzZsgXFxcWoqKjAli1bEBoa+m8rojdo0ACbNm1CRUXFBz+uHPdPsXPnTuh0Onh4eODnn3+u6uH8VwoLC1nhxj/jyZMnSExMfOu7RSwWw8bGBocOHYJer0erVq3g4uLClruUl5fDwcEBnTp1Yt8/n3zyCXt+SkoKZs2aBa1Wi9WrV4OI0Lt3byxduhRqtRo1a9aEt7c3BAIBMjMz0ahRIygUCgDAqlWrYGFhASLChAkTAAAuLi6oWbMmoqOjERMTg/T0dBgbG7Mp5dWrV4eLiwurQt63b1/cvHnzTx0bjuO4qiAAgD+xJJzjOK7KAKCpU6fSsGHDqKKigt0vFAqpXr16tHbtWlIoFOTl5UVOTk5UUlJCIpGIBAIB7d+/n1avXk2tW7emMWPG0LFjx2jnzp1EROTl5UXXrl0jqVRKVlZWVFJSQkZGRmRjY0OxsbFUVFREZmZmdPnyZVq7di0REUVHR1NOTg4REW3atInatm1LUqmUDh06RH5+fkRE9PLlS+rUqROtWbPmv9q/oKAgmj59Ovn6+pKxsfG7PHQc91G4evUqNW3alAoKCmjlypWUkJBQ1UP6j8aPH09jx46l69evk52d3X/9vF9//ZUWLFhAy5Yto9u3b9Obp3cajYakUikZGRnR0aNHydbWlgoKCsjR0ZHGjBlD27ZtI4lEQiUlJZSbm0ufffYZ7dmzh+RyOUkkEtqzZw8RvS5YGRAQQEeOHKF9+/ZRXFwc+fv7k7m5OR04cICkUikpFArS6/UkkUjIw8ODrK2tadWqVUREdOPGDapfvz5dv36dEhISqE+fPhQfH08ikYiN9eTJkzRkyBA6ePAg6XQ6atGiBQUHB1ObNm1IpVK9o6PMcRz3gVVtzM9xHPfn/frrrxgxYgQsLS0Nst6Ojo7IzMzEhAkTIBaLsX//fvacoKAgNGjQgP08YMAA9lwfHx+4urqiZs2aGD16NIgIGo0Gz549w+jRo5GSkoLs7GxIJBL4+vrCzs4OarUagYGByM/Ph5mZGYyNjSGXy9mU888++wxKpdIg62RjY4NRo0Zh7dq1WLduHT799FNotVo2/ZPeyE61adMG33//vUHxNo7j/rOioiI0bNgQQqEQU6ZM+cv/DRUVFcHExAS9e/f+t4/R6/U4dOgQZs+ejTFjxiAwMBBCoRAqlQpWVlbsu8PMzAxff/01vvnmGxARcnNz2TbGjh0LhUKBR48esaz2sGHDQETw9vZGbm4uatSoAZlMxrYXFBSE8+fPg4iwdOlSaLVaVvxNJpPB3d0doaGhmDNnDqRSKUQiEXbs2AEAWLlyJSIiImBhYQFfX19WdNLBwQF169ZFQkICK+ZmZWWFkSNH8unjHMf9Y/BMN8dx/xilpaV0/Phxun//Pt24cYO2bt1KR44cIYlEQgqFgkpLS2nr1q0UFRVF2dnZ1LVrVwoODialUklPnz6lU6dOERFRz549ycrKioKCgujmzZvUr18/kslkJJVK6fnz5ySVSqlbt240f/582rBhA508eZL2799P9erVoxMnTtCWLVuofv36dOXKFZo5cyY1atSIAgIC6KeffiKi1y135s6dS23atCGJREJ6vZ6GDh1KU6dOJa1WS126dKGmTZuSiYkJFRcX09GjR2n69On066+/kqmpKcssRUVFUceOHUmj0VThUee4v76KigoaMWIEffnll9ShQwf6+uuvSS6XV/Ww/q2JEyfSmDFj6OrVq+Tg4EBEr2f2vHjxgpYvX05z5syh8+fPk0gkIpFIRDKZjCZPnkwikYhSUlKIiMjKyooOHjxI7u7uVLduXSoqKiKJREISiYREIhEJhUJ69OgRyWQyksvlNGfOHFq0aBFNmzaNtFot1ahRg06dOkUSiYSePHnCMufW1tZ09+5dat26NZ0/f54uXLhAlpaWJJPJaOvWrTRq1CiaOnUqFRYWUkREBKnVaurVqxelpKQYZO7Ly8tpxowZlJWVRXl5eeTh4UHh4eGUkJBASUlJJJVKP/yB5ziOe1+qNubnOI57vwoKCvDFF18gKSkJZmZmkEgk6NatGw4fPgxTU1MkJCSgrKwMhYWFrCK6QqFAeHg4YmJiEBERASLC0aNHAbxu65ORkQFXV1cYGRkhOjoa9vb2aNOmDbKysmBmZgYbGxtoNBqo1Wr4+/vj8OHDBpnrnj17AnidrRoyZAisra1BRBg7dqzBunAA2LBhA1v/bWtri8TERLRo0QJRUVEQiURQKpVo3rw5vv32W+zatQtnz579y2fyOK6qrFixAnK5HCEhIe+sWNn78PTpU5iZmaFZs2bo3LkzzM3NIRAIIBaLIRQKkZSUhG3btqFWrVqwsLDAhQsXAMCgVkRlHYsbN26wVl+VGe3s7Gw4ODjA2NgYpaWlbP27i4sLyz4XFBTA1dUVQqEQrq6ubLvm5uaQyWQAXq/Trvydo6MjysrKcOHCBURGRiIsLAyrV69Gr169oFKpIBKJEBUVhRYtWiAxMRH29vYgIoSEhGDt2rVVc6A5juM+EB50cxz30Xj16hXGjx8POzs7EBEr0NOqVSu8fPkSPXr0YCeW06ZNAwA8evQIQqEQWVlZbDs5OTkwMzODVqs1aEXm7OzMqqJ7enpCq9WiSZMmLHAnIshkMshkMsTExGDBggVo1KgRiAhqtZpNRR81ahSio6NZa7OQkBBs3LjRoP9sfn4+Bg0axFqVvXnz8fHBrFmzUFRU9GEPMMf9DZw4cQK2trawtrbGsWPHqno4TEFBAaZOnYp+/fqhdevW0Ol0LJjt378/zM3NYW9vj/PnzwMAlixZAiJi+/Djjz+y7wCFQoGoqCjExsaygmc1atRAdHQ0Lly4gKysLPj5+UGpVCIuLg7R0dHw8PDA6tWrYWlpCXd3dygUCigUCuh0OrYN+r/lLk2aNMH27duRnZ2NmJgYeHh4gIgQGhqKb7755q1WiBcuXEB8fDykUimMjIwQGxuLtLQ0nDx58oMfZ47juKrAg26O4z46ZWVl2LBhAzp16oTAwECIxWI4OzsjPT2dnVhKJBK2FjEpKQmurq6oXbs2a0XWsmVLhIeHAwBrRTZv3jwQEcLDw7F//36EhYWhW7duUKlUrMf3p59+ioiICEyaNAn+/v6QyWTQaDRwdXU1aDk2ZcoUEBEsLCzeylwvXLgQEokESqUSPXv2xOHDh/Hrr7/i5s2b2LFjB2rXrg2hUAiZTAatVgsHBwfUr18fa9euRWlp6Yc70Bz3F3Xnzh3UqlULMpkMS5cu/eCvX1RUhNzcXOzZswcLFy5E06ZNIRaLYWRkBGdnZ0gkEnh5eWHLli0oLy9H3bp1YW1tjVu3brFthISEICYmBmFhYYiKimJZ6spAPTo6Gl988QWrPu7p6Qk/Pz/IZDJ4eHggKioKQqEQBQUFOH/+PEQiEbZu3YqEhATWRWHdunWsX7etra3B92OnTp1Y1XPgdfuvOnXqgIhgYmKC6OhoJCYmIigoCEKhEGq1Gn369MGdO3c++PHmOI6rajzo5jjuo3f69Gm0bdsWEonEoIiZWCzGsGHDWBGiAwcOsOdMnjyZFRCqtHTpUhARvLy8WCsyqVTKthcTE4Phw4fD0dERX331FZteaWxsDIVCAVdXVxQUFODq1ausX3jz5s0BAJcuXUJ4eDibypmSkmJwwgsAGzduZBknPz8/DBkyBOPHj8fw4cNZtl2tViM6Ohpdu3ZFeno6Nm/ejPLyclRUVODJkycoKiri09O5j0JJSQk6d+4MIkJ6ejrKy8vf+2uePn0aPXr0YEtZKi/Gubq6IjMzEz/99BPMzMwQERHB/r7PnDkDIsLq1avZdiqz2uvXr2dTxhs0aMC2uXfvXty+fRt+fn6sGOTs2bMBAJ6enli9ejUcHBzY7BulUgmNRoP4+HjcvHkTKpUKQqEQTZs2xYMHDwAAhw8fhkajMZhVo1Qq0alTJ4wZMwafffYZ6tWr99bMm+rVq2PevHl49uzZez++HMdxf1W8kBrHcdz/uXv3Li1evJi+/vpr+uWXX9j9AoGAdDodKZVKOn78ONnY2ND9+/fJ3t6eUlNT6fTp0yQSiUgsFtOePXto6dKllJyczAohrVixgoheFyAqLy8nsVhMarWa7t+/TyqVilasWEGTJk2iV69eUXR0ND158oTmzJlD5eXl5OjoSA4ODuTs7Ezu7u40bNgwEolENGHCBMrIyKBz585R79696c6dO6wNz7BhwygyMpIEAgERER0+fJimTp1KmzdvJrlcTs7OzmRkZET37t2jvLw8EgqFpNfr39pfS0tL0ul0JBQK2bYEAgG7vfnz7/3uQz32rzimj2n8f8d9BUDr1q2jOXPmUHBwMI0ePZo0Gs3//DqFhYV09OhRevToEZWXl5NGoyGVSkW5ubl06NAhVohMr9eTtbU1paamklAopJEjR1JqairNnDmTxGIxdevWjXbu3ElnzpwhU1NTIiLq1asXrV+/nlxcXEgqlZJIJKKEhATKyMigkJAQMjIyojlz5lBaWhrt37+fiIh8fX3p0aNH9OjRIzp58iRVr16dLCwsyN7enk6fPk2bN2+mPn36EABydnYmhUJBMpmMNmzYQEREX331FQ0fPpxq1KhBmzZtIisrKyJ63fawe/fu7Dvt98jlcsrMzGSF3TiO4z5mPOjmOI77FxUVFTR06FCaPn26Qf9vkUhENjY2tGXLFqpevTp16NCBjhw5QmfPnmX9Y0NCQkin09GuXbuIiGjGjBk0cOBAIiJycHAgiURCWq2WunbtSgMGDCALCwvKz8+noKAgsra2pvbt21OvXr3I3NycCgsLafHixfTw4UNav3493bx5kwoLC6msrIxGjx5NvXr1okaNGlGDBg2oX79+ZGtrS1euXCGFQsHGPHfuXEpLSyNvb2/q06cPdejQgdRqNa1evZrS09MpPz//d4+FSqUiX19fsrKyIiMjI5JIJET0upJy5e3Nn3/vd+/rsVXxmh/7vnC/TyQSUUVFBVlbW1PHjh1p27ZtdPXqVZozZw516tSJ7ty5Q25ubtS+fXtatGgRCQQCevLkCdnY2NDAgQPpwIEDrMr4yZMnKS4uju7cuUNGRkZUr149+v7772nPnj0UFhZGjx49ol9++YXUajU9fPiQiIg8PT2pVq1atGzZMurevTtdu3aNDh06RFqtlh4/fkx169YlmUxGRUVFdPDgQbK0tKQhQ4aw76o2bdpQkyZNKD09nQoLC6lt27bUp08fCgoKIoFAQKdOnaJhw4bR3r17Db4jiYhcXFyoV69e1KVLF3bhgOM47mPHg26O47h/Iz8/n77++mtasGAB3blzh4j+/8l0dHQ0JSUl0YgRIygqKorWr19Pcrmcli5dSp07d2atyADQ999/T0REgYGB1KhRIwoKCiKJREKJiYkkl8tJJBLRixcvSCKR0JQpU6hfv37Up08f+umnn2jo0KF08+ZNevToEX3++eckk8lIKBSSi4sLWVhY0KNHj+jnn38mtVpNIpGI+vTpQ6NGjaK7d+9SnTp16OLFi1S/fn3avn07iUQiIiKaNGkSDR061GBfnZycyN3dnQDQ2bNn6f79+yQWi6m8vJw9RiqVUqtWrahXr17k5+dHxcXFpNFoyMjIiGX+uI/HX/miwB/53S+//EK9evWie/fu0VdffUVRUVFvPbaoqIg2b95M169fp1OnTtHNmzffOi4ikYhcXV1pypQp1LBhQxo8eDDNnDmTtm/fTvXq1SMiopEjR1JmZibl5+eTWq0motcX6DIyMuiXX34hKysrEgqFNH/+fEpNTSVHR0e6evUq3b9/nxISEig4OJgWL15Mer2eBAIBKRQK6tevH02aNImIXmeZXVxcCADFx8dTu3btKDg4mMaNG0fZ2dm0e/du2rp1KymVSioqKqL09HRq1KgRLVmyxCBQfvjwIS1cuJDmzZtHt27dIpFIRFKplF6+fElERGFhYdSgQQOqUaMGKRQKMjc3J39/fxIKhX/gE8VxHPfPxYNujuO4/6C8vJyuX79OT548Ib1eTydOnKA1a9bQ4cOHiYhIKBRSSEgIZWVlUbVq1cjOzo5iYmJozZo1JBAIKDAwkE6fPk1ERAEBAaTVakkul9Pp06epR48eNG7cOBozZgy9fPmSTpw4Qfv376emTZuSSCSi8+fPExGRXq+nvLw82rJlCw0fPpwaNmxITk5ONGLECMrPzycfHx+6ceMGeXp60o4dO6hmzZp09+5dsrKyIqVSSefPn6ctW7ZQ37596d69e2zfEhMTqX///lS3bl0SCAQ0ZswYGj9+PBkZGVFycjI1a9aMTExM6OXLl5STk0OzZ8+mZ8+eGQTjPj4+1KtXL+rYsSPJ5XIqLy8nhULBA3Hub+fp06fUrl072rZtG6WkpJC1tTUVFRXRixcv6MKFC3T69GkqKysjjUZDjx8/Zs/TarXUrFkz2rBhA/n4+NCOHTtIq9XSw4cPyc7OjkaMGEEjRowgIqLS0lJycHCgxMRE+vnnn1lG29jYmM6fP0/Gxsasb/a2bdsoIyODFAoFubi4UHFxMeXl5dGSJUuoffv2tG3bNrK1taWAgABau3Ytde/enZ48eUJERCYmJmxJzLhx42jDhg107949srOzo8uXL5Ner6fOnTvT/fv3CQDl5uYSEVHbtm2pffv2ZG1tTWVlZXThwgWaN28eHT58mExNTalLly7k6elJoaGh5Ofn9+HfJI7juL8jcBzHcX/IhQsXsGnTJowZMwZWVlYgIgQFBaF79+4QCATo3r07ysrK8PXXX7OiQs2bN2eFypo2bYpq1aqxn3NyclCtWjUQEWJjY+Hq6oqaNWti1qxZUCgUMDY2BgBER0dj8ODByMrKgru7O0QiEXQ6HSwtLTFo0CCMGzcOUqkUSqUSoaGhsLGxQVBQEL7//nsIBAI2llatWkGv12PMmDEIDQ2FhYUFiAhjxozB06dP2X6+evUKKSkprAJx7969sXLlSmzatAlLly5F/fr1WQ/hym3LZDIkJCSgZ8+eaNKkCWtf1Lp1ayxfvhwvX7788G8Y91GrqKjAmTNnsHPnTmzZsgWHDh1CUVERLl++jMmTJ2Pw4MEYOHAgmjRpAhMTExARTE1N4eDgALFYDCsrK4wfPx6fffYZ+5yLRCJMnToVL168QJcuXWBra4uHDx+y15w8eTKkUimCg4PZ38C6detARPD19UVUVBQuXLiA7OxsWFtbQygUombNmqxvtoeHB4RCIWxsbHD//n24ubmx7xZLS0sYGRlBKBRCIpEgPj4e/v7+BmM7ceIEACAlJQW1atWCTqeDQCDA0KFD8euvvxocn/v372PixImwtrZ+qxhabGws1qxZw7sfcBzH/UE8081xHPcOVFRU0I4dO2jOnDmUk5NDAEggEFBQUBD17duX+vXrR4WFhURElJGRQV9++SXt3r2bGjRoQNWrV2fZrb59+1LDhg1p9+7ddOjQITYVvU2bNvT8+XPSaDT08uVLEgqFZGlpSfn5+TRy5EgaNGgQ1atXj4qKimjUqFHUtm1bsrKyosDAQHJyciKZTEY//fQT7d27l4iIUlJSaP78+UREdOPGDdq8eTMNHDiQbG1tKS8vj2WpX716RY0bN6bvv/+eJk2aRN26dWPTYR88eEDJycmUk5NDFhYW1KVLF/L29qZHjx7RypUr6ccff/y3a4BNTU2pbdu21LFjR7K2tiYLCwuSy+Xv+V3iPkZPnjyhJUuW0Lx58+jKlSsGv6tcQqFUKsnCwoLu3btHr169ombNmlFaWhpJpVKKi4uj6OhoWrNmDRER2dra0rNnz0ggENB3331HLVu2pEePHpGdnd1b67F//fVXsrS0pPLycrYe++zZs/Tdd99RVFQUvXjxggBQ586dafny5XT9+nVydnamkydPkpeXF40dO5YGDx5MIpGIHBwc6OzZs2RlZUXx8fFkbW1NI0aMoJycHOrSpQutWrWKUlJS6Ndff6WioiIiItJoNJSZmUlt2rQhIyMjqqiooFGjRlFWVhYVFxdTo0aNWDG2R48e0Zo1a+jq1avk5uZGAwYMoNDQULK2tiZbW9sP/r5xHMf9o1RpyM9xHPcP9OrVK9y7dw8bNmxAZGQkiAg6nc4gc1SvXj1s3boVbm5uiI+PZ21/Kioq4Obmhvr167/VFzw0NBTA/+8Lvnz5ctaiLDQ0FL6+vpDJZFixYgWICKdOncKBAwfg5OSEQYMGwdTUlL2+VqtFSEgIYmNjcfPmTUgkElhZWUGpVLK+xYsWLYKFhQUEAgE++eQTg328ffs2XF1dYWFhgRUrVuDVq1cAgAMHDry1r791ezMrTkRQKBTo0aMHcnJysHv3bmzcuBF79+7lPX25/9nVq1cxdOhQJCUlwdfX16AN4L/egoODsXz5cty/fx8BAQGwsLBAbm4uAKCsrAz29vaIjIxkMzPmzp3LnmthYcGy16NHj4ZYLEb16tURHByMmTNnYvHixRAKhZDJZIiMjMSoUaPg5+eHAQMGsHZfJ06cgEAggLu7O/r16wehUIhq1aoZ9M1OSkoCEcHGxgZ2dnawt7dHQUEBunfvDplMBq1Wi4YNG+LMmTMAgAcPHrB2YJU3ExMTpKamYuzYsRg+fDhCQ0NZNlwsFkMkEsHU1BRt27bFwYMHedtAjuO4d4wH3RzHce/Z2bNnkZaWxnpov3mrDGp79+7NAu+vvvoKEokEd+/eZduYP38+hEIhrly5wu7bvn07iAjTp08H8Hq6u5+fH+rWrQsiwqZNm3DixAkIhULWE5yIoNFosG/fPjRu3BjZ2dlo2bIliAjW1tZwcnJCbGwsCgoKEBgYCCKCh4cHvLy8kJeXBwB48eIFVCoV1Go1bty4wcZz7NgxGBkZGQT2/fv3x7lz51BcXIwJEyZAKpVCKpWiY8eO2LBhAw4ePIgdO3agQ4cOBr2L3wzOk5KSkJGRgdGjR2PYsGGYNGkSjh07huvXr2POnDkYO3YsxowZg6ysLJw9e/YDvKPc+3T//n1cvHgRFy9exL1796DX66HX63H37l1cunQJ165dQ1FREQ4dOoT27dvD3d0dFhYWsLKygrm5OYgIxsbG8PLyeuvzFBMTg4CAAIhEInz99dfsNXv27Am1Ws0CVwBsGri/vz8Lrn18fNi2fH19MXPmTGRnZ8Pb2xsikQgRERFo2LAhqlWrhmnTpoGI4OLigtOnT0On00EikWDlypUgIuzfvx/nz5+HQCDAuHHj0K5dOxARJBIJLCwsWN/s27dvQ6FQsL+Fyr7Zo0ePRlBQEEQiEczMzHDy5Ek29sePH/9mz+zfumk0Gqxbt+7DvcEcx3EfIR50cxzHfUAbN26EnZ3db578xsfH4+jRo3j48CG0Wi3q16/P1lA+e/YMGo0GnTt3NsiAOzg4wMTEBJGRkYiMjMScOXPQsGFDFmBUr14dvr6+SE9PZ69ja2sLAAgMDERWVhZ8fX2hVCphYmKCRo0aYcqUKRg3bhxsbGxgamqK0NBQmJqaIioqCgUFBSyAt7S0xLJlywAAw4YNM8heJyQkoKioiO33kCFDQEQYNGgQCxoA4OHDh6hduzaICDVq1MDXX3+N69ev4969e8jJyUFERATEYjEEAgEsLCzg5ORkENj/1i0yMhLz5s3D2bNncfXqVYNxcH9Nz58/x4IFCxAQEPDW+2lra2tw0ejNmRKurq4YNGgQWrRoAZFIBH9/fyxZsgTffvutweM7duyIixcvsoB38eLF7LUfP34MIyMjjB8/3mBMderUQVhYGLsYNn/+fLY9Pz8/VFRUwM/PD5mZmbC1tYVOp0NeXh7LQFeux7a0tERhYSFSUlIgEAjQtWtXCIVCWFtbIzk5GXZ2dhg/fjwGDhyIxo0bw8jICOfPn0fPnj0BvL5o5+/vD6lUisaNG+PFixcG47x06RLc3d1BRAgJCcHixYtx9OhR5ObmYvLkyW9lvd+8aDB79mz+98FxHPcB8KCb4zjuAysrK8PGjRtRr149CIXCtwKJGjVqoFOnThCLxQbBa9++fWFqampQAGn8+PGQSqUICwtjgfjatWtZhi4yMhJnzpzB0KFDDYqcVatWDWq1Gh4eHjAxMYGtrS2ePXuGAwcOoFq1ali5ciVEIhE0Gg3kcjk++eQTZGdnY+zYsSy4sba2ZhnAyux6ZYZ70aJFAAC9Xo/4+HgWIL1ZQO3x48fw9fWFmZkZ9uzZYzClde3atZDL5bCyssKoUaNw+/ZtvHjxAs2bN/+Pmbt/nU4sEAjQqFEjjBs3DsOHD0efPn2Qnp6OmTNnsgsAZWVlePLkiUGhqMuXL2PXrl3YsGED9u3bh4KCgvf6ufi70Ov1ePr0KfLy8vDw4UOUl5f/7uOvXr2KnTt3YsOGDdi7dy9u376NpUuXol69evD29oa5ufm/nQIuEonY+7d69WqMHDkSYrEYtWvXxs6dO1FRUYGNGzeyYLa0tBRlZWWwtbVl2xg1ahT7bIWFhaFu3boG45s2bRrEYjGCgoLY5/nq1asgIjg6OiIkJAQzZ87EuHHj2DZ1Oh10Oh0LroOCgmBtbQ1ra2uoVCr069cPq1evhkqlgo2NDaKiomBubg5ra2sMHDgQdnZ2MDIyQkBAABQKBcLCwlBQUIDWrVuz17137x4AIC4uDj4+PvDz84NQKISbm9tbwXJ5eTm+++47VojxzZuXlxcmTpyI7du3Y/Pmzdi1axfOnTvHp5BzHMd9QDzo5jiOq0KvXr3C3bt3UVBQgBcvXmD79u1o1KgRzM3N2VpLlUqF/v3749ChQ3B0dISvry8LAO/evQuJRIJJkyYZbNPS0hItWrRgWfGgoCB2Em5jY8OC8dWrV7MscmBgINRqNWQyGfbs2QMiwvfff4+9e/eyyugpKSkgIjg5OcHZ2Rm//PILFi9eDKVSybbv4uLCgpc5c+ZAJBLBwsIC0dHRLDM+atQomJiYQCwWQ6lU4qeffmLj37RpE4RCIdq0acOC9JKSEsTExBgEE/b29hg3bhw2b96M0aNHQ6lUQiAQoH79+lixYgW+//57bNu2Dc2aNWPZcQsLC/j5+cHDwwMSiQRisdhgrTsRwdzc/K3MKhFBKBSiSZMmWLlyJXJzc3H48GFcvHgRZWVl//P7XlFRgdu3b+PcuXO4fPkynjx58ic+RW8rKyvDgwcPcPv2bTx79uwPb6eiogKFhYUoLi7GvXv38OWXX8LFxcXguCiVSjRp0gTNmjVDaGgofHx8EBQUhJiYGLZE4bey1HFxcWxt8Zu3wMBAhIWFgYjQunVr3Lp1CwCwa9cuiMViJCcns4sjz58/h06nQ/PmzVlGev369QbBceVncefOnSygValUcHNzQ2xsLJycnCCVSqFSqWBqaor27duzmSFdunRBUFAQhEKhQcZYJpNBLBYjKysLq1evhp+fH4gIbm5uCA8PR3h4ONasWYP69euDiKBWq2FiYgIzMzMUFBTAx8cHAoEADg4OCAoKQnFxMfbv3486depALpez2SKV+17pzJkzaN68OfteqF+/Plq1aoX4+HhWmbxu3br45ptv8OOPP+LmzZs8uOY4jvsL4EE3x3HcX9itW7cwdOhQmJmZgYggl8shkUhgbW2N+fPn4/nz5+jduzekUin279/Pnjdy5EioVCrW+uvu3bss2DE3N2eFz3JycqBSqTBo0CAA/39deLNmzUBEOH36NE6fPg2RSARHR0cWLOzduxetW7dG48aNMXjwYIMATKVS4cqVK8jOzoaTkxOIXhdKc3R0fGu9uJeXF5vufunSJQQHB7MA581gtmvXruw1VCoVVq5cyTKsK1euhFAoROPGjXHt2jX2nDt37qBmzZqQSqXo0KEDjhw5wtYHT5kyBUqlEiKRCM2aNcPChQvx+eefQ6PR/G4W/c2Wa5U3S0tL1KtXD35+frC1tYWVlRV8fX2RkZGBZcuWIS0tDW3btkW7du2QkpKClJSU35zyW7duXSxcuBAbNmzAsmXLsHbtWpw6dQp6vR4FBQXYs2cPNmzYgN27d7P19VeuXMG2bdvw3XffYceOHdiyZQvat2/PArc3s52jR4/GuHHjWGuscePG4ciRI1iyZAmaNm2K8PBwREREICkpCYMGDUK9evV+twjZv84ssLa2RpcuXdC1a1f2eQ0LC8OKFStw+fJlNGjQACKRCAMGDMCVK1cwZ84cg+20a9cOJ06cwJ49eyAUCtGrVy8WSOv1enh6eiIuLs7gc7FgwQIQEWrWrMmC66ioKLZNDw8Ptu46KioKYrEYHTt2RLNmzeDn54dFixZBqVRCrVajqKgIFRUVsLa2xrx580D0esnHixcvEBISghUrVrCZKVqtFs2aNUNERATWrFnDgu6hQ4fC2dkZRkZGiI2Nxa+//gqlUgkzMzPY2Njg5s2bAICCggL4+vqyiw//euFm06ZN0Gq1EAqFaNq0KdatW4fjx4+z96vy70ehUCA0NBRJSUkYPny4QY0FjuM47q+DB90cx3F/AyUlJVi/fj2mT5+OoUOHonr16hAIBGydt6urK2QyGZYtW4by8nLk5eVBKpUiOTmZZboqp65WBmGV09ETEhJYheXKdeGdOnViU90DAgLg7OyM1atXs4JOwcHBsLa2hkwmM+jrO3nyZMTExKBOnTrIysqCSqWCVCpFZGQkbGxskJaWhnHjxsHa2hoWFhZwd3eHnZ0dYmNj0bVrV1haWrLM+8iRIwEA27ZtY9uXSCQ4duwYOy7Hjh1jhdnenOb85MkT+Pr6wsbGxiCLrtfr0a9fPxARBgwYgNu3b7PXkEqlBkFgjRo1MGzYMKSnp7MCXQEBAVi0aBF+/PFHHD9+HImJiRCLxRCLxWjTpg1GjRqFUaNGoVatWmx7jo6OiIqK+rdr+f9TUG9sbGywDKHyVhnY/jc3gUAAgUAAmUwGZ2dneHh4QCaTsYC5du3aSE5ORr169VhBu4CAAEyePPmtKcsCgQDh4eGoWbMmhEIhwsLCsHHjRpSVlSEvLw92dnZwcnJihb30ej3atWsHmUyG7du3A3i9lv/NCwPTpk1j71Ht2rVRq1Ytg/ezcuZFZW/r2NhY5Ofnw8nJCRqNhlUMX7hwIdtm5eeict113bp1odPpULduXTRt2hQhISHIysqCRqOBVCqFr68vXFxcIJfLcfHiRfZ5k8lkiImJwbZt29jaaaLXa821Wi1iY2PRu3dvVm/AxcUFcXFxAIAdO3aw4Lpp06bsIkKlhQsXQiQSwdPTEzNmzDCY8fD06VNkZGS8NRODiFCnTh2sW7eO983mOI77m+BBN8dx3N/UzZs3MWzYMPj5+cHa2ppN8ba3t8eECRMwceJEEBG6d++OsrIy7N+/n520W1hY4Pr16wCA3bt3g4hQvXp1Fohfu3YNQqEQdnZ2bCp6Tk4O4uLiIBKJsG/fPnTu3Bl169ZlU86JCLNmzYKbmxsUCgU8PDwgl8vRrl07AMCgQYNgY2OD1atXs4rqVlZW2LJlC7Kzs9GoUSOIxWK0bNkSJiYmCAoKQmxsrEFWWCAQwMrKCrGxsbh27RosLCwgEong4uKClJQUAMDBgwfZVNuLFy8aHLMpU6aAiDB37lx23+nTpw0qp8fFxbGs+LVr12BpaQk3NzeDYP/hw4cICAiAWq3Gl19+ifv37wN4Pd05ISEBIpGItV8qKSlB06ZN3wpc69Spg44dO8LR0RFEBHd3d8yaNQv5+fm4d+8e6tSpwy6QzJ49G9euXcNPP/3EqnJHRERg5cqV+O6776BSqQy2b2Jigvj4eFZt28vLC3PnzsXTp0/x8OFDhIaGQqFQID09HVevXgUAbNiwARKJBHFxcThx4gQqKipYu6rKWRbp6em4du0aNm/eDKFQyD5bwOup6AEBAXBwcEB+fj47Vrt27QIRYcWKFW+9D0SEHj16sPvPnTsHIsL8+fMRFhbGAuyEhATY2dkhMDAQISEhaN++PTIyMkD0ejlDaGgorKysMGHCBLbdmJgYJCQkQC6Xw8PDA61bt4ZWq4WpqSlkMhmcnJzg4eGBatWqITIyElZWVpBIJGjXrh169uwJiUQCjUaDiIgISKVSVKtWDWvWrGHbVygUGD58OIDXM1Jq1KgBotfLN97sPAAAs2fPhkAgQGJiIg4dOmQw5fv48eNo06YNxGIx5HI53NzcUL16dbbEwdnZGcOHD8eRI0dw7tw5ttab4ziO+/vgQTfHcdw/SG5uLjp37myQRRQIBHB0dMSUKVMMpt5aWVlh165dKC8vh4eHh0G/cADo3bs3q4xeGYxXBh2VgcqZM2dYZfLKgH/KlCmoW7cuVq9eDbFYjObNm+P06dOwsLCARCLB8ePHQURYt24dnJ2d0bhxY2RlZbF1tFKpFDY2Nvjll1/w9ddfs+yvSCRC8+bNceLECWRnZ7M13gMHDoROp0NoaChiY2Nx9OhRSCQSNsW3MhjPysqCUCiElZUVJk+ezPazQYMGbPytWrVi2cPi4mK4u7vDw8ODBdXA61kH4eHhMDc3N2gxVVZWhsTERKhUKuzcuRPA6yxv586dDTL1GRkZuHnzJkpLS9GgQQPI5XKsWrWKBWLPnz9HSEgINBoNNm/ezO7Pz8+Hg4MDHBwcWBb53LlzBlPiq1WrhqVLl+Lly5f48ssvQUQYPXo028bLly8REREBMzMznDhxwuBzI5fL0bJlS7b/lZW+iV6vST58+DCA/18zoEmTJgafl8oWdj/88IPBZzIpKQleXl4GQfSbF1IUCgVbX52cnAyxWAyFQgE7Ozs2NVwul0MsFsPc3JxNAZ8+fTr7HB05cgRCoZAtZyB6ve5aoVBg4sSJWL16Nby9vSEQCHDy5EkkJSUhIiICixYtQkhICIgIV65cwcCBA+Ho6IhevXqxfvNHjx6Fn58f+vfvD71eD2dnZ/YarVu3Zks1AGDJkiUQCARo1aoVm0VRaePGjXBzc2PvU2X7u5EjRyI6OhpEr5dOxMTEICUlBUOGDMH27dvfyo5zHMdxfz886OY4jvsHevz4MY4ePYqcnBwsXLgQzZs3Zz2y/3Uatbe3N7p37/5Wv/DKrGNlJXLgdTbT3d0d9evXZ0XaKoteVQZnb2bG1Wo13NzcEBUVhZYtW8LPzw+ffPIJiF5Xle7cuTPLileuU3348CGSkpIQGhqK4cOHs207ODhALpdj9OjRyMrKgp2dHUQiEZKTk+Hs7IzBgwcjOzsb9evXh1AohFwuZ0FeQUEBhg0bxsYokUgQERGBqVOnGhyLyix6QUEBZs+ezaZ3Vwbu2dnZsLCwABGhfv36Bsc8KysLIpGIBdwAcODAAYMgcM+ePex3gwcPhkQiMbgPANq1awelUmnQd1mv1yM4OBh2dnZsPTcAREREsO0nJCSwdlKVFzZGjBhhsO0pU6a8NUUfAOLj4+Hn52dQXT4yMpJte9OmTez+VatWsZkRbx5fS0tLKBQKqNVqiEQixMbGIicnh2XJjY2NodPpDKqAazQaTJ48ma2vNjMzg0KhQFFREerXrw8vLy9kZmZCLBYjICAAbm5uCAoKglwux969e0FEMDU1hZ2dHTw8PDB//nx2kUYoFCI+Ph5hYWFYs2YNKwA3b948tGjRAtHR0VixYgW6dOkCotfFAbVaLbRaLU6fPo3+/ftDJBJBoVAgKiqKtRnr0KEDJBIJ24egoCCsWrWKBd/r1q1jx6BZs2bYuHEjTp48iePHj2PJkiXw9fWFQCCAXC6HWq2Gra0t4uLiDLbBcRzH/bPwoJvjOO4jce/ePWRmZqJXr14G67D/9ZaYmIjc3FwAYEW5Dhw4wLYzffp0SCQSVrRJr9fD29ubPb9mzZosMx4fHw+5XG6wXjw1NRVExIKhyqy4paUliAiPHz9Gz549IZPJDDKi1tbWCA8Ph1wuh7u7O0xNTSEQCJCbm4uZM2fC3t4eX331Fdzc3GBqagpTU1NER0ejb9++GDduHExNTRETE4OKigrExMQgKyvL4IJBzZo18cMPPyA7O5s9XqPRwMTEhAWX06ZNg7W1NSwtLaHRaGBtbc3WF5uamkIqlUIkEsHc3ByxsbGswFZlpr4yUL969SpEIhEcHBzQqFEjFBcXAwBu3LgBgUCAefPmGbx3lWua9+7dy+47ffo027anpyeeP3/OftexY0e4uLgYZEkrKirg4uKCFi1aGGSdjxw5wgJjjUYDsVjMXu/N2RKVwbVCoYBQKIRGo4FGo0F2djbq1avHpshrNBrExcUhOzsb1atXBxHh0aNH6NKlC6KiopCWlsa226tXLyQkJCAgIIDVALC3t0deXh7S0tJYSy6NRoPk5GRIJBLY2dmhe/fubAbBl19+yT4/a9asYdP1K6fZKxQKVmBNJpNBKBRCIBDA1NQU8fHxSE9PZ9PzbW1tWS2B8vJy1v/bxMTE4GLHli1b3ipWZ2lpicTERCQlJbH9/q1CdLGxsVizZg1fj81xHPcR4UE3x3HcR6i0tBQrV65E7dq13woKKqucBwQEYMyYMfD29oZUKkVWVhaePXuGwsJCODs7w9vbm027njlzJnt+gwYN2DrfyjZNb64Xz8/Ph1wuh6mpqUFWvLLXd2BgIGJjYxEXF8fWpRMRunXrhiZNmqBNmzbIzMyEkZERjIyMAAADBw6ESqWCs7Mzy4B7eXnh2bNnsLOzY1OlIyMj4evrywq9VU5HFggEMDc3x9dff42srCxMmzaNjcXU1BQbNmxAdnY2mwbs7OyMb7/9FsDr7Hfjxo3ZWuTKQHfatGkG1a6NjIwQGRnJ1ihXZtHlcjl0Oh0KCgrYeEQiEYRCIVu7LpfLWSG0yixyZaBbGTBX3j969Gg2Tf/Nx1dWmVcoFDA3N4dOp0N2djYiIyOh0+nQtWtXREVFISIiArGxsWzbffv2RefOnZGdnc3W78+ZMwf79+9H586dkZWVhcmTJ4OIcOrUKRgbG2P9+vXIyspCQkICBAIB9Ho9PDw8YGdnZ1BQTqVSsfF4eHhAp9MhMDAQ1tbWMDY2Rvv27bF69WqYmppCpVKhevXqKCkpgY+PD3r16gWNRgN7e3uWoY6NjWUVzStnF7Ru3Zp97r/++mt2wedNjx49gqenJxwdHd+qA5CbmwsLCwtotVr0798fP//8MwDg6NGjbM38792USiV69+6N06dP486dO+/hr5njOI77qxMSx3Ec99GRSCTUtm1bOnjwIJ07d44yMzNp9OjRNGbMGJo2bRotWLCArKysaMaMGXTp0iUCQP379ycbGxsaOXIk9evXj+7evUthYWG0f/9+6tChA5mamhIR0c6dO6ldu3ZUUlJCdevWJTc3N7Kzs6O9e/fSjh07yMbGhiZPnkyFhYVUVlZG/fv3pxkzZtCCBQtIJBJRQUEBlZWV0fTp08ne3p6NecWKFTRs2DC6ceMGOTo6kkqlIpFIRNeuXaOLFy+Sq6srff7551RYWEhqtZoEAgHVqVOHioqKSKvVEhFR9erVSSqV0tGjR2nmzJn08uVLIiISCoXk7u5O/fv3p5kzZ9Lz58+JiGjAgAEUGRlJY8eOpcePH5ONjQ0JhUKqXbs2paam0uLFi+nZs2d06dIlEolENGbMGLK3t6f169fTyZMnSa/XExGRubk5KZVKSk9Pp+TkZMrNzSVjY2PavXs39erVi7p160aLFi2ie/fuUVJSEu3atYtsbW2pcePGlJqaSq9evaIZM2aQn58ftWjRgpKTk+mHH34gIiKBQEBr1qyhjh07UnJyMh09epSIiG7dukVubm7UqlUrSk5OpkOHDpGzszM9f/6catasSWFhYfTs2TN6/vw5hYSE0IMHD+j27dvk5+dHUqmUHfeVK1eSpaUlPXv2jO7du0dERHPmzKEePXrQkSNHaNasWeTs7ExERJcvX6bS0lKaOHEizZo1i8LCwggA+fr6Ul5eHl29epX69OnDth0XF0fVq1cnjUZDQ4YMISKi06dP08GDB2nIkCF08uRJEgqF5O/vT8+fP6erV69SfHw83blzh1JSUqht27aUl5dHVlZW1K9fP9q3bx+VlpaSTCYjIqJXr16Rm5sbASAioq5du1KLFi3o9OnTtHnzZjYOExMT2r17N6nVagoKCqJevXrR2bNniYgoODiYTp8+Td26daPFixeTl5cXWVlZUadOnejJkydERCSXy0koNDyl8vf3p7lz59KdO3do9uzZVKNGDbKysvqf/1Y5juO4f4AqDvo5juO4v7jKIly//PILhg8fztY00xvTZz09PdGnTx+Dta5WVlYYOXIk5s+fDyLCoEGD2LYKCwuhVCqRkpJiUMk5IyMDKpUKERERLDNes2ZNts3K9d+V04IFAgGbkrxgwQLk5OSw6tRKpRJxcXGws7Njfb6dnZ2Rn5+Ptm3bIjMzk1Utt7a2Ru/evREWFobMzEw2/f7SpUuoU6cOTExM4OzsjL59+4KIkJuby9pgubu7synNlfdLpVKDVk9RUVFYvnw5AgIC8NVXX0Gr1UIikUCn00Gj0aBbt24sGz9nzhz07t0bbdq0QdeuXVlV7CNHjiA8PBzDhw9nRcTojUzq9u3bkZWVhQ4dOsDY2BgAYGNjg5UrVyIrKwtxcXGoVasW9Ho9HB0d4eLiAg8PD9SsWROenp5YsGABhEIh3N3dDdrLWVtbQ6FQwMXFBa1atQIR4ZtvvoGpqSmWL1+O1atXs/vj4uIQGxsLAFi9ejVcXV1BRMjKykJwcDDmzJmDzZs3G9QVaNasGapVq4YVK1YgNDQURIQhQ4bA2NgYGo0GsbGxuHz5MqRSKSQSCWrVqsWmgHfp0gUSiQQKhQIREREsC71u3TqDbPMnn3yCc+fOAXhdTK5FixYQCARISkrCrl272OyEwsJCjBw5kr13Li4uqFWrFgIDA6FSqSAQCBAUFITOnTtjwIABGDVqFGvdVVZWhvv37+P27dtsbT3HcRzHAXx6OcdxHPc/qqioQGFhIW7fvo2nT59iz549aNmy5W+uX/3X4Lxly5Y4f/48ALBgfMyYMSzwvn79OkQiEfr168deb9myZWw7CQkJLEC6e/cuJBIJ+vfvz4q6xcfHY+jQoZBIJIiMjERoaCj69++PgQMHQiwWw8jICFFRUVCr1Zg9ezYLrgQCAfr06QN3d3ds3LiR9eWuUaMGLCws4OTkhGXLlrHe1OXl5YiKikLjxo2RmZkJY2NjSCQSAEBOTg58fHyQmJjIxu3o6IijR4+y4F0qlUIoFOKbb76BnZ0dxGIxcnNzQfS6GruzszNUKhUsLS1Z0H3y5EmYmZnBycnJoF+0UqmEs7MzgoOD4eHhgcGDB8PExARr166FSqVi93/yySdwdHSEp6cnVCoVnj17xtZCu7i4YOXKlXB0dMTq1avZmmQiQt26dTF48GCMHDkS1atXh1KpRKtWrVC/fn2MGDECOTk56NevHywsLCCVSrFx40Z2HAIDA2FhYQEHBwfY2trCxcUF8fHxBm3mKtvHxcfH4+rVq9BoNBAIBLCzs2PB9cWLF9mFjerVq+PUqVPs8/Hzzz/DxMQENWrUMFh3nZmZ+dbnsHbt2hgyZAhGjBiBsLAwdpHIysoKoaGhCA0NhY2NDbtAU7duXXTs2BEpKSkYP348fv311/f4l8VxHMf9U/Ggm+M4jnsnnj9/jl9++QXbt29HkyZNfjMIr1wvHhkZiczMTJYhTUpKwuHDh6HX61nV8GHDhkGv1+Ply5csCCYi9OnThwXe7dq1g7OzM4qKitg47t27x3p3Vwbib1YvV6lULFv+Zgs1oVDI7j958iQEAgGcnJxgYmLCsuiVLZ88PDzw1VdfITg4GBs3boSrqytEIhHOnj2LCRMmwNnZGT179mTb9vb2Rnl5OYKDg7Fs2TJIpVIolUoAr9eEOzg4oE2bNiAiuLm5wcbGBm3btkVGRgbr1zxlyhQEBwdjzZo1WLVqFVsvLhaL0blzZwCvs8tRUVEQCATw8/NDx44d2f1BQUHQarXYunUrvLy8sHLlSjYzwMTEBO3bt0dERARycnLQqFEjNvbw8HBERUVhyZIlaNKkCUJCQiCVSmFhYQEvLy92fCsLm4WFhbHjnpuby9apR0ZGshoACxcuNPhMfP/99+z9O3XqFBQKBZo2bYqSkhJ2f1lZGZo2bQqJRIIFCxawugEAcPbsWdjZ2UEmkyE5ORnHjh2DXq/Ht99++1YP8393c3BwQLt27fDpp5/i+PHjBjMwOI7jOO7P4EE3x3Ec917cvn0bY8aMQWxsLKpXr47AwEDUr18fXbt2RUREBAvA6f8KgRER/P39MXDgQIOiasuWLcP69etZkFkZwK1btw7nzp2DVqtF3bp1Dap3d+jQAaamprhy5Qq77/HjxzAyMsKwYcPYfdevX2ctphwcHAymBSclJcHFxcUgi379+nVoNBpYWFhArVazIH3Lli1sP8RiMdzd3Q3aeUmlUoSGhrLg3cPDAwKBAMHBwYiLi4OrqyvS0tIQHh4OW1tbbN26Fc2bN8f69esRFRUFY2NjeHt7IzAwEHl5ecjJyTEoSPbll18CeJ1dbteuHYgIwcHB2LFjB7s/OTkZRK9bXJmZmaFatWqIj49HUFAQy/ZLJBJUq1YNt27dglKpNMjUx8fHIy8vDy1btmTvzZtBcWpqKgQCAUaPHm3wOXjw4AErmldZpR2AwUUJuVyOuXPnsuO/detWyGQyREZG4ocffmABcGlpKVsqYGdnh7Fjx+Ls2bPIy8vDsWPH0KpVK7ZkoHKKf+XnTCaT/WaRs9TUVIN+6xzHcRz3rvGgm+M4jqsSer0eL168QHl5OSoqKrBz5040b94cXl5esLOzg4ODA1tbbWJiAnd3dxYgV95sbGxQs2ZNSCQS1KhRA3v37oVer2fVqB0cHHDhwgX2mqNGjYJAIMDKlSvZfW9OA2/atCnrlbx7924QEdavX28w7vT0dJiYmODp06cG9wcFBSE+Pt7gvjd7Xfv5+bHgvbJ/dWVfa19fXxQUFODTTz8F0ete4v7+/mzKtaenJ4gI9vb2bBuVVcors8WVr9+2bVsWeGo0GoSEhCA+Ph5ffvkldDodhEIhunTpYtBOLCYmBv7+/mjevDm7783th4eHG1yQaNq0KXQ6ncGxBYAxY8aAiDB37lyD+48cOQIjIyNERESwKeClpaWIj483eD+NjY3Rv39/LFiwAEOGDGHT/729vfHll19i6dKlWLhwIdq3b8+m6L/5fIFAgPj4eHz++eeYMWMGJkyYgNmzZ+PIkSOoqKjAhQsXsG/fPuzYsQPHjh3Ds2fP/vMHleM4juP+JB50cxzHcX9ply9fxmeffYaOHTsiKioKGo3md9eNu7q64osvvsDUqVNhZ2cHuVyObt264dSpU6ioqEDHjh0hEAjw+eef48mTJzh37hzUarVBFn3fvn2oqKhA06ZNoVQq8cMPP7Dx3Lx5E2q1GgkJCSxAB4Dly5eDiLBkyRJ234oVK9h27ezsDNYEh4aGIiAgwCCYLSkpgbm5OVq1amUwvfnOnTuQSCT49NNP2X2vXr1ivc2JCAsXLmS/+/7770FEmDp1qsGx3LVrF1tH/6bvv/8eYrEY3bp1Y8H4/fv3Dfq5h4aG4uzZswBeFxzz8/ODmZmZQQ93vV7Pis0lJycbrL0+duwYzM3NIRKJ0Lx5c+zevRu3bt1C27Zt/+PUb4FAYBBgW1lZ4dNPP8Xp06dx+PBhbN++HQcOHOBrrjmO47i/JB50cxzHcX8rFRUV2LVrF5o2bWpQBVsgEKBGjRoIDw83mBqtUCig1WpB9LoadXBwMMzNzVnf627dumHUqFEG2yIieHl5IS0tDU5OTpBKpRg/fjzu3bsH4HXwKpVKUadOHZa51ev16NatG0QiEQuAS0tLERwczLZpa2uLLVu2oLy8HD/++COUSiXi4+MNpsZ/9913ICL079/fIBs9derUtwLpuXPnGoz5888/Z+vbK9ewZ2ZmGhy/8ePHszXzpaWl7P6lS5dCKBQiKSmJTcs/deqUwQUJotfFyObNm4elS5fCy8uLTVlftmwZ7t27h+LiYkyaNAlmZmbsdwMHDsSIESPQo0cP6HQ6g6UFb2brf6sOgFQqRfv27XHo0CG8fPkS5eXl7/LjxHEcx3HvnQD4v+aVHMdxHPc3o9fr6dmzZ6TX60mr1Rr0Sn716hWJRCISi8VUXl5OW7dupR9++IEKCwvJyMiITExM6NWrV7RixQq6ffv2f3wtoVBIQqGQWrZsSTVq1KDbt2/T4sWLqaSkhBo3bkw9e/YkFxcXGjduHH377bcUFBREaWlpFB0dTfXq1aNr166xbTk5OVGnTp3o+fPnNHv2bHJ2dqahQ4dS69atSS6X05w5cygtLY3q1atHQ4YModjYWCIi+uyzz2jixInUqlUrGjhwIIWGhlJ6ejrNmDGDbVulUlHHjh0pMjKSvvvuO9q0aRNFRERQ3759qVmzZiSRSGjatGn06aefkpWVFfXs2ZO6du1KdnZ2tHnzZuratSs9efKE6tSpQ8nJyfTy5UsaMWIEPXz48HePTWVP8jdVq1aNZDIZPX/+nIqLi0mr1VJoaCilpqaSQCCg/Px8Ki0tJWNjYwoJCaFXr17RwYMH6dGjRwSATE1NKSoqiszNzf+bjwPHcRzH/SXxoJvjOI77qOn1enr8+DE9ffqUpFIp/fDDDzRv3jw6ePCgweNEIhFVq1aNnj9/To8ePaJXr16RRqMhBwcHevToEd24ccPg8QqFgoqLi1mA/+DBAyotLf3NMVQGrVqtlho3bkwmJib0888/0+HDh+nFixfk6upKDRs2JI1GQ8ePH6dDhw7Ry5cvyc/Pj6Kjo+mnn36iQ4cO/dt9rNy+TqcjFxcXkkqldOvWLbpz5w67KCEUCgmvZ8CRXC4nY2NjunPnjsH+q1QqKioqemv7Wq2WkpKSKDg4mNRqNanVavLx8SFPT8//5a3gOI7juH8kHnRzHMdx3G+4desW5eXl0YsXL0ir1ZKbmxuZmZn95mMB0MWLF+nevXtUXl5OpqamVL16dbp58yZt3bqVZYkfPnxIV69epQMHDtC//vvVaDTk7u5Oer2eXr16RQqFgpydnSk0NJROnDhB58+fp6dPn5JarSYvLy8KCgqi3NxcunbtGr148YKkUikJBAK6desWvXz58q0xenp6kqurK1lYWBAAMjExoYYNG1JQUBDt2bOHHj58SAKBgCwsLKhu3boswH7y5AlJpVIyMTEhmUxGR44coTNnzlBhYSEpFAqytbWlxMREUiqV7/5N4DiO47h/AB50cxzHcdwHdvPmTcrNzaUnT56QTCYjS0tLiomJIYVC8ae3XVRURNu3b6c7d+5QSUkJ6XQ6CgoKouDgYBIIBO9g9BzHcRzH/S940M1xHMdxHMdxHMdx74nwPz+E4ziO4ziO4ziO47g/ggfdHMdxHMdxHMdxHPee8KCb4ziO4ziO4ziO494THnRzHMdxHMdxHMdx3HvCg26O4ziO4ziO4ziOe0940M1xHMdxHMdxHMdx7wkPujmO4ziO4ziO4zjuPeFBN8dxHMdxHMdxHMe9Jzzo5jiO4ziO4ziO47j3hAfdHMdxHMdxHMdxHPee8KCb4ziO4ziO4ziO494THnRzHMdxHMdxHMdx3HvCg26O4ziO4ziO4ziOe0940M1xHMdxHMdxHMdx7wkPujmO4ziO4ziO4zjuPeFBN8dxHMdxHMdxHMe9Jzzo5jiO4ziO4ziO47j3hAfdHMdxHMdxHMdxHPee8KCb4ziO4ziO4ziO494THnRzHMdxHMdxHMdx3Hvy/wAM5YPDXNGfEwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "cb1ae550", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "({'node': '98'},\n", - " {'reach': '45l1', 'distance': 37.20599457458005},\n", - " [{'node': '98'}, {'reach': '45l1', 'distance': 37.20599457458005}])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network.recall(252), network.recall(133), network.recall([252, 133]) " - ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_network(network)" + ] + }, + { + "cell_type": "markdown", + "id": "5d3030f5", + "metadata": {}, + "source": [ + "Notice that in the visualisation above, some graph nodes have a thicker outline — these are the *nodes* (junctions and boundaries), while the others are *break points* along each reach.\n", + "\n", + "#### Mapping original IDs to integer IDs\n", + "\n", + "Internally, the `Network` relabels all nodes and break points with consecutive integers for efficient indexing. The original IDs used by the simulation tool are preserved and can be looked up with `find()`:\n", + "\n", + "In this Res1D example the original node IDs are strings. `find(node=...)` returns the corresponding integer ID:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d9d23a8b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:04.995517Z", + "iopub.status.busy": "2026-08-25T14:20:04.995321Z", + "iopub.status.idle": "2026-08-25T14:20:05.000066Z", + "shell.execute_reply": "2026-08-25T14:20:04.998667Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "41ca197f", - "metadata": {}, - "source": [ - "## Integration with `modelskill`\n", - "\n", - "Wrap a `Network` in a `NetworkModelResult` to make it compatible with the standard `modelskill` comparison workflow. The `item` argument selects which quantity to use when more than one is available in the network:" + "data": { + "text/plain": [ + "478" ] - }, + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(node=\"98\")" + ] + }, + { + "cell_type": "markdown", + "id": "ae495c5d", + "metadata": {}, + "source": [ + "Break points are identified in the original network by the edge (reach) they belong to and their distance from the start node.\n", + "\n", + "> **Note:** The current `Network` implementation assumes a directed edge, so distance is always measured from the start node." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "30c88717", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.002631Z", + "iopub.status.busy": "2026-08-25T14:20:05.002358Z", + "iopub.status.idle": "2026-08-25T14:20:05.007373Z", + "shell.execute_reply": "2026-08-25T14:20:05.005888Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 13, - "id": "edec2e5a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - ": WaterLevel" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "network_model = ms.NetworkModelResult(network, item=\"WaterLevel\")\n", - "network_model" + "data": { + "text/plain": [ + "240" ] - }, + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(reach=\"44l1\", distance=44.841)" + ] + }, + { + "cell_type": "markdown", + "id": "a7e41a31", + "metadata": {}, + "source": [ + "Multiple IDs can be looked up in a single call. For break points, each distance value corresponds to the edge at the same position in the `edge` list (one-to-one pairing):" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e25a4ba8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.009708Z", + "iopub.status.busy": "2026-08-25T14:20:05.009423Z", + "iopub.status.idle": "2026-08-25T14:20:05.015680Z", + "shell.execute_reply": "2026-08-25T14:20:05.014411Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "5905e267", - "metadata": {}, - "source": [ - "To evaluate the model we need observations at network nodes. These are represented by `NodeObservation`, which requires an integer node ID obtained via `Network.find()`.\n", - "\n", - "In this example we create synthetic sensor observations by extracting data from the network dataset and adding random noise to simulate real-world measurement error and timing jitter:" + "data": { + "text/plain": [ + "([455, 5, 68], [240, 244])" ] - }, + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.find(node=[\"92\", \"101\", \"113\"]), network.find(reach=[\"44l1\", \"45l1\"], distance=[44.841, 37.206])" + ] + }, + { + "cell_type": "markdown", + "id": "c4f36cfd", + "metadata": {}, + "source": [ + "Use `recall()` to translate integer IDs back to the original identifiers. This is useful when you want to know which original node or break point corresponds to a given integer ID:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cb1ae550", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.018483Z", + "iopub.status.busy": "2026-08-25T14:20:05.018235Z", + "iopub.status.idle": "2026-08-25T14:20:05.024805Z", + "shell.execute_reply": "2026-08-25T14:20:05.022827Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 14, - "id": "817e1800", - "metadata": {}, - "outputs": [], - "source": [ - "ds = network.to_dataset()\n", - "\n", - "# Script to generate dummy sensor data\n", - "sensor_1 = ds[\"WaterLevel\"].sel(node=30).to_pandas().rename(\"water_level@sens1\")\n", - "sensor_2 = ds[\"WaterLevel\"].sel(node=54).to_pandas().rename(\"water_level@sens2\")\n", - "sensor_3 = ds[\"WaterLevel\"].sel(node=71).to_pandas().rename(\"water_level@sens3\")\n", - "\n", - "perfect_sensors = [sensor_1, sensor_2, sensor_3]\n", - "real_sensors = []\n", - "\n", - "for n, sensor in enumerate(perfect_sensors, start=1):\n", - " sensor += np.random.normal(0, 0.1, len(sensor))\n", - " sensor.index = [sensor.index[i] + pd.Timedelta(s, unit=\"s\") for i, s in enumerate(np.random.uniform(-10, 10, len(sensor)))]\n", - " sensor.sort_index(inplace=True)\n", - " if n == 2:\n", - " sensor = sensor.iloc[30:]\n", - " if n == 3:\n", - " sensor = pd.concat([sensor.iloc[:50], sensor.iloc[70:]])\n", - "\n", - " real_sensors.append(sensor)\n", - " sensor.to_csv(f\"../tests/testdata/network_sensor_{n}.csv\")\n", - "\n", - "sensor_1 = real_sensors[0]\n", - "sensor_2 = real_sensors[1]\n", - "sensor_3 = real_sensors[2]" + "data": { + "text/plain": [ + "({'reach': '47l1', 'distance': 26.7092518454833},\n", + " {'reach': '1l1', 'distance': 0.0},\n", + " [{'reach': '47l1', 'distance': 26.7092518454833},\n", + " {'reach': '1l1', 'distance': 0.0}])" ] - }, + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network.recall(252), network.recall(133), network.recall([252, 133]) " + ] + }, + { + "cell_type": "markdown", + "id": "41ca197f", + "metadata": {}, + "source": [ + "## Integration with `modelskill`\n", + "\n", + "Wrap a `Network` in a `NetworkModelResult` to make it compatible with the standard `modelskill` comparison workflow. The `item` argument selects which quantity to use when more than one is available in the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "edec2e5a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.028134Z", + "iopub.status.busy": "2026-08-25T14:20:05.027832Z", + "iopub.status.idle": "2026-08-25T14:20:05.040168Z", + "shell.execute_reply": "2026-08-25T14:20:05.038998Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 15, - "id": "66d1b420", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens2 0.000501 0.721882 " - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The name is taken from the name of the series\n", - "node_id = network.find(reach=\"117l1\", distance=48.7)\n", - "single_obs = ms.NodeObservation(sensor_2, at=node_id)\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" + "data": { + "text/plain": [ + ": WaterLevel" ] - }, + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "network_model = ms.NetworkModelResult(network, item=\"WaterLevel\")\n", + "network_model" + ] + }, + { + "cell_type": "markdown", + "id": "5905e267", + "metadata": {}, + "source": [ + "To evaluate the model we need observations at network nodes. These are represented by `NodeObservation`, which is addressed the way the model names the location: a node's name, or a break point as a `(reach, distance)` pair. The integers the graph uses are an internal index, and observations never mention them.\n", + "\n", + "In this example we create synthetic sensor observations by extracting data from the network dataset and adding random noise to simulate real-world measurement error and timing jitter:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "817e1800", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.043090Z", + "iopub.status.busy": "2026-08-25T14:20:05.042858Z", + "iopub.status.idle": "2026-08-25T14:20:05.064739Z", + "shell.execute_reply": "2026-08-25T14:20:05.063884Z" + } + }, + "outputs": [], + "source": [ + "ds = network.to_dataset()\n", + "\n", + "# Script to generate dummy sensor data. Two sensors sit at named nodes and one\n", + "# at a break point along a reach, which is the pair of forms an observation takes.\n", + "sensor_locations = [\"98\", (\"117l1\", 48.7), \"101\"]\n", + "\n", + "\n", + "def graph_id(at):\n", + " if isinstance(at, str):\n", + " return network.find(node=at)\n", + " reach, distance = at\n", + " return network.find(reach=reach, distance=distance)\n", + "\n", + "\n", + "sensor_1, sensor_2, sensor_3 = (\n", + " ds[\"WaterLevel\"].sel(node=graph_id(at)).to_pandas().rename(f\"water_level@sens{n}\")\n", + " for n, at in enumerate(sensor_locations, start=1)\n", + ")\n", + "\n", + "perfect_sensors = [sensor_1, sensor_2, sensor_3]\n", + "real_sensors = []\n", + "\n", + "for n, sensor in enumerate(perfect_sensors, start=1):\n", + " sensor += np.random.normal(0, 0.1, len(sensor))\n", + " sensor.index = [sensor.index[i] + pd.Timedelta(s, unit=\"s\") for i, s in enumerate(np.random.uniform(-10, 10, len(sensor)))]\n", + " sensor.sort_index(inplace=True)\n", + " if n == 2:\n", + " sensor = sensor.iloc[30:]\n", + " if n == 3:\n", + " sensor = pd.concat([sensor.iloc[:50], sensor.iloc[70:]])\n", + "\n", + " real_sensors.append(sensor)\n", + " sensor.to_csv(f\"../tests/testdata/network_sensor_{n}.csv\")\n", + "\n", + "sensor_1 = real_sensors[0]\n", + "sensor_2 = real_sensors[1]\n", + "sensor_3 = real_sensors[2]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "66d1b420", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.067278Z", + "iopub.status.busy": "2026-08-25T14:20:05.067089Z", + "iopub.status.idle": "2026-08-25T14:20:05.115372Z", + "shell.execute_reply": "2026-08-25T14:20:05.114441Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 16, - "id": "ed1f9094", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "\n", - " si r2 \n", - "observation \n", - "network_sensor_2 0.000501 0.721882 " - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\n", + "
" ], - "source": [ - "# The name is taken from the name of the file\n", - "path_to_sensor2 = \"../tests/testdata/network_sensor_2.csv\"\n", - "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id)\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens2 79 0.011247 0.106083 0.105485 0.082545 0.85165 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens2 0.000545 0.720208 " ] - }, + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is taken from the name of the series\n", + "# sensor 2 sits at a break point, addressed by its reach and distance along it\n", + "at = (\"117l1\", 48.7)\n", + "single_obs = ms.NodeObservation(sensor_2, at=at)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ed1f9094", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.117280Z", + "iopub.status.busy": "2026-08-25T14:20:05.117046Z", + "iopub.status.idle": "2026-08-25T14:20:05.150538Z", + "shell.execute_reply": "2026-08-25T14:20:05.149228Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 17, - "id": "de621fec", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
Sensor 2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc si \\\n", - "observation \n", - "Sensor 2 80 0.007241 0.097285 0.097015 0.077789 0.850782 0.000501 \n", - "\n", - " r2 \n", - "observation \n", - "Sensor 2 0.721882 " - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
network_sensor_2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\n", + "
" ], - "source": [ - "# The name is passed\n", - "single_obs = ms.NodeObservation(path_to_sensor2, at=node_id, name=\"Sensor 2\")\n", - "cmp = ms.match(single_obs, network_model)\n", - "cmp.skill()" - ] - }, - { - "cell_type": "markdown", - "id": "2357349d", - "metadata": {}, - "source": [ - "### Plotting" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "network_sensor_2 79 0.011247 0.106083 0.105485 0.082545 0.85165 \n", + "\n", + " si r2 \n", + "observation \n", + "network_sensor_2 0.000545 0.720208 " ] - }, + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is taken from the name of the file\n", + "path_to_sensor2 = \"../tests/testdata/network_sensor_2.csv\"\n", + "single_obs = ms.NodeObservation(path_to_sensor2, at=at)\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "de621fec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.152192Z", + "iopub.status.busy": "2026-08-25T14:20:05.152048Z", + "iopub.status.idle": "2026-08-25T14:20:05.176449Z", + "shell.execute_reply": "2026-08-25T14:20:05.175587Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 18, - "id": "923a1d93", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
Sensor 2790.0112470.1060830.1054850.0825450.851650.0005450.720208
\n", + "
" ], - "source": [ - "cmp = ms.match(single_obs, network_model)\n", - "cmp.plot()\n", - "cmp.plot.timeseries();" + "text/plain": [ + " n bias rmse urmse mae cc si \\\n", + "observation \n", + "Sensor 2 79 0.011247 0.106083 0.105485 0.082545 0.85165 0.000545 \n", + "\n", + " r2 \n", + "observation \n", + "Sensor 2 0.720208 " ] - }, + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The name is passed\n", + "single_obs = ms.NodeObservation(path_to_sensor2, at=at, name=\"Sensor 2\")\n", + "cmp = ms.match(single_obs, network_model)\n", + "cmp.skill()" + ] + }, + { + "cell_type": "markdown", + "id": "2357349d", + "metadata": {}, + "source": [ + "### Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "923a1d93", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.178104Z", + "iopub.status.busy": "2026-08-25T14:20:05.177945Z", + "iopub.status.idle": "2026-08-25T14:20:05.761740Z", + "shell.execute_reply": "2026-08-25T14:20:05.760245Z" + } + }, + "outputs": [ { - "cell_type": "markdown", - "id": "02e77cf0", - "metadata": {}, - "source": [ - "## Multiple sensors\n", - "\n", - "When you have observations at several nodes you can use `NodeObservation.from_multiple()` to create a list of `NodeObservation` objects. Pass `nodes` as a `dict` mapping each node ID to either a column name/index within a shared `data` source, or to a separate data source entirely:" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "cell_type": "code", - "execution_count": 19, - "id": "752261bf", - "metadata": {}, - "outputs": [], - "source": [ - "sensor_df = pd.concat(real_sensors, axis=1)" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmp = ms.match(single_obs, network_model)\n", + "cmp.plot()\n", + "cmp.plot.timeseries();" + ] + }, + { + "cell_type": "markdown", + "id": "02e77cf0", + "metadata": {}, + "source": [ + "## Multiple sensors\n", + "\n", + "When you have observations at several nodes you can use `NodeObservation.from_multiple()` to create a list of `NodeObservation` objects. Pass `nodes` as a `dict` mapping each node ID to either a column name/index within a shared `data` source, or to a separate data source entirely:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "752261bf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.765128Z", + "iopub.status.busy": "2026-08-25T14:20:05.764941Z", + "iopub.status.idle": "2026-08-25T14:20:05.775259Z", + "shell.execute_reply": "2026-08-25T14:20:05.772228Z" + } + }, + "outputs": [], + "source": [ + "sensor_df = pd.concat(real_sensors, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9acfaf6f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:05.781391Z", + "iopub.status.busy": "2026-08-25T14:20:05.781041Z", + "iopub.status.idle": "2026-08-25T14:20:06.015467Z", + "shell.execute_reply": "2026-08-25T14:20:06.014152Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 20, - "id": "9acfaf6f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
water_level@sens2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", - "water_level@sens2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens1 0.000509 0.950559 \n", - "water_level@sens2 0.000501 0.721882 \n", - "water_level@sens3 0.000529 0.871119 " - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0058920.1035770.1034090.0807410.9774310.0005310.955162
water_level@sens2790.0112470.1060830.1054850.0825450.8516500.0005450.720208
water_level@sens389-0.0238980.1026050.0997830.0864510.1610080.000509-0.056709
\n", + "
" ], - "source": [ - "multi_obs = ms.NodeObservation.from_multiple(data=sensor_df, nodes={30: \"water_level@sens1\", 54: \"water_level@sens2\", 71: \"water_level@sens3\"})\n", - "ms.match(multi_obs, network_model).skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens1 110 0.005892 0.103577 0.103409 0.080741 0.977431 \n", + "water_level@sens2 79 0.011247 0.106083 0.105485 0.082545 0.851650 \n", + "water_level@sens3 89 -0.023898 0.102605 0.099783 0.086451 0.161008 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000531 0.955162 \n", + "water_level@sens2 0.000545 0.720208 \n", + "water_level@sens3 0.000509 -0.056709 " ] - }, + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "multi_obs = ms.NodeObservation.from_multiple(data=sensor_df, nodes=dict(zip(sensor_locations, sensor_df.columns)))\n", + "ms.match(multi_obs, network_model).skill()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d7a0acf1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T14:20:06.018707Z", + "iopub.status.busy": "2026-08-25T14:20:06.018293Z", + "iopub.status.idle": "2026-08-25T14:20:06.126797Z", + "shell.execute_reply": "2026-08-25T14:20:06.124201Z" + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": 21, - "id": "d7a0acf1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0008440.0989450.0989410.0760150.9749860.0005090.950559
network_sensor_2800.0072410.0972850.0970150.0777890.8507820.0005010.721882
water_level@sens389-0.0208130.1046320.1025410.0821040.9360940.0005290.871119
\n", - "
" - ], - "text/plain": [ - " n bias rmse urmse mae cc \\\n", - "observation \n", - "water_level@sens1 110 0.000844 0.098945 0.098941 0.076015 0.974986 \n", - "network_sensor_2 80 0.007241 0.097285 0.097015 0.077789 0.850782 \n", - "water_level@sens3 89 -0.020813 0.104632 0.102541 0.082104 0.936094 \n", - "\n", - " si r2 \n", - "observation \n", - "water_level@sens1 0.000509 0.950559 \n", - "network_sensor_2 0.000501 0.721882 \n", - "water_level@sens3 0.000529 0.871119 " - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
nbiasrmseurmsemaeccsir2
observation
water_level@sens11100.0058920.1035770.1034090.0807410.9774310.0005310.955162
network_sensor_2790.0112470.1060830.1054850.0825450.8516500.0005450.720208
water_level@sens389-0.0238980.1026050.0997830.0864510.1610080.000509-0.056709
\n", + "
" ], - "source": [ - "multi_obs = ms.NodeObservation.from_multiple(nodes={30: sensor_1, 54: path_to_sensor2, 71: sensor_3})\n", - "ms.match(multi_obs, network_model).skill()" + "text/plain": [ + " n bias rmse urmse mae cc \\\n", + "observation \n", + "water_level@sens1 110 0.005892 0.103577 0.103409 0.080741 0.977431 \n", + "network_sensor_2 79 0.011247 0.106083 0.105485 0.082545 0.851650 \n", + "water_level@sens3 89 -0.023898 0.102605 0.099783 0.086451 0.161008 \n", + "\n", + " si r2 \n", + "observation \n", + "water_level@sens1 0.000531 0.955162 \n", + "network_sensor_2 0.000545 0.720208 \n", + "water_level@sens3 0.000509 -0.056709 " ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" } - ], - "metadata": { - "kernelspec": { - "display_name": "modelskill (3.13.13)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.13" - } + ], + "source": [ + "multi_obs = ms.NodeObservation.from_multiple(nodes=dict(zip(sensor_locations, [sensor_1, path_to_sensor2, sensor_3])))\n", + "ms.match(multi_obs, network_model).skill()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "modelskill (3.13.13)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/roadmap/features/network-models.md b/roadmap/features/network-models.md index e6993e05e..246c8ad75 100644 --- a/roadmap/features/network-models.md +++ b/roadmap/features/network-models.md @@ -26,5 +26,5 @@ In active development. MIKE 1D, MIKE 11 and EPANET result files can be read toda MOUSE and Water Hammer results are not read yet: no shareable result file exists for either format, so support cannot be verified. SWMM results are not read yet: the reach connectivity lives in the companion '.inp' input file, which modelskill does not read yet. -The layer that reads those files and builds the network is proposed for mikeio1d rather than modelskill, where the formats, the fixtures and a first graph conversion already live (ADR-013). ModelSkill would keep the model result, the observations and the matching, and require the upstream module. The release is coordinated with it: this feature ships once both projects can ship, so that nothing is published here which then moves. +The layer that reads those files and builds the network lives in mikeio1d, where the formats, the fixtures and a first graph conversion already were (ADR-013). ModelSkill keeps the model result, the observations and the matching, and requires `mikeio1d[network]`. The release is coordinated: this feature ships once mikeio1d has released the module it depends on. diff --git a/tests/testdata/README.md b/tests/testdata/README.md index a6f4a71c6..63bb46db9 100644 --- a/tests/testdata/README.md +++ b/tests/testdata/README.md @@ -10,16 +10,20 @@ These network files come from | File | Format | Used for | |---|---|---| -| `network_cali.res11` | MIKE 11 | `Network.from_mike` coverage for `.res11` | -| `epanet.res` | EPANET | `Network.from_epanet` coverage | -| `epanet.resx` | EPANET (MIKE+) | the `resx=` companion — extra node quantities merged onto the `.res` network | -| `epanet.inp` | EPANET input | the `inp=` companion — real pipe lengths, which the `.res` does not carry | -| `swmm.out` | SWMM | asserting `.out` is refused — its reach connectivity lives in a companion `.inp` we do not read yet (#689) | +| `network_cali.res11` | MIKE 11 | nothing here any more — see below | +| `epanet.res` | EPANET | nothing here any more — see below | +| `epanet.resx` | EPANET (MIKE+) | extra node quantities, merged onto the `.res` network | +| `epanet.inp` | EPANET input | real pipe lengths, which the `.res` does not carry | +| `swmm.out` | SWMM | nothing here any more — see below | + +Reading these formats moved to mikeio1d with the rest of the topology layer +(ADR-013), and the tests that covered it moved with it. The files are kept because +mikeio1d has the same copies and modelskill may want EPANET-side coverage of its +own; nothing in this repository reads them today except `network.res1d`. `epanet.resx` and `epanet.inp` pair with `epanet.res`: same run, same IDs. The `.resx` node and reach IDs are a strict subset of the `.res` ones, and the `.inp` `[PIPES]` IDs cover every `.res` reach except the pump. -`swmm.out` is kept without its `.inp` on purpose. It pins the refusal, so the test -fails the day we add SWMM support or a future mikeio1d starts reporting reach -connectivity for it. +`swmm.out` is kept without its `.inp` on purpose: the refusal it used to pin is +mikeio1d's now, and the file is the fixture that refusal needs. diff --git a/tests/testdata/network_sensor_1.csv b/tests/testdata/network_sensor_1.csv index 904d9eb79..6f46c2869 100644 --- a/tests/testdata/network_sensor_1.csv +++ b/tests/testdata/network_sensor_1.csv @@ -1,111 +1,111 @@ ,water_level@sens1 -1994-08-07 16:35:06.721389014,193.7479319011718 -1994-08-07 16:36:11.808982110,193.9276622504125 -1994-08-07 16:36:58.463517098,193.73969537883863 -1994-08-07 16:38:50.136489724,193.5324026294447 -1994-08-07 16:39:54.184260240,193.75098664628783 -1994-08-07 16:41:02.301898383,193.9631823043365 -1994-08-07 16:41:48.047551850,193.88949067602914 -1994-08-07 16:43:03.765627271,193.73298338692013 -1994-08-07 16:43:59.271576674,193.518740505735 -1994-08-07 16:44:53.976575879,193.80052813920184 -1994-08-07 16:45:52.150380498,193.76709749688646 -1994-08-07 16:46:59.335689619,193.87266429057766 -1994-08-07 16:47:48.671800096,193.61027606890661 -1994-08-07 16:49:09.441634441,193.90646493021583 -1994-08-07 16:50:05.221428246,193.68537026321115 -1994-08-07 16:51:31.750429245,194.00527903620747 -1994-08-07 16:52:44.709396591,193.960610633433 -1994-08-07 16:54:15.295748944,193.87369664367992 -1994-08-07 16:56:09.081416788,193.74406275881358 -1994-08-07 16:57:14.043033644,193.71501017501876 -1994-08-07 16:58:18.210601321,193.83703675670696 -1994-08-07 16:59:03.257072206,194.06250124233108 -1994-08-07 17:00:06.081835904,193.97168058658363 -1994-08-07 17:01:06.426608705,193.6410669817052 -1994-08-07 17:02:22.837775497,193.7119913501634 -1994-08-07 17:03:18.768918912,193.8826429315821 -1994-08-07 17:04:17.424400499,193.76142364154504 -1994-08-07 17:05:06.371871595,193.82686832219773 -1994-08-07 17:06:17.991770538,193.7814248098547 -1994-08-07 17:07:14.600956935,193.747104244197 -1994-08-07 17:08:19.929202980,193.88962326399343 -1994-08-07 17:09:18.863933688,193.8894988894418 -1994-08-07 17:10:21.785300698,193.7678915506987 -1994-08-07 17:11:22.760047207,193.8350592978198 -1994-08-07 17:12:16.293904286,193.76937160755946 -1994-08-07 17:13:18.937531227,193.7072710276047 -1994-08-07 17:14:09.393470503,194.01678510826014 -1994-08-07 17:15:16.341863122,193.81790025709154 -1994-08-07 17:16:17.315241669,193.96796138622275 -1994-08-07 17:17:15.246401107,193.93776810871083 -1994-08-07 17:18:05.749523838,193.92373793354915 -1994-08-07 17:19:22.112742914,193.75041032904946 -1994-08-07 17:20:31.310425275,193.92249310948324 -1994-08-07 17:21:21.982712671,193.82335772625748 -1994-08-07 17:22:23.767907448,193.95466062588378 -1994-08-07 17:23:39.680152861,194.013618376674 -1994-08-07 17:24:38.147955485,194.11815372525726 -1994-08-07 17:25:38.420371252,194.50584562429492 -1994-08-07 17:26:24.408303070,194.54446646687336 -1994-08-07 17:27:31.105998416,194.46853129987517 -1994-08-07 17:28:34.880232331,194.55187457703428 -1994-08-07 17:29:37.175071072,194.86809034869842 -1994-08-07 17:30:35.271697419,194.70284194184958 -1994-08-07 17:31:31.204858260,194.98822903414495 -1994-08-07 17:32:24.847235710,195.24737706568624 -1994-08-07 17:33:36.679829931,195.2715904795984 -1994-08-07 17:34:37.932637257,195.1555004434547 -1994-08-07 17:35:25.487179907,195.11808508664626 -1994-08-07 17:36:22.047650391,195.35302938305526 -1994-08-07 17:37:22.665545301,195.058608262039 -1994-08-07 17:38:23.922713966,195.03890774364643 -1994-08-07 17:39:37.300808590,195.10925487796052 -1994-08-07 17:40:39.123378882,194.9197940042712 -1994-08-07 17:41:39.736323741,194.91541376013848 -1994-08-07 17:42:32.624612495,194.84419544155747 -1994-08-07 17:43:38.386604464,194.91238993528924 -1994-08-07 17:44:35.752954642,194.80146002502337 -1994-08-07 17:45:47.706770126,194.91559552756155 -1994-08-07 17:46:56.228029771,194.72765509600865 -1994-08-07 17:47:50.302639903,194.72477357208479 -1994-08-07 17:48:51.313688841,194.64138661647883 -1994-08-07 17:50:04.027931558,194.66788700646532 -1994-08-07 17:50:59.170111019,194.69887586125873 -1994-08-07 17:52:19.507804755,194.75091927194543 -1994-08-07 17:53:36.244289704,194.73563801241843 -1994-08-07 17:54:46.006725041,194.35800960937343 -1994-08-07 17:55:50.875697661,194.41711389439024 -1994-08-07 17:57:01.668197445,194.29313729304636 -1994-08-07 17:58:16.481604045,194.45199484204932 -1994-08-07 17:59:47.768779742,194.45872420226013 -1994-08-07 18:00:49.317493448,194.4314547834637 -1994-08-07 18:02:02.027423669,194.2515095971401 -1994-08-07 18:03:55.326990060,194.2601910363553 -1994-08-07 18:05:08.677524139,194.09049632407513 -1994-08-07 18:05:55.807125909,194.25764674606657 -1994-08-07 18:07:06.508171149,194.15893464151893 -1994-08-07 18:08:14.768585338,194.32278841101814 -1994-08-07 18:08:59.434113874,194.1892503649891 -1994-08-07 18:10:10.361033654,194.3360223971569 -1994-08-07 18:11:39.416513356,193.91053863482347 -1994-08-07 18:13:12.292137298,194.03847881603537 -1994-08-07 18:14:50.579821036,194.19255380323284 -1994-08-07 18:16:11.445107220,194.2372052362117 -1994-08-07 18:17:13.979038396,194.02910039993844 -1994-08-07 18:19:11.411173338,194.1543403568542 -1994-08-07 18:20:05.747471067,194.28718925009687 -1994-08-07 18:21:08.770390114,194.2290999628811 -1994-08-07 18:22:04.993112618,193.88244373099988 -1994-08-07 18:23:12.416131227,194.02896457246328 -1994-08-07 18:24:13.427829087,193.99948814393267 -1994-08-07 18:25:12.565706666,194.16456490763096 -1994-08-07 18:26:07.842114358,194.02641628418803 -1994-08-07 18:26:58.397587323,194.16132614507512 -1994-08-07 18:28:03.529864903,194.15134556849915 -1994-08-07 18:29:00.650668046,193.92727557471548 -1994-08-07 18:30:03.066222312,193.9766219050112 -1994-08-07 18:31:10.120818363,194.06760532977663 -1994-08-07 18:32:09.431674937,193.95571034292806 -1994-08-07 18:33:00.389496491,194.03147735060986 -1994-08-07 18:35:01.353919658,193.94705444753936 +1994-08-07 16:35:00.776781603,194.32011320654263 +1994-08-07 16:36:09.729399842,194.7470367441099 +1994-08-07 16:37:10.325784362,194.67395882505454 +1994-08-07 16:38:54.294488082,194.61153571139567 +1994-08-07 16:39:49.893755801,194.54321065864184 +1994-08-07 16:40:49.464208760,194.51251435556324 +1994-08-07 16:41:54.155002671,194.48729978930177 +1994-08-07 16:42:47.858648484,194.58252622043406 +1994-08-07 16:43:48.114422841,194.4304369580146 +1994-08-07 16:44:50.213843207,194.38249215797805 +1994-08-07 16:45:52.389905612,194.64429343992802 +1994-08-07 16:47:02.765925660,194.53358432734336 +1994-08-07 16:47:47.544625374,194.60385269292348 +1994-08-07 16:49:02.637927182,194.59824639141928 +1994-08-07 16:50:12.152163291,194.64549922015675 +1994-08-07 16:51:38.335652213,194.20982648777377 +1994-08-07 16:52:40.498338592,194.65174104529223 +1994-08-07 16:54:29.296070178,194.67321466962673 +1994-08-07 16:56:16.843462211,194.70496214061026 +1994-08-07 16:57:19.546830813,194.57169766844956 +1994-08-07 16:58:21.508555037,194.66168658625153 +1994-08-07 16:59:19.782410316,194.55758442776926 +1994-08-07 17:00:21.921517678,194.5576186499002 +1994-08-07 17:01:20.092192674,194.81469647880382 +1994-08-07 17:02:17.746355889,194.70522414915595 +1994-08-07 17:03:13.166714757,194.60789232032135 +1994-08-07 17:04:12.749365769,194.79521007424793 +1994-08-07 17:05:10.304197359,194.42783733284318 +1994-08-07 17:06:04.189757936,194.5555761260468 +1994-08-07 17:07:12.765391276,194.73618898202943 +1994-08-07 17:08:12.365563077,194.6375905289089 +1994-08-07 17:09:15.491917299,194.57025641473498 +1994-08-07 17:10:06.493562414,194.4688605015372 +1994-08-07 17:11:07.187363310,194.75550986631575 +1994-08-07 17:12:09.160016532,194.61054169889053 +1994-08-07 17:13:21.469083676,194.6253361248603 +1994-08-07 17:14:17.930689144,194.70277955607804 +1994-08-07 17:15:17.279332650,194.56556903513305 +1994-08-07 17:16:08.640601075,194.50005512303613 +1994-08-07 17:17:07.068658303,194.65868598122688 +1994-08-07 17:18:09.766449327,194.6653618297461 +1994-08-07 17:19:20.161218787,194.74595890778755 +1994-08-07 17:20:18.992883026,194.4980021093954 +1994-08-07 17:21:30.086313691,194.55154639192463 +1994-08-07 17:22:28.651457434,194.57671325756172 +1994-08-07 17:23:40.633424866,194.69867899539543 +1994-08-07 17:24:37.117548132,194.82545584348597 +1994-08-07 17:25:30.448984712,195.0279680264088 +1994-08-07 17:26:30.029453346,195.07988551475916 +1994-08-07 17:27:32.245829383,194.92487401587312 +1994-08-07 17:28:30.078420729,195.3240098122494 +1994-08-07 17:29:38.136013235,195.47706773119452 +1994-08-07 17:30:35.734525134,195.77572434729703 +1994-08-07 17:31:34.656548288,196.34019205600237 +1994-08-07 17:32:31.554119147,196.4872903805679 +1994-08-07 17:33:34.533280257,196.31028793328298 +1994-08-07 17:34:21.642437078,196.39518666193 +1994-08-07 17:35:37.901281041,196.23731771908797 +1994-08-07 17:36:31.067494778,196.2907368565569 +1994-08-07 17:37:26.536405793,196.05114435497984 +1994-08-07 17:38:26.179123415,196.23182104355894 +1994-08-07 17:39:34.480757192,195.7356264141028 +1994-08-07 17:40:32.367919827,195.76434390248752 +1994-08-07 17:41:29.068741892,195.387522485378 +1994-08-07 17:42:25.963454370,195.26662774076652 +1994-08-07 17:43:43.256506377,195.1620181140931 +1994-08-07 17:44:48.923258096,194.99956715610247 +1994-08-07 17:45:48.951022779,194.803275106843 +1994-08-07 17:46:51.832758663,194.62647855997503 +1994-08-07 17:47:53.011655455,194.840056508079 +1994-08-07 17:48:53.291279628,194.7191954018589 +1994-08-07 17:49:45.414193152,194.72130314272985 +1994-08-07 17:51:06.934395423,194.736784985074 +1994-08-07 17:52:14.283447737,194.57160881923406 +1994-08-07 17:53:31.345360278,194.83788750770336 +1994-08-07 17:54:45.878612606,194.6186418522351 +1994-08-07 17:55:54.526498381,194.60992402778382 +1994-08-07 17:57:07.804714354,194.70930496247433 +1994-08-07 17:58:29.732584061,194.631433387878 +1994-08-07 17:59:51.646966493,194.7453412546349 +1994-08-07 18:00:49.479370729,194.63355314090856 +1994-08-07 18:02:05.027988263,194.54741392208302 +1994-08-07 18:04:07.168692247,194.66260603569324 +1994-08-07 18:05:02.408720278,194.65222312074025 +1994-08-07 18:05:59.994427311,194.7324924261196 +1994-08-07 18:06:58.002591414,194.59584590330348 +1994-08-07 18:08:12.257364299,194.7322344755338 +1994-08-07 18:08:56.371471124,194.7565388217572 +1994-08-07 18:09:59.424399444,194.68480423777225 +1994-08-07 18:11:43.381217236,194.4815298273368 +1994-08-07 18:13:18.462469421,194.72667934520882 +1994-08-07 18:14:45.523662018,194.6906565875005 +1994-08-07 18:16:02.135996224,194.65676781090227 +1994-08-07 18:17:12.775638626,194.43981653379436 +1994-08-07 18:19:04.224160802,194.55663239846368 +1994-08-07 18:20:01.156801276,194.65240550437673 +1994-08-07 18:21:04.005495270,194.74085520785582 +1994-08-07 18:22:07.212758918,194.54846322157974 +1994-08-07 18:23:17.581805886,194.5943242421595 +1994-08-07 18:24:09.834797808,194.66609677586615 +1994-08-07 18:25:02.157922163,194.64754442371688 +1994-08-07 18:26:00.013570112,194.58158453962835 +1994-08-07 18:26:58.607951371,194.61501209771856 +1994-08-07 18:28:09.760211999,194.52247158113664 +1994-08-07 18:29:04.676695951,194.54233718320697 +1994-08-07 18:29:58.126126307,194.4578251058232 +1994-08-07 18:30:58.188406457,194.6101479534574 +1994-08-07 18:32:08.511690435,194.52181232461433 +1994-08-07 18:33:05.469289719,194.63804807700458 +1994-08-07 18:34:50.281906950,194.5500288327867 diff --git a/tests/testdata/network_sensor_2.csv b/tests/testdata/network_sensor_2.csv index 9eddb84df..403d0b069 100644 --- a/tests/testdata/network_sensor_2.csv +++ b/tests/testdata/network_sensor_2.csv @@ -1,81 +1,81 @@ ,water_level@sens2 -1994-08-07 17:08:19.453000537,193.69907521870385 -1994-08-07 17:09:11.667777579,193.53254848297152 -1994-08-07 17:10:17.713878006,193.37840712805215 -1994-08-07 17:11:14.377409723,193.36046774853432 -1994-08-07 17:12:19.607715440,193.35883525251685 -1994-08-07 17:13:16.506158153,193.54074175140104 -1994-08-07 17:14:22.442398906,193.5636244747378 -1994-08-07 17:15:07.096815541,193.3936963704199 -1994-08-07 17:16:10.480296727,193.48972566299682 -1994-08-07 17:17:22.450643797,193.4587060771225 -1994-08-07 17:18:21.490266204,193.35182993861991 -1994-08-07 17:19:19.872035872,193.45517089047667 -1994-08-07 17:20:18.551963043,193.39190620106453 -1994-08-07 17:21:37.487970642,193.65287311723839 -1994-08-07 17:22:38.893023517,193.51519324042974 -1994-08-07 17:23:37.808072814,193.72342214376903 -1994-08-07 17:24:30.088355655,193.42926966972004 -1994-08-07 17:25:22.809359233,193.373787100516 -1994-08-07 17:26:33.203907398,193.87313878617707 -1994-08-07 17:27:24.450142559,193.77977426912494 -1994-08-07 17:28:34.256134409,193.87776964481588 -1994-08-07 17:29:29.162052421,193.74593301162298 -1994-08-07 17:30:40.417250997,194.06335624478052 -1994-08-07 17:31:36.292748137,194.0891460493891 -1994-08-07 17:32:22.577927686,193.93598437841732 -1994-08-07 17:33:35.944430514,193.89206968675506 -1994-08-07 17:34:23.631420564,194.29720825961996 -1994-08-07 17:35:33.310491457,193.94006446417492 -1994-08-07 17:36:36.768648209,193.94301852816398 -1994-08-07 17:37:41.256034582,193.93359649072713 -1994-08-07 17:38:27.439954370,193.99934207664205 -1994-08-07 17:39:32.423879950,194.0276140940857 -1994-08-07 17:40:32.505523785,193.75309351356177 -1994-08-07 17:41:26.182311995,193.86393199710076 -1994-08-07 17:42:31.811747815,193.86698395764947 -1994-08-07 17:43:43.977586264,193.79824583031655 -1994-08-07 17:44:32.820391407,193.88413939303942 -1994-08-07 17:45:39.780028021,193.82682735759107 -1994-08-07 17:46:45.520148467,193.64527654802706 -1994-08-07 17:47:47.632936535,193.79625317554138 -1994-08-07 17:48:57.346727826,193.6655550615617 -1994-08-07 17:49:49.253930336,193.78374770218835 -1994-08-07 17:51:02.833869005,193.49014557011174 -1994-08-07 17:52:08.948334997,193.5521603282343 -1994-08-07 17:53:32.956569310,193.42249475180054 -1994-08-07 17:54:40.776321387,193.41421417275032 -1994-08-07 17:55:45.154182165,193.7623513346016 -1994-08-07 17:57:01.877564139,193.71602664387882 -1994-08-07 17:58:27.973645801,193.6626855905494 -1994-08-07 17:59:48.164323924,193.58427431473757 -1994-08-07 18:00:49.608896563,193.81199176289348 -1994-08-07 18:02:06.114975563,193.64886741921137 -1994-08-07 18:04:10.676323539,193.719005472149 -1994-08-07 18:05:07.173323943,193.96465013641256 -1994-08-07 18:06:11.346838731,193.68426045579662 -1994-08-07 18:07:15.138616621,193.88023114770002 -1994-08-07 18:08:12.352725832,193.73742809783437 -1994-08-07 18:09:09.040990372,193.95542280957721 -1994-08-07 18:10:05.444299339,193.72699587134503 -1994-08-07 18:11:43.548122207,193.64415106941962 -1994-08-07 18:13:19.975340480,193.61679887917686 -1994-08-07 18:15:00.099149664,193.7092729650918 -1994-08-07 18:15:58.266937956,193.51481360263026 -1994-08-07 18:17:11.010370099,193.88621915401467 -1994-08-07 18:19:00.194728453,193.70300139682695 -1994-08-07 18:20:01.268579900,193.74549285164244 -1994-08-07 18:20:59.085548638,193.61744713398235 -1994-08-07 18:22:04.935328179,193.73830581406855 -1994-08-07 18:23:02.479745169,193.64939163691596 -1994-08-07 18:24:03.446628434,193.70495758379232 -1994-08-07 18:25:06.549919135,193.8685145360975 -1994-08-07 18:26:03.183612415,193.76014328305922 -1994-08-07 18:27:13.078601240,193.970374402854 -1994-08-07 18:28:04.443206888,193.861958294037 -1994-08-07 18:29:11.413727234,193.7661905820629 -1994-08-07 18:30:08.277252518,193.82534783818286 -1994-08-07 18:31:15.483217962,193.74254129620306 -1994-08-07 18:32:16.040549977,193.6307058726291 -1994-08-07 18:33:10.182896344,193.70636292657173 -1994-08-07 18:34:50.194959733,193.5921011184813 +1994-08-07 17:08:16.746982777,193.46666085110937 +1994-08-07 17:09:15.911869348,193.5553573859252 +1994-08-07 17:10:12.195124338,193.68937807365793 +1994-08-07 17:11:04.448876310,193.45076123271946 +1994-08-07 17:12:21.097623039,193.35810147147876 +1994-08-07 17:13:10.410972001,193.2465448797826 +1994-08-07 17:14:18.997462489,193.3968538310765 +1994-08-07 17:15:03.516275677,193.4281083125626 +1994-08-07 17:16:19.363113442,193.41499628403477 +1994-08-07 17:17:21.535598304,193.5666798285079 +1994-08-07 17:18:06.703804784,193.39019715759977 +1994-08-07 17:19:07.113924200,193.38622798499898 +1994-08-07 17:20:33.249205987,193.44059499667398 +1994-08-07 17:21:31.188910307,193.39014297074812 +1994-08-07 17:22:25.449777484,193.5135983423928 +1994-08-07 17:23:34.351449340,193.44326026160877 +1994-08-07 17:24:36.704856539,193.64662660593314 +1994-08-07 17:25:23.749227916,193.68181603286484 +1994-08-07 17:26:25.413103928,193.65784040523326 +1994-08-07 17:27:34.119977569,193.6594899766634 +1994-08-07 17:28:38.077895472,193.56136289039708 +1994-08-07 17:29:28.892229227,193.88248108364874 +1994-08-07 17:30:37.381056452,193.879931506782 +1994-08-07 17:31:22.016878283,193.9764859878361 +1994-08-07 17:32:24.820104399,194.0092368597367 +1994-08-07 17:33:30.644397706,193.88064299765335 +1994-08-07 17:34:33.346912592,194.05445097743723 +1994-08-07 17:35:23.787289189,193.82172014137683 +1994-08-07 17:36:27.366039084,194.11063686379669 +1994-08-07 17:37:21.887545915,194.0337211037484 +1994-08-07 17:38:24.492378576,193.97610821824 +1994-08-07 17:39:30.357983784,193.8996749540457 +1994-08-07 17:40:32.873187909,193.92570259171478 +1994-08-07 17:41:34.362113670,194.00499314349867 +1994-08-07 17:42:37.953467214,193.97506638859474 +1994-08-07 17:43:42.534176765,193.8375936679057 +1994-08-07 17:44:46.286409008,193.8822436003635 +1994-08-07 17:45:38.814041258,193.92934125470285 +1994-08-07 17:46:46.299281342,193.8427036608706 +1994-08-07 17:47:54.794002989,193.67733464061652 +1994-08-07 17:48:47.411067897,193.7657885903237 +1994-08-07 17:49:54.806563276,193.79932081862353 +1994-08-07 17:51:07.203432962,193.6679871844179 +1994-08-07 17:52:24.175267637,193.66515188457322 +1994-08-07 17:53:38.221315864,193.47159887553875 +1994-08-07 17:54:47.955110981,193.3670697177164 +1994-08-07 17:55:57.151866554,193.2148360925973 +1994-08-07 17:57:08.560582293,193.62690790451714 +1994-08-07 17:58:23.735060106,193.72418492900746 +1994-08-07 17:59:55.978275973,193.6697424454863 +1994-08-07 18:00:56.860847094,193.862786559526 +1994-08-07 18:02:08.048762300,193.5319389365475 +1994-08-07 18:04:00.764336576,193.87660770279663 +1994-08-07 18:05:03.913437188,193.60076940202146 +1994-08-07 18:06:13.261131339,193.6366841968641 +1994-08-07 18:07:06.157111035,193.59798175417382 +1994-08-07 18:08:04.896493562,193.68986271298314 +1994-08-07 18:09:08.807194603,193.75154771138716 +1994-08-07 18:10:01.992525026,193.59058976854448 +1994-08-07 18:11:47.873996513,194.03607519614027 +1994-08-07 18:13:19.705641908,193.85331823073562 +1994-08-07 18:15:01.527177197,193.82125166357054 +1994-08-07 18:16:06.112479066,193.6735111347705 +1994-08-07 18:17:16.685286166,193.73108188615356 +1994-08-07 18:19:17.074371614,193.8626267277998 +1994-08-07 18:20:10.845364231,193.7936194327107 +1994-08-07 18:21:12.902532477,193.75779898411886 +1994-08-07 18:22:05.155728075,193.7031060506949 +1994-08-07 18:22:58.734020179,193.5646247175248 +1994-08-07 18:24:13.186786829,193.73911466320203 +1994-08-07 18:25:01.856294891,193.84057875255806 +1994-08-07 18:26:15.909490510,193.59172917653063 +1994-08-07 18:26:59.409353061,193.729350832721 +1994-08-07 18:28:14.140616186,193.6950562602535 +1994-08-07 18:29:12.131829961,193.56685946901322 +1994-08-07 18:30:15.997926093,193.7309558657659 +1994-08-07 18:31:00.070062248,193.77991569884506 +1994-08-07 18:31:58.657467012,193.65439446319758 +1994-08-07 18:33:12.430771829,193.7274017925486 +1994-08-07 18:35:06.217438898,193.7440013043444 diff --git a/tests/testdata/network_sensor_3.csv b/tests/testdata/network_sensor_3.csv index 540162613..b15854108 100644 --- a/tests/testdata/network_sensor_3.csv +++ b/tests/testdata/network_sensor_3.csv @@ -1,91 +1,91 @@ ,water_level@sens3 -1994-08-07 16:34:59.749185049,193.65573611633096 -1994-08-07 16:36:08.234735831,193.5492676961432 -1994-08-07 16:37:10.476205369,193.44270461528237 -1994-08-07 16:38:56.739070973,193.7316050738842 -1994-08-07 16:39:48.448422501,193.46705769407055 -1994-08-07 16:41:00.899011077,193.60328571871497 -1994-08-07 16:41:57.674627567,193.35125246300828 -1994-08-07 16:42:47.462417744,193.5185512837486 -1994-08-07 16:44:05.707731356,193.59592502393136 -1994-08-07 16:44:47.395900520,193.66394020062216 -1994-08-07 16:45:54.846537383,193.62178032405015 -1994-08-07 16:46:48.526040668,193.77009561152101 -1994-08-07 16:48:00.550698110,193.54903378032205 -1994-08-07 16:49:06.813081870,193.5248851167554 -1994-08-07 16:50:10.392793101,193.4807046599272 -1994-08-07 16:51:20.373948386,193.50658954793624 -1994-08-07 16:52:42.364153730,193.58489517430476 -1994-08-07 16:54:24.475220308,193.50643945831553 -1994-08-07 16:56:03.429894489,193.72466197230418 -1994-08-07 16:57:07.522109743,193.66315601778547 -1994-08-07 16:58:19.771112168,193.6526056046781 -1994-08-07 16:59:12.330382377,193.5774691241722 -1994-08-07 17:00:15.682992521,193.57194585146243 -1994-08-07 17:01:06.996793691,193.776140134919 -1994-08-07 17:02:03.506371148,193.68766157959166 -1994-08-07 17:03:10.614276582,193.49255884053937 -1994-08-07 17:04:12.713137359,193.62602129546661 -1994-08-07 17:05:11.105347604,193.6977653873034 -1994-08-07 17:06:08.694168494,193.76860864084824 -1994-08-07 17:07:10.279609860,193.50288362365427 -1994-08-07 17:08:21.003764660,193.55578257769696 -1994-08-07 17:09:06.412524613,193.56869342489048 -1994-08-07 17:10:15.705612895,193.40978399466348 -1994-08-07 17:11:09.451766070,193.60182994885278 -1994-08-07 17:12:08.055520793,193.51766966463958 -1994-08-07 17:13:10.657325255,193.7243146064135 -1994-08-07 17:14:21.633020060,193.51257532827768 -1994-08-07 17:15:09.075371450,193.55232084181247 -1994-08-07 17:16:17.914468302,193.62712317582472 -1994-08-07 17:17:16.975978261,193.5158279508316 -1994-08-07 17:18:08.275302169,193.52467436568807 -1994-08-07 17:19:15.119707735,193.8068739097595 -1994-08-07 17:20:17.654157988,193.58466106079132 -1994-08-07 17:21:35.874256489,193.6432198883477 -1994-08-07 17:22:26.201697028,193.7402389587467 -1994-08-07 17:23:40.614190845,193.8251455313248 -1994-08-07 17:24:35.163885201,194.0484457054399 -1994-08-07 17:25:33.831846465,194.2188581110414 -1994-08-07 17:26:29.463057842,194.14930206264734 -1994-08-07 17:27:32.301951282,194.26559908122894 -1994-08-07 17:48:51.253848509,194.47916510244187 -1994-08-07 17:49:47.468746981,194.53818636632545 -1994-08-07 17:51:17.048530468,194.42192673115431 -1994-08-07 17:52:06.196063531,194.3566111817392 -1994-08-07 17:53:33.571594531,194.49275563859712 -1994-08-07 17:54:40.295857745,194.24161289020807 -1994-08-07 17:55:51.426795930,194.32646211685966 -1994-08-07 17:57:07.010027886,194.3129625711656 -1994-08-07 17:58:14.788227728,194.21563049881922 -1994-08-07 17:59:55.817232777,193.97104689092097 -1994-08-07 18:01:00.899387468,194.01433322885484 -1994-08-07 18:02:11.092720572,194.06259026020842 -1994-08-07 18:04:08.113392108,194.0429608417371 -1994-08-07 18:05:13.679114222,193.96529261399613 -1994-08-07 18:05:59.122553354,194.15157054129583 -1994-08-07 18:06:57.704020361,194.05899018808853 -1994-08-07 18:08:00.962755607,193.87481824713652 -1994-08-07 18:09:12.803710813,193.94393360920478 -1994-08-07 18:09:55.783676414,193.90634365346295 -1994-08-07 18:11:38.994491765,194.00426585723756 -1994-08-07 18:13:23.817088485,194.21330958450045 -1994-08-07 18:15:02.660036684,193.89671511569932 -1994-08-07 18:16:07.012693812,193.78174880032458 -1994-08-07 18:17:20.710118446,193.86633562744598 -1994-08-07 18:19:15.130507240,194.0741744560302 -1994-08-07 18:20:15.800301822,194.00207588928566 -1994-08-07 18:21:05.594143504,193.98954078505082 -1994-08-07 18:22:10.672244133,193.96015892979668 -1994-08-07 18:22:59.116797345,193.8059099694073 -1994-08-07 18:24:17.782794557,193.83533534410043 -1994-08-07 18:25:04.518698881,193.9507667786435 -1994-08-07 18:26:01.010477471,193.74729023512035 -1994-08-07 18:26:58.886134140,194.11217785860217 -1994-08-07 18:28:09.564788837,193.8869974441292 -1994-08-07 18:29:08.171733686,193.8225247414004 -1994-08-07 18:30:08.862763988,193.94471797299423 -1994-08-07 18:30:58.204733811,193.73271910461622 -1994-08-07 18:32:15.465370257,193.6686396836888 -1994-08-07 18:33:11.959829548,193.89010296389915 -1994-08-07 18:35:04.487313817,193.81745709215483 +1994-08-07 16:34:53.680090784,195.93216076519226 +1994-08-07 16:36:03.016073867,195.9345555668001 +1994-08-07 16:37:03.615114632,195.87220444573137 +1994-08-07 16:39:04.169996900,196.07260811118314 +1994-08-07 16:40:05.088750158,196.01833164040877 +1994-08-07 16:40:58.934617468,195.7868431574667 +1994-08-07 16:41:46.633021730,196.07718129064628 +1994-08-07 16:42:54.313644581,195.9604742525487 +1994-08-07 16:44:01.994806709,195.82502054758228 +1994-08-07 16:45:05.716604054,195.8614853805758 +1994-08-07 16:46:05.078540769,195.94226830524835 +1994-08-07 16:47:04.659109174,196.13169890225316 +1994-08-07 16:48:04.071253636,196.0508294592809 +1994-08-07 16:48:55.856609530,195.8157297978531 +1994-08-07 16:50:20.836102217,195.78676980238802 +1994-08-07 16:51:27.259242998,196.0502612429115 +1994-08-07 16:52:46.613962431,195.90082751638676 +1994-08-07 16:54:14.361648370,195.82840913303832 +1994-08-07 16:56:09.602491818,195.86111093441735 +1994-08-07 16:57:07.509307885,196.08105725975832 +1994-08-07 16:58:04.607812159,195.91595807409047 +1994-08-07 16:59:06.162651347,196.046190892334 +1994-08-07 17:00:04.860410721,195.93309106576953 +1994-08-07 17:01:19.693130234,195.989758713676 +1994-08-07 17:02:17.013786542,196.03859678014445 +1994-08-07 17:03:21.921253632,195.9350327844052 +1994-08-07 17:04:21.306422808,196.0611642713905 +1994-08-07 17:05:19.649468214,195.99686776883638 +1994-08-07 17:06:03.336005403,195.7951648783128 +1994-08-07 17:07:08.175640300,196.03696226597071 +1994-08-07 17:08:13.223933084,196.04961642590735 +1994-08-07 17:09:20.896721614,195.86822876151624 +1994-08-07 17:10:12.692196265,195.93634924463356 +1994-08-07 17:11:21.281490027,195.95654321002246 +1994-08-07 17:12:09.750840411,195.88120744267295 +1994-08-07 17:13:19.174570528,195.69717438944858 +1994-08-07 17:14:11.448114976,196.1061718342362 +1994-08-07 17:15:07.570426731,196.09399840812893 +1994-08-07 17:16:06.885048483,195.85406340253886 +1994-08-07 17:17:22.662212163,196.0792883943752 +1994-08-07 17:18:22.246108903,196.12897187602258 +1994-08-07 17:19:12.398538344,195.96210045263325 +1994-08-07 17:20:32.008320960,196.01346569313253 +1994-08-07 17:21:31.501188032,195.97332807650434 +1994-08-07 17:22:35.058031998,196.0923133910623 +1994-08-07 17:23:24.124859305,195.93741310885218 +1994-08-07 17:24:38.659325565,196.00513593642532 +1994-08-07 17:25:35.358147024,196.06989936406853 +1994-08-07 17:26:22.438476497,195.95165645941802 +1994-08-07 17:27:37.111814779,196.1077539353862 +1994-08-07 17:48:59.845122779,196.06867177276968 +1994-08-07 17:49:59.732989933,196.0571296425243 +1994-08-07 17:51:15.496873472,195.8685146657441 +1994-08-07 17:52:14.096936412,196.14841260340083 +1994-08-07 17:53:40.763706788,195.93029445362168 +1994-08-07 17:54:39.549902410,196.01744835625516 +1994-08-07 17:55:52.701116337,195.96104178186428 +1994-08-07 17:56:59.300944272,195.80391343108298 +1994-08-07 17:58:15.648708976,196.04582044920252 +1994-08-07 17:59:55.609780366,195.73148703736967 +1994-08-07 18:00:48.491480170,196.0329238945659 +1994-08-07 18:02:05.832518720,195.94609041324372 +1994-08-07 18:04:01.981196118,196.0870217358456 +1994-08-07 18:05:06.385341376,195.82819669263213 +1994-08-07 18:06:02.100215510,195.97316503312695 +1994-08-07 18:07:09.809500401,196.04851254822992 +1994-08-07 18:08:02.507913856,195.93280039947714 +1994-08-07 18:09:09.478070425,196.07991903067744 +1994-08-07 18:10:12.897665524,195.8858685223849 +1994-08-07 18:11:42.297675514,195.85546581194953 +1994-08-07 18:13:09.578201802,196.03228099205927 +1994-08-07 18:14:58.536619975,195.9259991178699 +1994-08-07 18:16:06.565053613,195.8178981389149 +1994-08-07 18:17:14.826306388,195.88467512468196 +1994-08-07 18:19:09.806901698,195.8420830166265 +1994-08-07 18:19:58.851825129,195.88215275337 +1994-08-07 18:21:01.335159759,195.96773411751616 +1994-08-07 18:22:16.682911258,195.9911857524558 +1994-08-07 18:23:07.233670407,196.0512707039425 +1994-08-07 18:24:11.527824425,195.9524087710378 +1994-08-07 18:25:01.436698737,195.89337228514202 +1994-08-07 18:26:06.247244282,195.8784401317867 +1994-08-07 18:27:05.656973313,196.05157296880046 +1994-08-07 18:28:00.856102141,195.9754065310726 +1994-08-07 18:29:00.407347532,195.97144918429876 +1994-08-07 18:30:13.017417982,195.99000755334848 +1994-08-07 18:31:10.919329130,195.83631114492073 +1994-08-07 18:32:00.620127477,196.06952449706685 +1994-08-07 18:33:10.975642642,195.9252297985391 +1994-08-07 18:34:56.951901187,195.98766363899963 From c81faf3012cc9447c389ba43900aaf03bc00d8e9 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 16:25:39 +0200 Subject: [PATCH 011/117] Keep a 1.4.0a3 comparer loading The alpha wrote the graph integer into the node coordinate. Nothing on the load path derives a location from it any more, so such a file still loads and skills -- but a regression there would be silent, so the fixture is a file the alpha actually wrote rather than one built to look like it. Co-Authored-By: Claude Opus 5 --- tests/test_comparercollection.py | 19 +++++++++++++++++++ tests/testdata/node_comparer_1.4.0a3.nc | Bin 0 -> 17307 bytes 2 files changed, 19 insertions(+) create mode 100644 tests/testdata/node_comparer_1.4.0a3.nc diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index f77e087a1..8edd71129 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -538,6 +538,25 @@ def test_save_and_load_round_trips_node_gtype_raw_data(node_comparer, tmp_path): assert cc2[0].raw_mod_data["Network_Model"].node == "123" +def test_a_comparer_saved_by_1_4_0a3_still_loads(): + """The alpha wrote the graph integer into the node coordinate. + + Nothing on the load path derives a location from it any more, so such a file + keeps working -- it just gives the integer back. Needs no mikeio1d: it is a + netcdf file, not a network. + """ + cmp = ms.load("tests/testdata/node_comparer_1.4.0a3.nc") + + assert cmp.gtype == "node" + assert cmp.node == 0 + assert cmp.skill().to_dataframe().shape[0] == 1 + + # Turning it back into an observation is where the integer is refused, since + # NodeObservation no longer accepts one. + with pytest.raises(TypeError, match="not an integer"): + cmp._to_observation() + + def test_save_and_load_round_trips_reach_gtype_raw_data(reach_comparer, tmp_path): """Reach-gtype comparers must survive a save()/load() round trip too.""" cc = ms.ComparerCollection([reach_comparer]) diff --git a/tests/testdata/node_comparer_1.4.0a3.nc b/tests/testdata/node_comparer_1.4.0a3.nc new file mode 100644 index 0000000000000000000000000000000000000000..78c8a2751bd5dc0eb471beaa520a684086dc8007 GIT binary patch literal 17307 zcmeHOeQXrR6@PbUpU?IJCeWCq`8XSzIw>6IkJxnx!NwohiLqUqhNfz}+T5+piu0Xy zcR)y>iPWYMR6+swLn$ql`bU&V=?4kwKP`gyiyFS*6%uNQ>@ZpCd1d6gf0RI{dre#iXu3$R5pFm9!T00bcfWdP&Zy^}Vqz#=>W zs+&y3ZDT!P9|0^El_sz#k=f}a66S6@opDl0(V{}NXpFQ(qE@rfK^+930#@Qb*ke26 zJF>7mya_uY>VTGNXt^A~T0SIEMq={m{3hcz(k=kyQgqUqkm?y&jno@NUChR&W^?Gl z3=RTG9*;fs_8Ey3_r}p!N&Bhe5kAMKGwLrsK#=nby6dEj=Mlakc>CZ zU!rbgrDlbpsVb3{G*L@&u-Kjl+wDv^aqloy1As#}?|8kmb5yrZcK&lEgGXFZbi^f? zBSPn@=jexj{l#6_jf;&s*!8<(FXS-)OSvrWS673zbl@w)dq_}O)|s$BD`!jH@2Ax? zO{yxvJLtey#&puWPVcs|Xhnao?mKydeWPA#x|tQ0^LqN+hMC-om=4RU zXH+Gloh-L&&UYo9Y)04$5=%1U*4|7w<0NBtxGCD$zAoB`f8l8KF7XHO^pS?QdPhfl zAf;gQ1^w_ZA^JDQF#$fSsYF6_^~534$Uw_OvX@FzZ4Pz~r&E)5I_sdJqelu2h;&d7 zjg3uflfoiyY>Bi-n%C}#kKMVkG1Ax)X_W~4akUh2pJZeOiSFIE-^n5Hed-bEQ<8}X z8a;N@17omrYmX34w+>aM<&NyDmDk5ri$c~r(l;!g2YwKbOnIG+I>I4{@xdWWVy;dL zY_KYQKf`8jOF6y<9Ov{+T=P=H*~!h@`npjgl)M~^;|Z;4u!RBMT> zrBuk(dgS7lZ|)t%zJNy|B{H%slT;eU`=tR3WQ`-rUVKzlVgABQ=%LNq26|DuqjV`O zK^}M}Tm##w0A*1R|2TN-8mOfsv?nwb8E3*s}$qWeasJm zEnPzcbkDK16vueV&t2Y-pkWeJSkAkb!g4l?T+Uk()eStkjE^+e2xtT}0vZ90fJQ(g zpb^jrXaqC@8Uc-fMqsfK=Ds{ zcMVda;2v97B!*UnaNGLcgXEc(#KY;#w zxrVKTos3&@q0=I!RWzASCG5$p6Enxt_IN7oSV@Zi1Yy1E>>$H?KOdByfBt(9|J03D z3eO{{Hn;o$9(*0fHi+0^3D3*(|F_@ZOZzX=q;hzf9kFGU3v#ed4TlT`k*8E$e6#lC zUKh>c*%u3n{NAom<|W3F-zun#NR5svKCSq*jr^W!JAX=`87A#~Wfc7)TH=Yfzg{m( zh5apd@z9UH9-^*{eSm2-WXYps$wzv6dq#Q&yLwDv$y;&dk|mE@Su0~_b0$5Gq0gj9 z*9p;eIjvz~>1nYOF)xhqy6VYlu=kn2i`b1iMRtCZI_{7>qI?YcJ?a|1YrSR>hb!luVSPc|ftxkP z+a-C~%?MMcMHx18TM9ie+sg;-&D`ME{lgav^Um5a51c5MQFiLyiVKB#XYKgT=dJa| zzL$^7yfYq!l$hHC$`+)OH}CA6O6cW$Gv*swx10HSXSd4i9OZ$EAw z$7`BOguvYL&eY0){6zqs+00)JkiQZPX!>6xApFk!&M$;N|F>1Y z{UH0DDIu54_;&pEBRyd6wiE8N%XJddTQAiSAKAF>;anm&SsA)6UjM~+B@6aXs}D+M zaXm+)54OeH=IDAZjX#-;^E}+xgn*_GH3GSP;mkb}h$9M*1$vzUGB^C;r1V?X`>*iT z*n<3)2XM1MROq*?grDI@8$`qS1rX70#o=3YvupaGB5-2;#Isl4v`2)c2KYA5C~vu$ ztD({74RaxE=C+h;gEs9)+4Tx9zWQ!s;ii2?$*vS1QIM4V=9=dUH|;ZbOZmB4&HqfC zkehZM1+PZtta0I{{V}BvZ`PS#-15Mo#oV-ec6AHeqqq1cKF!0@d=U`1hMV@!tekpy z5k{oDoDTx@(B^pQ0|ie+BSCNAr3`DarDD#Xs Date: Tue, 25 Aug 2026 16:59:30 +0200 Subject: [PATCH 012/117] Say plainly what the ADRs now record ADR-013 was written as a proposal and parts of it no longer describe what was built: mikeio1d collapsed from_mike and from_epanet into Network.open, the extra is called network, and it named a fixture this repository does not have. The snapshot paragraphs said the same thing twice, once in each tense. ADR-012's note described its own position in the document. It now sits under the status line and says what moved. Co-Authored-By: Claude Opus 5 --- adr/010-optional-domain-dependencies.md | 6 +++--- adr/012-network-format-constructors.md | 23 +++++++++++------------ adr/013-network-topology-in-mikeio1d.md | 18 ++++++++++-------- adr/README.md | 2 +- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/adr/010-optional-domain-dependencies.md b/adr/010-optional-domain-dependencies.md index ef8c38852..4817b2c3d 100644 --- a/adr/010-optional-domain-dependencies.md +++ b/adr/010-optional-domain-dependencies.md @@ -56,10 +56,10 @@ Installation: `pip install modelskill modelskill-network` **Open Questions:** - Should `modelskill[all]` install all optional model types? -- How to handle version constraints for optional dependencies? *Answered for network +- How to handle version constraints for optional dependencies? Answered for network support by [ADR-013](013-network-topology-in-mikeio1d.md): the `network` extra names a - minimum mikeio1d, since the topology layer it depends on ships there. Network support - therefore requires whatever Python that release requires.* + minimum mikeio1d, because the topology layer ships there. Network support then requires + whatever Python that release requires. - Should optional dependencies be tested in CI for every commit or separately? ## Status Notes diff --git a/adr/012-network-format-constructors.md b/adr/012-network-format-constructors.md index d1f69033c..34577b07a 100644 --- a/adr/012-network-format-constructors.md +++ b/adr/012-network-format-constructors.md @@ -4,6 +4,17 @@ **Date**: 2026-08 +## Narrowed by ADR-013 + +The constructors, the companion arguments, the extension tables, the coverage test and the +`.inp` reader are mikeio1d's. It replaced `from_mike` and `from_epanet` with one +`Network.open` that reads the extension. Naming a constructor after the product that wrote +the file is still the rule, and mikeio1d applies it. + +For modelskill this leaves one step: `NetworkModelResult` hands a path to mikeio1d. The +refusal messages for `.out`, `.resx` and the formats without a fixture are written there +now. + ## Context `Network` is built from result files read through mikeio1d, whose single `Res1D` class opens nine extensions across five products — MIKE 1D (`.res1d`), MIKE 11 (`.res11`), MOUSE (`.prf`, `.crf`, `.xrf`), EPANET (`.res`), SWMM (`.out`), Water Hammer (`.whr`), and `.resx`, which is shared by the last three. There is no per-format reader and no per-format constructor argument, so from mikeio1d's side all nine look alike. modelskill's constructor was named `from_res1d`, and its extension guard was briefly widened to accept everything mikeio1d could read — making the name promise one format while reading nine. @@ -23,18 +34,6 @@ A product's companion files are arguments rather than constructors of their own. Every extension mikeio1d reads is accounted for in one of three module-level tables in `network.py`: readable by `from_mike`, readable by `from_epanet`, or refused with a reason that names the file or method which would lift it. A test asserts the tables cover exactly `Res1D.get_supported_file_extensions()`, so a mikeio1d release adding a tenth format fails CI instead of leaving that format silently unreachable. `from_res1d` is removed without a deprecation shim: it shipped only in the 1.4.0a3 alpha, and the network module is opt-in and absent from the API reference. -## Superseded in part by ADR-013 - -Everything below the line this note sits above is now mikeio1d's: the constructors, the -companion arguments, the extension tables and the coverage test moved there with the rest -of the topology layer, and `Network.open` replaced the two product constructors with one -entry point that reads the extension. The reasoning about naming a constructor after the -product that wrote the file still holds, and still applies -- upstream. What stays here is -the consequence for modelskill: a path handed to `NetworkModelResult` is opened by -mikeio1d, and the refusal messages for `.out`, `.resx` and the fixture-less formats are -upstream's to word. The `.inp` reader went with them, so the last consequence below is no -longer ours to carry. - ## Alternatives Considered **One constructor per extension** - `from_res`, `from_out` and `from_whr` say nothing about the product they belong to, and MOUSE would need three identical methods. diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md index acc444dbf..8b5be810c 100644 --- a/adr/013-network-topology-in-mikeio1d.md +++ b/adr/013-network-topology-in-mikeio1d.md @@ -8,7 +8,7 @@ `modelskill.network` grew into a topology layer of its own: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, a table of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. Roughly 630 code lines, against 25 for mikeio1d's `experimental.to_networkx`, which converts the same file and ignores gridpoints. -Most of that difference is work the upstream function declines to do rather than work done twice. But the layer sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp`, `network_chinese.res1d` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses four things from `Network` and never traverses the graph. +Most of that difference is work the upstream function declines to do rather than work done twice. But the layer sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses five members of `Network`, two of them private, and never traverses the graph. ## Decision @@ -16,16 +16,18 @@ mikeio1d gains an optional network module that builds and owns `Network`. models | Owner | Pieces | |---|---| -| mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `from_mike`/`from_epanet`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | +| mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `Network.open`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | | modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | -`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` travels with the class rather than leaving a stub behind. modelskill's `networks` extra requires a mikeio1d release new enough to contain it. +`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` travels with the class rather than leaving a stub behind. modelskill's `network` extra requires a mikeio1d release new enough to contain it. -Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index — they exist because the ID space is mixed and a tuple cannot be an xarray coordinate value, not because anyone should type one. A saved comparer records the original ID beside the integer, so reloading it does not depend on the numbering the installed mikeio1d happened to hand out. +Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index. They exist because the ID space mixes names and break points, and a tuple cannot be an xarray coordinate value. A saved comparer records the original ID, with the integer beside it as `node_index`, so reloading does not depend on the numbering the installed mikeio1d handed out. -The move is verified rather than trusted: the current loader's output over every fixture is snapshotted first — graph edges with their lengths and boundary flags, the alias map, the dataframe, the answers `find` and `recall` give — and those snapshots become the upstream module's acceptance test. Code moves verbatim before it is cleaned up. Neither project releases the feature until both can: modelskill 1.4.0 waits for the mikeio1d release that carries the module. +Snapshots check the move. Before anything moved, the loader's output over six fixture loads was recorded: graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` give. Those snapshots are the upstream module's acceptance test. -Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The six snapshots pass there unchanged: first against the code moved verbatim, then again after the entry points collapsed into a single `Network.open`. That second pass is what says the redesign changed no behaviour. The module is still unreleased, so the version pin this decision requires waits on mikeio1d's next release. +Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The snapshots pass there unchanged, twice: against the code moved verbatim, and again after the two product constructors collapsed into `Network.open`. The second pass covers the redesign. + +Neither project releases the feature until both can. modelskill 1.4.0 waits for the mikeio1d release carrying the module, which is not out yet. ## Alternatives Considered @@ -39,8 +41,8 @@ Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), mer ## Consequences -- ADR-012 is narrowed: the constructors, the companion arguments and the extension tables it describes become mikeio1d's, and the coverage test goes with them. Its reasoning about naming constructors after products still holds — upstream is simply where it now applies. -- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `networks` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. +- ADR-012 is narrowed: the constructors, the companion arguments, the extension tables and the coverage test become mikeio1d's. Naming a constructor after the product that wrote the file is still the rule, and mikeio1d applies it. +- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `network` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. - A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend nobody has written. - Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Cheap now, expensive after 1.4.0. - Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule, not ours. In exchange, a format mikeio1d adds no longer breaks our CI. diff --git a/adr/README.md b/adr/README.md index 6ce0ae2d4..fe0639ba0 100644 --- a/adr/README.md +++ b/adr/README.md @@ -30,7 +30,7 @@ Each ADR follows this structure: - [ADR-009](009-factory-pattern.md) - Factory pattern for type detection - [ADR-010](010-optional-domain-dependencies.md) - Optional dependencies for domain-specific model types (Draft) - [ADR-011](011-vertical-pre-extracted-columns.md) - VerticalModelResult ingests pre-extracted columns -- [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (Draft) +- [ADR-012](012-network-format-constructors.md) - One Network constructor per modelling product (narrowed by ADR-013) - [ADR-013](013-network-topology-in-mikeio1d.md) - The network topology layer belongs to mikeio1d ## Contributing From 6999d6142ebb671e79e2d1cc7a08eaa6588b6ed2 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 25 Aug 2026 17:04:13 +0200 Subject: [PATCH 013/117] Cut the flourishes from the network ADRs Inverted constructions, closing kickers and sentences that restate the one before them. Stacked clauses split into separate sentences. Co-Authored-By: Claude Opus 5 --- adr/010-optional-domain-dependencies.md | 2 +- adr/012-network-format-constructors.md | 5 ++--- adr/013-network-topology-in-mikeio1d.md | 18 +++++++++--------- 3 files changed, 12 insertions(+), 13 deletions(-) diff --git a/adr/010-optional-domain-dependencies.md b/adr/010-optional-domain-dependencies.md index 4817b2c3d..fc5e9dc89 100644 --- a/adr/010-optional-domain-dependencies.md +++ b/adr/010-optional-domain-dependencies.md @@ -58,7 +58,7 @@ Installation: `pip install modelskill modelskill-network` - Should `modelskill[all]` install all optional model types? - How to handle version constraints for optional dependencies? Answered for network support by [ADR-013](013-network-topology-in-mikeio1d.md): the `network` extra names a - minimum mikeio1d, because the topology layer ships there. Network support then requires + minimum mikeio1d, because the topology layer ships there. Network support requires whatever Python that release requires. - Should optional dependencies be tested in CI for every commit or separately? diff --git a/adr/012-network-format-constructors.md b/adr/012-network-format-constructors.md index 34577b07a..8a863068a 100644 --- a/adr/012-network-format-constructors.md +++ b/adr/012-network-format-constructors.md @@ -11,9 +11,8 @@ The constructors, the companion arguments, the extension tables, the coverage te `Network.open` that reads the extension. Naming a constructor after the product that wrote the file is still the rule, and mikeio1d applies it. -For modelskill this leaves one step: `NetworkModelResult` hands a path to mikeio1d. The -refusal messages for `.out`, `.resx` and the formats without a fixture are written there -now. +`NetworkModelResult` hands a path to mikeio1d. The refusal messages for `.out`, `.resx` +and the formats without a fixture are written there. ## Context diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md index 8b5be810c..6d28abecf 100644 --- a/adr/013-network-topology-in-mikeio1d.md +++ b/adr/013-network-topology-in-mikeio1d.md @@ -8,7 +8,7 @@ `modelskill.network` grew into a topology layer of its own: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, a table of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. Roughly 630 code lines, against 25 for mikeio1d's `experimental.to_networkx`, which converts the same file and ignores gridpoints. -Most of that difference is work the upstream function declines to do rather than work done twice. But the layer sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses five members of `Network`, two of them private, and never traverses the graph. +Most of those 630 lines do work the upstream function declines to do. The layer still sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses five members of `Network`, two of them private, and never traverses the graph. ## Decision @@ -19,30 +19,30 @@ mikeio1d gains an optional network module that builds and owns `Network`. models | mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `Network.open`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | | modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | -`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` travels with the class rather than leaving a stub behind. modelskill's `network` extra requires a mikeio1d release new enough to contain it. +`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` ships with the class. modelskill's `network` extra requires a mikeio1d release new enough to contain it. Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index. They exist because the ID space mixes names and break points, and a tuple cannot be an xarray coordinate value. A saved comparer records the original ID, with the integer beside it as `node_index`, so reloading does not depend on the numbering the installed mikeio1d handed out. -Snapshots check the move. Before anything moved, the loader's output over six fixture loads was recorded: graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` give. Those snapshots are the upstream module's acceptance test. +Before anything moved, the loader's output over six fixture loads was recorded: graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` give. Those snapshots are the upstream module's acceptance test. Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The snapshots pass there unchanged, twice: against the code moved verbatim, and again after the two product constructors collapsed into `Network.open`. The second pass covers the redesign. -Neither project releases the feature until both can. modelskill 1.4.0 waits for the mikeio1d release carrying the module, which is not out yet. +modelskill 1.4.0 waits for the mikeio1d release carrying the module. That release is not out yet. ## Alternatives Considered -**Keep the layer here.** Defensible while the API is private, but it means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform — and taking a CI failure when someone else's release adds a format. +**Keep the layer here.** Defensible while the API is private. It means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform. It also means a CI failure whenever someone else's release adds a format. **Move only the constructors and companions**, leaving the graph and the abstract types here. Splits the format knowledge from the topology it produces, and leaves `Res1DReach` here as the single adapter for a plug point with no second implementation. -**A separate `modelskill-network` package.** Rejected in ADR-010 for fragmenting the install, and it would still own format knowledge that mikeio1d has better. +**A separate `modelskill-network` package.** Rejected in ADR-010 for fragmenting the install. It would still own format knowledge that belongs with mikeio1d. -**Ask mikeio1d to guarantee stable node numbering** instead of dropping integers from our API. Puts a promise on someone else's release process to protect a number users should never have been handling. +**Ask mikeio1d to guarantee stable node numbering** instead of dropping integers from our API. Puts a promise on someone else's release process, to protect a number users should not be handling. ## Consequences - ADR-012 is narrowed: the constructors, the companion arguments, the extension tables and the coverage test become mikeio1d's. Naming a constructor after the product that wrote the file is still the rule, and mikeio1d applies it. - ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `network` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. - A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend nobody has written. -- Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Cheap now, expensive after 1.4.0. -- Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule, not ours. In exchange, a format mikeio1d adds no longer breaks our CI. +- Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Removing it after 1.4.0 would cost more. +- Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule. A format mikeio1d adds no longer breaks our CI. From a178762250d0ecb18424662c28d06efba1e73f44 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 09:18:21 +0200 Subject: [PATCH 014/117] Potential fix for pull request finding 'Statement has no effect' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> --- src/modelskill/obs.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 330617375..aa1281c8d 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -978,7 +978,8 @@ def from_multiple( on_missing: Literal["raise", "skip"] = "raise", aux_items: list[int | str] | None = None, attrs: dict | None = None, - ) -> list[NodeObservation]: ... + ) -> list[NodeObservation]: + pass @classmethod def from_multiple( From 829465743a3a456dc282fbd27e6a7e5d22faea69 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 09:18:38 +0200 Subject: [PATCH 015/117] Potential fix for pull request finding 'Statement has no effect' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> --- src/modelskill/obs.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index aa1281c8d..6fa32fefd 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -1204,7 +1204,8 @@ def from_multiple( quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, - ) -> list[ReachObservation]: ... + ) -> list[ReachObservation]: + pass @overload @classmethod From 64bb87a347de989566b3dbb4b04498dbe777a6e8 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 09:18:58 +0200 Subject: [PATCH 016/117] Potential fix for pull request finding 'Statement has no effect' Co-authored-by: Copilot Autofix powered by AI <223894421+github-code-quality[bot]@users.noreply.github.com> --- src/modelskill/obs.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 6fa32fefd..383aa0ede 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -1231,7 +1231,8 @@ def from_multiple( on_missing: Literal["raise", "skip"] = "raise", aux_items: list[int | str] | None = None, attrs: dict | None = None, - ) -> list[ReachObservation]: ... + ) -> list[ReachObservation]: + pass @classmethod def from_multiple( From 62df5047b4bfcca268045025e747dc0d2299d72a Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:22:34 +0200 Subject: [PATCH 017/117] Add reach branch to Comparer.to_dataframe A reach-gtype comparer fell through the gtype dispatch to NotImplementedError, even though the node branch's body is already correct for it: _drop_scalar_coords drops reach and distance too. --- src/modelskill/comparison/_comparison.py | 5 +++-- tests/test_comparercollection.py | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 34387d07f..7feebe6a5 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -1372,8 +1372,9 @@ def to_dataframe(self) -> pd.DataFrame: + ["z"] ) return df[cols] - elif self.gtype == str(GeometryType.NODE): - # For network data, drop node coordinate like other geometries drop their coordinates + elif self.gtype in (str(GeometryType.NODE), str(GeometryType.REACH)): + # For network data, drop the location coordinates like other geometries + # drop theirs return _drop_scalar_coords(self.data).to_dataframe() else: raise NotImplementedError(f"Unknown gtype: {self.gtype}") diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 8edd71129..2a66ad4ac 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -572,6 +572,21 @@ def test_save_and_load_round_trips_reach_gtype_raw_data(reach_comparer, tmp_path ) +def test_to_dataframe_on_a_node_comparer(node_comparer): + df = node_comparer.to_dataframe() + + assert list(df.columns) == ["Observation", "Network_Model"] + assert df.index.name == "time" + + +def test_to_dataframe_on_a_reach_comparer(reach_comparer): + """The location coordinates are dropped, as they are for every other gtype.""" + df = reach_comparer.to_dataframe() + + assert list(df.columns) == ["Observation", "Network_Model"] + assert df.index.name == "time" + + # ======================== plotting ======================== From 904e5f0d417fbacd85fcf914dc813d70b053ffab Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:23:36 +0200 Subject: [PATCH 018/117] Guard node extraction against locations with no data A breakpoint that exists but holds nothing for the selected quantity surfaced as "All datetime indices must be non-empty" from matching, because every timestep was dropped as NaN. The reach path already treats an all-NaN column as no data; the node path now does too. --- src/modelskill/model/network.py | 11 +++++++++++ tests/test_network.py | 16 ++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 7ca802fe7..2c8bf3ed7 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -289,6 +289,17 @@ def _extract_node(self, observation: NodeObservation) -> NodeModelResult: "NetworkModelResult(Network.open(path, nodes=[...]))." ) + # A location that carries no data for this quantity is all-NaN here, just + # as it is on the reach path: MIKE 1D stores quantities at different grid + # points, so a breakpoint carrying Discharge may carry no WaterLevel. + item = self.sel_items.values + if not bool(self.data[item].sel(node=node_id).notnull().any()): + raise ValueError( + f"{observation.at!r} was found in the network but has no data for " + f"quantity '{item}'. Choose a location that has this quantity, or a " + "model result for a quantity this location has." + ) + return self._as_node_result(node_id) def _extract_reach(self, observation: ReachObservation) -> NodeModelResult: diff --git a/tests/test_network.py b/tests/test_network.py index 83822d03b..69044e6c4 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -640,6 +640,22 @@ def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( nmr.extract(obs) +@pytest.mark.skipif( + sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" +) +def test_extract_breakpoint_without_data_for_the_quantity_raises_valueerror( + sample_node_data, +): + """MIKE 1D stores WaterLevel and Discharge at alternating grid points, so a + breakpoint that exists can still hold nothing for the selected quantity.""" + network = Network.open("./tests/testdata/network.res1d") + nmr = NetworkModelResult(network, item="WaterLevel") + obs = ms.NodeObservation(sample_node_data, at=("94l1", 21.285), item="WaterLevel") + + with pytest.raises(ValueError, match="no data for quantity 'WaterLevel'"): + nmr.extract(obs) + + class TestNodeObservationAliases: """NodeObservation accepts a node name or a (reach, distance) tuple.""" From ec14d7bc06e17e311f3f708c633ad7cf034b729d Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:24:19 +0200 Subject: [PATCH 019/117] Fix Option B breakpoint example in the network guide The example paired breakpoint 21.285 on 94l1 with a WaterLevel model result, but that breakpoint only carries Discharge, so the block could not run -- and its plain python fence kept quarto from ever executing it. Point it at 42.57, which does carry WaterLevel, and make the fence executable so the render catches this next time. --- docs/user-guide/network.qmd | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/user-guide/network.qmd b/docs/user-guide/network.qmd index 07d628043..751a3eafa 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -108,19 +108,19 @@ Resolution happens inside `ms.match()`. A name the network does not hold raises When your observation sits at a chainage along a reach rather than at a named junction node, you can use the `at` argument and pass a `(reach_id, distance)` tuple. The `NetworkModelResult` looks up the corresponding breakpoint at match time: -```python -obs_bp = ms.NodeObservation(path_to_sensor_data_1, at=("94l1", 21.285)) +```{python} +obs_bp = ms.NodeObservation(path_to_sensor_data_1, at=("94l1", 42.57)) cc = ms.match(obs=obs_bp, mod=mr) cc.skill() ``` -The tuple form is equivalent to calling `network.find(reach="94l1", distance=21.285)` beforehand, and is resolved during matching. +The tuple form is equivalent to calling `network.find(reach="94l1", distance=42.57)` beforehand, and is resolved during matching. ::: {.callout-note} ## Chainage tolerance -Break point distances are matched within the tolerance mikeio1d uses to decide two chainages are the same place, so small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no break point falls within it, a `ValueError` is raised. The distance recorded on the match is the network's own, not the one you typed. +Break point distances are matched within the tolerance mikeio1d uses to decide two chainages are the same place, so small floating-point discrepancies between the distance you type and the value stored in the network are handled gracefully. If no break point falls within it, a `ValueError` is raised, as it is when the break point exists but carries no data for the quantity you are scoring - MIKE 1D stores water level and discharge at alternating grid points along a reach. ::: ### 3. Using ReachObservation for reach-uniform quantities From 38c120eb27df4ce19ca037c2127db9ca43d33642 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:25:16 +0200 Subject: [PATCH 020/117] Match MIKE+ source on the file name, not a substring The source filter was an unanchored LIKE '%name%' on tsfilename, so it could not tell calib.dfs0 from my_calib.dfs0 -- it still reported the item as ambiguous and told the caller to pass the source they had just passed -- and an underscore in a real file name acted as a wildcard. Compare file names in pandas instead, splitting on the Windows separator the database stores. --- src/modelskill/obs.py | 20 +++++++++++++------- tests/test_mikeplus.py | 31 +++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 7 deletions(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 3dc494066..5d876f335 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -217,7 +217,7 @@ def __init__( ``db`` is a path or an already-open connection; an open one is left open. ``source`` restricts the measurements to one result file, matched on file - name, so a full path is fine. Without it, measurements from every file + name alone, so a full path is fine. Without it, measurements from every file are considered and an item registered against two of them raises. """ self._source = source @@ -229,11 +229,7 @@ def __init__( try: self._validate(conn) - query, params = self._QUERY, [] - if source is not None: - query += " WHERE m.tsfilename LIKE ?" - params.append(f"%{Path(source).name}%") - rows = pd.read_sql_query(query, conn, params=params) + rows = pd.read_sql_query(self._QUERY, conn) # Read the station names now rather than on demand: the only other # use is naming stations that carry no measurement, on the failure @@ -247,6 +243,11 @@ def __init__( if opened is not None: opened.close() + if source is not None: + wanted = self._file_name(source).casefold() + names = rows["tsfilename"].fillna("").map(self._file_name) + rows = rows[names.str.casefold() == wanted] + rows["quantity"] = rows["resitemname"].str.split(";").str[0].str.strip() self._rows = rows @@ -385,7 +386,7 @@ def _unresolved_message(self, missing: Sequence[str]) -> str: lines = [] if known: - where = f" for '{Path(self._source).name}'" if self._source else "" + where = f" for '{self._file_name(self._source)}'" if self._source else "" lines.append( f" Known station, no measurement registered{where} ({len(known)}):\n" + "\n".join(f" {item}" for item in known) @@ -397,6 +398,11 @@ def _unresolved_message(self, missing: Sequence[str]) -> str: ) return "\n".join(lines) + @staticmethod + def _file_name(path: object) -> str: + """The file name in a path, whose separator is Windows' in the database.""" + return str(path).replace("\\", "/").rsplit("/", 1)[-1] + @staticmethod def _display_names(selection: pd.DataFrame) -> pd.Series: # assetname is far shorter than the raw item name and is normally unique, diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py index 1169033dc..132fae486 100644 --- a/tests/test_mikeplus.py +++ b/tests/test_mikeplus.py @@ -266,6 +266,37 @@ def test_source_accepts_a_full_path(tmp_path): assert len(obs_list) == 1 +def test_source_matches_the_whole_file_name(tmp_path): + """A file name that is a substring of another must not match it as well.""" + path = build_db( + tmp_path / "substring.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [ + measurement("s1", "item_a", "Pressure", file="calib.dfs0"), + measurement("s1", "item_a", "Pressure", file="my_calib.dfs0"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure", source="calib.dfs0" + ) + + assert len(obs_list) == 1 + + +def test_an_underscore_in_the_source_is_not_a_wildcard(tmp_path): + path = build_db( + tmp_path / "wildcard.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [measurement("s1", "item_a", "Pressure", file="calibX1.dfs0")], + ) + + with pytest.raises(ValueError, match="could not be resolved"): + NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity="Pressure", source="calib_1.dfs0" + ) + + def test_item_registered_against_several_files_raises_without_source(tmp_path): path = build_db( tmp_path / "ambiguous.sqlite", From 112385707b0d0cfc7e363f9c3f2961b05782a959 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:27:05 +0200 Subject: [PATCH 021/117] Keep unclassifiable MIKE+ stations from aborting a resolve Every row matching the requested item names was classified before any quantity or kind filter, so a station whose locationtype is not a place in the network -- a rain gauge or a catchment registered in the same file -- failed the whole resolve, and on_missing="skip" could not help. Such stations are now left out, and named in the error only when they were what the caller asked for. --- src/modelskill/obs.py | 52 ++++++++++++++++++++++++++++++++++-------- tests/test_mikeplus.py | 34 +++++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 10 deletions(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 5d876f335..fe9cdad25 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -190,8 +190,10 @@ class _MikePlusStationResolver: # m_Station.locationtype codes. 8 is a junction and 12 a tank or reservoir; # both are graph nodes. 9 is a link, which becomes a breakpoint when the - # station carries a chainage and a whole reach when it does not. Unknown - # codes raise rather than guess. + # station carries a chainage and a whole reach when it does not. A station + # with any other code is not a place in the network, so it is left out + # rather than guessed at, and reported when it was what the caller asked + # for. _NODE_TYPES = frozenset({8, 12}) _LINK_TYPES = frozenset({9}) @@ -264,7 +266,8 @@ def resolve( ``quantity`` selects one of several measured quantities; left None it is inferred, and raises when the selection holds more than one. ``kind`` restricts the result to nodes or to reaches. ``on_missing="skip"`` drops - items the database does not register, which otherwise raise. + items the database does not register, which otherwise raise. Stations the + database does not place in the network are always left out. """ requested = list(dict.fromkeys(item_names)) rows = self._rows[self._rows["item_name"].isin(requested)].copy() @@ -294,12 +297,14 @@ def resolve( rows["location"] = [location for _, location in located] if quantity is None: - pool = rows if kind is None else rows[rows["kind"] == kind] + placed = rows[rows["kind"].notna()] + pool = placed if kind is None else placed[placed["kind"] == kind] available = sorted(pool["quantity"].unique()) if len(available) == 0: raise ValueError( f"No {kind} locations found. Quantities present: " f"{rows['quantity'].value_counts().to_dict()}." + + self._unsupported_message(rows) ) if len(available) > 1: raise ValueError( @@ -319,13 +324,25 @@ def resolve( if kind is not None: of_kind = selection[selection["kind"] == kind] if of_kind.empty: - other = sorted(selection["kind"].unique()) + other = sorted(selection["kind"].dropna().unique()) + if not other: + raise ValueError( + f"No {quantity!r} station could be placed in the network." + + self._unsupported_message(selection) + ) raise ValueError( f"All {len(selection)} {quantity!r} station(s) are of kind " - f"{other}, not {kind!r}." + f"{other}, not {kind!r}." + self._unsupported_message(selection) ) selection = of_kind + selection = selection[selection["kind"].notna()] + if selection.empty: + raise ValueError( + f"No {quantity!r} station could be placed in the network." + + self._unsupported_message(rows) + ) + names = self._display_names(selection) return [ _Station( @@ -356,7 +373,10 @@ def _validate(self, conn: sqlite3.Connection) -> None: "The database layout is not the one modelskill expects." ) - def _location(self, row: pd.Series) -> tuple[str, str | tuple[str, float]]: + def _location( + self, row: pd.Series + ) -> tuple[str | None, str | tuple[str, float] | None]: + """The kind and location of one station, or (None, None) if it is neither.""" # A link station with a chainage names a point along a reach, which is a # node observation at a breakpoint. Without a chainage it names the reach # as a whole. @@ -374,9 +394,21 @@ def _location(self, row: pd.Series) -> tuple[str, str | tuple[str, float]]: return "reach", location_id return "node", (location_id, float(chainage)) - raise ValueError( - f"Station '{row['locationid']}' has unsupported locationtype " - f"{row['locationtype']!r}. Known codes are " + return None, None + + def _unsupported_message(self, rows: pd.DataFrame) -> str: + """Names the stations of ``rows`` that are not places in the network.""" + unsupported = rows[rows["kind"].isna()] + if unsupported.empty: + return "" + + listed = ", ".join( + f"'{row.locationid}' ({row.locationtype!r})" + for row in unsupported.itertuples() + ) + return ( + " Station(s) with an unsupported locationtype were left out: " + f"{listed}. Known codes are " f"{sorted(self._NODE_TYPES | self._LINK_TYPES)}." ) diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py index 132fae486..3e8181092 100644 --- a/tests/test_mikeplus.py +++ b/tests/test_mikeplus.py @@ -313,6 +313,40 @@ def test_item_registered_against_several_files_raises_without_source(tmp_path): ) +def test_a_station_that_is_no_place_in_the_network_is_left_out(tmp_path): + """A rain gauge registered in the same file must not fail the whole resolve.""" + path = build_db( + tmp_path / "gauge.sqlite", + [ + station("s1", "wNode_1", JUNCTION, "PT.401"), + station("s2", "Catch_1", 1, "RG.1"), + ], + [ + measurement("s1", "item_pressure", "Pressure"), + measurement("s2", "item_rain", "Rainfall"), + ], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_pressure", "item_rain"), db=path, quantity="Pressure" + ) + + assert [obs.name for obs in obs_list] == ["PT.401"] + + +def test_asking_for_a_quantity_only_an_unplaceable_station_carries_raises(tmp_path): + path = build_db( + tmp_path / "gauge_only.sqlite", + [station("s2", "Catch_1", 1, "RG.1")], + [measurement("s2", "item_rain", "Rainfall")], + ) + + with pytest.raises(ValueError, match="unsupported locationtype"): + NodeObservation.from_multiple( + data=frame("item_rain"), db=path, quantity="Rainfall" + ) + + def test_unknown_locationtype_raises(tmp_path): path = build_db( tmp_path / "weird.sqlite", From 04e93ad9702aa71a0443b9f4c9fabeef5b72ed76 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:29:19 +0200 Subject: [PATCH 022/117] Treat a Quantity passed with db= as metadata only Its name was fed to the station resolver as a database item filter, so supplying metadata failed unless the name happened to match the database's own -- which the docstring never said it had to. A string selects; a Quantity describes. --- src/modelskill/obs.py | 14 +++++++++++--- tests/test_mikeplus.py | 16 ++++++++++++++++ 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index fe9cdad25..99af6deac 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -468,8 +468,10 @@ def _observations_from_mikeplus( # for every station in the database. opened, _ = _open_and_name(data, None) + # A Quantity is metadata and does not select: its name is the caller's own, + # not the database's. Only a string names a quantity in the database. given_quantity = quantity if isinstance(quantity, Quantity) else None - wanted = quantity.name if isinstance(quantity, Quantity) else quantity + wanted = quantity if isinstance(quantity, str) else None stations = _MikePlusStationResolver(db, source=source).resolve( _item_names(opened), @@ -1086,7 +1088,10 @@ def from_multiple( Physical quantity metadata, by default None. With ``db``, a string selects which quantity to build observations for and the metadata comes from the database; omit it and the quantity is inferred when - the data holds only one. + the data holds only one. A ``Quantity`` supplies the metadata and + does not select, so the database must hold only one quantity for + this kind of location - to do both, pass the string and set + ``obs.quantity`` on the observations afterwards. source : str, optional With ``db``, the file the items come from. Taken from ``data`` when that is a path, by default None. @@ -1337,7 +1342,10 @@ def from_multiple( Physical quantity metadata, by default None. With ``db``, a string selects which quantity to build observations for and the metadata comes from the database; omit it and the quantity is inferred when - the data holds only one. + the data holds only one. A ``Quantity`` supplies the metadata and + does not select, so the database must hold only one quantity for + this kind of location - to do both, pass the string and set + ``obs.quantity`` on the observations afterwards. source : str, optional With ``db``, the file the items come from. Taken from ``data`` when that is a path, by default None. diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py index 3e8181092..456b6f22c 100644 --- a/tests/test_mikeplus.py +++ b/tests/test_mikeplus.py @@ -4,6 +4,7 @@ import pandas as pd import pytest +from modelskill import Quantity from modelskill.obs import NodeObservation, ReachObservation STATION_COLUMNS = [ @@ -502,6 +503,21 @@ def test_db_without_data_raises(self, db): with pytest.raises(ValueError, match="'data' is required"): NodeObservation.from_multiple(db=db) + def test_a_quantity_object_supplies_metadata_and_does_not_select(self, tmp_path): + """A Quantity's name is the caller's own, not a name in the database.""" + path = build_db( + tmp_path / "metadata.sqlite", + [station("s1", "wNode_1", JUNCTION, "PT.401")], + [measurement("s1", "item_a", "Pressure")], + ) + + obs_list = NodeObservation.from_multiple( + data=frame("item_a"), db=path, quantity=Quantity("Pressure_m", "m") + ) + + assert [obs.quantity.name for obs in obs_list] == ["Pressure_m"] + assert [obs.quantity.unit for obs in obs_list] == ["m"] + def test_quantity_string_without_db_raises(self, calibration_data): with pytest.raises(TypeError, match="must be a Quantity"): NodeObservation.from_multiple( From 71be06cf1d0757a9fc60bbd397bfd442b16334a4 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 14:42:32 +0200 Subject: [PATCH 023/117] Rewrite ADR-013 to the point --- adr/013-network-topology-in-mikeio1d.md | 39 ++++++++++++++++--------- 1 file changed, 25 insertions(+), 14 deletions(-) diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md index 6d28abecf..a6ea74b5f 100644 --- a/adr/013-network-topology-in-mikeio1d.md +++ b/adr/013-network-topology-in-mikeio1d.md @@ -6,9 +6,13 @@ ## Context -`modelskill.network` grew into a topology layer of its own: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, a table of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. Roughly 630 code lines, against 25 for mikeio1d's `experimental.to_networkx`, which converts the same file and ignores gridpoints. +`modelskill.network` had grown to roughly 630 lines of topology: the abstract node/reach/breakpoint types, a `Res1D` adapter, one constructor per modelling product, the `.resx` and `.inp` companions, +tables of which extensions we refuse and why, a networkx graph carrying reach lengths and boundary edges, an alias map, and `find`/`recall`/`to_dataset` on top. `NetworkModelResult` uses five members +of `Network`, two of them private, and never traverses the graph. mikeio1d's `experimental.to_networkx` converts the same files in 25 lines and ignores gridpoints. -Most of those 630 lines do work the upstream function declines to do. The layer still sits on the wrong side of a line ADR-001 drew for mikeio: we call `mikeio.read()` and stop, without modelling dfsu geometry or policing its format list. Here we do both. `Res1D` reads nine extensions across five products; our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against — `network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp` — are copies of mikeio1d's own. Meanwhile `NetworkModelResult` uses five members of `Network`, two of them private, and never traverses the graph. +That leaves us on the far side of the line ADR-001 drew for mikeio, where we call `mikeio.read()` and stop, modelling no dfsu geometry and policing no format list. `Res1D` reads nine extensions across +five products. Our tables decide which of the nine we accept, and a test fails our CI when a mikeio1d release adds a tenth. The fixtures those tables are checked against are copies of mikeio1d's own: +`network.res1d`, `network_cali.res11`, `epanet.res/.resx/.inp`. ## Decision @@ -19,21 +23,25 @@ mikeio1d gains an optional network module that builds and owns `Network`. models | mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `Network.open`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | | modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | -`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` ships with the class. modelskill's `network` extra requires a mikeio1d release new enough to contain it. +`NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` ships with the class. +modelskill's `network` extra requires a mikeio1d release new enough to contain it. -Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index. They exist because the ID space mixes names and break points, and a tuple cannot be an xarray coordinate value. A saved comparer records the original ID, with the integer beside it as `node_index`, so reloading does not depend on the numbering the installed mikeio1d handed out. +Original IDs become the only identifier a user handles: `NodeObservation.at` takes a node name or a `(reach, distance)` pair, and no longer an integer. The alias integers stay an internal index, +because the ID space mixes names and break points and a tuple cannot be an xarray coordinate value. A saved comparer records the original ID with the integer beside it as `node_index`, so reloading +does not depend on the numbering the installed mikeio1d handed out. -Before anything moved, the loader's output over six fixture loads was recorded: graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` give. Those snapshots are the upstream module's acceptance test. +The loader's output over six fixture loads was recorded before anything moved — graph edges with their lengths and boundary flags, the alias map, the dataframe, and every answer `find` and `recall` +give. Those snapshots are the upstream module's acceptance test. Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The snapshots pass there unchanged +twice: against the code moved verbatim, and again after the two product constructors collapsed into `Network.open`. -Phase 1 landed as mikeio1d [#247](https://github.com/DHI/mikeio1d/pull/247), merged 2026-08-19. The snapshots pass there unchanged, twice: against the code moved verbatim, and again after the two product constructors collapsed into `Network.open`. The second pass covers the redesign. - -modelskill 1.4.0 waits for the mikeio1d release carrying the module. That release is not out yet. +modelskill 1.4.0 waits for the mikeio1d release carrying the module, which is not out yet. ## Alternatives Considered -**Keep the layer here.** Defensible while the API is private. It means maintaining a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform. It also means a CI failure whenever someone else's release adds a format. +**Keep the layer here.** Defensible while the API is private. Costs a format matrix, an EPANET `.inp` parser and a graph contract for traversals we never perform. -**Move only the constructors and companions**, leaving the graph and the abstract types here. Splits the format knowledge from the topology it produces, and leaves `Res1DReach` here as the single adapter for a plug point with no second implementation. +**Move only the constructors and companions**, leaving the graph and the abstract types here. Splits the format knowledge from the topology it produces, and leaves `Res1DReach` here as the single +adapter for a plug point with no second implementation. **A separate `modelskill-network` package.** Rejected in ADR-010 for fragmenting the install. It would still own format knowledge that belongs with mikeio1d. @@ -41,8 +49,11 @@ modelskill 1.4.0 waits for the mikeio1d release carrying the module. That releas ## Consequences -- ADR-012 is narrowed: the constructors, the companion arguments, the extension tables and the coverage test become mikeio1d's. Naming a constructor after the product that wrote the file is still the rule, and mikeio1d applies it. -- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `network` extra pins a minimum mikeio1d, and network support requires whatever Python that release requires. -- A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend nobody has written. -- Dropping `at=` is a breaking change for a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Removing it after 1.4.0 would cost more. +- ADR-012 is narrowed: the constructors, the companion arguments, the extension tables and the coverage test become mikeio1d's. Naming a constructor after the product that wrote the file is still the + rule, and mikeio1d applies it. +- ADR-010's open question about version constraints for optional dependencies is answered for this feature: the `network` extra pins a minimum mikeio1d, and network support requires whatever Python + that release requires. +- A hand-built network needs mikeio1d installed, since `BasicNode`/`BasicReach` move too. That costs a .NET dependency for users who touch no MIKE file, which only matters for tests and for a backend + nobody has written. +- Dropping `at=` breaks a signature that shipped in the 1.4.0a3 alpha only, while the network module is opt-in and absent from the API reference. Removing it after 1.4.0 would cost more. - Releases become coupled in one direction: a fix to network file reading ships on mikeio1d's schedule. A format mikeio1d adds no longer breaks our CI. From 137dfaf4235389199b501e609b5425d236e73b33 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 15:32:28 +0200 Subject: [PATCH 024/117] Move the network location reader next to NodeObservation _coords.py is a module of coordinate types. location_from_coords was the one piece of logic in it, and what it returns is NodeObservation.at's type -- a node name or a (reach, distance) pair. Both callers already import obs.py, so the move costs no new import edge. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 5 +++-- src/modelskill/model/network.py | 5 ++--- src/modelskill/obs.py | 23 +++++++++++++++++++++ src/modelskill/timeseries/_coords.py | 26 ------------------------ 4 files changed, 28 insertions(+), 31 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 7feebe6a5..c34ffee3a 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -31,9 +31,10 @@ TrackObservation, NodeObservation, ReachObservation, + _location_from_coords, ) from ..model import PointModelResult, TrackModelResult, VerticalModelResult -from ..timeseries._coords import NETWORK_LOCATION_COORDS, location_from_coords +from ..timeseries._coords import NETWORK_LOCATION_COORDS from ..timeseries._timeseries import _normalize_time_to_ns, _validate_data_var_name from ._comparer_plotter import ComparerPlotter from ..metrics import _parse_metric @@ -666,7 +667,7 @@ def distance(self) -> Any: @property def _at(self) -> Any: """Where this comparer sits, in the form NodeObservation.at takes""" - return location_from_coords(self.data) + return _location_from_coords(self.data) def _coordinate_values(self, coord: str) -> None | Any: """Get coordinate values if they exist, otherwise return None""" diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 2c8bf3ed7..1aae081c8 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -13,9 +13,8 @@ _parse_network_breakpoint_input, _parse_network_node_input, ) -from modelskill.timeseries._coords import location_from_coords from ._base import SelectedItems -from ..obs import NodeObservation, ReachObservation +from ..obs import NodeObservation, ReachObservation, _location_from_coords from ..quantity import Quantity from ..types import PointType @@ -125,7 +124,7 @@ def __init__( @property def node(self) -> Any: """Where this result was extracted, as its network named it.""" - return location_from_coords(self.data) + return _location_from_coords(self.data) @property def node_index(self) -> int | None: diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 99af6deac..e56c4f54c 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -866,6 +866,29 @@ def z(self): return self._coordinate_values("z") +def _location_from_coords(ds: xr.Dataset) -> Any: + """Where a network timeseries sits, as the network that produced it named it. + + Returns a node name for a node, a ``(reach, distance)`` pair for a + breakpoint, a reach name when no distance was given, and None for data that + carries no network location. The value is returned as recorded, so a comparer + saved by an older version gives back the integer it stored. + """ + if "node" in ds.coords: + return _scalar(ds, "node") + if "reach" in ds.coords: + reach = _scalar(ds, "reach") + if "distance" not in ds.coords: + return reach + return (reach, _scalar(ds, "distance")) + return None + + +def _scalar(ds: xr.Dataset, name: str) -> Any: + value = np.atleast_1d(ds.coords[name].values)[0] + return value.item() if hasattr(value, "item") else value + + class NodeObservation(Observation): """Class for observations at network nodes. diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index ea768f4ce..15c8b170c 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -1,9 +1,6 @@ from __future__ import annotations -from typing import Any - import numpy as np -import xarray as xr #: Scalar coordinates that say where a network timeseries sits, rather than what #: it holds. They are dropped on the way to a dataframe, where they would @@ -11,29 +8,6 @@ NETWORK_LOCATION_COORDS = ("node", "node_index", "reach", "distance") -def location_from_coords(ds: xr.Dataset) -> Any: - """Where a network timeseries sits, as the network that produced it named it. - - Returns a node name for a node, a ``(reach, distance)`` pair for a - breakpoint, a reach name when no distance was given, and None for data that - carries no network location. The value is returned as recorded, so a comparer - saved by an older version gives back the integer it stored. - """ - if "node" in ds.coords: - return _scalar(ds, "node") - if "reach" in ds.coords: - reach = _scalar(ds, "reach") - if "distance" not in ds.coords: - return reach - return (reach, _scalar(ds, "distance")) - return None - - -def _scalar(ds: xr.Dataset, name: str) -> Any: - value = np.atleast_1d(ds.coords[name].values)[0] - return value.item() if hasattr(value, "item") else value - - class XYZCoords: def __init__( self, From 3fcea062596feeb0f85c1c134c547976c5de9ad8 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 15:35:48 +0200 Subject: [PATCH 025/117] Read a NodeObservation's location through one function at and _create_new_instance each hand-wrote the node/breakpoint branch that _location_from_coords already performs. _at_from_coords wraps it with the coercion the at argument is declared with, so the as-recorded and coerced forms sit next to each other instead of being implicit in two copies. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/obs.py | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index e56c4f54c..260083559 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -889,6 +889,18 @@ def _scalar(ds: xr.Dataset, name: str) -> Any: return value.item() if hasattr(value, "item") else value +def _at_from_coords(ds: xr.Dataset) -> str | tuple[str, float]: + """The location in the form ``NodeObservation`` takes it. + + Unlike :func:`_location_from_coords`, which reports the location as + recorded, this coerces to the types the ``at`` argument is declared with. + """ + location = _location_from_coords(ds) + if isinstance(location, tuple): + return (str(location[0]), float(location[1])) + return str(location) + + class NodeObservation(Observation): """Class for observations at network nodes. @@ -997,24 +1009,11 @@ def __init__( @property def at(self) -> str | tuple[str, float]: """Observation location: a node name, or a ``(reach_id, distance)`` breakpoint.""" - if "reach" in self.data.coords: - return ( - str(self.data.coords["reach"].item()), - float(self.data.coords["distance"].item()), - ) - return str(self.data.coords["node"].item()) + return _at_from_coords(self.data) def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" - if "reach" in data.coords: - return self.__class__( - data, - at=( - str(data.coords["reach"].item()), - float(data.coords["distance"].item()), - ), - ) - return self.__class__(data, at=str(data.coords["node"].item())) + return self.__class__(data, at=_at_from_coords(data)) @overload @classmethod From f5d4711782b803e84c312fb1ed42dffff1ce1e4e Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 15:47:52 +0200 Subject: [PATCH 026/117] State the network-coordinate rule once, on GeometryType Which coordinates make a dataset network data was written out by hand in five places, in four different spellings. They still agreed, so this changes no behaviour -- it stops the next edit from splitting them. GeometryType.from_coords is the one home every caller can reach: types.py is the leaf that timeseries, comparison, obs and model all import, and the enum it returns is defined there. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 9 ++----- src/modelskill/model/network.py | 4 +-- src/modelskill/timeseries/_point.py | 7 +---- src/modelskill/timeseries/_timeseries.py | 13 +++------ src/modelskill/types.py | 34 ++++++++++++++++++++++++ 5 files changed, 42 insertions(+), 25 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index c34ffee3a..d9ba4b398 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -79,7 +79,7 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # coordinates # Only add x, y, z coordinates if they don't exist and we don't have node coordinates - has_network_coords = bool({"node", "reach"} & set(data.coords)) + has_network_coords = GeometryType.from_coords(data) is not None if not has_network_coords: if "x" not in data.coords: data.coords["x"] = np.nan @@ -119,12 +119,7 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # Validate attrs if "gtype" not in data.attrs: # Determine gtype based on available coordinates - if "node" in data.coords or {"reach", "distance"} <= set(data.coords): - data.attrs["gtype"] = str(GeometryType.NODE) - elif "reach" in data.coords: - data.attrs["gtype"] = str(GeometryType.REACH) - else: - data.attrs["gtype"] = str(GeometryType.POINT) + data.attrs["gtype"] = str(GeometryType.from_coords(data) or GeometryType.POINT) # assert "gtype" in data.attrs, "data must have a gtype attribute" # assert data.attrs["gtype"] in [ # str(GeometryType.POINT), diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 1aae081c8..8251c7fd3 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -16,7 +16,7 @@ from ._base import SelectedItems from ..obs import NodeObservation, ReachObservation, _location_from_coords from ..quantity import Quantity -from ..types import PointType +from ..types import GeometryType, PointType if TYPE_CHECKING: from mikeio1d.network import Network @@ -110,7 +110,7 @@ def __init__( if not isinstance(data, xr.Dataset): raise ValueError("'NodeModelResult' requires xarray.Dataset") - if not {"node", "reach"} & set(data.coords): + if GeometryType.from_coords(data) is None: raise ValueError( "'NodeModelResult' needs a node name, a (reach, distance) pair, or " "data that already carries a 'node' or 'reach' coordinate" diff --git a/src/modelskill/timeseries/_point.py b/src/modelskill/timeseries/_point.py index 38d3bedb0..306545c1f 100644 --- a/src/modelskill/timeseries/_point.py +++ b/src/modelskill/timeseries/_point.py @@ -168,12 +168,7 @@ def _include_attributes( ) -> xr.Dataset: ds = ds.copy() - if "node" in ds.coords or ("reach" in ds.coords and "distance" in ds.coords): - ds.attrs["gtype"] = str(GeometryType.NODE) - elif "reach" in ds.coords: - ds.attrs["gtype"] = str(GeometryType.REACH) - else: - ds.attrs["gtype"] = str(GeometryType.POINT) + ds.attrs["gtype"] = str(GeometryType.from_coords(ds) or GeometryType.POINT) ds[name].attrs["long_name"] = quantity.name ds[name].attrs["units"] = quantity.unit diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index 4bec9abcd..23ac62f51 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -102,16 +102,9 @@ def _validate_dataset(ds: xr.Dataset) -> xr.Dataset: # Validate coordinates: x,y spatial, node-based, or reach-based (with or without chainage) has_spatial_coords = "x" in ds.coords and "y" in ds.coords - has_node_coord = "node" in ds.coords - has_breakpoint_coords = "reach" in ds.coords and "distance" in ds.coords - has_reach_coord = "reach" in ds.coords and "distance" not in ds.coords - - if ( - not has_spatial_coords - and not has_node_coord - and not has_breakpoint_coords - and not has_reach_coord - ): + has_network_coords = GeometryType.from_coords(ds) is not None + + if not has_spatial_coords and not has_network_coords: raise ValueError( "data must have either x,y coordinates, a node coordinate, " "reach+distance coordinates, or a reach coordinate" diff --git a/src/modelskill/types.py b/src/modelskill/types.py index cf9e2a390..a00b0699a 100644 --- a/src/modelskill/types.py +++ b/src/modelskill/types.py @@ -56,6 +56,40 @@ def from_string(s: str) -> "GeometryType": f"GeometryType {s} not recognized. Available options: {[m.name for m in GeometryType]}" ) from e + @staticmethod + def from_coords(ds: xr.Dataset) -> "GeometryType | None": + """The geometry a dataset's coordinates make it. + + Parameters + ---------- + ds : xr.Dataset + Dataset to inspect. + + Returns + ------- + GeometryType or None + NODE for a node or a break point, REACH for a whole reach, and None + for data that carries no network location. + + Examples + -------- + >>> import xarray as xr + >>> from modelskill.types import GeometryType + >>> GeometryType.from_coords(xr.Dataset(coords={"node": "123"})) + + >>> GeometryType.from_coords(xr.Dataset(coords={"reach": "r1", "distance": 24.5})) + + >>> GeometryType.from_coords(xr.Dataset(coords={"reach": "r1"})) + + >>> GeometryType.from_coords(xr.Dataset(coords={"x": 0.0, "y": 0.0})) is None + True + """ + if "node" in ds.coords or {"reach", "distance"} <= set(ds.coords): + return GeometryType.NODE + if "reach" in ds.coords: + return GeometryType.REACH + return None + DataInputType = Union[ str, From 52f071106134f38760a7f74a64f279e98c7c70ac Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 15:51:17 +0200 Subject: [PATCH 027/117] Read a coordinate off a dataset through one function TimeSeries._coordinate_values, Comparer._coordinate_values and _scalar were three copies of the same four lines. Both methods and _scalar now delegate to one module-level function; _scalar keeps its .item() unwrap on top. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 13 +++++++------ src/modelskill/obs.py | 3 ++- src/modelskill/timeseries/_timeseries.py | 19 ++++++++++++++----- 3 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index d9ba4b398..2400c3bb4 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -35,7 +35,11 @@ ) from ..model import PointModelResult, TrackModelResult, VerticalModelResult from ..timeseries._coords import NETWORK_LOCATION_COORDS -from ..timeseries._timeseries import _normalize_time_to_ns, _validate_data_var_name +from ..timeseries._timeseries import ( + _coordinate_values, + _normalize_time_to_ns, + _validate_data_var_name, +) from ._comparer_plotter import ComparerPlotter from ..metrics import _parse_metric @@ -664,12 +668,9 @@ def _at(self) -> Any: """Where this comparer sits, in the form NodeObservation.at takes""" return _location_from_coords(self.data) - def _coordinate_values(self, coord: str) -> None | Any: + def _coordinate_values(self, coord: str) -> Any: """Get coordinate values if they exist, otherwise return None""" - if coord not in self.data.coords: - return None - vals = self.data[coord].values - return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals + return _coordinate_values(self.data, coord) @property def n_models(self) -> int: diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 260083559..16230f2f6 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -41,6 +41,7 @@ _parse_network_node_input, _parse_network_breakpoint_input, ) +from .timeseries._timeseries import _coordinate_values # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file @@ -885,7 +886,7 @@ def _location_from_coords(ds: xr.Dataset) -> Any: def _scalar(ds: xr.Dataset, name: str) -> Any: - value = np.atleast_1d(ds.coords[name].values)[0] + value = _coordinate_values(ds, name) return value.item() if hasattr(value, "item") else value diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index 23ac62f51..837e97e76 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -16,6 +16,18 @@ T = TypeVar("T", bound="TimeSeries") + +def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: + """A dataset's values for one coordinate, or None when it has no such coordinate. + + A scalar coordinate is unwrapped to its single value; anything else is + handed back as the array it is. + """ + if coord not in ds.coords: + return None + vals = ds[coord].values + return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals + DEFAULT_COLORS = [ "#b30000", "#7c1158", @@ -262,11 +274,8 @@ def node(self) -> Any: """node-coordinate""" return self._coordinate_values("node") - def _coordinate_values(self, coord: str) -> None | float | np.ndarray: - if coord not in self.data.coords: - return None # Node-based data doesn't have y coordinate - vals = self.data[coord].values - return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals + def _coordinate_values(self, coord: str) -> Any: + return _coordinate_values(self.data, coord) @property def _is_modelresult(self) -> bool: From 525e876d0aecda2d2fe79e5dce9172f359edc60a Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 15:58:30 +0200 Subject: [PATCH 028/117] Take the network vocabulary off the TimeSeries base TimeSeries carried a node property and a __repr__ branch that named node coordinates. The repr branch was dead: it was gated on gtype == "point", but any dataset with a node coordinate is given gtype "node", so a node observation printed no location at all. __repr__ now asks an overridable _location_repr(), which NodeObservation, ReachObservation and NodeModelResult answer with where they sit -- so they start reporting a location they never showed before. node moves to NodeObservation, the only class it ever said anything about. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/network.py | 3 +++ src/modelskill/obs.py | 11 +++++++++++ src/modelskill/timeseries/_timeseries.py | 21 +++++++++------------ tests/test_network.py | 1 + 4 files changed, 24 insertions(+), 12 deletions(-) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 8251c7fd3..b7db35d81 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -126,6 +126,9 @@ def node(self) -> Any: """Where this result was extracted, as its network named it.""" return _location_from_coords(self.data) + def _location_repr(self) -> str | None: + return f"Location: {self.node}" + @property def node_index(self) -> int | None: """Graph integer this location had in the network it came from, if recorded. diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 16230f2f6..5c0f17489 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -1012,6 +1012,14 @@ def at(self) -> str | tuple[str, float]: """Observation location: a node name, or a ``(reach_id, distance)`` breakpoint.""" return _at_from_coords(self.data) + @property + def node(self) -> Any: + """Name of the node this observation sits at, or None for a break point.""" + return self._coordinate_values("node") + + def _location_repr(self) -> str | None: + return f"Location: {self.at}" + def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" return self.__class__(data, at=_at_from_coords(data)) @@ -1267,6 +1275,9 @@ def reach(self) -> str: """Reach ID of this observation.""" return str(self.data.coords["reach"].item()) + def _location_repr(self) -> str | None: + return f"Location: {self.reach}" + def _create_new_instance(self, data: xr.Dataset) -> Self: """Reconstruct instance from a dataset slice.""" return self.__class__(data, reach=str(data.coords["reach"].item())) diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index 837e97e76..f4a46b150 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -269,11 +269,6 @@ def y(self) -> Any: def y(self, value: Any) -> None: self.data["y"] = value - @property - def node(self) -> Any: - """node-coordinate""" - return self._coordinate_values("node") - def _coordinate_values(self, coord: str) -> Any: return _coordinate_values(self.data, coord) @@ -295,16 +290,18 @@ def _values_as_series(self) -> pd.Series: def _aux_vars(self): return list(self.data.filter_by_attrs(kind="aux").data_vars) + def _location_repr(self) -> str | None: + """The location line for ``__repr__``, or None when there is nothing to say.""" + if self.gtype == str(GeometryType.POINT): + if self.x is not None and self.y is not None: + return f"Location: {self.x}, {self.y}" + return None + def __repr__(self) -> str: res = [] res.append(f"<{self.__class__.__name__}>: {self.name}") - if self.gtype == str(GeometryType.POINT): - # Show location based on available coordinates - if "node" in self.data.coords: - node_id = self.data.coords["node"].item() - res.append(f"Node: {node_id}") - elif self.x is not None and self.y is not None: - res.append(f"Location: {self.x}, {self.y}") + if (location := self._location_repr()) is not None: + res.append(location) res.append(f"Time: {self.time[0]} - {self.time[-1]}") res.append(f"Quantity: {self.quantity}") if len(self._aux_vars) > 0: diff --git a/tests/test_network.py b/tests/test_network.py index 69044e6c4..f2a354b8b 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -499,6 +499,7 @@ def test_init_(self, request, fixture_name): assert nmr.node == "123" assert nmr.name == "Node_123_Model" assert len(nmr.time) == 10 + assert "Location: 123" in repr(nmr) class TestNetworkIntegration: From a5b0ae21c5b7116409d98482e0cd028ec3d4a8dc Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Thu, 3 Sep 2026 16:05:11 +0200 Subject: [PATCH 029/117] Give the network parsers a module of their own _point.py, _track.py and _vertical.py each own their parse function; network was the only geometry without one, so its two parsers sat in _point.py. The edge is one way -- _network -> _point -> _coords -- and timeseries/__init__ re-exports the same names, so no caller changes. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/timeseries/__init__.py | 4 +-- src/modelskill/timeseries/_network.py | 45 +++++++++++++++++++++++++++ src/modelskill/timeseries/_point.py | 36 --------------------- 3 files changed, 47 insertions(+), 38 deletions(-) create mode 100644 src/modelskill/timeseries/_network.py diff --git a/src/modelskill/timeseries/__init__.py b/src/modelskill/timeseries/__init__.py index f52f17271..9869b51b2 100644 --- a/src/modelskill/timeseries/__init__.py +++ b/src/modelskill/timeseries/__init__.py @@ -1,6 +1,6 @@ from ._timeseries import TimeSeries -from ._point import ( - _parse_xyz_point_input, +from ._point import _parse_xyz_point_input +from ._network import ( _parse_network_node_input, _parse_network_breakpoint_input, ) diff --git a/src/modelskill/timeseries/_network.py b/src/modelskill/timeseries/_network.py new file mode 100644 index 000000000..535b22c53 --- /dev/null +++ b/src/modelskill/timeseries/_network.py @@ -0,0 +1,45 @@ +from __future__ import annotations +from typing import Sequence + +import xarray as xr + +from ..quantity import Quantity +from ..types import PointType +from ._coords import NodeCoords, ReachCoords +from ._point import _parse_point_input + + +def _parse_network_node_input( + data: PointType, + name: str | None, + item: str | int | None, + quantity: Quantity | None, + node: str | None, + aux_items: Sequence[int | str] | None, +) -> xr.Dataset: + if node is None: + raise ValueError("'node' argument cannot be empty.") + coords = NodeCoords(node=node) + ds = _parse_point_input(data, name, item, quantity, aux_items, coords=coords) + return ds + + +def _parse_network_breakpoint_input( + data: PointType, + name: str | None, + item: str | int | None, + quantity: Quantity | None, + aux_items: Sequence[int | str] | None, + *, + reach: str, + distance: float | None = None, +) -> xr.Dataset: + """Parse input for a breakpoint (or reach-level) observation. + + When ``distance`` is ``None`` the observation is reach-level — no + ``distance`` coordinate is stored and the result can be matched to any + breakpoint on the reach. + """ + coords = ReachCoords(reach=reach, distance=distance) + ds = _parse_point_input(data, name, item, quantity, aux_items, coords=coords) + return ds diff --git a/src/modelskill/timeseries/_point.py b/src/modelskill/timeseries/_point.py index 306545c1f..52fd7d122 100644 --- a/src/modelskill/timeseries/_point.py +++ b/src/modelskill/timeseries/_point.py @@ -274,39 +274,3 @@ def _parse_xyz_point_input( coords = XYZCoords(x, y, z) ds = _parse_point_input(data, name, item, quantity, aux_items, coords=coords) return ds - - -def _parse_network_node_input( - data: PointType, - name: str | None, - item: str | int | None, - quantity: Quantity | None, - node: str | None, - aux_items: Sequence[int | str] | None, -) -> xr.Dataset: - if node is None: - raise ValueError("'node' argument cannot be empty.") - coords = NodeCoords(node=node) - ds = _parse_point_input(data, name, item, quantity, aux_items, coords=coords) - return ds - - -def _parse_network_breakpoint_input( - data: PointType, - name: str | None, - item: str | int | None, - quantity: Quantity | None, - aux_items: Sequence[int | str] | None, - *, - reach: str, - distance: float | None = None, -) -> xr.Dataset: - """Parse input for a breakpoint (or reach-level) observation. - - When ``distance`` is ``None`` the observation is reach-level — no - ``distance`` coordinate is stored and the result can be matched to any - breakpoint on the reach. - """ - coords = ReachCoords(reach=reach, distance=distance) - ds = _parse_point_input(data, name, item, quantity, aux_items, coords=coords) - return ds From 4a50c0dfe7a0e1fb6a43b839a1d784426c803698 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 09:33:38 +0200 Subject: [PATCH 030/117] Name the network scope in from_network_coords GeometryType.from_coords read only network coordinates, but sat on a generic enum under a name that promised to classify any dataset. A plain x/y point got None rather than POINT, which the name gave no warning of. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 6 ++++-- src/modelskill/model/network.py | 2 +- src/modelskill/timeseries/_point.py | 2 +- src/modelskill/timeseries/_timeseries.py | 3 ++- src/modelskill/types.py | 16 ++++++++++------ 5 files changed, 18 insertions(+), 11 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 2400c3bb4..3b262df72 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -83,7 +83,7 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # coordinates # Only add x, y, z coordinates if they don't exist and we don't have node coordinates - has_network_coords = GeometryType.from_coords(data) is not None + has_network_coords = GeometryType.from_network_coords(data) is not None if not has_network_coords: if "x" not in data.coords: data.coords["x"] = np.nan @@ -123,7 +123,9 @@ def _parse_dataset(data: xr.Dataset) -> xr.Dataset: # Validate attrs if "gtype" not in data.attrs: # Determine gtype based on available coordinates - data.attrs["gtype"] = str(GeometryType.from_coords(data) or GeometryType.POINT) + data.attrs["gtype"] = str( + GeometryType.from_network_coords(data) or GeometryType.POINT + ) # assert "gtype" in data.attrs, "data must have a gtype attribute" # assert data.attrs["gtype"] in [ # str(GeometryType.POINT), diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index b7db35d81..f89bcd2ba 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -110,7 +110,7 @@ def __init__( if not isinstance(data, xr.Dataset): raise ValueError("'NodeModelResult' requires xarray.Dataset") - if GeometryType.from_coords(data) is None: + if GeometryType.from_network_coords(data) is None: raise ValueError( "'NodeModelResult' needs a node name, a (reach, distance) pair, or " "data that already carries a 'node' or 'reach' coordinate" diff --git a/src/modelskill/timeseries/_point.py b/src/modelskill/timeseries/_point.py index 52fd7d122..f0eb47b2d 100644 --- a/src/modelskill/timeseries/_point.py +++ b/src/modelskill/timeseries/_point.py @@ -168,7 +168,7 @@ def _include_attributes( ) -> xr.Dataset: ds = ds.copy() - ds.attrs["gtype"] = str(GeometryType.from_coords(ds) or GeometryType.POINT) + ds.attrs["gtype"] = str(GeometryType.from_network_coords(ds) or GeometryType.POINT) ds[name].attrs["long_name"] = quantity.name ds[name].attrs["units"] = quantity.unit diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index f4a46b150..5036bb3a6 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -28,6 +28,7 @@ def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: vals = ds[coord].values return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals + DEFAULT_COLORS = [ "#b30000", "#7c1158", @@ -114,7 +115,7 @@ def _validate_dataset(ds: xr.Dataset) -> xr.Dataset: # Validate coordinates: x,y spatial, node-based, or reach-based (with or without chainage) has_spatial_coords = "x" in ds.coords and "y" in ds.coords - has_network_coords = GeometryType.from_coords(ds) is not None + has_network_coords = GeometryType.from_network_coords(ds) is not None if not has_spatial_coords and not has_network_coords: raise ValueError( diff --git a/src/modelskill/types.py b/src/modelskill/types.py index a00b0699a..002ddb40f 100644 --- a/src/modelskill/types.py +++ b/src/modelskill/types.py @@ -57,8 +57,12 @@ def from_string(s: str) -> "GeometryType": ) from e @staticmethod - def from_coords(ds: xr.Dataset) -> "GeometryType | None": - """The geometry a dataset's coordinates make it. + def from_network_coords(ds: xr.Dataset) -> "GeometryType | None": + """The network location a dataset's coordinates record, if any. + + Only network coordinates are read. Data located some other way, by x and + y for instance, records no network location and gives None rather than + the geometry it does have. Parameters ---------- @@ -75,13 +79,13 @@ def from_coords(ds: xr.Dataset) -> "GeometryType | None": -------- >>> import xarray as xr >>> from modelskill.types import GeometryType - >>> GeometryType.from_coords(xr.Dataset(coords={"node": "123"})) + >>> GeometryType.from_network_coords(xr.Dataset(coords={"node": "123"})) - >>> GeometryType.from_coords(xr.Dataset(coords={"reach": "r1", "distance": 24.5})) + >>> GeometryType.from_network_coords(xr.Dataset(coords={"reach": "r1", "distance": 24.5})) - >>> GeometryType.from_coords(xr.Dataset(coords={"reach": "r1"})) + >>> GeometryType.from_network_coords(xr.Dataset(coords={"reach": "r1"})) - >>> GeometryType.from_coords(xr.Dataset(coords={"x": 0.0, "y": 0.0})) is None + >>> GeometryType.from_network_coords(xr.Dataset(coords={"x": 0.0, "y": 0.0})) is None True """ if "node" in ds.coords or {"reach", "distance"} <= set(ds.coords): From c6beb58f427008e53bed5036a3fc82d61ab2a248 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 09:35:20 +0200 Subject: [PATCH 031/117] Keep the coordinate reader in the coordinate module _coordinate_values sat in _timeseries.py while _coords.py held everything else about coordinates. Moving it also lets _coords.py read coordinates without importing _timeseries.py, which already imports _coords.py. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 3 +-- src/modelskill/obs.py | 2 +- src/modelskill/timeseries/_coords.py | 15 +++++++++++++++ src/modelskill/timeseries/_timeseries.py | 14 +------------- 4 files changed, 18 insertions(+), 16 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 3b262df72..c839aa670 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -34,9 +34,8 @@ _location_from_coords, ) from ..model import PointModelResult, TrackModelResult, VerticalModelResult -from ..timeseries._coords import NETWORK_LOCATION_COORDS +from ..timeseries._coords import NETWORK_LOCATION_COORDS, _coordinate_values from ..timeseries._timeseries import ( - _coordinate_values, _normalize_time_to_ns, _validate_data_var_name, ) diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index 5c0f17489..f4ae84e11 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -41,7 +41,7 @@ _parse_network_node_input, _parse_network_breakpoint_input, ) -from .timeseries._timeseries import _coordinate_values +from .timeseries._coords import _coordinate_values # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index 15c8b170c..c5c37556c 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -1,6 +1,9 @@ from __future__ import annotations +from typing import Any + import numpy as np +import xarray as xr #: Scalar coordinates that say where a network timeseries sits, rather than what #: it holds. They are dropped on the way to a dataframe, where they would @@ -56,3 +59,15 @@ def as_dict(self) -> dict: if self.distance is not None: d["distance"] = self.distance return d + + +def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: + """A dataset's values for one coordinate, or None when it has no such coordinate. + + A scalar coordinate is unwrapped to its single value; anything else is + handed back as the array it is. + """ + if coord not in ds.coords: + return None + vals = ds[coord].values + return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals diff --git a/src/modelskill/timeseries/_timeseries.py b/src/modelskill/timeseries/_timeseries.py index 5036bb3a6..55d8ae8af 100644 --- a/src/modelskill/timeseries/_timeseries.py +++ b/src/modelskill/timeseries/_timeseries.py @@ -10,25 +10,13 @@ from ..types import GeometryType from ..quantity import Quantity -from ._coords import NETWORK_LOCATION_COORDS +from ._coords import NETWORK_LOCATION_COORDS, _coordinate_values from ._plotter import TimeSeriesPlotter, MatplotlibTimeSeriesPlotter from .. import __version__ T = TypeVar("T", bound="TimeSeries") -def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: - """A dataset's values for one coordinate, or None when it has no such coordinate. - - A scalar coordinate is unwrapped to its single value; anything else is - handed back as the array it is. - """ - if coord not in ds.coords: - return None - vals = ds[coord].values - return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals - - DEFAULT_COLORS = [ "#b30000", "#7c1158", From 50fe132f53b133ae0a92c357d01d8e6bc6d4afb9 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 09:37:21 +0200 Subject: [PATCH 032/117] Read a network location from the coordinate module _location_from_coords lived in obs.py yet served model and comparison too, and it reads the same coordinates NodeCoords and ReachCoords write. It moves beside them as network_location. _at_from_coords stays in obs.py, since coercing to NodeObservation's `at` types is its own affair. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 9 ++++--- src/modelskill/model/network.py | 5 ++-- src/modelskill/obs.py | 32 ++++-------------------- src/modelskill/timeseries/_coords.py | 23 +++++++++++++++++ 4 files changed, 37 insertions(+), 32 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index c839aa670..4e3c6fe05 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -31,10 +31,13 @@ TrackObservation, NodeObservation, ReachObservation, - _location_from_coords, ) from ..model import PointModelResult, TrackModelResult, VerticalModelResult -from ..timeseries._coords import NETWORK_LOCATION_COORDS, _coordinate_values +from ..timeseries._coords import ( + NETWORK_LOCATION_COORDS, + _coordinate_values, + network_location, +) from ..timeseries._timeseries import ( _normalize_time_to_ns, _validate_data_var_name, @@ -667,7 +670,7 @@ def distance(self) -> Any: @property def _at(self) -> Any: """Where this comparer sits, in the form NodeObservation.at takes""" - return _location_from_coords(self.data) + return network_location(self.data) def _coordinate_values(self, coord: str) -> Any: """Get coordinate values if they exist, otherwise return None""" diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index f89bcd2ba..436c73019 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -14,7 +14,8 @@ _parse_network_node_input, ) from ._base import SelectedItems -from ..obs import NodeObservation, ReachObservation, _location_from_coords +from ..obs import NodeObservation, ReachObservation +from ..timeseries._coords import network_location from ..quantity import Quantity from ..types import GeometryType, PointType @@ -124,7 +125,7 @@ def __init__( @property def node(self) -> Any: """Where this result was extracted, as its network named it.""" - return _location_from_coords(self.data) + return network_location(self.data) def _location_repr(self) -> str | None: return f"Location: {self.node}" diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index f4ae84e11..d5f492286 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -41,7 +41,7 @@ _parse_network_node_input, _parse_network_breakpoint_input, ) -from .timeseries._coords import _coordinate_values +from .timeseries._coords import network_location # NetCDF attributes can only be str, int, float https://unidata.github.io/netcdf4-python/#attributes-in-a-netcdf-file @@ -867,36 +867,14 @@ def z(self): return self._coordinate_values("z") -def _location_from_coords(ds: xr.Dataset) -> Any: - """Where a network timeseries sits, as the network that produced it named it. - - Returns a node name for a node, a ``(reach, distance)`` pair for a - breakpoint, a reach name when no distance was given, and None for data that - carries no network location. The value is returned as recorded, so a comparer - saved by an older version gives back the integer it stored. - """ - if "node" in ds.coords: - return _scalar(ds, "node") - if "reach" in ds.coords: - reach = _scalar(ds, "reach") - if "distance" not in ds.coords: - return reach - return (reach, _scalar(ds, "distance")) - return None - - -def _scalar(ds: xr.Dataset, name: str) -> Any: - value = _coordinate_values(ds, name) - return value.item() if hasattr(value, "item") else value - - def _at_from_coords(ds: xr.Dataset) -> str | tuple[str, float]: """The location in the form ``NodeObservation`` takes it. - Unlike :func:`_location_from_coords`, which reports the location as - recorded, this coerces to the types the ``at`` argument is declared with. + Unlike :func:`~modelskill.timeseries._coords.network_location`, which + reports the location as recorded, this coerces to the types the ``at`` + argument is declared with. """ - location = _location_from_coords(ds) + location = network_location(ds) if isinstance(location, tuple): return (str(location[0]), float(location[1])) return str(location) diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index c5c37556c..9b5892fff 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -71,3 +71,26 @@ def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: return None vals = ds[coord].values return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals + + +def network_location(ds: xr.Dataset) -> Any: + """Where a network timeseries sits, as the network that produced it named it. + + Returns a node name for a node, a ``(reach, distance)`` pair for a + breakpoint, a reach name when no distance was given, and None for data that + carries no network location. The value is returned as recorded, so a comparer + saved by an older version gives back the integer it stored. + """ + if "node" in ds.coords: + return _scalar(ds, "node") + if "reach" in ds.coords: + reach = _scalar(ds, "reach") + if "distance" not in ds.coords: + return reach + return (reach, _scalar(ds, "distance")) + return None + + +def _scalar(ds: xr.Dataset, name: str) -> Any: + value = _coordinate_values(ds, name) + return value.item() if hasattr(value, "item") else value From aac8db150bcea689387655c2b223ca3b1e2c0940 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 10:36:31 +0200 Subject: [PATCH 033/117] Test the network module through its public surface The network tests reached past the objects a user holds and asserted on what backs them: the xarray coordinate layout instead of NodeObservation.at and .gtype, the private _create_new_instance instead of trim(), the unexported NodeModelResult, and NetworkModelResult.data. One test assigned to NetworkModelResult.data to reach a guard no caller can trigger; another replaced Network.to_dataset to fake a unit, re-testing Quantity.from_cf_attrs, which test_quantity.py already covers. Import the public names from modelskill, so the suite also proves they are exported, and move the ReachBreakPoint stub and network builder shared with the other test modules into tests/network_helpers.py. Adds the public surface that had no test at all: ms.observation() routing at= and reach= to the right class, Comparer.distance, NodeObservation.node on a breakpoint, and ReachObservation's weight and attrs. Drops two fixtures left over from the pre-mikeio1d xr.Dataset API. Co-Authored-By: Claude Opus 5 (1M context) --- tests/network_helpers.py | 39 ++++++ tests/test_network.py | 258 +++++++++++++++------------------------ 2 files changed, 140 insertions(+), 157 deletions(-) create mode 100644 tests/network_helpers.py diff --git a/tests/network_helpers.py b/tests/network_helpers.py new file mode 100644 index 000000000..5a17f4e3f --- /dev/null +++ b/tests/network_helpers.py @@ -0,0 +1,39 @@ +"""Helpers shared by the tests that build networks by hand. + +Importing this module needs mikeio1d, which is an optional dependency (ADR-010), +so guard the import with ``pytest.importorskip("mikeio1d.network")`` first. +""" + +from __future__ import annotations + +import pandas as pd +from mikeio1d.network import Network, BasicNode, BasicReach, ReachBreakPoint + + +class BreakPoint(ReachBreakPoint): + """A break point at a known distance along a reach.""" + + def __init__(self, reach, distance, data): + self._id = (reach, distance) + self._data = data + + @property + def id(self): + return self._id + + @property + def data(self): + return self._data + + +def make_network(node_ids, time, data, quantity="WaterLevel"): + """A chain of nodes, each carrying one quantity, joined by unit reaches.""" + nodes = [ + BasicNode(node_id, pd.DataFrame({quantity: data[:, i]}, index=time)) + for i, node_id in enumerate(node_ids) + ] + reaches = [ + BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) + for i in range(len(nodes) - 1) + ] + return Network(reaches) diff --git a/tests/test_network.py b/tests/test_network.py index f2a354b8b..dcaf4cbe5 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -10,66 +10,15 @@ import xarray as xr import numpy as np import modelskill as ms -from mikeio1d.network import Network, BasicNode, BasicReach, ReachBreakPoint -from modelskill.model.network import ( +from mikeio1d.network import Network, BasicNode, BasicReach +from modelskill import ( NetworkModelResult, - NodeModelResult, + NodeObservation, + Quantity, + ReachObservation, ) -from modelskill.obs import NodeObservation, ReachObservation -from modelskill.quantity import Quantity - -class BreakPoint(ReachBreakPoint): - """A break point at a known distance along a reach.""" - - def __init__(self, reach, distance, data): - self._id = (reach, distance) - self._data = data - - @property - def id(self): - return self._id - - @property - def data(self): - return self._data - - -def _make_network(node_ids, time, data, quantity="WaterLevel"): - nodes = [ - BasicNode(nid, pd.DataFrame({quantity: data[:, i]}, index=time)) - for i, nid in enumerate(node_ids) - ] - reaches = [ - BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) - for i in range(len(nodes) - 1) - ] - return Network(reaches) - - -@pytest.fixture -def sample_network_data(): - """Sample network data as xr.Dataset""" - time = pd.date_range("2010-01-01", periods=10, freq="h") - nodes = [123, 456, 789] - - # Create sample data - np.random.seed(42) # For reproducible tests - data = np.random.randn(len(time), len(nodes)) - - ds = xr.Dataset( - { - "WaterLevel": (["time", "node"], data), - }, - coords={ - "time": time, - "node": nodes, - }, - ) - ds["WaterLevel"].attrs["units"] = "m" - ds["WaterLevel"].attrs["long_name"] = "Water Level" - - return ds +from tests.network_helpers import BreakPoint, make_network @pytest.fixture @@ -78,7 +27,7 @@ def sample_network(): time = pd.date_range("2010-01-01", periods=10, freq="h") np.random.seed(42) data = np.random.randn(10, 3) - return _make_network(["123", "456", "789"], time, data) + return make_network(["123", "456", "789"], time, data) @pytest.fixture @@ -101,28 +50,6 @@ def sample_network_multivars(): return Network(reaches) -@pytest.fixture -def dataset_without_node(): - time = pd.date_range("2010-01-01", periods=10, freq="h") - - # Create sample data - np.random.seed(42) # For reproducible tests - data = np.random.randn(len(time)) - - ds = xr.Dataset( - { - "WaterLevel": (["time"], data), - }, - coords={ - "time": time, - }, - ) - ds["WaterLevel"].attrs["units"] = "m" - ds["WaterLevel"].attrs["long_name"] = "Water Level" - - return ds - - @pytest.fixture def breakpoint_network(): """A one-reach network whose data sits on a break point, not on the nodes.""" @@ -191,30 +118,21 @@ def test_explicit_quantity_wins(self, sample_network): assert nmr.quantity == given - def test_unit_is_used_when_the_data_carries_one(self, sample_network): - network = sample_network.copy() - ds = network.to_dataset() - ds["WaterLevel"].attrs["units"] = "meter" - network.to_dataset = lambda: ds # type: ignore[method-assign] - - nmr = NetworkModelResult(network) - - assert nmr.quantity == Quantity(name="WaterLevel", unit="meter") - def test_init_with_name(self, sample_network): """Test initialization with explicit name""" nmr = NetworkModelResult(sample_network, name="Test_Network") assert nmr.name == "Test_Network" - def test_init_with_item_selection(self, sample_network_multivars): + def test_init_with_item_selection(self, sample_network_multivars, sample_node_data): """Test initialization with specific item selection""" nmr = NetworkModelResult( sample_network_multivars, item="WaterLevel", name="Network_WL" ) + extracted = nmr.extract(NodeObservation(sample_node_data, at="123")) assert nmr.name == "Network_WL" - assert "WaterLevel" in nmr.data.data_vars - assert "Discharge" not in nmr.data.data_vars + assert nmr.quantity.name == "WaterLevel" + assert extracted.quantity.name == "WaterLevel" def test_init_fails_with_unsupported_type(self): """Test that passing a non-Network object raises an error""" @@ -237,7 +155,6 @@ def test_extract_valid_node(self, sample_network, sample_node_data): extracted = nmr.extract(obs) - assert isinstance(extracted, NodeModelResult) assert extracted.node == node_id assert len(extracted.time) == 10 @@ -487,21 +404,6 @@ def test_reaches_must_be_dict(self, multi_data): ReachObservation.from_multiple(data=multi_data, reaches="reach_1") -class TestNodeModelResult: - """Test NodeModelResult class""" - - @pytest.mark.parametrize("fixture_name", ["sample_node_data", "sample_series"]) - def test_init_(self, request, fixture_name): - """Test initialization with pandas DataFrame""" - data = request.getfixturevalue(fixture_name) - nmr = NodeModelResult(data, node="123", name="Node_123_Model") - - assert nmr.node == "123" - assert nmr.name == "Node_123_Model" - assert len(nmr.time) == 10 - assert "Location: 123" in repr(nmr) - - class TestNetworkIntegration: """Test integration between network models and observations""" @@ -513,7 +415,6 @@ def test_network_to_node_extraction(self, sample_network, sample_node_data): extracted = nmr.extract(obs) - assert isinstance(extracted, NodeModelResult) assert extracted.node == node_id assert extracted.name == "Network_Model" assert len(extracted.time) == len(obs.time) @@ -585,7 +486,6 @@ def test_extract_reach_observation_happy_path(sample_node_data): extracted = nmr.extract(obs) - assert isinstance(extracted, NodeModelResult) assert extracted.name == "network_model" reach, _ = extracted.node assert reach == "100l1" @@ -620,27 +520,6 @@ def test_extract_reach_observation_with_reaches_not_populated_raises_valueerror( nmr.extract(obs) -@pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" -) -def test_extract_reach_observation_breakpoint_node_missing_raises_valueerror( - sample_node_data, -): - path_to_file = "./tests/testdata/network.res1d" - network = Network.open(path_to_file) - nmr = NetworkModelResult(network, item="Discharge") - obs_data = sample_node_data.rename(columns={"WaterLevel": "Discharge"}) - on_reach = set(nmr.data.node.values[nmr.data["reach"].values == "100l1"]) - nmr.data = nmr.data.sel( - node=[int(node) for node in nmr.data.node.values if node not in on_reach] - ) - - obs = ms.ReachObservation(obs_data, reach="100l1", item="Discharge") - - with pytest.raises(ValueError, match="matching breakpoint nodes are missing"): - nmr.extract(obs) - - @pytest.mark.skipif( sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" ) @@ -669,45 +548,38 @@ def test_string_alias_stored(self, sample_node_data): obs = NodeObservation(sample_node_data, at="node_A", name="test") assert obs.at == "node_A" assert isinstance(obs.at, str) + assert obs.gtype == "node" - def test_string_alias_has_node_coord(self, sample_node_data): + def test_a_named_node_knows_its_node(self, sample_node_data): obs = NodeObservation(sample_node_data, at="node_A") - assert "node" in obs.data.coords - assert obs.data.coords["node"].item() == "node_A" - - def test_string_alias_gtype_is_node(self, sample_node_data): - obs = NodeObservation(sample_node_data, at="node_A") - assert obs.data.attrs["gtype"] == "node" + assert obs.node == "node_A" def test_tuple_node_stored(self, sample_node_data): obs = NodeObservation(sample_node_data, at=("reach_1", 24.5)) assert obs.at == ("reach_1", 24.5) assert isinstance(obs.at, tuple) + assert obs.gtype == "node" - def test_tuple_node_gtype_is_node(self, sample_node_data): + def test_a_breakpoint_has_no_node_name(self, sample_node_data): + """`node` names a junction; a breakpoint is placed along a reach instead.""" obs = NodeObservation(sample_node_data, at=("reach_1", 24.5)) - assert obs.data.attrs["gtype"] == "node" + assert obs.node is None - def test_tuple_node_has_reach_distance_coords(self, sample_node_data): + def test_a_breakpoint_survives_trimming(self, sample_node_data): obs = NodeObservation(sample_node_data, at=("reach_1", 24.5)) - assert "reach" in obs.data.coords - assert "distance" in obs.data.coords - assert str(obs.data.coords["reach"].item()) == "reach_1" - assert float(obs.data.coords["distance"].item()) == pytest.approx(24.5) - def test_tuple_node_has_no_node_coord(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=("reach_1", 24.5)) - assert "node" not in obs.data.coords + trimmed = obs.trim(start_time=obs.time[1], end_time=obs.time[-1]) - def test_tuple_node_roundtrip_via_create_new_instance(self, sample_node_data): - obs = NodeObservation(sample_node_data, at=("reach_1", 24.5)) - obs2 = obs._create_new_instance(obs.data) - assert obs2.at == ("reach_1", 24.5) + assert trimmed.at == ("reach_1", 24.5) + assert len(trimmed) == len(obs) - 1 - def test_string_roundtrip_via_create_new_instance(self, sample_node_data): + def test_a_named_node_observation_survives_trimming(self, sample_node_data): obs = NodeObservation(sample_node_data, at="node_A") - obs2 = obs._create_new_instance(obs.data) - assert obs2.at == "node_A" + + trimmed = obs.trim(start_time=obs.time[1], end_time=obs.time[-1]) + + assert trimmed.at == "node_A" + assert len(trimmed) == len(obs) - 1 # --------------------------------------------------------------------------- @@ -729,7 +601,6 @@ def test_extract_with_string_alias(self, sample_network, sample_node_data): extracted = nmr.extract(obs) - assert isinstance(extracted, NodeModelResult) assert extracted.node == "123" def test_extract_string_alias_wrong_key_raises( @@ -829,3 +700,76 @@ def test_a_named_node_survives_trimming(self, sample_network, sample_node_data): assert trimmed.node == extracted.node assert len(trimmed) == len(extracted) - 1 + + def test_a_matched_breakpoint_records_its_chainage( + self, breakpoint_network, sample_node_data + ): + nmr = NetworkModelResult(breakpoint_network, name="Network_Model") + obs = ms.NodeObservation(sample_node_data, at=("r1", 50.0), name="BP") + + cmp = ms.match(obs, nmr) + + assert cmp.gtype == "node" + assert cmp.node is None + assert cmp.reach == "r1" + assert cmp.distance == pytest.approx(50.0) + + def test_a_matched_reach_reports_the_breakpoint_it_was_read_from( + self, breakpoint_network, sample_node_data + ): + """The observation is reach-level, so gtype stays 'reach'; distance says + which breakpoint the model data was taken from.""" + nmr = NetworkModelResult(breakpoint_network, name="Network_Model") + obs = ms.ReachObservation(sample_node_data, reach="r1", name="Reach") + + cmp = ms.match(obs, nmr) + + assert cmp.gtype == "reach" + assert cmp.reach == "r1" + assert cmp.distance == pytest.approx(50.0) + + +class TestObservationFactory: + """ms.observation() routes the network keywords to the right class.""" + + def test_at_gives_a_node_observation(self, sample_node_data): + obs = ms.observation(sample_node_data, at="123", item="WaterLevel") + + assert isinstance(obs, ms.NodeObservation) + assert obs.at == "123" + + def test_a_breakpoint_tuple_gives_a_node_observation(self, sample_node_data): + obs = ms.observation(sample_node_data, at=("r1", 24.5), item="WaterLevel") + + assert isinstance(obs, ms.NodeObservation) + assert obs.at == ("r1", 24.5) + + def test_reach_gives_a_reach_observation(self, sample_node_data): + obs = ms.observation(sample_node_data, reach="r1", item="WaterLevel") + + assert isinstance(obs, ms.ReachObservation) + assert obs.reach == "r1" + + @pytest.mark.parametrize( + "gtype,kwargs,expected", + [ + ("node", {"at": "123"}, ms.NodeObservation), + ("reach", {"reach": "r1"}, ms.ReachObservation), + ], + ) + def test_gtype_can_be_named_outright( + self, sample_node_data, gtype, kwargs, expected + ): + obs = ms.observation(sample_node_data, gtype=gtype, item="WaterLevel", **kwargs) + + assert isinstance(obs, expected) + + +def test_a_reach_observation_keeps_its_weight_and_attrs(sample_node_data): + obs = ReachObservation( + sample_node_data, reach="r1", weight=2.5, attrs={"source": "test"} + ) + + assert obs.weight == 2.5 + assert obs.attrs["source"] == "test" + assert obs.quantity == Quantity.undefined() From a8ba234e6bae560f1e5e43460ea60e3027eec865 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 10:38:24 +0200 Subject: [PATCH 034/117] Reach the network comparers through modelskill's own names The two network fixtures deep-imported NetworkModelResult and the observations, and carried a second copy of the ReachBreakPoint stub that tests/network_helpers.py now holds. The 1.4.0a3 test called the private _to_observation to see an integer refused, which TestNodeObservationAliases already covers on the constructor itself. Adds the skill() and plot() calls a node or reach comparer had no test for. Co-Authored-By: Claude Opus 5 (1M context) --- tests/test_comparercollection.py | 55 +++++++++++++------------------- 1 file changed, 23 insertions(+), 32 deletions(-) diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 2a66ad4ac..1ee59ceea 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -456,8 +456,6 @@ def node_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a NodeObservation against a NetworkModelResult (node gtype).""" pytest.importorskip("mikeio1d.network") from mikeio1d.network import Network, BasicNode, BasicReach - from modelskill.model.network import NetworkModelResult - from modelskill.obs import NodeObservation time = pd.date_range("2019-01-01", periods=6, freq="D") node_a_data = pd.DataFrame( @@ -471,8 +469,8 @@ def node_comparer() -> modelskill.comparison.Comparer: ) network = Network([reach]) - nmr = NetworkModelResult(network, name="Network_Model") - obs = NodeObservation(node_a_data, at="123", name="Node_123_Obs") + nmr = ms.NetworkModelResult(network, name="Network_Model") + obs = ms.NodeObservation(node_a_data, at="123", name="Node_123_Obs") return ms.match(obs, nmr) @@ -481,27 +479,9 @@ def node_comparer() -> modelskill.comparison.Comparer: def reach_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a ReachObservation (reach gtype).""" pytest.importorskip("mikeio1d.network") - from mikeio1d.network import ( - Network, - BasicNode, - BasicReach, - ReachBreakPoint, - ) - from modelskill.model.network import NetworkModelResult - from modelskill.obs import ReachObservation - - class Point(ReachBreakPoint): - def __init__(self, reach, distance, data): - self._id = (reach, distance) - self._data = data - - @property - def id(self): - return self._id + from mikeio1d.network import Network, BasicNode, BasicReach - @property - def data(self): - return self._data + from tests.network_helpers import BreakPoint time = pd.date_range("2019-01-01", periods=6, freq="D") values = pd.DataFrame({"WaterLevel": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, index=time) @@ -511,11 +491,11 @@ def data(self): BasicNode("123", empty), BasicNode("456", empty), length=100.0, - breakpoints=[Point("r1", 50.0, values)], + breakpoints=[BreakPoint("r1", 50.0, values)], ) - nmr = NetworkModelResult(Network([reach]), name="Network_Model") - obs = ReachObservation(values, reach="r1", name="Reach_r1_Obs") + nmr = ms.NetworkModelResult(Network([reach]), name="Network_Model") + obs = ms.ReachObservation(values, reach="r1", name="Reach_r1_Obs") return ms.match(obs, nmr) @@ -551,11 +531,6 @@ def test_a_comparer_saved_by_1_4_0a3_still_loads(): assert cmp.node == 0 assert cmp.skill().to_dataframe().shape[0] == 1 - # Turning it back into an observation is where the integer is refused, since - # NodeObservation no longer accepts one. - with pytest.raises(TypeError, match="not an integer"): - cmp._to_observation() - def test_save_and_load_round_trips_reach_gtype_raw_data(reach_comparer, tmp_path): """Reach-gtype comparers must survive a save()/load() round trip too.""" @@ -587,6 +562,22 @@ def test_to_dataframe_on_a_reach_comparer(reach_comparer): assert df.index.name == "time" +def test_skill_on_a_node_comparer(node_comparer): + sk = node_comparer.skill() + + assert sk.to_dataframe().shape[0] == 1 + assert "Node_123_Obs" in sk.index + + +def test_plot_a_node_comparer(node_comparer): + assert node_comparer.plot.timeseries() is not None + assert node_comparer.plot.scatter() is not None + + +def test_plot_a_reach_comparer(reach_comparer): + assert reach_comparer.plot.timeseries() is not None + + # ======================== plotting ======================== From bc6e446377c09b2c05fa57ce0bab6173a522b5a4 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 10:40:17 +0200 Subject: [PATCH 035/117] Match a reach observation end to end ms.match() with a ReachObservation was only ever reached through a comparer fixture, so the reach path had no test of its own in test_match.py. Add one, and put the third copy of the hand-built network next to the other two in tests/network_helpers.py, which now also builds the one-reach network whose data sits on a break point. Co-Authored-By: Claude Opus 5 (1M context) --- tests/network_helpers.py | 13 ++++++++ tests/test_comparercollection.py | 16 +++------- tests/test_match.py | 54 ++++++++++++++++++++++---------- tests/test_network.py | 12 ++----- 4 files changed, 56 insertions(+), 39 deletions(-) diff --git a/tests/network_helpers.py b/tests/network_helpers.py index 5a17f4e3f..897951f30 100644 --- a/tests/network_helpers.py +++ b/tests/network_helpers.py @@ -37,3 +37,16 @@ def make_network(node_ids, time, data, quantity="WaterLevel"): for i in range(len(nodes) - 1) ] return Network(reaches) + + +def make_breakpoint_network(reach_id, distance, data): + """A one-reach network whose data sits on a break point, not on its nodes.""" + empty = pd.DataFrame() + reach = BasicReach( + reach_id, + BasicNode("start", empty), + BasicNode("end", empty), + length=100.0, + breakpoints=[BreakPoint(reach_id, distance, data)], + ) + return Network([reach]) diff --git a/tests/test_comparercollection.py b/tests/test_comparercollection.py index 1ee59ceea..7a1fb9459 100644 --- a/tests/test_comparercollection.py +++ b/tests/test_comparercollection.py @@ -479,22 +479,14 @@ def node_comparer() -> modelskill.comparison.Comparer: def reach_comparer() -> modelskill.comparison.Comparer: """A comparer built by matching a ReachObservation (reach gtype).""" pytest.importorskip("mikeio1d.network") - from mikeio1d.network import Network, BasicNode, BasicReach - - from tests.network_helpers import BreakPoint + from tests.network_helpers import make_breakpoint_network time = pd.date_range("2019-01-01", periods=6, freq="D") values = pd.DataFrame({"WaterLevel": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]}, index=time) - empty = pd.DataFrame() - reach = BasicReach( - "r1", - BasicNode("123", empty), - BasicNode("456", empty), - length=100.0, - breakpoints=[BreakPoint("r1", 50.0, values)], - ) - nmr = ms.NetworkModelResult(Network([reach]), name="Network_Model") + nmr = ms.NetworkModelResult( + make_breakpoint_network("r1", 50.0, values), name="Network_Model" + ) obs = ms.ReachObservation(values, reach="r1", name="Reach_r1_Obs") return ms.match(obs, nmr) diff --git a/tests/test_match.py b/tests/test_match.py index 781a8642e..ec0b25278 100644 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -9,21 +9,6 @@ from modelskill.model.dfsu import DfsuModelResult -def _make_basic_network(node_ids, time, data, quantity="WaterLevel"): - """A chain of nodes, each carrying one quantity, joined by unit reaches.""" - from mikeio1d.network import Network, BasicNode, BasicReach - - nodes = [ - BasicNode(node_id, pd.DataFrame({quantity: data[:, i]}, index=time)) - for i, node_id in enumerate(node_ids) - ] - reaches = [ - BasicReach(f"r{i}", nodes[i], nodes[i + 1], length=100.0) - for i in range(len(nodes) - 1) - ] - return Network(reaches) - - @pytest.fixture def o1(): fn = "tests/testdata/SW/HKNA_Hm0.dfs0" @@ -352,20 +337,24 @@ def test_only_1_model_depth_overlap(self, simple_vo, simple_vm): def network(): """Network fixture with 3 nodes""" pytest.importorskip("networkx") + from tests.network_helpers import make_network + time = pd.date_range("2017-10-27", periods=20, freq="h") np.random.seed(42) data = np.random.normal(1.5, 0.3, (20, 3)) - return _make_basic_network(["100", "200", "300"], time, data) + return make_network(["100", "200", "300"], time, data) @pytest.fixture def network2(): """Second network fixture with offset data for multi-model tests""" pytest.importorskip("networkx") + from tests.network_helpers import make_network + time = pd.date_range("2017-10-27", periods=20, freq="h") np.random.seed(42) data = np.random.normal(1.5, 0.3, (20, 3)) + 0.1 - return _make_basic_network(["100", "200", "300"], time, data) + return make_network(["100", "200", "300"], time, data) @pytest.fixture @@ -1018,6 +1007,37 @@ def test_match_node_obs_with_network_model(node_obs1, network_mr): assert cmp.mod_names == ["Network_Model"] +def test_match_reach_obs_with_network_model(): + """A reach observation matches any breakpoint along the reach.""" + pytest.importorskip("mikeio1d.network") + from tests.network_helpers import make_breakpoint_network + + time = pd.date_range("2017-10-27", periods=20, freq="h") + np.random.seed(42) + model_data = pd.DataFrame( + {"WaterLevel": np.random.normal(1.5, 0.3, len(time))}, index=time + ) + network_mr = ms.NetworkModelResult( + make_breakpoint_network("r0", 50.0, model_data), name="Network_Model" + ) + + np.random.seed(123) + obs_time = time[:18] + df = pd.DataFrame( + {"WaterLevel": np.random.normal(1.4, 0.2, len(obs_time))}, index=obs_time + ) + obs = ms.ReachObservation(df, reach="r0", name="Reach_r0") + + cmp = ms.match(obs, network_mr) + + assert cmp.n_models == 1 + assert cmp.n_points == 18 + assert cmp.name == "Reach_r0" + assert cmp.gtype == "reach" + assert cmp.reach == "r0" + assert cmp.mod_names == ["Network_Model"] + + def test_match_multiple_node_obs_with_network(node_obs1, node_obs2, network_mr): cc = ms.match([node_obs1, node_obs2], network_mr) assert cc.n_models == 1 diff --git a/tests/test_network.py b/tests/test_network.py index dcaf4cbe5..cf8857845 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -18,7 +18,7 @@ ReachObservation, ) -from tests.network_helpers import BreakPoint, make_network +from tests.network_helpers import make_breakpoint_network, make_network @pytest.fixture @@ -56,15 +56,7 @@ def breakpoint_network(): time = pd.date_range("2010-01-01", periods=10, freq="h") np.random.seed(42) values = pd.DataFrame({"WaterLevel": np.random.randn(10)}, index=time) - empty = pd.DataFrame() - reach = BasicReach( - "r1", - BasicNode("start", empty), - BasicNode("end", empty), - length=100.0, - breakpoints=[BreakPoint("r1", 50.0, values)], - ) - return Network([reach]) + return make_breakpoint_network("r1", 50.0, values) @pytest.fixture From dffb9093261e084a998aaf70751349596b25a037 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 10:40:51 +0200 Subject: [PATCH 036/117] Run the doctests that state the network-coordinate rule GeometryType.from_network_coords is the one place the rule lives, and its doctests were never collected: the doctest target named metrics.py alone. Also takes the MIKE+ observations from modelskill rather than modelskill.obs, and drops the integer node keys two of its tests still pass, which NodeObservation no longer accepts as a location. Co-Authored-By: Claude Opus 5 (1M context) --- justfile | 4 ++-- tests/test_mikeplus.py | 7 +++---- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/justfile b/justfile index d027887a5..e33c86c5c 100644 --- a/justfile +++ b/justfile @@ -23,9 +23,9 @@ test: typecheck: uv run mypy src/ --config-file pyproject.toml -# Run doctests in metrics.py +# Run doctests in metrics.py and types.py doctest: - uv run pytest src/modelskill/metrics.py --doctest-modules + uv run pytest src/modelskill/metrics.py src/modelskill/types.py --doctest-modules # Generate HTML coverage report coverage: diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py index 456b6f22c..bce209243 100644 --- a/tests/test_mikeplus.py +++ b/tests/test_mikeplus.py @@ -4,8 +4,7 @@ import pandas as pd import pytest -from modelskill import Quantity -from modelskill.obs import NodeObservation, ReachObservation +from modelskill import NodeObservation, Quantity, ReachObservation STATION_COLUMNS = [ "muid", @@ -496,7 +495,7 @@ def test_unresolvable_item_can_be_skipped(self, db, calibration_data): def test_db_and_nodes_are_mutually_exclusive(self, db, calibration_data): with pytest.raises(ValueError, match="mutually exclusive"): NodeObservation.from_multiple( - data=calibration_data, db=db, nodes={1: "item_pressure_1"} + data=calibration_data, db=db, nodes={"wNode_1": "item_pressure_1"} ) def test_db_without_data_raises(self, db): @@ -522,7 +521,7 @@ def test_quantity_string_without_db_raises(self, calibration_data): with pytest.raises(TypeError, match="must be a Quantity"): NodeObservation.from_multiple( data=calibration_data, - nodes={1: "item_pressure_1"}, + nodes={"wNode_1": "item_pressure_1"}, quantity="Pressure", ) From 61babd02973b18fd3b881f7b2836b196ecd08d83 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 11:42:08 +0200 Subject: [PATCH 037/117] Moving constant --- src/modelskill/timeseries/_coords.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/modelskill/timeseries/_coords.py b/src/modelskill/timeseries/_coords.py index 9b5892fff..14b5559d2 100644 --- a/src/modelskill/timeseries/_coords.py +++ b/src/modelskill/timeseries/_coords.py @@ -5,11 +5,6 @@ import numpy as np import xarray as xr -#: Scalar coordinates that say where a network timeseries sits, rather than what -#: it holds. They are dropped on the way to a dataframe, where they would -#: otherwise become columns. -NETWORK_LOCATION_COORDS = ("node", "node_index", "reach", "distance") - class XYZCoords: def __init__( @@ -73,6 +68,12 @@ def _coordinate_values(ds: xr.Dataset, coord: str) -> Any: return np.atleast_1d(vals)[0] if vals.ndim == 0 else vals +#: Scalar coordinates that say where a network timeseries sits, rather than what +#: it holds. They are dropped on the way to a dataframe, where they would +#: otherwise become columns. +NETWORK_LOCATION_COORDS = ("node", "node_index", "reach", "distance") + + def network_location(ds: xr.Dataset) -> Any: """Where a network timeseries sits, as the network that produced it named it. @@ -82,15 +83,15 @@ def network_location(ds: xr.Dataset) -> Any: saved by an older version gives back the integer it stored. """ if "node" in ds.coords: - return _scalar(ds, "node") + return _network_scalar(ds, "node") if "reach" in ds.coords: - reach = _scalar(ds, "reach") + reach = _network_scalar(ds, "reach") if "distance" not in ds.coords: return reach - return (reach, _scalar(ds, "distance")) + return (reach, _network_scalar(ds, "distance")) return None -def _scalar(ds: xr.Dataset, name: str) -> Any: +def _network_scalar(ds: xr.Dataset, name: str) -> Any: value = _coordinate_values(ds, name) return value.item() if hasattr(value, "item") else value From 9b5d164c14212de5a4aca222ce0d2eb69f3bc3e2 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 14:20:58 +0200 Subject: [PATCH 038/117] Fix network plotting in example notebook --- notebooks/Collection_systems_network.ipynb | 91 ++++++++++++---------- 1 file changed, 51 insertions(+), 40 deletions(-) diff --git a/notebooks/Collection_systems_network.ipynb b/notebooks/Collection_systems_network.ipynb index ffb8e9548..5291a0e84 100644 --- a/notebooks/Collection_systems_network.ipynb +++ b/notebooks/Collection_systems_network.ipynb @@ -938,40 +938,59 @@ }, "outputs": [], "source": [ - "def plot_network(network):\n", + "def network_layout(network):\n", + " \"\"\"Place every graph node: named nodes from the reach skeleton, break points\n", + " interpolated along the reach that carries them.\n", "\n", - " g = network.graph.copy()\n", - " lengths = nx.get_edge_attributes(g, \"length\")\n", - " max_len = max(lengths.values()) if lengths else 1.0\n", - " nx.set_edge_attributes(\n", - " g,\n", - " {e: v / max_len for e, v in lengths.items()},\n", - " \"norm_length\",\n", - " )\n", + " The graph joins a named node to the break point at the same chainage with a\n", + " zero-length edge, so a layout that reads edge lengths as distances cannot be\n", + " run over the graph itself. The skeleton of named nodes carries the reach\n", + " lengths without those edges, and every break point has a chainage that says\n", + " where along its reach it belongs.\n", + " \"\"\"\n", + " skeleton = nx.Graph()\n", + " for reach in network.reaches.values():\n", + " skeleton.add_edge(reach.start.id, reach.end.id, length=reach.length or 1.0)\n", + " named = nx.kamada_kawai_layout(skeleton, weight=\"length\")\n", + "\n", + " graph_id = {a: n for n, a in nx.get_node_attributes(network.graph, \"alias\").items()}\n", + " pos = {graph_id[name]: np.asarray(p) for name, p in named.items()}\n", + " for reach_id, reach in network.reaches.items():\n", + " start, end = np.asarray(named[reach.start.id]), np.asarray(named[reach.end.id])\n", + " span = reach.end_distance - reach.start_distance\n", + " for bp in reach.breakpoints:\n", + " if bp.distance is None: # a reach end whose chainage is unknown\n", + " fraction = 1.0\n", + " elif span == 0:\n", + " fraction = 0.0\n", + " else:\n", + " fraction = (bp.distance - reach.start_distance) / span\n", + " pos[graph_id[(reach_id, bp.distance)]] = start + fraction * (end - start)\n", + " return pos\n", + "\n", + "\n", + "def plot_network(network, ax=None):\n", + " \"\"\"Draw the network: named nodes as large circles, break points as small ones.\"\"\"\n", + " graph = network.graph\n", + " pos = network_layout(network)\n", "\n", " # recall() says what each integer stands for: a named node, or a break point\n", " # given as a reach and a distance along it.\n", - " kinds = network.recall(list(g.nodes()))\n", - " widthmap = [2 if \"node\" in kind else 1 for kind in kinds]\n", - " plot_kwargs = {\n", - " \"font_size\": 6,\n", - " \"node_size\": 130,\n", - " \"node_color\": \"white\",\n", - " \"edgecolors\": \"black\",\n", - " \"linewidths\": widthmap,\n", - " \"with_labels\": True,\n", - " }\n", - " fig, ax = plt.subplots(1, 1, sharey=True, layout=\"tight\", figsize=(10, 9))\n", + " kinds = network.recall(list(graph))\n", + " nodes = [n for n, kind in zip(graph, kinds) if \"node\" in kind]\n", + " breakpoints = [n for n, kind in zip(graph, kinds) if \"node\" not in kind]\n", "\n", - " pos = nx.kamada_kawai_layout(g, weight=\"norm_length\", scale=10)\n", - " nx.draw(g, ax=ax, pos=pos, **plot_kwargs)\n", - "\n", - " # Set limits explicitly AFTER draw, otherwise matplotlib auto-scales them away\n", - " xs, ys = zip(*pos.values())\n", - " pad = 0.5\n", - " ax.set_xlim(min(xs) - pad, max(xs) + pad)\n", - " ax.set_ylim(min(ys) - pad, max(ys) + pad)\n", - " plt.show()\n" + " if ax is None:\n", + " _, ax = plt.subplots(figsize=(10, 9), layout=\"tight\")\n", + " nx.draw_networkx_edges(graph, pos, ax=ax, edge_color=\"0.55\", width=0.8)\n", + " # break points first, so a break point coincident with a node hides beneath it\n", + " nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=breakpoints, node_size=14,\n", + " node_color=\"white\", edgecolors=\"0.45\", linewidths=0.6)\n", + " nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=nodes, node_size=55,\n", + " node_color=\"white\", edgecolors=\"black\", linewidths=1.4)\n", + " ax.set_aspect(\"equal\")\n", + " ax.set_axis_off()\n", + " return ax" ] }, { @@ -987,17 +1006,9 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/japr/Repos/modelskill/.venv/lib/python3.12/site-packages/networkx/drawing/layout.py:987: RuntimeWarning: divide by zero encountered in divide\n", - " costargs = (np, 1 / (dist_mtx + np.eye(dist_mtx.shape[0]) * 1e-3), meanwt, dim)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1007,7 +1018,7 @@ } ], "source": [ - "plot_network(network)" + "plot_network(network);" ] }, { @@ -1015,7 +1026,7 @@ "id": "5d3030f5", "metadata": {}, "source": [ - "Notice that in the visualisation above, some graph nodes have a thicker outline — these are the *nodes* (junctions and boundaries), while the others are *break points* along each reach.\n", + "Notice that in the visualisation above, the large, heavy circles are the *nodes* (junctions and boundaries), while the small ones strung along each reach are its *break points*. A break point coincident with a node — the first and last gridpoint of a reach — sits beneath that node's circle, which is where it physically is.\n", "\n", "#### Mapping original IDs to integer IDs\n", "\n", From 0be65c2eaf842f5bd8d7fc8711ba7f2f4dcef4a6 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 15:36:02 +0200 Subject: [PATCH 039/117] Include tests for network values passed to the comparer --- tests/test_network.py | 110 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) diff --git a/tests/test_network.py b/tests/test_network.py index cf8857845..095289cce 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -21,6 +21,22 @@ from tests.network_helpers import make_breakpoint_network, make_network +@pytest.fixture +def node_values(): + """A distinct series per node, so no node can stand in for another.""" + time = pd.date_range("2010-01-01", periods=10, freq="h") + values = np.arange(30.0).reshape(10, 3) + return pd.DataFrame(values, index=time, columns=["123", "456", "789"]) + + +@pytest.fixture +def distinct_network(node_values): + """A three-node network holding `node_values`, one column per node.""" + return make_network( + list(node_values.columns), node_values.index, node_values.to_numpy() + ) + + @pytest.fixture def sample_network(): """Sample Network with 3 nodes (WaterLevel quantity)""" @@ -456,6 +472,100 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data assert comparer.n_points > 0 +class TestValuesReachTheComparer: + """The series a comparer holds is the one the network keeps at that location. + + The observation is built from the model's own data, so an exact match is the + expected outcome and any mix-up between locations or models shows up as a + non-zero score. + """ + + def test_extract_returns_the_nodes_own_series(self, distinct_network, node_values): + nmr = NetworkModelResult(distinct_network, name="Network_Model") + obs = NodeObservation(node_values, at="456", item="456") + + extracted = nmr.extract(obs) + + assert extracted.to_dataframe()["Network_Model"].to_numpy() == pytest.approx( + node_values["456"].to_numpy() + ) + + def test_a_matched_node_scores_zero_against_its_own_series( + self, distinct_network, node_values + ): + nmr = NetworkModelResult(distinct_network, name="Network_Model") + obs = NodeObservation(node_values, at="456", item="456", name="Node_456_Obs") + + cmp = ms.match(obs, nmr) + + assert cmp.n_points == len(node_values) + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + def test_every_node_of_a_collection_keeps_its_own_series( + self, distinct_network, node_values + ): + """One observation per node, each read from that node's own column.""" + nmr = NetworkModelResult(distinct_network, name="Network_Model") + obs_list = NodeObservation.from_multiple( + data=node_values, nodes={nid: nid for nid in node_values.columns} + ) + + cc = ms.match(obs_list, nmr) + + assert len(cc) == 3 + for cmp in cc: + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + def test_two_networks_keep_their_series_apart(self, distinct_network, node_values): + """The second network is the first shifted by 0.1. + + A crossed model column would put that shift on the wrong name. + """ + shifted = make_network( + list(node_values.columns), + node_values.index, + node_values.to_numpy() + 0.1, + ) + obs = NodeObservation(node_values, at="456", item="456", name="Node_456_Obs") + + cmp = ms.match( + obs, + [ + NetworkModelResult(distinct_network, name="Network_1"), + NetworkModelResult(shifted, name="Network_2"), + ], + ) + + bias = cmp.score(metric="bias") + assert bias["Network_1"] == pytest.approx(0.0) + assert bias["Network_2"] == pytest.approx(0.1) + + def test_a_matched_breakpoint_scores_zero_against_its_own_series( + self, breakpoint_network + ): + """The break point's data sits on neither of the reach's nodes.""" + values = breakpoint_network.reaches["r1"].breakpoints[0].data + nmr = NetworkModelResult(breakpoint_network, name="Network_Model") + obs = NodeObservation(values, at=("r1", 50.0), name="BP_Obs") + + cmp = ms.match(obs, nmr) + + assert cmp.n_points == len(values) + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + def test_a_matched_reach_scores_zero_against_its_breakpoints_series( + self, breakpoint_network + ): + values = breakpoint_network.reaches["r1"].breakpoints[0].data + nmr = NetworkModelResult(breakpoint_network, name="Network_Model") + obs = ReachObservation(values, reach="r1", name="Reach_Obs") + + cmp = ms.match(obs, nmr) + + assert cmp.n_points == len(values) + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + @pytest.mark.skipif( sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" ) From d2995a16c043b4ddc02c82c1b4280701ea09f8c6 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 15:45:32 +0200 Subject: [PATCH 040/117] Reusing existing fixtures --- tests/test_network.py | 69 ++++++++++++++++++++----------------------- 1 file changed, 32 insertions(+), 37 deletions(-) diff --git a/tests/test_network.py b/tests/test_network.py index 095289cce..690df623b 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -21,22 +21,6 @@ from tests.network_helpers import make_breakpoint_network, make_network -@pytest.fixture -def node_values(): - """A distinct series per node, so no node can stand in for another.""" - time = pd.date_range("2010-01-01", periods=10, freq="h") - values = np.arange(30.0).reshape(10, 3) - return pd.DataFrame(values, index=time, columns=["123", "456", "789"]) - - -@pytest.fixture -def distinct_network(node_values): - """A three-node network holding `node_values`, one column per node.""" - return make_network( - list(node_values.columns), node_values.index, node_values.to_numpy() - ) - - @pytest.fixture def sample_network(): """Sample Network with 3 nodes (WaterLevel quantity)""" @@ -472,6 +456,19 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data assert comparer.n_points > 0 +def node_series(network): + """Each node's own series, keyed by node id, read off the network's reaches. + + The three nodes of `sample_network` carry three different series, so a + comparer built from one of them cannot be satisfied by any of the others. + """ + nodes = {} + for reach in network.reaches.values(): + for node in (reach.start, reach.end): + nodes[node.id] = node.data["WaterLevel"] + return pd.DataFrame(nodes) + + class TestValuesReachTheComparer: """The series a comparer holds is the one the network keeps at that location. @@ -480,34 +477,33 @@ class TestValuesReachTheComparer: non-zero score. """ - def test_extract_returns_the_nodes_own_series(self, distinct_network, node_values): - nmr = NetworkModelResult(distinct_network, name="Network_Model") - obs = NodeObservation(node_values, at="456", item="456") + def test_extract_returns_the_nodes_own_series(self, sample_network): + values = node_series(sample_network) + nmr = NetworkModelResult(sample_network, name="Network_Model") + obs = NodeObservation(values, at="456", item="456") extracted = nmr.extract(obs) assert extracted.to_dataframe()["Network_Model"].to_numpy() == pytest.approx( - node_values["456"].to_numpy() + values["456"].to_numpy() ) - def test_a_matched_node_scores_zero_against_its_own_series( - self, distinct_network, node_values - ): - nmr = NetworkModelResult(distinct_network, name="Network_Model") - obs = NodeObservation(node_values, at="456", item="456", name="Node_456_Obs") + def test_a_matched_node_scores_zero_against_its_own_series(self, sample_network): + values = node_series(sample_network) + nmr = NetworkModelResult(sample_network, name="Network_Model") + obs = NodeObservation(values, at="456", item="456", name="Node_456_Obs") cmp = ms.match(obs, nmr) - assert cmp.n_points == len(node_values) + assert cmp.n_points == len(values) assert cmp.score()["Network_Model"] == pytest.approx(0.0) - def test_every_node_of_a_collection_keeps_its_own_series( - self, distinct_network, node_values - ): + def test_every_node_of_a_collection_keeps_its_own_series(self, sample_network): """One observation per node, each read from that node's own column.""" - nmr = NetworkModelResult(distinct_network, name="Network_Model") + values = node_series(sample_network) + nmr = NetworkModelResult(sample_network, name="Network_Model") obs_list = NodeObservation.from_multiple( - data=node_values, nodes={nid: nid for nid in node_values.columns} + data=values, nodes={nid: nid for nid in values.columns} ) cc = ms.match(obs_list, nmr) @@ -516,22 +512,21 @@ def test_every_node_of_a_collection_keeps_its_own_series( for cmp in cc: assert cmp.score()["Network_Model"] == pytest.approx(0.0) - def test_two_networks_keep_their_series_apart(self, distinct_network, node_values): + def test_two_networks_keep_their_series_apart(self, sample_network): """The second network is the first shifted by 0.1. A crossed model column would put that shift on the wrong name. """ + values = node_series(sample_network) shifted = make_network( - list(node_values.columns), - node_values.index, - node_values.to_numpy() + 0.1, + list(values.columns), values.index, values.to_numpy() + 0.1 ) - obs = NodeObservation(node_values, at="456", item="456", name="Node_456_Obs") + obs = NodeObservation(values, at="456", item="456", name="Node_456_Obs") cmp = ms.match( obs, [ - NetworkModelResult(distinct_network, name="Network_1"), + NetworkModelResult(sample_network, name="Network_1"), NetworkModelResult(shifted, name="Network_2"), ], ) From 173fe46bffc4400895daacf71eb60293f051f293 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 15:47:32 +0200 Subject: [PATCH 041/117] Move function to network_helpers --- tests/network_helpers.py | 13 +++++++++++++ tests/test_network.py | 15 +-------------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/tests/network_helpers.py b/tests/network_helpers.py index 897951f30..43d738a42 100644 --- a/tests/network_helpers.py +++ b/tests/network_helpers.py @@ -50,3 +50,16 @@ def make_breakpoint_network(reach_id, distance, data): breakpoints=[BreakPoint(reach_id, distance, data)], ) return Network([reach]) + + +def node_series(network): + """Each node's own series, keyed by node id, read off the network's reaches. + + The three nodes of `sample_network` carry three different series, so a + comparer built from one of them cannot be satisfied by any of the others. + """ + nodes = {} + for reach in network.reaches.values(): + for node in (reach.start, reach.end): + nodes[node.id] = node.data["WaterLevel"] + return pd.DataFrame(nodes) diff --git a/tests/test_network.py b/tests/test_network.py index 690df623b..7578af456 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -18,7 +18,7 @@ ReachObservation, ) -from tests.network_helpers import make_breakpoint_network, make_network +from tests.network_helpers import make_breakpoint_network, make_network, node_series @pytest.fixture @@ -456,19 +456,6 @@ def test_matching_workflow_multiple_nodes(self, sample_network, sample_node_data assert comparer.n_points > 0 -def node_series(network): - """Each node's own series, keyed by node id, read off the network's reaches. - - The three nodes of `sample_network` carry three different series, so a - comparer built from one of them cannot be satisfied by any of the others. - """ - nodes = {} - for reach in network.reaches.values(): - for node in (reach.start, reach.end): - nodes[node.id] = node.data["WaterLevel"] - return pd.DataFrame(nodes) - - class TestValuesReachTheComparer: """The series a comparer holds is the one the network keeps at that location. From 77545a1839a11f2a338db96a99e9cd1b13a8402f Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 16:44:54 +0200 Subject: [PATCH 042/117] Assert the network values survive item selection and the file path The res1d values are checked against mikeio1d's own read of the file, which does not go through the Network layer the model result is built on. Co-Authored-By: Claude Opus 5 (1M context) --- tests/network_helpers.py | 6 ++-- tests/test_network.py | 74 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 75 insertions(+), 5 deletions(-) diff --git a/tests/network_helpers.py b/tests/network_helpers.py index 43d738a42..1c4f6a0a0 100644 --- a/tests/network_helpers.py +++ b/tests/network_helpers.py @@ -52,8 +52,8 @@ def make_breakpoint_network(reach_id, distance, data): return Network([reach]) -def node_series(network): - """Each node's own series, keyed by node id, read off the network's reaches. +def node_series(network, quantity="WaterLevel"): + """Each node's own series for `quantity`, keyed by node id, read off the reaches. The three nodes of `sample_network` carry three different series, so a comparer built from one of them cannot be satisfied by any of the others. @@ -61,5 +61,5 @@ def node_series(network): nodes = {} for reach in network.reaches.values(): for node in (reach.start, reach.end): - nodes[node.id] = node.data["WaterLevel"] + nodes[node.id] = node.data[quantity] return pd.DataFrame(nodes) diff --git a/tests/test_network.py b/tests/test_network.py index 7578af456..3a30cfc70 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -9,6 +9,7 @@ import pandas as pd import xarray as xr import numpy as np +import mikeio1d import modelskill as ms from mikeio1d.network import Network, BasicNode, BasicReach from modelskill import ( @@ -460,8 +461,8 @@ class TestValuesReachTheComparer: """The series a comparer holds is the one the network keeps at that location. The observation is built from the model's own data, so an exact match is the - expected outcome and any mix-up between locations or models shows up as a - non-zero score. + expected outcome and any mix-up between locations, quantities or models shows + up as a non-zero score. """ def test_extract_returns_the_nodes_own_series(self, sample_network): @@ -547,6 +548,75 @@ def test_a_matched_reach_scores_zero_against_its_breakpoints_series( assert cmp.n_points == len(values) assert cmp.score()["Network_Model"] == pytest.approx(0.0) + def test_the_selected_item_brings_its_own_values(self, sample_network_multivars): + """Discharge is ten times WaterLevel here, so the selected column cannot + pass for the one left behind.""" + discharge = node_series(sample_network_multivars, "Discharge") + nmr = NetworkModelResult( + sample_network_multivars, item="Discharge", name="Network_Model" + ) + obs = NodeObservation(discharge, at="123", item="123") + + extracted = nmr.extract(obs) + + assert extracted.to_dataframe()["Network_Model"].to_numpy() == pytest.approx( + discharge["123"].to_numpy() + ) + + def test_a_matched_item_scores_zero_against_its_own_series( + self, sample_network_multivars + ): + discharge = node_series(sample_network_multivars, "Discharge") + nmr = NetworkModelResult( + sample_network_multivars, item="Discharge", name="Network_Model" + ) + obs = NodeObservation(discharge, at="123", item="123", name="Node_123_Obs") + + cmp = ms.match(obs, nmr) + + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + def test_an_aux_item_brings_its_own_values(self, sample_network_multivars): + """The aux item rides alongside the scored one, and holds its own series.""" + water_level = node_series(sample_network_multivars) + discharge = node_series(sample_network_multivars, "Discharge") + nmr = NetworkModelResult( + sample_network_multivars, + item="WaterLevel", + aux_items=["Discharge"], + name="Network_Model", + ) + obs = NodeObservation(water_level, at="123", item="123", name="Node_123_Obs") + + cmp = ms.match(obs, nmr) + + assert cmp.data["Discharge"].attrs["kind"] == "aux" + assert cmp.data["Discharge"].to_numpy() == pytest.approx( + discharge["123"].to_numpy() + ) + assert cmp.score()["Network_Model"] == pytest.approx(0.0) + + +@pytest.mark.skipif( + sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" +) +def test_a_model_result_built_from_a_file_carries_the_files_own_values(): + """Checked against mikeio1d's own read of the file. + + That read goes straight to the result file, not through the Network the + model result is built on, so the two agreeing pins the whole way in. + """ + path = "./tests/testdata/network.res1d" + expected = mikeio1d.open(path).nodes.read()["WaterLevel:1"] + mr = NetworkModelResult(path, item="WaterLevel", name="Network_Model") + obs = NodeObservation(expected, at="1", name="Node_1_Obs") + + extracted = mr.extract(obs) + + assert extracted.to_dataframe()["Network_Model"].to_numpy() == pytest.approx( + expected.to_numpy() + ) + @pytest.mark.skipif( sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" From 5f4d83872e5c9300b6378b5d8adc1f4b57a457e3 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Fri, 4 Sep 2026 17:27:37 +0200 Subject: [PATCH 043/117] Remove NetworkModelResult.nodes It published the integers to_dataset() hands out, which ADR-013 says users should not handle: the numbering belongs to one network built by one mikeio1d version, which is why at= went and node_index is provenance nothing reads back. It was also the only member of this class that could not be answered without building the dense (time, node) x quantity rectangle. Ryan's review asks for a lazy source later (mikeio1d #250), and everything else here already allows it: matching uses only name and extract(obs). Removing this now keeps the eager rectangle an implementation choice rather than something 1.4.0 promises. Nothing in src/ or the docs read it. Topology questions belong to mr.network, which is mikeio1d's. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/network.py | 6 ------ tests/test_network.py | 3 +-- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 436c73019..97c2d05ee 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, Any, Sequence import numpy as np -import numpy.typing as npt import pandas as pd import xarray as xr @@ -251,11 +250,6 @@ def time(self) -> pd.DatetimeIndex: """Return the time coordinate as a pandas.DatetimeIndex.""" return pd.DatetimeIndex(self.data.time.to_index()) - @property - def nodes(self) -> npt.NDArray[np.intp]: - """Return the node IDs as a numpy array of integers.""" - return self.data.node.values - def extract( self, observation: NodeObservation | ReachObservation, diff --git a/tests/test_network.py b/tests/test_network.py index 3a30cfc70..ba05934be 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -89,7 +89,6 @@ def test_init_with_network(self, sample_network): assert len(nmr.time) == 10 assert isinstance(nmr.time, pd.DatetimeIndex) - assert len(nmr.nodes) == 3 def test_quantity_name_survives_to_the_model_result(self, sample_network): """The network knows its quantity by name even without a unit.""" @@ -625,7 +624,7 @@ def test_a_model_result_can_be_built_from_a_result_file(): mr = NetworkModelResult("./tests/testdata/network.res1d", item="WaterLevel") assert mr.quantity.name == "WaterLevel" - assert len(mr.nodes) > 0 + assert len(mr.time) > 0 @pytest.mark.skipif( From 95e9ce77a32b0185b65ec35e6c49e72f842a3bae Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Mon, 21 Sep 2026 10:50:54 +0200 Subject: [PATCH 044/117] Remove the MIKE+ station lookup The lookup reads a MIKE+ sqlite database to place measured timeseries in the network. It is not part of the mikeio1d move this branch is about, and six things about it are unsettled: no fixture written by MIKE+, the locationtype codes 8/9/12 taken on faith, an undocumented ';' encoding in resitemname, a Windows path matched on basename alone, nine columns validated against one layout, and a display name that depends on what else is in the database. from_multiple(db=...) is public API, so its shape would ship with 1.4.0 by association with a change that has nothing to do with it. Both from_multiple methods go back to two conventions and to quantity: Quantity | None. Extracted to branch mikeplus-station-lookup. See #706. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/obs.py | 540 +-------------------------------------- tests/test_mikeplus.py | 558 ----------------------------------------- 2 files changed, 12 insertions(+), 1086 deletions(-) delete mode 100644 tests/test_mikeplus.py diff --git a/src/modelskill/obs.py b/src/modelskill/obs.py index d5f492286..8fe906c02 100644 --- a/src/modelskill/obs.py +++ b/src/modelskill/obs.py @@ -14,14 +14,9 @@ from __future__ import annotations -import sqlite3 -from pathlib import Path from typing import ( Any, - Iterable, Literal, - NamedTuple, - Sequence, Union, overload, ) @@ -130,379 +125,6 @@ def _guess_gtype(**kwargs) -> GeometryType: return GeometryType.POINT -def _item_names(data: Any) -> list[str]: - """Names of the individual timeseries held by an already-opened data source.""" - if isinstance(data, pd.DataFrame): - return [str(c) for c in data.columns] - if isinstance(data, xr.Dataset): - return [str(v) for v in data.data_vars] - if hasattr(data, "names"): # mikeio.Dataset - return [str(n) for n in data.names] - if hasattr(data, "name"): # pd.Series, mikeio.DataArray, xr.DataArray - return [str(data.name)] - raise ValueError( - f"Cannot determine item names from data of type {type(data).__name__}" - ) - - -class _Station(NamedTuple): - """One measured timeseries, resolved to the network location it belongs to.""" - - item_name: str #: name of the item in the data source - name: str #: display name for the observation - location: str | tuple[str, float] #: node name, or (reach, chainage) - kind: Literal["node", "reach"] #: which observation class fits - quantity: str #: modelled quantity name - - -class _MikePlusStationResolver: - """Resolves data source items to network locations, via a MIKE+ database. - - A MIKE+ project ships a sqlite database alongside its result files. Two of - its tables say where the measured timeseries belong in the network: - - * ``m_Measurement`` - one row per measured timeseries, naming the file - (``tsfilename``) and the item within it (``tsitemname``), plus the - modelled quantity (``resitemname``). - * ``m_Station`` - the location, as ``locationid`` plus a ``locationtype`` - saying whether that identifier names a node or a link. - - Everything MIKE+ specific is contained here - the table names, the join, the - ``locationtype`` codes, the encoding of ``resitemname`` - so a change to the - database layout is a change to this class alone. Callers see only - :class:`_Station`. - """ - - _TABLES: dict[str, set[str]] = { - "m_Station": { - "muid", - "locationid", - "locationtype", - "chainagevalue", - "assetname", - }, - "m_Measurement": { - "measurementstationid", - "tsfilename", - "tsitemname", - "resitemname", - }, - } - - # m_Station.locationtype codes. 8 is a junction and 12 a tank or reservoir; - # both are graph nodes. 9 is a link, which becomes a breakpoint when the - # station carries a chainage and a whole reach when it does not. A station - # with any other code is not a place in the network, so it is left out - # rather than guessed at, and reported when it was what the caller asked - # for. - _NODE_TYPES = frozenset({8, 12}) - _LINK_TYPES = frozenset({9}) - - _QUERY = """ - SELECT m.tsitemname AS item_name, - m.tsfilename AS tsfilename, - m.resitemname AS resitemname, - s.assetname AS assetname, - s.locationid AS locationid, - s.locationtype AS locationtype, - s.chainagevalue AS chainagevalue - FROM m_Measurement m - JOIN m_Station s ON s.muid = m.measurementstationid - """ - - def __init__( - self, - db: str | Path | sqlite3.Connection, - *, - source: str | None = None, - ) -> None: - """Read the join, and the station names needed to explain a failure. - - ``db`` is a path or an already-open connection; an open one is left open. - ``source`` restricts the measurements to one result file, matched on file - name alone, so a full path is fine. Without it, measurements from every file - are considered and an item registered against two of them raises. - """ - self._source = source - - if isinstance(db, sqlite3.Connection): - conn, opened = db, None - else: - conn = opened = sqlite3.connect(str(db)) - try: - self._validate(conn) - - rows = pd.read_sql_query(self._QUERY, conn) - - # Read the station names now rather than on demand: the only other - # use is naming stations that carry no measurement, on the failure - # path, and reading them here is what lets the connection close. - self._assets = set( - pd.read_sql_query("SELECT assetname FROM m_Station", conn)["assetname"] - .dropna() - .tolist() - ) - finally: - if opened is not None: - opened.close() - - if source is not None: - wanted = self._file_name(source).casefold() - names = rows["tsfilename"].fillna("").map(self._file_name) - rows = rows[names.str.casefold() == wanted] - - rows["quantity"] = rows["resitemname"].str.split(";").str[0].str.strip() - self._rows = rows - - def resolve( - self, - item_names: Iterable[str], - *, - quantity: str | None = None, - kind: Literal["node", "reach"] | None = None, - on_missing: Literal["raise", "skip"] = "raise", - ) -> list[_Station]: - """Resolve item names, e.g. the columns of a dfs0, to their locations. - - ``quantity`` selects one of several measured quantities; left None it is - inferred, and raises when the selection holds more than one. ``kind`` - restricts the result to nodes or to reaches. ``on_missing="skip"`` drops - items the database does not register, which otherwise raise. Stations the - database does not place in the network are always left out. - """ - requested = list(dict.fromkeys(item_names)) - rows = self._rows[self._rows["item_name"].isin(requested)].copy() - - missing = [item for item in requested if item not in set(rows["item_name"])] - if missing and on_missing == "raise": - raise ValueError( - f"{len(missing)} of {len(requested)} items could not be resolved " - f"against the MIKE+ database.\n" - + self._unresolved_message(missing) - + '\n Pass on_missing="skip" to ignore these.' - ) - - if ambiguous := sorted( - rows.loc[rows.duplicated("item_name", keep=False), "item_name"].unique() - ): - raise ValueError( - f"Item(s) {ambiguous} are registered against more than one file. " - "Pass 'source' to say which file the data comes from." - ) - - if rows.empty: - raise ValueError("No items could be resolved against the MIKE+ database.") - - located = rows.apply(self._location, axis=1) - rows["kind"] = [k for k, _ in located] - rows["location"] = [location for _, location in located] - - if quantity is None: - placed = rows[rows["kind"].notna()] - pool = placed if kind is None else placed[placed["kind"] == kind] - available = sorted(pool["quantity"].unique()) - if len(available) == 0: - raise ValueError( - f"No {kind} locations found. Quantities present: " - f"{rows['quantity'].value_counts().to_dict()}." - + self._unsupported_message(rows) - ) - if len(available) > 1: - raise ValueError( - "Several quantities present, so 'quantity' cannot be inferred: " - f"{pool['quantity'].value_counts().to_dict()}. " - f"Pass one of {available}." - ) - quantity = available[0] - - selection = rows[rows["quantity"] == quantity] - if selection.empty: - raise ValueError( - f"Quantity {quantity!r} not found. Available: " - f"{rows['quantity'].value_counts().to_dict()}." - ) - - if kind is not None: - of_kind = selection[selection["kind"] == kind] - if of_kind.empty: - other = sorted(selection["kind"].dropna().unique()) - if not other: - raise ValueError( - f"No {quantity!r} station could be placed in the network." - + self._unsupported_message(selection) - ) - raise ValueError( - f"All {len(selection)} {quantity!r} station(s) are of kind " - f"{other}, not {kind!r}." + self._unsupported_message(selection) - ) - selection = of_kind - - selection = selection[selection["kind"].notna()] - if selection.empty: - raise ValueError( - f"No {quantity!r} station could be placed in the network." - + self._unsupported_message(rows) - ) - - names = self._display_names(selection) - return [ - _Station( - item_name=str(row.item_name), - name=str(name), - location=row.location, - kind=row.kind, - quantity=str(row.quantity), - ) - for name, row in zip(names, selection.itertuples()) - ] - - def _validate(self, conn: sqlite3.Connection) -> None: - tables = { - row[0] - for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'") - } - if missing := sorted(set(self._TABLES) - tables): - raise ValueError( - f"Database is missing table(s) {missing}. " - "A MIKE+ database with 'm_Station' and 'm_Measurement' is required." - ) - for table, required in self._TABLES.items(): - columns = {row[1] for row in conn.execute(f"PRAGMA table_info([{table}])")} - if missing_cols := sorted(required - columns): - raise ValueError( - f"Table '{table}' is missing column(s) {missing_cols}. " - "The database layout is not the one modelskill expects." - ) - - def _location( - self, row: pd.Series - ) -> tuple[str | None, str | tuple[str, float] | None]: - """The kind and location of one station, or (None, None) if it is neither.""" - # A link station with a chainage names a point along a reach, which is a - # node observation at a breakpoint. Without a chainage it names the reach - # as a whole. - try: - location_type = int(row["locationtype"]) - except (TypeError, ValueError): - location_type = -1 - - location_id = str(row["locationid"]) - if location_type in self._NODE_TYPES: - return "node", location_id - if location_type in self._LINK_TYPES: - chainage = row["chainagevalue"] - if pd.isna(chainage): - return "reach", location_id - return "node", (location_id, float(chainage)) - - return None, None - - def _unsupported_message(self, rows: pd.DataFrame) -> str: - """Names the stations of ``rows`` that are not places in the network.""" - unsupported = rows[rows["kind"].isna()] - if unsupported.empty: - return "" - - listed = ", ".join( - f"'{row.locationid}' ({row.locationtype!r})" - for row in unsupported.itertuples() - ) - return ( - " Station(s) with an unsupported locationtype were left out: " - f"{listed}. Known codes are " - f"{sorted(self._NODE_TYPES | self._LINK_TYPES)}." - ) - - def _unresolved_message(self, missing: Sequence[str]) -> str: - known = [item for item in missing if item in self._assets] - unknown = [item for item in missing if item not in self._assets] - - lines = [] - if known: - where = f" for '{self._file_name(self._source)}'" if self._source else "" - lines.append( - f" Known station, no measurement registered{where} ({len(known)}):\n" - + "\n".join(f" {item}" for item in known) - ) - if unknown: - lines.append( - f" Not found in the database ({len(unknown)}):\n" - + "\n".join(f" {item}" for item in unknown) - ) - return "\n".join(lines) - - @staticmethod - def _file_name(path: object) -> str: - """The file name in a path, whose separator is Windows' in the database.""" - return str(path).replace("\\", "/").rsplit("/", 1)[-1] - - @staticmethod - def _display_names(selection: pd.DataFrame) -> pd.Series: - # assetname is far shorter than the raw item name and is normally unique, - # but it is only safe as a display name when it distinguishes every row. - assets = selection["assetname"] - if assets.notna().all() and assets.nunique() == len(selection): - return assets.astype(str) - return selection["item_name"].astype(str) - - -def _observations_from_mikeplus( - cls: type, - *, - data: PointType, - db: Any, - kind: Literal["node", "reach"], - location_arg: str, - quantity: Quantity | str | None, - source: str | None, - on_missing: Literal["raise", "skip"], - aux_items: list[int | str] | None, - attrs: dict | None, -) -> list[Any]: - """Build observations from a data source and a MIKE+ database.""" - from .timeseries._point import _open_and_name - - if source is None and isinstance(data, (str, Path)): - source = str(data) - - # Open once rather than per observation; a path would otherwise be re-read - # for every station in the database. - opened, _ = _open_and_name(data, None) - - # A Quantity is metadata and does not select: its name is the caller's own, - # not the database's. Only a string names a quantity in the database. - given_quantity = quantity if isinstance(quantity, Quantity) else None - wanted = quantity if isinstance(quantity, str) else None - - stations = _MikePlusStationResolver(db, source=source).resolve( - _item_names(opened), - quantity=wanted, - kind=kind, - on_missing=on_missing, - ) - - observations = [] - for station in stations: - obs = cls( - opened, - item=station.item_name, - name=station.name, - quantity=given_quantity, - aux_items=aux_items, - attrs=attrs, - **{location_arg: station.location}, - ) - if given_quantity is None: - # The database names the quantity; the data source knows its unit. - obs.quantity = Quantity( - name=station.quantity, - unit=obs.quantity.unit, - is_directional=obs.quantity.is_directional, - ) - observations.append(obs) - return observations - - def _validate_attrs(data_attrs: dict, attrs: dict | None) -> None: # See similar method in xarray https://github.com/pydata/xarray/blob/main/xarray/backends/api.py#L165 @@ -1026,31 +648,13 @@ def from_multiple( ) -> list[NodeObservation]: pass - @overload - @classmethod - def from_multiple( - cls, - *, - data: PointType, - db: str | Path | Any, - quantity: Quantity | str | None = None, - source: str | None = None, - on_missing: Literal["raise", "skip"] = "raise", - aux_items: list[int | str] | None = None, - attrs: dict | None = None, - ) -> list[NodeObservation]: - pass - @classmethod def from_multiple( cls, *, data: PointType | None = None, nodes: dict[NodeLocation, Any] | None = None, - db: str | Path | Any | None = None, - quantity: Quantity | str | None = None, - source: str | None = None, - on_missing: Literal["raise", "skip"] = "raise", + quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[NodeObservation]: @@ -1069,44 +673,20 @@ def from_multiple( obs = NodeObservation.from_multiple(data=df, nodes={"123": "col_a", "456": "col_b"}) - 3. **MIKE+ database** — pass a single ``data`` object together with - ``db``, and the locations are looked up in the database:: - - obs = NodeObservation.from_multiple(data="calib.dfs0", db="model.sqlite") - - One observation is created per item of ``data`` that the database - places on a node, so several sensors at the same node are all kept. - Parameters ---------- data : PointType, optional Shared data source (required when ``nodes`` values are column - selectors, and when ``db`` is given). + selectors). nodes : dict[str | tuple[str, float], PointType | str | int] Mapping of location -> data source or column selector. A location takes either of the forms accepted by ``at``: a node name, or a ``(reach_id, distance)`` breakpoint. Note that a location can appear only once, so this form cannot - express several observations at the same node. Use ``db`` when the - data has several sensors at one location. - db : str, Path or sqlite3.Connection, optional - MIKE+ database locating the items of ``data`` in the network. - Mutually exclusive with ``nodes``. - quantity : Quantity or str, optional - Physical quantity metadata, by default None. With ``db``, a string - selects which quantity to build observations for and the metadata - comes from the database; omit it and the quantity is inferred when - the data holds only one. A ``Quantity`` supplies the metadata and - does not select, so the database must hold only one quantity for - this kind of location - to do both, pass the string and set - ``obs.quantity`` on the observations afterwards. - source : str, optional - With ``db``, the file the items come from. Taken from ``data`` when - that is a path, by default None. - on_missing : {"raise", "skip"}, optional - With ``db``, what to do with items the database cannot place, by - default "raise". + express several observations at the same node. + quantity : Quantity, optional + Physical quantity metadata, by default None. aux_items : list[int | str] | None, optional Auxiliary items, by default None. attrs : dict | None, optional @@ -1120,35 +700,8 @@ def from_multiple( Raises ------ ValueError - If both ``nodes`` and ``db`` are given, if neither is, or if the - database cannot resolve the requested items. + If ``nodes`` is not given. """ - if db is not None: - if nodes is not None: - raise ValueError( - "'nodes' and 'db' are mutually exclusive: the database " - "supplies the locations." - ) - if data is None: - raise ValueError("'data' is required when 'db' is given") - return _observations_from_mikeplus( - cls, - data=data, - db=db, - kind="node", - location_arg="at", - quantity=quantity, - source=source, - on_missing=on_missing, - aux_items=aux_items, - attrs=attrs, - ) - - if isinstance(quantity, str): - raise TypeError( - "'quantity' must be a Quantity unless 'db' is given, got str" - ) - if nodes is None: raise ValueError("'nodes' argument is required") if not isinstance(nodes, dict): @@ -1285,31 +838,13 @@ def from_multiple( ) -> list[ReachObservation]: pass - @overload - @classmethod - def from_multiple( - cls, - *, - data: PointType, - db: str | Path | Any, - quantity: Quantity | str | None = None, - source: str | None = None, - on_missing: Literal["raise", "skip"] = "raise", - aux_items: list[int | str] | None = None, - attrs: dict | None = None, - ) -> list[ReachObservation]: - pass - @classmethod def from_multiple( cls, *, data: PointType | None = None, reaches: dict[str, Any] | None = None, - db: str | Path | Any | None = None, - quantity: Quantity | str | None = None, - source: str | None = None, - on_missing: Literal["raise", "skip"] = "raise", + quantity: Quantity | None = None, aux_items: list[int | str] | None = None, attrs: dict | None = None, ) -> list[ReachObservation]: @@ -1328,42 +863,18 @@ def from_multiple( obs = ReachObservation.from_multiple(data=df, reaches={"r1": "col_a", "r2": "col_b"}) - 3. **MIKE+ database** — pass a single ``data`` object together with - ``db``, and the reaches are looked up in the database:: - - obs = ReachObservation.from_multiple(data="calib.dfs0", db="model.sqlite") - - One observation is created per item of ``data`` that the database - places on a link without a chainage. - Parameters ---------- data : PointType, optional Shared data source (required when ``reaches`` values are column - selectors, and when ``db`` is given). + selectors). reaches : dict[str, PointType | str | int] Mapping of reach_id -> data source or column selector. Note that a reach can appear only once, so this form cannot express - several observations on the same reach. Use ``db`` when the data has - several sensors on one reach. - db : str, Path or sqlite3.Connection, optional - MIKE+ database locating the items of ``data`` in the network. - Mutually exclusive with ``reaches``. - quantity : Quantity or str, optional - Physical quantity metadata, by default None. With ``db``, a string - selects which quantity to build observations for and the metadata - comes from the database; omit it and the quantity is inferred when - the data holds only one. A ``Quantity`` supplies the metadata and - does not select, so the database must hold only one quantity for - this kind of location - to do both, pass the string and set - ``obs.quantity`` on the observations afterwards. - source : str, optional - With ``db``, the file the items come from. Taken from ``data`` when - that is a path, by default None. - on_missing : {"raise", "skip"}, optional - With ``db``, what to do with items the database cannot place, by - default "raise". + several observations on the same reach. + quantity : Quantity, optional + Physical quantity metadata, by default None. aux_items : list[int | str] | None, optional Auxiliary items, by default None. attrs : dict | None, optional @@ -1377,35 +888,8 @@ def from_multiple( Raises ------ ValueError - If both ``reaches`` and ``db`` are given, if neither is, or if the - database cannot resolve the requested items. + If ``reaches`` is not given. """ - if db is not None: - if reaches is not None: - raise ValueError( - "'reaches' and 'db' are mutually exclusive: the database " - "supplies the locations." - ) - if data is None: - raise ValueError("'data' is required when 'db' is given") - return _observations_from_mikeplus( - cls, - data=data, - db=db, - kind="reach", - location_arg="reach", - quantity=quantity, - source=source, - on_missing=on_missing, - aux_items=aux_items, - attrs=attrs, - ) - - if isinstance(quantity, str): - raise TypeError( - "'quantity' must be a Quantity unless 'db' is given, got str" - ) - if reaches is None: raise ValueError("'reaches' argument is required") if not isinstance(reaches, dict): diff --git a/tests/test_mikeplus.py b/tests/test_mikeplus.py deleted file mode 100644 index bce209243..000000000 --- a/tests/test_mikeplus.py +++ /dev/null @@ -1,558 +0,0 @@ -import sqlite3 - -import numpy as np -import pandas as pd -import pytest - -from modelskill import NodeObservation, Quantity, ReachObservation - -STATION_COLUMNS = [ - "muid", - "locationid", - "locationtype", - "chainagevalue", - "assetname", -] -MEASUREMENT_COLUMNS = [ - "measurementstationid", - "tsfilename", - "tsitemname", - "resitemname", -] - -JUNCTION = 8 -LINK = 9 -TANK = 12 - - -def station(muid, locationid, locationtype, assetname, chainagevalue=None): - return dict( - muid=muid, - locationid=locationid, - locationtype=locationtype, - chainagevalue=chainagevalue, - assetname=assetname, - ) - - -def measurement(station_muid, item, quantity, file="calib.dfs0"): - return dict( - measurementstationid=station_muid, - tsfilename=rf"..\Scripts\{file}", - tsitemname=item, - resitemname=f"{quantity};{quantity};100450", - ) - - -def build_db(path, stations, measurements, *, station_columns=STATION_COLUMNS): - conn = sqlite3.connect(str(path)) - pd.DataFrame(stations, columns=station_columns).to_sql( - "m_Station", conn, index=False - ) - pd.DataFrame(measurements, columns=MEASUREMENT_COLUMNS).to_sql( - "m_Measurement", conn, index=False - ) - conn.commit() - conn.close() - return str(path) - - -@pytest.fixture -def db(tmp_path): - """Two pressure sensors on nodes, one flow meter on a link.""" - stations = [ - station("s1", "wNode_1", JUNCTION, "PT.401"), - station("s2", "Tank_A", TANK, "LT.410"), - station("s3", "Pipe_7", LINK, "FT.403"), - ] - measurements = [ - measurement("s1", "item_pressure_1", "Pressure"), - measurement("s2", "item_pressure_2", "Pressure"), - measurement("s3", "item_flow_1", "Flow"), - ] - return build_db(tmp_path / "mikeplus.sqlite", stations, measurements) - - -def frame(*items): - """A data source holding one timeseries per named item.""" - time = pd.date_range("2024-01-01", periods=24, freq="h") - rng = np.random.default_rng(42) - return pd.DataFrame( - {item: rng.normal(35.0, 1.0, len(time)) for item in items}, index=time - ) - - -def test_junction_and_tank_resolve_to_nodes(db): - obs_list = NodeObservation.from_multiple( - data=frame("item_pressure_1", "item_pressure_2"), db=db, quantity="Pressure" - ) - - assert {obs.at for obs in obs_list} == {"wNode_1", "Tank_A"} - - -def test_link_without_chainage_resolves_to_a_reach(db): - (obs,) = ReachObservation.from_multiple( - data=frame("item_flow_1"), db=db, quantity="Flow" - ) - - assert obs.reach == "Pipe_7" - - -def test_link_with_chainage_resolves_to_a_breakpoint(tmp_path): - path = build_db( - tmp_path / "chainage.sqlite", - [station("s1", "Pipe_7", LINK, "FT.403", chainagevalue=24.5)], - [measurement("s1", "item_flow_1", "Flow")], - ) - - (obs,) = NodeObservation.from_multiple( - data=frame("item_flow_1"), db=path, quantity="Flow" - ) - - assert obs.at == ("Pipe_7", 24.5) - - -def test_several_items_at_one_location_all_survive(tmp_path): - path = build_db( - tmp_path / "shared.sqlite", - [ - station("s1", "wNode_1", JUNCTION, "PT.401"), - station("s2", "wNode_1", JUNCTION, "PT.402"), - ], - [ - measurement("s1", "before_valve", "Pressure"), - measurement("s2", "after_valve", "Pressure"), - ], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("before_valve", "after_valve"), db=path, quantity="Pressure" - ) - - assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] - assert {obs.at for obs in obs_list} == {"wNode_1"} - - -def test_name_falls_back_to_item_name_when_assetnames_collide(tmp_path): - path = build_db( - tmp_path / "collide.sqlite", - [ - station("s1", "wNode_1", JUNCTION, "same"), - station("s2", "wNode_2", JUNCTION, "same"), - ], - [ - measurement("s1", "item_a", "Pressure"), - measurement("s2", "item_b", "Pressure"), - ], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_a", "item_b"), db=path, quantity="Pressure" - ) - - assert [obs.name for obs in obs_list] == ["item_a", "item_b"] - - -def test_quantity_is_inferred_when_unambiguous(db): - obs_list = NodeObservation.from_multiple( - data=frame("item_pressure_1", "item_pressure_2"), db=db - ) - - assert {obs.quantity.name for obs in obs_list} == {"Pressure"} - - -def test_ambiguous_quantity_raises_and_lists_options(tmp_path): - path = build_db( - tmp_path / "two_quantities.sqlite", - [ - station("s1", "wNode_1", JUNCTION, "PT.401"), - station("s2", "wNode_2", JUNCTION, "LT.410"), - ], - [ - measurement("s1", "item_pressure", "Pressure"), - measurement("s2", "item_level", "Water Level"), - ], - ) - - with pytest.raises(ValueError, match="cannot be inferred") as excinfo: - NodeObservation.from_multiple( - data=frame("item_pressure", "item_level"), db=path - ) - - assert "Pressure" in str(excinfo.value) - assert "Water Level" in str(excinfo.value) - - -def test_the_observation_kind_narrows_the_pool_used_for_inference(db): - # The database holds pressure on two nodes and flow on a reach. Asking for - # node observations leaves only one quantity, so it needs no naming. - obs_list = NodeObservation.from_multiple( - data=frame("item_pressure_1", "item_pressure_2", "item_flow_1"), db=db - ) - - assert {obs.quantity.name for obs in obs_list} == {"Pressure"} - assert len(obs_list) == 2 - - -def test_unknown_quantity_raises(db): - with pytest.raises(ValueError, match="not found"): - NodeObservation.from_multiple( - data=frame("item_pressure_1"), db=db, quantity="Discharge" - ) - - -def test_asking_for_a_node_when_the_station_is_a_reach_raises(db): - with pytest.raises(ValueError, match="not 'node'"): - NodeObservation.from_multiple(data=frame("item_flow_1"), db=db, quantity="Flow") - - -def test_missing_items_raise_and_separate_the_two_causes(db): - with pytest.raises(ValueError) as excinfo: - NodeObservation.from_multiple( - data=frame("item_pressure_1", "PT.401", "never_heard_of_it"), - db=db, - quantity="Pressure", - ) - - message = str(excinfo.value) - assert "no measurement registered" in message - assert "PT.401" in message - assert "Not found in the database" in message - assert "never_heard_of_it" in message - - -def test_missing_items_can_be_skipped(db): - obs_list = NodeObservation.from_multiple( - data=frame("item_pressure_1", "never_heard_of_it"), - db=db, - quantity="Pressure", - on_missing="skip", - ) - - assert [obs.name for obs in obs_list] == ["PT.401"] - - -def test_source_selects_between_files(tmp_path): - path = build_db( - tmp_path / "files.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [ - measurement("s1", "item_a", "Pressure", file="main.dfs0"), - measurement("s1", "item_a", "Pressure", file="other.dfs0"), - ], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity="Pressure", source="main.dfs0" - ) - - assert len(obs_list) == 1 - - -def test_source_accepts_a_full_path(tmp_path): - path = build_db( - tmp_path / "fullpath.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [measurement("s1", "item_a", "Pressure", file="main.dfs0")], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_a"), - db=path, - quantity="Pressure", - source="/some/where/main.dfs0", - ) - - assert len(obs_list) == 1 - - -def test_source_matches_the_whole_file_name(tmp_path): - """A file name that is a substring of another must not match it as well.""" - path = build_db( - tmp_path / "substring.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [ - measurement("s1", "item_a", "Pressure", file="calib.dfs0"), - measurement("s1", "item_a", "Pressure", file="my_calib.dfs0"), - ], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity="Pressure", source="calib.dfs0" - ) - - assert len(obs_list) == 1 - - -def test_an_underscore_in_the_source_is_not_a_wildcard(tmp_path): - path = build_db( - tmp_path / "wildcard.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [measurement("s1", "item_a", "Pressure", file="calibX1.dfs0")], - ) - - with pytest.raises(ValueError, match="could not be resolved"): - NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity="Pressure", source="calib_1.dfs0" - ) - - -def test_item_registered_against_several_files_raises_without_source(tmp_path): - path = build_db( - tmp_path / "ambiguous.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [ - measurement("s1", "item_a", "Pressure", file="main.dfs0"), - measurement("s1", "item_a", "Pressure", file="other.dfs0"), - ], - ) - - with pytest.raises(ValueError, match="more than one file"): - NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity="Pressure" - ) - - -def test_a_station_that_is_no_place_in_the_network_is_left_out(tmp_path): - """A rain gauge registered in the same file must not fail the whole resolve.""" - path = build_db( - tmp_path / "gauge.sqlite", - [ - station("s1", "wNode_1", JUNCTION, "PT.401"), - station("s2", "Catch_1", 1, "RG.1"), - ], - [ - measurement("s1", "item_pressure", "Pressure"), - measurement("s2", "item_rain", "Rainfall"), - ], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_pressure", "item_rain"), db=path, quantity="Pressure" - ) - - assert [obs.name for obs in obs_list] == ["PT.401"] - - -def test_asking_for_a_quantity_only_an_unplaceable_station_carries_raises(tmp_path): - path = build_db( - tmp_path / "gauge_only.sqlite", - [station("s2", "Catch_1", 1, "RG.1")], - [measurement("s2", "item_rain", "Rainfall")], - ) - - with pytest.raises(ValueError, match="unsupported locationtype"): - NodeObservation.from_multiple( - data=frame("item_rain"), db=path, quantity="Rainfall" - ) - - -def test_unknown_locationtype_raises(tmp_path): - path = build_db( - tmp_path / "weird.sqlite", - [station("s1", "wNode_1", 99, "PT.401")], - [measurement("s1", "item_a", "Pressure")], - ) - - with pytest.raises(ValueError, match="unsupported locationtype"): - NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity="Pressure" - ) - - -def test_accepts_an_open_connection(db): - conn = sqlite3.connect(db) - try: - (obs,) = ReachObservation.from_multiple( - data=frame("item_flow_1"), db=conn, quantity="Flow" - ) - finally: - conn.close() - - assert obs.reach == "Pipe_7" - - -def test_missing_table_raises(tmp_path): - path = str(tmp_path / "empty.sqlite") - conn = sqlite3.connect(path) - pd.DataFrame({"a": [1]}).to_sql("something_else", conn, index=False) - conn.close() - - with pytest.raises(ValueError, match="missing table"): - NodeObservation.from_multiple(data=frame("item_a"), db=path) - - -def test_missing_column_raises(tmp_path): - path = build_db( - tmp_path / "thin.sqlite", - [ - dict(muid="s1", locationid="wNode_1", locationtype=JUNCTION, assetname="a"), - ], - [measurement("s1", "item_a", "Pressure")], - station_columns=["muid", "locationid", "locationtype", "assetname"], - ) - - with pytest.raises(ValueError, match="missing column"): - NodeObservation.from_multiple(data=frame("item_a"), db=path) - - -@pytest.fixture -def calibration_data(): - """A data source holding both pressure and flow items.""" - time = pd.date_range("2024-01-01", periods=24, freq="h") - rng = np.random.default_rng(42) - return pd.DataFrame( - { - "item_pressure_1": rng.normal(35.0, 1.0, len(time)), - "item_pressure_2": rng.normal(36.0, 1.0, len(time)), - "item_flow_1": rng.normal(120.0, 5.0, len(time)), - }, - index=time, - ) - - -class TestNodeObservationFromDatabase: - def test_builds_one_observation_per_item(self, db, calibration_data): - obs_list = NodeObservation.from_multiple( - data=calibration_data, db=db, quantity="Pressure" - ) - - assert len(obs_list) == 2 - assert all(isinstance(obs, NodeObservation) for obs in obs_list) - assert [obs.at for obs in obs_list] == ["wNode_1", "Tank_A"] - - def test_names_come_from_the_database(self, db, calibration_data): - obs_list = NodeObservation.from_multiple( - data=calibration_data, db=db, quantity="Pressure" - ) - - assert [obs.name for obs in obs_list] == ["PT.401", "LT.410"] - - def test_quantity_comes_from_the_database(self, db, calibration_data): - obs_list = NodeObservation.from_multiple( - data=calibration_data, db=db, quantity="Pressure" - ) - - assert all(obs.quantity.name == "Pressure" for obs in obs_list) - - def test_data_is_selected_per_item(self, db, calibration_data): - obs_list = NodeObservation.from_multiple( - data=calibration_data, db=db, quantity="Pressure" - ) - - expected = calibration_data["item_pressure_1"].to_numpy() - assert obs_list[0].values == pytest.approx(expected) - - def test_quantity_is_inferred_when_only_nodes_are_wanted( - self, db, calibration_data - ): - obs_list = NodeObservation.from_multiple(data=calibration_data, db=db) - - assert len(obs_list) == 2 - assert all(obs.quantity.name == "Pressure" for obs in obs_list) - - def test_several_sensors_at_one_node_are_all_kept(self, tmp_path): - path = build_db( - tmp_path / "shared.sqlite", - [ - station("s1", "wNode_1", JUNCTION, "PT.401"), - station("s2", "wNode_1", JUNCTION, "PT.402"), - ], - [ - measurement("s1", "before_valve", "Pressure"), - measurement("s2", "after_valve", "Pressure"), - ], - ) - time = pd.date_range("2024-01-01", periods=5, freq="h") - data = pd.DataFrame( - {"before_valve": range(5), "after_valve": range(5, 10)}, index=time - ) - - obs_list = NodeObservation.from_multiple(data=data, db=path) - - assert [obs.at for obs in obs_list] == ["wNode_1", "wNode_1"] - assert [obs.name for obs in obs_list] == ["PT.401", "PT.402"] - - def test_flow_on_a_link_points_at_reach_observation(self, db, calibration_data): - with pytest.raises(ValueError, match="not 'node'"): - NodeObservation.from_multiple(data=calibration_data, db=db, quantity="Flow") - - def test_unresolvable_item_raises(self, db, calibration_data): - data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) - - with pytest.raises(ValueError, match="could not be resolved"): - NodeObservation.from_multiple(data=data, db=db, quantity="Pressure") - - def test_unresolvable_item_can_be_skipped(self, db, calibration_data): - data = calibration_data.rename(columns={"item_pressure_1": "mystery_sensor"}) - - obs_list = NodeObservation.from_multiple( - data=data, db=db, quantity="Pressure", on_missing="skip" - ) - - assert [obs.name for obs in obs_list] == ["LT.410"] - - def test_db_and_nodes_are_mutually_exclusive(self, db, calibration_data): - with pytest.raises(ValueError, match="mutually exclusive"): - NodeObservation.from_multiple( - data=calibration_data, db=db, nodes={"wNode_1": "item_pressure_1"} - ) - - def test_db_without_data_raises(self, db): - with pytest.raises(ValueError, match="'data' is required"): - NodeObservation.from_multiple(db=db) - - def test_a_quantity_object_supplies_metadata_and_does_not_select(self, tmp_path): - """A Quantity's name is the caller's own, not a name in the database.""" - path = build_db( - tmp_path / "metadata.sqlite", - [station("s1", "wNode_1", JUNCTION, "PT.401")], - [measurement("s1", "item_a", "Pressure")], - ) - - obs_list = NodeObservation.from_multiple( - data=frame("item_a"), db=path, quantity=Quantity("Pressure_m", "m") - ) - - assert [obs.quantity.name for obs in obs_list] == ["Pressure_m"] - assert [obs.quantity.unit for obs in obs_list] == ["m"] - - def test_quantity_string_without_db_raises(self, calibration_data): - with pytest.raises(TypeError, match="must be a Quantity"): - NodeObservation.from_multiple( - data=calibration_data, - nodes={"wNode_1": "item_pressure_1"}, - quantity="Pressure", - ) - - -class TestReachObservationFromDatabase: - def test_builds_reach_observations(self, db, calibration_data): - obs_list = ReachObservation.from_multiple( - data=calibration_data, db=db, quantity="Flow" - ) - - assert len(obs_list) == 1 - assert isinstance(obs_list[0], ReachObservation) - assert obs_list[0].reach == "Pipe_7" - assert obs_list[0].name == "FT.403" - assert obs_list[0].quantity.name == "Flow" - - def test_quantity_is_inferred_when_only_reaches_are_wanted( - self, db, calibration_data - ): - obs_list = ReachObservation.from_multiple(data=calibration_data, db=db) - - assert [obs.reach for obs in obs_list] == ["Pipe_7"] - - def test_pressure_on_a_node_points_at_node_observation(self, db, calibration_data): - with pytest.raises(ValueError, match="not 'reach'"): - ReachObservation.from_multiple( - data=calibration_data, db=db, quantity="Pressure" - ) - - def test_db_and_reaches_are_mutually_exclusive(self, db, calibration_data): - with pytest.raises(ValueError, match="mutually exclusive"): - ReachObservation.from_multiple( - data=calibration_data, db=db, reaches={"r1": "item_flow_1"} - ) From ebcede066d1882e8d3511e5a4b7310114fa48de9 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Mon, 21 Sep 2026 10:51:18 +0200 Subject: [PATCH 045/117] Drop the MIKE+ section from the network guide It documents from_multiple(db=...), which the previous commit removed. Co-Authored-By: Claude Opus 5 (1M context) --- docs/user-guide/network.qmd | 40 ------------------------------------- 1 file changed, 40 deletions(-) diff --git a/docs/user-guide/network.qmd b/docs/user-guide/network.qmd index 751a3eafa..5130778ac 100644 --- a/docs/user-guide/network.qmd +++ b/docs/user-guide/network.qmd @@ -146,46 +146,6 @@ cc_q.skill() Use `ReachObservation` when your measured quantity is representative of the whole reach (e.g. discharge, which is constant along a reach in steady flow). If you need to compare a quantity that varies spatially along the reach (e.g. water level at a specific chainage), use a `NodeObservation` with a `(reach, distance)` tuple instead (see [Option B](#option-b-breakpoint-by-reach-distance-tuple) above). ::: -## Locating observations with a MIKE+ database - -The examples above assume you already know where each sensor sits in the network. A MIKE+ project normally records that itself, in the sqlite database shipped alongside the result files: `m_Measurement` says which file and item each measured timeseries lives in, and `m_Station` says where in the network it belongs. - -Pass that database as `db` and modelskill does the lookup for you: - -```python -quantity = "Pressure" - -network = Network.open("model.res", quantities=quantity) -network_model = ms.NetworkModelResult(network, item=quantity) - -obs = ms.NodeObservation.from_multiple( - data="calibration.dfs0", - db="model.sqlite", - quantity=quantity, -) - -cc = ms.match(obs, network_model) -``` - -One observation is created per item of the data source, named after the station's asset name. Because the mapping runs item by item rather than location by location, several sensors at the same node — a pair either side of a check valve, say — all become separate observations. - -Reach-uniform quantities work the same way through the sibling method: - -```python -obs_q = ms.ReachObservation.from_multiple( - data="calibration.dfs0", db="model.sqlite", quantity="Flow" -) -``` - -Which class to use is decided by the database, not by you: stations recorded on a junction or a tank are node observations, and stations recorded on a link are reach observations. Asking `NodeObservation` for a quantity that the database places on links raises an error naming `ReachObservation`, and the other way around. - -A few details worth knowing: - -* **`quantity` is optional.** Omit it and the quantity is inferred, as long as the data holds only one for the class you asked for. A calibration file mixing pressure and flow raises an error listing what it found. -* **The quantity name comes from the database, the unit from the data.** Calibration files often carry no usable EUM information, so the database is the only reliable source for the name. -* **`source` picks between files.** It defaults to `data` when that is a path. Pass it explicitly if you hand over an already-read `mikeio.Dataset` or a `DataFrame`, since neither remembers where it came from. -* **Items the database cannot place raise by default**, separating the two causes: a station that exists but has no measurement registered for this file, and an item that is not in the database at all. Pass `on_missing="skip"` to build observations from the rest. - ## See also * [API reference — NetworkModelResult](../api/NetworkModelResult.qmd) From 57f519934da28699dff8cca7800f784f76a333c4 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Mon, 21 Sep 2026 10:51:26 +0200 Subject: [PATCH 046/117] Take the MIKE+ station resolver off ADR-013's ownership table The table says who owns what after the move. modelskill no longer holds the resolver on this branch. Co-Authored-By: Claude Opus 5 (1M context) --- adr/013-network-topology-in-mikeio1d.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/adr/013-network-topology-in-mikeio1d.md b/adr/013-network-topology-in-mikeio1d.md index a6ea74b5f..8968fe06a 100644 --- a/adr/013-network-topology-in-mikeio1d.md +++ b/adr/013-network-topology-in-mikeio1d.md @@ -21,7 +21,7 @@ mikeio1d gains an optional network module that builds and owns `Network`. models | Owner | Pieces | |---|---| | mikeio1d | abstract types and `BasicNode`/`BasicReach`, the `Res1D` adapter, `Network.open`, the `.resx` and `.inp` companions, the extension policy tables, graph construction with its length and boundary semantics, the alias map, `find`, `recall`, `to_dataframe`, `to_dataset` | -| modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching, the MIKE+ station resolver | +| modelskill | `NetworkModelResult`, `NodeModelResult`, `NodeObservation`, `ReachObservation`, matching | `NetworkModelResult` takes a `Network` the upstream module built, or a path it hands to that module. The module is an extra there, carrying networkx and xarray, so `to_dataset()` ships with the class. modelskill's `network` extra requires a mikeio1d release new enough to contain it. From eae79e0c9fd151835d3832d976775f004be954c6 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Mon, 21 Sep 2026 15:00:34 +0200 Subject: [PATCH 047/117] Read the network quantity off the attributes directly Quantity.from_cf_attrs needs a long_name and a units, and reports neither without both. mikeio1d's to_dataset writes the name only, so the call could never return anything but Quantity.undefined() and the fallback beside it always fired. One read of the two attributes replaces both. A unit is used if one ever travels with the data. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/network.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 97c2d05ee..5c57547ac 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -224,14 +224,16 @@ def __init__( self.sel_items = sel_items if quantity is None: - da = self.data[sel_items.values] - quantity = Quantity.from_cf_attrs(da.attrs) - if quantity == Quantity.undefined(): - # A result file names its quantity but carries no unit, and - # Quantity.from_cf_attrs needs both. Fall back to the name alone - # rather than reporting nothing at all. - name = da.attrs.get("long_name") or str(sel_items.values) - quantity = Quantity(name=name, unit="") + # Read straight off the attributes rather than through + # Quantity.from_cf_attrs, which needs a unit as well as a name and + # reports neither without both: a result file names its quantity and + # carries no unit for it, so that would report nothing at all. A unit + # is still used if one ever travels with the data. + attrs = self.data[sel_items.values].attrs + quantity = Quantity( + name=attrs.get("long_name") or str(sel_items.values), + unit=attrs.get("units", ""), + ) self.quantity = quantity # Mark data variables as model data From 4a8a14ce8e5717f3239d7833587601a3a8d20950 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 10:12:42 +0200 Subject: [PATCH 048/117] pin mikeio1d to alpha release --- pyproject.toml | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index e33d442ed..fb31252f0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -64,12 +64,7 @@ test = [ notebooks = ["nbformat", "nbconvert", "jupyter", "plotly", "shapely", "seaborn"] -network = ["mikeio1d[network]"] - -[tool.uv.sources] -# TODO: swap for a version floor in both "network" entries above once mikeio1d -# releases the network module. ADR-013 holds modelskill 1.4.0 until it does. -mikeio1d = { git = "https://github.com/DHI/mikeio1d", branch = "main" } +network = ["mikeio1d[network]==1.3.2a1"] [project.urls] "Homepage" = "https://github.com/DHI/modelskill" From fb885bab02aa0240ec70725f35884e34e7f00c2c Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 10:39:06 +0200 Subject: [PATCH 049/117] pin mikeio1d to alpha release --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index fb31252f0..c9efd8164 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -45,7 +45,7 @@ classifiers = [ [project.optional-dependencies] # networkx and xarray arrive through mikeio1d's own network extra, which # carries the topology layer this package builds on (ADR-013). -network = ["mikeio1d[network]"] +network = ["mikeio1d[network]==1.3.2a1"] [dependency-groups] dev = ["pytest", "plotly >= 4.5", "ruff==0.6.2", "netCDF4", "dask"] From 9e885c3c06b85e7f39aad5af3bb35207b2412a7f Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 11:05:59 +0200 Subject: [PATCH 050/117] Run the file-backed network tests on 3.14 The six guards were written on 2026-03-25, when pythonnet had no 3.14 wheel. pythonnet 3.1.0, published two months later, ships cp310.cp311.cp312.cp313.cp314. mikeio1d 1.3.2a1 reads tests/testdata/network.res1d on 3.14.5. The ceiling moves to 3.15 rather than going away: pythonnet's wheel tag stops at cp314, and mikeio1d declares requires-python >=3.12,<3.15. full_test.yml runs a 3.14 leg, and these six are the only tests that open a real res1d, so that half of the matrix was skipping the file-reading path entirely. Co-Authored-By: Claude Opus 5 (1M context) --- tests/test_network.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/test_network.py b/tests/test_network.py index ba05934be..4e9223bad 100644 --- a/tests/test_network.py +++ b/tests/test_network.py @@ -597,7 +597,7 @@ def test_an_aux_item_brings_its_own_values(self, sample_network_multivars): @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_a_model_result_built_from_a_file_carries_the_files_own_values(): """Checked against mikeio1d's own read of the file. @@ -618,7 +618,7 @@ def test_a_model_result_built_from_a_file_carries_the_files_own_values(): @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_a_model_result_can_be_built_from_a_result_file(): mr = NetworkModelResult("./tests/testdata/network.res1d", item="WaterLevel") @@ -628,7 +628,7 @@ def test_a_model_result_can_be_built_from_a_result_file(): @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_extract_reach_observation_happy_path(sample_node_data): path_to_file = "./tests/testdata/network.res1d" @@ -645,7 +645,7 @@ def test_extract_reach_observation_happy_path(sample_node_data): @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_extract_reach_observation_non_equivalent_breakpoints_raises(sample_node_data): path_to_file = "./tests/testdata/network.res1d" @@ -659,7 +659,7 @@ def test_extract_reach_observation_non_equivalent_breakpoints_raises(sample_node @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_extract_reach_observation_with_reaches_not_populated_raises_valueerror( sample_node_data, @@ -674,7 +674,7 @@ def test_extract_reach_observation_with_reaches_not_populated_raises_valueerror( @pytest.mark.skipif( - sys.version_info >= (3, 14), reason="mikeio1d requires Python < 3.14" + sys.version_info >= (3, 15), reason="mikeio1d requires Python < 3.15" ) def test_extract_breakpoint_without_data_for_the_quantity_raises_valueerror( sample_node_data, From 768179289e4593508753bc4d4bdc0a6370a809e6 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 11:07:24 +0200 Subject: [PATCH 051/117] Run the network notebook again Collection_systems_network.ipynb was skipped because pythonnet had no 3.14 wheel. pythonnet 3.1.0 ships one, and the notebook runs start to finish on 3.14.5. The skip stays for 3.15, where pythonnet has no wheel, so it becomes conditional rather than a bare entry in the list. The old comment cited Network.from_mike(), which this branch removed. The notebook is the only thing that exercises network.graph. Co-Authored-By: Claude Opus 5 (1M context) --- tests/notebooks/test_notebooks.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/notebooks/test_notebooks.py b/tests/notebooks/test_notebooks.py index 8b6fd62dc..3a7ba953f 100644 --- a/tests/notebooks/test_notebooks.py +++ b/tests/notebooks/test_notebooks.py @@ -1,5 +1,6 @@ import os import subprocess +import sys import nbformat from nbconvert.preprocessors import ExecutePreprocessor @@ -7,8 +8,11 @@ _TEST_DIR = os.path.dirname(os.path.abspath(__file__)) PARENT_DIR = os.path.join(_TEST_DIR, "../..") -SKIP_LIST = ["Download", "Metocean_track_comparison_global", "Metrics_widget", "Collection_systems_network"] -# We skip Collection_systems_network.ipynb since it uses Network.from_mike() which uses pythonnet and, currently, it does not support python 3.14 +SKIP_LIST = ["Download", "Metocean_track_comparison_global", "Metrics_widget"] +if sys.version_info >= (3, 15): + # Collection_systems_network.ipynb reads a res1d through mikeio1d, whose + # pythonnet has no 3.15 wheel. + SKIP_LIST.append("Collection_systems_network") def _process_notebook(notebook_filename, notebook_path="notebooks"): From 1107be3b899f1ef42762a576fed58ce9be9fb066 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 11:15:29 +0200 Subject: [PATCH 052/117] Build the docs on 3.14 The 3.13 pin was there because pythonnet had no 3.14 wheel. pythonnet 3.1.0 ships one, and quartodoc build plus quarto render complete on 3.14.5 with the network group installed, including user-guide/network.qmd, which opens a res1d at render time. The ceiling is now mikeio1d's own: requires-python >=3.12,<3.15. Co-Authored-By: Claude Opus 5 (1M context) --- .github/workflows/docs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index e854ab5b1..314600267 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -27,7 +27,7 @@ jobs: - name: Set up uv uses: astral-sh/setup-uv@v6 with: - python-version: "3.13" # Need to use 3.13 for docs build due to pythonnet dependency not yet supporting 3.14 + python-version: "3.14" # mikeio1d needs Python < 3.15, so the docs build cannot go higher enable-cache: true - name: Set up Quarto From 86eee4fb26e86d5ce5d00149bc3d929e25fa83cf Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 11:16:54 +0200 Subject: [PATCH 053/117] Guard the network fixtures on mikeio1d, not networkx The network and network2 fixtures called importorskip("networkx") and then imported tests/network_helpers.py, which imports mikeio1d.network at module scope. network_helpers' own docstring says to guard it with importorskip("mikeio1d.network"). networkx can be installed without mikeio1d. In that environment the fixtures raised ModuleNotFoundError as errors rather than skips: 9 errors in tests/test_match.py. The build-no-network CI job passes today only because networkx arrives through mikeio1d's network extra and is absent there too. Co-Authored-By: Claude Opus 5 (1M context) --- tests/test_match.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_match.py b/tests/test_match.py index ec0b25278..320ac92e6 100644 --- a/tests/test_match.py +++ b/tests/test_match.py @@ -336,7 +336,7 @@ def test_only_1_model_depth_overlap(self, simple_vo, simple_vm): @pytest.fixture def network(): """Network fixture with 3 nodes""" - pytest.importorskip("networkx") + pytest.importorskip("mikeio1d.network") from tests.network_helpers import make_network time = pd.date_range("2017-10-27", periods=20, freq="h") @@ -348,7 +348,7 @@ def network(): @pytest.fixture def network2(): """Second network fixture with offset data for multi-model tests""" - pytest.importorskip("networkx") + pytest.importorskip("mikeio1d.network") from tests.network_helpers import make_network time = pd.date_range("2017-10-27", periods=20, freq="h") From 4df5a6d8ee1cb55635996c3ce3bd532707d14d2a Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 13:30:44 +0200 Subject: [PATCH 054/117] Stop handing Comparer.load a name it ignores The dataset is already stamped and its variable already renamed to the model name, so both constructors skip their parse branch and drop the argument on the floor. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/comparison/_comparison.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/modelskill/comparison/_comparison.py b/src/modelskill/comparison/_comparison.py index 4e3c6fe05..9c9e2ab2c 100644 --- a/src/modelskill/comparison/_comparison.py +++ b/src/modelskill/comparison/_comparison.py @@ -1450,9 +1450,9 @@ def load(filename: Union[str, Path]) -> "Comparer": ) ts: PointModelResult | NodeModelResult if data.gtype in ("node", "reach"): - ts = NodeModelResult(data=ds, name=new_key) + ts = NodeModelResult(data=ds) else: - ts = PointModelResult(data=ds, name=new_key) + ts = PointModelResult(data=ds) raw_mod_data[new_key] = ts From aeafce22dfc3041fc0c86fd8d6a07cb5b5c0e23c Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 13:34:02 +0200 Subject: [PATCH 055/117] Build NodeModelResult only from data that knows where it is The constructor took a dfs0, a DataFrame or a Series plus a node name, which built a node result with no network anywhere. A location is named by the network it belongs to, so the only ways in are now NetworkModelResult.extract() and Comparer.load(), both of which hand over a dataset carrying its own location. Assembling that dataset from a network's raw columns moves to a private _from_network(), which sits on the class it returns. Wrong-type input now raises TypeError, matching NetworkModelResult. The docstring examples went with it: they showed ms.NodeModelResult(), an attribute that has never existed. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/network.py | 162 ++++++++++++++++++-------------- 1 file changed, 89 insertions(+), 73 deletions(-) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 5c57547ac..5c525b75f 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -16,7 +16,7 @@ from ..obs import NodeObservation, ReachObservation from ..timeseries._coords import network_location from ..quantity import Quantity -from ..types import GeometryType, PointType +from ..types import GeometryType if TYPE_CHECKING: from mikeio1d.network import Network @@ -36,91 +36,107 @@ def _network_class() -> type[Network]: class NodeModelResult(TimeSeries): - """Model result for a single network node. + """Model result at one network location. - Construct a NodeModelResult from timeseries data for a specific node. - This is a simple timeseries class designed for network node data. + What :meth:`NetworkModelResult.extract` returns: the timeseries of a single + node or break point, carrying in its coordinates the location it was taken + from. Extract one from a :class:`NetworkModelResult` rather than building it + directly, since a location is named by the network it belongs to. Parameters ---------- - data : str, Path, mikeio.Dataset, mikeio.DataArray, pd.DataFrame, pd.Series, xr.Dataset or xr.DataArray - filename (.dfs0 or .nc) or object with the data - name : str, optional - The name of the model result, - by default None (will be set to file name or item name) - node : str or tuple[str, float], optional - Where the data sits: a node name, or a break point as - ``(reach_id, distance)``. By default None, which requires data that - already carries a ``node`` or ``reach`` coordinate. - node_index : int, optional - The integer the network used for this location, recorded as provenance. - Nothing reads it back, by default None - item : str | int | None, optional - If multiple items/arrays are present in the input an item - must be given (as either an index or a string), by default None - quantity : Quantity, optional - Model quantity, for MIKE files this is inferred from the EUM information - aux_items : list[int | str], optional - Auxiliary items, by default None + data : xr.Dataset + Timeseries for one location, carrying a ``node`` coordinate, or a + ``reach`` coordinate with ``distance`` for a break point. - Examples + Raises + ------ + TypeError + If data is not an xarray.Dataset. + ValueError + If data carries no network location. + + See Also -------- - >>> import modelskill as ms - >>> mr = ms.NodeModelResult(data, node="123", name="Node_123") - >>> mr2 = ms.NodeModelResult(df, item="Water Level", node=("r1", 24.5)) + NetworkModelResult.extract : Extract a model result at a node or a reach. """ - def __init__( - self, - data: PointType, - node: str | tuple[str, float | None] | None = None, - *, - node_index: int | None = None, - name: str | None = None, - item: str | int | None = None, - quantity: Quantity | None = None, - aux_items: Sequence[int | str] | None = None, - ): - if not self._is_input_validated(data): - if isinstance(node, tuple): - reach, distance = node - data = _parse_network_breakpoint_input( - data, - name=name, - item=item, - quantity=quantity, - aux_items=aux_items, - reach=reach, - distance=distance, - ) - elif node is not None: - data = _parse_network_node_input( - data, - name=name, - item=item, - quantity=quantity, - node=node, - aux_items=aux_items, - ) - else: - raise ValueError( - "'NodeModelResult' needs a node name or a (reach, distance) " - "pair when the data does not already carry its location" - ) - + def __init__(self, data: xr.Dataset) -> None: if not isinstance(data, xr.Dataset): - raise ValueError("'NodeModelResult' requires xarray.Dataset") + raise TypeError( + "'NodeModelResult' takes an xarray.Dataset carrying its own " + f"location, got {type(data).__name__}. A model result for a " + "network location comes from NetworkModelResult.extract()." + ) if GeometryType.from_network_coords(data) is None: raise ValueError( - "'NodeModelResult' needs a node name, a (reach, distance) pair, or " - "data that already carries a 'node' or 'reach' coordinate" + "'NodeModelResult' needs data carrying a 'node' coordinate, or a " + "'reach' coordinate for a reach or a break point. A model result " + "for a network location comes from NetworkModelResult.extract()." ) - if node_index is not None: - data = data.assign_coords(node_index=int(node_index)) data_var = str(list(data.data_vars)[0]) data[data_var].attrs["kind"] = "model" super().__init__(data=data) + @classmethod + def _from_network( + cls, + data: xr.Dataset, + *, + location: str | tuple[str, float | None], + node_index: int, + name: str | None = None, + item: str | int | None = None, + quantity: Quantity | None = None, + aux_items: Sequence[int | str] | None = None, + ) -> NodeModelResult: + """Build a result from the data a network keeps at one location. + + Parameters + ---------- + data : xr.Dataset + Timeseries for one location, as the network stored it. + location : str or tuple of (str, float or None) + A node name, or a break point as ``(reach_id, distance)``. + node_index : int + The integer the network used for this location, recorded as + provenance. Nothing reads it back. + name : str, optional + The name of the model result, by default None (taken from the item) + item : str or int, optional + Item to take when the data holds more than one, by default None + quantity : Quantity, optional + Model quantity, by default None (inferred from the data) + aux_items : sequence of int or str, optional + Auxiliary items, by default None + + Returns + ------- + NodeModelResult + the result at that location + """ + if isinstance(location, tuple): + reach, distance = location + ds = _parse_network_breakpoint_input( + data, + name=name, + item=item, + quantity=quantity, + aux_items=aux_items, + reach=str(reach), + distance=distance, + ) + else: + ds = _parse_network_node_input( + data, + name=name, + item=item, + quantity=quantity, + node=location, + aux_items=aux_items, + ) + return cls(ds.assign_coords(node_index=int(node_index))) + @property def node(self) -> Any: """Where this result was extracted, as its network named it.""" @@ -363,9 +379,9 @@ def _as_node_result(self, node_id: int) -> NodeModelResult: data = self.data.sel(node=node_id).drop_vars( ("node", *self._UPSTREAM_IDENTITY_COORDS), errors="ignore" ) - return NodeModelResult( - data=data, - node=location, + return NodeModelResult._from_network( + data, + location=location, node_index=int(node_id), name=self.name, item=self.sel_items.values, From 52ef693f7cc52c60884bfcab29d5cdf66bf447d9 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 13:34:36 +0200 Subject: [PATCH 056/117] Drop the NodeModelResult _create_new_instance override It was identical to the base, which returns Self. The override carried a comment saying the location travels in the coords; the constructor now says that itself. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/network.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/modelskill/model/network.py b/src/modelskill/model/network.py index 5c525b75f..a654d1fde 100644 --- a/src/modelskill/model/network.py +++ b/src/modelskill/model/network.py @@ -157,10 +157,6 @@ def node_index(self) -> int | None: return None return int(np.atleast_1d(self.data.coords["node_index"].values)[0]) - def _create_new_instance(self, data: xr.Dataset) -> NodeModelResult: - """Create a new instance; the location already travels in the coords.""" - return self.__class__(data) - class NetworkModelResult: """Model result for network data with time and node dimensions. From 86aaa5f8c48c93e276759c70d83e5d746d089130 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 13:35:05 +0200 Subject: [PATCH 057/117] Describe NetworkModelResult by what it takes It read "a network field from xarray Dataset with time and node coordinates". It takes a result file or a mikeio1d Network. Co-Authored-By: Claude Opus 5 (1M context) --- src/modelskill/model/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/modelskill/model/__init__.py b/src/modelskill/model/__init__.py index 22c81857a..e81ca8d90 100644 --- a/src/modelskill/model/__init__.py +++ b/src/modelskill/model/__init__.py @@ -9,7 +9,7 @@ * SpatialField (extractable) - [`GridModelResult`](`modelskill.GridModelResult`) - a spatial field from a dfs2/nc file or a Xarray Dataset - [`DfsuModelResult`](`modelskill.DfsuModelResult`) - a spatial field from a dfsu file - - [`NetworkModelResult`](`modelskill.NetworkModelResult`) - a network field from xarray Dataset with time and node coordinates + - [`NetworkModelResult`](`modelskill.NetworkModelResult`) - a 1D network result from a res1d/res11/res file or a mikeio1d Network A model result can be created by explicitly invoking one of the above classes or using the [`model_result()`](`modelskill.model_result`) function which will return the appropriate type based on the input data (if possible). """ From ee60c4a1690264d87c70cb04c91257baf89959e8 Mon Sep 17 00:00:00 2001 From: jpalm3r Date: Tue, 22 Sep 2026 14:04:49 +0200 Subject: [PATCH 058/117] Seed the synthetic sensor data in the network notebook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The two random draws that build the sensor series were unseeded, so every run wrote three different CSVs over the committed fixtures. That is not just a manual-run problem: tests/notebooks/test_notebooks.py executes every tracked notebook with the working directory set to notebooks/, so `pytest tests/notebooks/` and the CI notebook job rewrote the test suite's own data underneath it. Seeded in the generating cell rather than at import, so the cell is reproducible when re-run on its own. The fixtures are regenerated once here. The values they had came from an unseeded run and cannot be reproduced; from now on a full execution leaves them byte-identical. Nothing asserts a value — the couplings are the 110-row count and the water_level@sens1 column name, both of which come from the slicing, not the noise. Co-Authored-By: Claude Opus 5 (1M context) --- notebooks/Collection_systems_network.ipynb | 219 ++++++++++---------- tests/testdata/network_sensor_1.csv | 220 ++++++++++----------- tests/testdata/network_sensor_2.csv | 160 +++++++-------- tests/testdata/network_sensor_3.csv | 180 ++++++++--------- 4 files changed, 391 insertions(+), 388 deletions(-) diff --git a/notebooks/Collection_systems_network.ipynb b/notebooks/Collection_systems_network.ipynb index 5291a0e84..9051e4bc1 100644 --- a/notebooks/Collection_systems_network.ipynb +++ b/notebooks/Collection_systems_network.ipynb @@ -667,7 +667,7 @@ " distance (node) float64 4kB nan nan 0.0 23.84 ... 1.0 0.0 41.21 82.43\n", "Data variables:\n", " WaterLevel (time, node) float32 218kB 195.4 194.7 195.4 ... 193.8 nan 195.0\n", - " Discharge (time, node) float32 218kB nan nan nan 5.72e-06 ... nan 0.0 nan