From bbf437dedcc6096a46a3190af1ae657a78b2e8da Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Tue, 30 Jan 2024 17:30:36 +0200
Subject: [PATCH 01/17] feat: implement distance_to_anomaly

Performance issues are a problem which can be solved by using the
alternative functionality that uses gdal_proximity function instead of
existing distance_computation implementation. The GDAL implementation is
orders of magnitude faster.
---
 docs/raster_processing/distance_to_anomaly.md |   3 +
 .../raster_processing/distance_to_anomaly.py  | 199 ++++++++++++++++++
 eis_toolkit/utilities/miscellaneous.py        |  50 +++++
 .../vector_processing/distance_computation.py |  14 +-
 notebooks/distance_to_anomaly.ipynb           | 160 ++++++++++++++
 .../test_distance_to_anomaly.py               | 125 +++++++++++
 6 files changed, 544 insertions(+), 7 deletions(-)
 create mode 100644 docs/raster_processing/distance_to_anomaly.md
 create mode 100644 eis_toolkit/raster_processing/distance_to_anomaly.py
 create mode 100644 notebooks/distance_to_anomaly.ipynb
 create mode 100644 tests/raster_processing/test_distance_to_anomaly.py

diff --git a/docs/raster_processing/distance_to_anomaly.md b/docs/raster_processing/distance_to_anomaly.md
new file mode 100644
index 00000000..b30a7983
--- /dev/null
+++ b/docs/raster_processing/distance_to_anomaly.md
@@ -0,0 +1,3 @@
+# Distance computation
+
+::: eis_toolkit.vector_processing.distance_computation
diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
new file mode 100644
index 00000000..2f700fb9
--- /dev/null
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -0,0 +1,199 @@
+from itertools import chain
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import geopandas as gpd
+import numpy as np
+import rasterio
+from beartype import beartype
+from beartype.typing import Literal, Tuple, Union
+from rasterio import profiles, transform
+
+from eis_toolkit.exceptions import InvalidParameterValueException
+from eis_toolkit.utilities.miscellaneous import row_points, toggle_gdal_exceptions
+from eis_toolkit.vector_processing.distance_computation import distance_computation
+
+THRESHOLD_CRITERIA_VALUE_TYPE = Union[Tuple[float, float], float]
+THRESHOLD_CRITERIA_TYPE = Literal["lower", "higher", "in_between", "outside"]
+
+
+@beartype
+def distance_to_anomaly(
+    raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_data: np.ndarray,
+    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
+    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+) -> np.ndarray:
+    """Calculate distance from raster cell to nearest anomaly.
+
+    The criteria for what is anomalous can be defined as a single number and
+    criteria text of "higher" or "lower". Alternatively, the definition can be
+    a range where values inside (criteria text of "within") or outside are
+    marked as anomalous (criteria text of "outside").
+
+    Args:
+        raster_profile: The raster profile of which the distances
+            to the nearest anomalous value are determined.
+        anomaly_raster: The raster in which the distances
+            to the nearest anomalous value are determined.
+        threshold_criteria_value: Value(s) used to define anomalous
+        threshold_criteria: Method to define anomalous
+
+    Returns:
+        A 2D numpy array with the distances to anomalies computed.
+
+    """
+    raster_width = raster_profile.get("width")
+    raster_height = raster_profile.get("height")
+
+    if not isinstance(raster_width, int) or not isinstance(raster_height, int):
+        raise InvalidParameterValueException(
+            f"Expected raster_profile to contain integer width and height. {raster_profile}"
+        )
+
+    raster_transform = raster_profile.get("transform")
+
+    if not isinstance(raster_transform, transform.Affine):
+        raise InvalidParameterValueException(
+            f"Expected raster_profile to contain an affine transformation. {raster_profile}"
+        )
+
+    return _distance_to_anomaly(
+        raster_profile=raster_profile,
+        anomaly_raster_profile=anomaly_raster_profile,
+        anomaly_raster_data=anomaly_raster_data,
+        threshold_criteria=threshold_criteria,
+        threshold_criteria_value=threshold_criteria_value,
+    )
+
+
+@beartype
+def distance_to_anomaly_gdal(
+    anomaly_raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_data: np.ndarray,
+    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
+    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    output_path: Path,
+    verbose: bool = False,
+) -> Path:
+    """Calculate distance from raster cell to nearest anomaly.
+
+    Distance is calculated for each cell in the anomaly raster and saved to a
+    new raster at output_path. The criteria for what is anomalous can be
+    defined as a single number and criteria text of "higher" or "lower".
+    Alternatively, the definition can be a range where values inside
+    (criteria text of "within") or outside are marked as anomalous
+    (criteria text of "outside").
+
+    Does not work on Windows.
+
+    Args:
+        anomaly_raster: The raster in which the distances
+            to the nearest anomalous value are determined.
+        threshold_criteria_value: Value(s) used to define anomalous
+        threshold_criteria: Method to define anomalous
+        output_path: The path to the raster with the distances to anomalies
+            calculated.
+        verbose: Whether to print gdal_proximity output.
+
+    Returns:
+        The path to the raster with the distances to anomalies calculated.
+    """
+    return _distance_to_anomaly_gdal(
+        output_path=output_path,
+        anomaly_raster_profile=anomaly_raster_profile,
+        anomaly_raster_data=anomaly_raster_data,
+        threshold_criteria=threshold_criteria,
+        threshold_criteria_value=threshold_criteria_value,
+        verbose=verbose,
+    )
+
+
+def _fits_criteria(
+    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
+    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    anomaly_raster_data: np.ndarray,
+) -> np.ndarray:
+    criteria_dict = {
+        "lower": lambda anomaly_raster_data: anomaly_raster_data < threshold_criteria_value,
+        "higher": lambda anomaly_raster_data: anomaly_raster_data > threshold_criteria_value,
+        "in_between": lambda anomaly_raster_data: np.where(
+            np.logical_and(anomaly_raster_data > threshold_criteria[0], anomaly_raster_data < threshold_criteria[1])
+        ),
+        "outside": lambda anomaly_raster_data: np.where(
+            np.logical_or(anomaly_raster_data < threshold_criteria[0], anomaly_raster_data > threshold_criteria[1])
+        ),
+    }
+    return np.where(np.isnan(anomaly_raster_data), False, criteria_dict[threshold_criteria](anomaly_raster_data))
+
+
+def _write_binary_anomaly_raster(tmp_dir: Path, anomaly_raster_profile, data_fits_criteria: np.ndarray):
+    anomaly_raster_binary_path = tmp_dir / "anomaly_raster_binary.tif"
+
+    anomaly_raster_binary_profile = anomaly_raster_profile
+    anomaly_raster_binary_profile.update(dtype=rasterio.uint8, count=1, nodata=None)
+    with rasterio.open(anomaly_raster_binary_path, mode="w", **anomaly_raster_binary_profile) as anomaly_raster_binary:
+        anomaly_raster_binary.write(data_fits_criteria.astype(rasterio.uint8), 1)
+
+    return anomaly_raster_binary_path
+
+
+def _distance_to_anomaly_gdal(
+    anomaly_raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_data: np.ndarray,
+    threshold_criteria_value: Union[Tuple[float, float], float],
+    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    output_path: Path,
+    verbose: bool,
+):
+    from osgeo_utils import gdal_proximity
+
+    data_fits_criteria = _fits_criteria(
+        threshold_criteria=threshold_criteria,
+        threshold_criteria_value=threshold_criteria_value,
+        anomaly_raster_data=anomaly_raster_data,
+    )
+
+    with TemporaryDirectory() as tmp_dir_str:
+        tmp_dir = Path(tmp_dir_str)
+        anomaly_raster_binary_path = _write_binary_anomaly_raster(
+            tmp_dir=tmp_dir, anomaly_raster_profile=anomaly_raster_profile, data_fits_criteria=data_fits_criteria
+        )
+        with toggle_gdal_exceptions():
+            gdal_proximity.gdal_proximity(
+                src_filename=str(anomaly_raster_binary_path),
+                dst_filename=str(output_path),
+                alg_options=("VALUES=1", "DISTUNITS=GEO"),
+                quiet=not verbose,
+            )
+
+    return output_path
+
+
+def _distance_to_anomaly(
+    raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_profile: Union[profiles.Profile, dict],
+    anomaly_raster_data: np.ndarray,
+    threshold_criteria_value: Union[Tuple[float, float], float],
+    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+) -> np.ndarray:
+    data_fits_criteria = _fits_criteria(
+        threshold_criteria=threshold_criteria,
+        threshold_criteria_value=threshold_criteria_value,
+        anomaly_raster_data=anomaly_raster_data,
+    )
+
+    cols = np.arange(anomaly_raster_data.shape[1])
+    rows = np.arange(anomaly_raster_data.shape[0])
+
+    all_points_by_rows = [
+        row_points(row=row, cols=cols[data_fits_criteria[row]], raster_transform=anomaly_raster_profile["transform"])
+        for row in rows
+    ]
+    all_points = list(chain(*all_points_by_rows))
+    all_points_gdf = gpd.GeoDataFrame(geometry=all_points, crs=anomaly_raster_profile["crs"])
+
+    distance_array = distance_computation(raster_profile=raster_profile, geometries=all_points_gdf)
+
+    return distance_array
diff --git a/eis_toolkit/utilities/miscellaneous.py b/eis_toolkit/utilities/miscellaneous.py
index 61494d90..2f3a6c66 100644
--- a/eis_toolkit/utilities/miscellaneous.py
+++ b/eis_toolkit/utilities/miscellaneous.py
@@ -1,9 +1,13 @@
+from contextlib import contextmanager
 from numbers import Number
 
 import numpy as np
 import pandas as pd
 from beartype import beartype
 from beartype.typing import Any, List, Optional, Sequence, Tuple, Union
+from osgeo import gdal
+from rasterio import transform
+from shapely.geometry import Point
 
 from eis_toolkit.exceptions import InvalidColumnException, InvalidColumnIndexException, InvalidDataShapeException
 from eis_toolkit.utilities.checks.dataframe import check_columns_valid
@@ -362,3 +366,49 @@ def rename_columns(df: pd.DataFrame, colnames=Sequence[str]) -> pd.DataFrame:
         names[columns[i]] = colnames[i]
 
     return df.rename(columns=names)
+
+
+def row_points(
+    row: int,
+    cols: np.ndarray,
+    raster_transform: transform.Affine,
+) -> List[Point]:
+    """Transform raster row cells to shapely Points.
+
+    Args:
+        row: Row index of cells to transfer
+        cols: Array of column indexes to transfer
+        raster_transform: Affine transformation matrix of the raster
+
+    Returns:
+        List of shapely Points
+    """
+    # transform.xy accepts either cols or rows as an array. The other then has
+    # to be an integer. The resulting x and y point coordinates are therefore
+    # in a 1D array
+
+    if len(cols) == 0:
+        return []
+
+    point_xs, point_ys = zip(*[raster_transform * (col + 0.5, row + 0.5) for col in cols])
+    # point_xs, point_ys = transform.xy(transform=raster_transform, cols=cols, rows=row)
+    return [Point(x, y) for x, y in zip(point_xs, point_ys)]
+
+
+@contextmanager
+def toggle_gdal_exceptions():
+    """Toggle GDAL exceptions using a context manager.
+
+    If the exceptions are already enabled, this function will do nothing.
+    """
+    already_has_exceptions_enabled = False
+    try:
+
+        gdal.UseExceptions()
+        if gdal.GetUseExceptions() != 0:
+            already_has_exceptions_enabled = True
+        yield
+
+    finally:
+        if not already_has_exceptions_enabled:
+            gdal.DontUseExceptions()
diff --git a/eis_toolkit/vector_processing/distance_computation.py b/eis_toolkit/vector_processing/distance_computation.py
index ba21fe7b..57453708 100644
--- a/eis_toolkit/vector_processing/distance_computation.py
+++ b/eis_toolkit/vector_processing/distance_computation.py
@@ -3,10 +3,10 @@
 from beartype import beartype
 from beartype.typing import Union
 from rasterio import profiles, transform
-from shapely.geometry import Point
 from shapely.geometry.base import BaseGeometry, BaseMultipartGeometry
 
 from eis_toolkit.exceptions import EmptyDataFrameException, InvalidParameterValueException, NonMatchingCrsException
+from eis_toolkit.utilities.miscellaneous import row_points
 
 
 @beartype
@@ -53,12 +53,12 @@ def _calculate_row_distances(
     raster_transform: transform.Affine,
     geometries_unary_union: Union[BaseGeometry, BaseMultipartGeometry],
 ) -> np.ndarray:
-    # transform.xy accepts either cols or rows as an array. The other then has
-    # to be an integer. The resulting x and y point coordinates are therefore
-    # in a 1D array
-    point_xs, point_ys = transform.xy(transform=raster_transform, cols=cols, rows=row)
-    row_points = [Point(x, y) for x, y in zip(point_xs, point_ys)]
-    row_distances = np.array([point.distance(geometries_unary_union) for point in row_points])
+    row_distances = np.array(
+        [
+            point.distance(geometries_unary_union)
+            for point in row_points(row=row, cols=cols, raster_transform=raster_transform)
+        ]
+    )
     return row_distances
 
 
diff --git a/notebooks/distance_to_anomaly.ipynb b/notebooks/distance_to_anomaly.ipynb
new file mode 100644
index 00000000..091c7a76
--- /dev/null
+++ b/notebooks/distance_to_anomaly.ipynb
@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b3d379c7-d0d1-44e4-9cdc-169f047b35f6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c3b27bf4-0a01-415f-a17f-a0f2b7fe68f7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/nialov/.cache/pypoetry/virtualenvs/eis-toolkit-14Bnyb2Y-py3.10/lib/python3.10/site-packages/geopandas/_compat.py:112: UserWarning: The Shapely GEOS version (3.10.3-CAPI-1.16.1) is incompatible with the GEOS version PyGEOS was compiled with (3.10.4-CAPI-1.16.2). Conversions between both will be slow.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from functools import partial\n",
+    "from tempfile import TemporaryDirectory\n",
+    "from pathlib import Path\n",
+    "from textwrap import fill\n",
+    "\n",
+    "import rasterio\n",
+    "from rasterio import plot\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib\n",
+    "import numpy as np\n",
+    "\n",
+    "from tests.raster_processing.clip_test import raster_path as SMALL_RASTER_PATH\n",
+    "from eis_toolkit.raster_processing.distance_to_anomaly import distance_to_anomaly, _fits_criteria, distance_to_anomaly_gdal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "02e9f227-8a87-487f-828e-c2d0d901e661",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def _plot_image(ax, data, title, transform):\n",
+    "    plot.show(data, transform=transform, ax=ax)\n",
+    "    ax.set_title(fill(title, width=25))\n",
+    "    norm = plt.Normalize(vmax=np.nanmax(data), vmin=np.nanmin(data))\n",
+    "    cmap = matplotlib.cm.viridis\n",
+    "    plt.colorbar(matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "71d8ab83-7d2e-4bbf-b662-9a14c37071e1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0...10...20...30...40...50...60...70...80...90..."
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq0AAAL3CAYAAACgSXw6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVyU1f4H8M/sDMuAKIgo4g6KWi5lmGa5pqZWFlmmqJlamln3WvIrE/UqaV3TrDDvNTVDzSXLzETMtMzdpEzLfUtFcmFR1pk5vz+4TD5zvugsCDPyfb9e86o5nPM85xnGw5lnzvd8VUIIAcYYY4wxxjyYurI7wBhjjDHG2K3wpJUxxhhjjHk8nrQyxhhjjDGPx5NWxhhjjDHm8XjSyhhjjDHGPB5PWhljjDHGmMfjSStjjDHGGPN4PGlljDHGGGMejyetjDHGGGPM4/GklTHGGHPRhg0bcPfdd8PHxwcqlQpZWVkYMmQI6tWr5/axVSoVEhMT3T5ORTt16hRUKhUWLVpUYeesV68ehgwZUmHnY5WDJ62MMcYq3aJFi6BSqWwPHx8fhIeHo0ePHnj//feRm5vr8rG3b9+OxMREZGVllV+HAVy+fBlxcXEwGo348MMPsWTJEvj5+Un18vLykJiYiC1btkg/W79+vVdOTJ1VVa6T3V4qIYSo7E4wxhir2hYtWoShQ4diypQpqF+/PoqLi5GRkYEtW7YgLS0NdevWxdq1a9GyZUunj/3uu+9i/PjxOHnyZLncAS21YcMG9OzZE2lpaejatautvLi4GFarFQaDAQBw6dIlhISEYNKkSdLEbcyYMfjwww9B/SkuKCiAVquFVqsttz5XBCEECgsLodPpoNFoANz8OstDYWEh1Go1dDrdbTk+8wze9S+BMcbYHa1nz55o27at7XlCQgI2b96MRx55BH379sXvv/8Oo9FYiT38W2ZmJgAgKChIUV5eEycfH59yOU5FMZvNsFqt0Ov1FdJ3IQQKCgpgNBptHxDYnY2XBzDGGPNonTt3xsSJE3H69Gl89tlntvJff/0VQ4YMQYMGDeDj44OwsDAMGzYMly9fttVJTEzE+PHjAQD169e3LT84deoUAGDhwoXo3LkzQkNDYTAY0KxZMyQnJ9+yTw8++CDi4+MBAPfccw9UKpVtTeWNa1pPnTqFkJAQAMDkyZNt509MTMSQIUPw4YcfAoBiaUQp+zWtiYmJUKlUOHbsGIYMGYKgoCAEBgZi6NChyMvLU/QvPz8fY8eORY0aNRAQEIC+ffvi3LlzDq+TLSgoQGJiIpo0aQIfHx/UqlULjz/+OI4fP267LpVKhXfffRezZ89Gw4YNYTAYcOjQIWlN662u02q1Yvbs2YiJiYGPjw9q1qyJkSNH4urVq4o+1atXD4888ghSU1PRtm1bGI1GfPzxx7af3bim9cqVK/jnP/+JFi1awN/fHyaTCT179sQvv/xyy2tnnovvtDLGGPN4gwYNwv/93/9h48aNeP755wEAaWlpOHHiBIYOHYqwsDAcPHgQ8+fPx8GDB7Fz506oVCo8/vjjOHLkCJYtW4b33nsPNWrUAADbRDI5ORkxMTHo27cvtFotvv76a7z44ouwWq0YPXp0mf154403EBUVhfnz59uWNDRs2FCqFxISguTkZLzwwgt47LHH8PjjjwMAWrZsievXr+P8+fNIS0vDkiVLHH4t4uLiUL9+fSQlJeHnn3/Gf//7X4SGhmLGjBm2OkOGDMGKFSswaNAg3Hfffdi6dSt69+7t0PEtFgseeeQRfPfddxgwYABefvll5ObmIi0tDb/99pviOhcuXIiCggKMGDECBoMBwcHBsFqtiuONHDnyptc5cuRI2/KQsWPH4uTJk/jggw+wf/9+/PTTT4o714cPH8bTTz+NkSNH4vnnn0dUVBR5DSdOnMCXX36JJ598EvXr18fFixfx8ccfo1OnTjh06BDCw8Mdei2YhxGMMcZYJVu4cKEAIPbs2VNmncDAQNGqVSvb87y8PKnOsmXLBADxww8/2MreeecdAUCcPHlSqk8do0ePHqJBgwYu9zk+Pl5ERkbanv/1118CgJg0aZJ0jNGjR4uy/hTbt5k0aZIAIIYNG6ao99hjj4nq1avbnu/bt08AEOPGjVPUGzJkSJn9uNEnn3wiAIhZs2ZJP7NarUIIIU6ePCkACJPJJDIzMxV1Sn+2cOHCW17njz/+KACIlJQURfmGDRuk8sjISAFAbNiwQTpOZGSkiI+Ptz0vKCgQFotF6pfBYBBTpkwp++KZR+PlAYwxxryCv7+/YheBG9e2FhQU4NKlS7jvvvsAAD///LNDx7zxGNnZ2bh06RI6deqEEydOIDs7u5x6Xr5GjRqleN6xY0dcvnwZOTk5AEoCxADgxRdfVNR76aWXHDr+6tWrUaNGDbL+jV/rA0D//v1td61dsXLlSgQGBqJbt264dOmS7dGmTRv4+/vj+++/V9SvX78+evToccvjGgwGqNUlUxyLxYLLly/D398fUVFRDr83mOfh5QGMMca8wrVr1xAaGmp7fuXKFUyePBnLly+3BUWVcnTC+dNPP2HSpEnYsWOHtC40OzsbgYGB7ne8nNWtW1fxvFq1agCAq1evwmQy4fTp01Cr1ahfv76iXqNGjRw6/vHjxxEVFeXQrgX253DW0aNHkZ2drfi93sj+9+ro+axWK+bMmYOPPvoIJ0+ehMVisf2sevXqrneYVSqetDLGGPN4f/75J7KzsxUTr7i4OGzfvh3jx4/H3XffDX9/f1itVjz88MPSukrK8ePH0aVLF0RHR2PWrFmIiIiAXq/H+vXr8d577zl0jMpQuo2UPVEJO1i6u5OD1WpFaGgoUlJSyJ/b38V19HzTp0/HxIkTMWzYMEydOhXBwcFQq9UYN26cx/5e2a3xpJUxxpjHKw3gKf1q+OrVq/juu+8wefJkvPXWW7Z6R48eldraf6Vd6uuvv0ZhYSHWrl2ruHtp/5W0u8o6/61+5qrIyEhYrVacPHkSjRs3tpUfO3bMofYNGzbErl27UFxcXG7bd5V1nQ0bNsSmTZtw//33l+tWZqtWrcJDDz2EBQsWKMqzsrJswXjM+/CaVsYYYx5t8+bNmDp1KurXr4+BAwcC+Ptuo/3dxdmzZ0vtS7NU2WfEoo6RnZ2NhQsXllfXAQC+vr7k+W/WN3eUTuw/+ugjRfncuXMdat+/f39cunQJH3zwgfQzV+/mlnWdcXFxsFgsmDp1qtTGbDa7/LpoNBqprytXrsS5c+dcOh7zDHynlTHGmMf49ttv8ccff8BsNuPixYvYvHkz0tLSEBkZibVr19o2rTeZTHjggQcwc+ZMFBcXo3bt2ti4cSNOnjwpHbNNmzYASrapGjBgAHQ6Hfr06YPu3btDr9ejT58+GDlyJK5du4b//Oc/CA0NxYULF8rtmoxGI5o1a4bPP/8cTZo0QXBwMJo3b47mzZvb+jZ27Fj06NEDGo0GAwYMcOt8bdq0Qf/+/TF79mxcvnzZtuXVkSNHANz67u7gwYPx6aef4tVXX8Xu3bvRsWNHXL9+HZs2bcKLL76Ifv36udQnQL7OTp06YeTIkUhKSkJ6ejq6d+8OnU6Ho0ePYuXKlZgzZw6eeOIJp8/3yCOPYMqUKRg6dCjat2+PAwcOICUlBQ0aNHD6WMyDVOreBYwxxpj4e/uo0oderxdhYWGiW7duYs6cOSInJ0dq8+eff4rHHntMBAUFicDAQPHkk0+K8+fPk9s6TZ06VdSuXVuo1WrF9ldr164VLVu2FD4+PqJevXpixowZti2fqC2yqD7fassrIYTYvn27aNOmjdDr9Yr+mc1m8dJLL4mQkBChUqkU20LZX0fplld//fUX2Y8b+3v9+nUxevRoERwcLPz9/cWjjz4qDh8+LACIt99++6bXJUTJVmBvvPGGqF+/vtDpdCIsLEw88cQT4vjx40KIv7e1euedd6S21JZXN7tOIYSYP3++aNOmjTAajSIgIEC0aNFCvPbaa+L8+fO2OpGRkaJ3795kf6ktr/7xj3+IWrVqCaPRKO6//36xY8cO0alTJ9GpU6dbXj/zTCohKmHlNmOMMcYqVHp6Olq1aoXPPvvMtsyCMW/Ca1oZY4yxO0x+fr5UNnv2bKjVajzwwAOV0CPG3MdrWhljjLE7zMyZM7Fv3z489NBD0Gq1+Pbbb/Htt99ixIgRiIiIqOzuMeYSXh7AGGOM3WHS0tIwefJkHDp0CNeuXUPdunUxaNAgvPHGGw4lDWDME/GklTHGGGOMeTxe08oYY4wxxjweT1oZY4wxxpjH40krY4wxdhMzZ85EdHR0lcpZX69ePQwZMsTpdvPmzUPdunVRWFhY/p1iVR5PWhljjLEy5OTkYMaMGXj99dehVvOfzFsZMmQIioqK8PHHH1d2V9gdiP8FMsYYY2X45JNPYDab8fTTT1d2V7yCj48P4uPjMWvWLHCcNytvPGlljDHGyrBw4UL07dsXPj4+ld0VrxEXF4fTp0/j+++/r+yusDsMT1oZY4wxwsmTJ/Hrr7+ia9euivJ3330X7du3R/Xq1WE0GtGmTRusWrVKaq9SqTBmzBh8+eWXaN68OQwGA2JiYrBhwwap7v79+9GzZ0+YTCb4+/ujS5cu2Llzp6LOokWLoFKpsG3bNowdOxYhISEICgrCyJEjUVRUhKysLAwePBjVqlVDtWrV8Nprr0l3Ox3t+41OnDgBlUqF9957T/rZ9u3boVKpsGzZMltZmzZtEBwcjK+++uqmx2XMWbxPK2OMMUZISUnBs88+i19//RUtWrSwlUdERKBv375o1qwZioqKsHz5cuzevRvr1q1D7969bfVUKhXuuusuZGZm4sUXX0RAQADef/99ZGRk4MyZM6hevToA4ODBg2jXrh1MJhNefPFF6HQ6fPzxxzh//jy2bt2Kdu3aASiZtA4dOhR33303wsLC0KdPH+zcuRNLlizBa6+9hu3bt6Nu3bro0KED1q9fj3Xr1mHx4sUYPHiw032vV68eHnzwQSxatAgA0KFDBxQUFGDv3r2K12j06NFYsmQJMjIy4Ovrayvv1q0brl69KtVnzC2CMcYYY5I333xTABC5ubmK8ry8PMXzoqIi0bx5c9G5c2dFOQCh1+vFsWPHbGW//PKLACDmzp1rK3v00UeFXq8Xx48ft5WdP39eBAQEiAceeMBWtnDhQgFA9OjRQ1itVlt5bGysUKlUYtSoUbYys9ks6tSpIzp16uRS3yMjI0V8fLzt+ccffywAiN9//13RtkaNGop6pUaMGCGMRqNUzpg7eHkAY4wxRrh8+TK0Wi38/f0V5Uaj0fb/V69eRXZ2Njp27Iiff/5ZOkbXrl3RsGFD2/OWLVvCZDLhxIkTAACLxYKNGzfi0UcfRYMGDWz1atWqhWeeeQbbtm1DTk6O4pjPPfccVCqV7Xm7du0ghMBzzz1nK9NoNGjbtq3tPK70/UZxcXHw8fFBSkqKrSw1NRWXLl3Cs88+K9WvVq0a8vPzkZeXd9PjMuYMnrQyxhhjTli3bh3uu+8++Pj4IDg4GCEhIUhOTkZ2drZUt27dulJZtWrVcPXqVQDAX3/9hby8PERFRUn1mjZtCqvVirNnz970mIGBgQBKvvq3Ly89jyt9v1FQUBD69OmDpUuX2spSUlJQu3ZtdO7cWaov/rfy8MbJNWPu4kkrY4wxRqhevTrMZjNyc3NtZT/++KNtN4GPPvoI69evR1paGp555hlyiyeNRkMem6rrqLKOSZXfeB5n+25v8ODBOHHiBLZv347c3FysXbsWTz/9NLl/7dWrV+Hr66u4s8uYu7SV3QHGGGPME0VHRwMo2UWgZcuWAIDVq1fDx8cHqampMBgMtroLFy506RwhISHw9fXF4cOHpZ/98ccfUKvV0h1UV7nb94cffhghISFISUlBu3btkJeXh0GDBpF1T548iaZNm5ZLvxkrxXdaGWOMMUJsbCwAKCLgNRoNVCoVLBaLrezUqVP48ssvXTqHRqNB9+7d8dVXX+HUqVO28osXL2Lp0qXo0KEDTCaTS8emzuVO37VaLZ5++mmsWLECixYtQosWLWyTeXs///wz2rdvXx7dZsyGJ62MMcYYoUGDBmjevDk2bdpkK+vduzfy8vLw8MMPY968eZgyZQratWuHRo0auXyef/3rX9BqtejQoQOmT5+OmTNnon379igsLMTMmTPL41LKre+DBw/GpUuX8P3335MBWACwb98+XLlyBf369SuvrjMGgCetjDHGWJmGDRuGr7/+Gvn5+QCAzp07Y8GCBcjIyMC4ceOwbNkyzJgxA4899pjL54iJicGPP/6I5s2bIykpCZMnT0ZkZCS+//572x6t5aE8+t6mTRvExMRArVZj4MCBZJ2VK1eibt26ZIAWY+7g5AKMMcZYGbKzs9GgQQPMnDlTsaVUVdaqVSsEBwfju+++k35WWFiIevXqYcKECXj55ZcroXfsTsZ3WplTVCoVEhMTbc9L0wreuBbLGUOGDEG9evXKpW+MMVbeAgMD8dprr+Gdd96B1Wqt7O5Uur179yI9PV2RZetGCxcuhE6nw6hRoyq4Z6wq4N0DmM1HH32E0aNH495778WuXbsquzu3NH36dDRr1gyPPvpoZXeFOamgoABFRUUutdXr9fDx8SnnHjFWttdffx2vv/56ZXejUv3222/Yt28f/v3vf6NWrVp46qmnyHqjRo3iCWsFcWccBbxzLOVJK7NJSUlBvXr1sHv3bhw7dsytwIKKMH36dDzxxBM8afUyBQUFqB/pj4xMy60rE8LCwnDy5EmvG2wZ82arVq3ClClTEBUVhWXLlvG/v0rm7jgKeOdYypNWBqBkT73t27fjiy++wMiRI5GSkoJJkyZVdrfYHaioqAgZmRac3BcJU4BzK5Rycq2o3+Y0ioqKvGqgZczbJSYmKpaGscrlzjgKeO9YymtaGYCSu6zVqlVD79698cQTTyjyS5eXL7/8Es2bN4ePjw+aN2+ONWvWkPXeffddtG/fHtWrV4fRaESbNm2watUqRR2VSoXr169j8eLFUKlUUKlUGDJkCADg9OnTePHFFxEVFQWj0Yjq1avjySefdHndLbs9/PxdezDGGCvh6jjqrWMp32llAEomrY8//jj0ej2efvppJCcnY8+ePbjnnnvK5fgbN25E//790axZMyQlJeHy5csYOnQo6tSpI9WdM2cO+vbti4EDB6KoqAjLly/Hk08+iXXr1qF3794AgCVLlmD48OG49957MWLECABAw4YNAQB79uzB9u3bMWDAANSpUwenTp1CcnIyHnzwQRw6dAi+vr7lck3MPVYIWOHc5iXO1meMsTuZK+NoaTtvxJNWhn379uGPP/7A3LlzAQAdOnRAnTp1kJKSUm6T1tdffx01a9bEtm3bEBgYCADo1KkTunfvjsjISEXdI0eOKPJVjxkzBq1bt8asWbNsk9Znn30Wo0aNQoMGDaQNrkvvFt+oT58+iI2NxerVq8tMO8gqlhVWOBuL7XwLxhi7c7kyjpa280a8PIAhJSUFNWvWxEMPPQSg5Kv3p556CsuXL1ek+3PVhQsXkJ6ejvj4eNuEFQC6deuGZs2aSfVvnLBevXoV2dnZ6NixI37++WeHzndj++LiYly+fBmNGjVCUFCQw8dgjDHGmGepcpPWb775Bu3atYPRaES1atUcijz//fff0bdvXwQGBsLPzw/33HMPzpw5A6Akb3Ppmkr7x8qVK23HGDt2LNq0aQODwYC7777b5f7frC+usFgsWL58OR566CGcPHkSx44dw7Fjx9CuXTtcvHiR3DzaWadPnwYANG7cWPpZVFSUVLZu3Trcd9998PHxQXBwMEJCQpCcnIzs7GyHzpefn4+33noLERERMBgMqFGjBkJCQpCVleXwMdjtZxHCpQerfDyOMuYZXB1HvXUsveMmrQ8++CAWLVpE/qz0q+GhQ4fil19+wU8//YRnnnnmpsc7fvw4OnTogOjoaGzZsgW//vorJk6caIu2i4iIwIULFxSPyZMnw9/fHz179lQca9iwYWXubeeIW/XFFZs3b8aFCxewfPlyNG7c2PaIi4sDgNsSkHUzP/74I/r27QsfHx989NFHWL9+PdLS0vDMM8/A0eRtL730EqZNm4a4uDisWLECGzduRFpaGqpXr86bg3uQ0rVYzj7Y7cfjKGPewdVx1FvH0iqzptVsNuPll1/GO++8o0jFR309faM33ngDvXr1wsyZM21lpQE/AKDRaBAWFqZos2bNGsTFxcHf/+/wvPfffx8A8Ndff+HXX38lz7Vt2zYkJCRg7969qFGjBh577DEkJSXBz8/Pob64IiUlBaGhofjwww+ln33xxRdYs2YN5s2bp/jK3Vmla1aPHj0q/ezw4cOK56tXr4aPjw9SU1NhMBhs5QsXLpTaqlQq8nyrVq1CfHw8/v3vf9vKCgoKkJWV5Ur32W1ihYCFA7G8Co+jjHkWV8bR0nbe6I6701qWn3/+GefOnYNarUarVq1Qq1Yt9OzZE7/99luZbaxWK7755hs0adIEPXr0QGhoKNq1a4cvv/yyzDb79u1Denq60zmqjx8/jocffhj9+/fHr7/+is8//xzbtm3DmDFjXO7LreTn5+OLL77AI488gieeeEJ6jBkzBrm5uVi7dq3L5wCAWrVq4e6778bixYsVX8+npaXh0KFDiroajQYqlUqxlvbUqVPkdfr5+ZETUY1GI92VnTt3brmsz2XlpyrdHbhT8DjKmGepqDutubm5GDduHCIjI2E0GtG+fXvs2bPnpm0KCwvxxhtvIDIyEgaDAfXq1cMnn3zizuVWnUnriRMnAJRskPzmm29i3bp1qFatGh588EFcuXKFbJOZmYlr167h7bffxsMPP4yNGzfisccew+OPP46tW7eSbRYsWICmTZuiffv2TvUvKSkJAwcOxLhx49C4cWO0b98e77//Pj799FMUFBS41JdbWbt2LXJzc9G3b1/y5/fddx9CQkLKZYlAUlISLl68iA4dOuC9997DxIkT8eSTTyImJkZRr3fv3sjLy8PDDz+MefPmYcqUKWjXrh2ZnatNmzbYtGkTZs2aheXLl9tSzz7yyCNYsmQJxo0bh/nz52Po0KF4//33Ub16dbevg7GqjMdRxqqm4cOHIy0tDUuWLMGBAwfQvXt3dO3aFefOnSuzTVxcHL777jssWLAAhw8fxrJly8g4FqcILzdt2jTh5+dne6jVamEwGBRlp0+fFikpKQKA+Pjjj21tCwoKRI0aNcS8efPIY587d04AEE8//bSivE+fPmLAgAFS/by8PBEYGCjefffdMvs7adIkcdddd0nlbdu2FXq9XtFvX19fAUAcOnTI6b44ok+fPsLHx0dcv369zDpDhgwROp1OXLp0SQghBAAxadIk288XLlwoAIiTJ0/e8nyrV68WTZs2FQaDQTRr1kx88cUXIj4+XkRGRirqLViwQDRu3FgYDAYRHR0tFi5cKCZNmiTs365//PGHeOCBB4TRaBQARHx8vBBCiKtXr4qhQ4eKGjVqCH9/f9GjRw/xxx9/iMjISFsdVnmys7MFAHHk95riwp+1nHoc+b2mACCys7Mr+zLuKDyOuj6OMlYZ3BlHnR1L8/LyhEajEevWrVOUt27dWrzxxhtkm2+//VYEBgaKy5cvl8v1lvL6Na2jRo2yBQ0BwMCBA9G/f388/vjjtrLw8HDUqlULgHLtlcFgQIMGDcqMGq1Rowa0Wq20Xqtp06bYtm2bVH/VqlXIy8vD4MGDnb6Oa9euYeTIkRg7dqz0s7p16wKAU31xhCNf+y9cuFCxnlTYfe0+ZMgQWyaqW3n88ccVvxcAeOyxx6R6w4YNw7Bhw6Ry+xSCUVFR5N2RoKAg8isIzojlWaz/ezjbhpU/HkddH0cZq0yujKOl7QAgJydHUW4wGBTxJEDJWnaLxSIFKxqNxjL/3axduxZt27bFzJkzsWTJEvj5+aFv376YOnWqWzEyXj9pDQ4ORnBwsO250WhEaGio9HVy6TYphw8fRocOHQCU7OF56tQpaXP7Unq9Hvfcc48ULHTkyBGyzYIFC9C3b1+EhIQ4fR2tW7fGoUOHyK/BSznTF8Y8ncWFAAJXAg7YrfE4yuMo806ujKOl7YCSnTtuNGnSJOkGUUBAAGJjYzF16lQ0bdoUNWvWxLJly7Bjx44y/62dOHEC27Ztg4+PD9asWYNLly7hxRdfxOXLl8nAakd5/aTVUSaTCaNGjcKkSZMQERGByMhIvPPOOwCAJ5980lYvOjoaSUlJtjuA48ePx1NPPYUHHngADz30EDZs2ICvv/4aW7ZsURz/2LFj+OGHH7B+/Xry/MeOHcO1a9eQkZGB/Px8pKenAyi5Y6HX6/H666/jvvvuw5gxYzB8+HD4+fnh0KFDSEtLwwcffOBUXxjzBhZR8nC2Das8PI4y5llcGUdL2wHA2bNnYTKZbOX2d1lLLVmyBMOGDUPt2rWh0WjQunVrPP3009i3bx9Z32q1QqVSISUlxZZUaNasWXjiiSfw0UcfuX63tVwXG3iATp06iYULF5I/KyoqEv/4xz9EaGioCAgIEF27dhW//fabog4Aqf2CBQtEo0aNhI+Pj7jrrrvEl19+KR07ISFBRERECIvFUma/AEiPG9eC7t69W3Tr1k34+/sLPz8/0bJlSzFt2jSn+8KYJytdi5V+KFQcPxvm1CP9UCivaa0API4y5tncGUfdGUuvXbsmzp8/L4QQIi4uTvTq1YusN3jwYNGwYUNF2aFDh0rW4R454tpFCyFUQnhpWgTGmFfKyclBYGAg0g+FIiDAuQ1McnOtuLtZJrKzsxV3BxhjrCpxZxwF3B9Lr169ivr162PmzJkYMWKE9PP58+dj3LhxyMzMtO21/NVXX+Hxxx/HtWvXXL7TWmW2vGKMeRYrVLA4+bCCTijBGGNVkSvjqCtjaWpqKjZs2ICTJ08iLS0NDz30EKKjozF06FAAQEJCgiJ48plnnkH16tUxdOhQHDp0CD/88APGjx+PYcOGuRWIxZNWxlilsArXHowxxkq4Oo46O5ZmZ2dj9OjRiI6OxuDBg9GhQwekpqZCp9MBAC5cuKDYQcTf3x9paWnIyspC27ZtMXDgQPTp08eW1c5VXrk8wGq14vz58wgICCgzlSdj7PYSQiA3Nxfh4eFQqx3//Fv6tdaug2Hwd/JrrWu5VrSLyeDlAeWAx1HGKl9ljKOA946lXrl7wPnz56VtGhhjlePs2bOoU6eO0+1Kv6Zytg0rHzyOMuY5KnIcLW3njbxy0hoQEAAAaN3rDWh0f29265tRINXV5BZJZaqiYvmg1ltvz6tyoA4ACOrTElWm1chtdUQZeTyHukIj3qtCozygVSufwOIj983sS5QZ5bZWnXxSi47oB/GOFA7+2xIauaLVvnvEsVTEr1VlkcvUxL4iKrNjxxPU74sok/oLQE30RVNInMOR18mNccr++JaiAvy2Yqrt3yPzLqW/N/stbxhjFScnJwcRERE8jjrIKyetpV9laXQ+0N4wadUSV6MhJjIqDTFboGYa9lUczDthPwEEQE9aNcQElSor90mr/JoI7a0nrSpikg1ikg0dMeHVE7OlCpi0quyP5+iklZiMkpNWB99Kjk5aVY5OWolFPRU9abUd0sWvlq1CBaujv9wb2rDyUfp7M5lMPGllrJJV5Dha2s4beeWklTHm/Xh5AGOMuYeXB3iRgJPXoNX8/VW/Kl9eCgCLfJtKRYXNUV/928eoUZ+EqLugVD3i7iu5FIC4w0lyJwm7Vu6f2Vdn95z62p9o50PcVSUSalipu6rEnVHyjiSFutPowN1M8sMltVyCqqeWC9VEHKOK6Bt1txTU3VyiGnW88ryr6vAHbvt6bo55FqhhcfIrA+plZIyxqsqVcbSknXfiLa8YY5VC/O9rLWcewoWvtHJzczFu3DhERkbCaDSiffv22LNnz224IsYYq1iujKOujqWewKlJa3JyMlq2bGlbAxUbG4tvv/3W9vOMjAwMGjQIYWFh8PPzQ+vWrbF69WrFMa5cuYKBAwfCZDIhKCgIzz33HK5du1Y+V8MYY3aGDx+OtLQ0LFmyBAcOHED37t3RtWtXnDt3rlL6w+MoY4y5xqlJa506dfD2229j37592Lt3Lzp37ox+/frh4MGDAIDBgwfj8OHDWLt2LQ4cOIDHH38ccXFx2L9/v+0YAwcOxMGDB5GWloZ169bhhx9+IFOAMcbubK5kcXF2HVZ+fj5Wr16NmTNn4oEHHkCjRo2QmJiIRo0aITk5+TZd2c3xOMoYKy+ujqPeuqbVqUlrnz590KtXLzRu3BhNmjTBtGnT4O/vj507dwIAtm/fjpdeegn33nsvGjRogDfffBNBQUHYt28fAOD333/Hhg0b8N///hft2rVDhw4dMHfuXCxfvhznz58v/6tjjHksi1C79ABKtom58VFYSOwBBsBsNsNiscDHx0dRbjQasW3bttt+jRQeRxlj5cXVcdTicACJZ3E5EMtisWDlypW4fv06YmNjAQDt27fH559/jt69eyMoKAgrVqxAQUEBHnzwQQDAjh07EBQUhLZt29qO07VrV6jVauzatQuPPfYYea7CwkLFH6WcnBwAgDr7GtRqYs9VRUeJiCUq6MqR4ClqqygiOIcKzqK2siLP6U6AFbVPKRHsZTHKv/aiQGVZkb98DWYiXbDFQG2fJdej/n249W/G0TxujgRiUc2otxW1J2sF5JNzOVDKw1mhgtXJZfXW//3i7TfFnzRpEhITE6X6AQEBiI2NxdSpU9G0aVPUrFkTy5Ytw44dO9CoUSOX+15ePGEcZYx5L1fG0ZJ2XpcMFYALk9YDBw4gNjYWBQUF8Pf3x5o1a9CsWTMAwIoVK/DUU0+hevXq0Gq18PX1xZo1a2x/HDIyMhAaGqrsgFaL4OBgZGRklHnOpKQkTJ482dmuMsY8mDtbXtlviG8wEFtW/M+SJUswbNgw1K5dGxqNBq1bt8bTTz9tu3NZGXgcZYyVh6q25ZXT0/OoqCikp6dj165deOGFFxAfH49Dhw4BACZOnIisrCxs2rQJe/fuxauvvoq4uDgcOHDArU4mJCQgOzvb9jh79qxbx2OMVT53vtIqDWIqfdxs0tqwYUNs3boV165dw9mzZ7F7924UFxejQYMGFXWpEh5HGWPlgZcH3IJer7d94m/Tpg327NmDOXPm4LXXXsMHH3yA3377DTExMQCAu+66Cz/++CM+/PBDzJs3D2FhYcjMzFQcz2w248qVKwgLCyvznAaD4aZ/lBhj7Fb8/Pzg5+eHq1evIjU1FTNnzqy0vvA4yhhjznN7qm21WlFYWIi8vLySA9qt59RoNLD+bw1pbGwssrKyFF/Lbd68GVarFe3atXO3K4wxL1KyFsv5h7NSU1OxYcMGnDx5EmlpaXjooYcQHR2NoUOH3oarcg2Po4wxV7g6jroylnoCp+60JiQkoGfPnqhbty5yc3OxdOlSbNmyBampqYiOjkajRo0wcuRIvPvuu6hevTq+/PJL25YsANC0aVM8/PDDeP755zFv3jwUFxdjzJgxGDBgAMLDw53vvdmiTDVEZL8iOZrFypE6VICVliijENmU6KxbRFMiw5bVIP86iwOIoKsAuX9F/srzmv3kflh8pCJYHQy6Kvd/H9RL50AQmyB+NWQZcQ1qKhCLeMtRZeT1O/qaUOvlXXw9Hc0I5khbd/emtrqQycWV4IHs7GwkJCTgzz//RHBwMPr3749p06ZBpyPStFUAjxtHGWNey5VxtKRdFQjEyszMxODBg3HhwgUEBgaiZcuWSE1NRbdu3QAA69evx4QJE9CnTx9cu3YNjRo1wuLFi9GrVy/bMVJSUjBmzBh06dIFarUa/fv3x/vvv1++V8UY83iurKuyUB/0biEuLg5xcXFOt7tdeBxljJUXV9enujKWegKnJq0LFiy46c8bN24sZW6xFxwcjKVLlzpzWsbYHcgKtctbXnkzHkcZY+XFlXG0pJ13jqXeGT7GGGOMMcaqFJeTCzDGmDssQgWLkwtjna3PGGN3MlfG0dJ23sirJ62isJjOSHUDFRGw5DC7ICsq+IlEZdxyMCOW0BEBVnoiq5UvEXTlTwVYyccrMsnnLfa3Oz4VdKVx/esEKtjJ4fv8VAIzqswiX5dUj0pCRl0XkenLQmTJokJ5qL6R1+8oFwOlHD1WZY1dFhcCCCxe+pUWY4zdDq6MoyXtvHMs9epJK2PMe1mFGlYnAwisXho8wBhjt4Mr42hJO+8cS3nSyhirFHynlTHG3FPV7rRyIBZjjDHGGPN4fKeVMVYprHA+GMCB/BGMMVZluDKOlrbzRt49abVaANyQfkjtYLQLmdlKvul8qyCvkj5Qv3riBraeCOwxymE8VICV2dfBAKsAIsCKKvOXimD2VX5VYNXJXx1QgU6aIvlYFKtePp7VwYREdNYpuS9qC9FnuyxWajPRjigjA7b0cpnZKFfUWR372qXcA6DK83guBnU5w7V9WvnLIcYYK+X6Pq3eOZZ696SVMea1XMuI5Z0DLWOM3Q6uZ8TyzrGUJ62MsUphhQpWJ2/XOlufMcbuZK6Mo6XtvJF3TrUZY16v9A6Bsw/GGGMlXB1HnR1Lc3NzMW7cOERGRsJoNKJ9+/bYs2ePQ21/+uknaLVa3H333S5coZJ332lVqZTrU6k1qNSm/g4mCVDZrU0UGuL4auJYWvmcVmL9arGJKAtwY/0qtVbVX15faTbKZcJ+zSmxLJPcvJ9Yb0qt1aT+fQiDY0vBqe3kqL6IYmK9qrR+WT6YmmhHrVK3Ev9aikxyGbXYU5vnGduLuLWO1r6td35QZ4wx5qThw4fjt99+w5IlSxAeHo7PPvsMXbt2xaFDh1C7du0y22VlZWHw4MHo0qULLl686HY/+LYFY6xSlO4v6OyDMcZYCVfH0dKxNCcnR/EoLCyUzpGfn4/Vq1dj5syZeOCBB9CoUSMkJiaiUaNGSE5Ovmn/Ro0ahWeeeQaxsbHlcr38F4AxVimsQuXSgzHGWAlXx9HSsTQiIgKBgYG2R1JSknQOs9kMi8UCHx9lfnej0Yht27aV2beFCxfixIkTmDRpUrldr3cvD2CMeS2rC3dOvXWbFsYYux1cGUdL2wHA2bNnYTL9vc7NYDBIdQMCAhAbG4upU6eiadOmqFmzJpYtW4YdO3agUaNG5PGPHj2KCRMm4Mcff4RWW35TTf4LwBirFKU5s519MMYYK+HqOFo6lppMJsWDmrQCwJIlSyCEQO3atWEwGPD+++/j6aefhpqI67FYLHjmmWcwefJkNGnSpFyv17vvtGo0ioQCKiooiipzFZGUQBjkl9DiL//SiwLlnemLAomgKyLAyuGgK19iA38fIuiKSBwAu4AqTb78uqmJRAJkcBYVDycvk4HQEq+nDxEBpSGugQrEogLx7CY5KuLrZUEkAyADvYi3kplImkBFKFEBa9RrUp7BTeQ36e4c3/5SPSO2jDHG2G3WsGFDbN26FdevX0dOTg5q1aqFp556Cg0aNJDq5ubmYu/evdi/fz/GjBkDALBarRBCQKvVYuPGjejcubNL/fDuSStjzGtZoILFyVm0s/UZY+xO5so4WtrOFX5+fvDz88PVq1eRmpqKmTNnSnVMJhMOHDigKPvoo4+wefNmrFq1CvXr13fp3ABPWhljlcSVr/t5eQBjjP3N1WVTzrZJTU2FEAJRUVE4duwYxo8fj+joaAwdOhQAkJCQgHPnzuHTTz+FWq1G8+bNFe1DQ0Ph4+MjlTuLJ62MsUphgfOf9olVFowxVmW5Mo6WtnNGdnY2EhIS8OeffyI4OBj9+/fHtGnToNOV7Dd/4cIFnDlzxul+OIsnrYyxSsF3WhljzD0Vdac1Li4OcXFxZf580aJFN22fmJiIxMREp85J8epJq0qrgUp9i0ug0ikRn0oEkcUKOuWxrT5yMJXFRARYEZmuCoKIoKtABwOsjHKZhQiwshqIgCUqiVc+kTmqSFmmKXQsmIj6gEedkzoeVPI/mmIisEmldzA4i9gMwz7ozEol4bISrweVhYsoo95eVvktAYsPcQ4zFQBG9M/BD9HS6+7oh2+qniP/bHh5KWOMsQrk1ZNWxpj3ciX/tbP1GWPsTubKOFrazhvxpJUxVikEVLA6ebtW8O1dxhizcWUcLW3njXjSyhirFHynlTHG3MN3WhljrALcmP/amTaMMcZKuDKOlrbzRt49abUKADdE1miIYCoNFZwjX7bwl6OdzAHKzFZmP7ldUYB8/EKTXEYFXRUFSkWwGIkAIyLoiAoeUhXLZRqz3FRTcOsgKxURsORwhiUHA3tURN/URCYuK3H9Kj0RsaQlXju7bFdkJi2iH4KKxCJecwr1AdbiI5dRGbE0jr7ut1sFnNPiQs5sV3JsM8bYncqVcbS0nTfyzl4zxhhjjLEqxbvvtDLGvBYvD2CMMffw8gDGGKsAVqhhdfLLHmfrM8bYncyVcbS0nTfiSStjrFJYhAoWJz/tO1ufMcbuZK6Mo6XtvJF3T1rVKkD996cFYTRIVYSvXGbxlVMWkUFWgcqyIn8ig5O/Y1mtigPkwB6qTPjIAUYqs3xeXdats1qVHFAuojI7qYuVz30uU+mf5KKCEPmcFvklJ6mIoChNPnFatRxgRyVsorJk2ae2ElSwFvGvQFCBbkT6KzUV2EUEcVEZsczE70tlcTBLFqUcPzg7Mp65O+bx8gDGGHNPVVse4J33hxljzAEWiwUTJ05E/fr1YTQa0bBhQ0ydOhWCTO/MGGPMk3n3nVbGmNcSQg2rkxtcCyfrz5gxA8nJyVi8eDFiYmKwd+9eDB06FIGBgRg7dqxTx2KMMU/jyjha2s4b8aSVMVYpLFDB4uSGsM7W3759O/r164fevXsDAOrVq4dly5Zh9+7dTh2HMcY8kSvjaGk7b+SdU23GmNezir/XYzn+KGmbk5OjeBQWEpkaALRv3x7fffcdjhw5AgD45ZdfsG3bNvTs2bOiLpMxxm4b18bRv8dSb+Pdd1p1WkD99yVYA32lKkVBclRQcQARdEUGWdk99yOCaeRTklmtLD5EAJDOsfRHKjJgR25KRyfJrDq5ojZPeY7qv12X6miu5kllWXfXkMqyGxBZrYjgLCrrlprK6kUEZ5n1xKdEKouVHSpISmioYCqqrVxGXYOjEUpWOR4QVuK6NIWOBcW52A0yMI8qK+91+1YXvtYqrR8REaEonzRpEhITE6X6EyZMQE5ODqKjo6HRaGCxWDBt2jQMHDjQ5X4zxpincGUcLW3njbx70soYq5LOnj0Lk8lke24w0FtWrFixAikpKVi6dCliYmKQnp6OcePGITw8HPHx8RXVXcYYY+XAqal2cnIyWrZsCZPJBJPJhNjYWHz77beKOjt27EDnzp3h5+cHk8mEBx54APn5f98qu3LlCgYOHAiTyYSgoCA899xzuHbtWvlcDWPMa1ihcukBwDYGlT7KmrSOHz8eEyZMwIABA9CiRQsMGjQIr7zyCpKSkiryUhV4HGWMlRdXx1FrVVjTWqdOHbz99tvYt28f9u7di86dO6Nfv344ePAggJKB9uGHH0b37t2xe/du7NmzB2PGjIH6hr1UBw4ciIMHDyItLQ3r1q3DDz/8gBEjRpTvVTHGPF7pptjOPpyRl5enGH8AQKPRwGql1nVUDB5HGWPlxdVxtEokF+jTp4/i+bRp05CcnIydO3ciJiYGr7zyCsaOHYsJEybY6kRFRdn+//fff8eGDRuwZ88etG3bFgAwd+5c9OrVC++++y7Cw8PduRbGmBdxZ02ro/r06YNp06ahbt26iImJwf79+zFr1iwMGzbMqeOUJx5HGWPlhde0OshisWDlypW4fv06YmNjkZmZiV27dmHgwIFo3749jh8/jujoaEybNg0dOnQAUHIHISgoyDbQAkDXrl2hVquxa9cuPPbYY+S5CgsLFdHBOTk5AACh10No/o5msfgQAVZBcll+dfmXVRRIBFkZlc+pACYr8Qpa9USwD/H+UBfKhVRWK3WR3JbKJkUizmt/XSVlyj5nN5QjzKrvyJHKAk7KAVsFwXJKsHwic5Zbe1dQgUhmKiPYrV8nMuiKypxFHEsQIZgqIpsWHIu5I99P9tnKAAcD8dz4IE33TVlopa7TCVa4kBHLyYuaO3cuJk6ciBdffBGZmZkIDw/HyJEj8dZbbzl1nNvFE8ZRxpj3cmUcLW3njZyeNhw4cAD+/v4wGAwYNWoU1qxZg2bNmuHEiRMAgMTERDz//PPYsGEDWrdujS5duuDo0aMAgIyMDISGhiqOp9VqERwcjIyMjDLPmZSUhMDAQNvDPnKYMeZ9hAtrsISTA21AQABmz56N06dPIz8/H8ePH8e//vUv6PXE1g0ViMdRxlh5cGUcdWUs9RROT1qjoqKQnp6OXbt24YUXXkB8fDwOHTpkWyM2cuRIDB06FK1atcJ7772HqKgofPLJJ251MiEhAdnZ2bbH2bNn3ToeY4xVJh5HGWPMeU4vD9Dr9WjUqBEAoE2bNtizZw/mzJljW3/VrFkzRf2mTZvizJkzAICwsDBkZmYqfm42m3HlyhWEhYWVeU6DwVBmdDBjzDuVbnLtbJs7AY+jjLHy4Mo4WtrOG7m9EtdqtaKwsBD16tVDeHg4Dh8+rPj5kSNHEBkZCQCIjY1FVlYW9u3bZ/v55s2bYbVa0a5dO3e7whjzIqUBBM4+7kQ8jjLGXOHqOOqtY6lTd1oTEhLQs2dP1K1bF7m5uVi6dCm2bNmC1NRUqFQqjB8/HpMmTcJdd92Fu+++G4sXL8Yff/yBVatWASi5W/Dwww/j+eefx7x581BcXIwxY8ZgwIABrkW8ajWARmN7ajVopCrFRvkXUxgkf8IorE4EWdkFVFFBUlSADRUkRQXTkGVU9isqc5SZOq9cZnFw6Z4lQNk4K0p+LbUFNeWyfLlzjl4rlRHK0WU2KiroypHAIKoKlSVL7XqWLCpITEXFiBFtrTq5zEK+n4gAMLsiMlsXgeqHxXDr7G8WOnOqw6rqnVaPG0cZY16rqt1pdWrSmpmZicGDB+PChQsIDAxEy5YtkZqaim7dugEAxo0bh4KCArzyyiu4cuUK7rrrLqSlpaFhw4a2Y6SkpGDMmDHo0qUL1Go1+vfvj/fff798r4ox5vFc2eDaWyNeb8TjKGOsvLiaKMDZNrm5uZg4cSLWrFmDzMxMtGrVCnPmzME999xD1v/iiy+QnJyM9PR0FBYWIiYmBomJiejRo4fTfb2RU5PWBQsW3LLOhAkTFPsL2gsODsbSpUudOS1jjN0xeBxljHmb4cOH47fffsOSJUsQHh6Ozz77DF27dsWhQ4dQu3Ztqf4PP/yAbt26Yfr06QgKCsLChQvRp08f7Nq1C61atXK5Hy7v08oYY+6oqssDGGOsvFTE8oD8/HysXr0aX331FR544AEAJdvyff3110hOTsa//vUvqc3s2bMVz6dPn46vvvoKX3/9NU9aGWPehyetjDHmHncnrfZJRqhdRsxmMywWC3x8fBTlRqMR27Ztc+x8Vityc3MRHBzsdF9v5N2TViFKHqVPqWAXOZ6IDnbxkaNWhF0glsosR6xoConAKSqDFREkRAVOUWWGK3LQjV+m3F8zETyTFyr32aqngr2ULxSVmekqEZylKSBeYAr1b4oKWCKuX0O8nlDL12UxEAfU2JVRmbSoMgcDp6j3l4rIkkVFYjn63qRQgWL2wXlUsBZ1XWZfubDIJNez2GVNsxZQL5zjeNLKGGPucXfSap9kZNKkSUhMTFSUBQQEIDY2FlOnTkXTpk1Rs2ZNLFu2DDt27LBt3Xcr7777Lq5du4a4uDin+3oj7560Msa8Fk9aGWPMPe5OWs+ePQuT6e+7FGXt5bxkyRIMGzYMtWvXhkajQevWrfH0008rtt4ry9KlSzF58mR89dVXUjY/Z3nnRl2MMcYYY8wtJpNJ8Shr0tqwYUNs3boV165dw9mzZ7F7924UFxejQYMGNz3+8uXLMXz4cKxYsQJdu3Z1u788aWWMVQoBuJAvmzHGWClXxlF3xlI/Pz/UqlULV69eRWpqKvr161dm3WXLlmHo0KFYtmwZevfu7eIZlXh5AGOsUvDyAMYYc09FJRdITU2FEAJRUVE4duwYxo8fj+joaAwdOhRASdKUc+fO4dNPPwVQsiQgPj4ec+bMQbt27ZCRkQGgJHgrMDDQ6f6W8u5Ja7EZuCGASFNMZWeSP09oiKxTmnwisEfYpxgi+kDcq1Y5mNWKQmW6CvhTjk7y/y1DKisOryaX+ftKZUVERjD7jFWCeGcUBcqvpdoo11MXEy+Uo4FY1Mc/KiNUEZHFigpssv/9OJI1qyxE5wQVYOVGliwqAM7hj8R2x7Nq5RNQWciK/eUy+6CrkrZ2gVhu3vfkSStjjLmnoiat2dnZSEhIwJ9//ong4GD0798f06ZNg05XEj184cIFnDlzxlZ//vz5MJvNGD16NEaPHm0rj4+Px6JFi5zubynvnrQyxrwWT1oZY8w9FTVpjYuLu2nkv/1EdMuWLU73yRE8aWWMVQqetDLGmHsqatLqKTgQizHGGGOMeTy+08oYqxRCqCCc/LTvbH3GGLuTuTKOlrbzRl49aVXlF0Cl/jsYRJMjRwUZcuQUQ8X+RIAKEbRSbBf/RAb6EK+gUBMBS8VyPRURYEQdrzBIviHuZ5AjatSFchQXFRREZY6yz8QkdEQdImuYmghg0+XK56TSlemuy9WsxGssiOAhKrBNTQTA2Z+WCvQiA6fcQAdiOZZ2i7ou6njk+87utaPamYkAKzLoisjMRQbJuaF06xVn2zDGGCvhyjha2s4befWklTHmvXhNK2OMuaeqrWnlSStjrFLw8gDGGHNPVVsewIFYjDHGGGPM43n1nVZx7TqE6u/Fohq9vBBP7yeX+fjIuXWFmpi/230SMftRG67Lzaj1htRaRUfXLxaa5MLrjYPl8+qIdbnE+l0Qa27ty4SWqKOXO0zlTLDmywtTfS7L9WocKJLK8kLkFy+nnnz9Qk0lSKAWrCrrUeuSoXFssabKrcQEVJmDGQeotya1ztWuKfU7pNaqUn2jklyo7JNGFLj3SZ2XBzDGmHt4eQBjjFUAXh7AGGPuqWrLA3jSyhirFMKFOwTeOtAyxtjt4Mo4WtrOG/GklTFWKQTK2AnsFm0YY4yVcGUcLW3njTgQizHGGGOMeTyvvtMqioqUcTa516Q6uity0JWPXo7GERo5QkUK9iGCZMxEMA0Z7OPgxxqqbVGgXJbVkIr2kovMPkQ1i1wG++QCVCAWkQxBXSB/7qGO73NJPp7P/tNSmSaqtlR2rY6vVEYFwFHJGtR2Lzz1iVRQAVaOfnNCxVJRv2tHf//UeR38aCnsAsqo9xIZ+0UkZXCkv1QgoTOsUEHFyQUYY8xlroyjpe28kVdPWhlj3osDsRhjzD0ciMUYYxXAKlRQ8ZZXjDHmMlfG0dJ23ognrYyxSiGEC4FY3ho9wBhjt4Er42hpO2/Ek1bGWKXg5QGMMeYeXh7gRYTZAqG6IXVPfoFUR50tB2fpdUQgltZPKrNqtXbPicxMGiI4y0gEZ5FZjeR6VDARFXRURGQ2ogKgqGAZjUOZjIgAK/uMSAC0xLG08ksOvww5+5VKI5/DapB/NxYqmIwKKKICg+yC5wTRkHo1yH/PVLwWmRKMqic3djhgiypzpNNWN66VeL9a9MrjWb120xTGGGPeiLe8YoxVitI7BM4+nFGvXj2oVCrpMXr06Nt0VYwxVnFcHUf5TitjjDmhIgKx9uzZA4vl768gfvvtN3Tr1g1PPvmkU8dhjDFPxIFYjDFWASoiECskJETx/O2330bDhg3RqVMn5w7EGGMeiAOxGGOsApQMts4GYpX8NycnR1FuMBhgMMiJRG5UVFSEzz77DK+++ipURKIQxhjzNq6Mo6XtvNEdNWkVRcVyGZElS62Vg32o4Cyrzqh4btFRQVJyGRU4ZDFQwVlyW00RlbLJsSAelXz50BFBUdo8ubHFoDxHcQBxrdS7hfi3opFjrmDxkZdPX29VVyrLbkhFmBHnJYKdqGA3R45FZjCjmlKBbmQZ8fuiArbcCLqirlV6T1BvJer4xPWb/eQOa0PylefLkwMfK0pERITi+aRJk5CYmHjTNl9++SWysrIwZMiQ29cxxhhjt80dNWlljHkPd7a8Onv2LEwmk638VndZAWDBggXo2bMnwsPDnesoY4x5KN7yijHGKoAAfWP5Vm0AwGQyKSatt3L69Gls2rQJX3zxhZNnZIwxz+XKOFrazhvxpJUxVikqMrnAwoULERoait69e7vUnjHGPBHfaWWMsYrgzq1WJ1itVixcuBDx8fHQannIY4zdQarYrVbvHsE1GkB1QxSJRY6KsRYWSmXqHDk6SaMhgrMMypfHbJSjX8y+cjuzkQjOIrJaCZ38rrESUTeqYiKzkdmxT0m663Lban/kSWXay9cVz4vC5a9ec+rK6wbzwuR+FPvL/bgaJb/VLETMlZUIWCNTNmkdrOcIB7NrUa+52kzUI4Kz3BogHMzO5Ug0KJVdzRwkX0RAqPxvJNykjNg3Xy/EyVufstJt2rQJZ86cwbBhwyq7K4wx5pVyc3MxceJErFmzBpmZmWjVqhXmzJmDe+65p8w2W7ZswauvvoqDBw8iIiICb775ptuBsJwRizFWOVzJ4OLCB5Pu3btDCIEmTZrchotgjLFK5Go2LCfH0uHDhyMtLQ1LlizBgQMH0L17d3Tt2hXnzp0j6588eRK9e/fGQw89hPT0dIwbNw7Dhw9HamqqW5fr1KQ1OTkZLVu2tAVBxMbG4ttvv5XqCSHQs2dPqFQqfPnll4qfnTlzBr1794avry9CQ0Mxfvx4mM3E7SrG2B2tdFNsZx/ejsdRxlh5cXUcdWYszc/Px+rVqzFz5kw88MADaNSoERITE9GoUSMkJyeTbebNm4f69evj3//+N5o2bYoxY8bgiSeewHvvvefW9Tq1PKBOnTp4++230bhxYwghsHjxYvTr1w/79+9HTEyMrd7s2bPJzbstFgt69+6NsLAwbN++HRcuXMDgwYOh0+kwffp0ty6EMeZdKjIQy5PwOMoYKy/uBmI5kqjFbDbDYrHAx0e5Cb3RaMS2bdvI4+/YsQNdu3ZVlPXo0QPjxo1zuq83cupOa58+fdCrVy80btwYTZo0wbRp0+Dv74+dO3fa6qSnp+Pf//43PvnkE6n9xo0bcejQIXz22We4++670bNnT0ydOhUffvghioqIHekZY3eu0q+onH14OR5HGWPlxtVx9H9jaUREBAIDA22PpKQk6RQBAQGIjY3F1KlTcf78eVgsFnz22WfYsWMHLly4QHYrIyMDNWvWVJTVrFkTOTk5yM/PJ9s4wuVALIvFgpUrV+L69euIjY0FAOTl5eGZZ57Bhx9+iLCwMKnNjh070KJFC8WF9OjRAy+88AIOHjyIVq1akecqLCxE4Q0BVaWfDFQaNVQ3BGIJK3G/mwjOEkRwFnKvS0UaX+WnCr2f/HIV+8rzfouP/IdVEK80Vc9KZCci/0wTKbFUVuKuDLHnuop4nawnziie687KHQ40R0llhcFGuSxIPqfZSGQEozJRkR+jiN8rFShlkeup7bJTqYqJV5P6VpUKziLqqR3MkkVyMNMVOU9zIHOWWf7VQNSSs1jVDM6VyvQa+SIKzMrIObOZSvPlOFe+7r8TlgfcyBPGUcaY93J12VRpG0cTtSxZsgTDhg1D7dq1odFo0Lp1azz99NPYt2+fK912mdOBWAcOHIC/vz8MBgNGjRqFNWvWoFmzZgCAV155Be3bt0e/fv3ItmXNvEt/VpakpCTFJwH7FI6MMeZNeBxljHmC0rX1pY+yJq0NGzbE1q1bce3aNZw9exa7d+9GcXExGjRoQNYPCwvDxYsXFWUXL16EyWSC0UjcUXGQ03dao6KikJ6ejuzsbKxatQrx8fHYunUrjh07hs2bN2P//v0ud6YsCQkJePXVV23Pc3JyeMBlzNtV0D6tnojHUcZYuajgfVr9/Pzg5+eHq1evIjU1FTNnziTrxcbGYv369YqytLQ02zdKrnJ60qrX69GoUSMAQJs2bbBnzx7MmTMHRqMRx48fR1BQkKJ+//790bFjR2zZsgVhYWHYvXu34uelM3Hqa7BS1MJgxph3q6qBWACPo4yx8lFRGbFSU1MhhEBUVBSOHTuG8ePHIzo6GkOHDgVQ8qH43Llz+PTTTwEAo0aNwgcffIDXXnsNw4YNw+bNm7FixQp88803Tvf1Rm7v02q1WlFYWIgJEybg119/RXp6uu0BAO+99x4WLlwIoGTmfeDAAWRmZtrap6WlwWQy2b4aY4xVIcLJxx2Kx1HGmMucHUddGEuzs7MxevRoREdHY/DgwejQoQNSU1Oh05XEOly4cAFnzvwdG1O/fn188803SEtLw1133YV///vf+O9//4sePXq4c6XO3WlNSEhAz549UbduXeTm5mLp0qXYsmULUlNTERYWRn7Kr1u3LurXrw+gZJPvZs2aYdCgQZg5cyYyMjLw5ptvYvTo0a7dAVCpSh6lTzXyHJz6NCGI4CxVsRx1q76ujHDTZckpnAxEliyLQY4wsmqJfqiJgCgiSxQZsEP85qxEgFVhNbnx1Sg/qax6fkPFc3WOnDWrsLrcObOPVAShkfthIQKxLP5ExBLx+1Lnya+xpoDIHEYEotkHT1FBUlT2KwrVlgrEciRICqCDrihUPatePklxgLJMBMvv6cAAOWqz2EK8h61ymV6rfDHNRB1nVNU7rR43jjLGvFZF3WmNi4tDXFxcmT9ftGiRVPbggw+W+1InpyatmZmZGDx4MC5cuIDAwEC0bNkSqamp6Natm0PtNRoN1q1bhxdeeAGxsbHw8/NDfHw8pkyZ4lLnGWPM2/A4yhhjrnFq0rpgwQKnDi6IfRgiIyOlxbmMsSqoigZi8TjKGCs3FRyIVdlc3qeVMcbco0IZuxDfog1jjLESroyjpe28D09aGWOVo4reaWWMsXLDd1q9mFoODFFZ5Sgb6us2UUykO8q9pniq0ckvl8Eol5l9qOAsIvuVjsqcRQRnUZmjiOAhOmBHLrteWz6v2RikeK42B0l18kPkdsWBcn/NvkTngoqlIp1efs2L84lItHzi90oEQGmIRGdq+0As4tfscIAVFbDlaFYr4l8atQ6e+l1T2cSKg+XOqIOUgVdarXwRhcVyRzQa+Vg+OvmF0qmV9VRq9zJi8aSVMcbcVMUmrW5vecUYY4wxxtjtdmfdaWWMeQ+hom8336oNY4yxEq6Mo6XtvBBPWhljlUKIkoezbRhjjJVwZRwtbeeNeNLKGKscvKaVMcbcU8XWtHr1pFWl0UCl+jtyhcp05WhwFoi2olAZ2KLOvS7V0frKGWj0vkRwlpEKfiLK5GRVsBocC3hRm6kIIOJ4xG89P9SuL8ShzL5E0FV1IsDKVy6DisiIVUxEHRXIZZpC+XXS5lNl8uHU9l0hXkoVkUmMCsSivk0hs1qpiAA7ohqV/YwKbCs2ERncfIn3q11TC5HpSkX8Hgw6+UXxN8hRbQF6ZVmxWc645RReHsAYY+7h5QGMMXb7qQT5WeaWbRhjjJVwZRwtbeeNePcAxhhjjDHm8fhOK2OscvCaVsYYcw+vaWWMsQrAa1oZY8w9vKbVi6hVyqAXKirGweAskl1bUSQHnqiuF0hl+hw5DZXZVz5nsa8cdGT2k99IFh8H31yOJihy4HBWHRF05S+/lhojkWKKYC4k3mq5ciSSLkd+nXS5cod116QiaAqJgCq7QCxqHQ/5b5cqo+LcHCwzG+WyoiDiNQ6gUn1RGdzkk9gHYqmJACuKmshspSci0Xy1yvd/sdbdQCzwnVbGGHMH32lljLEKwJNWxhhzTxWbtHIgFmOMMcYY83h8p5UxVjn4TitjjLmnit1p5UkrY6xycCAWY4y5hwOxvJeKykSkIbIuURmxqES8dvVEkZzpSZ0nB2JpcuVALIMPEXRFBFhZfIgAG7Vcj8qmRAUPkYFCVGCPXfeodioi+MdCBFMRoURQ58vXr8uWj6fPltvqc+X+auSETVCbqSgrojP2Vai3iJZ6LxFtiXrF/nK9IiLTFRXspiomzktdg/bWF6ZSy3V0Ovm346OTg+kMWrnMqFG+/zVSujHncHIBxhhzT1VLLnBHTVoZY16Elwcwxph7qtjyAA7EYowxxhhjHo8nrYwxxhhjzON59/IAlbrkYUOtpnSdsF9MSCQXEHn5UplaKy9+1BMJDaw6Yv2qRl7TqCIWTFPrJi16YrN6X7nM4ie/TvbnUOfL59QUEOsti+VrVVmIZABEggDDVakI+hxiHWa+vAZZRf2qHVjTayVeX2r9LsWik9sWBcj1zH7EWlXiqxg1sX6VTAdAraUlvttR2a1VdnT9qr9Ofl/bJxIAAD+NskyncXNNK1xY0+rWGRljrHJ11z+teG4WFT+OlrbzRnynlTFWOUqjXp19OOncuXN49tlnUb16dRiNRrRo0QJ79+69DRfEGGMVzNVxlHcPYIwxJ1RAINbVq1dx//3346GHHsK3336LkJAQHD16FNWqVXPyxIwx5oGqWCAWT1oZY5WjAiatM2bMQEREBBYuXGgrq1+/vpMnZYwxD1XFJq28PIAx5nVycnIUj8JCYuNeAGvXrkXbtm3x5JNPIjQ0FK1atcJ//vOfCu4tY4x5L4vFgokTJ6J+/fowGo1o2LAhpk6dKsf92ElJScFdd90FX19f1KpVC8OGDcPly5fd6suddaeV2IRfReURIIKiYCGCk+ySFQiLfDCRLwdiQcj11Fb5l2vQUokEjPLxqF8TsR7FWo0o8yEilvTEddgnDnAwOokKJtLlyGXGS8T1Z8n90OYTAUYW4h8GGXRFXL/erox4Ka1EgFWxr1xmJoLfBHE8OsCKSOjg4JIiKhmEivgdavXKICujQQ6mMvnIyTACDfJ7OFAnl5m0yrJCbeUlF4iIiFCUT5o0CYmJiVL9EydOIDk5Ga+++ir+7//+D3v27MHYsWOh1+sRHx/vYs8ZY8w16iYNlM8thcAfrh+vIpILzJgxA8nJyVi8eDFiYmKwd+9eDB06FIGBgRg7dizZ5qeffsLgwYPx3nvvoU+fPjh37hxGjRqF559/Hl988YXzHf6fO2vSyhjzHm4sDzh79ixMJpOt2GAwkNWtVivatm2L6dOnAwBatWqF3377DfPmzeNJK2PM+1XA8oDt27ejX79+6N27NwCgXr16WLZsGXbv3l1mmx07dqBevXq2SW39+vUxcuRIzJgxw4XO/o2XBzDGKodw8QHAZDIpHmVNWmvVqoVmzZopypo2bYozZ87chgtijLEK5uo4+r+x1JGlVu3bt8d3332HI0eOAAB++eUXbNu2DT179iyzW7GxsTh79izWr18PIQQuXryIVatWoVevXm5dLk9aGWOVovRrLWcfzrj//vtx+PBhRdmRI0cQGRlZjlfCGGOVw9Vx9MalVoGBgbZHUlKSdI4JEyZgwIABiI6Ohk6nQ6tWrTBu3DgMHDiwzH7df//9SElJwVNPPQW9Xo+wsDAEBgbiww8/dOt6eXkAY+yO9corr6B9+/aYPn064uLisHv3bsyfPx/z58+v7K4xxlilc2Sp1YoVK5CSkoKlS5ciJiYG6enpGDduHMLDw8tcZnXo0CG8/PLLeOutt9CjRw9cuHAB48ePx6hRo7BgwQKX++vdk1aVShl8ZaVuHDuYJUvlQFQMEehDRs8V0JHM9jRE5iwDdQ4iOMuqkdtSAUVCI78mlgK5zD5gjbqjRd3k0ubJ5/S9KNf0uyhnYtJQma6I11MQvxvyWsnXTvmcympl9pGKYKW/bZao5MuiUf/SqGAyHfEqE0FXOqMcBOXvqwyyCvaVg6mq+1yXyoL1eVJZkFYuq6ZTti0gsms5xZUNrp2sf88992DNmjVISEjAlClTUL9+fcyePfumdwgYY8xZ3TRxUpmmWROpLK9eoOK5ubjArUAslxMF/K9N6RKrmxk/frztbisAtGjRAqdPn0ZSUlKZk9akpCTcf//9GD9+PACgZcuW8PPzQ8eOHfGvf/0LtWrVcr7P8PZJK2PMe1XAPq0A8Mgjj+CRRx5xviFjjHm6CgjEysvLg9pu1yWNRgOrlUw8bmuj1SqnmJr/3Wy71VZZN8OTVsZYpXBnyyvGGGMVs+VVnz59MG3aNNStWxcxMTHYv38/Zs2ahWHDhtnqJCQk4Ny5c/j0009tbZ5//nkkJyfblgeMGzcO9957L8LDw53v8P/wpJUxVjkq6E4rY4zdsSrgTuvcuXMxceJEvPjii8jMzER4eDhGjhyJt956y1bnwoULil1ZhgwZgtzcXHzwwQf4xz/+gaCgIHTu3NntLa940soYY4wxxkgBAQGYPXs2Zs+eXWadRYsWSWUvvfQSXnrppXLti3dPWlUqZQAVFYdFLVCmMixR7DNnEVmzQGS6EtRHGCo4KydXKiKDs3RymdDqpTKVkOtp86kgJrkrjiTAUssJlmC8LK9p8c2Qg4Q0+Y4F7QgNEUyll6+LCpyjslNZ7DJiWeSXjUQFWJGxekTXiF8DrFTffIjMZEb5Pab3k1/4agFyoFQNX2WgVIjPNalOsE4OxKqmk4/lr5EzZ/molL9XrdrdQCwXvtbiO62MsUrWM+Jlqcx6/11S2fUwOaK3IEj5x9ZS5OY0zMXlAd46lnr3pJUx5r14eQBjjLmnApYHeBKnkgskJyejZcuWti0SYmNj8e233wIArly5gpdeeglRUVEwGo2oW7cuxo4di+zsbMUxzpw5g969e8PX1xehoaEYP348zGY379gwxryPG1lcvBmPo4yxcuNmRixv49Sd1jp16uDtt99G48aNIYTA4sWL0a9fP+zfvx9CCJw/fx7vvvsumjVrhtOnT2PUqFE4f/48Vq1aBQCwWCzo3bs3wsLCsH37dly4cAGDBw+GTqez5QZnjFUNVXX3AB5HGWPlpSJ2D/AkTk1a+/Tpo3g+bdo0JCcnY+fOnXjuueewevVq288aNmyIadOm4dlnn4XZbIZWq8XGjRtx6NAhbNq0CTVr1sTdd9+NqVOn4vXXX0diYiL0egcXHDLGmJficZQxxlzj8ppWi8WClStX4vr164iNjSXrZGdnw2Qy2TaY3bFjB1q0aIGaNWva6vTo0QMvvPACDh48iFatWpHHKSwsRGHh34FMOTk5Jf+jUpc8bIiNblVE9icqeIY6sd3GuSoq+IdoKaiALUH0LV8OdlHnyoEyWp38azIQQUHqIjnCypIjX79Ve+vsGepi+bp01+Xr0mXJAWaqYuJaqQArrdw3Qfy+qCAx6hqobFf2be0zfwGAmvp1UQtniLkAGfzlI792Fl8i6MpPPrEhQH49qaCrWn45Ulkd3yzF81C9HOhXTSu/v/zU8jl1qltnktNq+Otod3nEOMoYs+nhr8zwZL4nSqqT3TVSKisMJv4mOZBZ0VLoQjarKsypNa0AcODAAfj7+8NgMGDUqFFYs2YNmjVrJtW7dOkSpk6dihEjRtjKMjIyFAMtANvzjIyMMs+ZlJSEwMBA2yMiIsLZbjPGPE0VWodlj8dRxli5qGJrWp2etEZFRSE9PR27du3CCy+8gPj4eBw6dEhRJycnB71790azZs2QmJjodicTEhKQnZ1te5w9e9btYzLGKlfpWixnH3cCHkcZY+XB1XHUW8dSp5cH6PV6NGrUCADQpk0b7NmzB3PmzMHHH38MAMjNzcXDDz+MgIAArFmzBjrd319Zh4WFYffu3YrjXbx40fazshgMBhgMDtxnZ4x5Fy8dON3F4yhjrNxUoXHU6Tut9qxWq22dVE5ODrp37w69Xo+1a9fCx8dHUTc2NhYHDhxAZmamrSwtLQ0mk4n8aowxdgerQl9p3QqPo4wxl1Sx5QFO3WlNSEhAz549UbduXeTm5mLp0qXYsmULUlNTbQNtXl4ePvvsM+Tk5NgW+oeEhECj0aB79+5o1qwZBg0ahJkzZyIjIwNvvvkmRo8eXT53AIggHqiJ34zVseAs+xRIQhDHshCRPQQyOKtYDmQReflyN7Tyr4lIagVNofwaWnXEa0IElKnsrkNVKPdXVXzr4BwA5EchoZGvQVCBbY4GbFFJsohfj33SJirAyuJOViuDfFKzkQjO85dfOx8i6Co4QA6UigjIksoifa9IZXUNlxXPw7TZUp0Atfz+8lHLGcysxAuVZfVVPFc5EKzFZB4/jjJWRfRsNF4qu/LEXYrn2Y3kdoWh8tin9ifG0SIiS2Wm8q+3tcBLZ4+VxKlJa2ZmJgYPHowLFy4gMDAQLVu2RGpqKrp164YtW7Zg165dAGD72qvUyZMnUa9ePWg0Gqxbtw4vvPACYmNj4efnh/j4eEyZMqX8rogx5hWq6j6tPI4yxsoL79N6EwsWLCjzZw8++CB9J9JOZGQk1q9f78xpGWN3Ile+ovLSgfZGPI4yxsqNq1/1e+lY6vI+rYwx5o6qeqeVMcbKC99pZYyxilBF77Qyxli54Tut3kOlUUOl/jtgRFBBUUSwD7lnAhGcBdgttiaPRQQ1CSKYiMq6ZCYWbhPZMdTX5cXcVA4NdZF8PLWaioqS3632gVgUoSGOpZX7JtRUlJRjrx19Yqq/xOtOBdPZH4rMriWXUZlMzL5EmR8VdCUH2FFBV9WJoKtwfzl4qoHvJamsoU+mVFZP/5fieYiGyH6lkvtGvfMLiBfKYveuU1OpxBhjzAM9HD1BKrvQM1wqy2pVpHheL/IvqU69ADkQ1k9TJJX9mRcklf0ilEk9rPny321WNq+etDLGvBjfaWWMMffwnVbGGLv9eE0rY4y5h9e0MsZYReA7rYwx5h6+08oYYxWAJ62MMeYenrR6EYMOUOttT1VmOTBEEMFJZFQUFRRkH1BFBKeoNEQgkpV6N1CRWEQQD5UlK1/OYgRBBE4V6qUiFRU8RQZF2dUjAqwcDpyijk+hAqzIoCuiTEu8dsR5LTplmUV+iWD2lduZ/eR6xQHya241EUFXJteDrhzJdAUAETqiTJujeB5C/L50KvmffAH178EqX2uAukDxXK12LBtcWXh5AGPsdugZ+YpU9le3CKksq6U8P4htelzx/NGQn6U6dbXyOH28OFQq26VqIJWdrlFN8dySV4g/pVqOq2rLA6jAYcYYY4wxxjyKd99pZYx5L14ewBhj7uHlAYwxdvvx8gDGGHNPVVsewJNWxljl4DutjDHmHr7T6kXUamUAEXE1VEiQkBNXAFYiGEWlXPKrIj6aUME/ZJYsKmDL4lhGIWGWg31QIBeBCOKCnog80sovlBSfQ2QIUxEBZuT7ngimogJ7iORMdNYtglVLBE8Z5bJif7vnfkQ7f6kIRSYi6CpI7rBvoBwkF2q6JpXV9pODrmobs6SyOvqrUlmYTm4bpMmT+2L3/vRX+0h1dETasCyz3N9sq04qK3c8aWWMuenhJq9JZVceqCOVZTeW25pqymNf84Dziucdfc5JdWpp5T8aqbk1pbJ9l+TgL4tdgLf9c6dVsUkrB2IxxhhjjDGPx5NWxlilULn4YIwxVsLVcdSZsdRisWDixImoX78+jEYjGjZsiKlTp0JQ36reoLCwEG+88QYiIyNhMBhQr149fPLJJ85eooJ3Lw9gjHkvXh7AGGPuqYDlATNmzEBycjIWL16MmJgY7N27F0OHDkVgYCDGjh1bZru4uDhcvHgRCxYsQKNGjXDhwgVYiaWCzuBJK2OsUvDuAYwx5p6K2D1g+/bt6NevH3r37g0AqFevHpYtW4bdu3eX2WbDhg3YunUrTpw4geDgYFs7d3n3pLWo2C4Qi8ji5GCglJT9qqTQgXZuZMmi3jVEpithduzdRd7up4K9yGAnuz47mv3KQgRYUa+5I1m4AHLBitUgFxb7ymVFAUQgll1ZUYD8WhabiNc3UM6U4k8EXYWZcqWyun5yMFV930tSWR29nFUlWCMHBvip5QxbVuJ9V2h3GcVEpiuq7JJFDrq6bPWVynQqZdsCKiubMyrgTmtiYiImT56sKIuKisIff/zh5IkZY5WtS6fpUlnmI7Wksmt1iUBaYkzXWeRx9HRBsOL5Fav89/yvIjkS+ruMKKns/LlgqUytV46jVjmm1jlu3mnNyVFmUjQYDDAYDIqy9u3bY/78+Thy5AiaNGmCX375Bdu2bcOsWbPKPPzatWvRtm1bzJw5E0uWLIGfnx/69u2LqVOnwmg0utDhEt49aWWMsVuIiYnBpk2bbM+1xO4ZjDFWFUVEKHc4mDRpEhITExVlEyZMQE5ODqKjo6HRaGCxWDBt2jQMHDiwzOOeOHEC27Ztg4+PD9asWYNLly7hxRdfxOXLl7Fw4UKX+8ujN2Os8lTA1/1arRZhYWG3/0SMMVYZ3BhHz549C5PJZHtuf5cVAFasWIGUlBQsXboUMTExSE9Px7hx4xAeHo74+HjyuFarFSqVCikpKQgMDAQAzJo1C0888QQ++ugjl++28qSVMVYp3FnT6shXWqWOHj2K8PBw+Pj4IDY2FklJSahbt64rXWaMMY/i7ppWk8mkmLRSxo8fjwkTJmDAgAEAgBYtWuD06dNISkoqc9Jaq1Yt1K5d2zZhBYCmTZtCCIE///wTjRsTG+c6gLe8YoxVDuHiAyVfaQUGBtoeSUlJ5CnatWuHRYsWYcOGDUhOTsbJkyfRsWNH5ObKa5EZY8zruDqOOjHRzcvLg9ouBkWj0dx0J4D7778f58+fx7Vrf8dpHDlyBGq1GnXqyMkfHOXVd1pFQSGE+u9XXkVlfyKQgULEOjcBuwxIZgcDT9zZ0uEW+57ZqhGBXVQAGKgy8njKPquIACsymMpKlFmIMp3cD6tW/sxk9pHrFQUQZaZbB10BQFGg8nUqDiSuyyQv0A8wyUFXtUw5UlmkvxxM1cg3UyprbLgolYVp5ExX9sFOAHBdyO/rLCJQKseqzIBVIOT+Bqrl46uldGg0++Avq4Pv1bK4c6fVka+0AKBnz562/2/ZsiXatWuHyMhIrFixAs8995zTfWaMVYyOfd+Ryi70JLL8RcnjaHUfOe3llSw5i1X+ebls418tFM9PNa4u1bmvxkmpjET9ySxW/j2zmh37G13mKSpg94A+ffpg2rRpqFu3LmJiYrB//37MmjULw4YNs9VJSEjAuXPn8OmnnwIAnnnmGUydOhVDhw7F5MmTcenSJYwfPx7Dhg3jQCzGmBdyY/cAR77SogQFBaFJkyY4duyY020ZY8zjVMA+rXPnzsXEiRPx4osvIjMzE+Hh4Rg5ciTeeustW50LFy7gzJkztuf+/v5IS0vDSy+9hLZt26J69eqIi4vDv/71Lxc6+zeetDLGqoxr167h+PHjGDRoUGV3hTHGvEJAQABmz56N2bNnl1ln0aJFUll0dDTS0tLKtS+8ppUxVilKv9Zy9uGMf/7zn9i6dStOnTqF7du347HHHoNGo8HTTz99ey6KMcYqkKvjqLcmauE7rYyxylEByQX+/PNPPP3007h8+TJCQkLQoUMH7Ny5EyEhIU6emDHGPFAFLA/wJN49aTWbAdXfN4sFESikojYSpwKKKPZBTFRwEogyKtMTEbSiIrJwCfvMVABUVHYqBwOsyIxYjmQycvA1ooLahI4IaqMCsYigK7MfEXTlTwVYyWWFQUS2qyDl9WuC5AX6gQFySpJaAY5luor0uSyVNdD/JZVFaOWArSC13JfrQn7tCoiMVdetcuCRRqX8vf5l8ZPqqCFn3NIR72EflRycJrVTeX5GrOXLlzt5AsbY7dRN/aRUVtjzHqkso708Fga0kMfbu0POS2UncuXgqb9y5XFUlyv/rbZPNnjktLzHc6BBDtStYZTH1gs+gVKZSq0cN62Q/w44hSetjDF2+7mzewBjjLGK2T3Ak/CaVsYYY4wx5vH4TitjrHJUwPIAxhi7o/HyAC+iVinXXhbJ6/CESr6ZrNI4doPZfr2mINqp7BfAQN6onzpWmX1TU5v6E/WoNafEullBbQBvIdbX2iVSoN7PZPIC6rqIehYf+a1W7C+XFZrka3V4/WqwvH5XF1SgeF498LpUp7a/vDl1Hd8suZ5BXtMarpPrBWnkc2iIVzTLKicNuEysQ821OrYRs8XuvUglIFAT61DDiP4GEOttC4Ty9+rumlaVEFA5maDA2fqMscrzcPURUllhL3n96uXm8nrTonB5DDLqzFJZ+l/hUtmVP4OkMv0V4u+XA0OY9i+5b/v0chrodvVPSWW1qst/W7LylQkSLFb5mpzhyjha2s4befeklTHmvfhOK2OMuYfvtDLG2O3HgViMMeYeDsRijDHGGGPMw/CdVsZY5eDlAYwx5h5eHuBFtHpAfUMwS2GhXMdKbK5PBWI5spk+FYhEBjoRq7up5ALEKQSRcABWB99dRAAYWUadF8rF5iod8RoRSROEVn5NBBF0ZfaTy4oC5OMVOhp0VU3+vRqC5Q2fa1XLUTyvFyBv8l/XKJeF6nKksiCNnIQgQC2fk3KZCIoqEPIC/2IiuYCFfKfI7IO97AOzACDX6iOV+ankgIcAtRzUWGx3PLWbox4vD2DsztH9nkSp7GqfaKnserg8nhVUp/6OyvXOnQuWytS58pipyycSDRFTARVxDqvdIEONOdZLcnKXo0Fylr2o4Eyp7FphTeXxqeBrJ1S15QHePWlljHkvvtPKGGPuqWJ3Wp1a05qcnIyWLVvCZDLBZDIhNjYW3377re3nBQUFGD16NKpXrw5/f3/0798fFy9eVBzjzJkz6N27N3x9fREaGorx48fDbHZvywfGmPcpvUPg7MPb8TjKGCsvro6j3jqWOjVprVOnDt5++23s27cPe/fuRefOndGvXz8cPHgQAPDKK6/g66+/xsqVK7F161acP38ejz/+uK29xWJB7969UVRUhO3bt2Px4sVYtGgR3nrrrfK9KsaY5xMuPrwcj6OMsXLj6jjqpWOpU8sD+vTpo3g+bdo0JCcnY+fOnahTpw4WLFiApUuXonPnzgCAhQsXomnTpti5cyfuu+8+bNy4EYcOHcKmTZtQs2ZN3H333Zg6dSpef/11JCYmQq+XN1tnjLE7CY+jjDHmGpfXtFosFqxcuRLXr19HbGws9u3bh+LiYnTt2tVWJzo6GnXr1sWOHTtw3333YceOHWjRogVq1vx7IXKPHj3wwgsv4ODBg2jVqhV5rsLCQhTeEGSVk1MSJKPSa6FS/x3MIqivxyzy6mtBBF2pdHJQjH3gERk4pZVfQhUROOXohxoVEThFxNPQma6ogC3h2CJvKduVmrhaIoBN6OXXjcp+ZfaTA7aKAuRzFJvk0xYHydegq1YgldUOlrOPNA1Ufq0a5Zsh1alJZLXyU8tBfVRgk4bICkUFWFFtrcQXHVQ9V1F9owK9soiMW1S2K/tALyrLl7O89Suq8uIJ4yhjt9JNO0DxPDdOzmp1pW+gVFYcQGSHpDI3UnG/efLfDBXxJ15lJv6eU/WIoCvqj7p9X8i+FcoNL2XIf7yCjHKgrq9eGeRqLpaDXp1VlcZRp/9CHjhwAP7+/jAYDBg1ahTWrFmDZs2aISMjA3q9HkFBQYr6NWvWREZGyUQhIyNDMdCW/rz0Z2VJSkpCYGCg7REREeFstxljnkYI1x53AB5HGWPlwtVx1EvHUqcnrVFRUUhPT8euXbvwwgsvID4+HocOHbodfbNJSEhAdna27XH27Nnbej7G2O1XlYIH7PE4yhgrD1UtEMvp5QF6vR6NGjUCALRp0wZ79uzBnDlz8NRTT6GoqAhZWVmKuwQXL15EWFgYACAsLAy7d+9WHK80Kra0DsVgMMBgkPdFY4x5MVeCAbx0oLXH4yhjrFy4GlTlpWOp2wvorFYrCgsL0aZNG+h0Onz33Xe2nx0+fBhnzpxBbGwsACA2NhYHDhxAZubfG+6mpaXBZDKhWbNm7naFMca8Eo+jjDF2a07daU1ISEDPnj1Rt25d5ObmYunSpdiyZQtSU1MRGBiI5557Dq+++iqCg4NhMpnw0ksvITY2Fvfddx8AoHv37mjWrBkGDRqEmTNnIiMjA2+++SZGjx7t2h0AnRZQ33AJRFCUKJADdlRWeeGzUMnzd5X94YiMUOSicio4SyoBBJWtijoHFZxFrUchgq4EEYhGse+fisoQRpVpiQAjg7yA3uxDBF35EWUB8nWpguSMTaFB16SyRqa/pLKmfucVzxvr5TV/VKarPKv8fswRcjYpRwOnqKArRzka8EQFXjniOnGtlAC18t+Su+EDKmvJw9k23s7jxlHGbiHr2XsVzzPvlyOdAmrKgbBF2XKQp+qSvLuFulj+W0Alh6T+/ZP5AqnEkjrHAsCkMqofxJCsuSoH4B4T8jcfftWVf28s+e7dO3RlHC1t542cmrRmZmZi8ODBuHDhAgIDA9GyZUukpqaiW7duAID33nsParUa/fv3R2FhIXr06IGPPvrI1l6j0WDdunV44YUXEBsbCz8/P8THx2PKlCnle1WMMc9XRZcH8DjKGCs3VWx5gFOT1gULFtz05z4+Pvjwww/x4YcfllknMjIS69evd+a0jLE7kCvBAN4aPHAjHkcZY+XF1aAqbx1LXd6nlTHG3OLKtiteuk0LY4zdFq5uX+WlY2n57WTOGGOMMcbYbeLVd1qFRgNxQyYnFZGdCVYiEKmYSJdRLAf7QCMH3kio4CQqmxRZRnxmcDBwisx+5SgqeKxIGVYjiCwdKgORHpI6lka+VqtWLrMQMSNmf/n6TQFyMF3dgKtSWQPjJaksQndZ8ZwKurISq/FzrPLvnsomRXE1IMqZ46nh2jmogDCqjArOsg8Iy6P+bTmhqi4PYMyTPdB7plR25SHl2Ocfel2qU1wsj49qIuhKk08EXVG3zxy9pUbFJDt4PKuWaqzsHzXmUDcp1dRwmCMHJefplH9brHLSLKdUxPIAi8WCxMREfPbZZ8jIyEB4eDiGDBmCN998kw7atvPTTz+hU6dOaN68OdLT053v7A28etLKGPNiVTQQizHGyk0FBGLNmDEDycnJWLx4MWJiYrB3714MHToUgYGBGDt27E3bZmVlYfDgwejSpYttP2l38KSVMVYp+E4rY4y5pyLutG7fvh39+vVD7969AQD16tXDsmXLpCQnlFGjRuGZZ56BRqPBl19+6XxH7fCaVsZY5ahC+bIZY+y2cHUc/d9YmpOTo3gUFhZKp2jfvj2+++47HDlyBADwyy+/YNu2bejZs+dNu7Zw4UKcOHECkyZNKrfL5TutjLFKwXdaGWPMPe7eaY2IiFCUT5o0CYmJiYqyCRMmICcnB9HR0dBoNLBYLJg2bRoGDhxY5vGPHj2KCRMm4Mcff4SWSLjkKu+etGo0JY9SWnnRs0onB2cJKoiJCIASZmXA1q2XG98EsVhZpZFvdJNZsihUYJcbcTHCbBeIlS8HP1EZx1TFRMYTs2P/gsjF8kTWkkCj3Jd6vpelslo6OTjLPogpy+Ir1cm1ytdgIX7bVMCWTuVeMJI9R4O4HMmwRWXroq6LoieqFQmN3XOHDsUY81APR0+Qyi4/WlMqsxiU49K1DH+pjv6K/PdXV0j83aP+/OqpyCa5iMqSRWbOcnBsUpmJ/tkXUIkriQxejrLkK18nkS+/bhXp7NmzMJlMtudUVr0VK1YgJSUFS5cuRUxMDNLT0zFu3DiEh4cjPj5eqm+xWPDMM89g8uTJaNKkSbn217snrYwx78WBWIwx5h43A7FMJpNi0koZP348JkyYgAEDBgAAWrRogdOnTyMpKYmctObm5mLv3r3Yv38/xowZAwCwWq0QQkCr1WLjxo3o3LmzC53mSStjrJLw8gDGGHNPRQRi5eXlQW23RadGo4G1jG+GTSYTDhw4oCj76KOPsHnzZqxatQr169d3ur+leNLKGKscVuH8fsPu7E/MGGN3GlfG0dJ2DurTpw+mTZuGunXrIiYmBvv378esWbMwbNgwW52EhAScO3cOn376KdRqNZo3b644RmhoKHx8fKRyZ/GklTFWOXh5AGOMuacC9mmdO3cuJk6ciBdffBGZmZkIDw/HyJEj8dZbb9nqXLhwAWfOnHGhI87x7kmrRl3y+B+hIwKFLMTtazOREYvKRGWfJYrsQzkvoqayZBHb/KiI2/JCJbdVEd0TDmTdEkVyhjAVEZylypPLNAVyYJOmSA6IU1kdW8xu1MrZuarp5IwsVLYr+yxW1wWRhotABV2pHQyScjVbVVmoTFyOBFRR10ChrosK4iqA8ndY6ODxPcnbb7+NhIQEvPzyy5g9e3Zld4exSnW9SXWpLD9UHg+0ecrxRnOFmDo4GBBFBU5RbanhRaiJA1LHIwKs1MSffTVRz5F2VPytlXhJ1FSizevKC1MVeP44GhAQgNmzZ990zFy0aNFNj5GYmCjtSuAK7560Msa8lgourGl143x79uzBxx9/jJYtW7pxFMYY8xyujKOl7byR50/xGWN3pgpMLnDt2jUMHDgQ//nPf1CtWrVyvhDGGKskbiYX8DY8aWWMVYrSqFdnH4BjWVxuNHr0aPTu3Rtdu3atgCtjjLGK4eo46q07sfCklTFWOYSLD5RkcQkMDLQ9kpKSyjzN8uXL8fPPP9+0DmOMeSVXx1EvnbR69ZpWoVZD3BC4pKKCmKgsWURmJ0EEbEkZsagALgoREOV4PSKIx9FgL+p2PxVzRZ1XKM9LBWtZibtZ6uv5UpkmR846pbsuB0Bp84nAsSK57HqxXiq7ZvGRyqiAJUcyTDkasERxNIMVVY8KdnL4HETbYnHr9wkVdKUhRi/qnPZZuKyVOOo5ksWltN7LL7+MtLQ0+PjI7xnGqjLjRWL8zpezXVnlIVjicHJAMsBKLrNqHQu6Is/rYGCXirjdaJ/tytGgKyuR1Ysaku2zcFFZuVjZvHrSyhjzXiohoHJyXVVpfUeyuADAvn37kJmZidatW9vKLBYLfvjhB3zwwQcoLCyEprx3AGGMsQriyjha2s4b8aSVMVY5rCC/WLhlGyd06dJFyswydOhQREdH4/XXX+cJK2PMu7kyjpa280I8aWWMVQp37rQ6KiAgQMrA4ufnh+rVq7udmYUxxiob32lljLGKwBmxGGPMPRWQEcuTePekVavMiAUr8VWfmVhFTQRigQjEUtkFI1HBWiqNgxk6qOAnIruHSkOtSCcWeBOnuN1EsRyIJq7LmanUuXLAiz5LzpKlz5Z/X9oc+fov5/pJZWeCgqWyWrosqSxMl614Tgcdye8RRwOsKPYBS4AT2amI72zIMgf6R2XNcjToypGsXm5n/nJlr8ByuDuwZcsWt4/B2J1g4663pLI2z82SyrIbK59TQUfUcEDGhjoY92ofEFVyQKKio9m0dHJjq5YYI+3+LlNZs6zE330iDpickkjt3F2h5Oqeq156p5W3vGKMMcYYYx7Pu++0Msa8lisbXHvrhtiMMXY7uJoowFvHUp60MsYqRyUtD2CMsTtGFVsewJNWxlilUFlLHs62YYwxVsKVcbS0nTfy6kmrUKkgVDcsktY6mBGLyPZEBUAJ+z0ciYxYoqhYPhaVyYMKsFIRK8h1ROoRK9FfuRZgJbJ6EQFgKjVRz6q2L5CPT5SRwVk516Qy3WU5EMsYrJPKCi7Lb8lr1eS2RwNCpLJQQ65UFqApUDz3U8tZvYqIlfAWokxPBGw5mtWKCoqijudoABh1XqmtI3UqE99pZczjhGy7KJXlhYUpnhcFyv8OtUXyGCeIf69WedgnA6w0VAJKQQRFGagAKyJQioqFLpLL7LNdCSJgmgz+kovIr+CJS3BPFbvTyoFYjDHGGGPM43n1nVbGmBfjfVoZY8w9vE8rY4zdfhWREYsxxu5knBGLMcYqAq9pZYwx91SxNa1ePWmVPmFQgU1EIJawX2kNQEVku5ICr6iF4URQF70gm1g+bB/oBQAaapU2UU9NZPqijke9Me2DriAHZ0mBWWUQ1PXn50tl6qs5UplPphxg5RsoX0OxSS7LMJmksqO+cnBWTZ3yvJH6S1IdRwOs3Am6cpRDAVYOcjXTlaPndDuoS4DMonPLNoyx22bD4RlS2f3931U8z2xDjI9EQBQViEQOG0SZyuL6OEqeg8xU6UCKLSpJJZXFijgW+SfD7vCCCtx2hivjaGk7L8SBWIwxxhhjzON59Z1Wxpj34jWtjDHmHl7TyhhjFUHAhTWtt6UnjDHmnVwZR0vbeSHvnrSarcoN78n1I8RCFmrtp45a52q3CzKx7pVa04liOeEAVETSAGpdDHU8IkEAVaZycE2rAHEOu86oiDrC6ti7nNpQWlzPk8q0f8nrXP0C5J2niwLk1y4nwEcqO+5bQyoLMyoTDgRq5H5U18rJECjUWlWNG//yyTWy1LqrchxcrMQ/EkfXuZY7DsRizCv4frlb+bx2rFTnWgSxppX4U6g2E0kIqA38qSLiTxwRkgAVNZBS62ZdHE6oNbNU3+h1tA7UcQYHYjHGWAWwwvkB24MSejHGWKVzZRwtbeeFnArESkpKwj333IOAgACEhobi0UcfxeHDhxV1MjIyMGjQIISFhcHPzw+tW7fG6tWrFXWuXLmCgQMHwmQyISgoCM899xyuXXPsbhdj7M5QuhbL2Ye343GUMVZeXB1HvXUsdWrSunXrVowePRo7d+5EWloaiouL0b17d1y/ft1WZ/DgwTh8+DDWrl2LAwcO4PHHH0dcXBz2799vqzNw4EAcPHgQaWlpWLduHX744QeMGDGi/K6KMcY8FI+jjDHmGqcmrRs2bMCQIUMQExODu+66C4sWLcKZM2ewb98+W53t27fjpZdewr333osGDRrgzTffRFBQkK3O77//jg0bNuC///0v2rVrhw4dOmDu3LlYvnw5zp8/X75XxxjzXKVrsZx9eDkeRxlj5cbVcdSJsdRisWDixImoX78+jEYjGjZsiKlTp5LxK6W++OILdOvWDSEhITCZTIiNjUVqaqrbl+vWmtbs7GwAQHBwsK2sffv2+Pzzz9G7d28EBQVhxYoVKCgowIMPPggA2LFjB4KCgtC2bVtbm65du0KtVmPXrl147LHHpPMUFhaisLDQ9jwnpySAR1VshurGXX41VGALsdhDTSwEJ9qqtHYvj1Ze8a2iNtcvKpLL7BMVAFAR/SCDxKj1KvZ9A5RBaba2cmMVUSa9+chAL6If1DmJgC3qNVFlyYFYhgyDVOYXECiVFQfIncnx95fKjgcog7PqG/+S6tTWXZXKqNe8QMhBYo4mHHAHFTzlCCrAijoWeXxiLHI7mYB0Dg7EAip/HGXsVtIsKxTPOzz2jlQnO0oeNC3UOJJHBINSwVQOBk45OiKQx6MCquw3/6eGXyppApUMgUo4YF/N3WG1AgKxZsyYgeTkZCxevBgxMTHYu3cvhg4disDAQIwdO5Zs88MPP6Bbt26YPn06goKCsHDhQvTp0we7du1Cq1atnO/v/7g8abVarRg3bhzuv/9+NG/e3Fa+YsUKPPXUU6hevTq0Wi18fX2xZs0aNGrUCEDJWq3Q0FBlJ7RaBAcHIyMjgzxXUlISJk+e7GpXGWOeiCetPI4yxtxTAZPW7du3o1+/fujduzcAoF69eli2bBl2795dZpvZs2crnk+fPh1fffUVvv76a7cmrS7fJho9ejR+++03LF++XFE+ceJEZGVlYdOmTdi7dy9effVVxMXF4cCBAy53MiEhAdnZ2bbH2bNnXT4WY8xDWF183EF4HGWMucXVcfR/Y2lOTo7iceO3MaXat2+P7777DkeOHAEA/PLLL9i2bRt69uzpeDetVuTm5iq+UXKFS3dax4wZY1v4X6dOHVv58ePH8cEHH+C3335DTEwMAOCuu+7Cjz/+iA8//BDz5s1DWFgYMjMzFcczm824cuUKwsLCyPMZDAYYDPLXxowx5q14HGWMVbaIiAjF80mTJiExMVFRNmHCBOTk5CA6OhoajQYWiwXTpk3DwIEDHT7Pu+++i2vXriEuLs6t/jo1aRVC4KWXXsKaNWuwZcsW1K9fX/HzvLySjdvVauUNXI1GA6u1ZFofGxuLrKws7Nu3D23atAEAbN68GVarFe3atXP5Qhhj3qWqpnHlcZQxVl7cTeN69uxZmEwmWzn1wXbFihVISUnB0qVLERMTg/T0dIwbNw7h4eGIj4+/5bmWLl2KyZMn46uvvpKWNTnLqUnr6NGjsXTpUnz11VcICAiwrZ0KDAyE0WhEdHQ0GjVqhJEjR+Ldd99F9erV8eWXX9q2ZAGApk2b4uGHH8bzzz+PefPmobi4GGPGjMGAAQMQHh7uVOdVZmUglrASqx3UDq6AIDNnKduqtHLwjzAT0UmOZqYqJoKzyOxX1Apyoh4RnKWigqLklvKbnjgnGSlIJdcigrMEVS8vXypSX5aDQ3z95H9ERf6+UllxgHz9Z6sFKZ8Hyl9NRBkuSGVBROYsi5WMiJOLiJX7VDYtdzgUAObgKaljWciALeXvtViKKHBSFV3T6mnjKGPO8v/+D6lM/UAzuWKY/FWz1SKP56pCIjiYiOJSEWOwo8MQFcRFZdOShj5qyKGORS1dIrN/2bUjrt0pbq5pNZlMikkrZfz48ZgwYQIGDBgAAGjRogVOnz6NpKSkW05aly9fjuHDh2PlypXo2rWr8/2049Sa1uTkZGRnZ+PBBx9ErVq1bI/PP/8cAKDT6bB+/XqEhISgT58+aNmyJT799FMsXrwYvXr1sh0nJSUF0dHR6NKlC3r16oUOHTpg/vz5bl8MY8yLWIVrDy/H4yhjrNy4Oo46MZbm5eXd9JufsixbtgxDhw7FsmXLbEFc7nJ6ecCtNG7cWMrcYi84OBhLly515tSMsTtNFb3TyuMoY6zcVMDuAX369MG0adNQt25dxMTEYP/+/Zg1axaGDRtmq5OQkIBz587h008/BVCyJCA+Ph5z5sxBu3btbN8oGY1GBAbK21g66vZvMskYY4wxxrzS3Llz8cQTT+DFF19E06ZN8c9//hMjR47E1KlTbXUuXLiAM2fO2J7Pnz8fZrMZo0ePVnyj9PLLL7vVF7eSCzDGmOtcuUPg/XdaGWOs/LiaKdDxNgEBAZg9e7a09+qNFi1apHi+ZcsWF/p0a949aS02A+q/g55UVCAWlf2JypxFsW9LBVjp5SxJKioQqahYbktl06IyZ1FBN1Rf1ESZjgjOojKCWez6TGXSooLJqHUxVJYs6jUhAtGsOblSme6iXirzM8mve1GgXC87WBmw9Xs1eTugBkSWrBY+8h6WOiLqjApYoso0Dg4QRYJKOyajjudqxiqHg8Ts3ocWd7+qr6LLAxjzdhuyFkhl9z39b6nsQndiPPMlMkuaib9TRFOrlgrOkuupi6m/X8TxNFRElfIpGehFJdqU/5xBRQRiWXXCrg5xfGdUwPIAT+Ldk1bGmPeyCjh95/QOCMRijLFy48o4amvnfXjSyhirHMJK35W/VRvGGGMlXBlHS9t5IZ60MsYqBy8PYIwx91Sx5QG8ewBjjDHGGPN43n2ntdiszHhlJVZuUwFFDgZsOXQsIuOWoIKkNMSteGpj3mI5YEuACPZyNHMWFZxFsM+c5fBnMCKoi8ySRSED1orksmw5S5ZPhlEq8w2S386F1ZRlpwKrS3X2GuvJx1fJv4cI/WWpjFLe2a9cpYZjX//oie5S1x+pvap4fk3v5tdLFbCmNTk5GcnJyTh16hQAICYmBm+99RZ69uzp3HkZYze1c9k/pLLWI2dJZVebUcFPcpm6mPgbR8X4Un/2qb9Bjg7L9oFYOqK/VFAXEbFlDpY70vqu44rnxdeLcMLBrpF4TStjjFWAClgeUKdOHbz99tto3LgxhBBYvHgx+vXrh/379yMmJsa5czPGmKepYssDeNLKGKscAi5MWp2r3qdPH8XzadOmITk5GTt37uRJK2PM+7kyjpa280I8aWWMVQ437rTm5CiXjBgMBhgMhps2tVgsWLlyJa5fv47Y2FjnzssYY56I77R6vtLc3War3fpHcp0nsZDF0Xr2qDWoViJBgH2/AAhBJBegyijEm4tKYAByrS61LohY8COUOxwLQdUhkguQiQQcXdRKII6npl5PS6FUZi4ukMosBcrrt+bJdYqvy8fP18o7PufpiOQCxGtSQCWDKGeOJBdwdE2rlTiWlVgUdk2rPN71ayXPRSUMfhEREYrnkyZNQmJiIln3wIEDiI2NRUFBAfz9/bFmzRo0a9asAnrp2UQZHwAYKy+WInm8tRYQf8+IPxn2YzcA8u4gNdw6mmdFEMkK7P98WS2OrWkFkdDAqpU7Yv/3pvR5ZYyj3sgrJ625uSVZk7b8tbiSe1JB5H/3dy4qO4g8PwWuEGUHXDvlKaJslWuHqpJyc3MRGBjofEOrFWRkxS3bAGfPnoXJZLIV3+wua1RUFNLT05GdnY1Vq1YhPj4eW7durfIT19Jx1P4DAGPs9pFzLZao0HHU1s77eOWkNTw8HGfPnkVAQABUjtwhrUA5OTmIiIiQ/qh6E74Gz+Dp1yCEQG5uLsLDw109gMvLA0wmk8OviV6vR6NGjQAAbdq0wZ49ezBnzhx8/PHHzp37DsPj6O13J1wHX8PtVSnjaGk7L+SVk1a1Wo06depUdjduypk/qp6Kr8EzePI1uHRnoFQlJRewWq0oLKRu31ctPI5WnDvhOvgabp8KH0dL23khr5y0MsbuABWwT2tCQgJ69uyJunXrIjc3F0uXLsWWLVuQmprq3HkZY8wT8T6tjDF2Z8jMzMTgwYNx4cIFBAYGomXLlkhNTUW3bt0qu2uMMcacxJPWcmYwGDBp0qRbbr/jyfgaPMOdcA03I4SV3n3iFm2csWDBAqfqM89wp7z374Tr4GvwbK6Mo6XtvJFK8D4LjLEKlJOTg8DAQHQJGgytSu9UW7MowndZnyI7O9sj16YxxlhFcGccBbx3LOU7rYyxyiFcWIvFn7EZY+xvroyjtnbehyetjLHKYbU6vgt4KS/9Sosxxm4LV8ZRwGvHUp60MsYqB99pZYwx91SxO623P98kY4wxxhhjbqpyk9bk5GS0bNnStslwbGwsvv32W9vPMzIyMGjQIISFhcHPzw+tW7fG6tWryWMVFhbi7rvvhkqlQnp6uq08MTERKpVKevj5+SnaZ2VlYfTo0ahVqxYMBgOaNGmC9evXK+p8+OGHqFevHnx8fNCuXTvs3r3bo65h9uzZiIqKgtFoREREBF555RUUFCjzzlbWNQBAamoq7rvvPgQEBCAkJAT9+/fHqVOnFHW2bNmC1q1bw2AwoFGjRli0aJF0Dk++hi+++ALdunVDSEiIrR/UPqTUNVQmYbW69GCVz5PGIB5HK38MAngcrSyujqNeO5aKKmbt2rXim2++EUeOHBGHDx8W//d//yd0Op347bffhBBCdOvWTdxzzz1i165d4vjx42Lq1KlCrVaLn3/+WTrW2LFjRc+ePQUAsX//flt5bm6uuHDhguLRrFkzER8fb6tTWFgo2rZtK3r16iW2bdsmTp48KbZs2SLS09NtdZYvXy70er345JNPxMGDB8Xzzz8vgoKCxKeffuoR15CSkiIMBoNISUkRJ0+eFKmpqaJWrVrilVde8YhrOHHihDAYDCIhIUEcO3ZM7Nu3TzzwwAOiVatWijq+vr7i1VdfFYcOHRJz584VGo1GbNiwwWuu4eWXXxYzZswQu3fvFkeOHBEJCQlCp9MpzlPWNVy8eFHqy+2WnZ0tAIjOxqdEd99BTj06G58SAER2dnaF95v9jcfR8rsGHkc94xqq0jjqzWNplZu0UqpVqyb++9//CiGE8PPzE59++qni58HBweI///mPomz9+vUiOjpaHDx4UPoHYi89PV0AED/88IOtLDk5WTRo0EAUFRWV2e7ee+8Vo0ePtj23WCwiPDxcJCUlecQ1jB49WnTu3FlR79VXXxX333+/R1zDypUrhVarFRaLxVa2du1aoVKpbK/7a6+9JmJiYhTHfOqpp0SPHj285hoozZo1E5MnT3bpGm4322BriBPdfZ516tHZEOeVA21VwOMoj6M34nH09nJnHPXmsbTKLQ+4kcViwfLly3H9+nXExsYCANq3b4/PP/8cV65cgdVqxfLly1FQUIAHH3zQ1u7ixYt4/vnnsWTJEvj6+t7yPP/973/RpEkTdOzY0Va2du1axMbGYvTo0ahZsyaaN2+O6dOnw2KxAACKioqwb98+dO3a1dZGrVaja9eu2LFjh0dcQ/v27bFv3z7b1yMnTpzA+vXr0atXL4+4hjZt2kCtVmPhwoWwWCzIzs7GkiVL0LVrV+h0OgDAjh07FP0DgB49etj65w3XYM9qtSI3NxfBwcFOXUOFE6IkgtWph3cGD9zJeBzlcZTHUW8bR714LK3sWXNl+PXXX4Wfn5/QaDQiMDBQfPPNN7afXb16VXTv3l0AEFqtVphMJpGammr7udVqFQ8//LCYOnWqEEKIkydP3vTTdX5+vqhWrZqYMWOGojwqKkoYDAYxbNgwsXfvXrF8+XIRHBwsEhMThRBCnDt3TgAQ27dvV7QbP368uPfeez3iGoQQYs6cOUKn0wmtVisAiFGjRtl+5gnXsGXLFhEaGio0Go0AIGJjY8XVq1dtP2/cuLGYPn26os0333wjAIi8vDyvuAZ7M2bMENWqVbN9ZXWra6hotjsE+idFd8MzTj0665/0yrsDdyJPGIN4HPWMMYjHUe8aR715LK2Sd1qjoqKQnp6OXbt24YUXXkB8fDwOHToEAJg4cSKysrKwadMm7N27F6+++iri4uJw4MABAMDcuXORm5uLhIQEh861Zs0a5ObmIj4+XlFutVoRGhqK+fPno02bNnjqqafwxhtvYN68eV5zDVu2bMH06dPx0Ucf4eeff8YXX3yBb775BlOnTvWIa8jIyMDzzz+P+Ph47NmzB1u3boVer8cTTzwBUU6fMj3tGpYuXYrJkydjxYoVCA0NLZdrvF2EVbj0YJ7BE8YgHkc9bwxyhaddQ1UYR712LK3cObNn6NKlixgxYoQ4duyYAGBbAH7jz0eOHCmEEKJfv35CrVYLjUZjewAQGo1GDB48WDp2586dxaOPPiqVP/DAA6JLly6KsvXr1wsAorCwUBQWFgqNRiPWrFmjqDN48GDRt29fj7iGDh06iH/+85+KsiVLlgij0SgsFkulX8Obb74p2rZtqzjG2bNnBQCxY8cOIYQQHTt2FC+//LKizieffCJMJpMQQnjFNZRatmyZMBqNYt26dYpyZ6/hdiu9Q/CQ5nHRTfuUU4+HNI975d2BqoDHUR5Hb8Tj6O3lzjjqzWNplbzTas9qtaKwsBB5eXkAStap3Eij0cD6v+0h3n//ffzyyy9IT09Henq6bWuVzz//HNOmTVO0O3nyJL7//ns899xz0jnvv/9+HDt2zHZcADhy5Ahq1aoFvV4PvV6PNm3a4LvvvlP087vvvrOt9ansa8jLyyPPAwBCiEq/hpv1r/Q4sbGxiv4BQFpamq1/3nANALBs2TIMHToUy5YtQ+/evRX1nb2GilKl7g5UATyO8jh6Ix5HKwbfab3DTZgwQWzdulWcPHlS/Prrr2LChAlCpVKJjRs3iqKiItGoUSPRsWNHsWvXLnHs2DHx7rvvCpVKpVhjc6ObrWN68803RXh4uDCbzdLPzpw5IwICAsSYMWPE4cOHxbp160RoaKj417/+ZauzfPlyYTAYxKJFi8ShQ4fEiBEjRFBQkHjppZc84homTZokAgICxLJly8SJEyfExo0bRcOGDUVcXJxHXMN3330nVCqVmDx5sjhy5IjYt2+f6NGjh4iMjBR5eXlCiL+3ahk/frz4/fffxYcffkhu1eLJ15CSkiK0Wq348MMPFVvrZGVl3fIaMjIyyL7cTqV3CB5EP9FV9YRTjwfRzyvvDtxpeBwtv2vgcdQzrqEqjaPePJZWuUnrsGHDRGRkpNDr9SIkJER06dJFbNy40fbzI0eOiMcff1yEhoYKX19f0bJlS2m7jRuVNVBZLBZRp04d8X//939ltt2+fbto166dMBgMokGDBmLatGnSoDZ37lxRt25dodfrxb333it27tzpMddQXFwsEhMTRcOGDYWPj4+IiIgQL774orS4vTKvYdmyZaJVq1bCz89PhISEiL59+4rff/9dUef7778Xd999t9Dr9aJBgwZi4cKF0vE9+Ro6depUmsdP8bhxL8iyrqEylA62HdBLPIh+Tj06oJdXDrR3Gk8Zg4TgcdQTxiAheBytaO6Mo948lqqE8NZ9Dxhj3qigoAD169dHRkaGS+3DwsJw8uRJ+Pj4lHPPGGPMO7g7jgLeOZbypJUxVuEKCgpQVFTkUlu9Xu9VgyxjjN0O7oyjgHeOpTxpZYwxxhhjHo93D2CMMcYYYx6PJ60VKDExESqVqrK7wRhjXo3HUsaqJp60umjRokVQqVS2h4+PD8LDw9GjRw+8//77yM3NLZfznD9/HomJiUhPTy+X41W27du3IzExEVlZWZXdFa9yp70PGCvFY6lreCx1zZ32PqhqeNLqpilTpmDJkiVITk7GSy+9BAAYN24cWrRogV9//VVR980330R+fr5Txz9//jwmT558x/wD2759OyZPnswDrZPutPcBY/Z4LHUOj6WuudPeB1WNtrI74O169uyJtm3b2p4nJCRg8+bNeOSRR9C3b1/8/vvvMBqNAACtVgutll/yqiAvLw++vr6V3Q3GvAaPpYzCYylTqMxNYr3ZwoULBQCxZ88e8ufTp08XAMT8+fNtZZMmTRL2L/nGjRvF/fffLwIDA4Wfn59o0qSJSEhIEEKUbNYMYrPj0k2bf/jhB/HEE0+IiIgIodfrRZ06dcS4ceNsGT5KxcfHCz8/P/Hnn3+Kfv36CT8/P1GjRg3xj3/8Q9qE22KxiNmzZ4vmzZsLg8EgatSoIXr06CFd55IlS0Tr1q2Fj4+PqFatmnjqqafEmTNnbvqalV6//ePkyZNCiJJNtqdMmSIaNGgg9Hq9iIyMFAkJCaKgoOCmx3XlGt977z3RrFkzYTAYRGhoqBgxYoS4cuWKot6XX34pevXqJWrVqmXbMHvKlCnS8Tp16iRiYmLE3r17RceOHYXRaLTl4S4oKBBvvfWWaNiwoe13NH78eOma3HkfMObNeCzlsbQUj6XsVvij6m0yaNAg/N///R82btyI559/nqxz8OBBPPLII2jZsiWmTJkCg8GAY8eO4aeffgIANG3aFFOmTMFbb72FESNGoGPHjgCA9u3bAwBWrlyJvLw8vPDCC6hevTp2796NuXPn4s8//8TKlSsV57JYLOjRowfatWuHd999F5s2bcK///1vNGzYEC+88IKt3nPPPYdFixahZ8+eGD58OMxmM3788Ufs3LnTdhdk2rRpmDhxIuLi4jB8+HD89ddfmDt3Lh544AHs378fQUFB5PU+/vjjOHLkCJYtW4b33nsPNWrUAACEhIQAAIYPH47FixfjiSeewD/+8Q/s2rULSUlJ+P3337FmzZpbvuaOXuPIkSOxaNEiDB06FGPHjsXJkyfxwQcfYP/+/fjpp5+g0+kAlKy18/f3x6uvvgp/f39s3rwZb731FnJycvDOO+8ozn358mX07NkTAwYMwLPPPouaNWvCarWib9++2LZtG0aMGIGmTZviwIEDeO+993DkyBF8+eWX5fI+YOxOxmOpjMdSHkurrMqeNXurW90dEEKIwMBA0apVK9tz+7sD7733ngAg/vrrrzKPsWfPnjI/CdrfBRBCiKSkJKFSqcTp06dtZfHx8QKAmDJliqJuq1atRJs2bWzPN2/eLACIsWPHSse1Wq1CCCFOnTolNBqNmDZtmuLnBw4cEFqtViq398477yjuCJRKT08XAMTw4cMV5f/85z8FALF58+abHtfRa/zxxx8FAJGSkqKot2HDBqmcen1HjhwpfH19FZ/uS9P/zZs3T1F3yZIlQq1Wix9//FFRPm/ePAFA/PTTT0II998HjHkzHkt5LC3FYym7FQ7Euo38/f1vGvla+in6q6++gtVqdfr4peu7AOD69eu4dOkS2rdvDyEE9u/fL9UfNWqU4nnHjh1x4sQJ2/PVq1dDpVJh0qRJUtvS7WW++OILWK1WxMXF4dKlS7ZHWFgYGjdujO+//97p6wCA9evXAwBeffVVRfk//vEPAMA333zj0HFudY0rV65EYGAgunXrpuh/mzZt4O/vr+j/ja9vbm4uLl26hI4dOyIvLw9//PGH4jwGgwFDhw5VlK1cuRJNmzZFdHS04lydO3cGANu53H0fMHan47HUcTyW8lh6J+NJ62107do1BAQElPnzp556Cvfffz+GDx+OmjVrYsCAAVixYoXD/9jOnDmDIUOGIDg4GP7+/ggJCUGnTp0AANnZ2Yq6Pj4+tq+OSlWrVg1Xr161PT9+/DjCw8MRHBxc5jmPHj0KIQQaN26MkJAQxeP3339HZmamQ323d/r0aajVajRq1EhRHhYWhqCgIJw+ffqWx3DkGo8ePYrs7GyEhoZK/b927Zqi/wcPHsRjjz2GwMBAmEwmhISE4NlnnwUgv761a9eGXq9XlB09ehQHDx6UztOkSRMAsJ3L3fcBY3c6Hksdx2Mpj6V3Ml7Tepv8+eefyM7OlgaOGxmNRvzwww/4/vvv8c0332DDhg34/PPP0blzZ2zcuBEajabMthaLBd26dcOVK1fw+uuvIzo6Gn5+fjh37hyGDBki/SO92bGcYbVaoVKp8O2335LH9Pf3d+v47mwY7sg1Wq1WhIaGIiUlhfx56UCdlZWFTp06wWQyYcqUKWjYsCF8fHzw888/4/XXX5de3xvvJNx4rhYtWmDWrFnkuSIiImxtXX0fMHan47HUNTyW8lh6J+JJ622yZMkSAECPHj1uWk+tVqNLly7o0qULZs2ahenTp+ONN97A999/j65du5Y58Bw4cABHjhzB4sWLMXjwYFt5Wlqay31u2LAhUlNTceXKlTLvEDRs2BBCCNSvX9/2KdcZZV1PZGQkrFYrjh49iqZNm9rKL168iKysLERGRjp9LkrDhg2xadMm3H///eTgWGrLli24fPkyvvjiCzzwwAO28pMnTzp1rl9++QVdunS55R8QV98HjN3peCyl8VhK47H0zsbLA26DzZs3Y+rUqahfvz4GDhxYZr0rV65IZXfffTcAoLCwEADg5+cHANIG0qWfGIUQtjIhBObMmeNyv/v37w8hBCZPniz9rPQ8jz/+ODQaDSZPnqw4d2mdy5cv3/QcZV1Pr169AACzZ89WlJd+su7du7fD13EzcXFxsFgsmDp1qvQzs9ls6xf1+hYVFeGjjz5y6lznzp3Df/7zH+ln+fn5uH79OgD33geM3cl4LC0bj6UleCytWvhOq5u+/fZb/PHHHzCbzbh48SI2b96MtLQ0REZGYu3atfDx8Smz7ZQpU/DDDz+gd+/eiIyMRGZmJj766CPUqVMHHTp0AFDyCTMoKAjz5s1DQEAA/Pz80K5dO0RHR6Nhw4b45z//iXPnzsFkMmH16tWKNUfOeuihhzBo0CC8//77OHr0KB5++GFYrVb8+OOPeOihhzBmzBg0bNgQ//rXv5CQkIBTp07h0UcfRUBAAE6ePIk1a9ZgxIgR+Oc//1nmOdq0aQMAeOONNzBgwADodDr06dMHd911F+Lj4zF//nzb10m7d+/G4sWL8eijj+Khhx5y+bpu1KlTJ4wcORJJSUlIT09H9+7dodPpcPToUaxcuRJz5szBE088gfbt26NatWqIj4/H2LFjoVKpsGTJEumPy80MGjQIK1aswKhRo/D999/j/vvvh8ViwR9//IEVK1YgNTUVbdu2det9UL9+/XJ5XRirbDyW8lhaFh5LmU1FblVwJyndpqX0odfrRVhYmOjWrZuYM2eOyMnJkdrYb9Py3XffiX79+onw8HCh1+tFeHi4ePrpp8WRI0cU7b766ivRrFkzodVqFVt1HDp0SHTt2lX4+/uLGjVqiOeff1788ssv0nYepZtF36o/QghhNpvFO++8I6Kjo4VerxchISGiZ8+eYt++fYp6q1evFh06dBB+fn7Cz89PREdHi9GjR4vDhw/f8rWbOnWqqF27tlCr1dKG2JMnTxb169cXOp1OREREOL0htiPXKIQQ8+fPF23atBFGo1EEBASIFi1aiNdee02cP3/eVuenn34S9913nzAajSI8PFy89tprIjU1VQAQ33//va1e6YbYlKKiIjFjxgwRExMjDAaDqFatmmjTpo2YPHmyyM7OFkK4/z5gzJvxWMpjaSkeS9mtqIRw4uMOY4wxxhhjlYDXtDLGGGOMMY/Hk1bGGGOMMebxeNLKGGOMMcY8Hk9aGWOMMcaYx+NJK2OMMcYY83g8aWWMMcYYYx6PJ63sjrNlyxaoVCps2bKlsrvCGGNeicdR5ol40soYY4wxxjweT1oZY4wxxpjH40krY4wxxhjzeDxprWJOnz6NF198EVFRUTAajahevTqefPJJnDp1SlFv0aJFUKlU+Omnn/Dqq68iJCQEfn5+eOyxx/DXX39Jx/3oo48QExMDg8GA8PBwjB49GllZWYo6Dz74IJo3b45ff/0VnTp1gq+vLxo1aoRVq1YBALZu3Yp27drBaDQiKioKmzZtcqnv9iZNmgSdTkf2e8SIEQgKCkJBQcGtXzzGGAOPo/Z4HGUVhSetVcyePXuwfft2DBgwAO+//z5GjRqF7777Dg8++CDy8vKk+i+99BJ++eUXTJo0CS+88AK+/vprjBkzRlEnMTERo0ePRnh4OP7973+jf//++Pjjj9G9e3cUFxcr6l69ehWPPPII2rVrh5kzZ8JgMGDAgAH4/PPPMWDAAPTq1Qtvv/02rl+/jieeeAK5ubku973UoEGDYDab8fnnnyvKi4qKsGrVKvTv3x8+Pj6uvJyMsSqIx9G/8TjKKpRgVUpeXp5UtmPHDgFAfPrpp7ayhQsXCgCia9euwmq12spfeeUVodFoRFZWlhBCiMzMTKHX60X37t2FxWKx1fvggw8EAPHJJ5/Yyjp16iQAiKVLl9rK/vjjDwFAqNVqsXPnTlt5amqqACAWLlzodN+///57AUB8//33trLY2FjRrl07RdsvvvhCqscYY7fC4+jfeBxlFYnvtFYxRqPR9v/FxcW4fPkyGjVqhKCgIPz8889S/REjRkClUtmed+zYERaLBadPnwYAbNq0CUVFRRg3bhzU6r/fTs8//zxMJhO++eYbxfH8/f0xYMAA2/OoqCgEBQWhadOmaNeuna289P9PnDjhct9vNHjwYOzatQvHjx+3laWkpCAiIgKdOnW6aVvG2P+3d+fRUVRpG8CfztYJCQkECCFDElaBsBsVg6gIkVUEYRRmkARBUCbAAG6gKJuC2yA7qIOICoqIIIOsouA4LEIkEsEBURA+IcQRk7Bl677fH5muSXXdkOrqTrqLfn7n1Dnm5t5aArzeVL/vvVQe4yjjKHkHJ61+5urVq3juuecQHx8Pq9WKunXrol69esjLy0N+fr6mf0JCgurr2rVrAyj7eAqAEnRbtGih6hcSEoImTZoo33do2LChKngDQFRUFOLj4zVt5a9j5N7LGzx4MKxWK1atWgUAyM/Px6ZNmzB06FDN/RARXQvjKOMoeUeQt2+Aqte4ceOwYsUKTJgwASkpKYiKioLFYsGQIUNgt9s1/QMDA6XnEUIYun5F59NzHVfvvbzatWvjnnvuwapVq/Dcc8/ho48+QlFRER588EFDz0FE/otxlHGUvIOTVj/z0UcfIT09HX/729+UtsLCQk2Fql6JiYkAgGPHjqFJkyZKe3FxMU6ePInU1FS37rc8d+89LS0N/fv3x4EDB7Bq1Sp07NgRrVu39tj9EZF/YBxlHCXvYHqAnwkMDNT8dr9w4ULYbDZD50tNTUVISAgWLFigOu/y5cuRn5+Pvn37unW/5bl7771790bdunXx0ksvYffu3Xw7QESGMI4yjpJ38E2rn7nnnnvw7rvvIioqCklJSdi7dy8+++wz1KlTx9D56tWrhylTpmDGjBno1asX7r33Xhw7dgxLlizBzTff7NGA5u69BwcHY8iQIVi0aBECAwPxpz/9yWP3RkT+g3GUcZS8g5NWPzN//nwEBgZi1apVKCwsxG233YbPPvsMPXv2NHzO6dOno169eli0aBEmTpyI6OhojB49GrNnz0ZwcLBP3XtaWhoWLVqE7t27o0GDBh67NyLyH4yjjKPkHRZhNBOcyIS+/fZbdOjQAe+88w6GDRvm7dshIjIdxlHyFua0kl958803ERERgYEDB3r7VoiITIlxlLyF6QHkF/7xj3/g6NGjeOONNzB27FiEh4d7+5aIiEyFcZS8jekB5BcaNWqE8+fPo2fPnnj33XdRs2ZNb98SEZGpMI6St3HSSkREREQ+jzmtREREROTzOGklIiIiIp/n95PWl19+GS1btrzmnsunTp2CxWLB22+/rbRNnz4dFoulGu6Q/MHw4cPRqFGjKr3GsmXLkJCQgKKioiq9DpE79MRkV7jzb6tRo0YYPny4R+7DW95++21YLBacOnXKY+c02///tm7dioiICPz666/evhVyk19PWgsKCvDSSy/hqaeeQkBA1f8ozp49i+nTpyMrK6vKr0Wet2TJEtUvLq7y9p//8OHDUVxcjNdff90r1yeqTHXHZPKc2bNnY8OGDd6+DalevXqhWbNmmDNnjrdvhdzk11HhrbfeQmlpqaFt6KZOnYqrV6+6NObs2bOYMWMGJ60m5YlJa0V//m+++SaOHTtm/OZ0CA0NRXp6OubOnavZe5zIF7gTk0lu2LBhuHr1KhITEz12Ttn//3x50goAjzzyCF5//XVcvHjR27dCbvDrSeuKFStw7733IjQ01OWxQUFBhsYRyQQHB8NqtVb5dR544AH8/PPP+OKLL6r8WkSucicmXw8uX77s8XMGBgYiNDTUox/nm/H/f4MGDUJRURHWrl3r7VshN/jtpPXkyZM4fPgwUlNTVe15eXkYPnw4oqKiUKtWLaSnpyMvL08zXpbTs2PHDnTp0gW1atVCREQEWrRogaeffhoAsGvXLtx8880AgIceeggWi0WVJ/vPf/4T999/PxISEmC1WhEfH4+JEydqfpsdPnw4IiIi8Msvv2DAgAGIiIhAvXr18Pjjj8Nms6n62u12zJ8/H23btkVoaCjq1auHXr164eDBg6p+7733HpKTkxEWFobo6GgMGTIEZ86ccflnmpeXh4kTJ6JRo0awWq1o2LAh0tLS8J///Efpk5ubi5EjR6J+/foIDQ1F+/btsXLlStV5HDnEr776KhYvXowmTZqgRo0a6NGjB86cOQMhBGbNmoWGDRsiLCwM/fv3x4ULF1TnaNSoEe655x5s374dHTp0QGhoKJKSkvDxxx+r+lWUm+WcB9aoUSMcOXIEu3fvVv7sunbtCgC4cOECHn/8cbRt2xYRERGIjIxE79698e233yrnq+zPX5Z3d/nyZTz22GOIj4+H1WpFixYt8Oqrr2reklosFowdOxYbNmxAmzZtYLVa0bp1a2zdulXzXMnJyYiOjsYnn3yi+R6RN1UUk3/77TcMGzYMkZGRSkz+9ttvNXUGAJR/A6GhoWjTpg3Wr18vvdarr76Kzp07o06dOggLC0NycjI++ugjjzyH49/jqlWr0KJFC4SGhiI5ORlffvmlqp8j9hw9ehR//vOfUbt2bXTp0gUAUFpailmzZqFp06awWq1o1KgRnn76aSUfXQiBu+66C/Xq1UNubq5yzuLiYrRt2xZNmzZVJsCynFZHfNy1axduuukmhIWFoW3btti1axcA4OOPP1b+v5GcnIxDhw5J7738M1++fBkrV65UYtvw4cPxxRdfwGKxSP8cVq9eDYvFgr1792q+17VrV7Rp0waZmZno3LkzwsLC0LhxYyxbtkzpc+nSJYSHh+Ovf/2rZvz//d//ITAwUJUOEBMTg3bt2jH2mZ3wU++9954AIA4fPqy02e12cccdd4iAgADxl7/8RSxcuFB069ZNtGvXTgAQK1asUPpOmzZNlP/xfffddyIkJETcdNNNYv78+WLZsmXi8ccfF3fccYcQQoicnBwxc+ZMAUCMHj1avPvuu+Ldd98VP/74oxBCiHHjxok+ffqI2bNni9dff12MHDlSBAYGij/+8Y+q+05PTxehoaGidevWYsSIEWLp0qVi0KBBAoBYsmSJqu/w4cMFANG7d28xb9488eqrr4r+/fuLhQsXKn2ef/55YbFYxODBg8WSJUvEjBkzRN26dUWjRo3E77//rvvnefHiRdGmTRsRGBgoRo0aJZYuXSpmzZolbr75ZnHo0CEhhBBXrlwRrVq1EsHBwWLixIliwYIF4vbbbxcAxLx585RznTx5UgAQHTp0EElJSWLu3Lli6tSpIiQkRNx6663i6aefFp07dxYLFiwQ48ePFxaLRTz00EOq+0lMTBQ33HCDqFWrlpg8ebKYO3euaNu2rQgICBDbt2+v8M/RYcWKFQKAOHnypBBCiPXr14uGDRuKli1bKn92jvMcOHBANG3aVEyePFm8/vrrYubMmeIPf/iDiIqKEr/88ouuP//09HSRmJioXN9ut4tu3boJi8UiHn74YbFo0SLRr18/AUBMmDBBda8ARPv27UWDBg3ErFmzxLx580STJk1EjRo1xH/+8x/Ns6Wmpork5GSdf7JE1UMWk202m0hJSRGBgYFi7NixYtGiReLuu+8W7du318Tkbdu2iYCAANGmTRsxd+5c8cwzz4ioqCjRunVr1b8tIYRo2LCh+Mtf/iIWLVok5s6dK2655RYBQGzatEnVLzExUaSnp7v0HABEmzZtRN26dcXMmTPFSy+9JBITE0VYWJjIzs5W+jliT1JSkujfv79YsmSJWLx4sRCiLB4AEH/84x/F4sWLRVpamgAgBgwYoIz/6aefREREhLjvvvuUtsmTJwuLxSJ2796ttDnHMsdztWjRQjRo0EBMnz5dvPbaa+IPf/iDiIiIEO+9955ISEgQL774onjxxRdFVFSUaNasmbDZbJp7d3j33XeF1WoVt99+uxLb9uzZI+x2u4iPjxeDBg3S/Jz69OkjmjZtKv0Z3nnnnSIuLk7ExMSIsWPHigULFoguXboIAGL58uVKv6FDh4r69euL0tJS1fiXX35ZWCwW8fPPP6vaH374YVG3bl3pNckc/HbSOnXqVAFAXLx4UWnbsGGDACBefvllpa20tFSZWF1r0vraa68JAOLXX3+t8JoHDhzQnMfhypUrmrY5c+Zo/uE5gtnMmTNVfTt27KiaiHz++ecCgBg/frzmvHa7XQghxKlTp0RgYKB44YUXVN/Pzs4WQUFBmvZree655wQA8fHHH1d4vXnz5gkA4r333lO+V1xcLFJSUkRERIQoKCgQQvxv0lqvXj2Rl5en9J0yZYoyQSspKVHa//SnP4mQkBBRWFiotCUmJgoAYt26dUpbfn6+aNCggejYsaPSpnfSKoQQrVu3Fnfeeaemb2FhoSqgO57BarWq/pyu9efvPGl1/F18/vnnVf3++Mc/CovFIk6cOKG0ARAhISGqtm+//VYAUP2C4jB69GgRFhamaSfyJllMXrduneaXWpvNJrp166b5t9ShQwfRoEEDVczYvn27AKCZtDrH2+LiYtGmTRvRrVs3VbvRSSsAcfDgQaXt559/FqGhoaoJpiP2/OlPf1KNz8rKEgDEww8/rGp//PHHBQDx+eefK22vv/66ElP37dsnAgMDNb/UVjRpBSD27NmjtG3btk0AEGFhYar/5ziu8cUXX2juvbzw8HDpz2rKlCnCarWq/lxyc3NFUFCQmDZtmqa/EGWTVgDib3/7m9JWVFQkOnToIGJiYkRxcbHqnrds2aIa365dO2msnj17tgAgzp8/L70u+T6/TQ/47bffEBQUhIiICKVt8+bNCAoKwpgxY5S2wMBAjBs3rtLz1apVCwDwySefGFqqJSwsTPnvy5cv4z//+Q86d+4MIYTmoxkAePTRR1Vf33777fjpp5+Ur9etWweLxYJp06Zpxjo+1vn4449ht9vxwAMP4D//+Y9yxMbGonnz5i7lPa5btw7t27fHfffdV+H1Nm/ejNjYWFWRRXBwMMaPH49Lly5h9+7dqnH3338/oqKilK87deoEAHjwwQcRFBSkai8uLsYvv/yiGh8XF6e6n8jISKSlpeHQoUPIycnR/WyVsVqtSqWzzWbDb7/9pqSHfPPNN4bOuXnzZgQGBmL8+PGq9sceewxCCGzZskXVnpqaiqZNmypft2vXDpGRkaq/Ew61a9fG1atXceXKFUP3RlQVZDF569atCA4OxqhRo5S2gIAAZGRkqMaeO3cOWVlZSE9PV8WMu+++G0lJSZprlY+3v//+O/Lz83H77bcb/vfqLCUlBcnJycrXCQkJ6N+/P7Zt26ZJ43KO5Zs3bwYATJo0SdX+2GOPAQA+/fRTpW306NHo2bMnxo0bh2HDhqFp06aYPXu2rntMSkpCSkqK8rUjvnbr1g0JCQmadlks0SMtLQ1FRUWq9Is1a9agtLQUDz74YIXjgoKC8Mgjjyhfh4SE4JFHHkFubi4yMzMBlMW9uLg4rFq1Sun33Xff4fDhw9Jz165dGwBUKWtkLn47aZX5+eef0aBBA1XQBIAWLVpUOnbw4MG47bbb8PDDD6N+/foYMmQIPvzwQ90T2NOnT2P48OGIjo5W8lTvvPNOAEB+fr6qryM/tbzatWvj999/V77+8ccfERcXh+jo6Aqv+cMPP0AIgebNm6NevXqq4/vvv1flSlXmxx9/RJs2ba7Z5+eff0bz5s01S9m0atVK+X555QMnAOV/RvHx8dL28s8PAM2aNdPkq95www0A4NE1C+12O1577TU0b94cVqsVdevWRb169XD48GHNn51eP//8M+Li4jR7e+v9WQHavxMO4r85sWZaZ5H8kyMm16hRQ9XerFkzTT8AaN68ueYcsvi9adMm3HrrrQgNDUV0dDTq1auHpUuXGv736kx2HzfccAOuXLmiWSu0cePGqq9//vlnBAQEaJ4xNjYWtWrV0vzbX758Oa5cuYIffvgBb7/9tmpCfi3uxle9WrZsiZtvvlk1sVy1ahVuvfVWzTOWFxcXh/DwcFWbc/wOCAjA0KFDsWHDBuWX8FWrViE0NBT333+/5pyMfeYXVHmX61OdOnVQWlqKixcvaiYGRoSFheHLL7/EF198gU8//RRbt27FmjVr0K1bN2zfvh2BgYEVjrXZbLj77rtx4cIFPPXUU2jZsiXCw8Pxyy+/YPjw4ZqJ77XO5Qq73Q6LxYItW7ZIz+k8ea9uFT1nRe2OgOSKioKX89uQa5k9ezaeffZZjBgxArNmzUJ0dDQCAgIwYcIEjy2QXhlXfia///47atSooft/bkTVwdMxuSL//Oc/ce+99+KOO+7AkiVL0KBBAwQHB2PFihVYvXp1lV23IhX9O9Q7sdq1a5dSoJWdna16e3ot1RFfHdLS0vDXv/4V//d//4eioiLs27cPixYtMnw+53O/8sor2LBhA/70pz9h9erVuOeee1Rv3B0cE++6det65NpU/fx20tqyZUsAZRWr7dq1AwAkJiZi586duHTpkmrCpnf9zICAAHTv3h3du3fH3LlzMXv2bDzzzDP44osvkJqaWmEQys7OxvHjx7Fy5UqkpaUp7Tt27DD6eGjatCm2bduGCxcuVPi2tWnTphBCoHHjxspvsO5c77vvvrtmn8TERBw+fBh2u131tvXf//638n1POnHiBIQQqp/78ePHAUCp1Hd8XJSXl6ekeADaN5lAxf8T+eijj3DXXXdh+fLlqva8vDxVcHTlt/vExER89tlnmv+Be+JndfLkSeWNLZGvqCgmf/HFF7hy5YrqbeuJEydUYx3/Hn744QfNeZ3j97p16xAaGopt27aplplbsWKFZx6kgvs4fvw4atSoofmUzFliYiLsdjt++OEH1b/T8+fPIy8vT/Vv/9y5cxg3bhx69OiBkJAQPP744+jZs6fHY6ke14pvQ4YMwaRJk/D+++/j6tWrCA4OxuDBg695vrNnz+Ly5cuqt63O8RsA2rRpg44dO2LVqlVo2LAhTp8+jYULF0rPefLkSeWTMDInv00PcPw2Wn75pz59+qC0tBRLly5V2mw2W4X/AMpzXnIJADp06AAAym/Bjn98zktoOX6zLf+brBAC8+fP1/EkcoMGDYIQAjNmzNB8z3GdgQMHIjAwEDNmzND8Fi2EwG+//ebS9b799lvp0iaOc/fp0wc5OTlYs2aN8r3S0lIsXLgQERERSjqEp5w9e1Z1PwUFBXjnnXfQoUMHxMbGAoCSB1p+ORrH0i3OwsPDpcufBQYGan5+a9eu1eTYVvTnL9OnTx/YbDbN24jXXnsNFosFvXv3rvQcFfnmm2/QuXNnw+OJqoIsJvfs2RMlJSV48803lTa73Y7FixerxjZo0AAdOnTAypUrVR/x79ixA0ePHlX1DQwMhMViUX2acurUKY8ujL93715VfuyZM2fwySefoEePHpV+UtanTx8AwLx581Ttc+fOBQD07dtXaRs1ahTsdjuWL1+ON954A0FBQRg5cqRXNg+pKD4CZW82e/fujffeew+rVq1Cr169lF/oT58+rfwyXl5paalq9z7Hbn716tVT5QsDZRsobN++HfPmzUOdOnUqjI+ZmZm630STb/LbN61NmjRBmzZt8Nlnn2HEiBEAgH79+uG2227D5MmTcerUKWVdTz15TjNnzsSXX36Jvn37IjExEbm5uViyZAkaNmyorL3XtGlT1KpVC8uWLUPNmjURHh6OTp06oWXLlmjatCkef/xx/PLLL4iMjMS6desM5xABwF133YVhw4ZhwYIF+OGHH9CrVy/Y7Xb885//xF133YWxY8eiadOmeP755zFlyhScOnUKAwYMQM2aNXHy5EmsX78eo0ePxuOPP67rek888QQ++ugj3H///RgxYgSSk5Nx4cIFbNy4EcuWLUP79u0xevRovP766xg+fDgyMzPRqFEjfPTRR/jXv/6FefPmefwjwRtuuAEjR47EgQMHUL9+fbz11ls4f/686o1Kjx49kJCQgJEjR+KJJ55AYGAg3nrrLdSrVw+nT59WnS85ORlLly7F888/j2bNmiEmJgbdunXDPffcg5kzZ+Khhx5C586dkZ2djVWrVqFJkyaq8RX9+TvntAFlfxfvuusuPPPMMzh16hTat2+P7du345NPPsGECRNURVeuyMzMxIULF9C/f39D44mqiiwmDxgwALfccgsee+wxnDhxAi1btsTGjRuVlwTl3+7NmTMHffv2RZcuXTBixAhcuHABCxcuROvWrXHp0iWlX9++fTF37lz06tULf/7zn5Gbm4vFixejWbNmOHz4sEeepU2bNujZsyfGjx8Pq9WKJUuWAID0JYKz9u3bIz09HW+88Qby8vJw55134uuvv8bKlSsxYMAA3HXXXQDK3gx/+umnePvtt9GwYUMAwMKFC/Hggw9i6dKl+Mtf/uKRZ9ErOTkZn332GebOnYu4uDg0btxYKeICyj7G/+Mf/wgAmDVrlqp99+7dmol2XFwcXnrpJZw6dQo33HAD1qxZg6ysLLzxxhsIDg5W9f3zn/+MJ598EuvXr8eYMWM03wfK1gg/fPiwpoiPTKZ6FyvwLXPnzhURERGq5U9+++03MWzYMBEZGSmioqLEsGHDxKFDhypd8mrnzp2if//+Ii4uToSEhIi4uDjxpz/9SRw/flx1zU8++UQkJSWJoKAg1TmPHj0qUlNTRUREhKhbt64YNWqUsmxR+eump6eL8PBwzbPIliApLS0Vr7zyimjZsqUICQkR9erVE7179xaZmZmqfuvWrRNdunQR4eHhIjw8XLRs2VJkZGSIY8eOufTz/O2338TYsWPFH/7wBxESEiIaNmwo0tPTVWuFnj9/Xjz00EOibt26IiQkRLRt21azBJRjyatXXnlF1f7FF18IAGLt2rWqdseSLgcOHFDaEhMTRd++fcW2bdtEu3bthNVqFS1bttSMFUKIzMxM0alTJxESEiISEhLE3LlzpcvE5OTkiL59+4qaNWsKAMqSKoWFheKxxx4TDRo0EGFhYeK2224Te/fuFXfeeadm2ZWK/vydl7wSomzt24kTJ4q4uDgRHBwsmjdvLl555RVlCTEHACIjI0PzXLLlep566imRkJCgOQeRL5DF5F9//VX8+c9/FjVr1hRRUVFi+PDh4l//+pcAID744APV+HXr1olWrVoJq9UqkpKSxMcffyz9t7V8+XLRvHlzJS6sWLFCGkONLnmVkZEh3nvvPeUaHTt2VC0ZJcT/YrZsmcSSkhIxY8YM0bhxYxEcHCzi4+PFlClTlGX9zpw5I6KiokS/fv00Y++77z4RHh4ufvrpJyFExUte9e3bt8J7L08Wj2U/q3//+9/ijjvuEGFhYQKA5udWVFQkateuLaKiosTVq1eVdsfyVuXdeeedonXr1uLgwYMiJSVFhIaGisTERLFo0SLNPTv06dNHs4xXeUuXLhU1atRQllYkc/LrSWteXp6Ijo4Wf//73719K+RhFQVlf1ZYWChiY2NVa14S+RK9MXn9+vUCgPjqq6+q6c70q+iXSH9XUlIi6tWrJ0aMGFFpX8ek1RUDBgyocLMCIcrW8XVew5bMx29zWoGypTyefPJJvPLKK9VW5U3kLStWrEBwcLBmXcjr3Zdffol+/fohLi4OFotFk7sohMBzzz2HBg0aICwsDKmpqZpCmgsXLmDo0KHKVqIjR45UfeRMniGLyc5bWTvqDCIjI3HjjTd64zbJgA0bNuDXX39VFRt7yrlz5/Dpp59i2LBh0u9v3boVP/zwA6ZMmeLxa/sLX4mjfpvT6vDUU0/hqaee8vZt+KyrV69WmtMbHR2NkJCQarojMurRRx/1mQlrYWEhiouLDY0NCQlBaGio7v6XL19G+/btMWLECAwcOFDz/ZdffhkLFizAypUr0bhxYzz77LPo2bMnjh49qlxn6NChOHfuHHbs2IGSkhI89NBDGD16tFeWSLreOcfkcePG4erVq0hJSUFRURE+/vhj7NmzB7Nnz67WZdsq25AkLCxMusySv9u/fz8OHz6MWbNmoWPHjh4tuD158iT+9a9/4e9//zuCg4NVmxGU16tXr+vyl0x34ijgWiz1mTjq7Ve95Nsc+VDXOpxztXwB0wN819WrV0VsTGClf68qOmJjY1U5ca4AINavX698bbfbRWxsrCpfLy8vT1itVvH+++8LIcryzeGUM71lyxZhsVjEL7/8YuyHQLqtWrVK3HjjjSIyMlKEhISIpKQk6fbEVa2yv5eOHE4wPUAlPT1dBAYGiuTkZJGdna1rjN70AMf/nxISEqT1Ctczd+OoO7HUm3HU8t8bIJI6d+4cjhw5cs0+ycnJynqnRJUpKChAVFQUTmYmIrKmaxlKBRftaJz8M86cOYPIyEil3Wq1qtbcrIjFYsH69esxYMAAAGVbUzZt2hSHDh1SlqgDgDvvvBMdOnTA/Pnz8dZbb+Gxxx5TreZRWlqK0NBQrF27Vrp1MV1/Pvvss2t+Py4uTrplLFFVcCeOAu7FUm/GUb9PD6Bra9CgARo0aODt26DrUHhE2eEK239/xXbeanLatGmYPn26y/fg+Mi3fv36qvb69esr38vJyUFMTIzq+0FBQYiOjq70I2O6fqSmpnr7Fog0jMRRwLOxtDrjKCetROQVdgjY4doHPY7+srcDRET+xkgcdYwDzBdLOWklIq+www5X1+xwjIiMjFQFWqMcO6OdP39e9YnC+fPnlY+5YmNjkZubqxpXWlqKCxcuKOOJiLzBSBx1jAM8E0urM4769ZJXROTfGjdujNjYWOzcuVNpKygowP79+5XtHlNSUpCXl4fMzEylz+effw673a7a8YeIyB9VZxz1u0nrp59+ik6dOiEsLAy1a9dWEomv5fvvv8e9996LqKgohIeH4+abb1a2+Dx16hQsFov0WLt2rXKO8ePHIzk5GVarVZWo7Kpr3QuRmdiEMHS46tKlS8jKykJWVhaAsmVysrKycPr0aVgsFkyYMAHPP/88Nm7ciOzsbKSlpSEuLk6JDa1atUKvXr0watQofP311/jXv/6FsWPHYsiQIYiLi/PgT8Q8GEeJfIPROOpqLPWVOHrdpQd07doVw4cPx/DhwzXfW7duHUaNGoXZs2ejW7duKC0txXfffXfN8/3444/o0qULRo4ciRkzZiAyMhJHjhxR1h2Lj4/HuXPnVGPeeOMNvPLKK+jdu7eqfcSIEcqadUZUdi9EZuJOTqsrDh48qOzXDgCTJk0CAKSnp+Ptt9/Gk08+icuXL2P06NHIy8tDly5dsHXrVtW/q1WrVmHs2LHo3r07AgICMGjQICxYsMDlezELxlEic3A3p1UvX4mj192SVxUF29LSUjRq1AgzZszAyJEjdZ9vyJAhCA4Oxrvvvqt7TMeOHXHjjTdi+fLlmu9Nnz4dGzZsUH5bKe+rr77ClClTcPDgQdStWxf33Xcf5syZg/DwcMP3QuRrlKVa/t0ANV1cquXiRTsatzyH/Px8j+S0khzjKJFvcyeOAuaNpX6THvDNN9/gl19+QUBAADp27IgGDRqgd+/e13xDYLfb8emnn+KGG25Az549ERMTg06dOmm2LysvMzMTWVlZLgV0oOy3/169emHQoEE4fPgw1qxZg6+++gpjx441fC9EvszxhsDVg7yHcZTItxiNo2aNpX4zaf3pp58AlP2GPnXqVGzatAm1a9dG165dceHCBemY3NxcXLp0CS+++CJ69eqF7du347777sPAgQOxe/du6Zjly5ejVatW6Ny5s0v3N2fOHAwdOhQTJkxA8+bN0blzZyxYsADvvPMOCgsLDd0LEZEnMY4SkTeZPqd19uzZmD17tvL11atXsW/fPuU3awA4evQo7Pay5R2eeeYZDBo0CACwYsUKNGzYEGvXrpXuWewY079/f0ycOBEA0KFDB+zZswfLli3T7KF89epVrF69Gs8++6zLz/Htt9/i8OHDWLVqldImhIDdbsfJkyeVPa313guRrzNSDGCkEIsqxzjKOErmZLRA1ayx1PST1kcffRQPPPCA8vXQoUMxaNAgDBw4UGmLi4tT1g4rv82e1WpFkyZNKqwarVu3LoKCgjRb87Vq1QpfffWVpv9HH32EK1euIC0tzeXnuHTpEh555BGMHz9e872EhAQAcOleiHyd/b+Hq2PI8xhHGUfJnIzEUcc4MzL9pDU6OhrR0dHK12FhYYiJiUGzZs1U/RzLpBw7dgxdunQBAJSUlODUqVNITEyUnjskJAQ333wzjh07pmo/fvy4dMzy5ctx7733ol69ei4/x4033oijR49q7rs8V+6FyNfZIGBzMa/K1f6kD+Mo4yiZk5E46hhnRqaftOoVGRmJRx99FNOmTUN8fDwSExPxyiuvAADuv/9+pV/Lli0xZ84c3HfffQCAJ554AoMHD8Ydd9yBu+66C1u3bsU//vEP7Nq1S3X+EydO4Msvv8TmzZul1z9x4gQuXbqEnJwcXL16Val6TUpKQkhICJ566inceuutGDt2LB5++GGEh4fj6NGj2LFjBxYtWuTSvRCZgU38b/9rV8aQ9zCOEvkWI3HUMc6M/GbSCgCvvPIKgoKCMGzYMFy9ehWdOnXC559/jtq1ayt9jh07hvz8fOXr++67D8uWLcOcOXMwfvx4tGjRAuvWrVPeMji89dZbaNiwIXr06CG99sMPP6xK9O/YsSOAsgV6GzVqhHbt2mH37t145plncPvtt0MIgaZNm2Lw4MEu3wuRGTA9wJwYR4l8h7+lB1x367QSkW9zrC+YdTTG0DqtHZJyTbe2IBGRJ7kTRwHzxlK/etNKRL7DDgtssLg8hoiIyhiJo45xZsRJKxF5hV2UHa6OISKiMkbiqGOcGZly0mq323H27FnUrFkTFos5f1sgMjshBC5evIi4uDgEBLj+8ZTNwBsCI28USI5xlMj7vBFHHePMyJST1rNnzyI+Pt7bt0FEAM6cOYOGDRu6PI6TVu9iHCXyHdUZRx3jzMiUk9aaNWsCAH7+phEiI/73m0mRKNH0LRSlmrZioa2bK5TUoxUJ9R/qFbv2x1UktG2XRbCkn7btst2q63xXpP0k15Ddn13b74o9RNNW7DS21B6o6XPVpj1/seR+iyVjC23a+yixaX+rLJGMLbFp20rt2rGye7bZLU59tOPskjabTfsPWtj1tdmFvn6yZfKEZCxk55N9tOPcT9pH0maQ/Wohzj7xovLvkcyFcZRxlHFU241x1LeZctLq+CgrMiIAkTXLB1vtP5oQSVuR5C9csORvb7DTX94AyT/KIMn5IbT/6AMlbUISHAIkAVNI2iySIGeRBFZI2mzSfurzBcgClyRgyu5N9lzSsZIgKhsr76f9ucv6wSnIycZZJG2Q/I/ArjPYSoOj3mCr93w+EGwdjH60bBcW6f+YKhtDnsE4yjjKOKrt5g9x1DHOjEw5aSUi82N6ABGRe5geYCJX7MUIspd/Q6D9CKtQ+hGW9lyF0jcJgU59ZB9haT8iKtT5EZbs46pC6cdQ+vrJPhKT9bsq+W3d+SMx54+5APlHToWyj7pkH6+V6vv4S+9HWLKPxEolY21OY2W/5dsk59L9cZXOj790vzWQrfgs/ahL1k/HOE8qdb1ooDwbAmCDa+ewuXVFkmEcVWMcZRytdJwneSGOlo0zJ1NPWonIvISBj7WkuWpERH7KSBx1jDMjl6bnS5cuRbt27RAZGYnIyEikpKRgy5YtyvdzcnIwbNgwxMbGIjw8HDfeeCPWrVunOseFCxcwdOhQREZGolatWhg5ciQuXbrkmachIvJxjKNERMa4NGlt2LAhXnzxRWRmZuLgwYPo1q0b+vfvjyNHjgAA0tLScOzYMWzcuBHZ2dkYOHAgHnjgARw6dEg5x9ChQ3HkyBHs2LEDmzZtwpdffonRo0d79qmIyOc5crFcPcyOcZSIPMVoHDVrLHVp0tqvXz/06dMHzZs3xw033IAXXngBERER2LdvHwBgz549GDduHG655RY0adIEU6dORa1atZCZmQkA+P7777F161b8/e9/R6dOndClSxcsXLgQH3zwAc6ePev5pyMin2UTAYYOs2McJSJPMRpHzRpLDee02mw2rF27FpcvX0ZKSgoAoHPnzlizZg369u2LWrVq4cMPP0RhYSG6du0KANi7dy9q1aqFm266STlPamoqAgICsH//ftx3333SaxUVFaGoqEj5uqCgAABwVZSolkqRrxGoPV+hZNkUeVuQ09faxHtvFQvI1giUry+obbtqk41VP7+sCKBYkqAvLTSQ9pO0SfpJCwhkxQLSNQErb7PLlmBxozBAXgSgt03bZLhYAIClqpdqcRprKXbvN3U7LLC7WEBgr4q1ZryIcbTiNsZRxlF9bdomxlE948wZS12etGZnZyMlJQWFhYWIiIjA+vXrkZSUBAD48MMPMXjwYNSpUwdBQUGoUaMG1q9fj2bNmgEoy9WKiYlR30BQEKKjo5GTk1PhNefMmYMZM2a4eqtE5MP8eckrxlEi8gR/W/LK5el5ixYtkJWVhf3792PMmDFIT0/H0aNHAQDPPvss8vLy8Nlnn+HgwYOYNGkSHnjgAWRnZ7t1k1OmTEF+fr5ynDlzxq3zEZH3+dNHWs4YR4nIE5geUImQkBDlN/7k5GQcOHAA8+fPx5NPPolFixbhu+++Q+vWrQEA7du3xz//+U8sXrwYy5YtQ2xsLHJzc1XnKy0txYULFxAbG1vhNa1WK6xW7cc9RERmxDhKROQ6t6fadrsdRUVFuHLlStkJA9SnDAwMhN1elnSSkpKCvLw8paAAAD7//HPY7XZ06tTJ3VshIhMpy8Vy/bgeMY4SkRFG46hZY6lLb1qnTJmC3r17IyEhARcvXsTq1auxa9cubNu2DS1btkSzZs3wyCOP4NVXX0WdOnWwYcMGZUkWAGjVqhV69eqFUaNGYdmyZSgpKcHYsWMxZMgQxMXFuXzzV4RAYLmigUJJ8rX+YgFJcYBT4r7eAgJvFQvICwNkRQWyHVnU1y2W7tAiSfjXuRtLiSThv1iyu4sniwUAbcGAdN9rvbuxSPrpLhaQJfzr7Ke30MCi2clFNk7SJqE5l0ypuwUEru/kYtbigfIYRxlHnTGOMo4aZSSOlo0zZyx1adKam5uLtLQ0nDt3DlFRUWjXrh22bduGu+++GwCwefNmTJ48Gf369cOlS5fQrFkzrFy5En369FHOsWrVKowdOxbdu3dHQEAABg0ahAULFnj2qYjI5xnJq7JJKtvNhnGUiDzFaH6qWWOpS5PW5cuXX/P7zZs31+zc4iw6OhqrV6925bJEdB2yI8Avl7xiHCUiTzESR8vGmTOWmrN8jIiIiIj8iuHNBYiI3GETFthki4BXMoaIiMoYiaOOcWZk6knrFXsAAsollxfp2I2lrE1fIYBzmyy5X0/hQdm9Gi8WuGrT9iuSjJX301cIoC0g8GyxQKnOHVpk55MXC2j/wdkl13UuDhCSc8kKCHQXC8gKA6RjtU3SIgBJP1mbvDhAfT5pEYDeT4R09LOUuBf0bAYKCGwm/UjLlzGO6unHOKr+mnFUFx+No2XjzBlLTT1pJSLzsosA2F0sILCbtHiAiKgqGImjZePMGUs5aSUir+CbViIi9/jbm1YWYhERERGRz+ObViLyCjtcLwaQpaUREfkrI3HUMc6MTD1pvSKCEFAul8OtYgFJ4r7RAgJZcr+3igUKpTuySHZ3cdpVRbpri6wIQJK0XyLbjUVWGKB3h5ZSyQ4tkrF22Y4szm1uFAtId16xaZuk/XQWBujd3UVXcYDecTK6dnLRea4KGFunlR8OeRrjqHM/xlFnjKM6xsn4aBx1jDMjU09aici8jO2IZc5AS0RUFYzviGXOWMpJKxF5hR0W2OFqeoA51xYkIqoKRuKoY5wZcdJKRF7BN61ERO7hm1YTuSJCYCmfi6V30WqdC1kXCnWulDTHSpL/pTcXy1fyrsr6qXOlpIti61zYWpafJV/YWpZPpa+fbCFr2YLXmjwrnQtWyxa21rvYtXSsrJ8s38mT/WSLbnswF0u4uSg2+QbGUadrMI5q2hhHdZxLhnHU40w9aSUi8zK2Tqs53w4QEVUF4+u0mjOWctJKRF5hFxbYXV3yyqT7ZRMRVQUjcdQxzow4aSUir7AbeENg1mVaiIiqgpE46hhnRpy0EpFXGNkz28ge20RE1ysjcdQxzoxMPWm9ag+BpVziu/7CAGP93FnsWpbwXypZeLo6igWKJGNLnJL+iyXjqqNYwC5ZFFpaLCBZKFvP4taWUn2LYksT/mULYMvG6k34l51PtpC13kW2dSyKrXe7aT2FBsLNRbHJNzCOqjGOMo6qMI76FFNPWonIvGywwObiWoGu9iciup4ZiaOOcWbESSsReQXTA4iI3MP0ACKiamCD67/tSz4JJCLyW0biqGOcGXHSSkRewTetRETu4ZtWE7lst0J4qIBAT3FAkWTXFv07tOhL+C+RFBVUdbEAoC0YkBULyHZykRcLaH/rs0uuqXc3Flk/yAoBJIn2zgn+sgICvYUB0qR9vYUBsnvTeT6919X00VlAoHt3F+dTsYDgusA46nQNxlFNE+OoE8ZRrzH1pJWIzMvIntlm3S+biKgqGImjjnFmxEkrEXmFgAV2F3OxhEkrXomIqoKROOoYZ0bmnGoTkek53hC4erh0DZsNzz77LBo3boywsDA0bdoUs2bNghD/+yxPCIHnnnsODRo0QFhYGFJTU/HDDz94+nGJiDzOaBx1JZb6UhzlpJWIvMKxZ7arhyteeuklLF26FIsWLcL333+Pl156CS+//DIWLlyo9Hn55ZexYMECLFu2DPv370d4eDh69uyJwsJCTz8yEZFHGY2jrsRSX4qjpk4PuCKCIcol0hcK2Q4qsgICSaK9ngICWdK+pO2qTXYf2uR7WRFAsSRJX1poIOlntFgA0BYM6C4WkOyoIisWsEuLBfTtqqJnhxagouIApwICWXK/bJzuwgBZP51FCrIiAOlOLpI2HbvFVHkBQYmxcQ42A3tmu9p/z5496N+/P/r27QsAaNSoEd5//318/fXXAMreDsybNw9Tp05F//79AQDvvPMO6tevjw0bNmDIkCEuXc+MGEedrsE4qm1jHK38/CaKo45xevlSHOWbViIynYKCAtVRVFQk7de5c2fs3LkTx48fBwB8++23+Oqrr9C7d28AwMmTJ5GTk4PU1FRlTFRUFDp16oS9e/dW/YMQEXmRnljqS3HU1G9aici8jHzc7+gfHx+vap82bRqmT5+u6T958mQUFBSgZcuWCAwMhM1mwwsvvIChQ4cCAHJycgAA9evXV42rX7++8j0iIl9lJI46xgH6YqkvxVFOWonIK+wIgN3FD3sc/c+cOYPIyEil3Wq1Svt/+OGHWLVqFVavXo3WrVsjKysLEyZMQFxcHNLT043fPBGRDzASRx3jAH2x1JfiKCetROQVNmGBzcU3BI7+kZGRqkBbkSeeeAKTJ09Wcqratm2Ln3/+GXPmzEF6ejpiY2MBAOfPn0eDBg2UcefPn0eHDh1cujcioupmJI46xgH6YqkvxVFTT1qv2K1OBQTGdmgpO5cs6d9pdxNJEYC8qEC2G4v2msXSHVq0Y2W7u8gS/I0WC8jOVyorDJDu2mJ8hxb9xQLaJnmSvqyoQM842fm1bQE6x+re8UVvkYLOooJqLyBwcycXd9ID9Lpy5QoCAtR/9wIDA2G3l/2wGjdujNjYWOzcuVMJrgUFBdi/fz/GjBnj0rXMinHUuR/jqKaNcVTN5HHUMU4vX4qjpp60EhFdS79+/fDCCy8gISEBrVu3xqFDhzB37lyMGDECAGCxWDBhwgQ8//zzaN68ORo3boxnn30WcXFxGDBggHdvnojIB/hSHOWklYi8QogA2F3cLEC42H/hwoV49tln8Ze//AW5ubmIi4vDI488gueee07p8+STT+Ly5csYPXo08vLy0KVLF2zduhWhoaEuXYuIqLoZiaOOcXr5UhzlpJWIvMIGC2wubiXoav+aNWti3rx5mDdvXoV9LBYLZs6ciZkzZ7p0biIibzMSRx3j9PKlOMpJKxF5hV24nqNqN5g3RkR0PTISRx3jzMjUk9arzgUEksKAIsmuLbJ+VyUJ/s7FAdIdVaQ7tOgtIPBssUCppJ+eYgFAWzDgVrGApPjAnd1YZGN1J9/r2clFViwg3RVG5zXdKRZwo/hAW0AgiUoe3cnFvahnN/CxlpGPwejaGEfVGEdlbYyjKiaPo45xZmTOuyYiIiIiv+LSpHXp0qVo166dsq5XSkoKtmzZouqzd+9edOvWDeHh4YiMjMQdd9yBq1evKt+/cOEChg4disjISNSqVQsjR47EpUuXPPM0RGQadlgMHWbHOEpEnmI0jpo1lro0aW3YsCFefPFFZGZm4uDBg+jWrRv69++PI0eOACgLtL169UKPHj3w9ddf48CBAxg7dqxqfa+hQ4fiyJEj2LFjBzZt2oQvv/wSo0eP9uxTEZHPcyyK7ephdoyjROQpRuOoWWOpSzmt/fr1U339wgsvYOnSpdi3bx9at26NiRMnYvz48Zg8ebLSp0WLFsp/f//999i6dSsOHDiAm266CUDZUgp9+vTBq6++iri4OHeehYhMxF9zWhlHichT/C2n1XAhls1mw9q1a3H58mWkpKQgNzcX+/fvx9ChQ9G5c2f8+OOPaNmyJV544QV06dIFQNkbhFq1aimBFgBSU1MREBCA/fv347777pNeq6ioCEVFRcrXBQUFAIBCexBQrhhAz24sFbVdtcnGqhPtZQUEsiIAaaGBtJ++YoFSSbFAiSSZX1ZAYJMVGujYpcWtYgFZEYCsWEC684rexH2dO744tQVIdh/RswOM7FwAEKC3qEBvsYC0nzZRX1pAIFzvA7hTQGBsnIMdBnbEMulHWhVhHP1vG+Oopo1xVGcb46ix1QNMGktdnmpnZ2cjIiICVqsVjz76KNavX4+kpCT89NNPAIDp06dj1KhR2Lp1K2688UZ0794dP/zwAwAgJycHMTExqvMFBQUhOjoaOTk5FV5zzpw5iIqKUo74+HhXb5uIfIwwkIMlTBponTGOEpEnGImjZo6lLk9aW7RogaysLGVP2fT0dBw9elTZg/aRRx7BQw89hI4dO+K1115DixYt8NZbb7l1k1OmTEF+fr5ynDlzxq3zERF5E+MoEZHrXE4PCAkJQbNmzQAAycnJOHDgAObPn6/kXyUlJan6t2rVCqdPnwYAxMbGIjc3V/X90tJSXLhwAbGxsRVe02q1wmq1unqrROTD7MJAeoBJiwecMY4SkScYiaOOcWbkdiau3W5HUVERGjVqhLi4OBw7dkz1/ePHjyMxMREAkJKSgry8PGRmZirf//zzz2G329GpUyd3b4WITMRRQODqcT1iHCUiI4zGUbPGUpfetE6ZMgW9e/dGQkICLl68iNWrV2PXrl3Ytm0bLBYLnnjiCUybNg3t27dHhw4dsHLlSvz73//GRx99BKDsbUGvXr0watQoLFu2DCUlJRg7diyGDBliqOL1qj0E9nIFBPoLA2RFBZXvvlJskxQQyIoA3NiNRVpAICsWkIyVJf3L2vTs0uLxYgFpYYDOYgHZWIM7o7hVLCAtPtDXJi800FcYoLf4QE8BgbRYwFsFBH76ppVxlHFUeyOMo3raGEe1/O1Nq0uT1tzcXKSlpeHcuXOIiopCu3btsG3bNtx9990AgAkTJqCwsBATJ07EhQsX0L59e+zYsQNNmzZVzrFq1SqMHTsW3bt3R0BAAAYNGoQFCxZ49qmIyOcZWeDarBWv5TGOEpGnGN0owKyx1KVJ6/LlyyvtM3nyZNX6gs6io6OxevVqVy5LRHTdYBwlIjLG8DqtRETu8Nf0ACIiT2F6ABFRNeCklYjIPZy0mshVWzDstvIFBMHSPs5kBQSyQgBtAYFniwVkO69UR7GAXZLg71wwUC3FAnp3VdGdpK9jrI7dXgB5sYA7BQSyYgHdu8DovGfnHV+qfCeXUoMD/4uTVt/AOFp5G+OoUwPjqHacieKoY5wZmXrSSkTmxUkrEZF7/G3Sas6FuoiIiIjIr/BNKxF5hYDry66490EaEdH1xUgcdYwzI05aicgrmB5AROQef0sPMPWktdgeDJQrGtBbLFAo3ZFFsrtLaZBTH33FArKE/xJZYYBkrE13sYD2L5xdMla6I4vkfJp+vl4sIL1u5WP1JuPrLhaQFRrIdmipjh1fnHetkRUL2CWNOn/ldj6fKGEh1vWAcVSNcbTysYyj5o6jjnFmZOpJKxGZFyetRETu4aSViKgacNJKROQef5u0cvUAIiIiIvJ5fNNKRF4hhAXCxd/2Xe1PRHQ9MxJHHePMyNST1qu2INhUO7l4rligrJ86wV+6k4vXdmOR9at8h5ayi+ho81KxgDxxX+c1ZIUAzgUE7uyeordYQNpP33V1Fx9ICgE019BZQCDd8UXGaWiAuwUEsLi8VIuRpV3o2hhHnfsxjmrOxzha6TgzxVHHODMy9aSViMyLOa1ERO7xt5xWTlqJyCuYHkBE5B5/Sw9gIRYRERER+TxTv2ktFkEQ5fKq3Mm7KpKMLXHKdyqWjKuevCt9OVayxa515V0BgPOCytLcKR/Pu9KxkLXHF6KW5V25sVC23nvRcz7pAtiyZ9CbUiXUHQNK9SZxyTE9wDcwjjq3MY5Wdl3GUcn5TRRHHePMyNSTViIyL6YHEBG5x9/SAzhpJSKvEAbeEJg10BIRVQUjcdQxzow4aSUirxDQfFKmawwREZUxEkcd48yIhVhERERE5PNM/aa12B4IUW7hak8WCwDaggFZsYBsUWx5sYD2VbxsYWu9hQG6F7vWubi181hpsrw0ud13igWMFhDIE/QrP1eF9yY7n/Te9PULKJUVMxgrIJBdU7p4to5f3YW7BQSwwMLNBbyOcdT5Ioyjld0L46i546hjnBmZetJKRObFQiwiIvewEIuIqBrYhQUWLnlFRGSYkTjqGGdGnLQSkVcIYaAQy6zVA0REVcBIHHWMMyNOWonIK5geQETkHqYHmEihLRg2W7DytaxYoNiuTfDXUywAaAsGdBcLlMp2Y5Ht2qJvhxb9u7Ho3X2l8qR/2TjpLiC6d1Sp/mIB2TX07qji8R1f3CkWkLTJn0Nc82uggsIAaT9tN809uFlAQL6BcdT5hIyjlV2DcZRx1FtMPWklIvPim1YiIvfwTSsRUTVgIRYRkXtYiEVEVA1YiEVE5B4WYhERVYOyYOtqekAV3QwRkQkZiaOOcWZk6klriS0AwlZ+Jxdtgn+xJOlfT7FA2fnVY0tlhQHSXVuM79Civ1hA2yTfVUXfTivORQW6d3LRex9eKBYAtIn28j76zq+7+ECyg4pbxQIl2h+U9F6cxsruA9LdXbTn11VAYJM8PJkO46ga46hkLOOoGuOo15h60kpE5sVCLCIi97AQi4ioGghIt+uudAwREZUxEkcd48yIk1Yi8gq+aSUicg/ftBIRVQe+aiUico+fvWo19aS1xB4IUa5oQLbTiqxNT7EAoC0EcKtYQFJ8oHs3FsnOK7KxupP+dRQVyBPo9RUjuLPjiyeLBWT9pNfUWRigdycX3YUG7hQLSPo534t0pxV75eMA6CottbCA4LrAOOrUj3G00n6Mo4yj3iKJAERE1eC/H2u5csDAR1q//PILHnzwQdSpUwdhYWFo27YtDh48+L/bEALPPfccGjRogLCwMKSmpuKHH37w5JMSEVUNA3HUSCz1lTjq0qR16dKlaNeuHSIjIxEZGYmUlBRs2bJF008Igd69e8NisWDDhg2q750+fRp9+/ZFjRo1EBMTgyeeeAKlpZJf24jouuZYFNvVwxW///47brvtNgQHB2PLli04evQo/va3v6F27dpKn5dffhkLFizAsmXLsH//foSHh6Nnz54oLCz08BOXYRwlIk8xGkddiaW+FEddSg9o2LAhXnzxRTRv3hxCCKxcuRL9+/fHoUOH0Lp1a6XfvHnzYLFoZ/E2mw19+/ZFbGws9uzZg3PnziEtLQ3BwcGYPXu2+09DRKZRHYVYL730EuLj47FixQqlrXHjxuXOJzBv3jxMnToV/fv3BwC88847qF+/PjZs2IAhQ4a4dD09GEeJyFOqoxDLl+KoS29a+/Xrhz59+qB58+a44YYb8MILLyAiIgL79u1T+mRlZeFvf/sb3nrrLc347du34+jRo3jvvffQoUMH9O7dG7NmzcLixYtRXFzs/tMQkXk4PqJy9QBQUFCgOoqKiqSX2LhxI2666Sbcf//9iImJQceOHfHmm28q3z958iRycnKQmpqqtEVFRaFTp07Yu3dvlTw24ygReYzROOpCLPWlOGq4EMtms2Ht2rW4fPkyUlJSAABXrlzBn//8ZyxevBixsbGaMXv37kXbtm1Rv359pa1nz54YM2YMjhw5go4dO0qvVVRUpPpBFhQUAChL+i+/k0upXTsHlxULyPrJCgFsTkn/bhULyIoAZMUC0l1QdO7GonfHFx2FBgG6r6nz/DoLCDxZLCC7hmyc/D7c2I1FuluK5BqSBH+jxQIAEFCivojs/LoLCCT9tOPc+zjayMf9jv7x8fGq9mnTpmH69Oma/j/99BOWLl2KSZMm4emnn8aBAwcwfvx4hISEID09HTk5OQCgikmOrx3fq0qMo2UYR3Wen3FU28Y4amhLVldiqS/FUZcnrdnZ2UhJSUFhYSEiIiKwfv16JCUlAQAmTpyIzp07K6+HneXk5EgfyvG9isyZMwczZsxw9VaJ6Dp15swZREZGKl9brVZpP7vdjptuukn52Lxjx4747rvvsGzZMqSnp1fLvcowjhKRL9ATS30pjrq8ekCLFi2QlZWF/fv3Y8yYMUhPT8fRo0exceNGfP7555g3b57Hb3LKlCnIz89XjjNnznj8GkRUzYTBA1CKmBxHRZPWBg0aKJNBh1atWuH06dMAoLzJPH/+vKrP+fPnpW85PYVxlIg8wmgcdSGW+lIcdflNa0hICJo1awYASE5OxoEDBzB//nyEhYXhxx9/RK1atVT9Bw0ahNtvvx27du1CbGwsvv76a9X3HQ95rQezWq0V/k+JiMypOgqxbrvtNhw7dkzVdvz4cSQmJgIoKyaIjY3Fzp070aFDBwBlH5s7JpNVhXGUiDyhOgqxfCmOur1Oq91uR1FRESZPnozDhw8jKytLOQDgtddeUyrOUlJSkJ2djdzcXGX8jh07EBkZqZnFE5EfMPBmwBUTJ07Evn37MHv2bJw4cQKrV6/GG2+8gYyMDACAxWLBhAkT8Pzzz2Pjxo3Izs5GWloa4uLiMGDAAA88oD6Mo0RkmMG3rHr5Uhx16U3rlClT0Lt3byQkJODixYtYvXo1du3ahW3btiE2Nlb6W35CQoKyNEKPHj2QlJSEYcOG4eWXX0ZOTg6mTp2KjIwMQ28ASu0BEOWKAUrcKRaQJN/bncZ6vFhAmqSvM3FfNlbvTi7SfurzyZLxpUUAeosK9N6HB4sFZGM9Xiwg241FupOLzjZJ0r+eYgEAsOgpICiV/EFIiwp0FBDYSyrtcy3V8ab15ptvxvr16zFlyhTMnDkTjRs3xrx58zB06FClz5NPPonLly9j9OjRyMvLQ5cuXbB161aEhoa6dC29GEcZR50xjjKOGlUdb1p9KY66NGnNzc1FWloazp07h6ioKLRr1w7btm3D3XffrWt8YGAgNm3ahDFjxiAlJQXh4eFIT0/HzJkzDd08EVFl7rnnHtxzzz0Vft9isWDmzJnVFocYR4nIbHwljro0aV2+fLlLJxeSdRgSExOxefNml85DRNchIx/5G0gR8DWMo0TkMQZTp8waSw2v00pE5B7Lfw9XxxARURkjcdQxznw4aSUi7/DTN61ERB7DN63mUWp32sml3H87yIsFtG3OxQIAYHdKqheScZDunuJGsYA0wd34rioBOsc67/ji1s4r0vuQ9ZPtgiLpZ7BYQNbP48UCkl1W5AUP+nZ8gaRNWiwgKzRwbivRPphFVkBgk7VVXkAANwsIOGn1DYyjlbcxjlZ+TcZRE8VRxzgTcnvJKyIiIiKiqmbqN61EZGLCUna4OoaIiMoYiaOOcSbESSsReYUQZYerY4iIqIyROOoYZ0actBKRdzCnlYjIPX6W02rqSavNblEl69t07tpil7RJd2lxbtNbLCBN2q+GYgFpkYK+sc6J+54uIJAm7ruxC4yeYgHZdaulWEDST164IPkhy3ZV0VMsAGh2aZEWC0iKClCqbROS+3AubhBuFxAwPcAXMI6qMY5Wfl3GUZPHUcc4EzL1pJWIzMsiyg5XxxARURkjcdQxzoy4egARERER+Ty+aSUi72BOKxGRe5jTSkRUDZjTSkTkHua0mkepPQCiXNGAXZLMLysWkPXTtUuLtAhA764t2tPrLRaQJ8brLEiQFQLoSNLXU2RQ0TWlSfUe3vFFd79S56+9VCygczcWaQGB5Hy6dmmR7dAiKxYokRQCSPppdpkRxdo+ruCbVp/AOOp8XUk/xlGnrxlHnZkqjjrGmZCpJ61EZGKctBIRucfPJq0sxCIiIiIin8c3rUTkHXzTSkTkHj9708pJKxF5BwuxiIjcw0Is87DZAoByif/SXVskfzC6dm0BtAUDknxvaVGBLLndnV1W3CkWMLj7it4Eff1FBfruQ3fxgXMyO/Tt0uK1YgG9BQSy3VekRQWSsc5FBXp3aJH1K9YWFQinggS7cG8nF24u4BsYR53aGEclbYyj5Zk9jjrGmZGpJ61EZGJMDyAico+fpQewEIuIiIiIfB4nrURERETk80ydHmCzWVS5WLIFsKV5V5JFsWU5VXDqJ82JkuUi6e6nbQuQLrItGasz78poLpb+haj1tenNsdK/KLbOnC2n3CufyrvSs7A1IF/cWpaL5dTP8GLX0OZdAYAoKlJ/7W4uFgzktLp1RZJhHHUeq6+NcVTHuRhHtW0+EEcd48zI1JNWIjIxrh5AROQerh5ARFQNWIhFROQePyvE4qSViLyDk1YiIvf42aSVhVhERERE5PNM/aZV2AJURQN2SWGAkBQV6CkWALSFANLCAElut2zxbHmyvM6Fsj1dLCBdtNpp8WjdhQGyfnqLD4wtbA3IF8WWP6v6h+fzxQKSfroXt3ZO+je42HV14eYCvoFxtPI2xlHGUdU4k8dRxzgzMvWklYhMjOkBRETu8bP0AE5aicg7OGklInIPJ61ERFWP6QFERO7xt/QAFmIRERERkc8z9ZtWu9OiutJdW2TFAtICAskFNAUE2i66d23RWVSgP0lfZ5uOYgFZP73X1L2jiiThX3exgKRNft3K22TJ/T5fLGBwRxYhO5eOHVqqDTcX8AmMozraGEedzsU4qmkzUxx1jDMhU09aicjEmNNKROQe5rQSEVU95rQSEbnH33JaOWklIu/gm1YiIvf42ZtWFmIRERERkc8z9ZtWYbOoCgSEZDcWo7u2ANqkf93FAjoLDaQ7vrhRaKA7wV/HLjB6CwP07+Sid+cVWTK/9ocify4dO77IChlMWCxgdEcWrxULyBj5WMukbwd8GeNo5W2Mo4yjqj5mj6P/HWdGpp60EpGJMT2AiMg9TA+o2NKlS9GuXTtERkYiMjISKSkp2LJlCwDgwoULGDduHFq0aIGwsDAkJCRg/PjxyM/PV53j9OnT6Nu3L2rUqIGYmBg88cQTKJUtO0FE1zdh8DA5xlEi8hijcdSksdSlN60NGzbEiy++iObNm0MIgZUrV6J///44dOgQhBA4e/YsXn31VSQlJeHnn3/Go48+irNnz+Kjjz4CANhsNvTt2xexsbHYs2cPzp07h7S0NAQHB2P27NlV8oBE5Jv8dfUAxlEi8hR/Wz3AIoRw69ajo6PxyiuvYOTIkZrvrV27Fg8++CAuX76MoKAgbNmyBffccw/Onj2L+vXrAwCWLVuGp556Cr/++itCQkJ0XbOgoABRUVFIeONZBNQIVdrtpZIXxyWSNllOVWnlbQElshwu7enluU6y88v66WvTP5a5WCrMxaq0j16logS78Any8/MRGRmpe5zj32/Tp2cjMDS08gHl2AoL8ePsp12+pq9jHNWennGUcVRPP8ZR1+MoYN5Yajin1WazYe3atbh8+TJSUlKkfRw/jKCgssvs3bsXbdu2VQItAPTs2RNjxozBkSNH0LFjR+l5ioqKUFTuL0lBQQEAQAiLumhAb7GA3gIC57+7OpP7A/ScC+7t+KI3yOkd6xy8pAFeFkT1BnhJkJMHW52BVRKA5ffn1M8uGSfb3cWEgdWnigNIF8bRCvqAcZRxlHGUtFxe8io7OxsRERGwWq149NFHsX79eiQlJWn6/ec//8GsWbMwevRopS0nJ0cVaAEoX+fk5FR4zTlz5iAqKko54uPjXb1tIvI1fpSH5YxxlIg8ws9yWl2etLZo0QJZWVnYv38/xowZg/T0dBw9elTVp6CgAH379kVSUhKmT5/u9k1OmTIF+fn5ynHmzBm3z0lE3uXIxXL1uB4wjhKRJxiNo2aNpS6nB4SEhKBZs2YAgOTkZBw4cADz58/H66+/DgC4ePEievXqhZo1a2L9+vUIDg5WxsbGxuLrr79Wne/8+fPK9ypitVphtVpdvVUi8nUmDZzuYhwlIo/xozjq9o5YdrtdyZMqKChAjx49EBISgo0bNyLUKTk4JSUF2dnZyM3NVdp27NiByMhI6UdjRHQd86OPtCrDOEpEhvhZeoBLb1qnTJmC3r17IyEhARcvXsTq1auxa9cubNu2TQm0V65cwXvvvYeCggIl0b9evXoIDAxEjx49kJSUhGHDhuHll19GTk4Opk6dioyMDENvAITdqYBAtpOL7A9GVhwoTdxXn8+dhH/9RQB6ryGrLDV+L85tbhULyCpXpcUNOttkCf6y+9NTqSorIJCci8UCVFUYRyV9GEe152Ic1TQxjpJLk9bc3FykpaXh3LlziIqKQrt27bBt2zbcfffd2LVrF/bv3w8AysdeDidPnkSjRo0QGBiITZs2YcyYMUhJSUF4eDjS09Mxc+ZMzz0REZmCv67TyjhKRJ7ib+u0ujRpXb58eYXf69q1K/Qs+ZqYmIjNmze7clkiuh4Z+YjKpIG2PMZRIvIYox/1mzSWGl6nlYjIHf76ppWIyFP4ppWIqDr46ZtWIiKP8bM3rW6vHuBVdkulh8UmOeySQ9bPeV0zm+zQjoMdmsMiO6Tn03noPF+A9BCSw6lPqewQmsMiOQJK7PqOYskh6WexCc0RUGLTHBY9R1Gp5kBxieawlNo0B0pKtUep9hAlJZpD2q+4RHvYbNqjqEhzkDEvvvgiLBYLJkyYoLQVFhYiIyMDderUQUREBAYNGqQsIeUXGEcZRxlHyQXejKPmnrQSkXlV8zItBw4cwOuvv4527dqp2idOnIh//OMfWLt2LXbv3o2zZ89i4MCBxi9ERFRdqnnJK2/HUU5aicgrqnMXl0uXLmHo0KF48803Ubt2baU9Pz8fy5cvx9y5c9GtWzckJydjxYoV2LNnD/bt2+ehJyUiqhrVuSOWL8RRTlqJyDvceDvgWL/UcRRV8lFfRkYG+vbti9TUVFV7ZmYmSkpKVO0tW7ZEQkIC9u7d64mnJCKqOm6+aXUllvpCHOWklYi8w41AGx8fj6ioKOWYM2dOhZf54IMP8M0330j75OTkICQkBLVq1VK1169fHzk5OW4+IBFRFXNz0qo3lvpKHDX36gGOQgEH2etuyS4o0l1bdPSzSHaK0b3zis4dX+S7sWgfzJ0dX+Q7uaj76d6hpUR7UemuLZJ+8t1iJA8h231FtruLbKzTTivS3VgkO6XAJjmXbEcV7tBimDtLXp05cwaRkZFKe0U7QZ05cwZ//etfsWPHDs12qPRfjKM6rsE4qu7DOOor3F3ySk8s9aU4yjetRGQ6kZGRqqOiSWtmZiZyc3Nx4403IigoCEFBQdi9ezcWLFiAoKAg1K9fH8XFxcjLy1ONO3/+PGJjY6vhSYiIvEdPLPWlOGruN61EZF5GKlhd7N+9e3dkZ2er2h566CG0bNkSTz31FOLj4xEcHIydO3di0KBBAIBjx47h9OnTSElJcfHmiIiqmdGVAFwY40txlJNWIvKK6tgRq2bNmmjTpo2qLTw8HHXq1FHaR44ciUmTJiE6OhqRkZEYN24cUlJScOutt7p2MSKialYdO2L5UhzlpJWIvKMa3rTq8dprryEgIACDBg1CUVERevbsiSVLlnj+QkREnlYNb1r1qK44au5Jq2OnlP+SJfhDSJL+ZYn2kj9A50R73YUBOosF9Cb8y4sK3LiGXXYN4XKfitp0FwuUaG9YWgQgKyCQnM+5WKDsfLZK+0gT/iXXlBYasFjAOC9NWnft2qX6OjQ0FIsXL8bixYvdP7kZMY4auwbjqBrjqHd4adLqrTjKQiwiIiIi8nnmftNKRKZl+e/h6hgiIipjJI46xpkRJ61E5B0+ktNKRGRaPpLTWl04aSUir6iO1QOIiK5n1bF6gC8x96RVWNQFArIiAGkCveTFuI6iAuluLzoKDyq8Dzf6yYoK5An+kn6SHHpNsYTeHWVkO77oLRbQW0Ag231FWlRQ+U4u0oR/nbuxQFJUIWTnY7GAPnzT6hsYR53aGEc1GEd9l5+9aWUhFhERERH5PHO/aSUiczPpb/tERD7Dj+IoJ61E5BXMaSUicg9zWomIqgNzWomI3ONnOa3mnrQ6/2Hp3FVFmvQvLT5wKjTQu2uL7kIGWfK9zrGyZH6dSf8BsqR/pzZZIr/0mrIdX2Rjdbbp2o0FkO+qIisgcOqnt1hA724sMiwW0IdvWn0E42jlYxlHVV8yjvoOvmklIqoOfNNKROQeP3vTytUDiIiIiMjn8U0rEXkF0wOIiNzD9AAiourA9AAiIvf4WXqAuSetzn9YQrJDi85iAVlxgHObe8UC1dEm28lFZ9K/Uz/pOFnCv+Rcsl1WpG2SwgBpsYCkqECa9C+7hnPSvxvFAiwM8DBOWn0D46hTG+OoBuOo7+KklYio6jE9gIjIPf6WHsBCLCIiIiLyeXzTSkTewfQAIiL3MD3APCzCAku5/Cvp62438rN0vT7XkcNVYZv0fiX3IVs8W3K+AOmi2HrbnBfFli26LcnhKpHlU+lbUFuanyVbeFqWP6VzcWvnXDEhOxfzrrzCIgQswrXI6Wp/qhzjqBrjKOOomRiJo45xZmTqSSsRmRjftBIRuYdvWomIqh4LsYiI3MNCLCIiIiIiH8M3rUTkHUwPICJyD9MDTESzKLa2i7yoQNZWeaGB3iIDeZu+IgDdbW4VH1ReHCBdOFtWGKCzTbawtcUmKyDQtkkXu3ZjcWtNHxYLeAXTA3wE46ga46i2jXHUZ/lbeoC5J61EZF5800pE5B4/e9PqUk7r0qVL0a5dO0RGRiIyMhIpKSnYsmWL8v3CwkJkZGSgTp06iIiIwKBBg3D+/HnVOU6fPo2+ffuiRo0aiImJwRNPPIFS2RIbRHRdc7whcPUwO8ZRIvIUo3HUrLHUpUlrw4YN8eKLLyIzMxMHDx5Et27d0L9/fxw5cgQAMHHiRPzjH//A2rVrsXv3bpw9exYDBw5UxttsNvTt2xfFxcXYs2cPVq5cibfffhvPPfecZ5+KiHyfMHiYHOMoEXmM0Thq0ljqUnpAv379VF+/8MILWLp0Kfbt24eGDRti+fLlWL16Nbp16wYAWLFiBVq1aoV9+/bh1ltvxfbt23H06FF89tlnqF+/Pjp06IBZs2bhqaeewvTp0xESEuK5JyMi8kGMo0RExhjOabXZbFi7di0uX76MlJQUZGZmoqSkBKmpqUqfli1bIiEhAXv37sWtt96KvXv3om3btqhfv77Sp2fPnhgzZgyOHDmCjh07Sq9VVFSEonJJ3gUFBWX/oaOAwK1dW5zbdBcjGG/zdGGAbAcZ2a4qmgIH6bkkJ5Mm98t2d5Ek8kuKCqQ7ucjaJPfHHVnMx6wfUXkK42jVtDGO6ouZjKPXB3+Koy6v05qdnY2IiAhYrVY8+uijWL9+PZKSkpCTk4OQkBDUqlVL1b9+/frIyckBAOTk5KgCreP7ju9VZM6cOYiKilKO+Ph4V2+biHyNEMaO6wDjKBF5hNE4atJY6vKktUWLFsjKysL+/fsxZswYpKen4+jRo1Vxb4opU6YgPz9fOc6cOVOl1yOiqudPxQPOGEeJyBP8rRDL5fSAkJAQNGvWDACQnJyMAwcOYP78+Rg8eDCKi4uRl5enektw/vx5xMbGAgBiY2Px9ddfq87nqIp19JGxWq2wWq2u3ioR+TIjxQAmDbTOGEeJyCOMFlWZNJa6vY2r3W5HUVERkpOTERwcjJ07dyrfO3bsGE6fPo2UlBQAQEpKCrKzs5Gbm6v02bFjByIjI5GUlOTurRARmRLjKBFR5Vx60zplyhT07t0bCQkJuHjxIlavXo1du3Zh27ZtiIqKwsiRIzFp0iRER0cjMjIS48aNQ0pKCm699VYAQI8ePZCUlIRhw4bh5ZdfRk5ODqZOnYqMjAxTvAFwbycXfW3uFRUYHwvnnVwkO6pICw8kbdKiAllhgGw3lhLtbizSflyT0vQsdvnf2crGmB3jaNW3MY4yjvoLI3HUMc6MXJq05ubmIi0tDefOnUNUVBTatWuHbdu24e677wYAvPbaawgICMCgQYNQVFSEnj17YsmSJcr4wMBAbNq0CWPGjEFKSgrCw8ORnp6OmTNnevapiMj3+Wl6AOMoEXmMn6UHuDRpXb58+TW/HxoaisWLF2Px4sUV9klMTMTmzZtduSwRXYeMFAOYtXigPMZRIvIUo0VVZo2lhtdpJSJyi5FlV0y6TAsRUZUwunyVSWOp24VYRERERERV7bp606o7Wd6dxP3rgGbXFmifVf6z1FcsICs+gKRNSHeBkRQLFGuLCrhri/n5a3qAr2Mc1YdxlHwB0wOIiKqDnxZiERF5DAuxiIiqHt+0EhG5h29aiYiqAwuxiIjc42eFWJy0EpFX8E0rEZF7+KbVTIzmclwH9BdL+PAPyC4rSNC2sViAqAoxjqoxjhL5LHNPWonIvFiIRUTkHhZiERFVPaYHEBG5h+kBRETVwS7kH21WNoaIiMoYiaOOcSbESSsReQfTA4iI3ONn6QHcxpWIiIiIfB7ftBKRV1hgIKe1Su6EiMicjMRRxzgz4qSViLyDmwsQEbnHzzYXYHoAEXmFo+rV1cMVc+bMwc0334yaNWsiJiYGAwYMwLFjx1R9CgsLkZGRgTp16iAiIgKDBg3C+fPnPfikRERVw2gcdSWW+lIc5aSViLxDGDxcsHv3bmRkZGDfvn3YsWMHSkpK0KNHD1y+fFnpM3HiRPzjH//A2rVrsXv3bpw9exYDBw50//mIiKqa0TjqQiz1pTjK9AAium5t3bpV9fXbb7+NmJgYZGZm4o477kB+fj6WL1+O1atXo1u3bgCAFStWoFWrVti3bx9uvfVWb9w2EZHP8KU4yjetROQVFiEMHQBQUFCgOop0bkeZn58PAIiOjgYAZGZmoqSkBKmpqUqfli1bIiEhAXv37vXwExMReZbROOpOLPVmHOWklYi8w27wABAfH4+oqCjlmDNnTuWXs9sxYcIE3HbbbWjTpg0AICcnByEhIahVq5aqb/369ZGTk+OBhyQiqkJG46jBWOrtOMr0ACLyivK/7bsyBgDOnDmDyMhIpd1qtVY6NiMjA9999x2++uor126UiMhHGYmjjnGA67HU23GUk1Yi8g43dsSKjIxUBdrKjB07Fps2bcKXX36Jhg0bKu2xsbEoLi5GXl6e6i3B+fPnERsb6+LNERFVMzd3xHIllvpCHDV3eoDF6fAjwqI9ND8PCwCLRXv4igCLrsMSGKg9rFbNQSbjWF/Q1cOlSwiMHTsW69evx+eff47GjRurvp+cnIzg4GDs3LlTaTt27BhOnz6NlJQUjzymz2McZRxlHDUvo3HUhVjqS3GUb1qJ6LqVkZGB1atX45NPPkHNmjWV/KqoqCiEhYUhKioKI0eOxKRJkxAdHY3IyEiMGzcOKSkpXDmAiAi+FUc5aSUirzCyWYCr/ZcuXQoA6Nq1q6p9xYoVGD58OADgtddeQ0BAAAYNGoSioiL07NkTS5Ysce1CREReYCSOOsbp5UtxlJNWIvKOatjGVejoHxoaisWLF2Px4sWu3QsRkbdVwzauvhRHOWklIq+w2MsOV8cQEVEZI3HUMc6MrqtJq5Dkxkvz5XW2yc53PRCSH4rzs8p/lpLGAG0tnwjUtllkbTbJ2CDtX0mLXftbnrDZtPdC5lINb1rJdYyj+jCOkk+ohjetvsTcqwcQERERkV+4rt60EpGJuLFOKxERwe11Ws2Gk1Yi8gp3dsQiIiL3d8QyG05aicg7mNNKROQeP8tp5aTVBbKkek+36S5kkPWTZCjrHYtAdaOsCEAESsoN7dqTWSRFBQgMlLTJzidpCyjVXkN2PsluLqKoSNuPfIMA4GoFqznjLJXDOMo4Sh5kJI46xpkQC7GIiIiIyOfxTSsReQVzWomI3MOcViKi6iBgIKe1Su6EiMicjMRRxzgTMvek1QJ1XpEbuU26FtR2Y4FttxbiluZdSRa2liV7BEgWlA6UjLWp2yyS88sWwJadH0HaPCkhybHiQtl+joVYvoFx1KlNMpZxlHwVC7GIiKqBHfJJSGVjiIiojJE46hhnQi4VYs2ZMwc333wzatasiZiYGAwYMADHjh1T9cnJycGwYcMQGxuL8PBw3HjjjVi3bp2qz4ULFzB06FBERkaiVq1aGDlyJC5duuT+0xCRaThysVw9zI5xlIg8xWgcNWssdWnSunv3bmRkZGDfvn3YsWMHSkpK0KNHD1y+fFnpk5aWhmPHjmHjxo3Izs7GwIED8cADD+DQoUNKn6FDh+LIkSPYsWMHNm3ahC+//BKjR4/23FMREfkoxlEiImNcSg/YunWr6uu3334bMTExyMzMxB133AEA2LNnD5YuXYpbbrkFADB16lS89tpryMzMRMeOHfH9999j69atOHDgAG666SYAwMKFC9GnTx+8+uqriIuL88RzEZGv89OcVsZRIvIY5rTql5+fDwCIjo5W2jp37ow1a9agb9++qFWrFj788EMUFhaia9euAIC9e/eiVq1aSqAFgNTUVAQEBGD//v247777NNcpKipCUbnFjQsKCsr+Q0cBga7CAACwSP4AnTq6twC2LOFfkgQvW9jajcWu9RYaOBcVOBcUAIA9SDswQLaItQ8vlM1Fsn2In05anTGOMo4yjpJhfjZpNby5gN1ux4QJE3DbbbehTZs2SvuHH36IkpIS1KlTB1arFY888gjWr1+PZs2aASjL1YqJiVGdKygoCNHR0cjJyZFea86cOYiKilKO+Ph4o7dNRL7CEWxdPa4jjKNE5BajcdSksdTwpDUjIwPfffcdPvjgA1X7s88+i7y8PHz22Wc4ePAgJk2ahAceeADZ2dmGb3LKlCnIz89XjjNnzhg+FxH5CLvB4zrCOEpEbjEaR00aSw2lB4wdO1ZJ/G/YsKHS/uOPP2LRokX47rvv0Lp1awBA+/bt8c9//hOLFy/GsmXLEBsbi9zcXNX5SktLceHCBcTGxkqvZ7VaYZXsh0xEZFaMo0RErnHpTasQAmPHjsX69evx+eefo3HjxqrvX7lypeykTnk3gYGBsP83nyYlJQV5eXnIzMxUvv/555/DbrejU6dOhh6CiMzHn5ZpKY9xlIg8xd+WvHLpTWtGRgZWr16NTz75BDVr1lRyp6KiohAWFoaWLVuiWbNmeOSRR/Dqq6+iTp062LBhg7IkCwC0atUKvXr1wqhRo7Bs2TKUlJRg7NixGDJkiMsVr8IiIMon/kuS9C06CgPKziU7v9Mw2U1Id0/R2eZWEYD2ueyS/HmL5CMAIW1zKiCQ7PZikRQGcHcXMsxPC7EYRyUYRyVtjKOkAwuxKrZ06VLk5+eja9euaNCggXKsWbMGABAcHIzNmzejXr166NevH9q1a4d33nkHK1euRJ8+fZTzrFq1Ci1btkT37t3Rp08fdOnSBW+88YZnn4yIfJtdGDtMjnGUiDzGaBw1aSx16U2r0DEzb968uWbnFmfR0dFYvXq1K5cmouuNn75pZRwlIo/hm1YiIiIiIt/i1uYCRETGGXlDYM63A0REVcPomqvmjKXmnrRqdnIxXixg0ZH0L90BRZaMr3c3Fo+36dy1RUebrIDgutjdRbLkD3d38RI/TQ/wOYyjTm2Mo5prMI76Lj9LDzD3pJWIzMsu4PJv+yYtHiAiqhJG4qgyznw4aSUi7xB2+Su2ysYQEVEZI3HUMc6EOGklIu9gegARkXv8LD2AqwcQERERkc8z95tW5wICncnykpoC+U4uTjuSWPQm6EvPJWuTnC9QshuJrEhBluAvyVExuruL884uFV3T53d3cW4o1t4Giwq8hDmtvoFx1Kkf46imn3MD46jvYE4rEVE1YHoAEZF7/Cw9gJNWIvIOAQOT1iq5EyIiczISRx3jTIiTViLyDr5pJSJyD9+0+j7H3t32wkJVu6VUkiskaUOJrJ/kOqXOX+scV1L5uSpuk+Ri6T6fJBdLej5tW4BTW4BkXECpNk9K2mazadosNkmOlaQfbNqHtdglPwC79gcgZP2cflBC8sMUkmQ3nq9oWAAADMRJREFUWT9SK0XZz0iYNPj5O8ZRxlHGUe9jHHWNKSetFy9eBACcnTzby3dCRBcvXkRUVJTrA+12AC6uFSjbwYcMYRwl8h3VGkeVceZjyklrXFwczpw5g5o1a8IiK2H1ooKCAsTHx+PMmTOIjIz09u0YwmfwDb7+DEIIXLx4EXFxcUZPwPQAL2IcrXrXw3PwGaqWV+KoY5wJmXLSGhAQgIYNG3r7Nq4pMjLS5/5xuIrP4Bt8+RkMvRlw4KTVqxhHq8/18Bx8hqpT7XHUMc6ETDlpJaLrANdpJSJyj5+t08odsYiIiIjI5/FNq4dZrVZMmzYNVsnuIGbBZ/AN18MzXIsQdmnFcWVj6Pp3vfzdvx6eg8/g24zEUcc4M7IIrrNARNWooKAAUVFR6F4rDUGWEJfGlopi7Mx7B/n5+T6Zm0ZEVB3ciaOAeWMp37QSkXcIA7lY/B2biOh/jMRRZZz5cNJKRN5htwMWFz+iMulHWkREVcJIHAVMG0s5aSUi7+CbViIi9/jZm1auHkBEREREPs/vJq1Lly5Fu3btlEWGU1JSsGXLFuX7OTk5GDZsGGJjYxEeHo4bb7wR69atk56rqKgIHTp0gMViQVZWltI+ffp0WCwWzREeHq4an5eXh4yMDDRo0ABWqxU33HADNm/erOqzePFiNGrUCKGhoejUqRO+/vprn3qGefPmoUWLFggLC0N8fDwmTpyIQqe9zL31DACwbds23HrrrahZsybq1auHQYMG4dSpU6o+u3btwo033gir1YpmzZrh7bff1lzDl5/h448/xt1334169eop97Ft2zZdz+BNwm43dJD3+VIMYhz1fgwCGEe9xWgcNW0sFX5m48aN4tNPPxXHjx8Xx44dE08//bQIDg4W3333nRBCiLvvvlvcfPPNYv/+/eLHH38Us2bNEgEBAeKbb77RnGv8+PGid+/eAoA4dOiQ0n7x4kVx7tw51ZGUlCTS09OVPkVFReKmm24Sffr0EV999ZU4efKk2LVrl8jKylL6fPDBByIkJES89dZb4siRI2LUqFGiVq1a4p133vGJZ1i1apWwWq1i1apV4uTJk2Lbtm2iQYMGYuLEiT7xDD/99JOwWq1iypQp4sSJEyIzM1PccccdomPHjqo+NWrUEJMmTRJHjx4VCxcuFIGBgWLr1q2meYa//vWv4qWXXhJff/21OH78uJgyZYoIDg5WXaeiZzh//rzmXqpafn6+ACC6hQ0WPWoMc+noFjZYABD5+fnVft/0P4yjnnsGxlHfeAZ/iqNmjqV+N2mVqV27tvj73/8uhBAiPDxcvPPOO6rvR0dHizfffFPVtnnzZtGyZUtx5MgRzT8QZ1lZWQKA+PLLL5W2pUuXiiZNmoji4uIKx91yyy0iIyND+dpms4m4uDgxZ84cn3iGjIwM0a1bN1W/SZMmidtuu80nnmHt2rUiKChI2Gw2pW3jxo3CYrEoP/cnn3xStG7dWnXOwYMHi549e5rmGWSSkpLEjBkzDD1DVVOCrfUB0SP0QZeObtYHTBlo/QHjKONoeYyjVcudOGrmWOp36QHl2Ww2fPDBB7h8+TJSUlIAAJ07d8aaNWtw4cIF2O12fPDBBygsLETXrl2VcefPn8eoUaPw7rvvokaNGpVe5+9//ztuuOEG3H777Urbxo0bkZKSgoyMDNSvXx9t2rTB7NmzYbPZAADFxcXIzMxEamqqMiYgIACpqanYu3evTzxD586dkZmZqXw88tNPP2Hz5s3o06ePTzxDcnIyAgICsGLFCthsNuTn5+Pdd99FamoqgoODAQB79+5V3R8A9OzZU7k/MzyDM7vdjosXLyI6OtqlZ6h2QpRVsLp0mLN44HrGOMo4yjhqtjhq4ljq7VmzNxw+fFiEh4eLwMBAERUVJT799FPle7///rvo0aOHACCCgoJEZGSk2LZtm/J9u90uevXqJWbNmiWEEOLkyZPX/O366tWronbt2uKll15Stbdo0UJYrVYxYsQIcfDgQfHBBx+I6OhoMX36dCGEEL/88osAIPbs2aMa98QTT4hbbrnFJ55BCCHmz58vgoODRVBQkAAgHn30UeV7vvAMu3btEjExMSIwMFAAECkpKeL3339Xvt+8eXMxe/Zs1ZhPP/1UABBXrlwxxTM4e+mll0Tt2rWVj6wqe4bqprwhCLlf9LD+2aWjW8j9pnw7cD3yhRjEOOobMYhx1Fxx1Myx1C/ftLZo0QJZWVnYv38/xowZg/T0dBw9ehQA8OyzzyIvLw+fffYZDh48iEmTJuGBBx5AdnY2AGDhwoW4ePEipkyZouta69evx8WLF5Genq5qt9vtiImJwRtvvIHk5GQMHjwYzzzzDJYtW2aaZ9i1axdmz56NJUuW4JtvvsHHH3+MTz/9FLNmzfKJZ8jJycGoUaOQnp6OAwcOYPfu3QgJCcEf//hHCA/9lulrz7B69WrMmDEDH374IWJiYjzyjFVF2IWhg3yDL8QgxlHfi0FG+Noz+EMcNW0s9e6c2Td0795djB49Wpw4cUIAUBLAy3//kUceEUII0b9/fxEQECACAwOVA4AIDAwUaWlpmnN369ZNDBgwQNN+xx13iO7du6vaNm/eLACIoqIiUVRUJAIDA8X69etVfdLS0sS9997rE8/QpUsX8fjjj6va3n33XREWFiZsNpvXn2Hq1KnipptuUp3jzJkzAoDYu3evEEKI22+/Xfz1r39V9XnrrbdEZGSkEEKY4hkc3n//fREWFiY2bdqkanf1Gaqa4w3BXYEDxd1Bg1067gocaOjtwKJFi0RiYqKwWq3illtuEfv376+ip/NfjKOMo+UxjlYtd+Ko0VjqC3HUL9+0OrPb7SgqKsKVK1cAlOWplBcYGAj7f5eHWLBgAb799ltkZWUhKytLWVplzZo1eOGFF1TjTp48iS+++AIjR47UXPO2227DiRMnlPMCwPHjx9GgQQOEhIQgJCQEycnJ2Llzp+o+d+7cqeT6ePsZrly5Ir0OAAghvP4M17o/x3lSUlJU9wcAO3bsUO7PDM8AAO+//z4eeughvP/+++jbt6+qv6vPUF2q6+3AmjVrMGnSJEybNg3ffPMN2rdvj549eyI3N7cKnsp/MY4yjpbHOFo9qutNq8/E0WqfJnvZ5MmTxe7du8XJkyfF4cOHxeTJk4XFYhHbt28XxcXFolmzZuL2228X+/fvFydOnBCvvvqqsFgsqhyb8q6VxzR16lQRFxcnSktLNd87ffq0qFmzphg7dqw4duyY2LRpk4iJiRHPP/+80ueDDz4QVqtVvP322+Lo0aNi9OjRolatWmLcuHE+8QzTpk0TNWvWFO+//7746aefxPbt20XTpk3FAw884BPPsHPnTmGxWMSMGTPE8ePHRWZmpujZs6dITEwUV65cEUL8b6mWJ554Qnz//fdi8eLF0qVafPkZVq1aJYKCgsTixYtVS+vk5eVV+gw5OTnSe6lKjjcEXdFfpFr+6NLRFf1dfjvgSxW/1wvGUc89A+OobzyDP8VRI7HUV+Ko301aR4wYIRITE0VISIioV6+e6N69u9i+fbvy/ePHj4uBAweKmJgYUaNGDdGuXTvNchvlVRSobDabaNiwoXj66acrHLtnzx7RqVMnYbVaRZMmTcQLL7ygCWoLFy4UCQkJIiQkRNxyyy1i3759PvMMJSUlYvr06aJp06YiNDRUxMfHi7/85S+a5HZvPsP7778vOnbsKMLDw0W9evXEvffeK77//ntVny+++EJ06NBBhISEiCZNmogVK1Zozu/Lz3DnnXc69vFTHeXXgqzoGbzBEWy7oI/oiv4uHV3QRwAQZ86cEfn5+cpRWFgovZavfaR3vfCVGCQE46gvxCAhGEermztx1NVY6ktx1CKEWdc9ICIzKiwsROPGjZGTk2NofEREBC5duqRqmzZtGqZPn67pe/bsWfzhD3/Anj17VB/hPfnkk9i9ezf2799v6B6IiLzJ3TgK6I+lvhRHg6rtSkREAEJDQ3Hy5EkUFxcbGi+EgMViUbVZrVZP3BoRkSm4G0cBc8ZSTlqJqNqFhoYiNDS0yq9Tt25dBAYG4vz586r28+fPIzY2tsqvT0RUVfwxjnL1ACK6bvlqxS8RkVn4Uhzlm1Yiuq5NmjQJ6enpuOmmm3DLLbdg3rx5uHz5Mh566CFv3xoRkSn4ShzlpJWIrmuDBw/Gr7/+iueeew45OTno0KEDtm7divr163v71oiITMFX4ihXDyAiIiIin8ecViIiIiLyeZy0EhEREZHP46SViIiIiHweJ61ERERE5PM4aSUiIiIin8dJKxERERH5PE5aiYiIiMjncdJKRERERD6Pk1YiIiIi8nmctBIRERGRz+OklYiIiIh83v8DFrlacp7P/EAAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 800x900 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 2, figsize=(8, 9))\n",
+    "axes = axes.flatten()\n",
+    "threshold_criteria_value = 8.0\n",
+    "threshold_criteria = \"higher\"\n",
+    "\n",
+    "with rasterio.open(SMALL_RASTER_PATH) as raster:\n",
+    "    raster_data = raster.read(1)\n",
+    "    raster_profile = raster.profile\n",
+    "raster_transform = raster_profile[\"transform\"]\n",
+    "\n",
+    "_plot_image = partial(_plot_image, transform=raster_transform)\n",
+    "\n",
+    "_plot_image(ax=axes[0], data=raster_data, title=\"All data\")\n",
+    "\n",
+    "raster_data_fits_criteria = _fits_criteria(threshold_criteria_value=threshold_criteria_value, threshold_criteria=threshold_criteria, anomaly_raster_data=raster_data)\n",
+    "raster_data_criteria = np.where(raster_data_fits_criteria, raster_data, np.nan)\n",
+    "_plot_image(ax=axes[1], data=raster_data_criteria, title=\"Data fitting criteria (anomaly)\")\n",
+    "\n",
+    "distance_matrix = distance_to_anomaly(\n",
+    "    raster_profile=raster_profile,\n",
+    "    anomaly_raster_data=raster_data,\n",
+    "    anomaly_raster_profile=raster_profile,\n",
+    "    threshold_criteria_value=threshold_criteria_value,\n",
+    "    threshold_criteria=threshold_criteria,\n",
+    ")\n",
+    "_plot_image(ax=axes[2], data=distance_matrix, title=\"Distance to nearest anomaly (distance_computation)\")\n",
+    "\n",
+    "with TemporaryDirectory() as tmp_dir_str:\n",
+    "    distance_path = Path(tmp_dir_str) / \"distance_to_anomaly_gdal.tif\"\n",
+    "    try:\n",
+    "        distance_path = distance_to_anomaly_gdal(\n",
+    "            anomaly_raster_data=raster_data,\n",
+    "            anomaly_raster_profile=raster_profile,\n",
+    "            threshold_criteria_value=threshold_criteria_value,\n",
+    "            threshold_criteria=threshold_criteria,\n",
+    "            output_path=distance_path,\n",
+    "        )\n",
+    "        with rasterio.open(distance_path) as distance_raster:\n",
+    "            _plot_image(ax=axes[3], data=distance_raster.read(1), title=\"Distance to nearest anomaly (gdal_proximity.py)\")\n",
+    "    except ModuleNotFoundError as exc:\n",
+    "        print(\"distance_to_anomaly_gdal does not work on windows.\")\n",
+    "        print(exc)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/raster_processing/test_distance_to_anomaly.py b/tests/raster_processing/test_distance_to_anomaly.py
new file mode 100644
index 00000000..83db9fc0
--- /dev/null
+++ b/tests/raster_processing/test_distance_to_anomaly.py
@@ -0,0 +1,125 @@
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+import rasterio
+import rasterio.plot
+
+from eis_toolkit.raster_processing import distance_to_anomaly
+from tests.raster_processing.clip_test import raster_path as SMALL_RASTER_PATH
+
+with rasterio.open(SMALL_RASTER_PATH) as raster:
+    SMALL_RASTER_PROFILE = raster.profile
+    SMALL_RASTER_DATA = raster.read(1)
+
+EXPECTED_SMALL_RASTER_SHAPE = SMALL_RASTER_PROFILE["height"], SMALL_RASTER_PROFILE["width"]
+
+
+@pytest.mark.parametrize(
+    ",".join(
+        [
+            "raster_profile",
+            "anomaly_raster_profile",
+            "anomaly_raster_data",
+            "threshold_criteria_value",
+            "threshold_criteria",
+            "expected_shape",
+            "expected_mean",
+        ]
+    ),
+    [
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            6.451948,
+            id="small_raster_higher",
+        ),
+    ],
+)
+def test_distance_to_anomaly(
+    raster_profile,
+    anomaly_raster_profile,
+    anomaly_raster_data,
+    threshold_criteria_value,
+    threshold_criteria,
+    expected_shape,
+    expected_mean,
+):
+    """Test distance_to_anomaly."""
+
+    result = distance_to_anomaly.distance_to_anomaly(
+        raster_profile=raster_profile,
+        anomaly_raster_profile=anomaly_raster_profile,
+        anomaly_raster_data=anomaly_raster_data,
+        threshold_criteria_value=threshold_criteria_value,
+        threshold_criteria=threshold_criteria,
+    )
+
+    assert isinstance(result, np.ndarray)
+    assert result.shape == expected_shape
+    if expected_mean is not None:
+        assert np.isclose(np.mean(result), expected_mean)
+
+
+@pytest.mark.parametrize(
+    ",".join(
+        [
+            "anomaly_raster_profile",
+            "anomaly_raster_data",
+            "threshold_criteria_value",
+            "threshold_criteria",
+            "expected_shape",
+            "expected_mean",
+        ]
+    ),
+    [
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            6.452082,
+            id="small_raster_higher",
+        ),
+    ],
+)
+@pytest.mark.xfail(
+    sys.platform == "win32", reason="GDAL utilities are not available on Windows.", raises=ModuleNotFoundError
+)
+def test_distance_to_anomaly_gdal(
+    anomaly_raster_profile,
+    anomaly_raster_data,
+    threshold_criteria_value,
+    threshold_criteria,
+    expected_shape,
+    expected_mean,
+    tmp_path,
+):
+    """Test distance_to_anomaly_gdal."""
+
+    output_path = tmp_path / "output.tif"
+    result = distance_to_anomaly.distance_to_anomaly_gdal(
+        anomaly_raster_profile=anomaly_raster_profile,
+        anomaly_raster_data=anomaly_raster_data,
+        threshold_criteria_value=threshold_criteria_value,
+        threshold_criteria=threshold_criteria,
+        output_path=output_path,
+    )
+
+    assert isinstance(result, Path)
+    assert result.is_file()
+
+    with rasterio.open(result) as result_raster:
+
+        assert result_raster.meta["dtype"] in {"float32", "float64"}
+        result_raster_data = result_raster.read(1)
+
+    assert result_raster_data.shape == expected_shape
+    if expected_mean is not None:
+        assert np.isclose(np.mean(result_raster_data), expected_mean)

From 5b0057c78d47090d90d64da23b8af0871982aa5e Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Wed, 14 Feb 2024 11:29:12 +0200
Subject: [PATCH 02/17] docs: fix names

---
 docs/raster_processing/distance_to_anomaly.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/raster_processing/distance_to_anomaly.md b/docs/raster_processing/distance_to_anomaly.md
index b30a7983..211bb86a 100644
--- a/docs/raster_processing/distance_to_anomaly.md
+++ b/docs/raster_processing/distance_to_anomaly.md
@@ -1,3 +1,3 @@
-# Distance computation
+# Distance to anomaly
 
-::: eis_toolkit.vector_processing.distance_computation
+::: eis_toolkit.raster_processing.distance_to_anomaly

From 1dc9c8608bd68fdbd5e605b407766c9fddd1e80a Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Wed, 14 Feb 2024 11:46:20 +0200
Subject: [PATCH 03/17] refactor: use Number as type

---
 eis_toolkit/raster_processing/distance_to_anomaly.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index 2f700fb9..30fad1d0 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -1,4 +1,5 @@
 from itertools import chain
+from numbers import Number
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
@@ -13,7 +14,7 @@
 from eis_toolkit.utilities.miscellaneous import row_points, toggle_gdal_exceptions
 from eis_toolkit.vector_processing.distance_computation import distance_computation
 
-THRESHOLD_CRITERIA_VALUE_TYPE = Union[Tuple[float, float], float]
+THRESHOLD_CRITERIA_VALUE_TYPE = Union[Tuple[Number, Number], Number]
 THRESHOLD_CRITERIA_TYPE = Literal["lower", "higher", "in_between", "outside"]
 
 
@@ -142,7 +143,7 @@ def _write_binary_anomaly_raster(tmp_dir: Path, anomaly_raster_profile, data_fit
 def _distance_to_anomaly_gdal(
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: Union[Tuple[float, float], float],
+    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
     threshold_criteria: THRESHOLD_CRITERIA_TYPE,
     output_path: Path,
     verbose: bool,
@@ -175,7 +176,7 @@ def _distance_to_anomaly(
     raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: Union[Tuple[float, float], float],
+    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
     threshold_criteria: THRESHOLD_CRITERIA_TYPE,
 ) -> np.ndarray:
     data_fits_criteria = _fits_criteria(

From 7775bfbe0ef1e33176aab9367eabaac4d8a86536 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 23 Feb 2024 15:33:09 +0200
Subject: [PATCH 04/17] fix(distance_to_anomaly): apply review suggestions

Based on review by @nmaarnio and @em-t, updated faulty documentation,
simplified inputs and outputs and made a separate check for raster
profile values.
---
 .../raster_processing/distance_to_anomaly.py  | 65 ++++++++-----------
 eis_toolkit/utilities/checks/raster.py        | 29 +++++++++
 .../vector_processing/distance_computation.py | 16 ++---
 3 files changed, 59 insertions(+), 51 deletions(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index 30fad1d0..81851dcd 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -8,24 +8,20 @@
 import rasterio
 from beartype import beartype
 from beartype.typing import Literal, Tuple, Union
-from rasterio import profiles, transform
+from rasterio import profiles
 
-from eis_toolkit.exceptions import InvalidParameterValueException
+from eis_toolkit.utilities.checks.raster import check_raster_profile
 from eis_toolkit.utilities.miscellaneous import row_points, toggle_gdal_exceptions
 from eis_toolkit.vector_processing.distance_computation import distance_computation
 
-THRESHOLD_CRITERIA_VALUE_TYPE = Union[Tuple[Number, Number], Number]
-THRESHOLD_CRITERIA_TYPE = Literal["lower", "higher", "in_between", "outside"]
-
 
 @beartype
 def distance_to_anomaly(
-    raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
-    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
-) -> np.ndarray:
+    threshold_criteria_value: Union[Tuple[Number, Number], Number],
+    threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
+) -> Tuple[np.ndarray, Union[profiles.Profile, dict]]:
     """Calculate distance from raster cell to nearest anomaly.
 
     The criteria for what is anomalous can be defined as a single number and
@@ -34,47 +30,35 @@ def distance_to_anomaly(
     marked as anomalous (criteria text of "outside").
 
     Args:
-        raster_profile: The raster profile of which the distances
+        anomaly_raster_profile: The raster profile in which the distances
             to the nearest anomalous value are determined.
-        anomaly_raster: The raster in which the distances
+        anomaly_raster_data: The raster data in which the distances
             to the nearest anomalous value are determined.
         threshold_criteria_value: Value(s) used to define anomalous
         threshold_criteria: Method to define anomalous
 
     Returns:
-        A 2D numpy array with the distances to anomalies computed.
+        A 2D numpy array with the distances to anomalies computed
+        and the original anomaly raster profile.
 
     """
-    raster_width = raster_profile.get("width")
-    raster_height = raster_profile.get("height")
-
-    if not isinstance(raster_width, int) or not isinstance(raster_height, int):
-        raise InvalidParameterValueException(
-            f"Expected raster_profile to contain integer width and height. {raster_profile}"
-        )
-
-    raster_transform = raster_profile.get("transform")
+    check_raster_profile(raster_profile=anomaly_raster_profile)
 
-    if not isinstance(raster_transform, transform.Affine):
-        raise InvalidParameterValueException(
-            f"Expected raster_profile to contain an affine transformation. {raster_profile}"
-        )
-
-    return _distance_to_anomaly(
-        raster_profile=raster_profile,
+    out_image = _distance_to_anomaly(
         anomaly_raster_profile=anomaly_raster_profile,
         anomaly_raster_data=anomaly_raster_data,
         threshold_criteria=threshold_criteria,
         threshold_criteria_value=threshold_criteria_value,
     )
+    return out_image, anomaly_raster_profile
 
 
 @beartype
 def distance_to_anomaly_gdal(
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
-    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    threshold_criteria_value: Union[Tuple[Number, Number], Number],
+    threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
     output_path: Path,
     verbose: bool = False,
 ) -> Path:
@@ -90,7 +74,9 @@ def distance_to_anomaly_gdal(
     Does not work on Windows.
 
     Args:
-        anomaly_raster: The raster in which the distances
+        anomaly_raster_profile: The raster profile in which the distances
+            to the nearest anomalous value are determined.
+        anomaly_raster_data: The raster data in which the distances
             to the nearest anomalous value are determined.
         threshold_criteria_value: Value(s) used to define anomalous
         threshold_criteria: Method to define anomalous
@@ -101,6 +87,8 @@ def distance_to_anomaly_gdal(
     Returns:
         The path to the raster with the distances to anomalies calculated.
     """
+    check_raster_profile(raster_profile=anomaly_raster_profile)
+
     return _distance_to_anomaly_gdal(
         output_path=output_path,
         anomaly_raster_profile=anomaly_raster_profile,
@@ -112,8 +100,8 @@ def distance_to_anomaly_gdal(
 
 
 def _fits_criteria(
-    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
-    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    threshold_criteria_value: Union[Tuple[Number, Number], Number],
+    threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
     anomaly_raster_data: np.ndarray,
 ) -> np.ndarray:
     criteria_dict = {
@@ -143,8 +131,8 @@ def _write_binary_anomaly_raster(tmp_dir: Path, anomaly_raster_profile, data_fit
 def _distance_to_anomaly_gdal(
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
-    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    threshold_criteria_value: Union[Tuple[Number, Number], Number],
+    threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
     output_path: Path,
     verbose: bool,
 ):
@@ -173,11 +161,10 @@ def _distance_to_anomaly_gdal(
 
 
 def _distance_to_anomaly(
-    raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_profile: Union[profiles.Profile, dict],
     anomaly_raster_data: np.ndarray,
-    threshold_criteria_value: THRESHOLD_CRITERIA_VALUE_TYPE,
-    threshold_criteria: THRESHOLD_CRITERIA_TYPE,
+    threshold_criteria_value: Union[Tuple[Number, Number], Number],
+    threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
 ) -> np.ndarray:
     data_fits_criteria = _fits_criteria(
         threshold_criteria=threshold_criteria,
@@ -195,6 +182,6 @@ def _distance_to_anomaly(
     all_points = list(chain(*all_points_by_rows))
     all_points_gdf = gpd.GeoDataFrame(geometry=all_points, crs=anomaly_raster_profile["crs"])
 
-    distance_array = distance_computation(raster_profile=raster_profile, geometries=all_points_gdf)
+    distance_array = distance_computation(raster_profile=anomaly_raster_profile, geometries=all_points_gdf)
 
     return distance_array
diff --git a/eis_toolkit/utilities/checks/raster.py b/eis_toolkit/utilities/checks/raster.py
index 90138e24..a93a32fc 100644
--- a/eis_toolkit/utilities/checks/raster.py
+++ b/eis_toolkit/utilities/checks/raster.py
@@ -1,7 +1,11 @@
 import rasterio
+import rasterio.profiles
+import rasterio.transform
 from beartype import beartype
 from beartype.typing import Iterable, Sequence, Union
 
+from eis_toolkit.exceptions import InvalidParameterValueException
+
 
 @beartype
 def check_matching_cell_size(
@@ -166,3 +170,28 @@ def check_quadratic_pixels(raster: rasterio.io.DatasetReader) -> bool:
         return True
     else:
         return False
+
+
+@beartype
+def check_raster_profile(
+    raster_profile: Union[rasterio.profiles.Profile, dict],
+):
+    """Check raster profile values.
+
+    Checks that width and height are sensible and that the profile contains a
+    transform.
+    """
+    raster_width = raster_profile.get("width")
+    raster_height = raster_profile.get("height")
+
+    if not isinstance(raster_width, int) or not isinstance(raster_height, int):
+        raise InvalidParameterValueException(
+            f"Expected raster_profile to contain integer width and height. {raster_profile}"
+        )
+
+    raster_transform = raster_profile.get("transform")
+
+    if not isinstance(raster_transform, rasterio.transform.Affine):
+        raise InvalidParameterValueException(
+            f"Expected raster_profile to contain an affine transformation. {raster_profile}"
+        )
diff --git a/eis_toolkit/vector_processing/distance_computation.py b/eis_toolkit/vector_processing/distance_computation.py
index 57453708..46c16365 100644
--- a/eis_toolkit/vector_processing/distance_computation.py
+++ b/eis_toolkit/vector_processing/distance_computation.py
@@ -5,7 +5,8 @@
 from rasterio import profiles, transform
 from shapely.geometry.base import BaseGeometry, BaseMultipartGeometry
 
-from eis_toolkit.exceptions import EmptyDataFrameException, InvalidParameterValueException, NonMatchingCrsException
+from eis_toolkit.exceptions import EmptyDataFrameException, NonMatchingCrsException
+from eis_toolkit.utilities.checks.raster import check_raster_profile
 from eis_toolkit.utilities.miscellaneous import row_points
 
 
@@ -27,21 +28,12 @@ def distance_computation(raster_profile: Union[profiles.Profile, dict], geometri
     if geometries.shape[0] == 0:
         raise EmptyDataFrameException("Expected GeoDataFrame to not be empty.")
 
+    check_raster_profile(raster_profile=raster_profile)
+
     raster_width = raster_profile.get("width")
     raster_height = raster_profile.get("height")
-
-    if not isinstance(raster_width, int) or not isinstance(raster_height, int):
-        raise InvalidParameterValueException(
-            f"Expected raster_profile to contain integer width and height. {raster_profile}"
-        )
-
     raster_transform = raster_profile.get("transform")
 
-    if not isinstance(raster_transform, transform.Affine):
-        raise InvalidParameterValueException(
-            f"Expected raster_profile to contain an affine transformation. {raster_profile}"
-        )
-
     return _distance_computation(
         raster_width=raster_width, raster_height=raster_height, raster_transform=raster_transform, geometries=geometries
     )

From abd858e444018b15333cdcf75cda0176230cf52b Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 23 Feb 2024 15:35:40 +0200
Subject: [PATCH 05/17] test(distance_to_anomaly): update tests

Updated tests according to previous changes and added some new ones to
test raster profile check.
---
 .../test_distance_to_anomaly.py               | 93 +++++++++++++++++--
 1 file changed, 83 insertions(+), 10 deletions(-)

diff --git a/tests/raster_processing/test_distance_to_anomaly.py b/tests/raster_processing/test_distance_to_anomaly.py
index 83db9fc0..59331f86 100644
--- a/tests/raster_processing/test_distance_to_anomaly.py
+++ b/tests/raster_processing/test_distance_to_anomaly.py
@@ -1,11 +1,15 @@
 import sys
+from contextlib import nullcontext
+from functools import partial
 from pathlib import Path
 
 import numpy as np
 import pytest
 import rasterio
 import rasterio.plot
+import rasterio.profiles
 
+from eis_toolkit.exceptions import InvalidParameterValueException
 from eis_toolkit.raster_processing import distance_to_anomaly
 from tests.raster_processing.clip_test import raster_path as SMALL_RASTER_PATH
 
@@ -16,10 +20,14 @@
 EXPECTED_SMALL_RASTER_SHAPE = SMALL_RASTER_PROFILE["height"], SMALL_RASTER_PROFILE["width"]
 
 
+def _check_result(out_image, out_profile):
+    assert isinstance(out_image, np.ndarray)
+    assert isinstance(out_profile, (dict, rasterio.profiles.Profile))
+
+
 @pytest.mark.parametrize(
     ",".join(
         [
-            "raster_profile",
             "anomaly_raster_profile",
             "anomaly_raster_data",
             "threshold_criteria_value",
@@ -30,7 +38,6 @@
     ),
     [
         pytest.param(
-            SMALL_RASTER_PROFILE,
             SMALL_RASTER_PROFILE,
             SMALL_RASTER_DATA,
             5.0,
@@ -41,8 +48,7 @@
         ),
     ],
 )
-def test_distance_to_anomaly(
-    raster_profile,
+def test_distance_to_anomaly_expected(
     anomaly_raster_profile,
     anomaly_raster_data,
     threshold_criteria_value,
@@ -50,20 +56,20 @@ def test_distance_to_anomaly(
     expected_shape,
     expected_mean,
 ):
-    """Test distance_to_anomaly."""
+    """Test distance_to_anomaly with expected result."""
 
-    result = distance_to_anomaly.distance_to_anomaly(
-        raster_profile=raster_profile,
+    out_image, out_profile = distance_to_anomaly.distance_to_anomaly(
         anomaly_raster_profile=anomaly_raster_profile,
         anomaly_raster_data=anomaly_raster_data,
         threshold_criteria_value=threshold_criteria_value,
         threshold_criteria=threshold_criteria,
     )
 
-    assert isinstance(result, np.ndarray)
-    assert result.shape == expected_shape
+    _check_result(out_image=out_image, out_profile=out_profile)
+
+    assert out_image.shape == expected_shape
     if expected_mean is not None:
-        assert np.isclose(np.mean(result), expected_mean)
+        assert np.isclose(np.mean(out_image), expected_mean)
 
 
 @pytest.mark.parametrize(
@@ -123,3 +129,70 @@ def test_distance_to_anomaly_gdal(
     assert result_raster_data.shape == expected_shape
     if expected_mean is not None:
         assert np.isclose(np.mean(result_raster_data), expected_mean)
+
+
+@pytest.mark.parametrize(
+    ",".join(
+        [
+            "anomaly_raster_profile",
+            "anomaly_raster_data",
+            "threshold_criteria_value",
+            "threshold_criteria",
+            "profile_additions",
+            "raises",
+        ]
+    ),
+    [
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            dict,
+            nullcontext,
+            id="no_expected_exception",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            partial(dict, height=2.2),
+            partial(pytest.raises, InvalidParameterValueException),
+            id="expected_invalid_param_due_to_float_value",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            partial(dict, transform=None),
+            partial(pytest.raises, InvalidParameterValueException),
+            id="expected_invalid_param_due_to_transform_value",
+        ),
+    ],
+)
+def test_distance_to_anomaly_check(
+    anomaly_raster_profile,
+    anomaly_raster_data,
+    threshold_criteria_value,
+    threshold_criteria,
+    profile_additions,
+    raises,
+):
+    """Test distance_to_anomaly checks."""
+
+    anomaly_raster_profile_with_additions = {**anomaly_raster_profile, **profile_additions()}
+    with raises() as exc_info:
+        out_image, out_profile = distance_to_anomaly.distance_to_anomaly(
+            anomaly_raster_profile=anomaly_raster_profile_with_additions,
+            anomaly_raster_data=anomaly_raster_data,
+            threshold_criteria_value=threshold_criteria_value,
+            threshold_criteria=threshold_criteria,
+        )
+
+    if exc_info is not None:
+        # Expected error
+        return
+
+    _check_result(out_image=out_image, out_profile=out_profile)

From 5d25fdb8d1fc64eaea7db35699724f672e6f6ec8 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 23 Feb 2024 15:39:42 +0200
Subject: [PATCH 06/17] docs(distance_to_anomaly): update notebook

---
 notebooks/distance_to_anomaly.ipynb | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/notebooks/distance_to_anomaly.ipynb b/notebooks/distance_to_anomaly.ipynb
index 091c7a76..e4459188 100644
--- a/notebooks/distance_to_anomaly.ipynb
+++ b/notebooks/distance_to_anomaly.ipynb
@@ -25,7 +25,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/nialov/.cache/pypoetry/virtualenvs/eis-toolkit-14Bnyb2Y-py3.10/lib/python3.10/site-packages/geopandas/_compat.py:112: UserWarning: The Shapely GEOS version (3.10.3-CAPI-1.16.1) is incompatible with the GEOS version PyGEOS was compiled with (3.10.4-CAPI-1.16.2). Conversions between both will be slow.\n",
+      "/home/nialov/.cache/pypoetry/virtualenvs/eis-toolkit-tACG8vKh-py3.10/lib/python3.10/site-packages/geopandas/_compat.py:112: UserWarning: The Shapely GEOS version (3.10.3-CAPI-1.16.1) is incompatible with the GEOS version PyGEOS was compiled with (3.10.4-CAPI-1.16.2). Conversions between both will be slow.\n",
       "  warnings.warn(\n"
      ]
     }
@@ -76,7 +76,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0...10...20...30...40...50...60...70...80...90..."
+      "Several drivers matching tif extension. Using GTiff\n"
      ]
     },
     {
@@ -109,14 +109,13 @@
     "raster_data_criteria = np.where(raster_data_fits_criteria, raster_data, np.nan)\n",
     "_plot_image(ax=axes[1], data=raster_data_criteria, title=\"Data fitting criteria (anomaly)\")\n",
     "\n",
-    "distance_matrix = distance_to_anomaly(\n",
-    "    raster_profile=raster_profile,\n",
+    "out_image, _ = distance_to_anomaly(\n",
     "    anomaly_raster_data=raster_data,\n",
     "    anomaly_raster_profile=raster_profile,\n",
     "    threshold_criteria_value=threshold_criteria_value,\n",
     "    threshold_criteria=threshold_criteria,\n",
     ")\n",
-    "_plot_image(ax=axes[2], data=distance_matrix, title=\"Distance to nearest anomaly (distance_computation)\")\n",
+    "_plot_image(ax=axes[2], data=out_image, title=\"Distance to nearest anomaly (distance_computation)\")\n",
     "\n",
     "with TemporaryDirectory() as tmp_dir_str:\n",
     "    distance_path = Path(tmp_dir_str) / \"distance_to_anomaly_gdal.tif\"\n",

From ead23e7920dded7bf867012010465ebaaa11f3c1 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Thu, 7 Mar 2024 14:21:59 +0200
Subject: [PATCH 07/17] feat(distance_to_anomaly): handle nodata

Uses nodata value from raster profile and falls back to using
np.nan if profile does not contain it.
---
 .../raster_processing/distance_to_anomaly.py      | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index 81851dcd..02b26f74 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -7,7 +7,7 @@
 import numpy as np
 import rasterio
 from beartype import beartype
-from beartype.typing import Literal, Tuple, Union
+from beartype.typing import Literal, Optional, Tuple, Union
 from rasterio import profiles
 
 from eis_toolkit.utilities.checks.raster import check_raster_profile
@@ -27,7 +27,8 @@ def distance_to_anomaly(
     The criteria for what is anomalous can be defined as a single number and
     criteria text of "higher" or "lower". Alternatively, the definition can be
     a range where values inside (criteria text of "within") or outside are
-    marked as anomalous (criteria text of "outside").
+    marked as anomalous (criteria text of "outside"). If anomaly_raster_profile does
+    contain "nodata" key, np.nan is assumed to correspond to nodata values.
 
     Args:
         anomaly_raster_profile: The raster profile in which the distances
@@ -69,7 +70,8 @@ def distance_to_anomaly_gdal(
     defined as a single number and criteria text of "higher" or "lower".
     Alternatively, the definition can be a range where values inside
     (criteria text of "within") or outside are marked as anomalous
-    (criteria text of "outside").
+    (criteria text of "outside"). If anomaly_raster_profile does
+    contain "nodata" key, np.nan is assumed to correspond to nodata values.
 
     Does not work on Windows.
 
@@ -103,7 +105,9 @@ def _fits_criteria(
     threshold_criteria_value: Union[Tuple[Number, Number], Number],
     threshold_criteria: Literal["lower", "higher", "in_between", "outside"],
     anomaly_raster_data: np.ndarray,
+    nodata_value: Optional[Number],
 ) -> np.ndarray:
+
     criteria_dict = {
         "lower": lambda anomaly_raster_data: anomaly_raster_data < threshold_criteria_value,
         "higher": lambda anomaly_raster_data: anomaly_raster_data > threshold_criteria_value,
@@ -114,7 +118,8 @@ def _fits_criteria(
             np.logical_or(anomaly_raster_data < threshold_criteria[0], anomaly_raster_data > threshold_criteria[1])
         ),
     }
-    return np.where(np.isnan(anomaly_raster_data), False, criteria_dict[threshold_criteria](anomaly_raster_data))
+    mask = anomaly_raster_data == nodata_value if nodata_value is not None else np.isnan(anomaly_raster_data)
+    return np.where(mask, False, criteria_dict[threshold_criteria](anomaly_raster_data))
 
 
 def _write_binary_anomaly_raster(tmp_dir: Path, anomaly_raster_profile, data_fits_criteria: np.ndarray):
@@ -142,6 +147,7 @@ def _distance_to_anomaly_gdal(
         threshold_criteria=threshold_criteria,
         threshold_criteria_value=threshold_criteria_value,
         anomaly_raster_data=anomaly_raster_data,
+        nodata_value=anomaly_raster_profile.get("nodata"),
     )
 
     with TemporaryDirectory() as tmp_dir_str:
@@ -170,6 +176,7 @@ def _distance_to_anomaly(
         threshold_criteria=threshold_criteria,
         threshold_criteria_value=threshold_criteria_value,
         anomaly_raster_data=anomaly_raster_data,
+        nodata_value=anomaly_raster_profile.get("nodata"),
     )
 
     cols = np.arange(anomaly_raster_data.shape[1])

From b706b25c81108b8ad67c1267b3fe05ecd21d9a93 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Thu, 7 Mar 2024 14:22:14 +0200
Subject: [PATCH 08/17] test(distance_to_anomaly): test with nodata

---
 .../test_distance_to_anomaly.py               | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/tests/raster_processing/test_distance_to_anomaly.py b/tests/raster_processing/test_distance_to_anomaly.py
index 59331f86..4a7f5b79 100644
--- a/tests/raster_processing/test_distance_to_anomaly.py
+++ b/tests/raster_processing/test_distance_to_anomaly.py
@@ -23,6 +23,7 @@
 def _check_result(out_image, out_profile):
     assert isinstance(out_image, np.ndarray)
     assert isinstance(out_profile, (dict, rasterio.profiles.Profile))
+    assert not np.any(np.isnan(out_image))
 
 
 @pytest.mark.parametrize(
@@ -58,6 +59,8 @@ def test_distance_to_anomaly_expected(
 ):
     """Test distance_to_anomaly with expected result."""
 
+    # No np.nan expected in input here
+    assert not np.any(np.isnan(anomaly_raster_data))
     out_image, out_profile = distance_to_anomaly.distance_to_anomaly(
         anomaly_raster_profile=anomaly_raster_profile,
         anomaly_raster_data=anomaly_raster_data,
@@ -196,3 +199,58 @@ def test_distance_to_anomaly_check(
         return
 
     _check_result(out_image=out_image, out_profile=out_profile)
+
+
+@pytest.mark.parametrize(
+    ",".join(
+        [
+            "anomaly_raster_profile",
+            "anomaly_raster_data",
+            "threshold_criteria_value",
+            "threshold_criteria",
+            "expected_shape",
+            "expected_mean_without_nodata",
+            "nodata_mask_value",
+        ]
+    ),
+    [
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "higher",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            6.451948,
+            # Part of values over 5 will now be masked as nodata
+            9.0,
+            id="small_raster_with_inserted_nodata",
+        ),
+    ],
+)
+def test_distance_to_anomaly_nodata_handling(
+    anomaly_raster_profile,
+    anomaly_raster_data,
+    threshold_criteria_value,
+    threshold_criteria,
+    expected_shape,
+    expected_mean_without_nodata,
+    nodata_mask_value,
+):
+    """Test distance_to_anomaly with expected result."""
+
+    anomaly_raster_data_with_nodata = np.where(anomaly_raster_data > nodata_mask_value, np.nan, anomaly_raster_data)
+    assert np.any(np.isnan(anomaly_raster_data_with_nodata))
+
+    out_image, out_profile = distance_to_anomaly.distance_to_anomaly(
+        anomaly_raster_profile=anomaly_raster_profile,
+        anomaly_raster_data=anomaly_raster_data_with_nodata,
+        threshold_criteria_value=threshold_criteria_value,
+        threshold_criteria=threshold_criteria,
+    )
+
+    _check_result(out_image=out_image, out_profile=out_profile)
+
+    assert out_image.shape == expected_shape
+
+    # Result should not be same as without nodata addition
+    assert not np.isclose(np.mean(out_image), expected_mean_without_nodata)

From cc19baa862bfb857a65b639da8bb90f391728282 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Thu, 7 Mar 2024 14:27:47 +0200
Subject: [PATCH 09/17] fix(miscellaneous): fix check logic

---
 eis_toolkit/utilities/miscellaneous.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/eis_toolkit/utilities/miscellaneous.py b/eis_toolkit/utilities/miscellaneous.py
index 2f3a6c66..b0018f89 100644
--- a/eis_toolkit/utilities/miscellaneous.py
+++ b/eis_toolkit/utilities/miscellaneous.py
@@ -403,12 +403,10 @@ def toggle_gdal_exceptions():
     """
     already_has_exceptions_enabled = False
     try:
-
-        gdal.UseExceptions()
         if gdal.GetUseExceptions() != 0:
             already_has_exceptions_enabled = True
+        gdal.UseExceptions()
         yield
-
     finally:
         if not already_has_exceptions_enabled:
             gdal.DontUseExceptions()

From 9b24bad188f0d3aa9a76f6cfc7547274d341b2e6 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Thu, 7 Mar 2024 14:31:36 +0200
Subject: [PATCH 10/17] docs(distance_to_anomaly): add function input

---
 notebooks/distance_to_anomaly.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/notebooks/distance_to_anomaly.ipynb b/notebooks/distance_to_anomaly.ipynb
index e4459188..5beda70f 100644
--- a/notebooks/distance_to_anomaly.ipynb
+++ b/notebooks/distance_to_anomaly.ipynb
@@ -105,7 +105,7 @@
     "\n",
     "_plot_image(ax=axes[0], data=raster_data, title=\"All data\")\n",
     "\n",
-    "raster_data_fits_criteria = _fits_criteria(threshold_criteria_value=threshold_criteria_value, threshold_criteria=threshold_criteria, anomaly_raster_data=raster_data)\n",
+    "raster_data_fits_criteria = _fits_criteria(threshold_criteria_value=threshold_criteria_value, threshold_criteria=threshold_criteria, anomaly_raster_data=raster_data, nodata_value=raster_profile.get(\"nodata\"))\n",
     "raster_data_criteria = np.where(raster_data_fits_criteria, raster_data, np.nan)\n",
     "_plot_image(ax=axes[1], data=raster_data_criteria, title=\"Data fitting criteria (anomaly)\")\n",
     "\n",

From ed187cbc56b25026a0b63b6208701fa82cbe66f9 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 8 Mar 2024 17:53:49 +0200
Subject: [PATCH 11/17] feat(distance_to_anomaly): check threshold inputs

---
 .../raster_processing/distance_to_anomaly.py  | 30 ++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index 02b26f74..1415e6ef 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -10,11 +10,30 @@
 from beartype.typing import Literal, Optional, Tuple, Union
 from rasterio import profiles
 
+from eis_toolkit.exceptions import InvalidParameterValueException
 from eis_toolkit.utilities.checks.raster import check_raster_profile
 from eis_toolkit.utilities.miscellaneous import row_points, toggle_gdal_exceptions
 from eis_toolkit.vector_processing.distance_computation import distance_computation
 
 
+def _check_threshold_criteria_and_value(threshold_criteria, threshold_criteria_value):
+    if threshold_criteria in {"lower", "higher"} and not isinstance(threshold_criteria_value, Number):
+        raise InvalidParameterValueException(
+            f"Expected threshold_criteria_value {threshold_criteria_value} "
+            "to be a single number rather than a tuple."
+        )
+    if threshold_criteria in {"in_between", "outside"}:
+        if not isinstance(threshold_criteria_value, tuple):
+            raise InvalidParameterValueException(
+                f"Expected threshold_criteria_value ({threshold_criteria_value}) " "to be a tuple rather than a number."
+            )
+        if threshold_criteria_value[0] >= threshold_criteria_value[1]:
+            raise InvalidParameterValueException(
+                f"Expected first value in threshold_criteria_value ({threshold_criteria_value})"
+                "tuple to be lower than the second."
+            )
+
+
 @beartype
 def distance_to_anomaly(
     anomaly_raster_profile: Union[profiles.Profile, dict],
@@ -35,7 +54,10 @@ def distance_to_anomaly(
             to the nearest anomalous value are determined.
         anomaly_raster_data: The raster data in which the distances
             to the nearest anomalous value are determined.
-        threshold_criteria_value: Value(s) used to define anomalous
+        threshold_criteria_value: Value(s) used to define anomalous.
+            If the threshold criteria requires a tuple of values,
+            the first value should be the minimum and the second
+            the maximum value.
         threshold_criteria: Method to define anomalous
 
     Returns:
@@ -44,6 +66,9 @@ def distance_to_anomaly(
 
     """
     check_raster_profile(raster_profile=anomaly_raster_profile)
+    _check_threshold_criteria_and_value(
+        threshold_criteria=threshold_criteria, threshold_criteria_value=threshold_criteria_value
+    )
 
     out_image = _distance_to_anomaly(
         anomaly_raster_profile=anomaly_raster_profile,
@@ -90,6 +115,9 @@ def distance_to_anomaly_gdal(
         The path to the raster with the distances to anomalies calculated.
     """
     check_raster_profile(raster_profile=anomaly_raster_profile)
+    _check_threshold_criteria_and_value(
+        threshold_criteria=threshold_criteria, threshold_criteria_value=threshold_criteria_value
+    )
 
     return _distance_to_anomaly_gdal(
         output_path=output_path,

From abcc7ba6a65a42016a47093c7d4a3d1b477bf2fd Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 8 Mar 2024 17:54:24 +0200
Subject: [PATCH 12/17] fix(distance_to_anomaly): use correct variable

---
 eis_toolkit/raster_processing/distance_to_anomaly.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index 1415e6ef..f48166b1 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -139,14 +139,17 @@ def _fits_criteria(
     criteria_dict = {
         "lower": lambda anomaly_raster_data: anomaly_raster_data < threshold_criteria_value,
         "higher": lambda anomaly_raster_data: anomaly_raster_data > threshold_criteria_value,
-        "in_between": lambda anomaly_raster_data: np.where(
-            np.logical_and(anomaly_raster_data > threshold_criteria[0], anomaly_raster_data < threshold_criteria[1])
+        "in_between": lambda anomaly_raster_data: np.logical_and(
+            anomaly_raster_data > threshold_criteria_value[0],  # type: ignore
+            anomaly_raster_data < threshold_criteria_value[1],  # type: ignore
         ),
-        "outside": lambda anomaly_raster_data: np.where(
-            np.logical_or(anomaly_raster_data < threshold_criteria[0], anomaly_raster_data > threshold_criteria[1])
+        "outside": lambda anomaly_raster_data: np.logical_or(
+            anomaly_raster_data < threshold_criteria_value[0],  # type: ignore
+            anomaly_raster_data > threshold_criteria_value[1],  # type: ignore
         ),
     }
     mask = anomaly_raster_data == nodata_value if nodata_value is not None else np.isnan(anomaly_raster_data)
+
     return np.where(mask, False, criteria_dict[threshold_criteria](anomaly_raster_data))
 
 

From 819d5d5ee5a6843f3d780cd1a7dc433fca88b35e Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 8 Mar 2024 17:54:39 +0200
Subject: [PATCH 13/17] test(distance_to_anomaly): test checks and all criteria

---
 .../test_distance_to_anomaly.py               | 59 ++++++++++++++++++-
 1 file changed, 57 insertions(+), 2 deletions(-)

diff --git a/tests/raster_processing/test_distance_to_anomaly.py b/tests/raster_processing/test_distance_to_anomaly.py
index 4a7f5b79..eb033291 100644
--- a/tests/raster_processing/test_distance_to_anomaly.py
+++ b/tests/raster_processing/test_distance_to_anomaly.py
@@ -8,6 +8,7 @@
 import rasterio
 import rasterio.plot
 import rasterio.profiles
+from beartype.roar import BeartypeCallHintParamViolation
 
 from eis_toolkit.exceptions import InvalidParameterValueException
 from eis_toolkit.raster_processing import distance_to_anomaly
@@ -38,6 +39,15 @@ def _check_result(out_image, out_profile):
         ]
     ),
     [
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "lower",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            5.694903,
+            id="small_raster_lower",
+        ),
         pytest.param(
             SMALL_RASTER_PROFILE,
             SMALL_RASTER_DATA,
@@ -47,6 +57,24 @@ def _check_result(out_image, out_profile):
             6.451948,
             id="small_raster_higher",
         ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            (2.5, 7.5),
+            "in_between",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            2.114331,
+            id="small_raster_in_between",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            (2.5, 7.5),
+            "outside",
+            EXPECTED_SMALL_RASTER_SHAPE,
+            32.490106,
+            id="small_raster_outside",
+        ),
     ],
 )
 def test_distance_to_anomaly_expected(
@@ -162,7 +190,7 @@ def test_distance_to_anomaly_gdal(
             "higher",
             partial(dict, height=2.2),
             partial(pytest.raises, InvalidParameterValueException),
-            id="expected_invalid_param_due_to_float_value",
+            id="expected_invalid_param_due_to_float_value_in_profile",
         ),
         pytest.param(
             SMALL_RASTER_PROFILE,
@@ -171,7 +199,34 @@ def test_distance_to_anomaly_gdal(
             "higher",
             partial(dict, transform=None),
             partial(pytest.raises, InvalidParameterValueException),
-            id="expected_invalid_param_due_to_transform_value",
+            id="expected_invalid_param_due_to_none_transform_value",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            5.0,
+            "in_between",
+            dict,
+            partial(pytest.raises, InvalidParameterValueException),
+            id="expected_invalid_param_due_to_number_rather_than_range",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            (7.5, 2.5),
+            "in_between",
+            dict,
+            partial(pytest.raises, InvalidParameterValueException),
+            id="expected_invalid_param_due_to_invalid_order_in_tuple",
+        ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            (1.5, 2.5, 7.5),
+            "in_between",
+            dict,
+            partial(pytest.raises, BeartypeCallHintParamViolation),
+            id="expected_invalid_param_due_to_tuple_of_length_three",
         ),
     ],
 )

From cbcede450390ef4ae5876979f4a15437ef9665e5 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 8 Mar 2024 17:54:50 +0200
Subject: [PATCH 14/17] docs(distance_to_anomaly): add all criteria examples

---
 notebooks/distance_to_anomaly.ipynb | 213 +++++++++++++++++++++-------
 1 file changed, 164 insertions(+), 49 deletions(-)

diff --git a/notebooks/distance_to_anomaly.ipynb b/notebooks/distance_to_anomaly.ipynb
index 5beda70f..130ee5b8 100644
--- a/notebooks/distance_to_anomaly.ipynb
+++ b/notebooks/distance_to_anomaly.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "id": "b3d379c7-d0d1-44e4-9cdc-169f047b35f6",
    "metadata": {
     "tags": []
@@ -10,12 +10,13 @@
    "outputs": [],
    "source": [
     "import sys\n",
-    "sys.path.append('..')"
+    "\n",
+    "sys.path.append(\"..\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "c3b27bf4-0a01-415f-a17f-a0f2b7fe68f7",
    "metadata": {
     "tags": []
@@ -43,12 +44,16 @@
     "import numpy as np\n",
     "\n",
     "from tests.raster_processing.clip_test import raster_path as SMALL_RASTER_PATH\n",
-    "from eis_toolkit.raster_processing.distance_to_anomaly import distance_to_anomaly, _fits_criteria, distance_to_anomaly_gdal"
+    "from eis_toolkit.raster_processing.distance_to_anomaly import (\n",
+    "    distance_to_anomaly,\n",
+    "    _fits_criteria,\n",
+    "    distance_to_anomaly_gdal,\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 12,
    "id": "02e9f227-8a87-487f-828e-c2d0d901e661",
    "metadata": {
     "tags": []
@@ -61,13 +66,69 @@
     "    norm = plt.Normalize(vmax=np.nanmax(data), vmin=np.nanmin(data))\n",
     "    cmap = matplotlib.cm.viridis\n",
     "    plt.colorbar(matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap), ax=ax)\n",
-    "    "
+    "\n",
+    "\n",
+    "def _plot_distance_example(threshold_criteria_value, threshold_criteria):\n",
+    "    fig, axes = plt.subplots(2, 2, figsize=(8, 9))\n",
+    "    axes = axes.flatten()\n",
+    "\n",
+    "    with rasterio.open(SMALL_RASTER_PATH) as raster:\n",
+    "        raster_data = raster.read(1)\n",
+    "        raster_profile = raster.profile\n",
+    "    raster_transform = raster_profile[\"transform\"]\n",
+    "\n",
+    "    _plot_image_with_transform = partial(_plot_image, transform=raster_transform)\n",
+    "\n",
+    "    _plot_image_with_transform(ax=axes[0], data=raster_data, title=\"All data\")\n",
+    "\n",
+    "    raster_data_fits_criteria = _fits_criteria(\n",
+    "        threshold_criteria_value=threshold_criteria_value,\n",
+    "        threshold_criteria=threshold_criteria,\n",
+    "        anomaly_raster_data=raster_data,\n",
+    "        nodata_value=raster_profile.get(\"nodata\"),\n",
+    "    )\n",
+    "    raster_data_criteria = np.where(raster_data_fits_criteria, raster_data, np.nan)\n",
+    "    _plot_image_with_transform(\n",
+    "        ax=axes[1], data=raster_data_criteria, title=\"Data fitting criteria (anomaly)\"\n",
+    "    )\n",
+    "\n",
+    "    out_image, _ = distance_to_anomaly(\n",
+    "        anomaly_raster_data=raster_data,\n",
+    "        anomaly_raster_profile=raster_profile,\n",
+    "        threshold_criteria_value=threshold_criteria_value,\n",
+    "        threshold_criteria=threshold_criteria,\n",
+    "    )\n",
+    "    _plot_image_with_transform(\n",
+    "        ax=axes[2],\n",
+    "        data=out_image,\n",
+    "        title=\"Distance to nearest anomaly (distance_computation)\",\n",
+    "    )\n",
+    "\n",
+    "    with TemporaryDirectory() as tmp_dir_str:\n",
+    "        distance_path = Path(tmp_dir_str) / \"distance_to_anomaly_gdal.tif\"\n",
+    "        try:\n",
+    "            distance_path = distance_to_anomaly_gdal(\n",
+    "                anomaly_raster_data=raster_data,\n",
+    "                anomaly_raster_profile=raster_profile,\n",
+    "                threshold_criteria_value=threshold_criteria_value,\n",
+    "                threshold_criteria=threshold_criteria,\n",
+    "                output_path=distance_path,\n",
+    "            )\n",
+    "            with rasterio.open(distance_path) as distance_raster:\n",
+    "                _plot_image_with_transform(\n",
+    "                    ax=axes[3],\n",
+    "                    data=distance_raster.read(1),\n",
+    "                    title=\"Distance to nearest anomaly (gdal_proximity.py)\",\n",
+    "                )\n",
+    "        except ModuleNotFoundError as exc:\n",
+    "            print(\"distance_to_anomaly_gdal does not work on windows.\")\n",
+    "            print(exc)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "71d8ab83-7d2e-4bbf-b662-9a14c37071e1",
+   "execution_count": 13,
+   "id": "4af1be28-b9b0-4b60-ac04-6dfc8307ffda",
    "metadata": {
     "tags": []
    },
@@ -91,47 +152,101 @@
     }
    ],
    "source": [
-    "fig, axes = plt.subplots(2, 2, figsize=(8, 9))\n",
-    "axes = axes.flatten()\n",
-    "threshold_criteria_value = 8.0\n",
-    "threshold_criteria = \"higher\"\n",
-    "\n",
-    "with rasterio.open(SMALL_RASTER_PATH) as raster:\n",
-    "    raster_data = raster.read(1)\n",
-    "    raster_profile = raster.profile\n",
-    "raster_transform = raster_profile[\"transform\"]\n",
-    "\n",
-    "_plot_image = partial(_plot_image, transform=raster_transform)\n",
-    "\n",
-    "_plot_image(ax=axes[0], data=raster_data, title=\"All data\")\n",
-    "\n",
-    "raster_data_fits_criteria = _fits_criteria(threshold_criteria_value=threshold_criteria_value, threshold_criteria=threshold_criteria, anomaly_raster_data=raster_data, nodata_value=raster_profile.get(\"nodata\"))\n",
-    "raster_data_criteria = np.where(raster_data_fits_criteria, raster_data, np.nan)\n",
-    "_plot_image(ax=axes[1], data=raster_data_criteria, title=\"Data fitting criteria (anomaly)\")\n",
-    "\n",
-    "out_image, _ = distance_to_anomaly(\n",
-    "    anomaly_raster_data=raster_data,\n",
-    "    anomaly_raster_profile=raster_profile,\n",
-    "    threshold_criteria_value=threshold_criteria_value,\n",
-    "    threshold_criteria=threshold_criteria,\n",
-    ")\n",
-    "_plot_image(ax=axes[2], data=out_image, title=\"Distance to nearest anomaly (distance_computation)\")\n",
-    "\n",
-    "with TemporaryDirectory() as tmp_dir_str:\n",
-    "    distance_path = Path(tmp_dir_str) / \"distance_to_anomaly_gdal.tif\"\n",
-    "    try:\n",
-    "        distance_path = distance_to_anomaly_gdal(\n",
-    "            anomaly_raster_data=raster_data,\n",
-    "            anomaly_raster_profile=raster_profile,\n",
-    "            threshold_criteria_value=threshold_criteria_value,\n",
-    "            threshold_criteria=threshold_criteria,\n",
-    "            output_path=distance_path,\n",
-    "        )\n",
-    "        with rasterio.open(distance_path) as distance_raster:\n",
-    "            _plot_image(ax=axes[3], data=distance_raster.read(1), title=\"Distance to nearest anomaly (gdal_proximity.py)\")\n",
-    "    except ModuleNotFoundError as exc:\n",
-    "        print(\"distance_to_anomaly_gdal does not work on windows.\")\n",
-    "        print(exc)"
+    "_plot_distance_example(threshold_criteria_value=8.0, threshold_criteria=\"higher\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "2b633218-be36-482b-a10c-915f71522ece",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Several drivers matching tif extension. Using GTiff\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x900 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_plot_distance_example(threshold_criteria_value=8.0, threshold_criteria=\"lower\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2bba94fe-8e57-48a7-9d1c-ceb0cb589355",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Several drivers matching tif extension. Using GTiff\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x900 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_plot_distance_example(\n",
+    "    threshold_criteria_value=(5.0, 7.5), threshold_criteria=\"in_between\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "de981707-328a-4280-9496-054ede1c2947",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Several drivers matching tif extension. Using GTiff\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x900 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_plot_distance_example(\n",
+    "    threshold_criteria_value=(5.0, 7.5), threshold_criteria=\"outside\"\n",
+    ")"
    ]
   }
  ],

From 53e3edd4b831a666f1575057377b0a792526e035 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Mon, 11 Mar 2024 08:56:42 +0200
Subject: [PATCH 15/17] style(distance_to_anomaly): clean code and docs

---
 eis_toolkit/raster_processing/distance_to_anomaly.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index f48166b1..f5a8e6a8 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -25,7 +25,7 @@ def _check_threshold_criteria_and_value(threshold_criteria, threshold_criteria_v
     if threshold_criteria in {"in_between", "outside"}:
         if not isinstance(threshold_criteria_value, tuple):
             raise InvalidParameterValueException(
-                f"Expected threshold_criteria_value ({threshold_criteria_value}) " "to be a tuple rather than a number."
+                f"Expected threshold_criteria_value ({threshold_criteria_value}) to be a tuple rather than a number."
             )
         if threshold_criteria_value[0] >= threshold_criteria_value[1]:
             raise InvalidParameterValueException(
@@ -58,7 +58,7 @@ def distance_to_anomaly(
             If the threshold criteria requires a tuple of values,
             the first value should be the minimum and the second
             the maximum value.
-        threshold_criteria: Method to define anomalous
+        threshold_criteria: Method to define anomalous.
 
     Returns:
         A 2D numpy array with the distances to anomalies computed
@@ -105,8 +105,8 @@ def distance_to_anomaly_gdal(
             to the nearest anomalous value are determined.
         anomaly_raster_data: The raster data in which the distances
             to the nearest anomalous value are determined.
-        threshold_criteria_value: Value(s) used to define anomalous
-        threshold_criteria: Method to define anomalous
+        threshold_criteria_value: Value(s) used to define anomalous.
+        threshold_criteria: Method to define anomalous.
         output_path: The path to the raster with the distances to anomalies
             calculated.
         verbose: Whether to print gdal_proximity output.
@@ -156,8 +156,7 @@ def _fits_criteria(
 def _write_binary_anomaly_raster(tmp_dir: Path, anomaly_raster_profile, data_fits_criteria: np.ndarray):
     anomaly_raster_binary_path = tmp_dir / "anomaly_raster_binary.tif"
 
-    anomaly_raster_binary_profile = anomaly_raster_profile
-    anomaly_raster_binary_profile.update(dtype=rasterio.uint8, count=1, nodata=None)
+    anomaly_raster_binary_profile = {**anomaly_raster_profile, **dict(dtype=rasterio.uint8, count=1, nodata=None)}
     with rasterio.open(anomaly_raster_binary_path, mode="w", **anomaly_raster_binary_profile) as anomaly_raster_binary:
         anomaly_raster_binary.write(data_fits_criteria.astype(rasterio.uint8), 1)
 

From 74cc1da15611c4cf4ce38dd9d6092f90865841cc Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 15 Mar 2024 08:58:11 +0200
Subject: [PATCH 16/17] feat(distance_to_anomaly): check threshold data match

If the criteria does not match any of the data, an exception is raised to notify
the user.
---
 .../raster_processing/distance_to_anomaly.py        | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/eis_toolkit/raster_processing/distance_to_anomaly.py b/eis_toolkit/raster_processing/distance_to_anomaly.py
index f5a8e6a8..b8c4cc1b 100644
--- a/eis_toolkit/raster_processing/distance_to_anomaly.py
+++ b/eis_toolkit/raster_processing/distance_to_anomaly.py
@@ -10,7 +10,7 @@
 from beartype.typing import Literal, Optional, Tuple, Union
 from rasterio import profiles
 
-from eis_toolkit.exceptions import InvalidParameterValueException
+from eis_toolkit.exceptions import EmptyDataException, InvalidParameterValueException
 from eis_toolkit.utilities.checks.raster import check_raster_profile
 from eis_toolkit.utilities.miscellaneous import row_points, toggle_gdal_exceptions
 from eis_toolkit.vector_processing.distance_computation import distance_computation
@@ -208,6 +208,17 @@ def _distance_to_anomaly(
         anomaly_raster_data=anomaly_raster_data,
         nodata_value=anomaly_raster_profile.get("nodata"),
     )
+    if np.sum(data_fits_criteria) == 0:
+        raise EmptyDataException(
+            " ".join(
+                [
+                    "Expected the passed threshold criteria to match at least some data.",
+                    f"Check that the values of threshold_criteria ({threshold_criteria})",
+                    f"and threshold_criteria_value {threshold_criteria_value}",
+                    "match at least part of the data.",
+                ]
+            )
+        )
 
     cols = np.arange(anomaly_raster_data.shape[1])
     rows = np.arange(anomaly_raster_data.shape[0])

From fea025867184dfea03e69bc3c427e2882b107572 Mon Sep 17 00:00:00 2001
From: nialov <nikolasovaskainen@gmail.com>
Date: Fri, 15 Mar 2024 08:58:33 +0200
Subject: [PATCH 17/17] test(distance_to_anomaly): test criteria data check

---
 tests/raster_processing/test_distance_to_anomaly.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tests/raster_processing/test_distance_to_anomaly.py b/tests/raster_processing/test_distance_to_anomaly.py
index eb033291..00adac8a 100644
--- a/tests/raster_processing/test_distance_to_anomaly.py
+++ b/tests/raster_processing/test_distance_to_anomaly.py
@@ -10,7 +10,7 @@
 import rasterio.profiles
 from beartype.roar import BeartypeCallHintParamViolation
 
-from eis_toolkit.exceptions import InvalidParameterValueException
+from eis_toolkit.exceptions import EmptyDataException, InvalidParameterValueException
 from eis_toolkit.raster_processing import distance_to_anomaly
 from tests.raster_processing.clip_test import raster_path as SMALL_RASTER_PATH
 
@@ -228,6 +228,15 @@ def test_distance_to_anomaly_gdal(
             partial(pytest.raises, BeartypeCallHintParamViolation),
             id="expected_invalid_param_due_to_tuple_of_length_three",
         ),
+        pytest.param(
+            SMALL_RASTER_PROFILE,
+            SMALL_RASTER_DATA,
+            (100.5, 122.5),
+            "in_between",
+            dict,
+            partial(pytest.raises, EmptyDataException),
+            id="expected_empty_data_due_to_threshold_range_outside_values",
+        ),
     ],
 )
 def test_distance_to_anomaly_check(