From d091a2ae07ab4cadbae74517ba8500a6e7473b24 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Fri, 2 Aug 2024 12:05:00 +0200 Subject: [PATCH 01/13] fix aggr issue when nan transcripts + tests (#101) --- sopa/segmentation/aggregate.py | 3 +++ sopa/utils/data.py | 3 +++ tests/test_aggregation.py | 5 ++++- 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index 4a635638..52848232 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -471,6 +471,9 @@ def _add_coo( joined = geo_df.sjoin(points_gdf) cells_indices, column_indices = joined.index, joined[gene_column].cat.codes + cells_indices = cells_indices[column_indices >= 0] + column_indices = column_indices[column_indices >= 0] + X_partition = coo_matrix( (np.full(len(cells_indices), 1), (cells_indices, column_indices)), shape=(len(geo_df), len(gene_names)), diff --git a/sopa/utils/data.py b/sopa/utils/data.py index 4c3e51d1..1f04da52 100644 --- a/sopa/utils/data.py +++ b/sopa/utils/data.py @@ -125,6 +125,9 @@ def uniform( else: gene_names = np.random.choice(genes, size=n_genes) + gene_names = gene_names.astype(object) + gene_names[3] = np.nan # Add a nan value for tests + df = pd.DataFrame( { "x": points_coords[:, 0], diff --git a/tests/test_aggregation.py b/tests/test_aggregation.py index 4bf234f0..1ff4635a 100644 --- a/tests/test_aggregation.py +++ b/tests/test_aggregation.py @@ -40,6 +40,9 @@ def test_count_transcripts(): "gene": ["a", "a", "b", "c", "a", "c", "b", "b"], } ) + df_pandas["gene"] = df_pandas["gene"].astype(object) + df_pandas["gene"].loc[0] = np.nan + points = dd.from_pandas(df_pandas, npartitions=2) polygons = [ Polygon(((1, 2), (3, 2), (3, 4), (1, 4))), @@ -50,6 +53,6 @@ def test_count_transcripts(): gdf = gpd.GeoDataFrame(geometry=polygons) adata = aggregate._count_transcripts_aligned(gdf, points, "gene") - expected = np.array([[0, 3, 1], [2, 0, 1], [2, 3, 1]]) + expected = np.array([[0, 3, 1], [1, 0, 1], [1, 3, 1]]) assert (adata.X.toarray() == expected).all() From 0d279adeaf42e592abe199630eb2a2cbac5870d5 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Fri, 2 Aug 2024 12:06:13 +0200 Subject: [PATCH 02/13] update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d6b64036..cfc89f62 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,8 @@ +## [1.x.x] - 2024-xx-xx + +### Fix +- Fixed aggregation issue when gene names are `NaN` or `None` (#101) + ## [1.1.2] - 2024-07-24 ### Fix From fefedb1908d4f431246c33ec5faacfab3a0a84a3 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sat, 3 Aug 2024 14:35:18 +0200 Subject: [PATCH 03/13] Support multipolygons in ROI rasterization --- CHANGELOG.md | 3 +++ sopa/segmentation/shapes.py | 14 +++++++++++--- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cfc89f62..994d04f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,9 @@ ### Fix - Fixed aggregation issue when gene names are `NaN` or `None` (#101) +### Added +- Support multipolygons in ROI rasterization + ## [1.1.2] - 2024-07-24 ### Fix diff --git a/sopa/segmentation/shapes.py b/sopa/segmentation/shapes.py index 07650832..08abb2e1 100644 --- a/sopa/segmentation/shapes.py +++ b/sopa/segmentation/shapes.py @@ -179,7 +179,7 @@ def pixel_outer_bounds(bounds: tuple[int, int, int, int]) -> tuple[int, int, int def rasterize( - cell: Polygon, shape: tuple[int, int], xy_min: tuple[int, int] = [0, 0] + cell: Polygon | MultiPolygon, shape: tuple[int, int], xy_min: tuple[int, int] = [0, 0] ) -> np.ndarray: """Transform a cell polygon into a numpy array with value 1 where the polygon touches a pixel, else 0. @@ -196,6 +196,14 @@ def rasterize( xmin, ymin, xmax, ymax = [xy_min[0], xy_min[1], xy_min[0] + shape[1], xy_min[1] + shape[0]] cell_translated = shapely.affinity.translate(cell, -xmin, -ymin) + geoms = ( + cell_translated.geoms if isinstance(cell_translated, MultiPolygon) else [cell_translated] + ) + + rasterized_image = np.zeros((ymax - ymin, xmax - xmin), dtype=np.int8) + + for geom in geoms: + coords = np.array(geom.exterior.coords)[None, :].astype(np.int32) + cv2.fillPoly(rasterized_image, coords, color=1) - coords = np.array(cell_translated.exterior.coords)[None, :].astype(np.int32) - return cv2.fillPoly(np.zeros((ymax - ymin, xmax - xmin), dtype=np.int8), coords, color=1) + return rasterized_image From 535c0d9cd0c601b0302f4727731786e17368ccbe Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Mon, 5 Aug 2024 15:49:02 +0200 Subject: [PATCH 04/13] add aggregate_bins (WIP) --- sopa/segmentation/aggregate.py | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index 52848232..7eb01236 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -480,3 +480,30 @@ def _add_coo( ) X_partitions.append(X_partition) + + +def aggregate_bins(sdata: SpatialData, table_key: str, shapes_key: str, bins_key: str) -> AnnData: + """Aggregate bins (for instance, from Visium HD data) into cells. + + Args: + sdata: The `SpatialData` object + table_key: Key of the table containing the bin-by-gene counts + shapes_key: Key of the shapes containing the cell boundaries + bins_key: Key of the shapes containing the bins boundaries + + Returns: + An `AnnData` object of shape with the cell-by-gene count matrix + """ + bins = sdata[bins_key][["geometry"]].reset_index(drop=True) # bins as points + cells = to_intrinsic(sdata, shapes_key, bins_key).reset_index(drop=True) + + bin_within_cell = gpd.sjoin(bins, cells) + + indices_matrix = coo_matrix( + (np.full(len(bin_within_cell), 1), (bin_within_cell["index_right"], bin_within_cell.index)), + shape=(len(cells), len(bins)), + ) + + adata = AnnData(indices_matrix @ sdata[table_key].X, obs=cells[[]], var=sdata[table_key].var) + adata.obsm["spatial"] = np.stack([cells.centroid.x, cells.centroid.y], axis=1) + return adata From f4fc9d4f901f9578e9ec32fd17398a1faec5c852 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 11 Aug 2024 10:37:12 +0200 Subject: [PATCH 05/13] minor update aggregate bins (add expand radius) --- sopa/patches/patches.py | 2 +- sopa/segmentation/aggregate.py | 30 ++++++++++++++++++++++-------- 2 files changed, 23 insertions(+), 9 deletions(-) diff --git a/sopa/patches/patches.py b/sopa/patches/patches.py index bcb0a689..a3ef0f38 100644 --- a/sopa/patches/patches.py +++ b/sopa/patches/patches.py @@ -297,7 +297,7 @@ def write( self, temp_dir: str, cell_key: str = None, - unassigned_value: int | str = None, + unassigned_value: int | str | None = None, use_prior: bool = False, config: dict = {}, config_path: str | None = None, diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index 7eb01236..f38056d8 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -301,6 +301,15 @@ def _fillna(df: pd.DataFrame): df[key] = df[key].fillna(0) +def expand_radius(geo_df: gpd.GeoDataFrame, expand_radius_ratio: float | None) -> gpd.GeoDataFrame: + if not expand_radius_ratio: + return geo_df + + expand_radius_ = expand_radius_ratio * np.mean(np.sqrt(geo_df.area / np.pi)) + geo_df.geometry = geo_df.buffer(expand_radius_) + return geo_df + + def average_channels( sdata: SpatialData, image_key: str = None, @@ -322,11 +331,7 @@ def average_channels( geo_df = get_element(sdata, "shapes", shapes_key) geo_df = to_intrinsic(sdata, geo_df, image) - - expand_radius = expand_radius_ratio * np.mean(np.sqrt(geo_df.area / np.pi)) - - if expand_radius > 0: - geo_df = geo_df.buffer(expand_radius) + geo_df = expand_radius(geo_df, expand_radius_ratio) log.info( f"Averaging channels intensity over {len(geo_df)} cells with expansion {expand_radius}" @@ -397,7 +402,7 @@ def count_transcripts( gene_column: str, shapes_key: str = None, points_key: str = None, - geo_df: gpd.GeoDataFrame = None, + geo_df: gpd.GeoDataFrame | None = None, ) -> AnnData: """Counts transcripts per cell. @@ -482,7 +487,13 @@ def _add_coo( X_partitions.append(X_partition) -def aggregate_bins(sdata: SpatialData, table_key: str, shapes_key: str, bins_key: str) -> AnnData: +def aggregate_bins( + sdata: SpatialData, + table_key: str, + shapes_key: str, + bins_key: str, + expand_radius_ratio: float = 0, +) -> AnnData: """Aggregate bins (for instance, from Visium HD data) into cells. Args: @@ -490,12 +501,15 @@ def aggregate_bins(sdata: SpatialData, table_key: str, shapes_key: str, bins_key table_key: Key of the table containing the bin-by-gene counts shapes_key: Key of the shapes containing the cell boundaries bins_key: Key of the shapes containing the bins boundaries + expand_radius_ratio: Cells polygons will be expanded by `expand_radius_ratio * mean_radius`. This help better aggregate bins from the cytoplasm. Returns: An `AnnData` object of shape with the cell-by-gene count matrix """ - bins = sdata[bins_key][["geometry"]].reset_index(drop=True) # bins as points + bins = sdata.shapes[bins_key][["geometry"]].reset_index(drop=True) # bins as points + cells = to_intrinsic(sdata, shapes_key, bins_key).reset_index(drop=True) + cells = expand_radius(cells, expand_radius_ratio) bin_within_cell = gpd.sjoin(bins, cells) From 5ff6583d7308e8b6ef751ac23183f0217b311361 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 11 Aug 2024 12:49:29 +0200 Subject: [PATCH 06/13] Fix Xenium reader for old Xenium data format (#105) --- CHANGELOG.md | 3 +++ sopa/io/__init__.py | 1 + sopa/io/reader/merscope.py | 2 ++ sopa/io/reader/visium_hd.py | 46 +++++++++++++++++++++++++++++++++++++ sopa/io/reader/xenium.py | 9 +++++++- sopa/utils/__init__.py | 1 + sopa/utils/image.py | 30 ++++++++++++++++++++++-- 7 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 sopa/io/reader/visium_hd.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 994d04f2..e8a063a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,9 +2,12 @@ ### Fix - Fixed aggregation issue when gene names are `NaN` or `None` (#101) +- Fix Xenium reader for old Xenium data format (#105) ### Added - Support multipolygons in ROI rasterization +- Added bins aggregation +- Added Visium HD reader (tutorial comming soon) ## [1.1.2] - 2024-07-24 diff --git a/sopa/io/__init__.py b/sopa/io/__init__.py index 06bd492f..0c5ea984 100644 --- a/sopa/io/__init__.py +++ b/sopa/io/__init__.py @@ -22,6 +22,7 @@ from .reader.utils import ome_tif from .reader.wsi import wsi, wsi_autoscale from .reader.aics import aicsimageio +from .reader.visium_hd import visium_hd from .report import write_report from ..utils.data import blobs, uniform diff --git a/sopa/io/reader/merscope.py b/sopa/io/reader/merscope.py index b1848d8c..0a66200f 100644 --- a/sopa/io/reader/merscope.py +++ b/sopa/io/reader/merscope.py @@ -20,6 +20,7 @@ def merscope( slide_name: str | None = None, image_models_kwargs: dict | None = None, imread_kwargs: dict | None = None, + **kwargs: int, ) -> SpatialData: """Read MERSCOPE data as a `SpatialData` object. For more information, refer to [spatialdata-io](https://spatialdata.scverse.org/projects/io/en/latest/generated/spatialdata_io.merscope.html). @@ -52,4 +53,5 @@ def merscope( imread_kwargs=imread_kwargs, cells_boundaries=False, cells_table=False, + **kwargs, ) diff --git a/sopa/io/reader/visium_hd.py b/sopa/io/reader/visium_hd.py new file mode 100644 index 00000000..846bd61a --- /dev/null +++ b/sopa/io/reader/visium_hd.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +import logging +from pathlib import Path + +from spatialdata import SpatialData +from spatialdata_io.readers.visium_hd import visium_hd as visium_hd_spatialdata_io + +from ...utils import string_channel_names +from .utils import _default_image_kwargs + +log = logging.getLogger(__name__) + + +def visium_hd( + path: str | Path, + bin_size: int | list[int] | None = 2, + image_models_kwargs: dict | None = None, + imread_kwargs: dict | None = None, + **kwargs: int, +) -> SpatialData: + """Read Visium HD data as a `SpatialData` object. For more information, refer to [spatialdata-io](https://spatialdata.scverse.org/projects/io/en/latest/generated/spatialdata_io.visium_hd.html). + + Args: + path: Path to the Visium HD directory containing all the experiment files + image_models_kwargs: Keyword arguments passed to `spatialdata.models.Image2DModel`. + imread_kwargs: Keyword arguments passed to `dask_image.imread.imread`. + + Returns: + A `SpatialData` object representing the Xenium experiment + """ + image_models_kwargs, imread_kwargs = _default_image_kwargs(image_models_kwargs, imread_kwargs) + + del image_models_kwargs["scale_factors"] # already set in the spatialdata_io reader + + sdata = visium_hd_spatialdata_io( + path, + bin_size=bin_size, + image_models_kwargs=image_models_kwargs, + imread_kwargs=imread_kwargs, + **kwargs, + ) + + string_channel_names(sdata) # Ensure that channel names are strings + + return sdata diff --git a/sopa/io/reader/xenium.py b/sopa/io/reader/xenium.py index 37cde294..28b02efc 100644 --- a/sopa/io/reader/xenium.py +++ b/sopa/io/reader/xenium.py @@ -6,6 +6,7 @@ from spatialdata import SpatialData from spatialdata_io.readers.xenium import xenium as xenium_spatialdata_io +from ...utils import string_channel_names from .utils import _default_image_kwargs log = logging.getLogger(__name__) @@ -15,6 +16,7 @@ def xenium( path: str | Path, image_models_kwargs: dict | None = None, imread_kwargs: dict | None = None, + **kwargs: int, ) -> SpatialData: """Read Xenium data as a `SpatialData` object. For more information, refer to [spatialdata-io](https://spatialdata.scverse.org/projects/io/en/latest/generated/spatialdata_io.xenium.html). @@ -34,7 +36,7 @@ def xenium( """ image_models_kwargs, imread_kwargs = _default_image_kwargs(image_models_kwargs, imread_kwargs) - return xenium_spatialdata_io( + sdata = xenium_spatialdata_io( path, cells_table=False, aligned_images=False, @@ -46,4 +48,9 @@ def xenium( cells_boundaries=False, image_models_kwargs=image_models_kwargs, imread_kwargs=imread_kwargs, + **kwargs, ) + + string_channel_names(sdata) # Ensure that channel names are strings + + return sdata diff --git a/sopa/utils/__init__.py b/sopa/utils/__init__.py index e69de29b..7b047d1a 100644 --- a/sopa/utils/__init__.py +++ b/sopa/utils/__init__.py @@ -0,0 +1 @@ +from .image import get_channel_names, scale_dtype, string_channel_names diff --git a/sopa/utils/image.py b/sopa/utils/image.py index 09f3b43d..c2e49672 100644 --- a/sopa/utils/image.py +++ b/sopa/utils/image.py @@ -3,10 +3,12 @@ import dask.array as da import dask_image.ndinterp import numpy as np -import xarray as xr +from datatree import DataTree +from spatialdata import SpatialData +from xarray import DataArray -def resize(xarr: xr.DataArray, scale_factor: float) -> da.Array: +def resize(xarr: DataArray, scale_factor: float) -> da.Array: """Resize a xarray image Args: @@ -77,3 +79,27 @@ def scale_dtype(arr: np.ndarray, dtype: np.dtype) -> np.ndarray: factor = np.iinfo(dtype).max / np.iinfo(arr.dtype).max return (arr * factor).astype(dtype) + + +def get_channel_names(image: DataArray | DataTree) -> np.ndarray: + if isinstance(image, DataArray): + return image.coords["c"].values + if isinstance(image, DataTree): + return image["scale0"].coords["c"].values + raise ValueError(f"Image must be a DataTree or a DataArray. Found: {type(image)}") + + +def string_channel_names(sdata: SpatialData, default_single_channel: str = "DAPI"): + for key, image in list(sdata.images.items()): + c_coords = get_channel_names(image) + + if c_coords.dtype.kind in {"U", "S"}: + continue + + c_coords = [str(i) for i in range(len(c_coords))] + if len(c_coords) == 1: + c_coords = [default_single_channel] + + new_image = image.assign_coords(c=c_coords) + del sdata.images[key] + sdata.images[key] = new_image From 0d528cf225fde9b11efb0193646eb3f5b9f41002 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 11 Aug 2024 13:06:15 +0200 Subject: [PATCH 07/13] minor change bins aggregation --- sopa/segmentation/aggregate.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index f38056d8..13631e4a 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -506,7 +506,7 @@ def aggregate_bins( Returns: An `AnnData` object of shape with the cell-by-gene count matrix """ - bins = sdata.shapes[bins_key][["geometry"]].reset_index(drop=True) # bins as points + bins = sdata.shapes[bins_key].centroid.reset_index(drop=True) # bins as points cells = to_intrinsic(sdata, shapes_key, bins_key).reset_index(drop=True) cells = expand_radius(cells, expand_radius_ratio) From 4f9189ac5346a8d7700025790a4eea45717a468d Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 11 Aug 2024 13:27:55 +0200 Subject: [PATCH 08/13] add submodule imports in init --- sopa/__init__.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sopa/__init__.py b/sopa/__init__.py index 867b5505..73a50751 100644 --- a/sopa/__init__.py +++ b/sopa/__init__.py @@ -1,8 +1,14 @@ import importlib.metadata import logging +import sys from ._logging import configure_logger __version__ = importlib.metadata.version("sopa") log = logging.getLogger("sopa") configure_logger(log) + +if "--help" not in sys.argv: + from . import utils + from . import io + from . import segmentation From e4e6e2254a1ca51c74756477ee359e476845c556 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 11 Aug 2024 13:28:30 +0200 Subject: [PATCH 09/13] update changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index e8a063a7..7e1128e8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,9 @@ - Added bins aggregation - Added Visium HD reader (tutorial comming soon) +### Changed +- Import submodules in init (segmentation, io, utils) + ## [1.1.2] - 2024-07-24 ### Fix From c501a76db6be4fb4cb48abb03ca3c87d9018e48c Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Tue, 13 Aug 2024 11:55:12 +0200 Subject: [PATCH 10/13] minor API improvements/cleaning --- sopa/cli/patchify.py | 6 ++---- sopa/io/standardize.py | 9 +++------ sopa/utils/__init__.py | 8 +++++++- sopa/utils/image.py | 6 +++++- 4 files changed, 17 insertions(+), 12 deletions(-) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 34c479a7..05d2f68e 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -24,11 +24,10 @@ def image( """Prepare patches for staining-based segmentation (including Cellpose)""" from sopa._constants import SopaFiles from sopa._sdata import get_key - from sopa.io.standardize import read_zarr_standardized, sanity_check + from sopa.io.standardize import read_zarr_standardized from sopa.patches import Patches2D sdata = read_zarr_standardized(sdata_path) - sanity_check(sdata) image_key = get_key(sdata, "images") @@ -195,11 +194,10 @@ def _patchify_transcripts( """ from sopa._constants import SopaFiles from sopa._sdata import get_key - from sopa.io.standardize import read_zarr_standardized, sanity_check + from sopa.io.standardize import read_zarr_standardized from sopa.patches import Patches2D sdata = read_zarr_standardized(sdata_path) - sanity_check(sdata) if isinstance(unassigned_value, str) and unassigned_value.isdigit(): unassigned_value = int(unassigned_value) diff --git a/sopa/io/standardize.py b/sopa/io/standardize.py index 1a2fbbb1..ac3c0aa1 100644 --- a/sopa/io/standardize.py +++ b/sopa/io/standardize.py @@ -8,7 +8,7 @@ from .._constants import VALID_DIMENSIONS, SopaKeys from .._sdata import get_spatial_image -from ..utils.image import _check_integer_dtype +from ..utils import _check_integer_dtype, get_channel_names, is_string_dtype log = logging.getLogger(__name__) @@ -36,11 +36,8 @@ def sanity_check(sdata: SpatialData, delete_table: bool = False, warn: bool = Fa f"The spatialdata object has {len(sdata.points)} points objects. It's easier to have only one (corresponding to transcripts), since sopa will use it directly without providing a key argument" ) - # TODO: see https://github.com/scverse/spatialdata/issues/402 - # image_channels: np.ndarray = image.coords["c"].values - # if image_channels.dtype.type is not np.str_: - # log.warn(f"Channel names are not strings. Converting {image_channels} to string values.") - # sdata[image_key].data = sdata[image_key].assign_coords(c=image_channels.astype(str)) + c_coords = get_channel_names(image) + assert is_string_dtype(c_coords), f"Channel names must be strings, not {c_coords.dtype}" if SopaKeys.TABLE in sdata.tables: if delete_table: diff --git a/sopa/utils/__init__.py b/sopa/utils/__init__.py index 7b047d1a..b6daa3e6 100644 --- a/sopa/utils/__init__.py +++ b/sopa/utils/__init__.py @@ -1 +1,7 @@ -from .image import get_channel_names, scale_dtype, string_channel_names +from .image import ( + get_channel_names, + scale_dtype, + string_channel_names, + is_string_dtype, + _check_integer_dtype, +) diff --git a/sopa/utils/image.py b/sopa/utils/image.py index c2e49672..ded1de14 100644 --- a/sopa/utils/image.py +++ b/sopa/utils/image.py @@ -89,11 +89,15 @@ def get_channel_names(image: DataArray | DataTree) -> np.ndarray: raise ValueError(f"Image must be a DataTree or a DataArray. Found: {type(image)}") +def is_string_dtype(c_coords: np.ndarray) -> bool: + return c_coords.dtype.kind in {"U", "S"} + + def string_channel_names(sdata: SpatialData, default_single_channel: str = "DAPI"): for key, image in list(sdata.images.items()): c_coords = get_channel_names(image) - if c_coords.dtype.kind in {"U", "S"}: + if is_string_dtype(c_coords): continue c_coords = [str(i) for i in range(len(c_coords))] From d0a541e993f822047a991650078242043c29c953 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 18 Aug 2024 12:25:17 +0200 Subject: [PATCH 11/13] major API simplification (WIP) --- CHANGELOG.md | 1 + pyproject.toml | 4 +- sopa/__init__.py | 3 + sopa/_constants.py | 7 ++ sopa/_sdata.py | 122 +++++++++++++++++------------ sopa/annotation/tangram/run.py | 11 +-- sopa/cli/annotate.py | 8 +- sopa/cli/app.py | 20 ++--- sopa/cli/check.py | 7 +- sopa/cli/explorer.py | 12 +-- sopa/cli/patchify.py | 16 ++-- sopa/cli/resolve.py | 28 ++----- sopa/cli/segmentation.py | 8 +- sopa/io/explorer/converter.py | 13 ++- sopa/io/explorer/images.py | 11 +-- sopa/io/explorer/shapes.py | 4 +- sopa/io/explorer/table.py | 8 +- sopa/io/explorer/utils.py | 12 +-- sopa/io/reader/aics.py | 8 +- sopa/io/reader/cosmx.py | 31 ++------ sopa/io/reader/hyperion.py | 4 +- sopa/io/reader/macsima.py | 4 +- sopa/io/reader/utils.py | 4 +- sopa/io/reader/visium_hd.py | 13 ++- sopa/io/reader/wsi.py | 4 +- sopa/io/reader/xenium.py | 7 +- sopa/io/report/engine.py | 17 ++-- sopa/io/report/generate.py | 8 +- sopa/io/standardize.py | 24 ++---- sopa/patches/cluster.py | 4 +- sopa/patches/infer.py | 30 +++---- sopa/patches/models/resnet.py | 4 +- sopa/patches/patches.py | 39 ++++----- sopa/segmentation/__init__.py | 1 + sopa/segmentation/aggregate.py | 53 ++++--------- sopa/segmentation/shapes.py | 16 +--- sopa/segmentation/stainings.py | 4 +- sopa/segmentation/tissue.py | 96 ++++++++++++++--------- sopa/segmentation/transcripts.py | 26 ++---- sopa/spatial/_build.py | 4 +- sopa/spatial/_graph.py | 4 +- sopa/spatial/morpho.py | 8 +- sopa/spatial/utils.py | 8 +- sopa/utils/data.py | 14 +--- sopa/utils/image.py | 21 ++--- sopa/utils/polygon_crop.py | 8 +- tests/test_aggregation.py | 4 +- tests/test_patches.py | 8 +- tests/test_rasterize_geometries.py | 4 +- tests/test_spatial_stats.py | 4 +- workflow/utils.py | 20 +---- 51 files changed, 323 insertions(+), 476 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e1128e8..10d298d7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ ### Changed - Import submodules in init (segmentation, io, utils) +- API simplification in progress (new API + tutorial comming soon) ## [1.1.2] - 2024-07-24 diff --git a/pyproject.toml b/pyproject.toml index 266ac0cf..f8ff8f01 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "sopa" -version = "1.1.2" +version = "1.1.3" description = "Spatial-omics pipeline and analysis" documentation = "https://gustaveroussy.github.io/sopa" homepage = "https://gustaveroussy.github.io/sopa" @@ -76,7 +76,7 @@ testpaths = ["tests"] python_files = "test_*.py" [tool.black] -line-length = 100 +line-length = 120 include = '\.pyi?$' exclude = ''' /( diff --git a/sopa/__init__.py b/sopa/__init__.py index 73a50751..2046c06f 100644 --- a/sopa/__init__.py +++ b/sopa/__init__.py @@ -12,3 +12,6 @@ from . import utils from . import io from . import segmentation + + from .segmentation import tissue_segmentation + from ._sdata import get_spatial_image, get_spatial_element, to_intrinsic diff --git a/sopa/_constants.py b/sopa/_constants.py index f6fb3b57..3a80d0c8 100644 --- a/sopa/_constants.py +++ b/sopa/_constants.py @@ -33,6 +33,13 @@ class SopaKeys: GEOMETRY_COUNT = "n_components" +class SopaAttrs: + CELL_SEGMENTATION = "for_cell_segmentation" + TISSUE_SEGMENTATION = "for_tissue_segmentation" + BINS_AGGREGATION = "for_bins_aggregation" + GENE_COLUMN = "feature_key" + + VALID_DIMENSIONS = ("c", "y", "x") LOW_AVERAGE_COUNT = 0.01 EPS = 1e-5 diff --git a/sopa/_sdata.py b/sopa/_sdata.py index 3de83c76..21020e5e 100644 --- a/sopa/_sdata.py +++ b/sopa/_sdata.py @@ -12,7 +12,7 @@ from spatialdata.transformations import Identity, get_transformation, set_transformation from xarray import DataArray -from ._constants import SopaKeys +from ._constants import SopaAttrs, SopaKeys log = logging.getLogger(__name__) @@ -40,9 +40,7 @@ def get_boundaries( if res is not None: return res - error_message = ( - "sdata object has no valid segmentation boundary. Consider running Sopa segmentation first." - ) + error_message = "sdata object has no valid segmentation boundary. Consider running Sopa segmentation first." if not warn: raise ValueError(error_message) @@ -51,17 +49,13 @@ def get_boundaries( return (None, None) if return_key else None -def _try_get_boundaries( - sdata: SpatialData, shapes_key: str, return_key: bool -) -> gpd.GeoDataFrame | None: +def _try_get_boundaries(sdata: SpatialData, shapes_key: str, return_key: bool) -> gpd.GeoDataFrame | None: """Try to get a cell boundaries for a given `shapes_key`""" if shapes_key in sdata.shapes: return (shapes_key, sdata[shapes_key]) if return_key else sdata[shapes_key] -def get_intrinsic_cs( - sdata: SpatialData, element: SpatialElement | str, name: str | None = None -) -> str: +def get_intrinsic_cs(sdata: SpatialData, element: SpatialElement | str, name: str | None = None) -> str: """Gets the name of the intrinsic coordinate system of an element Args: @@ -86,9 +80,7 @@ def get_intrinsic_cs( return name -def to_intrinsic( - sdata: SpatialData, element: SpatialElement | str, element_cs: SpatialElement | str -) -> SpatialElement: +def to_intrinsic(sdata: SpatialData, element: SpatialElement | str, element_cs: SpatialElement | str) -> SpatialElement: """Transforms a `SpatialElement` into the intrinsic coordinate system of another `SpatialElement` Args: @@ -105,32 +97,6 @@ def to_intrinsic( return sdata.transform_element_to_coordinate_system(element, cs) -def get_key(sdata: SpatialData, attr: str, key: str | None = None): - if key is not None: - return key - - elements = getattr(sdata, attr) - - if not len(elements): - return None - - assert ( - len(elements) == 1 - ), f"Trying to get an element key of `sdata.{attr}`, but it contains multiple values and no dict key was provided" - - return next(iter(elements.keys())) - - -def get_element(sdata: SpatialData, attr: str, key: str | None = None): - key = get_key(sdata, attr, key) - return sdata[key] if key is not None else None - - -def get_item(sdata: SpatialData, attr: str, key: str | None = None): - key = get_key(sdata, attr, key) - return key, sdata[key] if key is not None else None - - def get_intensities(sdata: SpatialData) -> pd.DataFrame | None: """Gets the intensity dataframe of shape `n_obs x n_channels`""" assert SopaKeys.TABLE in sdata.tables, f"No '{SopaKeys.TABLE}' found in sdata.tables" @@ -155,35 +121,87 @@ def iter_scales(image: DataTree) -> Iterator[xr.DataArray]: Yields: Each scale (as a `xr.DataArray`) """ - assert isinstance( - image, DataTree - ), f"Multiscale iteration is reserved for type DataTree. Found {type(image)}" + assert isinstance(image, DataTree), f"Multiscale iteration is reserved for type DataTree. Found {type(image)}" for scale in image: yield next(iter(image[scale].values())) +def get_spatial_element( + element_dict: dict[str, SpatialElement], + key: str | None = None, + valid_attr: str | None = None, + return_key: bool = False, + as_spatial_image: bool = False, +) -> SpatialElement | tuple[str, SpatialElement]: + """Gets an element from a SpatialData object. + + Args: + sdata: SpatialData object. + key: Optional element key. If `None`, returns the only element (if only one), or tries to find an element with `valid_attr`. + return_key: Whether to also return the key of the element. + valid_attr: Attribute that the element must have to be considered valid. + as_spatial_image: Whether to return the element as a `SpatialImage` (if it is a `DataTree`) + + Returns: + If `return_key` is False, only the element is returned, else a tuple `(element_key, element)` + """ + assert len(element_dict), "No spatial element was found in the dict." + + if key is not None: + return _return_element(element_dict, key, return_key, as_spatial_image) + + if len(element_dict) == 1: + key = next(iter(element_dict.keys())) + + assert valid_attr is None or element_dict[key].attrs.get( + valid_attr, True + ), f"Element {key} is not valid for the attribute {valid_attr}." + + return _return_element(element_dict, key, return_key, as_spatial_image) + + assert valid_attr is not None, "Multiple elements found. Provide an element key." + + keys = [key for key, element in element_dict.items() if element.attrs.get(valid_attr)] + + assert len(keys) > 0, f"No element with the attribute {valid_attr}. Provide an element key." + assert len(keys) == 1, f"Multiple valid elements found: {keys}. Provide an element key." + + return _return_element(element_dict, keys[0], return_key, as_spatial_image) + + def get_spatial_image( - sdata: SpatialData, key: str | None = None, return_key: bool = False + sdata: SpatialData, + key: str | None = None, + return_key: bool = False, + valid_attr: str = SopaAttrs.CELL_SEGMENTATION, ) -> DataArray | tuple[str, DataArray]: """Gets a DataArray from a SpatialData object (if the image has multiple scale, the `scale0` is returned) Args: sdata: SpatialData object. - key: Optional image key. If `None`, returns the only image (if only one), or raises an error. + key: Optional image key. If `None`, returns the only image (if only one), or tries to find an image with `valid_attr`. return_key: Whether to also return the key of the image. + valid_attr: Attribute that the image must have to be considered valid. Returns: If `return_key` is False, only the image is returned, else a tuple `(image_key, image)` """ - key = get_key(sdata, "images", key) + return get_spatial_element( + sdata.images, + key=key, + valid_attr=valid_attr, + return_key=return_key, + as_spatial_image=True, + ) + - assert key is not None, "One image in `sdata.images` is required" +def _return_element( + element_dict: dict[str, SpatialElement], key: str, return_key: bool, as_spatial_image: bool +) -> SpatialElement | tuple[str, SpatialElement]: + element = element_dict[key] - image = sdata.images[key] - if isinstance(image, DataTree): - image = next(iter(image["scale0"].values())) + if as_spatial_image and isinstance(element, DataTree): + element = next(iter(element["scale0"].values())) - if return_key: - return key, image - return image + return (key, element) if return_key else element diff --git a/sopa/annotation/tangram/run.py b/sopa/annotation/tangram/run.py index f63d9447..76ebddbb 100644 --- a/sopa/annotation/tangram/run.py +++ b/sopa/annotation/tangram/run.py @@ -124,9 +124,7 @@ def init_obsm(self, level: int): ) def get_hard_labels(self, df: pd.DataFrame) -> pd.Series: - df = df.clip( - df.quantile(1 - self.clip_percentile), df.quantile(self.clip_percentile), axis=1 - ) + df = df.clip(df.quantile(1 - self.clip_percentile), df.quantile(self.clip_percentile), axis=1) df = (df - df.min()) / (df.max() - df.min()) return df.idxmax(1) @@ -138,9 +136,7 @@ def pp_adata(self, ad_sp_: AnnData, ad_sc_: AnnData, split: np.ndarray) -> AnnDa sc.pp.filter_genes(ad_sp_split, min_cells=1) # Calculate uniform density prior as 1/number_of_spots - ad_sp_split.obs["uniform_density"] = ( - np.ones(ad_sp_split.X.shape[0]) / ad_sp_split.X.shape[0] - ) + ad_sp_split.obs["uniform_density"] = np.ones(ad_sp_split.X.shape[0]) / ad_sp_split.X.shape[0] # Calculate rna_count_based density prior as % of rna molecule count rna_count_per_spot = np.array(ad_sp_split.X.sum(axis=1)).squeeze() @@ -157,8 +153,7 @@ def pp_adata(self, ad_sp_: AnnData, ad_sc_: AnnData, split: np.ndarray) -> AnnDa ) selection = list( - set(ad_sp_split.var_names[ad_sp_split.var.counts > 0]) - & set(ad_sc_.var_names[ad_sc_.var.counts > 0]) + set(ad_sp_split.var_names[ad_sp_split.var.counts > 0]) & set(ad_sc_.var_names[ad_sc_.var.counts > 0]) ) assert len( diff --git a/sopa/cli/annotate.py b/sopa/cli/annotate.py index 006e1e84..9cb8e51a 100644 --- a/sopa/cli/annotate.py +++ b/sopa/cli/annotate.py @@ -13,9 +13,7 @@ def fluorescence( sdata_path: str = typer.Argument(help=SDATA_HELPER), marker_cell_dict: str = typer.Option(callback=ast.literal_eval), - cell_type_key: str = typer.Option( - "cell_type", help="Key added in `adata.obs` corresponding to the cell type" - ), + cell_type_key: str = typer.Option("cell_type", help="Key added in `adata.obs` corresponding to the cell type"), ): """Simple annotation based on fluorescence, where each provided channel corresponds to one cell type. @@ -39,9 +37,7 @@ def fluorescence( @app_annotate.command() def tangram( sdata_path: str = typer.Argument(help=SDATA_HELPER), - sc_reference_path: str = typer.Option( - help="Path to the scRNAseq annotated reference, as a `.h5ad` file" - ), + sc_reference_path: str = typer.Option(help="Path to the scRNAseq annotated reference, as a `.h5ad` file"), cell_type_key: str = typer.Option(help="Key of `adata_ref.obs` containing the cell-types"), reference_preprocessing: str = typer.Option( None, diff --git a/sopa/cli/app.py b/sopa/cli/app.py index e0cbb4fc..3c6bf66c 100644 --- a/sopa/cli/app.py +++ b/sopa/cli/app.py @@ -28,9 +28,7 @@ name="segmentation", help="Perform cell segmentation on patches. NB: for `baysor`, use directly the `baysor` command line.", ) -app.add_typer( - app_resolve, name="resolve", help="Resolve the segmentation conflicts over patches overlaps" -) +app.add_typer(app_resolve, name="resolve", help="Resolve the segmentation conflicts over patches overlaps") app.add_typer( app_patchify, name="patchify", @@ -77,9 +75,7 @@ def read( io.standardize._check_can_write_zarr(sdata_path) - assert ( - technology is not None or config_path is not None - ), "Provide the argument `--technology` or `--config-path`" + assert technology is not None or config_path is not None, "Provide the argument `--technology` or `--config-path`" if config_path is not None: assert not kwargs, "Provide either a path to a config, or some kwargs, but not both" @@ -114,9 +110,7 @@ def crop( None, help="List of channel names to be displayed. Optional if there are already only 1 or 3 channels", ), - scale_factor: float = typer.Option( - 10, help="Resize the image by this value (high value for a lower memory usage)" - ), + scale_factor: float = typer.Option(10, help="Resize the image by this value (high value for a lower memory usage)"), margin_ratio: float = typer.Option( 0.1, help="Ratio of the image margin on the display (compared to the image size)" ), @@ -163,16 +157,12 @@ def aggregate( None, help="Column of the transcript dataframe representing the gene names. If not provided, it will not compute transcript count", ), - average_intensities: bool = typer.Option( - False, help="Whether to average the channel intensities inside each cell" - ), + average_intensities: bool = typer.Option(False, help="Whether to average the channel intensities inside each cell"), expand_radius_ratio: float = typer.Option( default=0, help="Cells polygons will be expanded by `expand_radius_ratio * mean_radius` for channels averaging **only**. This help better aggregate boundary stainings", ), - min_transcripts: int = typer.Option( - 0, help="Cells with less transcript than this integer will be filtered" - ), + min_transcripts: int = typer.Option(0, help="Cells with less transcript than this integer will be filtered"), min_intensity_ratio: float = typer.Option( 0, help="Cells whose mean channel intensity is less than `min_intensity_ratio * quantile_90` will be filtered", diff --git a/sopa/cli/check.py b/sopa/cli/check.py index 063432aa..0ab7c6f5 100644 --- a/sopa/cli/check.py +++ b/sopa/cli/check.py @@ -16,9 +16,7 @@ def _open_config(path: str) -> dict: with open(path, "r") as f: return yaml.safe_load(f) except: - log.warn( - f"Config file '{path}' could't be read. Make sure that the file exist and that it is a YAML file" - ) + log.warn(f"Config file '{path}' could't be read. Make sure that the file exist and that it is a YAML file") return @@ -99,8 +97,7 @@ def _check_dict(config: dict, d: dict, log, prefix: str = "config"): break else: display = "\n - ".join( - element if isinstance(element, str) else " AND ".join(element) - for element in values + element if isinstance(element, str) else " AND ".join(element) for element in values ) log.warn(f"One of these element must be in {prefix}['{key}']:\n - {display}") diff --git a/sopa/cli/explorer.py b/sopa/cli/explorer.py index 8bf23f2e..09035325 100644 --- a/sopa/cli/explorer.py +++ b/sopa/cli/explorer.py @@ -6,9 +6,7 @@ app_explorer = typer.Typer() -PIXELSIZE_DEPRECATED = ( - "`pixelsize` is deprecated and will be removed in future versions. Use `pixel_size` instead." -) +PIXELSIZE_DEPRECATED = "`pixelsize` is deprecated and will be removed in future versions. Use `pixel_size` instead." @app_explorer.command() @@ -18,9 +16,7 @@ def write( None, help="Path to a directory where Xenium Explorer's outputs will be saved. By default, writes to the same path as `sdata_path` but with the `.explorer` suffix", ), - gene_column: str = typer.Option( - None, help="Column name of the points dataframe containing the gene names" - ), + gene_column: str = typer.Option(None, help="Column name of the points dataframe containing the gene names"), shapes_key: str = typer.Option( None, help="Sdata key for the boundaries. By default, uses the baysor boundaires, else the cellpose boundaries", @@ -134,6 +130,4 @@ def add_aligned( sdata = spatialdata.read_zarr(sdata_path) image = io.ome_tif(image_path, as_image=True) - align( - sdata, image, transformation_matrix_path, overwrite=overwrite, image_key=original_image_key - ) + align(sdata, image, transformation_matrix_path, overwrite=overwrite, image_key=original_image_key) diff --git a/sopa/cli/patchify.py b/sopa/cli/patchify.py index 05d2f68e..dedd6ac6 100644 --- a/sopa/cli/patchify.py +++ b/sopa/cli/patchify.py @@ -13,9 +13,7 @@ @app_patchify.command() def image( sdata_path: str = typer.Argument(help=SDATA_HELPER), - patch_width_pixel: float = typer.Option( - 5000, help="Width (and height) of each patch in pixels" - ), + patch_width_pixel: float = typer.Option(5000, help="Width (and height) of each patch in pixels"), patch_overlap_pixel: float = typer.Option( 100, help="Number of overlapping pixels between the patches. We advise to choose approximately twice the diameter of a cell", @@ -23,13 +21,13 @@ def image( ): """Prepare patches for staining-based segmentation (including Cellpose)""" from sopa._constants import SopaFiles - from sopa._sdata import get_key + from sopa._sdata import get_spatial_image from sopa.io.standardize import read_zarr_standardized from sopa.patches import Patches2D sdata = read_zarr_standardized(sdata_path) - image_key = get_key(sdata, "images") + image_key, _ = get_spatial_image(sdata, return_key=True) patches = Patches2D(sdata, image_key, patch_width_pixel, patch_overlap_pixel) patches.write() @@ -120,9 +118,7 @@ def comseg( None, help="If --cell-key is provided, this is the value given to transcripts that are not inside any cell (if it's already 0, don't provide this argument)", ), - min_transcripts_per_patch: int = typer.Option( - 1000, help="Minimum number of transcripts per patch" - ), + min_transcripts_per_patch: int = typer.Option(1000, help="Minimum number of transcripts per patch"), min_cells_per_patch: int = typer.Option(1, help="Minimum number of cells per patch"), shapes_key: str = typer.Option( SopaKeys.CELLPOSE_BOUNDARIES, @@ -193,7 +189,7 @@ def _patchify_transcripts( """ from sopa._constants import SopaFiles - from sopa._sdata import get_key + from sopa._sdata import get_spatial_element from sopa.io.standardize import read_zarr_standardized from sopa.patches import Patches2D @@ -206,7 +202,7 @@ def _patchify_transcripts( config or config_path is not None ), "Provide '--config-path', the path to a Baysor config file (toml) or comseg file (jsons)" - df_key = get_key(sdata, "points") + df_key = get_spatial_element(sdata.points) patches = Patches2D(sdata, df_key, patch_width_microns, patch_overlap_microns) valid_indices = patches.patchify_transcripts( temp_dir, diff --git a/sopa/cli/resolve.py b/sopa/cli/resolve.py index e3fbedf9..d063f504 100644 --- a/sopa/cli/resolve.py +++ b/sopa/cli/resolve.py @@ -47,7 +47,7 @@ def generic( def _resolve_generic(sdata_path: str, patch_dirs: list[str], shapes_key: str): - from sopa._sdata import get_key + from sopa._sdata import get_spatial_image from sopa.io.standardize import read_zarr_standardized from sopa.segmentation import shapes from sopa.segmentation.stainings import StainingSegmentation @@ -56,7 +56,7 @@ def _resolve_generic(sdata_path: str, patch_dirs: list[str], shapes_key: str): assert len(patch_dirs) > 0, "No patch directory was provided, cannot load cells" - image_key = get_key(sdata, "images") + image_key, _ = get_spatial_image(sdata, return_key=True) cells = [] for patch_dir in patch_dirs: @@ -69,19 +69,13 @@ def _resolve_generic(sdata_path: str, patch_dirs: list[str], shapes_key: str): @app_resolve.command() def baysor( sdata_path: str = typer.Argument(help=SDATA_HELPER), - gene_column: str = typer.Option( - help="Column of the transcripts dataframe containing the genes names" - ), + gene_column: str = typer.Option(help="Column of the transcripts dataframe containing the genes names"), baysor_temp_dir: str = typer.Option( None, help="Path to the directory containing all the baysor patches (see `sopa patchify`). By default, uses the `.sopa_cache/baysor_boundaries` directory", ), - min_area: float = typer.Option( - 0, help="Cells with an area less than this value (in microns^2) will be filtered" - ), - patches_dirs: list[str] = typer.Option( - [], help="List of patches directories inside `baysor_temp_dir`" - ), + min_area: float = typer.Option(0, help="Cells with an area less than this value (in microns^2) will be filtered"), + patches_dirs: list[str] = typer.Option([], help="List of patches directories inside `baysor_temp_dir`"), ): """Resolve patches conflicts after baysor segmentation. Provide either `--baysor-temp-dir` or `--patches-dirs`""" from sopa._constants import SopaKeys @@ -101,19 +95,13 @@ def baysor( @app_resolve.command() def comseg( sdata_path: str = typer.Argument(help=SDATA_HELPER), - gene_column: str = typer.Option( - help="Column of the transcripts dataframe containing the genes names" - ), + gene_column: str = typer.Option(help="Column of the transcripts dataframe containing the genes names"), comseg_temp_dir: str = typer.Option( None, help="Path to the directory containing all the comseg patches (see `sopa patchify`). By default, uses the `.sopa_cache/comseg_boundaries` directory", ), - min_area: float = typer.Option( - 0, help="Cells with an area less than this value (in microns^2) will be filtered" - ), - patches_dirs: list[str] = typer.Option( - [], help="List of patches directories inside `comseg_temp_dir`" - ), + min_area: float = typer.Option(0, help="Cells with an area less than this value (in microns^2) will be filtered"), + patches_dirs: list[str] = typer.Option([], help="List of patches directories inside `comseg_temp_dir`"), ): """Resolve patches conflicts after comseg segmentation. Provide either `--comseg-temp-dir` or `--patches-dirs`""" from sopa._constants import SopaKeys diff --git a/sopa/cli/segmentation.py b/sopa/cli/segmentation.py index f39ce956..04aa1587 100644 --- a/sopa/cli/segmentation.py +++ b/sopa/cli/segmentation.py @@ -21,9 +21,7 @@ def cellpose( cellprob_threshold: float = typer.Option(-6, help="Cellpose `cellprob_threshold` parameter"), model_type: str = typer.Option("cyto3", help="Name of the cellpose model"), pretrained_model: str = typer.Option(None, help="Path to the pretrained model to be loaded"), - min_area: int = typer.Option( - 0, help="Minimum area (in pixels^2) for a cell to be considered as valid" - ), + min_area: int = typer.Option(0, help="Minimum area (in pixels^2) for a cell to be considered as valid"), clip_limit: float = typer.Option( 0.2, help="Parameter for skimage.exposure.equalize_adapthist (applied before running cellpose)", @@ -96,9 +94,7 @@ def generic_staining( help="Kwargs for the method. This should be a dictionnary, in inline string format.", ), channels: list[str] = typer.Option(help="Names of the channels used for segmentation."), - min_area: int = typer.Option( - 0, help="Minimum area (in pixels^2) for a cell to be considered as valid" - ), + min_area: int = typer.Option(0, help="Minimum area (in pixels^2) for a cell to be considered as valid"), clip_limit: float = typer.Option( 0.2, help="Parameter for skimage.exposure.equalize_adapthist (applied before running the segmentation method)", diff --git a/sopa/io/explorer/converter.py b/sopa/io/explorer/converter.py index 3212c342..c4b385d7 100644 --- a/sopa/io/explorer/converter.py +++ b/sopa/io/explorer/converter.py @@ -8,7 +8,12 @@ from spatialdata import SpatialData from ..._constants import SopaKeys -from ..._sdata import get_boundaries, get_element, get_spatial_image, to_intrinsic +from ..._sdata import ( + get_boundaries, + get_spatial_element, + get_spatial_image, + to_intrinsic, +) from . import ( write_cell_categories, write_gene_counts, @@ -98,7 +103,7 @@ def write( path: Path = Path(path) _check_explorer_directory(path) - image_key, image = get_spatial_image(sdata, image_key, return_key=True) + image_key, _ = get_spatial_image(sdata, key=image_key, return_key=True) ### Saving cell categories and gene counts if SopaKeys.TABLE in sdata.tables: @@ -127,7 +132,9 @@ def write( write_polygons(path, geo_df.geometry, polygon_max_vertices, pixel_size=pixel_size) ### Saving transcripts - df = get_element(sdata, "points", points_key) + df = None + if len(sdata.points): + df = get_spatial_element(sdata.points, key=points_key) if _should_save(mode, "t") and df is not None: if gene_column is not None: diff --git a/sopa/io/explorer/images.py b/sopa/io/explorer/images.py index 92c9ae02..7de0676b 100644 --- a/sopa/io/explorer/images.py +++ b/sopa/io/explorer/images.py @@ -141,9 +141,7 @@ def _set_colors(channel_names: list[str]) -> list[str]: But some channels colors are set to white by default. This functions allows to color these channels with an available wavelength color (e.g., `550`). """ - existing_wavelength = [ - bool(re.search(r"(? list[str]: colors_iterator: list = np.repeat(valid_colors, ceil(n_missing / len(valid_colors))).tolist() return [ - _to_color(c, is_wavelength, colors_iterator) - for c, is_wavelength in zip(channel_names, existing_wavelength) + _to_color(c, is_wavelength, colors_iterator) for c, is_wavelength in zip(channel_names, existing_wavelength) ] def _to_xenium_explorer_multiscale(image: DataArray | DataTree, n_subscales: int) -> DataTree: if isinstance(image, DataTree): - shapes = np.array( - [next(iter(data_tree.values())).shape[1:] for data_tree in image.values()] - ) + shapes = np.array([next(iter(data_tree.values())).shape[1:] for data_tree in image.values()]) if len(shapes) == n_subscales + 1 and (shapes[:-1] // shapes[1:] == 2).all(): return image diff --git a/sopa/io/explorer/shapes.py b/sopa/io/explorer/shapes.py index dcb769e9..7e34e4e9 100644 --- a/sopa/io/explorer/shapes.py +++ b/sopa/io/explorer/shapes.py @@ -17,9 +17,7 @@ TOLERANCE_STEP = 0.5 -def pad_polygon( - polygon: Polygon, max_vertices: int, tolerance: float = TOLERANCE_STEP -) -> np.ndarray: +def pad_polygon(polygon: Polygon, max_vertices: int, tolerance: float = TOLERANCE_STEP) -> np.ndarray: """Transform the polygon to have the desired number of vertices Args: diff --git a/sopa/io/explorer/table.py b/sopa/io/explorer/table.py index 7d69e382..121986ec 100644 --- a/sopa/io/explorer/table.py +++ b/sopa/io/explorer/table.py @@ -14,9 +14,7 @@ log = logging.getLogger(__name__) -def write_gene_counts( - path: str, adata: AnnData, layer: str | None = None, is_dir: bool = True -) -> None: +def write_gene_counts(path: str, adata: AnnData, layer: str | None = None, is_dir: bool = True) -> None: """Write a `cell_feature_matrix.zarr.zip` file containing the cell-by-gene transcript counts (i.e., from `adata.X`) Args: @@ -67,9 +65,7 @@ def write_gene_counts( cells_group.array("indptr", indptr, dtype="uint32", chunks=indptr.shape) -def _write_categorical_column( - root: zarr.Group, index: int, values: np.ndarray, categories: list[str] -) -> None: +def _write_categorical_column(root: zarr.Group, index: int, values: np.ndarray, categories: list[str]) -> None: group = root.create_group(index) values_indices = [np.where(values == cat)[0] for cat in categories] values_cum_len = np.cumsum([len(indices) for indices in values_indices]) diff --git a/sopa/io/explorer/utils.py b/sopa/io/explorer/utils.py index 06e77760..0135988d 100644 --- a/sopa/io/explorer/utils.py +++ b/sopa/io/explorer/utils.py @@ -9,7 +9,7 @@ from spatialdata.models import ShapesModel from spatialdata.transformations import get_transformation -from ..._sdata import get_element +from ..._sdata import get_spatial_element def explorer_file_path(path: str, filename: str, is_dir: bool): @@ -45,9 +45,7 @@ def _selection_to_polygon(df, pixel_size): return Polygon(df[["X", "Y"]].values / pixel_size) -def xenium_explorer_selection( - path: str | Path, pixel_size: float = 0.2125, return_list: bool = False -) -> Polygon: +def xenium_explorer_selection(path: str | Path, pixel_size: float = 0.2125, return_list: bool = False) -> Polygon: df = pd.read_csv(path, skiprows=2) if "Selection" not in df: @@ -74,10 +72,8 @@ def add_explorer_selection( pixel_size: Number of microns in a pixel. It must be the same value as the one used in `sopa.io.write` """ polys = xenium_explorer_selection(path, pixel_size=pixel_size, return_list=True) - image = get_element(sdata, "images", image_key) + image = get_spatial_element(sdata.images, key=image_key) transformations = get_transformation(image, get_all=True).copy() - sdata.shapes[shapes_key] = ShapesModel.parse( - gpd.GeoDataFrame(geometry=polys), transformations=transformations - ) + sdata.shapes[shapes_key] = ShapesModel.parse(gpd.GeoDataFrame(geometry=polys), transformations=transformations) diff --git a/sopa/io/reader/aics.py b/sopa/io/reader/aics.py index 922b00bd..12592c70 100644 --- a/sopa/io/reader/aics.py +++ b/sopa/io/reader/aics.py @@ -38,15 +38,11 @@ def aicsimageio( try: from aicsimageio import AICSImage except ImportError: - raise ImportError( - "You need to install aicsimageio, e.g. by running `pip install aicsimageio`" - ) + raise ImportError("You need to install aicsimageio, e.g. by running `pip install aicsimageio`") xarr: xr.DataArray = AICSImage(path, **aics_kwargs).xarray_dask_data - assert ( - len(xarr.coords["T"]) == 1 - ), f"Only one time dimension is supported, found {len(xarr.coords['T'])}." + assert len(xarr.coords["T"]) == 1, f"Only one time dimension is supported, found {len(xarr.coords['T'])}." if len(xarr.coords["Z"]) > 1: log.info(f"3D image found, only reading {z_stack:=}") diff --git a/sopa/io/reader/cosmx.py b/sopa/io/reader/cosmx.py index a1db9097..25ba9008 100644 --- a/sopa/io/reader/cosmx.py +++ b/sopa/io/reader/cosmx.py @@ -59,8 +59,7 @@ def cosmx( protein_dir_dict = {} if read_proteins: protein_dir_dict = { - int(protein_dir.parent.name[3:]): protein_dir - for protein_dir in list(path.rglob("**/FOV*/ProteinImages")) + int(protein_dir.parent.name[3:]): protein_dir for protein_dir in list(path.rglob("**/FOV*/ProteinImages")) } assert len(protein_dir_dict), f"No directory called 'ProteinImages' was found under {path}" @@ -82,18 +81,12 @@ def cosmx( fov_files = list(images_dir.rglob(pattern)) assert len(fov_files), f"No file matches the pattern {pattern} inside {images_dir}" - assert ( - len(fov_files) == 1 - ), f"Multiple files match the pattern {pattern}: {', '.join(fov_files)}" + assert len(fov_files) == 1, f"Multiple files match the pattern {pattern}: {', '.join(fov_files)}" - image, c_coords = _read_fov_image( - fov_files[0], protein_dir_dict.get(fov), morphology_coords, **imread_kwargs - ) + image, c_coords = _read_fov_image(fov_files[0], protein_dir_dict.get(fov), morphology_coords, **imread_kwargs) image_name = f"{fov}_image" - parsed_image = Image2DModel.parse( - image, dims=("c", "y", "x"), c_coords=c_coords, **image_models_kwargs - ) + parsed_image = Image2DModel.parse(image, dims=("c", "y", "x"), c_coords=c_coords, **image_models_kwargs) if read_proteins: return SpatialData(images={image_name: parsed_image}) @@ -132,9 +125,7 @@ def _infer_dataset_id(path: Path, dataset_id: str | None) -> str: if found: return found.group(1) - raise ValueError( - "Could not infer `dataset_id` from the name of the transcript file. Please specify it manually." - ) + raise ValueError("Could not infer `dataset_id` from the name of the transcript file. Please specify it manually.") def _read_fov_image( @@ -194,9 +185,7 @@ def _read_stitched_image( if image_path.suffix == ".TIF": fov = int(pattern.findall(image_path.name)[0]) - image, c_coords = _read_fov_image( - image_path, protein_dir_dict.get(fov), morphology_coords, **imread_kwargs - ) + image, c_coords = _read_fov_image(image_path, protein_dir_dict.get(fov), morphology_coords, **imread_kwargs) c_coords_dict[fov] = c_coords @@ -212,17 +201,13 @@ def _read_stitched_image( c_coords = list(set.union(*[set(names) for names in c_coords_dict.values()])) - stitched_image = da.zeros( - shape=(len(c_coords), fov_locs["y1"].max(), fov_locs["x1"].max()), dtype=image.dtype - ) + stitched_image = da.zeros(shape=(len(c_coords), fov_locs["y1"].max(), fov_locs["x1"].max()), dtype=image.dtype) stitched_image = xr.DataArray(stitched_image, dims=("c", "y", "x"), coords={"c": c_coords}) for fov, im in fov_images.items(): xmin, xmax = fov_locs.loc[fov, "x0"], fov_locs.loc[fov, "x1"] ymin, ymax = fov_locs.loc[fov, "y0"], fov_locs.loc[fov, "y1"] - stitched_image.loc[ - {"c": c_coords_dict[fov], "y": slice(ymin, ymax), "x": slice(xmin, xmax)} - ] = im + stitched_image.loc[{"c": c_coords_dict[fov], "y": slice(ymin, ymax), "x": slice(xmin, xmax)}] = im if len(c_coords_dict[fov]) < len(c_coords): log.warn(f"Missing channels ({len(c_coords) - len(c_coords_dict[fov])}) for FOV {fov}") diff --git a/sopa/io/reader/hyperion.py b/sopa/io/reader/hyperion.py index bef6ceb3..79aa49ea 100644 --- a/sopa/io/reader/hyperion.py +++ b/sopa/io/reader/hyperion.py @@ -16,9 +16,7 @@ log = logging.getLogger(__name__) -def hyperion( - path: Path, image_models_kwargs: dict | None = None, imread_kwargs: dict | None = None -) -> SpatialData: +def hyperion(path: Path, image_models_kwargs: dict | None = None, imread_kwargs: dict | None = None) -> SpatialData: """Read Hyperion data as a `SpatialData` object Args: diff --git a/sopa/io/reader/macsima.py b/sopa/io/reader/macsima.py index 9229f72c..7378a085 100644 --- a/sopa/io/reader/macsima.py +++ b/sopa/io/reader/macsima.py @@ -25,9 +25,7 @@ def macsima(path: Path, **kwargs: int) -> SpatialData: Returns: A `SpatialData` object with a 2D-image of shape `(C, Y, X)` """ - return _general_tif_directory_reader( - path, files_to_channels=_get_channel_names_macsima, **kwargs - ) + return _general_tif_directory_reader(path, files_to_channels=_get_channel_names_macsima, **kwargs) def _parse_name_macsima(file): diff --git a/sopa/io/reader/utils.py b/sopa/io/reader/utils.py index 13e6675b..f0f1a3a2 100644 --- a/sopa/io/reader/utils.py +++ b/sopa/io/reader/utils.py @@ -97,9 +97,7 @@ def _clip_intensity_values( return ((image / denominator.data.compute()[:, None, None]).clip(0, 1) * 255).astype(np.uint8) -def _image_int_dtype( - image: xr.DataArray, clip_quantile: bool | None = None, quantile: float = 0.99 -) -> xr.DataArray: +def _image_int_dtype(image: xr.DataArray, clip_quantile: bool | None = None, quantile: float = 0.99) -> xr.DataArray: image = image.transpose("c", "y", "x") if np.issubdtype(image.dtype, np.integer): diff --git a/sopa/io/reader/visium_hd.py b/sopa/io/reader/visium_hd.py index 846bd61a..99b5b1e3 100644 --- a/sopa/io/reader/visium_hd.py +++ b/sopa/io/reader/visium_hd.py @@ -6,6 +6,7 @@ from spatialdata import SpatialData from spatialdata_io.readers.visium_hd import visium_hd as visium_hd_spatialdata_io +from ..._constants import SopaAttrs from ...utils import string_channel_names from .utils import _default_image_kwargs @@ -33,7 +34,7 @@ def visium_hd( del image_models_kwargs["scale_factors"] # already set in the spatialdata_io reader - sdata = visium_hd_spatialdata_io( + sdata: SpatialData = visium_hd_spatialdata_io( path, bin_size=bin_size, image_models_kwargs=image_models_kwargs, @@ -43,4 +44,14 @@ def visium_hd( string_channel_names(sdata) # Ensure that channel names are strings + for key, image in sdata.images.items(): + if key.endswith("_full_image"): + image.attrs[SopaAttrs.CELL_SEGMENTATION] = True + elif key.endswith("_hires_image"): + image.attrs[SopaAttrs.TISSUE_SEGMENTATION] = True + + for key, geo_df in sdata.shapes.items(): + if key.endswith("_002um"): + geo_df.attrs[SopaAttrs.BINS_AGGREGATION] = True + return sdata diff --git a/sopa/io/reader/wsi.py b/sopa/io/reader/wsi.py index 0b1ca408..e3723d0a 100644 --- a/sopa/io/reader/wsi.py +++ b/sopa/io/reader/wsi.py @@ -111,9 +111,7 @@ def _default_image_models_kwargs(image_models_kwargs: dict | None) -> dict: return image_models_kwargs -def _open_wsi( - path: str | Path, backend: str = "openslide" -) -> tuple[str, xarray.Dataset, Any, dict]: +def _open_wsi(path: str | Path, backend: str = "openslide") -> tuple[str, xarray.Dataset, Any, dict]: image_name = Path(path).stem if backend == "tiffslide": diff --git a/sopa/io/reader/xenium.py b/sopa/io/reader/xenium.py index 28b02efc..167766a8 100644 --- a/sopa/io/reader/xenium.py +++ b/sopa/io/reader/xenium.py @@ -6,6 +6,7 @@ from spatialdata import SpatialData from spatialdata_io.readers.xenium import xenium as xenium_spatialdata_io +from ..._constants import SopaAttrs from ...utils import string_channel_names from .utils import _default_image_kwargs @@ -36,7 +37,7 @@ def xenium( """ image_models_kwargs, imread_kwargs = _default_image_kwargs(image_models_kwargs, imread_kwargs) - sdata = xenium_spatialdata_io( + sdata: SpatialData = xenium_spatialdata_io( path, cells_table=False, aligned_images=False, @@ -53,4 +54,8 @@ def xenium( string_channel_names(sdata) # Ensure that channel names are strings + for key, image in sdata.images.items(): + if key.startswith("morphology"): + image.attrs[SopaAttrs.CELL_SEGMENTATION] = True + return sdata diff --git a/sopa/io/report/engine.py b/sopa/io/report/engine.py index 993337e5..d2587bc0 100644 --- a/sopa/io/report/engine.py +++ b/sopa/io/report/engine.py @@ -165,10 +165,7 @@ def __init__(self, section: Section) -> None: self.section = section def subsections(self): - li = [ - f"
  • {subsection.name}
    • " - for subsection in self.section.children - ] + li = [f"
  • {subsection.name}
    • " for subsection in self.section.children] return "".join(li) def __str__(self) -> str: @@ -212,9 +209,7 @@ def __str__(self) -> str: class Image(Renderable): """Image renderer""" - def __init__( - self, fig: Figure, width: float = 50, extension: str = "png", pretty_legend: bool = True - ): + def __init__(self, fig: Figure, width: float = 50, extension: str = "png", pretty_legend: bool = True): self.fig = fig self.width = width self.extension = extension @@ -222,9 +217,7 @@ def __init__( def make_figure_pretty(self): if self.pretty_legend and _has_handles(self.fig): - self.fig.legend( - bbox_to_anchor=(1.04, 0.5), loc="center left", borderaxespad=0, frameon=False - ) + self.fig.legend(bbox_to_anchor=(1.04, 0.5), loc="center left", borderaxespad=0, frameon=False) sns.despine(fig=self.fig, offset=10, trim=True) def encod(self): @@ -235,7 +228,9 @@ def encod(self): return base64.b64encode(tmpfile.getvalue()).decode("utf-8") def __str__(self) -> str: - return f"""""" + return ( + f"""""" + ) def _has_handles(fig: Figure) -> bool: diff --git a/sopa/io/report/generate.py b/sopa/io/report/generate.py index 5d78c431..ecca7d18 100644 --- a/sopa/io/report/generate.py +++ b/sopa/io/report/generate.py @@ -120,9 +120,7 @@ def channel_section(self): subsections = [ SubSection( "Names", - Paragraph( - f"Channels names:
    {Message(', '.join(map(str, list(image.coords['c'].values))))}" - ), + Paragraph(f"Channels names:
    {Message(', '.join(map(str, list(image.coords['c'].values))))}"), ) ] @@ -166,9 +164,7 @@ def transcripts_section(self): f"{low_average.sum()} genes have a low count (less than {LOW_AVERAGE_COUNT} per cell, on average):" ) ) - QC_subsubsections.append( - Message(", ".join(self.adata.var_names[low_average]), color="danger") - ) + QC_subsubsections.append(Message(", ".join(self.adata.var_names[low_average]), color="danger")) fig1 = plt.figure() _kdeplot_vmax_quantile(mean_transcript_count) diff --git a/sopa/io/standardize.py b/sopa/io/standardize.py index ac3c0aa1..74d182c7 100644 --- a/sopa/io/standardize.py +++ b/sopa/io/standardize.py @@ -14,22 +14,13 @@ def sanity_check(sdata: SpatialData, delete_table: bool = False, warn: bool = False): + assert len(sdata.images) > 0, "The spatialdata object has no image. Sopa is not designed for this." + + image = get_spatial_image(sdata) assert ( - len(sdata.images) > 0 - ), "The spatialdata object has no image. Sopa is not designed for this." - - if len(sdata.images) != 1: - message = f"The spatialdata object has {len(sdata.images)} images. We advise to run sopa on one image (which can have multiple channels and multiple scales)" - if warn: - log.warn(message) - else: - raise ValueError(message) - else: - image = get_spatial_image(sdata) - assert ( - image.dims == VALID_DIMENSIONS - ), f"Image must have the following three dimensions: {VALID_DIMENSIONS}. Found {image.dims}" - _check_integer_dtype(image.dtype) + image.dims == VALID_DIMENSIONS + ), f"Image must have the following three dimensions: {VALID_DIMENSIONS}. Found {image.dims}" + _check_integer_dtype(image.dtype) if len(sdata.points) > 1: log.warn( @@ -73,9 +64,6 @@ def write_standardized(sdata: SpatialData, sdata_path: str, delete_table: bool = SopaKeys.TABLE not in sdata.tables ), f"sdata.tables['{SopaKeys.TABLE}'] exists. Delete it you want to use sopa, to avoid conflicts with future table generation" - if len(sdata.points) == 0: - log.warn("No transcripts found. Some tools from sopa will not be available.") - log.info(f"Writing the following spatialdata object to {sdata_path}:\n{sdata}") sdata_path: Path = Path(sdata_path) diff --git a/sopa/patches/cluster.py b/sopa/patches/cluster.py index 763d6c64..765bdf92 100644 --- a/sopa/patches/cluster.py +++ b/sopa/patches/cluster.py @@ -48,9 +48,7 @@ def cluster_embeddings( element = sdata.images[element] if isinstance(method, str): - assert ( - method in METHODS_DICT - ), f"Method {method} is not available. Use one of: {', '.join(METHODS_DICT.keys())}" + assert method in METHODS_DICT, f"Method {method} is not available. Use one of: {', '.join(METHODS_DICT.keys())}" method = METHODS_DICT[method] gdf_patches = sdata[SopaKeys.PATCHES_INFERENCE_KEY] diff --git a/sopa/patches/infer.py b/sopa/patches/infer.py index 48c481f7..e2e46b8d 100644 --- a/sopa/patches/infer.py +++ b/sopa/patches/infer.py @@ -19,16 +19,14 @@ from xarray import DataArray from .._constants import SopaKeys -from .._sdata import get_intrinsic_cs, get_key +from .._sdata import get_intrinsic_cs, get_spatial_image from ..segmentation import Patches2D from . import models log = logging.getLogger(__name__) -def _get_best_level_for_downsample( - level_downsamples: list[float], downsample: float, epsilon: float = 0.01 -) -> int: +def _get_best_level_for_downsample(level_downsamples: list[float], downsample: float, epsilon: float = 0.01) -> int: """Return the best level for a given downsampling factor""" if downsample <= 1.0: return 0 @@ -122,14 +120,12 @@ def _get_extraction_parameters(self): return slide_metadata = self.image.attrs.get("metadata", {}) - self.level, self.resize_factor, self.patch_width_scale0, self.downsample, success = ( - _get_extraction_parameters( - slide_metadata, - self.patch_width, - self.level, - self.magnification, - backend=self.image.attrs.get("backend"), - ) + self.level, self.resize_factor, self.patch_width_scale0, self.downsample, success = _get_extraction_parameters( + slide_metadata, + self.patch_width, + self.level, + self.magnification, + backend=self.image.attrs.get("backend"), ) if not success: log.error("Error retrieving the image mpp, skipping tile embedding.") @@ -157,9 +153,7 @@ def _numpy_patch( def _torch_batch(self, bboxes: np.ndarray): """Retrives a batch of patches using the bboxes""" - extraction_patch_width = int( - np.round(self.patch_width_scale0 / self.downsample / self.resize_factor) - ) + extraction_patch_width = int(np.round(self.patch_width_scale0 / self.downsample / self.resize_factor)) batch = np.array([self._numpy_patch(box, extraction_patch_width) for box in bboxes]) batch = torch.tensor(batch, dtype=torch.float32) / 255.0 @@ -210,13 +204,11 @@ def infer_wsi_patches( Returns: If the processing was successful, returns the `DataArray` of shape `(C,Y,X)` containing the model predictions, else `False` """ - image_key = get_key(sdata, "images", image_key) + image_key, _ = get_spatial_image(sdata, key=image_key, return_key=True) image = sdata.images[image_key] infer = Inference(image, model, patch_width, level, magnification, device) - patches = Patches2D( - sdata, image_key, infer.patch_width_scale0, infer.downsample * patch_overlap - ) + patches = Patches2D(sdata, image_key, infer.patch_width_scale0, infer.downsample * patch_overlap) log.info(f"Processing {len(patches)} patches extracted from level {infer.level}") diff --git a/sopa/patches/models/resnet.py b/sopa/patches/models/resnet.py index 01e109f2..f31a515b 100644 --- a/sopa/patches/models/resnet.py +++ b/sopa/patches/models/resnet.py @@ -22,9 +22,7 @@ def __init__(self): nn.Flatten(start_dim=1), ) - self.t = transforms.Compose( - [transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))] - ) + self.t = transforms.Compose([transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))]) def __call__(self, x): x = self.features(self.t(x)) diff --git a/sopa/patches/patches.py b/sopa/patches/patches.py index a3ef0f38..8fe245ca 100644 --- a/sopa/patches/patches.py +++ b/sopa/patches/patches.py @@ -18,7 +18,12 @@ from xarray import DataArray from .._constants import EPS, ROI, SopaFiles, SopaKeys -from .._sdata import get_boundaries, get_item, get_spatial_image, to_intrinsic +from .._sdata import ( + get_boundaries, + get_spatial_element, + get_spatial_image, + to_intrinsic, +) dask.config.set({"dataframe.query-planning": False}) import dask.dataframe as dd # noqa @@ -203,9 +208,7 @@ def write(self, overwrite: bool = True, shapes_key: str | None = None) -> gpd.Ge SopaKeys.PATCHES_ILOCS: self.ilocs.tolist(), } ) - geo_df = ShapesModel.parse( - geo_df, transformations=get_transformation(self.element, get_all=True).copy() - ) + geo_df = ShapesModel.parse(geo_df, transformations=get_transformation(self.element, get_all=True).copy()) self.sdata.shapes[shapes_key] = geo_df if self.sdata.is_backed(): @@ -250,9 +253,9 @@ def patchify_transcripts( Returns: A list of patches indices. Each index correspond to the name of a subdirectory inside `temp_dir` """ - return TranscriptPatches( - self, self.element, config_name, csv_name, min_transcripts_per_patch - ).write(temp_dir, cell_key, unassigned_value, use_prior, config, config_path, shapes_key) + return TranscriptPatches(self, self.element, config_name, csv_name, min_transcripts_per_patch).write( + temp_dir, cell_key, unassigned_value, use_prior, config, config_path, shapes_key + ) def patchify_centroids( self, @@ -316,9 +319,7 @@ def write( if use_prior: prior_boundaries = self.sdata[shapes_key] - _map_transcript_to_cell( - self.sdata, SopaKeys.DEFAULT_CELL_KEY, self.df, prior_boundaries - ) + _map_transcript_to_cell(self.sdata, SopaKeys.DEFAULT_CELL_KEY, self.df, prior_boundaries) self._setup_patches_directory() @@ -326,9 +327,7 @@ def write( if isinstance(self.df, dd.DataFrame): with ProgressBar(): - self.df.map_partitions( - partial(self._query_points_partition, patches_gdf), meta=() - ).compute() + self.df.map_partitions(partial(self._query_points_partition, patches_gdf), meta=()).compute() else: self._write_points(patches_gdf, self.df) @@ -362,9 +361,7 @@ def valid_indices(self): f"Patch {index} has < {self.min_transcripts_per_patch} transcripts. Segmentation will not be run on this patch." ) - def _query_points_partition( - self, patches_gdf: gpd.GeoDataFrame, df: pd.DataFrame - ) -> pd.DataFrame: + def _query_points_partition(self, patches_gdf: gpd.GeoDataFrame, df: pd.DataFrame) -> pd.DataFrame: points_gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df["x"], df["y"])) self._write_points(patches_gdf, points_gdf, mode="a") @@ -390,9 +387,7 @@ def _check_min_lines(path: str, n: int) -> bool: def _get_cell_id(gdf: gpd.GeoDataFrame, partition: pd.DataFrame, na_cells: int = 0) -> pd.Series: - points_gdf = gpd.GeoDataFrame( - partition, geometry=gpd.points_from_xy(partition["x"], partition["y"]) - ) + points_gdf = gpd.GeoDataFrame(partition, geometry=gpd.points_from_xy(partition["x"], partition["y"])) gdf.index.name = "index_right" # to reuse the index name later spatial_join = points_gdf.sjoin(gdf, how="left") spatial_join = spatial_join[~spatial_join.index.duplicated(keep="first")] @@ -408,7 +403,7 @@ def _map_transcript_to_cell( geo_df: gpd.GeoDataFrame | None = None, ): if df is None: - df = get_item(sdata, "points") + df = get_spatial_element(sdata.points) if geo_df is None: geo_df = get_boundaries(sdata) @@ -430,9 +425,7 @@ def _assign_prior(series: dd.Series, unassigned_value: int | str | None) -> pd.S series = series.cat.as_known() categories = series.cat.categories - assert ( - unassigned_value in categories - ), f"Unassigned value {unassigned_value} not in categories" + assert unassigned_value in categories, f"Unassigned value {unassigned_value} not in categories" categories = categories.delete(categories.get_loc(unassigned_value)) categories = pd.Index([unassigned_value]).append(categories) diff --git a/sopa/segmentation/__init__.py b/sopa/segmentation/__init__.py index 6af4f433..5b55fb9a 100644 --- a/sopa/segmentation/__init__.py +++ b/sopa/segmentation/__init__.py @@ -2,3 +2,4 @@ from ..patches import Patches2D from .aggregate import Aggregator, overlay_segmentation from .stainings import StainingSegmentation +from .tissue import tissue_segmentation diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index 13631e4a..fdfebedd 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -22,8 +22,7 @@ from .._constants import SopaKeys from .._sdata import ( get_boundaries, - get_element, - get_item, + get_spatial_element, get_spatial_image, to_intrinsic, ) @@ -126,9 +125,7 @@ def overlay_segmentation( instance_key = old_table.uns["spatialdata_attrs"]["instance_key"] if isinstance(old_shapes_key, list): - assert ( - len(old_shapes_key) == 1 - ), "Can't overlap segmentation on multi-region SpatialData object" + assert len(old_shapes_key) == 1, "Can't overlap segmentation on multi-region SpatialData object" old_shapes_key = old_shapes_key[0] old_geo_df = self.sdata[old_shapes_key] @@ -143,14 +140,10 @@ def overlay_segmentation( table_crop = old_table[~np.isin(old_table.obs[instance_key], gdf_join.index)].copy() table_crop.obs[SopaKeys.CELL_OVERLAY_KEY] = False - self.compute_table( - gene_column=gene_column, average_intensities=average_intensities, save_table=False - ) + self.compute_table(gene_column=gene_column, average_intensities=average_intensities, save_table=False) self.table.obs[SopaKeys.CELL_OVERLAY_KEY] = True - self.table = anndata.concat( - [table_crop, self.table], uns_merge="first", join="outer", fill_value=0 - ) + self.table = anndata.concat([table_crop, self.table], uns_merge="first", join="outer", fill_value=0) _fillna(self.table.obs) self.shapes_key = f"{old_shapes_key}+{self.shapes_key}" @@ -169,15 +162,9 @@ def standardized_table(self, save_table: bool = True): self.sdata.delete_element_from_disk(self.shapes_key) self.sdata.write_element(self.shapes_key) - self.table.obsm["spatial"] = np.array( - [[centroid.x, centroid.y] for centroid in self.geo_df.centroid] - ) - self.table.obs[SopaKeys.REGION_KEY] = pd.Series( - self.shapes_key, index=self.table.obs_names, dtype="category" - ) - self.table.obs[SopaKeys.SLIDE_KEY] = pd.Series( - self.image_key, index=self.table.obs_names, dtype="category" - ) + self.table.obsm["spatial"] = np.array([[centroid.x, centroid.y] for centroid in self.geo_df.centroid]) + self.table.obs[SopaKeys.REGION_KEY] = pd.Series(self.shapes_key, index=self.table.obs_names, dtype="category") + self.table.obs[SopaKeys.SLIDE_KEY] = pd.Series(self.image_key, index=self.table.obs_names, dtype="category") self.table.obs[SopaKeys.INSTANCE_KEY] = self.geo_df.index self.table.obs[SopaKeys.AREA_OBS] = self.geo_df.area.values @@ -232,9 +219,7 @@ def compute_table( min_intensity_ratio: Cells whose mean channel intensity is less than `min_intensity_ratio * quantile_90` will be filtered save_table: Whether the table should be saved on disk or not """ - does_count = ( - self.table is not None and isinstance(self.table.X, csr_matrix) - ) or gene_column is not None + does_count = (self.table is not None and isinstance(self.table.X, csr_matrix)) or gene_column is not None assert ( average_intensities or does_count @@ -329,19 +314,15 @@ def average_channels( """ image = get_spatial_image(sdata, image_key) - geo_df = get_element(sdata, "shapes", shapes_key) + geo_df = get_spatial_element(sdata.shapes, key=shapes_key) geo_df = to_intrinsic(sdata, geo_df, image) geo_df = expand_radius(geo_df, expand_radius_ratio) - log.info( - f"Averaging channels intensity over {len(geo_df)} cells with expansion {expand_radius}" - ) + log.info(f"Averaging channels intensity over {len(geo_df)} cells with expansion {expand_radius}") return _average_channels_aligned(image, geo_df) -def _average_channels_aligned( - image: DataArray, geo_df: gpd.GeoDataFrame | list[Polygon] -) -> np.ndarray: +def _average_channels_aligned(image: DataArray, geo_df: gpd.GeoDataFrame | list[Polygon]) -> np.ndarray: """Average channel intensities per cell. The image and cells have to be aligned, i.e. be on the same coordinate system. Args: @@ -416,19 +397,17 @@ def count_transcripts( Returns: An `AnnData` object of shape `(n_cells, n_genes)` with the counts per cell """ - points_key, points = get_item(sdata, "points", points_key) + points_key, points = get_spatial_element(sdata.points, key=points_key) if geo_df is None: - geo_df = get_element(sdata, "shapes", shapes_key) + geo_df = get_spatial_element(sdata.shapes, key=shapes_key) geo_df = to_intrinsic(sdata, geo_df, points_key) log.info(f"Aggregating transcripts over {len(geo_df)} cells") return _count_transcripts_aligned(geo_df, points, gene_column) -def _count_transcripts_aligned( - geo_df: gpd.GeoDataFrame, points: dd.DataFrame, value_key: str -) -> AnnData: +def _count_transcripts_aligned(geo_df: gpd.GeoDataFrame, points: dd.DataFrame, value_key: str) -> AnnData: """Count transcripts per cell. The cells and points have to be aligned (i.e., in the same coordinate system) Args: @@ -470,9 +449,7 @@ def _add_coo( gene_column: list[str], gene_names: list[str], ) -> None: - points_gdf = gpd.GeoDataFrame( - partition, geometry=gpd.points_from_xy(partition["x"], partition["y"]) - ) + points_gdf = gpd.GeoDataFrame(partition, geometry=gpd.points_from_xy(partition["x"], partition["y"])) joined = geo_df.sjoin(points_gdf) cells_indices, column_indices = joined.index, joined[gene_column].cat.codes diff --git a/sopa/segmentation/shapes.py b/sopa/segmentation/shapes.py index 08abb2e1..75b48617 100644 --- a/sopa/segmentation/shapes.py +++ b/sopa/segmentation/shapes.py @@ -76,9 +76,7 @@ def _contours(cell_mask: np.ndarray) -> MultiPolygon: import cv2 contours, _ = cv2.findContours(cell_mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) - return MultiPolygon( - [Polygon(contour[:, 0, :]) for contour in contours if contour.shape[0] >= 4] - ) + return MultiPolygon([Polygon(contour[:, 0, :]) for contour in contours if contour.shape[0] >= 4]) def _ensure_polygon(cell: Polygon | MultiPolygon | GeometryCollection) -> Polygon: @@ -138,9 +136,7 @@ def _default_tolerance(mean_radius: float) -> float: return 2 -def geometrize( - mask: np.ndarray, tolerance: float | None = None, smooth_radius_ratio: float = 0.1 -) -> list[Polygon]: +def geometrize(mask: np.ndarray, tolerance: float | None = None, smooth_radius_ratio: float = 0.1) -> list[Polygon]: """Convert a cells mask to multiple `shapely` geometries. Inspired from https://github.com/Vizgen/vizgen-postprocessing Args: @@ -178,9 +174,7 @@ def pixel_outer_bounds(bounds: tuple[int, int, int, int]) -> tuple[int, int, int return [floor(bounds[0]), floor(bounds[1]), ceil(bounds[2]) + 1, ceil(bounds[3]) + 1] -def rasterize( - cell: Polygon | MultiPolygon, shape: tuple[int, int], xy_min: tuple[int, int] = [0, 0] -) -> np.ndarray: +def rasterize(cell: Polygon | MultiPolygon, shape: tuple[int, int], xy_min: tuple[int, int] = [0, 0]) -> np.ndarray: """Transform a cell polygon into a numpy array with value 1 where the polygon touches a pixel, else 0. Args: @@ -196,9 +190,7 @@ def rasterize( xmin, ymin, xmax, ymax = [xy_min[0], xy_min[1], xy_min[0] + shape[1], xy_min[1] + shape[0]] cell_translated = shapely.affinity.translate(cell, -xmin, -ymin) - geoms = ( - cell_translated.geoms if isinstance(cell_translated, MultiPolygon) else [cell_translated] - ) + geoms = cell_translated.geoms if isinstance(cell_translated, MultiPolygon) else [cell_translated] rasterized_image = np.zeros((ymax - ymin, xmax - xmin), dtype=np.int8) diff --git a/sopa/segmentation/stainings.py b/sopa/segmentation/stainings.py index 6a70bea2..bc9989c7 100644 --- a/sopa/segmentation/stainings.py +++ b/sopa/segmentation/stainings.py @@ -195,9 +195,7 @@ def add_shapes(cls, sdata: SpatialData, cells: list[Polygon], image_key: str, sh geo_df = gpd.GeoDataFrame({"geometry": cells}) geo_df.index = image_key + geo_df.index.astype(str) - geo_df = ShapesModel.parse( - geo_df, transformations=get_transformation(image, get_all=True).copy() - ) + geo_df = ShapesModel.parse(geo_df, transformations=get_transformation(image, get_all=True).copy()) sdata.shapes[shapes_key] = geo_df if sdata.is_backed(): diff --git a/sopa/segmentation/tissue.py b/sopa/segmentation/tissue.py index 0f4f3fd3..6043c970 100644 --- a/sopa/segmentation/tissue.py +++ b/sopa/segmentation/tissue.py @@ -1,23 +1,33 @@ from __future__ import annotations import logging +import warnings import geopandas as gpd import numpy as np import spatialdata -import xarray as xr from datatree import DataTree from shapely.geometry import Polygon from spatialdata import SpatialData from spatialdata.models import ShapesModel +from xarray import DataArray -from .._constants import ROI -from .._sdata import get_intrinsic_cs, get_item +from .._constants import ROI, SopaAttrs +from .._sdata import get_intrinsic_cs, get_spatial_element log = logging.getLogger(__name__) -def hsv_otsu( +def hsv_otsu(*args, **kwargs): + warnings.warn( + "This function is deprecated and will be removed in late 2024. Use `sopa.tissue_segmentation` instead.", + DeprecationWarning, + stacklevel=2, + ) + tissue_segmentation(*args, **kwargs) + + +def tissue_segmentation( sdata: SpatialData, image_key: str | None = None, level: int = -1, @@ -26,7 +36,7 @@ def hsv_otsu( close_k: int = 5, drop_threshold: int = 0.01, ) -> bool: - """Perform WSI tissue segmentation. The resulting ROIs are saved as shapes. + """Perform WSI tissue segmentation. The resulting regions-of-interests (ROI) are saved as shapes. !!! info This segmentation method first transforms the image from RBG color space to HSV and then @@ -40,7 +50,7 @@ def hsv_otsu( Args: sdata: A `SpatialData` object representing an H&E image image_key: Optional key of the H&E image - level: Level of the multiscale image on which the segmentation will be performed + level: Level of the multiscale image on which the segmentation will be performed (if the image is a `DataTree`) blur_k: The kernel size of the median bluring operation open_k: The kernel size of the morphological openning operation close_k: The kernel size of the morphological closing operation @@ -49,26 +59,51 @@ def hsv_otsu( Returns: `True` if tissue segmentation was successful, else `False` if no polygon was output. """ - import cv2 - - image_key, image = get_item(sdata, "images", image_key) + assert ( + ROI.KEY not in sdata.shapes + ), f"sdata['{ROI.KEY}'] was already existing, but tissue segmentation is run on top. Delete the shape(s) first." - if level == 0 or not isinstance(image, DataTree): - log.warn("Running hsv_otsu on the full image can be slow. We recommend using a DataTree") + image_key, image = get_spatial_element( + sdata.images, + key=image_key, + valid_attr=SopaAttrs.TISSUE_SEGMENTATION, + return_key=True, + ) if isinstance(image, DataTree): level_keys = list(image.keys()) - image: xr.DataArray = next(iter(image[level_keys[level]].values())) + image: DataArray = next(iter(image[level_keys[level]].values())) + + polygons = _get_polygons(image, blur_k, open_k, close_k, drop_threshold) + + if not len(polygons): + log.warn( + "No polygon has been found after tissue segmentation. Check that there is some tissue in the image, or consider updating the segmentation parameters." + ) + return False + + _save_tissue_segmentation(sdata, polygons, image_key, image) + return True + + +def _get_polygons(image: DataArray, blur_k: int, open_k: int, close_k: int, drop_threshold: int) -> list[Polygon]: + import cv2 thumbnail = np.array(image.transpose("y", "x", "c")) + + assert thumbnail.shape[2] == 3, "The image should be in RGB color space" + + if thumbnail.shape[0] * thumbnail.shape[1] > 1e8: + log.warning( + "Tissue segmentation is computationally expensive for large images. Consider using a smaller image, or set the `level` parameter." + ) + thumbnail_hsv = cv2.cvtColor(thumbnail, cv2.COLOR_RGB2HSV) thumbnail_hsv_blurred = cv2.medianBlur(thumbnail_hsv[:, :, 1], blur_k) _, mask = cv2.threshold(thumbnail_hsv_blurred, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY) mask_open = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((open_k, open_k), np.uint8)) - mask_open_close = cv2.morphologyEx( - mask_open, cv2.MORPH_CLOSE, np.ones((close_k, close_k), np.uint8) - ) + mask_open_close = cv2.morphologyEx(mask_open, cv2.MORPH_CLOSE, np.ones((close_k, close_k), np.uint8)) num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(mask_open_close, 4, cv2.CV_32S) @@ -79,29 +114,16 @@ def hsv_otsu( np.array(labels == i, dtype="uint8"), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE, - )[0][0] + )[ + 0 + ][0] c_closed = np.array(list(cc) + [cc[0]]) contours.extend([c_closed.squeeze()]) - polygons = [Polygon(contour) for contour in contours] - - if not len(polygons): - log.warn( - "No polygon has been found after tissue segmentation. Check that there is some tissue in the image, or consider updating the segmentation parameters." - ) - return False - - _save_tissue_segmentation(sdata, polygons, image_key, image) - return True - + return [Polygon(contour) for contour in contours] -def _save_tissue_segmentation( - sdata: SpatialData, polygons: list[Polygon], image_key: str, image_scale: xr.DataArray -): - assert ( - ROI.KEY not in sdata.shapes - ), f"sdata['{ROI.KEY}'] was already existing, but tissue segmentation is run on top. Delete the shape(s) first." +def _save_tissue_segmentation(sdata: SpatialData, polygons: list[Polygon], image_key: str, image_scale: DataArray): geo_df = gpd.GeoDataFrame(geometry=polygons) geo_df = ShapesModel.parse( geo_df, @@ -109,10 +131,10 @@ def _save_tissue_segmentation( ) image_cs = get_intrinsic_cs(sdata, sdata[image_key]) - geo_df = spatialdata.transform( - geo_df, image_scale.attrs["transform"][image_cs], maintain_positioning=True - ) + geo_df = spatialdata.transform(geo_df, image_scale.attrs["transform"][image_cs], maintain_positioning=True) sdata.shapes[ROI.KEY] = geo_df + if sdata.is_backed(): + sdata.write_element(ROI.KEY, overwrite=True) - log.info(f"Tissue segmentation saved in sdata['{ROI.KEY}']") + log.info(f"Tissue segmentation added in sdata['{ROI.KEY}']") diff --git a/sopa/segmentation/transcripts.py b/sopa/segmentation/transcripts.py index 4bee516e..0dc43d09 100644 --- a/sopa/segmentation/transcripts.py +++ b/sopa/segmentation/transcripts.py @@ -16,7 +16,7 @@ from tqdm import tqdm from .._constants import SopaKeys -from .._sdata import get_element, get_key +from .._sdata import get_spatial_element, get_spatial_image from . import aggregate, shapes log = logging.getLogger(__name__) @@ -45,8 +45,8 @@ def resolve( patches_cells, adatas = _read_all_segmented_patches(temp_dir, min_area, patches_dirs) geo_df, cells_indices, new_ids = _resolve_patches(patches_cells, adatas) - image_key = get_key(sdata, "images") - points = get_element(sdata, "points") + image_key, _ = get_spatial_image(sdata, return_key=True) + points = get_spatial_element(sdata.points) transformations = get_transformation(points, get_all=True).copy() geo_df = ShapesModel.parse(geo_df, transformations=transformations) @@ -90,9 +90,7 @@ def resolve( sdata.write_element(shapes_key, overwrite=True) sdata.write_element(SopaKeys.TABLE, overwrite=True) - log.info( - f"Added sdata.tables['{SopaKeys.TABLE}'], and {len(geo_df)} cell boundaries to sdata['{shapes_key}']" - ) + log.info(f"Added sdata.tables['{SopaKeys.TABLE}'], and {len(geo_df)} cell boundaries to sdata['{shapes_key}']") def _read_one_segmented_patch( @@ -102,9 +100,7 @@ def _read_one_segmented_patch( loom_file = directory / "segmentation_counts.loom" if loom_file.exists(): - adata = anndata.read_loom( - directory / "segmentation_counts.loom", obs_names="Name", var_names="Name" - ) + adata = anndata.read_loom(directory / "segmentation_counts.loom", obs_names="Name", var_names="Name") else: adata = anndata.read_h5ad(directory / "segmentation_counts.h5ad") @@ -117,13 +113,9 @@ def _read_one_segmented_patch( polygons_dict = json.load(f) polygons_dict = {c["cell"]: c for c in polygons_dict["geometries"]} - cells_num = cells_num[ - cells_num.map(lambda num: len(polygons_dict[num]["coordinates"][0]) >= min_vertices) - ] + cells_num = cells_num[cells_num.map(lambda num: len(polygons_dict[num]["coordinates"][0]) >= min_vertices)] - gdf = gpd.GeoDataFrame( - index=cells_num.index, geometry=[shape(polygons_dict[cell_num]) for cell_num in cells_num] - ) + gdf = gpd.GeoDataFrame(index=cells_num.index, geometry=[shape(polygons_dict[cell_num]) for cell_num in cells_num]) gdf.geometry = gdf.geometry.map(lambda cell: shapes._ensure_polygon(cell)) gdf = gdf[~gdf.geometry.isna()] @@ -173,9 +165,7 @@ def _resolve_patches( cells = [cell for cells in patches_cells for cell in cells] segmentation_ids = np.array([cell_id for ids in patch_ids for cell_id in ids]) - cells_resolved, cells_indices = shapes.solve_conflicts( - cells, patch_indices=patch_indices, return_indices=True - ) + cells_resolved, cells_indices = shapes.solve_conflicts(cells, patch_indices=patch_indices, return_indices=True) existing_ids = segmentation_ids[cells_indices[cells_indices >= 0]] new_ids = np.char.add("merged_cell_", np.arange((cells_indices == -1).sum()).astype(str)) diff --git a/sopa/spatial/_build.py b/sopa/spatial/_build.py index d5d01590..a71a11e0 100644 --- a/sopa/spatial/_build.py +++ b/sopa/spatial/_build.py @@ -44,9 +44,7 @@ def spatial_neighbors( if isinstance(adata, SpatialData): adata = adata.tables[SopaKeys.TABLE] - assert ( - radius is None or len(radius) == 2 - ), "Radius is expected to be a tuple (min_radius, max_radius)" + assert radius is None or len(radius) == 2, "Radius is expected to be a tuple (min_radius, max_radius)" log.info("Computing delaunay graph") diff --git a/sopa/spatial/_graph.py b/sopa/spatial/_graph.py index eab38a2a..2ec45767 100644 --- a/sopa/spatial/_graph.py +++ b/sopa/spatial/_graph.py @@ -88,9 +88,7 @@ def polygon(self) -> Polygon: rings = self.rings index_largest = np.argmax([Polygon(ring).area for ring in rings]) - return Polygon( - rings[index_largest], rings[:index_largest] + rings[index_largest + 1 :] - ).buffer(0) + return Polygon(rings[index_largest], rings[:index_largest] + rings[index_largest + 1 :]).buffer(0) def visit(self, simplices_to_visit: set[int]): visited = set() diff --git a/sopa/spatial/morpho.py b/sopa/spatial/morpho.py index 47cc6e69..cb6ded42 100644 --- a/sopa/spatial/morpho.py +++ b/sopa/spatial/morpho.py @@ -78,9 +78,7 @@ def geometrize_niches( gdf[SopaKeys.GEOMETRY_LENGTH] = gdf.length gdf[SopaKeys.GEOMETRY_AREA] = gdf.area - gdf[SopaKeys.GEOMETRY_ROUNDNESS] = ( - 4 * np.pi * gdf[SopaKeys.GEOMETRY_AREA] / gdf[SopaKeys.GEOMETRY_LENGTH] ** 2 - ) + gdf[SopaKeys.GEOMETRY_ROUNDNESS] = 4 * np.pi * gdf[SopaKeys.GEOMETRY_AREA] / gdf[SopaKeys.GEOMETRY_LENGTH] ** 2 # Remove minor components (compared to the largest component of its corresponding niche) gdf = gdf[gdf.area >= gdf[niche_key].map(gdf.groupby(niche_key).area.max() * perc_area_th)] @@ -88,9 +86,7 @@ def geometrize_niches( return gdf -def _clean_components( - adata: AnnData, gdf: gpd.GeoDataFrame, niche_key: str, buffer: int | str -) -> gpd.GeoDataFrame: +def _clean_components(adata: AnnData, gdf: gpd.GeoDataFrame, niche_key: str, buffer: int | str) -> gpd.GeoDataFrame: data = {"geometry": [], niche_key: []} if buffer == "auto": diff --git a/sopa/spatial/utils.py b/sopa/spatial/utils.py index 349f9cb2..2c714c82 100644 --- a/sopa/spatial/utils.py +++ b/sopa/spatial/utils.py @@ -37,11 +37,7 @@ def sjoin( if target_coordinate_system is None: target_coordinate_system = get_intrinsic_cs(sdata, left_element) - left_element = sdata.transform_element_to_coordinate_system( - left_element, target_coordinate_system - ) - right_element = sdata.transform_element_to_coordinate_system( - right_element, target_coordinate_system - ) + left_element = sdata.transform_element_to_coordinate_system(left_element, target_coordinate_system) + right_element = sdata.transform_element_to_coordinate_system(right_element, target_coordinate_system) return gpd.sjoin(left_element, right_element, how=how, **kwargs) diff --git a/sopa/utils/data.py b/sopa/utils/data.py index 1f04da52..75d4f320 100644 --- a/sopa/utils/data.py +++ b/sopa/utils/data.py @@ -119,9 +119,7 @@ def uniform( where_cell_type = np.where(cell_types_index[point_cell_index] == i)[0] probabilities = np.full(len(genes), 0.2 / (len(genes) - 1)) probabilities[i] = 0.8 - gene_names[where_cell_type] = np.random.choice( - genes, len(where_cell_type), p=probabilities - ) + gene_names[where_cell_type] = np.random.choice(genes, len(where_cell_type), p=probabilities) else: gene_names = np.random.choice(genes, size=n_genes) @@ -144,11 +142,7 @@ def uniform( df = dd.from_pandas(df, chunksize=2_000_000) - points = { - "transcripts": PointsModel.parse( - df, transformations={"global": affine, "microns": Identity()} - ) - } + points = {"transcripts": PointsModel.parse(df, transformations={"global": affine, "microns": Identity()})} if include_vertices: points["vertices"] = PointsModel.parse(vertices) @@ -198,9 +192,7 @@ def blobs( **kwargs, ) -> SpatialData: """Adapts the blobs dataset from SpatialData for sopa. Please refer to the SpatialData documentation""" - _blobs = BlobsDataset( - length=length, n_points=n_points, c_coords=c_coords, n_channels=len(c_coords), **kwargs - ) + _blobs = BlobsDataset(length=length, n_points=n_points, c_coords=c_coords, n_channels=len(c_coords), **kwargs) image = _blobs._image_blobs( _blobs.transformations, diff --git a/sopa/utils/image.py b/sopa/utils/image.py index ded1de14..a6b09934 100644 --- a/sopa/utils/image.py +++ b/sopa/utils/image.py @@ -20,19 +20,12 @@ def resize(xarr: DataArray, scale_factor: float) -> da.Array: """ resize_dims = [dim in ["x", "y"] for dim in xarr.dims] transform = np.diag([scale_factor if resize_dim else 1 for resize_dim in resize_dims]) - output_shape = [ - size // scale_factor if resize_dim else size - for size, resize_dim in zip(xarr.shape, resize_dims) - ] + output_shape = [size // scale_factor if resize_dim else size for size, resize_dim in zip(xarr.shape, resize_dims)] - return dask_image.ndinterp.affine_transform( - xarr.data, matrix=transform, output_shape=output_shape - ) + return dask_image.ndinterp.affine_transform(xarr.data, matrix=transform, output_shape=output_shape) -def resize_numpy( - arr: np.ndarray, scale_factor: float, dims: list[str], output_shape: list[int] -) -> np.ndarray: +def resize_numpy(arr: np.ndarray, scale_factor: float, dims: list[str], output_shape: list[int]) -> np.ndarray: """Resize a numpy image Args: @@ -47,15 +40,11 @@ def resize_numpy( resize_dims = [dim in ["x", "y"] for dim in dims] transform = np.diag([scale_factor if resize_dim else 1 for resize_dim in resize_dims]) - return dask_image.ndinterp.affine_transform( - arr, matrix=transform, output_shape=output_shape - ).compute() + return dask_image.ndinterp.affine_transform(arr, matrix=transform, output_shape=output_shape).compute() def _check_integer_dtype(dtype: np.dtype): - assert np.issubdtype( - dtype, np.integer - ), f"Expecting image to have an intenger dtype, but found {dtype}" + assert np.issubdtype(dtype, np.integer), f"Expecting image to have an intenger dtype, but found {dtype}" def scale_dtype(arr: np.ndarray, dtype: np.dtype) -> np.ndarray: diff --git a/sopa/utils/polygon_crop.py b/sopa/utils/polygon_crop.py index ce19bc33..d11ff45e 100644 --- a/sopa/utils/polygon_crop.py +++ b/sopa/utils/polygon_crop.py @@ -73,9 +73,7 @@ def _draw_polygon(image: np.ndarray, scale_factor: float, margin_ratio: float): return Polygon(selector.vertices * scale_factor) -def intermediate_selection( - intermediate_image: str, intermediate_polygon: str, margin_ratio: float = 0.1 -): +def intermediate_selection(intermediate_image: str, intermediate_polygon: str, margin_ratio: float = 0.1): log.info(f"Reading intermediate image {intermediate_image}") z = zarr.open(intermediate_image, mode="r") @@ -131,9 +129,7 @@ def polygon_selection( geo_df = gpd.GeoDataFrame(geometry=[polygon]) - geo_df = ShapesModel.parse( - geo_df, transformations=get_transformation(sdata[image_key], get_all=True).copy() - ) + geo_df = ShapesModel.parse(geo_df, transformations=get_transformation(sdata[image_key], get_all=True).copy()) sdata.shapes[ROI.KEY] = geo_df if sdata.is_backed(): sdata.write_element(ROI.KEY, overwrite=True) diff --git a/tests/test_aggregation.py b/tests/test_aggregation.py index 1ff4635a..300a2b66 100644 --- a/tests/test_aggregation.py +++ b/tests/test_aggregation.py @@ -25,9 +25,7 @@ def test_average_channels_aligned(): means = aggregate._average_channels_aligned(xarr, cells) - true_means = np.stack( - [image[:, y : y + cell_size, x : x + cell_size].mean(axis=(1, 2)) for x, y in cell_start] - ) + true_means = np.stack([image[:, y : y + cell_size, x : x + cell_size].mean(axis=(1, 2)) for x, y in cell_start]) assert (means == true_means).all() diff --git a/tests/test_patches.py b/tests/test_patches.py index b7e2417e..71bce631 100644 --- a/tests/test_patches.py +++ b/tests/test_patches.py @@ -6,7 +6,7 @@ from shapely.geometry import box from spatialdata import SpatialData -from sopa._sdata import get_key +from sopa._sdata import get_spatial_element from sopa.patches import Patches2D, _get_cell_id from sopa.utils.data import uniform @@ -18,7 +18,7 @@ def sdata() -> SpatialData: def test_patchify_image(sdata: SpatialData): - image_key = get_key(sdata, "images") + image_key, _ = get_spatial_element(sdata.images, return_key=True) patches = Patches2D(sdata, image_key, 300, 100) assert len(patches) == 9 @@ -44,9 +44,7 @@ def test_patchify_baysor(sdata: SpatialData): def test_get_cell_id(): polygons = [box(10, 10, 20, 28), box(15, 18, 25, 22), box(30, 35, 34, 42)] gdf = gpd.GeoDataFrame(geometry=polygons) - df = pd.DataFrame( - {"x": [1.5, 16, 23, 67, 33, 19, 22, 10], "y": [15, 21, 34, 5, 40, 20, 21, 10]} - ) + df = pd.DataFrame({"x": [1.5, 16, 23, 67, 33, 19, 22, 10], "y": [15, 21, 34, 5, 40, 20, 21, 10]}) cell_id = _get_cell_id(gdf, df) diff --git a/tests/test_rasterize_geometries.py b/tests/test_rasterize_geometries.py index 08f6a965..83b7b3d2 100644 --- a/tests/test_rasterize_geometries.py +++ b/tests/test_rasterize_geometries.py @@ -26,9 +26,7 @@ def test_raster_and_geometrize(): new_cell = shapes.geometrize(mask, 0, 0)[0] new_mask = shapes.rasterize(new_cell, image_shape) - assert ( - mask == new_mask - ).all(), "Applying geometrize and then rasterize shouldn't change the mask" + assert (mask == new_mask).all(), "Applying geometrize and then rasterize shouldn't change the mask" def test_rasterize_cropped(): diff --git a/tests/test_spatial_stats.py b/tests/test_spatial_stats.py index 9d4bee04..af3a7eb8 100644 --- a/tests/test_spatial_stats.py +++ b/tests/test_spatial_stats.py @@ -76,9 +76,7 @@ def test_geometrize_niches(adata: AnnData): def test_niches_geometry_stats(adata: AnnData): - df_geometries_stats = niches_geometry_stats( - adata, NICHE_KEY, aggregation=["min", "mean"], buffer=0 - ) + df_geometries_stats = niches_geometry_stats(adata, NICHE_KEY, aggregation=["min", "mean"], buffer=0) expected_a = [0, 1, 1, np.sqrt(18)] * 2 # sqrt(3**2 + 3**2) assert (df_geometries_stats.iloc[0, 4:] == np.array(expected_a)).all() diff --git a/workflow/utils.py b/workflow/utils.py index 2148d92f..dee924e4 100644 --- a/workflow/utils.py +++ b/workflow/utils.py @@ -95,31 +95,21 @@ def cells_paths(self, file_content: str, name, dirs: bool = False): A list of temporary boundary directories or files """ if name == "cellpose": - return [ - str(self.smk_cellpose_temp_dir / f"{i}.parquet") for i in range(int(file_content)) - ] + return [str(self.smk_cellpose_temp_dir / f"{i}.parquet") for i in range(int(file_content))] if name == "baysor": indices = map(int, file_content.split()) BAYSOR_FILES = ["segmentation_polygons.json", "segmentation_counts.loom"] if dirs: return [str(self.smk_baysor_temp_dir / str(i)) for i in indices] - return [ - str(self.smk_baysor_temp_dir / str(i) / file) - for i in indices - for file in BAYSOR_FILES - ] + return [str(self.smk_baysor_temp_dir / str(i) / file) for i in indices for file in BAYSOR_FILES] if name == "comseg": indices = map(int, file_content.split()) COMSEG_FILES = ["segmentation_polygons.json", "segmentation_counts.h5ad"] if dirs: return [str(self.smk_comseg_temp_dir / str(i)) for i in indices] - return [ - str(self.smk_comseg_temp_dir / str(i) / file) - for i in indices - for file in COMSEG_FILES - ] + return [str(self.smk_comseg_temp_dir / str(i) / file) for i in indices for file in COMSEG_FILES] class Args: @@ -150,9 +140,7 @@ def __str__(self) -> str: return self.dump() def dump(self, prefix=""): - return " ".join( - (res for item in self.config.items() for res in self.dump_arg(*item, prefix)) - ) + return " ".join((res for item in self.config.items() for res in self.dump_arg(*item, prefix))) @classmethod def dump_arg(cls, key: str, value, prefix: str = ""): From fd504bfab9064ab540552b277c32907a755eae45 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 18 Aug 2024 12:50:44 +0200 Subject: [PATCH 12/13] add missing return_key=True --- sopa/_constants.py | 8 +++++--- sopa/segmentation/aggregate.py | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/sopa/_constants.py b/sopa/_constants.py index 3a80d0c8..61e07e38 100644 --- a/sopa/_constants.py +++ b/sopa/_constants.py @@ -34,9 +34,11 @@ class SopaKeys: class SopaAttrs: - CELL_SEGMENTATION = "for_cell_segmentation" - TISSUE_SEGMENTATION = "for_tissue_segmentation" - BINS_AGGREGATION = "for_bins_aggregation" + CELL_SEGMENTATION = "cell_segmentation_image" + TISSUE_SEGMENTATION = "tissue_segmentation_image" + BINS_AGGREGATION = "bins_aggregation_shapes" + BINS_TABLE = "bins_table" + TRANSCRIPTS = "transcripts_dataframe" GENE_COLUMN = "feature_key" diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregate.py index fdfebedd..4d47354d 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregate.py @@ -397,7 +397,7 @@ def count_transcripts( Returns: An `AnnData` object of shape `(n_cells, n_genes)` with the counts per cell """ - points_key, points = get_spatial_element(sdata.points, key=points_key) + points_key, points = get_spatial_element(sdata.points, key=points_key, return_key=True) if geo_df is None: geo_df = get_spatial_element(sdata.shapes, key=shapes_key) From cd12b4784c7fb4ea666e33ddfefb74784a949552 Mon Sep 17 00:00:00 2001 From: Blampey Quentin Date: Sun, 18 Aug 2024 14:33:34 +0200 Subject: [PATCH 13/13] formatting + minor display fix in tutorials --- docs/tutorials/api_usage.ipynb | 155 +++++++++++------- docs/tutorials/comseg.ipynb | 2 +- docs/tutorials/xenium_explorer/explorer.ipynb | 6 +- sopa/cli/app.py | 2 +- sopa/segmentation/__init__.py | 4 +- .../{aggregate.py => aggregation.py} | 24 ++- sopa/segmentation/transcripts.py | 4 +- sopa/utils/data.py | 2 +- tests/test_aggregation.py | 6 +- 9 files changed, 125 insertions(+), 80 deletions(-) rename sopa/segmentation/{aggregate.py => aggregation.py} (96%) diff --git a/docs/tutorials/api_usage.ipynb b/docs/tutorials/api_usage.ipynb index e9ddbacc..2dd0fc1c 100644 --- a/docs/tutorials/api_usage.ipynb +++ b/docs/tutorials/api_usage.ipynb @@ -7,15 +7,14 @@ "outputs": [], "source": [ "import spatialdata\n", - "import sopa.segmentation\n", - "import sopa.io" + "import sopa" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Create a `SpatialData` object\n", + "## Create a SpatialData object\n", "\n", "For this tutorial, we use a generated dataset. You can expect a total runtime of a few minutes.\n", "\n", @@ -37,17 +36,17 @@ { "data": { "text/plain": [ - "SpatialData object with:\n", + "SpatialData object\n", "├── Images\n", - "│ └── 'image': SpatialImage[cyx] (4, 2048, 2048)\n", + "│ └── 'image': DataArray[cyx] (4, 2048, 2048)\n", "├── Points\n", - "│ └── 'transcripts': DataFrame with shape: (, 4) (3D points)\n", + "│ └── 'transcripts': DataFrame with shape: (, 5) (3D points)\n", "└── Shapes\n", " └── 'cells': GeoDataFrame shape: (400, 1) (2D shapes)\n", "with coordinate systems:\n", - "▸ 'global', with elements:\n", + " ▸ 'global', with elements:\n", " image (Images), transcripts (Points), cells (Shapes)\n", - "▸ 'microns', with elements:\n", + " ▸ 'microns', with elements:\n", " transcripts (Points)" ] }, @@ -106,14 +105,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[36;20m[INFO] (sopa.segmentation.patching)\u001b[0m 4 patches were saved in sdata['sopa_patches']\n" + "\u001b[36;20m[INFO] (sopa.patches.patches)\u001b[0m 4 patches were saved in sdata['sopa_patches']\n" ] } ], @@ -131,21 +130,22 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "['DAPI' 'CK' 'CD3' 'CD20']\n" - ] + "data": { + "text/plain": [ + "array(['DAPI', 'CK', 'CD3', 'CD20'], dtype='\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[########################################] | 100% Completed | 106.06 ms\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/quentinblampey/Library/Caches/pypoetry/virtualenvs/sopa-hDHgkEug-py3.9/lib/python3.9/site-packages/spatialdata/_core/_elements.py:96: UserWarning: Key `cellpose_boundaries` already exists. Overwriting it in-memory.\n", " self._check_key(key, self.keys(), self._shared_keys)\n" ] } @@ -485,30 +508,31 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "SpatialData object with:\n", + "SpatialData object\n", "├── Images\n", - "│ └── 'image': SpatialImage[cyx] (4, 2048, 2048)\n", + "│ └── 'image': DataArray[cyx] (4, 2048, 2048)\n", "├── Points\n", - "│ └── 'transcripts': DataFrame with shape: (, 4) (3D points)\n", + "│ └── 'transcripts': DataFrame with shape: (, 5) (3D points)\n", "├── Shapes\n", - "│ ├── 'baysor_boundaries': GeoDataFrame shape: (373, 1) (2D shapes)\n", - "│ └── 'cells': GeoDataFrame shape: (400, 1) (2D shapes)\n", + "│ ├── 'cellpose_boundaries': GeoDataFrame shape: (367, 1) (2D shapes)\n", + "│ ├── 'cells': GeoDataFrame shape: (400, 1) (2D shapes)\n", + "│ └── 'sopa_patches': GeoDataFrame shape: (4, 3) (2D shapes)\n", "└── Tables\n", - " └── 'table': AnnData (373, 5)\n", + " └── 'table': AnnData (367, 5)\n", "with coordinate systems:\n", - "▸ 'global', with elements:\n", - " image (Images), transcripts (Points), baysor_boundaries (Shapes), cells (Shapes)\n", - "▸ 'microns', with elements:\n", - " transcripts (Points), baysor_boundaries (Shapes)" + " ▸ 'global', with elements:\n", + " image (Images), transcripts (Points), cellpose_boundaries (Shapes), cells (Shapes), sopa_patches (Shapes)\n", + " ▸ 'microns', with elements:\n", + " transcripts (Points)" ] }, - "execution_count": 29, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -569,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -606,7 +630,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -619,9 +643,9 @@ "\u001b[36;20m[INFO] (sopa.io.report.generate)\u001b[0m Writing transcripts_section\n", "\u001b[36;20m[INFO] (sopa.io.report.generate)\u001b[0m Writing representation_section\n", "\u001b[36;20m[INFO] (sopa.io.report.generate)\u001b[0m Computing UMAP on 367 cells\n", - "/Users/quentinblampey/mambaforge/envs/sopa/lib/python3.10/site-packages/scanpy/plotting/_tools/scatterplots.py:394: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n", - " cax = scatter(\n", - "\u001b[36;20m[INFO] (sopa.io.report.generate)\u001b[0m Writing report to report.html\n" + "/Users/quentinblampey/Library/Caches/pypoetry/virtualenvs/sopa-hDHgkEug-py3.9/lib/python3.9/site-packages/numba/np/ufunc/parallel.py:371: NumbaWarning: \u001b[1mThe TBB threading layer requires TBB version 2021 update 6 or later i.e., TBB_INTERFACE_VERSION >= 12060. Found TBB_INTERFACE_VERSION = 12050. The TBB threading layer is disabled.\u001b[0m\n", + " warnings.warn(problem)\n", + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" ] } ], @@ -647,7 +671,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -688,13 +712,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### With `spatialdata-plot`\n", + "### With spatialdata-plot\n", "[`spatialdata-plot`](https://github.com/scverse/spatialdata-plot) library is a static plotting library for `SpatialData` objects" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -703,7 +727,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -717,20 +741,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/quentinblampey/mambaforge/envs/spatial/lib/python3.10/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", + "/Users/quentinblampey/Library/Caches/pypoetry/virtualenvs/sopa-hDHgkEug-py3.9/lib/python3.9/site-packages/anndata/_core/aligned_df.py:67: ImplicitModificationWarning: Transforming to str index.\n", " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", - "/Users/quentinblampey/mambaforge/envs/spatial/lib/python3.10/site-packages/spatialdata/_core/_elements.py:102: UserWarning: Key `transcripts` already exists. Overwriting it.\n", + "/Users/quentinblampey/Library/Caches/pypoetry/virtualenvs/sopa-hDHgkEug-py3.9/lib/python3.9/site-packages/spatialdata/_core/_elements.py:106: UserWarning: Key `transcripts` already exists. Overwriting it in-memory.\n", " self._check_key(key, self.keys(), self._shared_keys)\n", - "/Users/quentinblampey/mambaforge/envs/spatial/lib/python3.10/site-packages/spatialdata_plot/pl/render.py:320: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", - " _cax = ax.scatter(\n", - "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.0..1.9530949634755863].\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Using matplotlib \n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAHrCAYAAAAQZ+2yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddZwVVd/AvzNze+/d7k6apbtLxMDuwi5sfezubn2sR7HzFVERRRSlu3OB7Y67u3dvT7x/zLKAAbuAAnq/n88q98yZmTNz5875nV8KmqZphAgRIkSIECFCHGLEQz2AECFChAgRIkQICAklIUKECBEiRIjDhJBQEiJEiBAhQoQ4LAgJJSFChAgRIkSIw4KQUBIiRIgQIUKEOCwICSUhQoQIESJEiMOCkFASIkSIECFChDgsCAklIUKECBEiRIjDgpBQEiJEiBAhQoQ4LAgJJSFC/AvJzMxkypQpHd5v7ty5CILA559/ftDGct999yEIwkE7XogQIY5cQkJJiBAhQoQIEeKwICSUhAgRIkSIECEOC0JCSYgQIUKECBHisCAklIQI8Q9j7ty59O/fH4vFQk5ODq+99lq7/DZ27NjBaaedRnR0NDabjcGDB/Ptt9/+YV9FUbjjjjtITEwkLCyMyZMnU1paukefefPmcdppp5Geno7ZbCYtLY0bbrgBr9d70K41RIgQ/ywMh3oAIUKEOHisWrWKo48+mqSkJO6//34UReGBBx4gLi5ur/tVV1czdOhQPB4P1157LTExMUybNo3Jkyfz+eefc9JJJ+3R/+GHH0YQBG699VZqamp47rnnGD9+PKtXr8ZqtQLw2Wef4fF4uPLKK4mJiWHp0qW8+OKLlJWV8dlnn/1l9yBEiBBHLiGhJESIfxD33nsvkiSxYMECkpOTATj99NPp2rXrXvd77LHHqK6uZt68eQwfPhyASy+9lPz8fG688UZOOOEERHGXYrWhoYFNmzbhcDgA6Nu3L6effjpvvPEG1157LQCPP/54m4ACcNlll5Gbm8sdd9xBSUkJ6enpB/XaQ4QIceQTMt+ECPEPQVEUfvzxR0488cQ2gQQgNzeXSZMm7XXfmTNnMnDgwDaBBMBut3PZZZdRVFTExo0b9+h//vnntwkkAKeeeipJSUnMnDmzrW13gcTtdlNXV8fQoUPRNI1Vq1bt93WGCBHin0tIKAkR4h9CTU0NXq+X3Nzc3237o7bdKS4upnPnzr9r36lhKS4u3qM9Ly9vj8+CIJCbm0tRUVFbW0lJCVOmTCE6Ohq73U5cXByjRo0CoKmpqV3XFCJEiH8XIfNNiBAhDjqKojBhwgQaGhq49dZb6dKlC2FhYZSXlzNlyhRUVT3UQwwRIsRhSEgoCRHiH0J8fDwWi4Vt27b9btsfte1ORkYGW7Zs+V375s2b27bvTkFBwR6fNU1j27Zt5OfnA7Bu3Tq2bt3KtGnTOP/889v6zZ49u30XEyJEiH8lIfNNiBD/ECRJYvz48UyfPp2Kioq29m3btvHdd9/tdd9jjjmGpUuXsmjRorY2t9vN66+/TmZmJt26dduj/7vvvovL5Wr7/Pnnn1NZWdnmuyJJEqALKzvRNI3nn39+/y8wRIgQ/3hCmpIQIf5B3Hffffzwww8MGzaMK6+8EkVReOmll+jRowerV6/+0/1uu+02PvroIyZNmsS1115LdHQ006ZNo7CwkC+++GKPyBuA6Ohohg8fzoUXXkh1dTXPPfccubm5XHrppQB06dKFnJwcbr75ZsrLywkPD+eLL77A6XT+lZcfIkSII5yQUBIixD+Ifv368d1333HzzTdz9913k5aWxgMPPMCmTZvaTDF/REJCAgsXLuTWW2/lxRdfxOfzkZ+fz9dff82xxx77u/533HEHa9eu5dFHH8XlcjFu3DheeeUVbDYbAEajka+//pprr72WRx99FIvFwkknncTUqVPp1avXX3b9IUKEOLIRtN31qyFChPhHcuKJJ7Jhw4bf+YKECBEixOFEyKckRIh/GL9N415QUMDMmTMZPXr0oRlQiBAhQrSTkKYkRIh/GElJSUyZMoXs7GyKi4t59dVX8fv9rFq16nf5RUKECBHicCLkUxIixD+Mo48+mo8++oiqqirMZjNDhgzhkUceCQkkIUKEOOw5rM03L7/8MpmZmVgsFgYNGsTSpUsP9ZBChDjsefvttykqKsLn89HU1MSsWbPo27fvoR5WiBAhjiB+/fVXjj/+eJKTkxEEgenTp+9zn7lz59K3b1/MZjO5ubm88847HT7vYSuUfPLJJ9x4443ce++9rFy5kl69ejFx4kRqamoO9dBChAgRIkSIfzRut5tevXrx8ssvt6t/YWEhxx57LGPGjGH16tVcf/31XHLJJXz//fcdOu9h61MyaNAgBgwYwEsvvQSAqqqkpaVxzTXXcNtttx3i0YUIESJEiBD/DgRB4Msvv+TEE0/80z633nor3377LevXr29rO/PMM2lsbGTWrFntPtdh6VMSCARYsWIFt99+e1ubKIqMHz9+j4yTu+P3+/H7/W2fVVWloaGBmJgYBEH4y8ccIkSIECFCtBdN03C5XCQnJ/8uOeG+8Pl8BAKB/Trnb+dDs9mM2Wzu8LF+y6JFixg/fvwebRMnTuT666/v0HEOS6Gkrq4ORVFISEjYoz0hIeFPE0A9+uij3H///X/H8EKECBEiRIiDQmlpKampqe3u7/P5yMpMoKq6ucPnstvttLS07NF27733ct9993X4WL+lqqrqD+fs5uZmvF4vVqu1Xcc5LIWS/eH222/nxhtvbPvc1NREenr6IRzRX4fVbKJPQiSj8tLpdewYJl18l75hxwJYswxt/IUIjggAti9fxtGnn0K904XSgcqsos2COSWe/Elj+fj2h4i2OQDYWr6D9158lJUmkU1bS3BvLsJfVY/m9e/jiIcfggACAhoaB8OIKQoiNpOV8yafwKSjj8HgDqA2tlBU66WssITi+nJ21JRQUl9GQ0sjfrnjK52OkgUEgbL93F8QIDLCzthBPbjtqivoNPok2LENbp0KGwrAaoaB3aB7Npo9DPf4c7Gn5nD7f27ijbfeJlFWsAJbD94lHfYICEQ5IhnRbwidnX7ybREYew7HHBaJoirUtzgpriujsLaU2uZ6FFUBwBf0Ud/ipMHdhMvbgj/opyOPpUGA4QkxDDh6MFP/cw+RKV3gg7fgjjshLQmi7NDsgRtvQJt8NoIgsnXVco479VSq647g9P+igDEmkkHdsukxoAthnbJJqGoid94KUkoqabHbcDS7KeuWxbfnHYNz+Xq2zl9F5YYd1De66NBN/gtwOBwd6h8IBKiqbqZo032EOyzt3q/Z5SOz632UlpYSHh7e1n4wtCQHk8NSKImNjUWSJKqrq/dor66uJjEx8Q/3OVgqqMMdURBwhFnITo6nf9dcjj7tYmzh4dDYAD9+B2P7wo+fop18IYIjmi6DBjEgwsbGFg+F/vYJJYLZiCk2ks7jhvF/jzxHclgEFY01xFrD6d+1N3OeeIClhWuImbMUwWBAC8oEqhvQgvJffPUHjigKmIwGzCYjJqOBOCBKllknq/hlhUBQZn/crERBwGqy0Dkzl2f+9zoWe9ge2/21Tcz97zcsXPQrpQWwRNPY6mpAbp2QDjaCoJs8YzQN2WjAKYqomoaiqMiKgqq29xoFtECQFo8Pq9muv8w8TRD06JNcdASkxEOEncCWUtT+TYR3C6dXRgaapnvSG/+SKzx8MRlNvPbEE5x6xSWULVpLw7SfiEnJxj6qD44+MWgGAy2ltVRvK6O8rBIFEUkOEtAUSmuq+GXxAhauXkxVYy3egA+tnbOmCNhVFTkgk5CQiTk8HBYvBUGCQEAXSCwm+PJjXLEOHJPOo/+osRw98Wje/eCjQz037z8aaIEgittLrdnC+qMHM2J1EeU2GwXhDsa+8zlWg0BjpzT8ZiPrIuxENLbQEjg83lf7614Q7rAQHt5+oaRtv/DwPYSSg0ViYuIfztnh4eHt1pLAYSqUmEwm+vXrx5w5c9oca1RVZc6cOUydOvXQDu4QI4oCDruNyLwMRt56H7bUzhAMwLTnYWshLFkLoghVFXDr01jD7Lz11SzuuvIK3lqwaN8aAUFAslpI7tmF6fc/RXJYBN6SIspuvoq1d93J0fnDuNXemSGxGveNUJEbXQRqGpCbWlAOc6HEaJCwh1lJSYgmMS6SmEgHKUEZq9fP8UNGk5SQzN3PPktFVQ2y3DFhQRINRIVFcN0112GxhxGobiBYVIcpJhxDRizmuAhGX3ocXUf2JD4/gw+feIbrnnsat9+zX0LQ3sciYrWaiHSE4Q8PI9xuo58k4g8EaXJ5qHM20+L2EQjKqPs4d5imkesLIJRW8+uq5XSfeApar4FobgWxpgkiwqG2EU90OC1DRxI/dDQAX82di6qqFB/UKzv8EQWB/qJEj/yeAKQOySe5TxcESUQw7nrdRnRKIaJTCp3+4BiXcC0lGzZz4ilnsGHbJgJKsF3nTtHA5HKTWNWMOToeAM3rQXBYICYcEuJg0hCCHgn7+DPb9uubk8u0/b/kQ4+mofoChFfWErtoDTWd0mgSof+6jUTUOPFYDaweMpSS+CgK6utxrd+Oo9ZJjj/AxiNWEkPX8HZAlOxI3/1hyJAhzJw5c4+22bNnM2TIkA4d57AUSgBuvPFGLrjgAvr378/AgQN57rnncLvdXHjhhYd6aPuHIIAo4NA0UoCtmoaKgEnTyADaW5FEEAVsVjPXXHcnsTsFktcfh59+huo6EDTwywjpiSiblyJ1GUhCj3we//QL3kpJYZ+6SlHAHhvNl0+9REZ8Ms2uRoqnXo5QU4n3jdeovTODuMRURiZ14Z3weF7xW/lkSyneHeUoLV4Oih3kIJIHVANeg0RUhJ2c9ESO7pJBz/hIHF2yiErPpNuQU7BGxQEwdMRIxpwwmara+nYLJgICJoORlLhkTjn3VAACn85G+HEhAbOVoCBjfecRzIkRpCfmA9BlwEByjCYCPg+bDuL1SqKIPcxCVmo8XXJS6d+7B0ePOYaqyiKKl8yntrKOOVX1bCuqpLq+Ca/Pv9evrAVwqBrO+kY++Hw6Z51+EZHZeQSfeQn54vPRwqz4jRbE8WcT3384ABvWrGb2T3P3KfD8ExEFEc1kpal2lzlEtJgAUCtrkZ9+FrlRRBwyGDEpEjHahiAHQVXQJBNEhiN1zia9exfuvPsuLrr0ImTfvoVHgEIgSVY4+sEn2trUJ59BfPs52LABctIILFqHds5VGI1GGqqrWDj7B557++2DfRv+NroDArA+GGRTo4uGshrq5i5nWEBlS0QYw2trcYbbqfH4WFnfhHnBahLWbaeh0UVjBxce/zZaWlrYtm1b2+fCwkJWr15NdHQ06enp3H777ZSXl/Puu+8CcMUVV/DSSy/xn//8h4suuoiffvqJTz/9lG+//bZD5z1shZIzzjiD2tpa7rnnHqqqqujduzezZs36nSPNYY8gIBglJKsF0WIiSQCjopKkalQFgqS7vbhUjUSgqj3H0yA3rzOd+rVKn5+8Cd98C3IQSqp0Na3FCuV1KKt/YHtVFZ1GT6aquh1HF8BgMvHuf98gv0t33D4Pr6/6juScFNI8LURvL2LLhRdQ17cPOTfdTnp0DI8NPYHbuo/kqNNOYdmcXw4rocQAONDFsEijRGpMBDl9OzOhTydyIx3Ye/fA0uloBKOtbZ/cAYN49733OOmkk3G1eNo1GQgCGCUDkyaMwxbhIFjvQllbgtRUi1RVgioIBJ59FfMd17XtU76tnAjJhO8gXq8gCFjMRlISohk1qCcXXnI5PQcdhWgw0h3gnGvw7thCyvRpfDFrDis37KCyRia4j5ezExA9foqKK7n+zlt4Y9onmIaNQliwgvqfZhE5bhKW6BgAvC0t3HPLLcjKv/OFLwgCZSYLEa3Vkv2zfoV5C1GCEfB//4PqYnBEoaxZi+ZvIRgIIjRVQVZP1Ng0qCnGN2YssY9ey4mnn8QjjzzMms3rQWvf/VyiaqTl7dK/SBk5yFOup/6hG5G8GqbjzsE+Qo+QmDr1Cr76dhaeI9AfbCeunf9QNUr9QSrqGun562o2RtohJY6KxBgcviCLaxoo3VyIpbgSqbKemkAQT0dOJAoIoqj/2FvPp6nqIX3faXTMHaajI12+fDljxoxp+7zTZ/OCCy7gnXfeobKykpKSkrbtWVlZfPvtt9xwww08//zzpKam8uabbzJx4sQOnfewFUoApk6demSba0QB0WzCGB2OOTUBW1I8kVmZ1NXX4q93Yquqp6SkksjGFmpkpV0PeJKi4N+wGY+zAVtUNNrpFyNU1cErr0B0OBSUgtuPFhuBEptFxgD9oXrngw/Y12MpGI28+PJLHD9uAn45yHNLvqJeCxAZ4cAoKzijIzF6vNje/B+Nn39JyQtPkjFwJHFRsXz/0WfkdO6Es77hYNy5g4IMrAWQREbYLGSlxTN6aB/6jZ+M0RKD4IgFow0qSlHfeASfPRrzNfcyZtxRvPDCC1xy6WWo7dWWCALxsdEAKFt3YFz1E0LJFvD5wGhEfvZ5lI8+wfLDl4hJCVRWN1BqNFEuGaCd6vl9ESVAN4uJbv3yefjJ1wmL/b3/lTW7M2decQcun4c6pwtnkxtZ8e3VhLQaEBQVY5ObGd/NYcTzz3LxLbdhjIkl8bRzASjcvo2rr76Sn36eSyCoHE6y6d+Khh52qRr0V6taW482fwPChl+hqQ7NEobQWIfW0oiWlI0Ym4wWdIMgIfrcEJOEVivTvGEH4d2zOee8c1l31+20V8RTFJXxw4YxKCebZoeJaR98gSEzh4Q3v9qj35qffqTw62/xBdt35O6AD9guivp76jD5gkt2+7cmKyhNboq8fjJq6imrbaTEbKLGIOIsrEB2uVFavJi8/vYvBgQBwWhAspnJ69qVgKZQXlmJ6g+geHyoXj9aO9/dB5u/2nwzevTovb4X/ihb6+jRo1m1alWHzvNbDmuh5Iim1TfDnBrPO888y6BBQ0mKisUoSnj9Xqau+IZ5ixbSOG8VrvXbESvrUL3+fT7cFg3c1dVMnXoxDz/4KEnZXeDme9CSMxB+nQ4WM9qgkWjX3og1tysABevW8s477+z10GZ7GLM++ojRxx2Pqqq8O/sjfPUlRBntCKpCQ2wE+b8uxmez4Q9zEHB7qHr+abZIL3DMmx8TlZDIgP4D+KGD2fv+amTAYpBwxUczfuQojj73dkTTbg7RFWXw9tOIW3dgDW7FGfUK0Rddz/lTLmL90qU8+epr+zyHBiiqSkml7uQlxkehuJxgtiCYrAiuevC4UfL7Iybpmr6CzdsIKvJBtfMmGw2khtuYev7FhMUmojXUITz1MCyfDyePg6IGtBvvxRCfwnkXXs/KNRspLK3G6/MjK3sfhwYEgjLBZjc3P/woLS0ejDExSABFRbz1+uus9Po6FOH1T0RTVXxBPwvnLaLbmKEYh/bBPX0+BnsM+FoQo+OgyQkGAwICaslmRFcDqqohhsei+dyY6sqp/SmF8O7ZnHH6Kdx21+37PvFuuAq2MbNgG4rFxFtvvsFlV14NgCLLzJ79Pe+8/TarZ3yN5JfZ17clGCSskkiqwcAOqwmzyYQalFH9AVSfHy24nxOyICBIIjZVJQUo0TR8B+GnoCkKTq9CNRDt8rJNAKco4hMEXbOhau0WSARJQrJbMSXGcsmll/D8TXcC0OL1sKW8hMJNG3nljdf5de48FLcX2u08HmJvhISSvwjBaMAYHc7Y8aM57ZiT2to1VcVqtvLKkJO5LSWB74wGIr1+TC4PG4PyPiNYtgIlikrZ/MXccsPl3HjTzfQdeTzC2RegjhqCoJkRUjMQAEUO8sW7b3HDHXfR0LCXkD9R4PThwxh93PEALP/1O5xrV9K5upGaTjmIskpCWRWqqiEFA1R0yaEmPR53YyOWjcU019URlZB42KyefosoCGSIAt265COazGhV5QjfT4eCrVBRBPUN4PYhGCXC8vu37ZeVntG+E2gaQSXIomXLADBmptKcl4+lbDtCUNXVvoA4fBgA7ooaSqpK8QZ8beahMHRTU40gtK22O4IgCJSajMTGR5PRe4Detuw7mPEV5CbDojVQUolw3aVob3+OPSmTE045k1+WrtcTNyntEyY0TaOxqZkbHniwrS0N3ffk32mw2RNV0/AGvHz+zbecf83FmHIyES86BSp2QGIqiqKA2Q5WB2pdFWJ9MZjsYDajuWpRY9PwO6IQVi4FziA+JbnDz0IBkAhU+4M8+MijnHPWOQQ8HoaNG0tBwTZUVd23WVIAwWAg1RFGH7uV0uRY/EmxRFnMKG4fgVon/rIaAvWNqL4AtFcYlUREkxHRakayWUhEwxyQSQgqlPoDaIGgrnk4QEqBFEDRIFVR2+2z14YoINmtWLOSOe68s3j6ej2LuKaq2K02+uV2oV9uFyaOmUCPiWMoW7Vevw9/4ztQ1bQO+W0dKT5eIaHkr0AAyWqmW0wEnbrktjV/8fy9WDYWkPHok/SITuHJtGHkTpSYsbWEQFEFosvdrgiWQEDGUdtAzeqtPPXkE1xZUcGw0y5GTNFtyYHmRubP/4G333qLnxYsp97ZvNcVrCBJrN2wlk3r19C1Ry8yu/YiY9YMjC43SZt2YG9y4XU4qE9JIKKuEWQPHiXAJ7mZiNVNDLXq9vPDsWKBgD5hG202Mk8/X29ctgCefwGyk8HtgaIqiLDD0MGY+w9HlWWeu/MWPn3xFezoE+7e0ABZkdm8fQsNVdVEJyYgXnIagfsexxRwo2XmEcw9HvvFpwGw/rs5lDZU4Av69RBlk4lukoQIBI0GgrKMPyAjy0q7NQ+6H7WAwWREEFvt3snJ0D0Hmlr0q3B6wVOI9sozCDfexVEnnE3ai69RUlHX4fu6+zdd8qe9/n1oaPjkAJsKNvHyA89ww7MPYOrfmbL0LqjZfbGt+wWzpqE4orEpCoK3Ec1oRjOGIfp8BNK6EYy1kHDjeQCsWbJ0vyaTKgBNo6ysnEFdukAwyKaG9ptWBaOR7g4rmanxaJ3S6TlmOGePnMQ6xc2C0m2sX7uW5uWbiFu5iaKaBtzefU/IgiQhOWyYEmOwpMRjSowhIRAk0tXCckHEVlqNv1qP5NOCwQPKH1LW+pcI+xUBJhgMmBJj6NUtjzeu+g8GUWLtttXMWPod0RGxpEhhDBt+DLH2SO676SauvOY6ArXOIyItwuFOSCj5KxAEpDAr1gG9eeiSmwAIBgM0B2UaYyLg+muIv+xa4oeP5urOwzjlwU4c03QpYv0vKO2QtiM1Dbs3QHVNAwWrt1JR8wJDFi3lqituoKK0iOdefpat24uoqnVS3+gisA+7sSCJbI+0c+E30/g+9yHiE1KJPOUMzPfejzfMjUFRsDS70AxG1o3qjaO4iqoaJ5YmhbueeoW07GwURdnDU/twYadpJZiYvKuxZz+IDIOyaoiJgLRE3UE4IxOAurIivpn+BQFV26d6eyeyotDsdfH0/Q/z8KsvEH3iBGrlIHWPv0Dy+y9hT9fP39Lk4t5X3qCqqQbJKJCZkkxGagLpkXbCgWSfB6G2gfJGD4XNLTS53AQC8j7fz5oGqqoRCMisX/ErQ449G3IGg8sLDU3Q3AwGE6Qkom5cRmDHZizZXXj4jnsYdcKJHbup/xZaTQzsngJcVdGUvTs4KopCbIuTeZ+8y9WP3Yk5IYYyGjF/9Twev5dmRzRIRpIiIkmskkAT0BQ/vpHjMF13AdH9ugHQWF3DWVMuQtMOzCS24Te5I/aFIEkYHDaiUuJwjx9EYPJY/tv/ZJJtEUwEbs4fi3O8h6ryEsq2bOHWa6ayurQaLfDnvlGCJCGFh2HLSyN2SD4XnnoWV/UZRW1zA0/M/YxcSaB86Rpcq7fi3lykT/B7OV57aVfwwG8RBSSrmbD0RLL75xNmsSErMh+WrCXKK5Dx7TfIRgFfz8Fgj+Tc40/llbvuYFWzG+Vv9C/5qx1dDxUhoWQvCIKAJIkYJBGxVa2uKCqKoqJq6p8/e4KAYDYyfOQYrBYrda4G5n36DsbqWgxBhfr0ZNY++xiOskL6nHouiVFxDO7dlw1zFuhL3n081DHoYa7b/AEMVfXUO5sp31LMT+9+SqEoEpQV/IEggaCM0g61vAgkSCL1gswHDVu4KrkP+ZFJVFfUYYjQzRrOjBTWje5PWVIknaZNp4cpistffJ2I1jTCU6ZMobCwsIN3+O9BlhVWrlrD7NdfZMJl1yBk5sApp8MP34LVAnYreP3IQ8ZiAKpKStje4qVS1Wjva1FDwx/08+xbbxAwmXj82SeIO/UYoo4ehWG3RGqvP/I4K7etQdaCnDppPK998BkG4670YpXrl7Dso7eoqHXy1ZbtbCgopbqukcA+VmCaphGQZbyNzSx8fxoDxhyPweaApDSoqILoKAi3oQ3Nx9c9m5rnHiP7hXfoP27CEV8bSkDQVWKgJ9I60NevoE+iotWMZLdhsFsRDAZOGzqSqy68mBvuvouF8xf+qYOjhkap7KexpoLlc39h6MSj6PXsPcyaeiPb5y1C9booQ2OEoJGbmoecmkfiSRPJOvcYJLMJVVWZ/91sbrnjDnYU7fh7JxMBBJMBU3w0Q666nIHjx9ArLo1kWwTulmYaaitJTM0iymwjKrsLXbO7MOf6AtbddT+yLP+xX4UgIFpN9I12YO2axd2X3cC4brqJMTosnLfOugVV07gp8WO+idaTeqk+P0Fn8yHx0xBEEdFmwZSZjClPN+FKgsDId74ksaCImoRYmjKTcVVVQko2RqORi664iuseehTF4/sbhZLDK0/JwSIklPwBAiAZJCwmI+F2K2lWK7EGKDMaafH4aWrx4Pb48AeCe82MmZ2YAkDJ5jVU1lSQVVhCmD/Aju65SJpCzdwfEFpNCitKi9o9vvrW/2saBGUFWVFJ1TREoF4UWp3j2/8A5gG2QJD0bWWYamohGcI8Xkw+H+YwC2ZnE357GLFlVbS0NJJy9Akcfcl1iAYD69at45RTTqGgoMNWW0CfUERRxCBKSKIEAmiqRlCVUVXloNhBFVXD2ezmleefISwmiqGnnAtX34bSdyCCcz3BtZsJ9hmGfeAwlGCAh55+nCaXR7f/d4BkTSM86OOTl58nWFvNIy89jy1aj8j59q13+Gbau3yxeBFuUaNfhI3+ybF7CCQAST0GMfnhQajBANZXHuT9T2fg8fppbHbv05QTDCoY6pvYUlqJ39WMweZAHj0AQ0s1pCeg1bnwywpF9ijCTz4HaC3QJUrQbvHr8EEURAyShFEyYpAkQEBRFAJKEFmRUfdTwyAYjRijwjGnxGHJSCItPAyT2cglV17FgN4Dmf/TL4w7aTJzv/se1f/HpQJqgTolyFXXXcf0GTPI7JTHmf/3ERvnLyA8MpLI5GR8Tc1s+3UR8b3yye2ta0dWzV3ArbfdxfL1q3B53ft9DfuPHjEYk5XGI5feiLSblmjZO69SVF6IRVbJd8vEnj+F+MEjufG8i3nt2RdpcnvR/iBDsSCJWC0mHIkxmPp2Y1inXgDMrdnOEEcSZqsNURAYEJ1IaXwM2zIS8W8tYYvLjXYosq4KAqLRgGS3cdLgCQA4txcQVuOEgExYi5fipCTWTnsNkyCQ03comXmdEQzSLuE4xH4TEkp+gwCYTEZiohxkJsfRKSuZgWEWIgwGqpNiCG4rY3V9I+vLaimvqtcnr99OFq0ZBnMjYgHYrnmp6pRO7zkLCa+oJnXDFhpi43BNHI9RlGjwtKCuWo3g23f0DcBvLcOaprEJXeOxu5AkCAJi6ypYr+/yxzVeSmSFdK+fap+fTpK+UmncugkRAbcjDEddPVHlFYgx4fQdcS49JumOux9+/DGXXnwxHk+HIv7bkEQJq8lCjtmKGh6L3RKGKIj4gwEa3E4a3c24/R4CSvCA/FU0TaPF42NBVQM1jzzM/9Kz6TxgKNKQsQQae7F53m3k9hoNwHuvvshPvy7E7fV3IBW7TiO6w2q1IjP9o/f5Yvr/kdm3L9mJiXz+zbf4gwFAI8xsITMmnHiLhhrw6863bz6HUFkFdz8GgGg0ceqZl7Jl8yYqapx4fH68vgAiumNpMTv9SHZNGpqmscbjx1NSQ8HmTfROSMHbZxTB599ArWhAS07GOOBYuo4+Dqk1ZPWxO+7A5zuY2VL+egQEjAYj4VY7sfZoYhxRhFvtCIJIQJOpaayh0lmj14+RAx16dgSjgfCYcLoM7M2HL73FwtpCZm5bQozVTte8zm39Znz0CSddcA4/Tv/6TydODVizZTPd+/TmySee5Kqrr6Jbq7MzgD06itgsfSXu9/l46N4Heemll/AF/QTk4CEQSGh1cJVIy8xoE0hWLf6Z4q0b8G7fRKc1WzB6PQS9ASpWLMPy9Q/Exydxw4UXcd8DD/3xMUWRow0GYmxWTBPGYTGY8DQ6MZ92Lisj7GQ8+hTJ3Xtxdo8xjEjtxove11i8cA1bDYZDI5Roeg6SfqnZHBObjapprPnsXXzR4cSVlNMcG0na2i1osp/axhpyAE0Q2u/se7CGSch8869AkkSiI8Lo0y2Hyy6+kEFDRhITn4rmbgajEVd5IVuWLeDjX39l/vINbNlRjsf3mxefqqF6fCSF6YWWtqkBrHW11MdFYWlyASIIMukt+mRQVVxIZX0TWR49X0Q5+3au/CN2/iQkScRoMGAxGzGbjHpyL5OZhgbdDCAre+aRcGsa2z0+HPWNLHPWMhJw9BvAnFPGYvH4qctMICs2jRF3P4Jk1mst/DrrO84595x2R238lp3F64ZExBIXn86Qrvkk9ehJZNDLr+uLqAk0smbreorryqhvceILHliCJ1lWaGx2495SxN0nnkDysUdz78NPERWXQPcHXsFgNNJUX8fdjz1Bk8u7X8m/WoAtrf+OAIJeD/MXzGf+bn0kUcRmMRHMSefYa+7Rw5OdDQjrV8KCpRBjge65aANPJiwhnbMmn86iVZupqGnA5w+So2k4gVRJpMlixmI2IokiiqriD8gEZZlCp4v/3H8fM78fhaNHP1i+CTUQQDSZ2sbx809zuOeee5i/YOEB3NVDg0EyEB0WyV1XT+X8667AFGbHYDIitaZxD3h9vPbECzzxwnPUNte3v/ChIBBtNjLaEca4yZPJTs0gOzWDpd0SeELKwWLQ75+zrpqo2ASmT/uQk848nR++/mavZgaPx8PVU6/mo2nv0K1bNworKqioqKBLp06cf9xxSFYrDzzyGBvWr8UjCIfYYVwAQSAuPFIfu9vF1g/fxm+xMfTrnxB9fgqG9ENAw9jSSPGnH9Bz6s2MGjrsz48oChTZrUjZadwSr6cpqF+xBIu7CVxOKjauIbm7rj1Ji0zg3ktuZuTPCxDKatplzj7YaJoGQYUHT9K12IsL1yL8+gt528pYOWYIqsWMP8yKqPrxtv6kIsMjUAPyYRuBeCQREkp2Y6eWpHNOBq+/No3kvK67NtojAIiOTmRIzyH0PnkKTz1+D6+9/Ymev+E3YWyK18f2DRvo2q0H12QPYfu0L3GVlVGbHkdVWiIJ20uJbc1roZqthNU2UB4IkgEksH9CCYDJaMBht9I/zIotNgIhPppLp1zJ0WddQPGmDVx6+aXMX7YCnz+w6/ejqsguD5Gbi1nxwUcoQycRld0J7ewz+d5fRURA45huxyKZLWws2MTtTz3Btx9+st8CCYDFaCIxMo4rrr+J46ZeiDFsV1bVsYCqKHz91v/xwvPPs7F8K3UHoXhdUFaolhUS/AGWfvwFkYnp3PfAwxiMRrauXs0L556LWlnDwVib7YA/zBgpCAJmk5HMzHQsKa0hxy8/CPW1MGEIeBtgzWqExVvh1gfoMfFUMt55h/VbSxEFgSI0ulhMNEWF0y0uiviYCCxmIz5/EJfHj9unsL2ohMVLV/LfRx/mqjvvRpSkNoFk+a9zufPBB/n5l191H4AjDEkQCTPbyIpP47zrrsIRH/O7PiarhWvu/Q+pOVlcec3V1DU3tFXi3RuCJKI6wmjOTMaandbW/oJ513vgky//R2npJo45+jy6dcpn+sefcMpJJ/HdrH3n55m/bBnzW8PGATZs2MCCL7+kAcgB0oFNh3pS0zS0oEzBtgKCwSC2MAcDL76G4kfuxRkfQ2VOJpvGDyeuqIj0FatxV1QAYI+M2uuEvMli5tkr/0O/mDQUTeUXVzVZ4RGE1Tbiee1VVn/3HWX9e3LU5f8hzGojJyOLNcw7NJO8qjG6b3+6Z+mRk6677iY1Mo6WfnHEl1ewbNJoIiQRLS+LnKA+hZY7G3VT3t8ZEoyG2gH9R0f6HkpCQsluCKKAzWLmxWdfIjmvK5rXDZuXINRVgySBqEL/wWimeKyRsdz5wPP4G/w8994HyIq6xwpHCyq8fN999BkwkJTMLLo/8yrfX3wmm9LikNLSCUvOJaWLXgelR3YuprhkXLVNbEbb70nRaJDoFGnnuNNP4Zbrb6GpqpRm3PQafgIAGV278+477zHhmAlsLyrHF2gVTDRQ/QGqahvY/OOvvPbBW1x1weWckzeME6sqcCQkYTRbKC0uZMTZp9G8vQTV287V5x9gECUcVgdjhozipFv1xE6arKA0+jDE6k6hoiRxwmWnER8fydQbbqLZ24LSgYqpf0YVEC2r2Fxenn7mebqkprNtxw6+fvoZkmSZjl7VTp8YSdiZglpDUVXcmrrXFW9kpO5rosleBLMKXg8UV8DPpdDggtw01PMvQ0xKJTMrF0FYgCgK2Kw2SI5jaG4q+V0yyU5LIDkjl8TsfNJze2EwWbjvrluY/srrvHj/A7z66GM0RIQT7ghHlmVKy8uRZeWwDN9uDwaDgWh7JJMnHkt4fAxqIEjzPW8jVpci1tUQdMRjHNEZ+5XnctK5p7F5+TIeeOWFdgsl/gg70lFjOHPoMW3tfncL/o0bqPvyMxqtCv7UGF5aNZNzfAGG5ffn3bffIS4pab+uJ6L1zwntjvT6a9FQA0GKt2zj7vdf4cELppLVawBRdz7M6rtvIaasCp8RNFWhfsBAel58PQBWUdKTk/3REVUV1etHbH3kvlPrERfMI76onKjKCpqb4igTDDQeMwqTZMAfCLBj7i96lNOhQNMoLStv+zj+3f9DMhjQVJX5z9zLmBaF3jffhcG4S/NYV9UaffQ3/qxC5pt/AZIokpWZRo/BemEx7cm7EAekw8YimPGrLpTExSJkpqGcfy1Sj75cPPVaXv30U7y+wJ5fuqZRt3Ezk/v04eVvvmHwsOEc++EMJikKoiT97twnDxrM+g0b90sgEQBJksgMs3DDFZcz5d6HESWJ6NxdNnB5zVKEzDwSs3N45YXnOWfKRXtGdSgqbo+fNZV1TLv3QY7qNZDc3n0wp2cBsHH9Wi66bipNm3ag+Py/05KkAgGgph3jNRqMxNqjOOcCPUV5YNVmAm/ORqwuRR7ZFyEzA9UejXVsZ4acOIHLNlzM3Y8/iF/2oxwEb/w6dE2Ux+3mrMuv2K9jOGgtvmaxEW51YDeHYZAMqJqK2+/G5XXr/jBycA9BStM0AsEgkkE3g2l+N0JdAxRWQqMHLAbolIHW5EatKENMSiUxIRlFVekkCoxx2Mg751SOOeFEMjK7Ygz/vabg/keeRlA1vn35NTZ6fPh8tVRV1+7XdR40fhvhsx9CkSAIZIlGRvQbyI2P6cms5KUbMGzfjrBlJaLfg+CIQHE10pCZR/SkQfQZMRLLG6/v07fEBsQBkXl5vH/pf7CYzFQXbOSXj94mrGAHSZsLMLlaGKmpOJPiWNsnjx8//4lhn/1AbGIiycnJVLRqDTqCF91HbH81owcdDbRAEH9VPa+/+z6lVpE3T7qEyPw+pF96OerUaxj+5kcwZQojz7gEo9lCdWUFl1991Z+asDRFRW5q4dXpnzG09wAmCdF82bcP3tnzcEXmUpaXQ1GfzoyQ7ABIQGNN3SHN+bFx3XqmXnctLz3/ApLBQFAOYjQY6X/lrYiShMFooqmpkYiISH3MJaUHJelbiJBQsgeCIDB2nF6sKlBUgLGiCNYHob4Z6pzgbAanG7xe+Ow96NEXY3i47hCmL5L3YDlAUxNnTZnCqsVLiIyJQZQkqisraKiuxllZycL1G9g+bx5zv/mmQ+OURD1cWRAE3fHPKBGRlsSUux9AlCQUdxWix4UQkQ4lhRgevQM5PQ/tsZcZcdTxXHnF5Tz+1LPIirLLoVNVUX1+lpVVMnjoEDoNGMDpo0bxw5rV/DDnJ9Sd2RY1rS2HQ4IoECNJ2GUZtyhSq2p7rQUhCAIGyUBsVCyDxg0GIPjtAsRVcxHqK1DXzkWLz0QZdDx+r5fIY3tzxmXn8tQrL9DoaUI5COvJPxKcBEFAFIXW+9maLVHV/nQiy0Qk0mKnJSGdrLh0kiLjsZosyIpMtbMGe/lWnE11bPI2s3E3R11V0/D6gqS0lpYXw2JRzHYkqxUaWyAhBu2YociGeIz99PszKr8fiqySYTYz8fjjOe7up/YcjM8LW1ah/fw98qgJGPsM577HnmHZkqWsX7QMDmVCJ0lENBgQzEaEVmFcUxQ0fxBVljtkApQ0jQhR4PLzz8AUZiVYVo3vmbcwFGxAaKhENdsRLFYkRzSBKjcAed06YzQYEAUBZS9CST4QK8vcfvMdxIRH0lBfzexP3yBl+RrWDx+Az2IkaUsh5oAXb3gY5hYfscef2Lb//golh2PiOU1RUJrdhG8uZPX/PmBujyFM6tEfb0oqvlNOovv4Y0icpGd//nHhPM4773yqCveSokxRSXW5KXznfTafNYUunbsxqucwtltexRQMkrRtO7XhJmpi0gHYvHUTxW7fodOUtPLyiy+x8qc52AWNUqPAz9/MJjFJzzfU1FBP5uihDEjL4rxhI7nntdf/9vGFNCX/AjQ0xg7WHbb8TXUYXB6EigbYWABOlz5phNlg4lCU2HQkdHXyXsNWNSjatp1O3boxZuhQ1mzeRNWWraRqGk3oWQcjaf8XYZAkbFYTYTYLdpsFo8GApmkYDCLpcRF4ykqwZ+UiemsRvv0EFm+AbjlQVothQyHBMZ9hnHQG/7ntbn756RfmzF+4p61R01c29T4/i+YtYNH8Bbue5p3XKYl6ocFIB90NIjajgVWOMJoDQcwtXoLO5l2Fqv4AURDpP2gAZnsYco0Tbc5cKNsG3ma02DSEmlKknz9EXRVJoN8LRCbGcdn5Z3Pnk4+38y61H0EQMBokLGYjVosZq0FkvMdPsQjLVPB4/XsKbuhRQ6otgsj4dHp36supp5xItx5ZNGyroXhDDVWNNTTYIyjfsQ6qi9gW8LQ5W2qahtcfYN7iZZxxpYxoMCA98CratTVoTz8IzlJ8RQ1YHrgfgJb6Ot54710UVWVLtANTbuauwa+ZCa+9q5t+BBWhxYNhzQoCT72BKSaJnr3y+XXZyn3mOPlLEPTQWlOYhaNMRgpT4qmI0f2ylBYPgdpGgg1NKC1efUXcDs2JKoj4RRHVrNcuCmwoxLDsJ6guAaMROmdCdh9Uqx3Dj9/AhWNJz07HIBn4o1hNE9ADPcS+HghXNJavXsnQkaOxh0dhj4ohvLqWkR99g98kUdatE0WDe1OVEklms8xlp18KwPS3/3fARcgOKzRQA0HSa+qRV8mM76ybmbv3GQJ9hrR1e/LZp7jzgQeQXZ59fn9Bf5CmukbOufUmVkz/jqhO3ViZHEdmSSVN4WEUyyrd41IBqC0q+VvzffwR+UBQ02hYv5FwAJOB8y+8gB9mzQZg1fff07ytmB83bmf2zMOr3teRTkgo2Q2LrNC4aDGcchqOXkNQX3gf7ctpCD8uBmcj+FUIBsGRhDjxLABUt0fPuLmP309tTQ2fTp/e9rlpt22N7RibIIDZZCQ6wk5uRhLZ6Qkkx0cRZrUgKyrBoExsdDgBRS/mLVjSYF2hvhLdWgTx0dApDUPhCnxLkrEMGsG0t98lp2cPZPcfuGRqrf/5zXUJBglDhB1zagKO/FxsRgNSdgY/n3Mt87au4+4v3idsxUbKSqvxNblRA4HfHUNVVRIidN8RTQ4ilBeA4kVwu0DeAbGpUL4F3AnUfTyD5OsvZvi4MWhPPtaOO9V+IoFMixEtNpLolHjSEmPINBqIamohxx9A0mBHSRXV9U20eHwoioqAgNVoISwhg0suu4JxZ59AWKpeZC92MCQtKKZ+Ux3FCalYjRaqVYXwhnIa3E1tfg2BoMwHM77GevUl3PqfO4hOy8AQG4/w6Iu4S7cTlpYDQFlxIePHjqSkogZRELDarJh2li2o2Q7/ewcqq8BshpxkWFUPSSkYbfrk72+oxSCJhyKAAdFkxJQQQ35aAqbEGHr37UlM1yzq/R7khibcW4pxb9iBp6CEQHXDn+b72B0NjWIE1Aj9+qwDuxI8YRLarz+jFhdDfDri8RPRZB+B539ACwYxms3EJ8bh9DgxaHqIq6qqKKpKQNXwAi50E0qBJPLro4/QbcgQxg8YwjEX38zKzj2J+OBzbKtXIxeV0BQfQY09l7OPvgSjwcj0L/+Pky+9DG0/orUOazSNRg20+ia+/OgjTj//AgC2FGxl6dIl/N9nnzFj1veowWC7EpyVAWU+P8a58/G6W7CG2cmcMpW4qGjys3I5IzlFr8EEPPrcc4c8XbsLPXNPI7qvT2VAZvPsORhMJob26UPhxo16AdVDiKp1LLfckVIv8F8hlIii7owotobb7VTNh7W+qXfac30aPPf8c0SEhzHmllsxxcShXXAtlBXDwkWQkgnX3wG9+mIAXNWVPHb1FfgDB5ZHoz0YJIl+dis9e3Xlqpv/g8kuIcn1mPChCkYEcyTxOQOxxuirDUq3g9sNC9aApkKXLMhMQUjsQsv82VgGjSAhK4uuXbuyfPmK9g1CEpHsNiyZyWT26kR2rzz8vTozrHs/cmNzyc3MZW6Yn3LxMyJFidUllQTrm/bQmGitxev+7/vZXPvAXZiT4wmceBx8/hXIVZCQidprDGxcgC8sgoLCapKBvB7dDjjd9u4IgkCUyUBKVDgZ3bLpMqArXXLSiIsJR/L68VsiyCgs4cf5y1m5YQfbS6tpcfsQBYEwi5UrrrycyTddpl+Ty41WXoXYJQfHsAwcwzLIpB+DakZzvsnAtJde5boH7m0TSjRNw+3x8+aHnzJ75kz6J8Ryxu13cdRJZ7YJJACpGVlE1jiRfQFMBpEEWSEuWVdxs2EDOFugrgE8Mjhs0DkX7noGwWqjubQQ54Z1erbTvxk9pbidsG7ZxBw3jjsmnUHvrG6IgoBb9vN9ww6e2ryQ2qTVCEYDitePWi/vO8+DBgE5QHS0LpSIURGYX9JNWf6rbkBIyMR0mp4p1HRcP4TWxHSdOmXj8dRjNEq6+cwbwOX24vb62BzczelXUQk0tnDelZfx7bT36du9F4PHnQDjTkCTZUzffEHNF+8y8fQpRMbEUVpczHmXXfqnDp5HOk6gWYMzLpjC9XfcSVAOUlfXWidJ1Tou6SoqwWY3a5ctY9DoMRwz+ZQ9NtdUVvLOyy8ze85P+z1mURDaMhTruZn2rybX7rmp29JCqhqKGmTe0qX7Pb6DSch8c4RiNhkIs1qIM4okSSJFogG/rODx+Ul1eZDZlVsiCDhVjeteepFxP8/kttenkZbXHe3uZwmUrMSU3hdBMqD6faz65QceefhBFixbh/wXOzgJAlhNRoaEWTnj/AvpedQJbds0VWnNyNn62e9FeOUZmPs9JESBywMRYXo69TOugs69iN3t2FWV7a8OIRoNGGMjsffMJWJ4H2K75dKQnUK/6Ky2Pv8dfAqvSw5mxM8ked5KSpevRWnx7PGLkBWZwtJCZkz7kNOuuhjbI7fhFTW0dz9EScpErSvE8uRdJEwcR6JBv7ay0tIOJzPbG5Ik4ouwY+6Zy9Gd08lPjSd+cA+MjgjEmD6Iljh61ZTjqLodIRCk0eXB5w+CJpCVnsn5114EgPeTmWgvvQapPTGMH4DUKwOxd08Eg4QlXo+wGTFxAoaHHmD3dZWiqrR4fLh9AdbXN7Pm8qt56Oln6d9/ALfdeicJKXo24JS8TiirVpGmaQS9PmLC9W9PqyxH8Hj0uizpCdDcAuechxATh9xczwcvPkihX9YT+/3NbyPBbMQUH409P49nTr+ULnF6eK2maYQZzJwc35Uh5lhuMDtY0tSCr6QKxeXWq6zuBQ2NgBzkpmuu57IpF9MlM5fkzjnYUmMxPnA3Qms6fzUQxOjYFWI+bEA+sWF+HHYrsqxQ53RRUlHLjtJqahua8fl38/kJBKkrKGL0uadz/WWXcdSoseQlpZEQFUvGiWeQceIZbcedcv1UPG43giTusx7OkUjZbv+uLC//034dQtO48447uW7qVLZVV1O6fTurN25k3fr11NXuvzO2KO40w5owm4yIooCsqAQCQfwBmUBQPmIjzv5t/OOFktTEGNKT45js92Mxm6lLTmC9309pZS2u4ip8zW5EeVc68y2qRvemFr7bWkz8W69z72PPI0gGzFkDAShes4wXXnmKVQuWU1xRS30g+JeXhBYFke5WE/XdckjKTN+1QZYRWjNzUlcFhVsRnBvhq/8DswFS4qF3HlQ3ok29C6FzLzRFRpD0fYKBAJVVle0bhACi2YQ5MYaoHnm8c+xF5MSnEVRkjOKux8gqGblu8LFcN/hYAEZPGMMvP/2qa2t2DltVaPa1cN/jT5Kdl0e/CSOxPXY3/p6daFpXRsw152BKSdzj9AXLlh202g2CAGajgYTocPLzUunavyvJ2akYkpIRrL3BpE9uxvgUeuSkUukLsqmshnqni2BAITMrC8loJNDQjO+D7zGHp6EVbyH41ibkki1gdyCPPhn1wuOIHNQVl9e7R+bVnaiqxg5VoUhWEANBWLaKxctW8d/X/8erTz5JWmQkP69dixkoU/QS79s2rScxtwva0SfD558iKBpsK4X8PDRRQgCaGqpYXVpGlcdLUFb+XplEFJAs+nOS0ad7m0Cy7tLzaCwvI3z0WLpeNpWkyDheyZ/EMdt3EP/TMiqMBsr8wX1O7LKqMGfpYgp2lNIvK5++Oflc9eItWGKj2/o4N2wFm5mYzrqpa2j/HgzuHoPFqCHLCjX1jdTOW8USSeJbQaC6rlEXOEHP2eP24NlezpNPPM3z097BFB/NmIFDePu6Owhz6BmP3/jfaywp2Ig5OY6oZjdOtwdfQNbNOId67hMF9vCh0fZDq/EXMmfRIuYsWnTQjmeQRGxWC3HR4aQkRBMdacdqkEiodVLiC1BT34TH6WJNay2wDEBhT6GroyQCVvbUqBwKDp9v9eDxjxdKJo7ozZA+nenV3EJMdBKJV9yFu66ST959mtnzV7F6YyHW6oa2rKwasCGoYKxtZOZb7zG4a2/S8vKQTEaWL5jH02/8l+o6J4nOZmwB+aAk2toXkiTSFGGne4yD2J599MZP/gszv4Z6NwQDkBwJI3qDw4EyqCtqUQ2U1yAkxCCMOhpp6AjUgJ/5M99m4YqNnDD8GHasWNmugn0AaGBr9RO4Y/LZ5MTrk42xVcCpnfsjS6e9Rsq5F9B73HFtu9lrazBrGr+1vvqDfoqqSjjtnPO46647uejayzCfcwY7sz1UV1Rx23X/wWKEM44ay+vPPrvf9w/ADmSj+/KUCgLxJgOnaRpDktNJGTUJoyUS7FkgmcBZD1F6qG3K8RcyOnsNs7eUsK24Cjnow+l0AiAaRMSCZdDShGiPRjNa0FKyEdzNaA1O5J9/gUFdCd9H4SwVUHf7HmRZ4aZrryUJPfS4BN3cZPP4uO/xR/ly5Dgc0Qn4jj0F6b03EaxGtFonanUzZqChqJS1m4upc7oI/t0J0gSBTpJEoiTx2GA9QsNVsAXvuvVYNIXAJx+zcski+rw2jejYOC7q1JfPwr7AZTT8YfZOAeF3IdXeoI/S+nKSWhqJ27aK2f9L5PjrL2/rE945C6Ntl6ak7+AxSBHx4CwHalEavTRmdcf680+UL1rDsrXbqK5r2lUuQlF1zY3XR6C6gUSjgYJFaxky5xcGjhhOiVFlW6CZLhedQsDtIXrFOrK3lFBQ20hji5v1OwWcv5EcoEQQUKxmpDArksWMYJAwSRKexmYUr0/PLXQQTU07I9V2Rh5q7J+p5EAwGiSiwsPIzUxicN+ujBkxBIdJIWJHCVp1A5vCrGzfXMTmNdsobmimyeUmSlEJcmBCSQR6SYmdQokoiBglAwbJgCSKaBooqkJQCSKrR25eoEPBP14oOePUk+nRJZPw6FgMUd3AaMGRksWFVz3A8WfWsG7pci69+WYqquvbohQ0TcMUlHHVObnp4ksoNRqg1YwQlBVkWUH5G1egggBGo4HcpFTMEXF6o6cBml16CMH2cqh3giChxEZSl5VD+OnXQGIiktmMKVbXOqxa8D0ffvJ/rFi/g1+e/C9aB16eXQGHouLIzeOcvH4ALHnrJYSf5qI2NuDVFLKLKggIZhh3HB6/lzuuOg9LVdXvwqXTgXBNY2PQT1VTDbfedTubFi/knCsuo+fQgSybO49LLr+KksoyfAEfr330/gFrSVrQzXNN6BNdjCBiTU5m5A0PIVmsuzqWFsP5Z8Dr70BeF4wJeeQl5NH5m+9YsHIzKho1dXpQsWSzINaUQlgkyEFQAgjh0Whde+BO70ajs55YIL5TboeL+zWwZ42jOE0j1uunaGMBrz/7ODfd9xiGE86g7tWXISIMscaJMbcLZmBLSTnF5bV49qN+z4EiCAJ+UeDsCy+nf2YXlGCADd/+H/XZqUTUNBBTXA7rNlK3ZCEpx57AsIyu3JMQjdNoaFvcS6KIQTRgkCQEQUTTNBRVQVZklNYXvDfgpzoQoM7TzOP33s37335NggAPffwu4dHRe4xJitDDr4lKAVKQoiAmawiT+06g9tUnKS6vpb7RhRLYc8LWZAVNURFVFcFsosGg8LPYTHi/7gzNzuPVtGGYjGZe/vVL5s34CtOy9YTtKMfidOH7Gx01k4FmEXIcYZSmJfD8nfdw1gmn6on2gFWL5nPcRedRU92A0uJBk+UDWmLrYf0iZpMRk0mfhFVVIyjLbaUO/o7nThDAZjUzuE9P7rz9dvoOG4PBol+z5qxBbaoiS3WxftVyauzfk7psE4FgkDUe/wELCVt2+7dRMmC3hBFpCycyLAKr0YKqaXj8HupbnDR5XfgCvgPOSP1bQj4lRyi9x55JeHj479qliGgSIqJJyOpCz/+9TkPjcoJBue2LS0JfwW5XVIJqAPytzlOtD3P13zP81nNCRFBGCOqFogRRhBMvhQWLoaAQGhoh4AefD//8VUg5/bH2G7TnMVSV16e9x69LN1JV18iqoEJHfiLVgCxoKI274oa6TTiWHYsW4y9pxmyUcMbHENN6f5p8bpZ6WigymwkIIvzmbBqgaiq+gF587MXPPuKVLz7FaDTiD/hRVAVF3ZUVdafD5oEIJ5ta/y8BpQaRqBNPQrJYUZsaEKd/AZW18PabEGiBR2+D3sPg2lsAOPm0C3jrgy/RVBW3X49WEgwGtg89jiRXE2aDGeOO1VBdiDc8mvraQmrH9KUbEJOYCJJwwIV4FcDZ7Oa51//H5dffij02juiv51D+5RdEjR5DZLceACz7agYmZxPB/czzkAWUQ4ez24Je4Tk1vxdTTj8PgI1PPYj842z8uVmUx0Vha2gkqqqWis8+JGHiMXSPS+OMfiN49celiAgYjWYirA4ibeFE2MIxG03Iiozb76HO5aTZ68IX1J+PjcBmWUF0O8n56XtQVcLuuJNH//vqnoOqrYLVc0CKhrgk8LigWz7miFiu/M+jjBwzmScee5L3p3/1h09Xtd1GS9csRkyexKTRY2jMTuJKWw4OQX99Xj/uDIpykvjuky9o+HEJytoChIbmvy0ip9JkIC3cgad/dx66/gYunnjyHtv7DBlOypgBuNduxVtQStDZvN/RLZIkYrOYiYlykJWWSLeuXairLkfw+qhzealwNiPUOJGa3RQBzQd+eX9KLpBmMfHqf98ieWeiSJ8XLFaEqHikqHgigWGZQ4hP7ga199HQ5MLrDx40P0CzwUS0PZK8xCxy4jNJi0nGYbVjiwjD5W9h+frVbK8poqy+gkZPM0Hl4AmrKgJqBxzZO9L3UPKPF0oAqCqH+gZYvwIsdbCjCvJHwrjJuBvrkTQ/FrOJFrevbRIsQA8ZDcCu8NhDhKpqlAZkFu7YStpX/6X35MsRouLgqBNhzVN67pSMZNQB3Wn0BRHjdCNI6bZtPHH9VMIsFiq8PmbMm4fPHyAYVDrsB9MgQLOsYt+wiblrlzI6fyCO9CzS77yX9ZdeQGxpOVa3h9L++XQGbEhs83hp8v9+VbJ7wigNrVUAaX1JBLz0RQ/FKxYljJKBcEHEJxkADVlVCMqtK+b9/E40TcPgC5AerzuTBravxfLBa7CpWI8qiAyH9VuhtpbmCJXwC26lz5CRWCxh2GQngxLi2o7V+cOnqPtxES2vTMOuaBhsIoE4CfvoPHpO0f1qvnn9DWw+L979Gq1OTesfioq9spZ7rriS+19+GUdSMllXXQNAQ0M9V1x8Mdumz0ChY09sRmv/ZsDf+rlgr3v8CZpGr7zOiKJISdE2Nq9aTKBHLkqYnZr0JFLXbcOgBCiW/KgzPmbQyedx8+nn8soDj2E2mIizR9M1JY8zjjuOCcePw+uTWTl/LauXrmJzxTYKqgupcFbh8rYgqwp5gEuR2YKelfWZ/71JvzEjOfWMs/CsWYrxxYcxmo2QEQ/fLYb6RrCHQacsAlfdjGngSHoMGsa7Xw6jKDqaJU7nHsKYYJAwRkcQ1jWLV8+7hpTIXW7i1XVVuOtryO6czwNpg9gyvAh/ZS3+iloSmlwElPZlOD4gBAEpzMbjr77Mmaee1dY877vPwGRkxLgTAXjnkRdoKq/CW13L5LPPxl1b3+EYUUkUCbdbyUyJZ0KnTO558W3CUjNY/9006hfPp7bJxeIWL3WL11JWrLLd4/tL41BNBon83r1Izu2MpigIX/4Xpn8D6WlgjYSkDBgwGKFXPzoNmcDDb3Zh+7mn01K3HOdBOL9BMnDblVdxz3NPU1lQTEtBNWEYichOwt4lEU1R+fn1mcz4egZLt69ma9V2Gt3Nh6b68xHEv0Mo+eJdmPElOKxgsUK4DXrojqtyUwMJokiOplL3GzND4yEZ7O9RVZXmFi9V5bVsnDmLzIxcovoeBadfBKtWwXsfo5bW4p3+C87EZLq0Zpq86JJLWDrvV+KAIkFAU7X9d8rVQPUF8FfWcfZT99PjlEnMOO5yorLyUC44B/GBxzE1txDYKVyIIt6SKhS3bw8n1/bgA1TJQITVTi+TBbspjKDFSr0o0eJtweVyUh/w4A8G9usHrmoaeR4vW9euZeyZ5xCMSYQrTsWybCMUV0JFHXTLJpAWT0N0FOGAq7GR+oYGWoCVixfz/G23c+rVV5OSlkraSeOpSYjA+8Ns0m67CdFibjvXC489zuu334axw6P8cxzArE8+4fVvvuac007ntEmTkJ1OnnroIX4qK9svUc0ORANL0Cf3/RJIADSNWb/OAyA9Mxfj6x+xpqGEH+sKsBcWU52diNdhYltWMq76GgYBaemZRFjCMBtEuiTnct0FFzHpxvPaDpk3uj/H1bpYNWcJH33wEfPWLKSotpQWnwfrbrWiPEAnVUEt1cVeKToebWAPmL0Q5iwDhwXC7Xr4dF0d8ldfYBo4EoA5X3xOw28EEgBBFJHCw+jdK5+UyFgUOYh/WwHBujqWfDKNhE1biH37fSLTMnm7xySOXrae5ogNxIgiMn+9UCJIIsYoB0dNOLqtbfvH06ieO4u6nHRkRWHI2Ml0i0yEyEToDrHJCWTUNVCFtoeJcF+YTAaS46MZkJ/LaSecRFhqBgBdR0wkmJaCq3oHcdXVrHJ5cAdUDFV1iC3evyQQQBCgxGii90kn6Q1l22DdFjCYYfUGcHuhoASSYlFffBhh8ImEp6Rx9IhRNC5YhgVYxf6/4wVBwGwwMWjYcERRJKVzFnTO2rOPKDL28mMxBP20THdT39JAi89DoL1Vq/dByHxzJDP5RJj7g74S7pMLCdGweglMOJ2IjDxOmHA8hYvXHfBpItHNPls4uMW1EjWNeFcLJZX1VK3YzK+fvMe42HTs6V2Qjz8ZX/EO/FWV1AdkzKeeg2Q0MXfuz8z59Vc0TWtVoR74I6kGZYL1jXRdsIbUyjq+SOzMOYMmMPq8qylLzcOzbSteY6u5RQN/eS2qz9+hUwsIbDMYiA+PpUtMCnkJ6Rw7dCDbarw0NTUjVe6gqrqQ2Z5mqpvqcPvdHX7piehyUuVG3aBjskXhfPVLbGP6YIuOQEiIwS9rVNisSEQBsPqH7/F6vKjABk3jhscf5/Znn+OME0/ipbdeJ37oABiq58goKyyitqCAH957nzs+eP+gF1qrRNdoyG4Pr7/zDq+/8w47Y7L261sWBDYCXUSBHIPEFlFEUFU9v8x+5KPYsmEj0z/+iONOPY2kyFiSImMZk9qNXwNz6Dp1NAm5XRlvd7T1//n7WShePzmxqfTO7M6Yc3UNk1LXiLylElO/HMLiHAw/czxDThnF5y+8yc2PPIjH52H1b85tVTTmz/qOE66aijktE+XEK2D+GoiPgsYmiIiA5HjISEQ4WjdzrF2xlJMvnILrN8cyADlo1BkljsvrCUD9utX8/MpTRNU7Sa2qJbqwjNqbbyT8k/8jOTKeTslplJmNbDca8O0jxBlBaI2UaUXrYDYs9JwwaZ1yiY7Qn9NZ11+IYUcJKS1u7A3NtGzcxoy1qzn95gcBKK6rxh/wEiEK2BXaLZQIgkCU2Uh2WgID8/PI6rurcrJkT0TqkYi5c4DBlZvJ7DSC/E3bKXn6GVZt2IL6F6RMEAURq9HEyJFj9fH5Vbj/Bd3pf+0aWLkU/m86lBUibC5EGCoRDPiZOW8uTaKIgEIS+y+UiIKI1WTRhSDAt2ozhuJtIMtotU6Cc5dhunIKhtEDGXX9aYRnxzFxSRdufu5pyn5TDyvEnvw7hJKIRGj2gscDsgYNjWhbStosbCn9BrFW+/M6J+0lHH3CCwcaBaGtamyrW/p+H7cFsCsaZQ1Neh2JX9cQ2W8Jo9K7YBg6BvvQMbh+ns2cmdO57KTTAbj/vvsPvse3qiK7PMS53CTWN/LlrXdyztwJAKSOOQrGHEXuzjHX1hFZ30htB1+yBkki2h5F3/TuTErIYNz5p5N39lEANK0upLGsFluskRNWrOamxx5nR00xvoC/Qz9yFd2EVGPSi+KZ4xKQLruRql9moa7bhi8uBndUJDZ/JD0n6BEk3336GcHdrkVDwxvw8e5nn1BUXcm333yNwWjkjjvu5MXnXyBKCWLmr6n8+kcTyX7VUGlNBS/ZLBgiHWhhZmzh4dx13IksWLWK+YuXIDe1oHp9HSs2pmmcdM65RN50I+dPmsidd99HfEYmE4Yf+7uuMz78kLMvu5weko2e4fFcedHJWOKj0QIy/ic/hEVz8RqMiJdcijQiH2NaNKffcDnL58/jx68+pUxTqNvteGsFcC9ZinLJuTz52jvY4tPQ7ngUHrkFmsOhthG2leDuk0eLoId1miQjXq/vd0/QIMAdDDI+sxPnjZgEgLN0O2gqtRlJWF0ukt1epAjdsbamrop15UWoQQUvv/Wi2o3WMg2SzYJksyAYpNZKugEUtwfVF2j//ZZE+uT3AqC6rpLimDDyNsv4jSYwSgSMJlK++ZHKvF4knXAqqzauxBsexgazCSXYfoOiWYC+JiNDI+2MHTWB6Iz+uzZ+/iH07oeQ2xlzej4Z6ZDRfzR31dRz9j33EjzIQomA/p2lxCaR2bW73tipVUgymqDfAP3v0qvhxx8gUTe3rv95FsaiYnYAFg6sCKIoCFiMZsJaHxpDuI3gS2+hbd4Kqowg+/Fv34Y0bwaC1UKfyaPpM3k0Xy9ZyAc/zT4oagtNE9C09vuJdKTvoeRfIZRoOwogIQpBVEEFzScjR8ZjaM3Z8eybr9EcVA44lL9EEBAkCcFkwLCzAJmqoQZlVH9A93rfDxtrc+ufGJBZ1OQiYlsJ6+5/iCcNVgaMHENEbBxJYyZw5RhdQPji/feZ+8svB3Yxf4ai8j2Q7fZiXb2JObNmMu7oY9i0aSMBOUivnvoLcuOCBcSqGh1JhyQKAikGM4nhcQzM6EqvyHiihF2hnRG9s4joratIJw7uw6KNBbz6/hsEZRlZ7ZgDWSHw2U8/cdnCBfQZOoy4084g7rQz8NVU4yotIaZ337ZqzvO+/ZYnv5r+h8dRNZW5v8xlYKdORAsC6yoqCPD3OkLvL4LRiDE6nFFjR3H2sGGsXbuEG+5+krSUdJpbXPS7+lyq1mxGKq6kucXTMcFEVWmsquar9z4gwhfkgfc/oKKokHc+/4TpP/xA6dZt9JYVCsorkI1mmqNsHHXWqWSeOA4A/3/uhR8XIjTVoYVHoX43H/9Xs+Hq04kY2YtLbr2Bn76djvM3E6umgcXtZdOPc7nlmot5/tX3MHTpib/7EIQ53yE98CTk9yYsJg57a1rzzevXI/+BU7AfyMvM5rVX3yTMbGFz+XYKZn8NJgP+iAjKu3YmpqKO6F56bZjFSjP+qnqU5pY/vVeCQSLGbkVLjGHE+LEM6NefVc5q1m7bgmFHCSWV9QQq6wg2udACwXZNXvmdugCwNdjMrKnnkrvibmIKy9mSmUz2sjU0J8bhjLSTBDiNBjRV6/CkqEoSqs1Mz9ETyBp6ot7Y1ABXXAZb1kC4Ay46D1KyYZye3LGuoRZJ+n1+ngNFEERMBhPZ6bm60z9AIAA3XQ/FxTB4MAwcBOOPgvFH6cF/sszsd/+Hv9mDoqgHxTQvCiJrF65k2OSJGHLSEd/7L95Tr4bqMgj6ELevx3fNvfhOOoWoY3V3gTXlFb8Lc99fVDq26DlSPFn+8UKJ7PNS99KT2LwBDOkpYBQJlFRjeOgejJKB5XO+Z+asHzD5/CSw/8lwsoAIk8SmmCiMsZGY4qMRLSY0WUFuaiFQXU+wvgnF49tvz3dV0/D5g8iyiyaXh1MumIIdGN+nLy9//S32iAhKt2xhypVX7udVtI9GYKWiYnS5ueSqq7noqKP46uOPKAsEmDLlQsoanMyaPh13B48rChLpBiPdwyLISe1KdGoX7F10IUQtK0f+7mfELrlIg/sjGA1cdfOVfPR/n9DsdXVYKAGor6+n77DhDB88iEsuuojJJ59CVHwClni9ls2GNWv4+pOPufvJp/bprV9dWUmAI+eHjyRiiLCTMiCfz157mwh7OC0BH/ZW7VG43cF9193A888/hUeR8RZWskPpYJE0VaM4IPPgRx/xxi+/UFtXh6rqmU81RWFWq4BuNxiY9uHbDBg3Wt+tvBLlyxmITQ0gGhAEFbVkPaKmoixeDCN7YY+KpEASUYO/L89dp+lRSqVzFzD9vTc59bJrMN50J67JJxLRtVdbP7fTyYP338uzr7z6h1rF5cDQYcOIiNRNIy0rVnL8ix9QtmMzS3/+GrenAO+9dxJ70tkAFG/ciGfbXqJbRBHJEUZWSizW7jm8cd9jxMbEt23esGMTFz15DwWbdpC5oZAqZxOV+4qgUlTys3T95ArVjTvcTHhdA7bGRmLKa/FGOFg9cSS5Q3rTDWjxeFE9vg6nxs9QVcyKStehowHQNq1AuHgKbNoOSbHQryv8NBv6d0PunI8hNYstntY6XBxcfwZBEEhKSOKJl57c1WgyweST4NOP4fEnwGqGH36CfF1gLJk3hzlbtrM8qPyhANpRNE1DVmTmzl9K4n3vceojFyEmJSB07YzWVIsW9COkdSZY56fh2/ltQkltTU3IdLMP/vFCicFixXrX41Q+9SAt5YWIXj/hlkjS8/sS9Pu55vbbaHJ5yGpdPJjYj1BIQUCxmRHiYwjv3Yk+o4bRpUd3MmLi6awaCUOi2u0mUF7NhkVLeOq/r6EE9j8+VFZUZEXFH5CJ0DSWzlvAuePGcdGll/LC00/T0nIgisl2oulVNIsKi3jutdeJAdzA46/+d78PKYoisjkMITqR+IhYorKSMPfSS4UHL7gIZfUWBGsYviFDsH/2JrFpSUTYHEhO6YBWH/MXL2HBkiWYrrmGSWPHkZGQwPSff6KkpKTdc3Bd69+RgmgyYk6K5d5b7yDCrofM7xRI6suLiUnJ4Jy+oym9tIlvnnuR0iY3QiBISutk26HEU6pGVdmfpymPMpnIH7TLHND89XIMPUYjbFqM2lSF4GqGqiIMiTHYb9Yr865dsqLVl+j3X5AJiPQH2Vbt5Kb7HsCeksHRx05uE0iqi3Zw7Wkn8/OOQhpd7r0KnK9+/DG33XcfSdnZ9J98GgCp2V1ISs+lYvkC0gaPAmD1jk38+MorxKzfRkNTi552/jeIFhPmlDgY3BNG9cUWEbnH9u7ZXZk09UrqPvkIe1MLlkAQXO69CoKarNApTheiTRu3cfqTXyL4vDSkxFOUn8eQzn245KQzsJv0c1lKK9Dqmzq8MGpAw6dCarfeAMh1mzHaLGA26Y7DggANLWiSAVr9W+zNHj2sv0Nn2jeCIPDV9M/I7tYFpdkFRWVIPTrDhAn63933wocfgEdfFmmyzOfTPqKithmvP3BQzNr6AtFLVHUhdZtXt7Ur0TmIqfVQtI5gr3HIVdtR18wj6L0Ko9VCUmoy1Q37n05/dzQEtA6E+Xak76HkHy+UeBsaCM/MJvXJV1g9eyaJNgeG1iqjsiyzdv1mAoEgm9GjD/bHL1o0GalLjieub2deOvdCTj/urD/vfOa5rPnlF+auWYdvfy5oNzRNo7T135tXrOCrFXsW1uuBrtU4kMyF7eG3ib72l2RNI0LQ6No5lx4TOhM7MAtBFFBmzEL9eS5EJ6ANPxHDkDwAqtdvQxKlP0zh3lE0Dfz+ANO/++6Aj3XYI4pINgv9R4/g3CG6o+CCT98kZ+yxxETEsPbZx4g+/Ux6DRzFbcNPoK8tlnuuv4HK+ibCgzIiB/eZEpsauWTEaB597z1Se3Ql4pJj8P4yEy0uFc1iRfA1gTUSecgQBFGkdNM2/nP3/QQV+U8nPAXw+PxU1MicefY5vPHsc6SlpeMsKead555l+8aN1CPsM8mXFgyy/OuvOf6669ra1m1cQ89uvdoEkpkL5vCfh+8hbfUW3M1uFG/gd4KETYBsq5mmrGT8k4aRPWIINoMJgBk3XUqni6+iS7c+3N11FCPPcrCu22AefOQJhC070AJ/LkBYFYU5n39Gp575XDDwKGZ+MQN3hIO6Xl0wNjrJO/VcpDC9bEJ5cSHb3vuQTKeLDR3UFjg1gZWBAH6vF5PVhjsunvDjhiMGZWhuhkIn2mmnofTrg8ERSaClhfWLFhH8C5LISZJEfLK+WPH+9CvyHY8RlhSDcfI4OO8cSE+H225v6++vqce/cCXZ9U1skg+OLlPVVDwBL6WuBk4YrvuzyM1uvGsXYa7YgRYRg7ruF5okI+WdsslqNTOZbBYwSgit2sKQ0uT3/OOFkhN69OChTz9l/DHHMPA3VSmtYWFYbWF4vLp4sF8Tqygi2sxYMpOIGTGAoa0hhgDrSrfC1gLqzAKRSSn0yemFp8VFXVMDMZJI+UFQI+51aK1/RwpeTcNot3PFy/djsOirdrWgEP/9j4EWQAsGoKwATeoGgE9WCMjBg1o9+N+AIAqIFhOPXX0jkiiypmQTNd99z5YNaymYMJKBzU00v/YiqstFrzHHcFTfYQya/h1Thg1h+ub9Dhb+U0oE+HLTJraeei4L1y5CMpnwmc0YXXVoVhvSmZMxHnsUYo5uyivdUUh0XRUxcoA/qtykomfuBZAVhabmFs645NI2M4Koaa1OyPueEWRgygMP8IzZzNkXXUTRyhVcfcFZXP7Aw4wYPJTy8jJuvPdeIldvxNDUTOmfTHoxkohkMZEQG0VYbjqPRujRPK71a5Gbm6m883as9z5ARu+BjO06gLFdBxDn9HDpjTfj2cv4POhh52NPOY3O+flMeOgZVEEgMiqG2vLiNoGkx/Xn4/thAZRV0ez3d9jxXlNVWjx+3v/wXa6cegMGRx6udduxxkRg8Pjg/ocQh45sm1Dee/ZJikorMAXk35WY2CeCgCCJel2vndFJrdFgmqISDAa5+JLL+PT/PsN+4rG0rN1E8M1pqM/twPDxLMRxw+GCMxDysgGY8+H3NDa70Py+g5ojJKAqLPK1cFu2XpndX1OD3DWemLceAFXB+c0PiImJDD92PAaTiR9mz2ZtVQnmlHgc/gCax0tdU0eN3LsIaUqOUJa43Uw+9RRuuuhi4iMiqKut5YRzz6XvyJHM/Phj6uvrD+j4gqgnL0rqksu7599MgiMKVZH58eHbaWisx+j2IgggnXwK5PRiXXkhLWEm6o0GUA5OvPqfsfYvPfrBpx5Y2eLCWVVDXGvhQeeHyzFrYUiWKDAYUSUJrYfu2BcVH0lkS4NeWyK05Gg/gsDpRx3NoE7d8QcDLJzzJXGihtHnI3bdZoxBP0XdO1FQsBxbXDyd8wcSER1DRqdOJG4uoP11pduHpmn4g37csgfJpGsPzI/dhaCC2WpEiopo66uqKgt/+B6zpxnpT44XCb/T5uysawWtWpQOjK+hoYEpV17Jpdddh6apmESRCy67XHey1HRH9i5eH+UaxPPHuUnKDQYaIh3Ep8TzcGIfskzhBBvqWTDtVWyNLeD3MvubjzAoDQzO6UWXyCQmn3Ue199xF559FCrcHAgy9phJLPl1HqnZ2W3tCWm6EHf7i09R+N0vBKobULx+3dG1g2jomsTnn3+Biy66HHtKJu6r76Zp2zpEo4SjS1dMwI71K1j800+8+uJLKG5Pu3+VOxdQikGis8mAy2GnMToc0aqH3CpuL3KzG6VZryb93azvePz+R7njgbsIu/MGGlpUNJcVU1gERqMXc1Q0AlC2bBPfzPqR2UC5IBzUiERVUwl43QitnmSm1CSSn324bXvslRe1VWRfvWI5N374X6LG9AdRIKOqjmBVA3UrNv3Bkdt5fkKOrkcsXq+Ph15+me7oK59H33mHE44+mm9//PHADy6KSDYzp40/mgRHFN6aaopuu4n0BfOJc9hZPWkMjup6nE5d+BnUOZ+oyEhEqYqNB9kDTC+QJeiRyOiZYI+kyVrRFBpbmjjnrAv5dMZnRMZFE37ZaFwrf8Ik+9EGDUA6+VjEHD0Tq6uxEc3VSFD5+wugHdFoGh6vHrUiaRqiL0BUXSPJO0qI21FKQ2IcWWs2IeZk06mH7uvxxhcf8ePcuX+Z34ysKmwt2saKn36m39gxhCXuypzqqa7l2zff4+clS/l141pMxdsJov6pCWn9XzC+dEAKBChEL37n8wco3vlD0zQ2AqnsI1maBuNSczgqPg9NVZnzyf/YmpHAoKXLiS0sRVRU1llNrPUH6DJ0MoLBgNdobJdWo6K8gsvOOov3v/yS9QsX8Njzz3LC8ScgWa08f//DdHM24VE19n8K1H3ZdhSV8tFbbzLlmmsJ6zuAsL4D9ujzzcOPsvjrb6nzByjpQJBPN0ASBTbFRJAUFU5092wsvTphjopgWHonbu4zhqzEVJYsWsCNxx9Ho8fPE08/SX5+PsedOhnHXVdRdd+zmCf2wzphKADuyhqef/wllheupba5noB88N8TOWi8eu89xGWk061PHxRF4etX32D75i30GjsKnwRvrpzHJrtKwhnjyUtMoLm+hrSNO9jhD8IBCCX/VP4VQslONuz8RzDI519/3a59wmlH/QZB4IT8wQBUffguvlUr0cJsJBYUk5GwnpqcDBw/zYUz9Eqmn7z7Gd169dyPK/hjdlaoNBmMmI1mBEFAU1X8chC/7EdW5L8kq+LBRtM0svxe/KsWM/X8K3jv248xJsUR/dWrNE3/gfDjxuoq3VaafF6WB/16REeIdqOpKjN+mM36dWvo0bMXUcedgPT1jyQXFCMGFDBI+IwGerQEEESRHTUV3Pn4Q3hkGflgh1LsRlCRGXfSiQwfNgKzZEQSJDRFZcP6DcQ21OP1udmqydgUmYh9H+6gYoW2rLyG1r/fCgt787PRVBXV56dLrO4LscJZSoGvkeSN27DX1GJr8hBR30h4ZDTH5o8G4OE3XiG8uRkP7VvlLlq6lKEpKdQDUcBV8xehtlZeroOOm1H+gKCscPnNNyOqKhOPOZalG9ahqBphJiPB0nI2fTkDoz9IPR17TOoAS7gDW146O4bkc8Hxk5nYYwD5EUnYxV35kIePHE3CgD7ULV2J2+fl8iuvYGZ2Or369ib9mbsB/V6v+L9ZfPfAoyytqWSHuwG33/OXpHevB35Zu5Ye/fpxxrHHEigpQVy7lijgq//7kOTLz8fRrysv9h/GmPhcJMnAg8XzKI+wE2Yxwy3P7fe5Q3lK/gUICG2VStEgE40gumDypy8cTSPcYqN3ph6Wt7pqB2EZSVjcPpwBBZPXj0EOUhMdRuGCn8gaNpa07Bz84sHx9pBECbvZRpQ9kjhHDNH2SEwGIwE5iNPdRGVjNU53E96Ab1d9mcMYJxpBvxd13o88dtm1XPvY/YTFxhBxop5Abd38ZTQHfPQd2JetGzfQov191Zr/Magais/P8598yBs9ezEiPo9vB+eTIIXhyM1B9bYQt3oVlh76Kri5vo70ilp8vgAb/qKbbUd3Mm9qbmbmdzMRRRFREHUBW9OoV2SMrb/HJnb5jPxd7F4VdsOf9vpzNEVFbWrBUa8vcfrHZKBMOB7D9jeIqnHiigzHOHYMZ11wA0aDicLSIt5+9WUsgSB5vzn/n9HIrgylbRqtVsGpeD/G/GcEAkGevv4GHrv+BgokERCIVBRGoE/S5XQ8MVmNxYQ1NY7o3p254NxzuT9/Qts2n8/LcmcJw5Nai+6lJ1BVGIVaXkuNs5ZTTzmVX+fOIT4lhZVz5/PSi6+zasUKEp01NAe8NKvyrnefKOpmN5G2pJaaou53css2U6am8fE335ADdAd2iHDetddy6W13/m6f4zL60xCTi7PFxaz9Ous/m5BQAhhECaPBiMVoxiAaiFBVMv1eWlSFJlVmy16mPU1VUVp2WaiNBVtRDSJbRw4gOisXW2o63eqaqVk6nxmzPuW6YXq0g1GQCB7gC14SJSJsDjolZtM9tTOdk3JIjkrAbDDjC/qpaqphXckmNpRtobC2lCZPM8ph7hRaBiSiYXU7Wfi/11i1ehmfLl8CwP89/xKv3HkPDQEfJbKfBu3IMk8dTghBmW8/+4zm2+4iye7gknte2WO7a+NaLJk5AHz59QwqGl375YvQXjLQtQGb2K1I4245Uf/ywnZ/NarKWGcTJZ99jufsC7DZHQzqMRheGkyNaMI4sD+5Z16AaDCweMNqbrvmKkyVtQjawRUoDhYudN+cnTk/bMBGdGGxvT5HdiAB2C4IxCcnM/1/75GRm0t8a4bc8u++pvHzT5iXk0Bm115wUmdcriaMERbMqQkE65uRm1vYXrSdvG7dMZtMeNz6u1jTNCrkIAoaMgKCQUK0mjE4wpDCwxBNRlBVFK8fudGF4vaiBoIHXEBwO7BdFDBEOvjPyF1BDxVL5yMoGklDRtBPsIHDRrN2YDWUQ46u/0AEQcAkGelttDAmJ5feZ5xJmV+leekymjZuYF3QR4u7iVyPiwJN+WMnKVWjsWaXpV1xRFEeZWDUqefTpWvftvauJ53F0KDu2Lpx5Qo8rgPLJSKgpzlOikygX1Y+g/L6MnhYf5K6JiFFRSIIQWrWlZLwqZHOzQ1saq5nsd/D9iOg7kIVEAEENZnKFUu559rryM7J4eH/3EpkwIeEHr59YC7K/15igHiDhCCoLPn+Kyaccu7v+ji66Umn1qxewdPPPY/HH/xLnxon+xeOf8SggVODhfMXkTtuGEefcwZ3nXUR2XFJxL/walu37xf+zDm330L22i3YPX42HsIh743fJpksQVc+dGTJk4Q+Adk0jbGjRjJowJC2bY0zvqTlxhsIRNjJq44jJVHXRDscEVw45SrOGVvFRVOvobm5BQ1we9y4PXtGsuysdh2UBGK6dqLFasCQGoclPZE0ReG6rgNxVlby2vczsZbWsLjFoxcQPVBzsCBgc9gZ1Vf3x1rxzAPULV5Ec+dcxpWWg0Gi0mEhsme/AzqN7ujafkHj8F6O7uJfLZSYDCZi7FGMyO3KXdM/JCw5EQBVUfjqwTcILFhMeuFaqisLKfe7UZUgskFCknaplRVVQ/X5KdlWQHpuHsMef5GC1UvaBJKVDWUYG5romdsdk2TF29LCHTfecMAPviSK2C1hZMamcvxxxzPy1DFYk6P26JOeEccYn5d59ZXUtTiR/R5E1XVEmHG2o6/GfMCXL75AA1DRus3S2h5i/0gzSiTZrfRIjsW3cBa1A7sTm9QDwfD7WsZfzfgCg89/4C/qfVCx7y4d4nB8RhYDuf4gcesLWP7ki9T3HU52XBIATQ31XP/y03z20ccEahpYvh9ZVw81HR1tAbq2xCOJNPp0DUd9fTXLH7ub1K9/wCBq1KQkEOb14vrqCxpHjCEyrwvH9xoKveDdJ55kRlnlnzqviOjPwflHTeCVmbqh5JNlc3hNreJSUwKn9Rmvt/lr8K7fjnlHOWHFlShe/wHnXYoKj0RozZ/U4/IbWGQ0IaxbSdlX9xJdUYPZZkH96psDPMs/k3+tUCKJEllWB0Ojkrj0wfsIS04kWOtE9SmY02I59pqzsQTCWRWdRNn6eQyt2EJA9VER7SDcbsVoMKAoCk0tXhpdHs696EI++OAj0tLSiJ14IgAf/zCDW6a/R7ChmXTM9IlKYOMPP1Kyo4hE2q/m/MPxSwYirA5OGD+Widfq1U41j4/gwi1oTj+SpQXD8WNJOWkIZ506jAnFZcwcNhrJ7z4ihBIZfaISgWT2fOEdbpPNkYQgCJTZLKRkp9G1f1eGnXQa0Wl99I2NTojcU7AdPngw0+z/w+PyEDycnxtRaPUVEBFVle6KQgutvhiHkWKwStPI9vhI9PqoXbEKho/i21kzueTG66irrkH1+FGDQfiLcxgdLrQAaNDQ4ATAKBlZkhuH0L0zEeXVxNfWI3l91OTYWfzArRz93ldt+67avGWv360qQJPFRFXSrkiuMwaM44zf9IseO4DBw8czfNV6Nj3/XyoOVCjRNMpLSzn2+st4/dGnyIqMY/A5l7L8zMnUZKVilGWszW6kAyxUGDLf/IMQEDBKBmIiYumclElslP4ilr9fjjxnKabnrsMUE07fgb0Ib6jFkpzBOpuKYPSRn5dESkI0NouZyKIKilq8LHG6KCguZNiwIbzwxJMMHjacHdu3ccedd1NXU0O824fH7eazoIJXUUljP6u67obUWjo7Njm1rc19/m0Im1aDPRylqQqxz5eIqXr4bGxGKiLiQcl++nei8teEeP5bkUSBiAg7qVlJ9Bo1lKiBx+gbtiyDmZ9AYiKcdXNb/+49ehEXHU5VrfOgV3s9KAgCgtGAFGZFslsRzSYENHxuPw1+P6LHjxoIHLCvwMGiBd0J1a/BlTfehPrMM5SVlQMakapGAroPyb9K8NY0CrdtQ5aDhEdGkzbheDa4ZTI27MDk9hDW7KYqI43giZNQNBVJELnlwbupDO49fwuiSIMjjHXexrYmj7MeW1TMHt2eHHommY5YgkcHOeGL6bhaPLCXLLr7QlQ1Yr0+Smf9yCnJD7Dy7hexRMfgykhlY7/uRNbU47VZSRQOj2fycOPfKZQIECYa6Gq1kxSbhiGgr0rE2CSk8u2oG7cgDelHVJaDTIOKHBlFQqIR0iz0HDuM1IxcwiQHqtfL9s1LiN2wjl+XbWTx6q2cNWUKflnWT9IajteiKFg13cbpQ1dbHii5qkqUomC3WwEIzvoFNq2CoB+hsg6hpYnAVTdjmfERAG/d+3KHPcwlUUSU9NwnAIqqoqrqAVdTDnHoEAQBm8VMQlwU3YechCAZoGwrzJgGiTFQVwnffg7HngpAfGIaSYkJbNz+Vxcr2A8EAdFqxhgTgTUrBUtyLOlmIxZZpcXnR2n2YC4sJ1Bdj+LxHTbahzZTlapCSWlbuw1dM2jj3yeU1FZU8eQTj3D7HfdyYfZgao53UBG/gOqqUryLlpDm8dJv0DFIgsgn82bz/ZtvYPP49pquQRBFRKsFr92Es6WJKHsEG559nNSYeAwTjyauSw8AMh26JsVoNGKdOIHC4mkQ3HvNob3RF4j3B6mpc1K4cAU1rkbiHZG4enYlY8lymmLtKAGFOOnApt8/rvy09/5HAv9KoQQEHJKRcKMNe3gsxoxMvfXHL9B2rEfbsgmG9MPUK53kZ68heuEyRo0agupqRnSE73GkHt0HkDu8hO4DFiK//BpzF64g2CSjKLtWlQerNszuhCsy5oAXp1NXe4rxUYiahqAqqJk9EbYuRivY0dZ/y7qNSAEfuYpMGey1dLckiZhNRmwWM/YwCwZJRFE1PF4fbo8fXyCIIodCcY9EBEFAFEWOmnw25uhEtCYnwkN3wsp10OyB9EQY6UaTd6BNuBLR5iA9IwNhwYqdMvbhgaAXuDMlRGPvnkPfvHRiEqIp7teV2LpG/GYTceU1NC1aS/PKzfjLqnXB5DDRmPwRFRx835ojBTUQ5I2nn6VHegbHnzuF+LzuxOd1B6Bh/WpsGdlYzDbWlhVy239uIby+ibigvPccUrtp0Tb6GxlmjyAmO4fi119HnvkVq/v2YfDZF6NFRiLGxWK3hHHBmKOY8eZ7B1TauAkoApLcXqQNOyjfvJn4AYMZNvE0ZtXW0tTYhKNLDyJy8vbvBK1oCB1ydA2Zbw5j+moqJlTKHZFYOnfCHG8DQF2xCKFkI8Enn4UwB9L4MQhR4VhH6V7hbQJJ6WbYvgUi4tB6DcKSkM7ISemMnHQmX7z9JlOunkqL92CkKvpzFgkQG/Cybsd2Tge0yAhUrwtRNCKUbkGJy0RorkcLBBFMRuoDzfi9LZhUBctejmsyGoiNcpCWFEteZhJ52emImoI/GKS8uoFtRZUUV9RS17Cz4uZfepkhDjKqqpGXlcPQscfpDa88CTU14AuCqkCzG35dAfF5iDYHAJUFBaTICpsOo+9aMBowxUUR3rcrMRMHY+rVmbHxOZyc3JsqbzPTpQZ+aC7FlBCDaDbRuGANvpIqVN9f+7v8JyMKApIk/sbRX0VR1H0WNtwnikqRy80pN9xAzvtvc9E55zC2/2Dyc7oQ3aN3W7eFP8ymbNN2zB4/7akak+ELkFpew5bqYobFZGDt0x+b+zlqYiOwLVhE6VczqcpKRjv3LMaddSUZ6Zm65H0Al1OAHh2oamCpqOXZp57irfc+JKVzdy687wV2rF5Jdp9+f0819yOQg+5g8OijjzJgwAAcDgfx8fGceOKJbNmyZ+qf0aNH6ynRd/u74oor9uhTUlLCsccei81mIz4+nltuuQVZPjgVJ+uBelWlxedm6PmjEM1GlM3bUbeW6rLklq34p96E/z8P/X7n9/8Ht1wDW5fAV28g3Hwh2jfvoTTqupBTLryE5049lQOTgfeNqqm4fW48sv5gB5qaCXhdyC1ONGcVaks9TUNGI5iMyMEgroJ1OLxuNvLnDrYGg0SEw0bPzhncfssN/PetT7n76WlMveF2zj5pAqdNGsKkUX3p2y2bhNhIjIZ/pUzbMQQBWh0w+YOEeRb0sMW/C1VTyczI1p1CgWBOZ7TYKLjtfBg/GCQBzWyBKVMBaCgtxrujBHPg8ErlL5pMmBJisPfIIbxvV27PHcElmUOJNtnoFpHIHfZufBI/gusHjKHr8EGYU+MRbWaOkMXiYYfJaCDcYSMlIZrc9ET69uhE5+wUkuOjiQwPw2Q0IAgHdnO1oIzc1ELBohXcc/d9jD7rNPqfOZkf/5+9s46Tql7/+PvE9O5sd7MLLCzdJd2KgmBgYIIitl7Ra/e99s/u1muAioooktLdXduds9Nz4vfHWREUlDT53Nde3JnvnPM9szPf83yf5/N8PjOm7x8TLciobh+eI9kNaRrVoRA+l4eF9caqF5eRjSZoRFbXIcgSBa1b4ItykhyfBoDH5UJXFI632FGLIbJXqGm8N/1z8jp1YPqMLxAliZzOXRFFkZUrVx7XOX5UdD2an78CTvhdZeHChUyZMoWuXbuiKAr//ve/GTp0KFu3bsXR5FgJMHHiRB544IH9v9vt9v3/raoqp59+OomJiSxdupSysjImTJiAyWTikUceOe455iNg01QiXDU01jUQkZaIf8129IhYRF8DQnI6Qv/hyBed/ssXfzUDisqgtNIQVqioQPj8M+g6CAB3VRXrli2j6rhn+evQdR1fKMCWfbsBMOVksTc+Hl2VsAgCflGC0cNJBtYuWMTe4n34tcNrTQiCQK5JJiY2gjuuvY5+516+/7nI9LZEJDYnM2Up8TFrsZllwhsa+drlQVHV498lHQY/7sxkWSJB10lXFBp0nc2CiPon4QccFpKIaJIRrWYEk8nYWaoqWiCIFggZtuWaTgYGf+BQLawCwgnXlOms6dR+PZOi67eS1qo15nMvwbdoIaaSSqTCEjRdRO3bB7PZMEJ74qJx1De4qfgzpcQEAdFiwhwfhTM7jWszO9ErOhOAwuWLCFVXkTJoOAk2O5dnduXSSzvzTnQWT06+DrsOq/7Y2f+lIAF5JolQZBjnXTie66feRXhMHLLJRNDvo2jHVt7+z8O8NXc+tS4v/mDouEzv9JBR+ta8PrIraijbXcjwOYswSZfTtW071m3YYHx3juRYmka9P8jmRg/ith3QC6TwcBAEatvm4uzSDT0tiawO3WiVaBgZPvLqS2hB5cQRMHRA1di1ZRvjzj6bfj17ctOVE1EliUuvvfYEneTvhRMelHz77cHCuW+//Tbx8fGsWbOGvgco3NntdhITEw95jNmzZ7N161bmzJlDQkICHTp04MEHH2Tq1Kncd999mJucRI8VOjpBJURpfSVf/G8a17a7E+uoflR/+DlhkyZgv/GKw7/4+VfgzMGwLR90FSQZ/V8PIiUk46qu4LLxY1hXXPyrnI0TBVVTWbBoATvWradlxw5YH7ufHYtWYNUhoOt07WtopXzz7jts9bnxAWaMnfnPybayJJJqM9OtVXO6DTnTePC7z2HebLj0WoRWedhyB9JOsCIUllGbm8XwvSVsFAW2nOCgRBAELGYT4Q4rkU4HkeEOWqgKyR4/NYqKNxCk1OM3uC1/wuBEsJiQnQ7MCTFYU+KRI8KwWK2IAYW64lKCZTWEaupR3F72qBqJGAGJAIiihFkyIUsykiii6zqKphBSFSMAPE5FXj9QWlzKmb178p933mLYqLNhwiSqbpuCo6wKd24mYkIaicDGxfNZsyufYq+fsqY/sZHZZD/5WUc3HHh/z5hFAGdkJG9eP5VhA4ZiNhnrwdr3Xyf42muYfT5K3nyV+CEjsI8cQXpGCy4bPZ6NX89m1ptv/3UYf4fBSbQf+gViTDLJEQ5adGnL7fc/gsUZuf85s9VGdvvOTLnxZty7tzOjvIayqjoCwdDxfR40HYumY1KC2IEqwVCPXbRo8VEfR/X5ce4tIWqzoYurhILU52bT+c5HiEnP2j80pIR49dUX+e7Lr5syJScBms7CJUtZuGTpCTncqZbgY0RDg+FSER0dfdDjH3zwAe+//z6JiYmMGjWKu+++e3+2ZNmyZbRt25aEhIT944cNG8bkyZPZsmULHTt2/MV5AoEAgcBP9WKX69clfBVNodZdxzNvvcb5ky4iNisD6bYrsHQ0GNmBRi+NxaVs/GEx4TQSnmim5fCLEeISoVVHWDQfbCbo1hGhicX9/JP3sC2/iLLfcYUOhIJcce21LF6ymJzhQ8gZPuSg570uF19N+4RwXcMHpGCIkiVzMKkuQhA474qJXPrYkwDoAS9CwSpY8AO88xH8bxoMGISpZS9SK3fQY+kmKhxWJI8fQQmesEVSACxmmZSEKCYNHsgNz7zMmlmfsnfdIsIKK/DU1qMGgqwpqaakvIYGt/ekZWqOBYJJpluPbjz/5FM0y25OWFg45gPKXAs2r+bCpx+iccNOvLsKUTw+ilXNCMRkM2FWB1mOCCKtThS7A1XTaPS5qfXUU+9pwB3wHpfOzKamH5Pbw9R/38WgYWdg69qDwglXseedN6korMBeVccIoKiukUV1LgKKiiAIyE0EaKvFjEmW0HWdYEjBHwgRDIX2S47/HujXpSujhhq8GC0YIP+d1/C/9z7J+ftQkYjLL6a+ph5X9854ktJxmK3YMtLZIYq/6MIxqg7Grf7PlBD6EYIgIIsSkighCiIxmkqUprFFU9HgxGfTMNaIQrMFa5ST8A4t+ffLb2FxRqIV5SPM+wDBpKN3OR2hRUcSu/fhxhdeIX7aJ/zfm+9RXd943JsFP7D+x1+O8fLCgIygQnxlDb7Fqwn4/VisNvr/b+b+Mbu2b6a8qJAbXnqOzYuWo7o8f2oy9IHQjpLoejRj/0ic1KBE0zRuvPFGevfuTZs2bfY/fsEFF5CRkUFycjIbN25k6tSp7Nixg88++wyA8vLygwISYP/v5eWHZkQ8+uij3H///Uc1P38oQGldBZ9Om87kf91MbBOhtXzXXu4dcwlqfQU1BJDz0rjyyotoKTdlaPr2gfmzITwKLS5qPzFn+cq11LvcKL+znsOSpUuYes01DBo2DP8BdV2rpvHRhx+y1v9TYWAfBgnrwG4gAWiVEL8/IAFg1puwbhuYRbBZ4MJz4YelkNOS6NaD0dMXULo1n/xaNwiGXoAgCIgHnF/T9aNO5cqyRFREGB1aZTHummuxhDvpde4VdD/9bIKFO6nasRZl1zbMa7axYv0uAgVlfx7CrWi0qF5y0YV06dztkEP6t+nCpVddybtvvU1kbT32QJCdGlhlM7Hh0WTGpTEoIp44ZwxKSjPsNhnvjs1sry1neX0l+6oKafQfvwBeKKSydftOPnztFSZMuY6Wl00i5+LL2frtLCwZBsvFomoEAiEQwGY109xhwx4bQVRiDA6bFV3XEapqKalpYJfLi8vtJXAc+g5HDF3nu7lzKdm9k5ScFsxZ9BU7GwtplhyLw1WPhE691Uarp57D3qnr/pc5yyuRm3SC9mF0mZkkCVmWEEUBXQdFVQkp6u/+HT4cZFHCYrIQYXeSbDKThIBZ1wgF/JSrIRpDfgKh4AlzwBUFgZAoY7LYSXNG0qNdLs8/938407PRG12I/7kHkuywYjOCIKPHxCLEpJHR7TTu6HYa9Z4Az77+9p8ig6lg6BwVa1CxcSt9Rg7j7f97lry27QGYeP/trPxsOpaKWjb5gqheH/rv8HdvgxFnHYux4z8BJzUomTJlCps3b2bx4oPTbpMmTdr/323btiUpKYlBgwaxZ88esrOzj+lcd9xxBzfffPP+310uF2lpab/6Gk3X8AX9PPD4f8lITaam0c3aDZuY+fVM0irKqdc1dkhwli+ZoWMn7ScHNlYUoeW1RNVUqixmWmIEYFt3F1Pf6P1DvpCPvfQSj7300m8P5JftyUmAq7ycL196jjMnX2c8uLcWtuSDLIPbB6EQfPsuXPMgckwagZxsqsXlgFH6MZtk7DYLNosZURJRFJVAMITXF8AfCKEegWS2KAqE2a1kpycy/rTuNOvca/9zkiMKW6vupLfqzsWhAGdXlfPdN1/yr/sfpqS8+siEvSTRMOYymxAkEXTQFAU9qBiL0XFGNoIsY46NpCEhEoDKqlIWvvkc7jAre9q0YGh4Cn079eXhbmdwQUprnt5yHo1V9ezTBGKdMXRt3oH77ryVSJMDe2Q0ke3SkGxmNH8QT0kF65ev48a772J3eT5uv+e4b0QhReXy62/ky/kLue666+jXrx9tzxi1//mCtWvRAZvFTFZqPIOTY2mXlkCnIcOI79SDGlc5pfMXsHnrdr4vq2brriJKKmoJhk5yYKJDywYXX7z3DlPuf5ievUeyWnFR4PMRXVZKeWYWaYOGYO/cFa/fy71ffYjly++ZNv0LugPrgDyTjJaZRnZWGn53PRaLiVBIIVTXSLCmno2NXrz+4B96czXLZuIiYjhz2Om0zGiOvcFPaFc+HpOVIsUP1SXsrSygsKYET8B7RN+xX4MoiDgsdgJRCWTHZ9AyOYPJ11+Ms3lL9GAQ4fUnoK4SVhVCQyOs24wwezJ6VnOCE67CkpnL+PMv5MV33oM/ATHaj2HwCEAwxOofFtO2S1eSUlIIc4azZ+8edFVDD4aOyyn4aOHixPjQnCrfHCWuvfZavv76a3744QdSU1N/dWz37t0B2L17N9nZ2SQmJv6CmVxRUQFwWB6KxWLBYrEc01zLqyo5/YLx+3f6ug67AVE36v3r9+RTuHkzGe0Mk7LwqQ+h3xyifPr/EH1GFsJdX0d5db1B9DqmWfxxqAWidbjrkQfpdfZYYhOS0V11CAmRUF4LNjMkRYPmRxeMzEppeRVurx9BgIhwB6NHjeS0Th3w+hrZtmMT9Q0uqmoaKCyrprSiFrfX/5uBgyRJhIfZyEqNp212s5+e+OFtCEoQ0wxad0a0WAlPzmDcldfRe/AZXHzWmazbuPnwWjACCGYTssOOHBWOKTYSyWYBXadtUgbuiio2rF6L5gsc+05JEMiQRWoiwmgUjAVZEiXq1RD1ZiftP56FUlVN6c2Q3LMveSnNiBg+hGUFJVgbfKRGJzJhwgTantH/F4cWrWbCs9M4LTuNVxKiuO3CC1kSChBUjt/CTtU0pk+fzvTp02nXrh1XjBuHu6SELT/8wIfbtmE2ybQLs9EvrzmjRgwhOVhNxhkXIEbHEw+06jWa3lWliC/ch6hpBF0eypvaRE8mvCGVT158mT7nnkf7vHaM7zqSBVt3knbNTeT07kNsqsEXeHX5XL58+VXkjTux+oMsBdpYTAhZaaxasRabM4JQMECgvgbJbKWxMJ93Hrsf1+r1FJXV0Ojx/eq1ZAElQEiWEGQZmsQGdU1DV9RjCnbDgFgEPLYwnr7mGs554K79z9Wu3Uv1zmrq6utZu3otq3dvQFEVCmtL8QX9x0wyFRCwixJ97E7Sk5vTum0vunfqSHaf7k3Pa3DBZGjZGRbMhd2boHU2vDMTlm9CSUzCMikXKTwMSRR/V97LEUPV0FWN0n35vy8x52c4XjXvvztOeFCi6zrXXXcdn3/+OQsWLCArK+s3X7N+/XoAkpIMc6qePXvy8MMPU1lZSXx8PADff/89TqeT1q1bn+gpHzR39YAvdTOMBpuC0nJyu3XhzP79mHLFRDr160dYfAJJ50/YP/blp58GXSQ1OZWSkpITlk79PeAHtumQJsjEJiQD0FBcQERsJEK4A8HtRY8KR09PRRREdF1j3aZtNLp9OGwWrr/8UqY++tT+42lKiLr8HezO38H8BfP57Kvv2FtYQX2j51cXeEkUcNgsxMdE4ExvCj4rS+C2x0EUIDIc8nLQHVGo51+BnNuepMwsLhw1irJfCUoEkwlzbCS2ZqnEtWvJ4IGDGNSqAwNTmxMVHoGmKFx/6QW8Mus7lAb3ITkHoigi7l9sdTRVR9N/UrdN1nXcgkALUWR+sIagrhETk0CrWi/mmQuIzS+gJjGRbY8/TNh7HXA6nFTGRlDiDMPmF2geHk2fXu33nzO0chfKjFmwcBH68BEIedlYzuhNl8GncdO117DuoQcIneDunI0bN3LDxo37FwVRELBazLSIjeSOp18lIjMbXVUMFVgAXQNBxBqXzJgRo3Gu2kKOJPCSLKOqJ9fzVwfq6uo4+5KLWTV7HlnRiWTd9J+Dxmiaxofvf0Dh3hLERi9eBCxmGVdMJBNGDcPmjADAZLZgijc+97bIaG584R1Kb76cDfNXUBkMsVU9NGcqEkOlOctmZl9EOKaYCCS7FQQRzecnVN+I0uA2gt2jyB4lAQ5BJCw8Bl9R3UHPRXdqRnQnI2Dv4unLkOWbePHtd/j462mElBAh9diyVCaTzL3X3Uj/AYPIad+OiJSE/ZlhAMxWSEiCkWcZP+tXw6w3YFg3Iyhp2pyZzBY07c/uQw7oR+9q/GeDztG1+f5jMyVTpkzhww8/ZMaMGYSHh+/ngERERGCz2dizZw8ffvghI0eOJCYmho0bN3LTTTfRt29f2jVlIoYOHUrr1q25+OKLeeyxxygvL+euu+5iypQpx5wNORYUYSwQHoBAiI2z5zBlzjwqLSb6DBvOKy++jDMqiqk338bGdRvZsn49KVmZXHzehXw582sCSvAvYX4Hxo7Z6w+hqiqSJFGKjFcPEhnpROzYCbFlS4K2dMIBQRApKKsnpCikJMQw+tzzAdCVEHpjPWJUHDE5bYjJaUP3wWO57l/13HXDFN6Y9jlur++wG0cBAVmSSPIHMYcZwl2UVUB+sUG/j4+GjGaQkwhbt0Bue7auXslHL7142OsSZAk5IgxH62zOv/h8Hht3JQ6b46AxoixzxQ038e72zXh3FqC6faDrpAHhskip3Ua4w4bdakYUBZSggsXjoyAQxB8IoagqpTqcoekUCRAMBVgZqqWPOZaM9l1xzZxNbVoyutlEScscBtjDAChvbEAQRSwmM+kmCybRWDRC074l+MybiNUlaElZCKs2oKxYQyDcSeTgjkRnZdFOgMVNAlYnGj/e1mRRwG6RGXTjjURkGmVVQZIhGIAlc2HNLBhwDnTuS2r3kbQ+awNrdhVhLa9p6sA4ebemXYBT1WnYvI27Hn6QF598BoANWzbw0uyviHS50UrL2ThrHqE6F1pIQQQcNguZqfGMHmG0+2srlyA+/zhkN4MoJ/oFkzHFJnDnHQ/zUsHlrKltYEdIOSSJt0GWiLLbKEuLJ6JFBgntWvLYGRdgtliZuWMD386dQ+n6rfgKyghV1x9xYFIEZFjsZMYk06BF4S+twZocg7pmA1pNA2JGBkJsBFJMJDmDuvJE/054L3Dz/oxPUVT1mALVC04/g1uffOygx/SaWiguQUhLheiDjRrp0AUemgqDOqO2aIn19HMBsEryn9Mj6WdIBWyAD/gTGigcEU4RXY8QLzXxGvr373/Q42+99RaXXnopZrOZOXPm8Mwzz+DxeEhLS2Ps2LHcdddPKUpJkvj666+ZPHkyPXv2xOFwcMkllxyka/J7wI9BiPsRO3WIVzWq/SG+nTmb7p16MmLgUM4ZMYz/Pv4fzHbDh+bZF59nX/+97C3dR4OvkZCinHCG/MlAdXUN3333LSNHno790mtxxMVhz2mBIEkA/BgOKqEQtS4/dpuFO/79b1p2NEidwhcvIOzeCW3bQWw6elQqQot2OCIiuWDMGD7//nt8/sBhuzQ0XUcLhgh6fEhCU1Cybp3xb1oCdOoFL71ttM6WG71D+SVFBDzeQ19QkzeKNT2Bq6+ayINnX4ooiNQEPaxzVVCxcQ37WmdxV2IXEvPycHZtTaimAS0QhJBKlFkmI8JBUk4azTOSDME4k4yttIqCylq2VdWxtbKemrpGAopCiaahegOEquvJ99XTxxyLs0cvPIpC0GHH5vaSvG0H1a4a4iPieG7YuVz+xicke71EBwPsXrKXTm1bIJ81GPWxh9GrCpGCbuQ7pqI6Ygk4jO60kCjgMpkgFDipKWhBEOgsCIwbe6Hx91n7PeLeHfC/L6CkFFplQu17EJcC6dl0nXQHS0vqML/wKqLgPyjr+HOIgoAg/uirpBOjaWg6R6zvo9FklRAI8drzLzGm7wBUVWHMlZfTJRgkVdUoUFUCmm54zOggSCKRTgeXjh1LpwFGUCJuWAEVZVBWChmJCPGfwvnXEpvTijGXXMb6ffdj8odQfp75EUVkZxi1uRkk9e3C8JEjuLHTQDIdRpfhoLZdefzsy5mzbikX3/tv6lduRqlzHVF5UBElXFYbSTFJjLnxAqzJMej+AMFrbwPFBIEQWnIGer8ByCM7Y23fgqumTOKTmV8ccwln6abNKKEQsslE7evTsL7/P6iqwuZzQYwTeneFLq2gZ3/IzjFe9OE3qO+/gfjA/chWY+3zu90nTOTyZKISQxqh8o+eyCn8AielfPNrSEtLY+HChb95nIyMDL755psTNa0TAg2oQMAsmejfpy9PPPwQrXp02f+8d+N2pLgY4pLiefjhh7jr9jvZU1lAvafhmNOqvyc0Xef1115n5MjTyerzk6ZMwN1I3b58fMEgy9et5+0PPyB/Tz6PXXc1Y86/DAB10VdI02dC51YQaoRF3yG0zEAp2I085GxMcdFEhNspr64/fFCiaaQ0uPFWu7AntzQezM2FnCy4fyoMGr9/rJhopNszo+NYqev4DnE8QRSR7FbOOedcHhhjBCRrd29k7oq5uJxh6KKAeet2SOxCkt1JfNtcGldvI1RdjywouOIisbXLYUCHFnRonUVibCRWmwOEMLR6jdKQQvGajTz6ymtsa3CzATD7/JwvOBnvNFLsBRtWEIpwEJdfgismAldsJO/N/YRbzp5CbpsOjOw7kGUfTCMQ9FO9bDWhUV0xpcQgdWyHsGMb0q2TESZegAwo5UYqPyqvFUUOO4Lfa9xwTyLqTBIBrwd7TCxUlcLsuVBRASYz1LuhcjPccyO8/RUAKTFxxGkaNYc5niCALMvYLWasVjNmk4SuQ4bHhy8YokHTjSD+KO6rSjDI0NGj9y9mDmA7sPNn40TBKA/aw38SauSLT40yVEo8rNoC4ZFgJP5wle4j3mpBkkQygHAMPoALEEwSSdHh3HDxBCZfdg02S9NNuaGOPeuWk9C6PbHxyQzr3If7plzH1KI70bx+VNX/2xwTQcBuszP10X+R2rEZekgheM9TaM5MKN2JuGcDQslWNERC7TKxtoeM5s2OywG8rKSM77+cxYixZ2LOa0kovQMmexmqFkAq3ILw1UxYswrKy+DWu40XmS1Il18DQCgYIBQMMv2TT46bcPt7IMiJMUb9I3HKkO8UAINb8MjUqdz8oNF+rAVD+FduQl26FvXbuQidO2B5fCoDxwxlzNwlfDjzM/zBAIrq+UtkS2bOnMnG5StITE3l6+lfU7RuJ6aQQExSPKOvPpdxF18EggmxoART5E8pXWnfKnC5we+Hj2bD5r1wdj/EngZPyBYWhs1mlD8OB1XVqAuE2NLoRtF1TAA9esPX8yAy+pCv2bV7NyH1MO+rKNC2TRtevvkuJFFkjruEpesW0u9/M2hMiGPx+aNIX74eX+fTsUVE0bF1Gwoi5yBbTISZZbLTE+nXLY9BfbuTmdcVc3gKWKMQmhb/bICzodZs4fbHn8QbCNEsKp43rr4dURBZtmkFnldfwm4zsSm3LStH9Eb1+igs2su+smKyklLZ4GpkuQCxmkKkGqJHvdsISnJbIibHwzU/2S84Eo33O691Lq26dWD5wsXQ+NtupgLCAVocoOvaEX0SdaBQF/C6GogC0GRYvx0Ky8Bigd2FkBoHcdGGsV9EFNkt82gRUth+CE6VKAhYLCaiI8JIT44lITYSZ5gddJ1QrYtgeTVCnZstLs8xlX9aNl3hQoyy68/zZy11nVRNY2/+DnRNRRAlCEmwciNYdkGsE3oYOj8hbw2ltcWUOu0IgkADhnuvG4wMnNlESmQ440aMxmax0VhXjXfpEuqfeYJKi8SehDhaNW9D89vvZeLQMXz01ddUFX1OsVfnNx1PdJ0zBg0gt4chfuh64m1Elx3JZgNBgsh4dI8LuUUMttMNGYPX//MsMapK3a8d91dPqfHpS28wYuyZOLrn0bCkCGa8TahwF9QXI+kCgi7C3OXQYxH0OQ0l4Cfo9bJ50XzuvvZaghU1LP0LEv1P4c+FU0HJUcIkyXTq/FN2xLVgG+Ks9YgeD2ZE9O9mEzp9IKb+XZl4zQRWrl5LjbsOb9D3p+eXCAhIgsT4cRPokJFHp6y2dE3uQHaXXHLO6oBkMQEw/ooJtAgPY8Yn7wIGl0RYvcNoId5ZABERgA5rtkGWQd40S9JvhuqarrM+GKKguJJLLj2HSVddxWn9RmJpCkg0v4/8h2+FfsPZt2sPr331FV/OW/yr76vdZsNkMuZd9tE7tFu6hsiSSsSgjq26nvr4WEp2bCGnWx9GZLVmTTBIbihEaZSTNi3SGDSwHy26j0MwH8BlqqtErypBcYZjSszhyltv54k33qC4rIr7p1yH2EQQTFi6htp6P8VmmJ+ZQEWDh9Pb9+WRbgP3z2nH1m14/V5WuaqRy3bReV8xXfMyEG+6Hq687JDXJJtMPPfY4/QefQaqP4B+mPZLURAxSTJWsxWLbEYSRTRdJxAK4A8FCCqhXyVka5qGx+tn2949pOS1w++IwuawI+RmgtcHdW7olAtdW8H65dBvBB2HjeSsm25i13/+y+aQesBcBOw2CwMjHLRslkrW8F60a9uWxNRMwuzRhLwBfnj7BTZs3o1e62HHrny8/uBRBSY1GOTFn5ddf4SkaqjBEDW1tXiKdxOW3hIuvRJWXwepsdCjLTRpWMjWKAKpGQi+5dgVhQoOcNYWQDSb2JeeBFFGoPhy9XaazfiYRC3Enh7d8IbbyXj/U4pHjCS1fVfeu+1ezvt2PprLw87f6EzSdJ0N8+birqgkLCEef0QE1toCBEFCEgT0lGzEhiqsD04FYNWMOSz55BPa+tyA9osM0ZEgpCqUrV9D/sJlZPbrialrKtoMCcHvJqSBEh4J8RmoVT4EwYQdqK+uZsCA3tTUN0J9I86QwvHQmyXRsJQw7deN0VFUjZCioqrqSevYlSQRuclkEAQ0TUPVNDT1yIL3PwqnWoJPAQCTZOK719+j/2hDzyFicBu889ehm2LRU1tDeBzK53Mw9e9KWHoSSVEJtJJNSDoU/MFz/y1IkoTTGsagyHjO7NGdHldfiD0tHtFqiMYFdxahCwKW5qkQgPgWhiBeqLIMMSsJ2SyDywtd08AXgIhw1JpKRCAlowW2sIjfVF8NKSp1Lg9LV2+mpOwBcrPfZvTZ59Kr62lsXDSbL4oK2PPvOwgWllHjcv+mpPWqjRtYuWkt3dp2ol1UGntYTXh1DVEl5Zz1eA27erajJCCQ060Pw+Ka8YhqSFzHRUYwZsz5NO92thGQbNwAn3wAFh9EWxEWr0WwWFCf+x+W8Ag6d+pI2aw5vPnOO/QZPJjE9HSaXXUNmVdMQl04l3ZlRYwZMZrYmNj9c3vv+efZtGEDGYCjpgTPHpEftqyi6xm9jQHh4QddixYMIjZZLEQnJWFNTyRYXoMSUn6RLZFEiTayhUBYJN1t4YgRsbgcEYRUherGWipd1VQ31v6qEJum6Xj9AWbNncvgUWNQcvLweX3YI5wQGwXVO2BHIZTUwPAQgbbtsUQnk5iZQbXditTo25/KN5kk7r7+OkaNHEF6q9Y4YhN+cb7RqamcKdp4JCqOS84exaffzjkqzZPDGU3+iM2SSG1IIbaylg1rF9I7vSWcfzFsXgOLF0J4GHzwCvqN9yDEJTBoxMV8/MTrxKsqFQceqMlkcVSXHqQ7jYC542ff0ujzIaoatooqMjZWUZ2ZRqm/ilQgI7MZZ517Hnc+8dShpnYQ7LpGWFkp3739HmOn3oI5NxnPtK+x28MIZbVHLtiIadyZCBFOGstrePSRp9jhayQOnWNVB1E0lXV+L5+/+Co39euJrVdratNSMfsaoDwfzRFJQLJjuf16wnv3IBgIcO3EqyC/FLei0KhD2TGeWxDAJMs4w2xERYQREW7HYjahqhqNHh91DW7qXB6CQeWEloZEUcBiMuEMN4jsVovZ8BTzB2n0+Gj0+AgElZNK2D4eaLqAdhTdN0cz9o/EqaDkSCAIRspWEJBkiYzcFj895wtAvRtp5TcgSmjN2qOXGPQpkzMMZ5iT3FAIv67/6YMSkyQTFRZJ/3HnMOjuaw2BMUAPBlFeeBXl+Xcwf/MJAEHFStemXWVj/h6ktTuJiA5HEHUor0V3WMHrJ7h7BybAHBZO+7hEdoRW/+biFQopVNW68AdCVFY3UrL5P0wX/otLENgdUhCqaolpdLNZUX+1pS9KUWj0+Ph4wVy6te1E65FjCQb9KJv2ErZzN5ElJcQVxGMSjBt9uD0Ma0o6ZeFxvPn8C6RmN3k9b1oLp48ASYOWGZCcAGW1SA4bSmUZUngE6ekZCMCsH34gtVkzzhozhuuuu47+ffvSfdAwujfNqSJ/H4/eew/r1m1g6aZNpAN1QLOAn3x/PaaaX6oYeGZ8QcNz/0dhi0x6vPgWAJvL92FJjkO0WRA8BytRioJAoslKgjOG/s5YMiMTUHM6IITH4qjMJ21MP2I7tGTz+g1M+tetVNRUoh4mYxIKqXwz61uefAbCE1Kpi4jAHueE5DgorISyOogLIewuwVRVCtHJ+BwykTGR1PuDqAHjuJERTm596FHEJtI0gK6qCHu2GqtQs7bYE37SpumUlso8WaI8pJyw3aqm6TS6fewrqmTe97PpPvh85DAn+i13wZ7tUFiOZqpB93mQgW1bN1Ho9pOv/Oy90XVQNS7r0d94j+rrsH85i6zSStB1YgtLqU5Lpd17H+FIzzTGBANMX77UcIr+jUyJDOzTFT6eOZOxU2/B2aszxc3TkdITMQd8hJJFbLdMAWDmpzPZXrKbYr+bncKx639pmoYr5OPlH35g1Jad5OS1QBvRi7qSYhwmMyGrCfv1FxE+egSqonDVZZNY/t13WDWVCAxZ+mOBAJhNJmIiw8htlkLzrGS6delCh5w8dpUXsGb1CnbuK2PrriLqK2uoCYROiK2EJIo47BYSYyNp2SyFsYOHMGj4aCw2B9u2beSFt15j9fqtVNY04PUH0f4CPJm/C04FJb8CQZIQLCYkqwXBJCEIIrJs5ZOFSxm6fifNOrQAqwVh8yz00t2gKQhaEK1Nz/3H0HSNKkmiThR+syleEH7sRgDQ0X7HCF1AQBZlunftxpn/nowgiYS+X4Ty4ltoWhhsXobojENfsQ5aZtGqQzaW5oZi7ndrltI+zIqlxoXssIISQK/yEWyRgbdLXxxARVEhG2bPIfqIdlQC6CKoMnrQhMdkQwHa9+7Fs3ffxgvX38jC775DEXSDpPgziEBzQNahpdvLso8+xnfZ1djCwuk6fiLBfiNZf91EhOJi4q+YSOsxPxFo+2c256677sXelKXwLJyOY+YX0KM1VNWBJwDLNkHzVPRIJyFPAyYgMyVl/81TVVU+mzaNz6ZPp227ttw6ZQqts5rx2fvv8/yHH9IYCtEKg5Oyo+nfH9AxixpVhdsJBP1YzNb9c/Lv2UVjSSErx/Qness6WuR1pFjzIYc7EM2mX1y/WTYTFp3IoH5DuOj6SdQt3IkgJmCSZaJG9CT2bOPzmdGhDZdv2MhTLz5ndG0c4vav6Tr78gupr64mMjYW17mnE21VIDoCtuwGuxkcdvAHELxGViPSBM0iHVgrJNYHQoiiQPOcbERJQvP5CM76CGttHcLSuVBeA6kJcM4V8KMRJOCrLiPVbKLcHzxhSpu6ruP1ByksrWLX6m0Ub1lPZve+KIJOaMhItEAA8+gLMKek422o56077mCXz/8Lbgo6aKEQ329cR88BQwgE/FS0zcadGENcYTmNkeGUtW1Jz6aA5KM9a/n0/kcQ1m/AoSj7OSU/fdMhFojBEGKrb/rZvWwJG1atpn3XLrR95cFfXI/f7ebZl56jtLYcfyhwfO686ARCQcobKnn2mWd59rXniTxzEN+/9zmRzXLp8ehUIrp1RNc0bplyIx9P/wS/dvzlDcNWwkGbFulce/UVnNZ/JJEpRvt5J2DM+bWsWvAlr7/8KrWhEAU1DWwMHB9v5Ufl6IyUODq1aca4M0cy8sKb9ncZxuXm0WvYmXw17UMe+O9/2Z1fgtcXQNN1soE9x3nNJwqnyjf/JIgiotWMKToCS3Is1rQEElJSuOy0IQxt0wmbxU5ck9YEjY0I29aj+v2Iyc3B6kA4oLIqOmVW6jqFh/lACAhIkuEMazVbMEnGTSY+FMQc8rNFCRHg6D1kjhoCpKak8PgrTyObTXg35aNPfRixfB9iRhu0dn3B24iyuxgT4Mxrtv+G2HHgmbhbdcB95b+IbNYCyWIFUURCIMxq3Fxfefkllvv8+H9lCsY0BCwmM4kRcWTFptIlKgFHcg4JiQlc/fy/ALjk+hvYsGYTTncdfq/rF8fMwgh82oKhI7JxG/2vvoQrJ1zM+N6DCUtOoe3jz7Ll9Rf2ByT7ivKp2JfPF19/w0XnX0DrjgbJUM9qjTpWR3r9bSMYCSnQLAXdbCHQoSVqk5CY4jvEbkrX2bRhI5dMuuoX1+mF/R0qewBEAVVVcQf9DJvzBuc1a8UV6d0x2x3odfXYK6rp8snXNA4bYxw6PAwO4S0kCiIRZjut01pw9dMP4UyMIblnR5SCWqTECASLdND4of3688bbbxNUQijaoUslkapKTVkJkbGxWCJioK4AfCEIBKG2wSDb7i2C8YYJZmxSEhlWCx5BwAyogkDMjzoXApiWLwZRgQ27QJAhKgI+eg3CTNBzBP7aSvYpHspsFoRGzwnlEgSbsnCzVZX7HcacTNGJmK68af+Yxro6Hr5mElv2FOA/lJePrqMFQjz7xhtcd9kkohKSGPTMm+geL64VSyleMJON3XI5XQ0RJpn48OMPWL10BVGBEF4dzCYZi9mEySQhCgLOkEJ4IIimqEgHXGtQCXLfww/z+RefA1BdUkr+nn3ERkdiEUWeeuQ/bNizBX8ocELEGjVdw+xzM/OdN7j5XzeQ2aI5be+4krTsLKLS03A3urnyksv47MsZKNrxyxz8GBzkZCRxz4230HvsxU0T0aCxGuwRmJ3R9D7zUlo278DjN17Drg3bkaobjsv80Woxk5IYQ69OLTljUHeGnzvJCEgKd8O+dejNuyInZzJmwkR69TyNs84bx4atO0kIhCjD2PD81Tt3/sw4FZT8HIKAZLNgToolLC+bc8acxWVdTqN9bntM0i/fLs3nR7VHIEoW9MgYhIKthCoLcM0ZgXNwH8ZfPZ5Xpr+Nqv+ybi8gkCGZiLU78EfEE++MJS4mjj59uhEjKix97326ZCSzr7SEOXv3nHSV2LtuvJ64hHjqC0ppeOx1YhwOtLAoxJKdUF2I7nYj1OSj3nQZUlQ4QZ8Ps81Gq7y2kNf2sMf94o3X+e/Tz+A/gjVMliQi7U7apOUyNDaV9PRWdBx5GikjOu0fY1Ml0tLzSNm7nh1eD8tRD6ql78EQR1qC8QEP9/nxzP2Bd9atZ06PLnz8xifYmuWQNO4CAD789ksm3XITgdIqlEYP4ydMYPZXX5GQmUVYeiv0uAzUNXciqRqoOrrDRmhsfxp2FBGdlQsYZZujkVb/RSlP19FCCorLw/XJ7Tk7tw8Aam0tweefJ6rehX9PIdELlkJOO2K9KqEGt+HbccBdu7+uESeIXH7OmTgTY356XzOayMINbpTZSwisXE/441PpOqAPUeGR1HoaDhuUxKPj2rUb2rYnPKcdfL3OaKE1mQ2V3V3FhhWBauQUkpOaURVmJ1+WUAQj97d58yaKd+8gNacl+uVT4I3HwBuAYCM0RkGLPNi9Eb3bUKzR8XTs2Y/vlm7ar2NyIhFSFGrr3Vx+2aVcNOFiYlNTSUxMJD4ympVLF3P3I49QWFxKMHR4PoEeUmgoKuP1p5/gX/c+hNMaBtYwIkaOJn7AUFJ2byKsaYORWd7Inuo68hWV3hYTRDsJxkcT6XQgyxLxNQ3Uub2s9QUJ1TciNXlF6cCML2cwa9o00mNiuG7MOFb6fegY2ThVU1F17YRuWGIAKeTn0Sef4JVXXqHdAEMaoHDPXi4ZPZqKzZsI55f+WccCSRQJD7PRvVM7epx5nvHgd5/D5x+BFIBhfcGUij5oNLGtOjDwnHOYXfQscr37mIMSQRCwWc2kJcXQsXUzBgw9H8nqBL8bvn4DWiQjSNthwUrUzsNIaJ7L68++wJXDhpNPiAT+PAHJqUzJPwSCLGGKj6LTGUN44tZ/0yPlJ4PA/IZKFudvwuVp5JpeowGQkhLQF3xPsLQadu9GXbWCxp17cQSN/XubHl3RpEPrt1hMZjo4IuhijyK892DOmHI56d3bIjdlIMY/ZOgBVBYWkd2yFZ6A96RlTHRdp1Exbu21S1dgXfw1qj0cKTYNrWgbYlUpmiShBRQC67ZgH9iDOf/7nEdeep6M5pl0b5OHy+1i5fr11NXXEggGCQUVqmvrKC0rP6I6sAw4ZQvdwmMYFpVCy/YD6NCrBTFjehw0Lql7J0YkZ7C2powGXyN6wAc/u6H+qNKoAHWqhlDTQLXbR0XdPELBICazmZQmB9nAlh0k7y1mV0gBVWPTlq0Ma9WSYYMG8OiXsxBtdip7tCcqJhNp1FloEnhkCCa5MNsduBsbWbp8xfGV23TQ/AEC5dXESUZ2KRgMsPbhO8gKBQlYTEiSgL8wH4C+MRkEispRvf6DrNY9QIZJxvpjx5LLTeC6OxBb56Hv3ItKDEJdBcK+9cBUrBHhdAoLo1Y/PFF0mwaPvv4Sn5w9Fkf7nmhrFyD6GiA5GmYth5o6aJ8LC+agnzaS6MyWnDn6fOatuNvYTeuQ6HLz8n/v56HXPkTI7QSKBJIMDfXg9oM/gL5pE8r8LzENHsNFl07hsWdePiklTF03CNU/rF3H0g0bDQsBwZDsV1XDt+c3CZW6jur28v4TT7F65Qro0g5nVhq3DBlDbkoGndp2/2nslp2oXj82h43caCctMhOxd8olo20bOnQYgODzs3nTWj6Z8x0r1m2jqLwGt9ePqhoBx8hzzmEIhv6KF4Ew9P1Oxyda/agIsAKvv/46yXY7ktNJXXk5b37yCWJ9PTGcOGl2WZIId9g4c+AwJJMZSvbB5+/BtnwjyF20BjyLwBoOA0YQ2yyTSGcYsiQhcGwlHFEQcFgtpCfHc9aF12JPa42uaQjPPwLLV0D786CiGhYsxL9lE9aJd9GmTz/ade/Gnvk/HLKr6+cQBAFJlIhHIA6BGlGiVgBFVVA09YRtLk8puv4TIAiIFjM3XDmRh267C1mWCaoKGzcsY0V9KY0FBUSXlVHRPJV9riqynHFomkZ4s2Rolgx92sGlZxNzwCG3rFlDQ2PDL04lixJOWzhCZh6JyS04/7934cgw/F7UfQXokoycngJAfHoap/XozZxF806qCNucxYu56sYbcHRsQ77FRkxiM8Iy22DTFWTRg/n6qxEHDkCKM9Le1QV7Kd6wjqVrlvOhrhucGMH4Uuq6jq7/tpjegWgriLROy2DSLbfiqBWJimhJ1PDOAATfnEbouxXYXr4Hc2wE3SdeSMXDJUzzuTDVlqAcKs1+APSQwg5VI8EZgampg2X/cw2NaP6fSm66rrMpoLBv4WJuq64iJj4B75Q7SMxtd5C67Y/KKWt++AGfP3DE13noCTap2ZbXMH3eHE5r2wWz2UKXR5/FPfF69i6dx7qtq4hRGkkBJNmEL7/MmPcB7/F62UyDLZy0b1fQ++IxSM4whIoStM8/Qo9OhbRcdGcMhB0gG+4PEC0cPijRgIUrV7N24Vw69RtEKDkX875lYLdBUgyYTJARj7ZmDb7pHxF2/gROHzueq2+5HV0Hs64jegPsWLQUv9eD1e4glJaKKTcNFAVS4tCjnKjYUVOyMQHhUdGYzNaT6tyqaTrBw2SHjgS6olLs9rF97kL0lauRI8P5+OkXOa1bD/p36c6Qzl3ZuGYtS+YvJNJmJTw9gaS2OfRpm0PuyDFEtOmHIBpLcHKP/gy46GrefekJnn75dfJLKvH6AvsvfwtGdkJHJwKDNxXJiVck9Tb9oGnc98wzv3j+RGRIfoQhpCdR6zPKfoQ7QdAhzml86HYVg1UCt8HCsYaFYTHLRuvuMSbQBMHoBDtn8BkkZOUZj73xFOzZBu5GeOYjKK0GWcbaMRfN40YyW2iIjjqia5dFCavZitMWRrrZRqYgUW2xUaVr1Htd1Hsa8AZ9KOqJI3D/3XAqKDkQgkCL1rncd8sdyLLMzvxtzNi7jphFK2m7bC3uSCcFnfJI3l1EQ9cKcMbxzbczWbJkNanRcbRMTaLHoP6ExcaweO48nnrueb78+stfcA0EBEyyibjwaFqm5dHp3HNxZCSie/347ngSvpmBFpsEw/oRdt/NAJwx8gx+WLb4mL0tjgSLFi8CICG3OR+0ziXGI9PC5yKlQ3uS7pmCKSkOAH+jh3lvf8D0Z54mLOTfP5sfA5FjTbfbdDj/huvoe/XB+hxaWQ2hx55ECI8g9PrnWP41gaQzepO8ZQyOVwuQ6yXDmfXn5xUAQUSQRUMoS4Cq2hpum3w18amp7C0toyA/n++++46fF9c0Xcft9bF78xZiBiaQndcRgGXzZrNy7WpE2YwkmXEKAk+88OKJyWCpGkqjl+nvvs/jk2/GZDYjmy1E5ubRKTePbLcLr88okVSWlBh+Kj+TLdd0HTXgJ93kR7KY0IMKalktYmM1gt+HbrKg11cQ7D5o/2s2KAp7f2Vamq4jur3Mm/YpnfoNQhwwErV5HkKrfYiWj8Dnx5+eBpGZ2EeNBeC7t9+moy/AEgzTujWKQpfYRKQm4bn6Bg9hdR5MsRGQGo+S0Q7reRP3L0gz33mLwqLiP/3CXQsQCIHiQmn00AJYviOfyrc+4FVdZ7cOGTo0s1tIaZZCh97taTtkBI7m/Y0D5O9A37IJevTFFBPPFTffQ2RyJjfcdDOBQGh/maL0gHP+Vb1afg5N1wmFVNauXc6oiyYjOWNAc8DqZaAqkJEE7VsavCXA5FcJBEMHGWEeLRI0jSyvn7Id29AVxXB2jo4ElwdqG6GoEmIjIRREMYHUJJ8/qFsP9k6fgQ8jQDwUmiHQaLYTH5tMVlwaueExZMhmNNlEkclMaX0F20p2UVJbRr3XRVA51gbuJuhHGbP/2b9MTTgVlBwIAd557CmsFgvb927jpcJF2Pwy7TduI3XrbvzhdkqbZyCKEolWJwDfFezgg4/fRa2sp7k/gK5r5DvsNDS6Dqv/IAgCFtlMTHg0LZzR5PY2WoxD709HnzMTwedCbDDDh59QF5dE1JTxnDagLxaT5bjsyX8LFRUVzJ4xg6FnncXYu65n/k13kvvAv4nKMZyeG0rKefnJ1/h29rc48rdS7Wk4YW3OzYEdgoA5If4XzwVffA8x6Edzm1Dm/ICQm4p51EA6D+uB/LoEh0pLNqluinYrcrgdKcyGIIpoIYX/+2IaqtuH5g+gq+phv6yapnPm+eczcfhwIqMjadThpQ/eIxgIEggpKIqhm3Ai/xx6SKF06y5uGj0Ke3QkC20iw0/rx7WnjyMuJpaIMONz986rryB5fGRycDeApms0BLzk9O4AgFrvQq8uR7eFo4cnIlYVoiamY775UgC8NbXUuht+U9jPGgyx+Lu53BgMGj4nObnGz4ARxvMHjF21cD7v3/nvgzKGmsnEu2+/h8lmI1BVyZ6l63BERhDduw/h2a2x9TeUVNfNncWjL77Ejq+/JUtRj0kI7A+BqiGoGuEYJZVGflKUtckSdz70KO2GD8MqBLCnNEkKTP8APn4bIcaB/sX7qJdfg9RzKGPPn0B6UirDR4+hrqHxT6uTcbxQm8T5ikoqKM/fRkpOe+g/FNathj0l0Og1SnwdDD5ZYkYLGhq9R8Xd+jnqdPCqKrPXr6b/0jmk9x2OLjoQqhqgpgFUHQLVEOMk1LwDFpthSbBk+XKq4bBE/WgAyUS3iBhyew5ixKBBpEZGYvEp2PNyiGyRgCCLvPfM27z61mvsrsin1l1/XBvMU5ySfwBMJhPtuxu14Po9u0gqKCJn1S6ar9qA5A8RiIsirrCcirzmxMcbpZUVu7bgC/oI+t3UNwk91Tb8eio/XNdohUC2IJLbMh1bliEkpf6wHNHtgYZadGcselgk6i5Dtql1+zzC7Q4avK6TGvFeOnky2047jYxOHZkw7ytESSLg9pC/eQs33XQ7jZs3sCfopybo49CG7seGPUBLAUwRxk1XC4YIPvJ/6F4N7ZMPoLEOMUpGL92DMn0m5lEDiclJP0CV9IC5iAKSzYolNQF7Tir25umM6doT0W5n8d7tlGzegXdnIb6CUkLV9YYB32EupbKqioffe2//7ymACfhlQe4EQdfR/EFe+nY2siyj2iys+3wWT95+D+PadaRjmzZMX7qURcuX0xzj5hfPT2l8TdNoDHqxpxny/nJ8NOIzjxFcuBJsYcjfz0T6zwPYWhuf3/f/7wXqvS6U3whK8nUo2ruXi3p0J61NLmFpSdxyw1TC4o3PbsDlYuualbzw3nt8/MmnhCvaQdmnhIRE0poZ/CxLXDzdvltE0OfF6gjbP6axvo6zL72csspqMoJ/vfS2Bqzll5wLS6tcBl01+eAHv/8GnngEHGFgMyGUVCL+5yG8o7dguWAyXfsN5Mbrp/DYE0/j9QdOiDbHnw2KolHf6GHbnmLmf/8NF+W0Rz/jTHj0fjCbIC0JvUNnxPZGUOLMaEZIl47LhdgHbAwq+MtqWLt9ixGUZOWAydCiwu+HnFR8mgnbeONv9uUbr7Lx66/xcvhymVs2cf/Vk7ng5puIzso47Pkvv3MyrXKzuOaWW/EEvPhDx1n2/RviVFByAELBILfccRvPPf0sPYacSdlCBefM5fgcDmqyY4mod9H++8WYzh6PKEr4/D727d6LFgyhadoR96/nAnZVwZmYQNdbDAdWvaoGfe1y9LBIiEmB+BSEhmqoMBK3kkn+XXRLysrKuPKqq/j0008RJYklS5Zw0fkX0lheRoyqYtZVLHBcctKHgoZhoOa0GnLuotmEMHwQng9XYXfVgMmCHpuMFpOCr6wWayCAJcxOZEI0SvGOn25gAohmM+bEGCJ6tCGiR1uGn9afp/OGAoac9tsbFvDkN59TvWQ97k27CFbUHpF7K8CPTIzSXx11/NB0o30VRUUVDFrf6u9ms/i72fs/Z7uARA5eKHV0gqEgl91yK8+KEgNHjcB+zpnYz/lRA+T2/WP/ff1tvPzmq0escaGqGnvXrUffsJ58u53CuT/QZ8BA3lgwjz179oDHB/4gbu2X/i4FBQV07tyZc84Zx+kjT6d9hw5YHWGUlZbyw4wvKK2u4rvZsykuq0JR/0IZkp/hUHv4rGY/icIFPn4Ly7bN8O13kBQNtW7YUwweH4LTgWnmDLyCifBLr+WKiVfxvw/eo6isGo/PfzLpNUcEUfhpp62jH/d89uvGlFXzv0+nM/bCydickbiGD8c0dz6hqCjEdj0JA/ZsXMf3r79G9d6C48qU6IDfH8JZVM7OVRthEtC6Pdob08HdgF5ciLp9B0rrPOzhTvZs2cStt09FUtRf6tUcAJNk4sLbbyMqxTAKDe6rQPS4EWQZNb8cbelqyE3HesEoeo4dzlUrV/LWM/9h5TFfyalMyT8DOrz0+uu0aNOK666YzBmnncX/GmoJfTANZ3kdFpeb6OtvxHnWOABeW/QNwYoaVF/goA6I34ILCFdVzpk8AdluJVBWh++h95BjMhEUFVEUUGvK0CKT0GKbRLxq6/D6Tl73zYGYNm0at06aRGRUFA88/TShJrEvgM0n8bzJmsriJ58kymyhWY9uWHp0xF9SQ2BZR+TCrQglu/BExlGU0Iw4ixG89MvJYN2KH/hxvyGIElK4HXtOGlGndaTnwP7cmWJkv3xuF7YwJxM7DaZ7agsulp6koL4RpcGN6jkC91Zg68m6+MNB/6lwfKha9qHIqaqusSN/D+PGj2do/0H867pryG7dirD4GGTLTx4+u9esQPY2HlbN9VBYBTRo0Oj2UrZqLV+sXkejIBjCUqqGdJg5AbB+PR+uX8+dd95FamoKiYmJqOvWgaqxQRT+ltkAgNiISABKdmxCKFpLcnE+dGphuCwHaoxSRUwkJERjKq5EX7YQ7cKJJKdmcMF5Y3n9nQ/xB0Mox5EhOFaIgoAkiZhNMmazCUkU0XXDj8YfCKGo6nH93RRFpa7Bzabt+fzwzVcMO/9inI+9gBYMYjuAkP7AHVPZPm8h1sBx8jAw2qkrfAEWrVjFrapqWDckpgApkNMauf9wfvyW/PfppyhocBP8lUsUEDBJJubO+IZx11yJFgjhe+Q1pKISBDWIWF+Jpqvo3wh4lSD2CWMZP/lSPvi/J477Wv6OOBWUHIgmUaSpDz1EZl4eo3r05YzhF/JRfgFdPvgCxRmG8/Y7AHh1/gxmPPkkenHFLzogfgv1QIwSorHK2ONakqLQbr4IXgugffAeWnJzdF3HbzchXmCIZe1Ys/64VRuPBk++9tpBvx/Oiv5YIAgConiAdq1ucCHqdJj35Qw+nD2XsVffwG1PP0TE2MGULf4B5asKwsr34Yp3kHTeTy3Cw88dx6MfvNt0YBDMMubYSAY4LHSPSeHmzP6Igoi7roY5D0ylRUZzWkycQrv4dD655k7OLalme34pmj94RNmSv4rYtKIqyB4XO7/7mlHz5yJa7EiiSOu2eVxy0fnERUdRsnk90bpG1VEee38WQ9M5sO5VjuGkezjUASqQAUQVl7C6uIREjE6Sv2tAAlBaZmgYRySksNMTILpNNtbCCoiRYFe+YVXh98POYnDaMVtAXbsYug9i/EWX8v3331NT14jnJJrSHQqGFLuVmMgw4mMjiI1ykqLrmPwBygIhNte7sVTX0+j1E6lqeDh6DQ9d1wkEFSqqG7jzv4/Ta9gZhEdFIZrNaKqKKElsWb2KzXPmUxhUqD4B16UD2xWNPTt2MW7EUJq1bE4w6CM1LZXk5FRiE5JJTUymrLCI/330CSHltzu0JFFk1otvMnzMWYQlxWEb0RXlpb0I+ZvB0wBprRHiE7EM7QdAxc69VFisEDhWgf5TLcH/GOiKQqCylsuuvIIFX35Dm2bNueb6B8nvfQbO1PT94+Z+/iWubXvxVTegH4VpGIATCKEy5fY7+ECS6XHV5diyY+E/U3FJGqFZiwj17kX07VdiTjHahN999z0CSvCkdd78Fk5E62FrwC9L1Nqt2K1mTCYZXdOJiI4mP7+QSF+AXZpOTcDLE2++THbbloy9/GL0C8eyNzKC5mcMpnnn9vuPt23DBm68794DyGcCgklGjnYSFR1Jv7Y9EAWR/MLdfP/NNCS7iYavPqdo4SKS33qXlpHxzLjjUdp8v5hQrQt+0YPz14YFnaASxKsEcfsbsWo6ZQtKuHnBbMowWkp/LSV9tHA1/RwOP5Kik2G/2N1vmej9nvhRCfi3VIePFt8vWEhdXS1RUdHUK3YqN+0hLtKJ1WJGSIiF3cXgD0JZJVRJYDEjLfwGug8iu1UHLrzoIrbd/x+8/t9vU/JjQNIiM4l2uRm0aZFORkockaKIzafij0/D61GZ/ebbbNixl/IGD75jnJuu6wRDCus2biYlPY127dri8XjYvXs3CQmJ2ItLyAsqNMAJCUr2nzOoMGPOfEwLf8Aky0hNXl+KohJSVBRFPeKSuaZrmFz1BF0eSIpDateSkNkMooDuiIKoeMThA5ESDUPOt96cjks4vr+lrgvoR2GydzRj/0icCkp+jiYRq7q9RYw571xWfvs9UTGxZHY2SgAVleU8+39PMePzrwnVutAO4dD6WwhifLlKfG6uueNuzvngU4ZMnUqX0/vjuOsmavqdRvyAHogmmdqSMu684Wbe/XrGb3ZI/JkhiSIRskB8TCSpqQkkxEaSlJjApKtvIa9bb7768D1uu+E6TA1u/CEVn6eBNYsWMPbyi0nu0p7kLkYwEgwG+WzadJ75v2dYuWrVwYu0AIIoIppNrO6Yy+NpRpfDgn2bSZs9l7Qde9nRowvlGmx6/C7OeOA5MlPSSUpKZm9B+V+OWPlbKOaA9lFNI4Tx2fvxU1T/B8wJDD7OyebkHA0EQSBC19GAoRiZoO0n8PihUIj5M2Zw9qWX0XHCNWy8bTIhBBIdFuyR4QgpCSCbweUCWQJXIyxcin5lNUJ0LJOuv4P1y9fz6ifT+D36OgUBzGaZxLhIundowchBPenaewBRMVlIYTEIB/gyJSSnsvreuyndUYDbGzguXRnDMNHDkqXL6Qn0A2bt3UcsRobyZHjOaE2ZGsONuummrR/d1k9HJ6iE8HRqT3TLTACC9z0EuzeBMwEhMQNkGWX29+iTxiCYZLp0z+P7z70Hu0+fAnAqKDk0NB3NH2DP+k106d6N5265lSGXX8FHn37Es3fdiauyCmdQoUo72kZxAz+qAgpqiO2eWp7ftI7Prr+R1x0v0L5/b+KHGhLjFcUlXNatN6XVFfiV4F+2NfBHaeeahGi6tsuhY6ss8lq3pN/pV2CLNlqAR11wMRaLiSuuvZZArYtQMMT7X3zG4MEDMccnIKCzcvkKnn7lFUpKSw+tiqhjLCiKyti2vYgw2/D7vDT77zNkr9qEGPCTkFjIni5tSFm/GVUJIUoSZkn6wzJQvyeCwLY/ehJ/IoiCiEmSMckmRMlEmK5RooRISk7GrwQpKC4+YZ+LG+66m9MGDyGueQvCTz+XLZ+/g9QinRRBxJSeaAQjboch3KXrEOaE8AgAfHW1FJSeuDBOFAVkSdqfGdD1Jtl6VTM0aUSRMLuVrNR4Rp8+gkFnT0Iw/8RFQtMMt2Mgo2VL8pqnUVhajT8QOq7OmAMhYJT1wMjSnmiRuJ/jePSVAIJKiEmTLwfA9ekXqN/PN7R3IiJQW3RF2LoE800XIZhk/I1u3v9iBr7j1Ck5uHh6ZOP/CjgVlBwOuqHYuHfPPk6/9lqkG25EVVXsmkYKHHUd/pCn0HV8QT8hJUSdt4FBZ47iP/few5W33AjAhy+9xLqyQgLofxkuw6FgMcskxUfRs0MLxgztTo/uXYlvNRTBGo5eWUZo9teYLriCoWPP577KMu6+70Eqqhsoqq9n0EUXHfmJmlRRkywObu06GIAtn76Ds6yc+tgIguEp1MVF03b+MqriIvC6XURYrMTYw37TTv4U/l4wSTJZFgc5Nid6VAKWyFhi4mI544KzOHP8GBrr68nLa0d5ZflREYEPh+KSEi6bNImvv/mGVudfyLK3XyFlVxHxcZHIwRBCSDGIr4pqOFGfMxLBZMJXW8m1V1/Eio0bjptPIooCFrMJZ5iN2CgnzjAbsiSR2uCmrtHDmqCC2+MHAaIiwujTqxsDzrrcCEgK9sDutbByBeTvgxat4JaHiErOpE3zdFZt3E1dg9sQdzwBd7+lx3+I3xWKqtA618jMlgZDbGjVnS5VRagV+QTryrHfeDURQ/uihhRuveZWFq1dQZ1+8tS5/8o4FZQcCTQdVTOiWi8/kbmyMbxGjrcurmgqSlDFHwpw1b9u4eFnn+bcoUN5+eOPcf1l4ttDQxQEHDYr6UmxdG6TTZ9+A4luOdCQ1967G+GGSZjsoPi9mK68gcsmXc+Glat59cNPCQSP/maghxTObNsZS5MSY4MaItSlLd5IJwXJCaRt3UFpahxSdR2WJonvkNuHfioo+cdARiTG7uT6CZcg1AVpP3IknUb0xhYdsX9MREwMV105iceefPyEeU7NnDWLLRs2kNe+PZPmLqN693YCFflY5sxF/G4OQqMXNA29Rzto1RYB2LplLXsLSwkEQr90oT4KSIDNaqF5djr/nXoH7Xr0Ytu6RWzdsoK2Cc0JS2+OEB1HwO3loqsm0jY3m5vu+A+SzYFeXYLwzauwo8BQO62rhSWL4YYQssNJdvPmOOxL92de/onQ0XnxhRe4+7HHyL3wHByd2mNucOEQwZSTgyU6EoAXbp7KxzM+xeVzH7fEg5EpOZqW4L8GTgUlx4EfPShOFFlP13V0dPILC3ns9ddP0FH/WIiSiMNuISUxmi6dOxOdOxhBEGHvVph4GQS8CGIkppULULr2Rm7fhduvv5m3P/2MYPDoTbd0VeONTz9l6m1TiUpMYuBl18Nl16OGgsz86GXKHPmsat2REbU61qhoAl4vWzdtOqkeK6fw54EoiHQyW7l49BimPP/UQc/pmk6ouBL3jr1ED+nJpRddwJuvvkFQCR6/JHgTrr/6at776COSMzJIymsPee1h4Fnot1SjrlqCmNcRrbwYclshAUsWLMBcUE6EP/AL7ZcjRSsgShSoS4rlk1deJ6fnaQAkZLeg35hL9/s5/YgenTsy8cKLcUREoVQWI33+EixeB2E22NMIG/eA1Qz7dkLzPGJjkg3fq6b//RNKoYfCPY8/jl828fAjD5PWqsVBz9VVVfPWfx7ntVdfpkENoqjHX+bSdAHtKMirRzP2j8SpoOQ4sPaPnsBfAIIAVrOJKGcYrboNMQKSbWth4f8gMQYqNYiJgOxkfqRgVtdUGk6gTcZ+RwVdp7q0nDa9e3P1jddx1bnnE5+QhGQyM+K8q9nQshO5dgf92jR52Xw/G1dt3Qm+6lP4s8IkyWhhEdgSflLdVKo9hBZsQ127B9Z8jyhrMKQnabnN6dUsl10balitHJsr7c8xb/lyUjIzadUqlzNGDmfM4IG079wNe1wC0vCzAJDSjC4/TdN4/5PPMdXUYz6OlulaICzcwaMPP0xOz9PQgwH02mLE+EwjIPH70DUVwW6o69bXFLOzMJ++QKCiHNuClQhL1hslTotsCL6ZZSgtMoKStFzs9W6UUOgfG5D8iEcefYQtK5bTtn17zBUVxCckMnvXLmZ9P4fEgB8/OicmvP374lRQcgq/DUFAEEWQRSOoQEdXNcM35ggWSx1ISE4nMikHXdcQVn4LK7eBHoQWadDggYoaBNkg021YvoRsVWPtMTqBommU5hdw/x138tSjj9AuOYl7H3uSgQOH0KVbn4OGrpv9/V8nr/lbEDCiwJ8UYJrE1/7AOf3JIEsyalgMo66aAIBSXIX/8c8hMQuhthwaqjCFxxAqqcaUEssZfXvz9qZV2PHhOYFv5Pbt29m3dw//++A90pLjuPT8C+jSoTOb92wjLDKWXr36sXz+fLbuKcCnagdxygRBQBJERFFsCtxB01RUXTtkEF9vlmneqgVnnWdcs1q1BrlgKzy7DBr8IKkItz4K6WEUrJpNttNB4YZ1AIgx8XidDhxmE4I/CHGxENKgY3N8y+Zh6zecZm26EJaUQua+Erac+qwxY948Zsyb94vyfgSGjk/ZCTrP76Ho+sILL/D4449TXl5O+/btee655+jWrdthxz/zzDO89NJLFBYWEhsby7hx43j00UexWq2Hfc3PcSooOYVfhSBLiFYzUpgdOdyOYDYZHBuPl8gGNxX+IHrw8G3Rug7BoMLA/iMB0OZ/j/T+NCivh/bNoVk6vPARBBS0M69AAiIcTiRFOb46vqahev04/QHKquu47Kyz6N21O/169mRtRQXb9uyhevsO6sp/Z6UMQWgK8oSmmOHHwOE4rlUAQZYNaX6LCdls5l8TLmX+8mWsXLmKkKIesYz+3xkChrV8mNVBTIbh/RO88zHE0lp0nxsKtkFDDYLfi7Z2PaQMJrdnd3g3jJaKl42ainqCiJy6DoFAiMqaBhoavdz93yexmGXiVJ2wgJ/rVJ3qpm6WA78HkihhM1m45NzzGDv6TF587R3Wrl2HL+jDE/DhC/pRVOWgjIUsSSTERQOghQLI65bBlnyorITV26BZKojGeJNJIcNqRpWNW0Od38++ds3Js1iwVVRhCqpow3vir2ugpLaUiGU/kNizL5defBnjFi0//jfmb4SftzBv5K8jvgjw8ccfc/PNN/Pyyy/TvXt3nnnmGYYNG8aOHTuIj/+lceqHH37I7bffzptvvkmvXr3YuXMnl156KYIg8NRTTx3iDIfGqaDkrwDhwJ3v73haswlzbATRLZrRqkdnclq3IjMphRyzgy3LFjNt5kzMJZWUVNejenyH7GDRNI1Gj4/mLfIACGzdiDW3GaKtDEqqwb0aLDZCV0zA1OQUG92yFeuP8z4NgK5TqOrIKiiKn/L5C1gyfwGFx3nYY4IoIFrMSHYrot2K2BTcaYEgqteP6vUbInxHe9GiiGg1ExkbSXaUk8akWE4fdx4PXHE9fp+XEYNPY9/ufIpcbrRA6B/NndH3/6tTV1hKbHY6YrQDddkihJ2rEOrLETUNKTUHQTeCOJsMrZunUlyio/n87PP48Hj9KCeAGK1j+BuFFAWPL4AggKrpROk6DRgt3NkYEgI6AmbZRGZKBv/33LMMGzUcgL5njeL7j77hw1fepaCqiMLqEipc1QRCgf1ESkEQCPgNSThBNkFqAtS7YMNOiA6H0irYtg1Sm5GQ3ZshN4VRWWIoaJisDj5ft5viMAstOnUk3q1g8qk05uTgM1tIzGoOgDUmliygBI6Z+/J3x4kOSE52puSpp55i4sSJXHbZZQC8/PLLzJw5kzfffJPbb7/9F+OXLl1K7969ueCCCwDIzMxk/PjxrFix4qjOeyoo+bNCMNRJRZMMP7LaVY2sQBC/ov4kinWyTi9LWGMimP7Ou4wYPOIXz4/pPZiGGAfz1m+mduFyfPmlRmDys3uepul4fAHy9+0jOjML+7X/IlBVDLO+RH71NRh/FeLoczBZjPSet9HFtGnTjkja+UihAOg6QfhjAhJJRLLbsCTHYk1PxJIUS3xSEuEWK4HaBtzF5RSs24K/suboLAsEAclmwZwUS1S7FkSnxZPYoTU3nW2YPFptdp57+TVG3fMvzGu2EqyqNY7/D4aqaXgDPop3FRCbnY6Qlwtffo3p1snIU66CJcsQSsugu+FMm9E2m7GTLmTLnG/JKa5gcWUtW4srcbl9BllREBFkEUGUjFSMfnSlTfgxUWbcsg4UlkvFkB7IBvIlmYzkdBYvmk9sWgqaquLbuB1HxzyGXziK3Lh43nttOqv3bmBd/mYqG2sINDnQarpOfb3hay0IIsxdDe9/DfEx0DzT+M5++zl6115IkVG06dYXgFAgQFxyCv+a+l+ccXHYIqP2z/nAffLOLVu4/pprEIE4TgUlvxeONsH641iX62DdZYvFguUATywwRCrXrFnDHXfcsf8xURQZPHgwy5YtO+Txe/Xqxfvvv8/KlSvp1q0be/fu5ZtvvuHiiy8+8klyKij5U8IomVhIjQwjJszO3pgI0HTS6hqx19TR4AkgBI/Mq+WY52Ax8cYLL+0PSDwBLzXeRio1P7G6TGZsCk9faUTLb336PpNvugXNFzQW458hFFK48fbb+O/Dj9BtwCAscakw4Rrjpwnlxfl89OG7vPTKGxQUl/19vFBEAcluxZqWQMJpnRg9Zgzndu5D99j0g4YFAn4unXg5n3wyHS1wZIGDRRQIiwyjdWo8Us+2ZI4+g/+m9iDC6tg/pk3bTnz3/JuMvfVads5bSkhp+EeXckJqiHqvix1bt9Nh+GloHTvB2AsxXWfY1HNa74PGW1Mz6HPxtbQfOJTG/ALarVrOE6+/zd7iStyBENjMyOEOJIcNkySS4fOzJxDC3+j9Kft1jCjG8AnaBTjNFq6ZfA2xaSkEyquoe+JdTMtWII8fhuXaK8gc2p1zAyaE9wRC9ZWs9HuMMo6uoWs61TW1aIqCKMuEqj3Iu4oQGn0QFwV2M3p9BcHLz6F49CjSx0/GZDIz/X//Y/R555HQ3Ogk8bvd1FSU42pooKqmmqLyCmr27uWB556npqbG8DA65qs9hd8LaWlpB/1+7733ct999x30WHV1NaqqkpCQcNDjCQkJbN9+aL3jCy64gOrqavr06YOu6yiKwtVXX82///3vo5rfqaDkTwbBJCM7HVjSEmjVJpeHr/sXSTktqaippLSshEBpOR7ZilTfwOSpU2k4GZ0jkkj7jh0YP2YcmqbxxbRXca1diTkIpa1yMAkSl48YT3iKcWMdf+Y47n72Gcpq6g8ZlGi6ztLV6xh61lm0bpnNhAsuYMyZZ5PcIhdPQz3PPv4An335JcXlNdS7PARDfx9+umgykdoym//edz8jhozAeYBEd9DvQ5dlLLIJi8XKfx59jK/nz8ddWvGbu+xUjK6msJhIkrq2Z9IZ4+mb3QWTIOIrzGfT/z2GP9xBt1vuokVKBnNefpdzrrqcJV99+48OShRNpd7rYvG6NZzHRGydW0Bn46arV9chxEYdNF6QDafa8JQWhKe0YFynXsxespBGRUVTNMxpiWR3aktUahLegr0oPh+51Q3sKqvBt68Upc71m0FmKuAAdhziuQKMNuYIh5MLLjUyYP7XPyZ84XyITyf0znSkXr2RO+XSclQnrmkWSWjyTtTGKlaICjoasiyR6AtQXrCX5OwWeFrkEta6GZLTaZDMGz1oF07A5/FiadUZk8lMVXk5V91wPW+88QYD+/Rh5qIfWLVqlaGVoutoum5IGBzwMT0VkPy+OFZDvqKiIpxO5/7Hf54lOVYsWLCARx55hBdffJHu3buze/dubrjhBh588EHuvvvuIz7OqaDkTwRBljBFOXG0zqLdqCG8fPVUMuyRACRFx9Ghed5B42cunM+HH31ChKLi58QZiQmSiGI2Php6KEjkB5/gkE1EV9QQXlFDRF0Dy5avQc9Mp+vl1xOdnM6ECy7ksY13QyB4SN6Lqml4fH7WbdrOlnse4N6HHyUvrw2VlRVUVFTiD4QIhhTU4xCI+jPC4bDy7L0PcObpowGoVP1s37IW+bnnqPQH2Nm3A7ZAiEsuv42MlFT+dd45PPfsS1Rrv77DrgS6Ws2EUuKYOuU2OmW0BCB/01o2vPI0rjAHlspSVt8ymRaPPkVCTCKz3/6Q3v1PY+3KNf/YjhxVU2n0NfL94nm/eM799jTCrx4PYUZrLLoGQlPpdOH30G8IJpuDwYP7UmU2ccmocUw+YxzRYYbo2p7Gam7at4B6l5sJFQHmfzmL3QtXEiyvNvg8h4Gl6edwkESRcaPHEJcYT9DlJfTDGuSoeIR9GxEDfgJPfYB65jDMo7sTndeMYaNPZ+fHNXTUG4hPiObma29FqK+nbtdOkrNbQK9hVEXHkjBwDIIso5QUYsrJJRLDpFEJhbhlyjW4XI3MWbyYOYsXH8M7feSIxehMKTLJyJKIIIrouo6qaiSEQpTqTSXYUzghcDqdBwUlh0JsbCySJFFRcbA7T0VFBYmJiYd8zd13383FF1/MlVdeCUDbtoax4qRJk7jzzjsRxSMT1/vHBSWiKCCJImZBoLUgUIWOS9XwqRq+P3hugsWEOTGG2C5tmDZpKrH2SCpVP9Pz15JU4ybGYsGcmkH3mEwA9m1YQ4xJIk5R0Tj0TusYZ8LekmKq62qIjYohctRZLKspIWXjDiKra3DUuQiZTHxw4wTKvUVcQjpXnnUOT9x5HyqH7+PVdQz3TVXDFwiyZNnKpscN0bi/EwczA0gBZEmkR49eACz4+gOqZ83C5PORvnk3KbpG9ubtbOnegdq6Kpz2cCxhdhJMMtWK8quBg1kA2STTtXPX/QHJunkzKX3zVVSbFTU8gvwOrfGUlrH+7aeYMPHfOJ2RnDlkKGtXrf1HE15DqsK+4nx++HwGfcectf/xYN/2PwUkYAQky+bCXbdDfjF8PhPadWLk6EtJa9WVvn1HNB0vBAhkh8fyaqsRRMpWrIKEe8SF3PDQ3bz36ltoQddh3/PfMpoTBIFh/QzBM1HQcbTNQp81B72hCiHMiaCD+uj9MGQamCMI2SLo1r09EWlhjL38RiJijBR8KBhE1zQiW7YhsmWb/cc35eSiBAPUVVaiqBrjJ1zMD4sWHf0bewwQgGRJJNpsgrgoOkgSAauJUlEk5PJgbnAT5Q+wKXTkjr3/FJxMoqvZbKZz587MnTuX0aNHA0bTwty5c7n22msP+Rqv1/uLwENqEuY7mk7Kf0xQIghgkmUcdivOMBtRNgvZqopTEAnXBHyqxoKKKoKh42xFPY4JSjYrlpR4zhg+gtiwSAI1Vax78HaUnFS2h4cTXl5Jq6JyeP5dVFUlLDEOS3EZDb7gCbdb11SVlxfO4q7RF5F1zkVUTbmc+J17MTe4sIVCVGWl0XrecurVAN6rOtAsOZVhfU7j66+/+c1j/5T2/fsuMnWAQ4Ss3BbEx8YTUhX2rF1GZmk1zqoqJI8XczCEOyGalms3kRiXDMC2kgLCNA35N3aHKUCjrnPBOINEtqKxjB1zv6Z1QRkem4XI4nJSd+xm7hVjiautw+mMBKDgOFqg7UAzDHfhk020PtkIKiEGnzOOyy69jFdef5X6wkKiOhnkVtwu2LcHVi6E4i3g8UPzdHjmcXjzf0QlpNM34SdOUNXMLylY/gNd73yYRIcR1ARCAcLsYbzywOMsXryMXctWE6GohHH0752uanz54it06t2LuKw05Cfvwbd3G8K8HWjORLBHInXpjBAVge4PkBluJmFgZ3IGnYUcHoXmb0T1NGCKST3ouG+8/H8U7dzO4N4DmPH6ayxbvIQ1IYVAUPldYlZBMLx4aiMcRKXGM6hFOu01HTHaSZXVTHlVPeq2vWwrr8VW14jPH/z9AxPhwBv5n0vz52R339x8881ccskldOnShW7duvHMM8/g8Xj2d+NMmDCBlJQUHn30UQBGjRrFU089RceOHfeXb+6++25GjRq1Pzg5EvwjghJBAKvFTGJsJM0zk8jJSCI5PoqExEQS01sw+PQLAIF7zxvLrAU/sCUQ/P2JloKAaDVjjo9iTNvuAJTO/564RcsJVeew7oyBdPp+Ed4wBzXVZcTEJjH5/oc5/9xzCTR4DOfOEwVNQ/P6efPzT7lu2GiiImJoed4EgjfeCKJA0GqhPjaGlB27oLKahvNrsdsdtHeEsVbX/1S29H8UXMA2WUaXTYCxABf06EjAEU6LBSuIDQRxxcVg1hTyhw2gYxPXxGQyEYfxxfy1oKRKBw8iwaDBV+genkRUu57ULlhJeF0DcihITVwsp81axMjn3wWg0eVi2rezjnlhDWK8dH8A/LP1+q+GkKrw2puvs+rtN+mVFM8zu/cZRNA50zDNmA67iiDaCVEOKKuBskPzt5LPHIve0EDJ+eMwjz6b3RX57A3U0+W6O8iLTeOmCZcwZeU6EhSVY3GHSdE1Fm3bzpPjJ/PA959gDrcjJCejSTKCpxZ98TSkGyYZg6u9pDaPRsjrgRgWBXVViI/ehhDnQO3SD2nAOQDMm/UFw4aewe6IOG668ELcqk5QVQn8jvddi1mmRXQ4/dITye3Sik79u5GT2QbFEsJbU0ZldR0uSWSXKZ9yi5ni8hp8/t/BLV0QjGYDiwnRbEaQRaPTJRhCC4bQg8ohuXN/N5x33nlUVVVxzz33UF5eTocOHfj222/3k18LCwsPyozcddddCILAXXfdRUlJCXFxcYwaNYqHH374qM77jwhKTLJMbJSTjnnNGNijDX1796Z5+/5Y4zMPGvfgx9Nx3nU7j7z2Bl5f4FePKSAgCIYFuNC0Omu6hqppaMfiKiqAIIrEx8TSu6kzY16whgFV1URWVFOTnoK5wYsYUFj+v9c4/bp7GN2zH6d16Ur5FzNxceLaXXVVw+lyE75xO7d/+xEvjbmSzFFjmddYRe2C+cQUl1PUKpHEtduRO3YlKSmNgN/P7pnfHNOi+7eFprN39262Fu6jdXoWKbltqC8swxsTjafRTVxRMcHwMBTtJyLk5IuvYsJbH/3m+1grCLj9fh68/mq+WrQak2wioUcfql58kYZwO6m79pHi9bG+e+v9r/n4pefw1tYdc+lGAbbQ1B0mSwiyBIKArmnoIdVYqI9Sv0MAY9fQNKXfW6Zc13UqVJWvPG4mrlxK+9MGYBp9ObToCA/eAamxkJMJ20rRc/IOu9e09ulLzd33UL9vD6boaForfsoHbyLvtDQiomNBMMo0v17JPzQKgLyAhyW1FVQXl5HcKptgeAIm2YSmKagRiZBk1PmF1CgkbxSEJYCmwofPQ1kZQjACqehTtPBYxC4DGDhiNAAJqWlUXHAhRccwr+NBLJBgs5CenkDn9i3o0qc9uaeNQUrIAUD3ecioL8KX3B7z7K9otWQ1bq+fYEhBOZlE7Sbdn2bhNmKiI7BEhrM9KQ5dVQnVughW1RGqqkNxeY6rs+pE4Fhbgo8G11577WHLNQsWLDjod1mWuffee7n33nuP/kQHHue4Xv0XgCCAw2YhIzmWIX27M/6ya4hIamLbaxpUlqFtWYWSnYslM5c7/+8Fxky4jN6DBlPf0HDIY4qCiEU2YzNbCbeFYZZNaLqOP+hvUlX0EVRDRxfR60YwEG8PQxRFAn4vCbPmARKWgJ+UrTupykghsqaa9u16AODxelD25ZMHrDzO9+nguejkeXxE7Ctm0ytv8r+0bMZ3GUD/8yayOCeb7V9OoyEQwhQdz+WTbgHg2w8/YGZjI3Ench5/cSQpKjR6+GLOt7S+fDKnEcmqbbswhYfhbtsGR6MHV1wkKVdfBxhtwdPeegOXouH9rYPrOiF/gOricr6aMY2zx47HlpBEY1IETpuD8rRENLeP1TERDPV5iLQ5mLd4CVroOBZ0UUS0mJAjwpAjw0lKT2PSyFEUFBXx1uefoTS4yWpopFrRqP2tQwkikighSxKyaKR2VU0jKRSkQFd/V2JjGeAIhJhy8/U8+OD9DBh+NrTuCOdcBOWb4ZJ/g9X+q8nvhtdeQpAk6jLT8cY4qU1Ppn2ioRpb0dhAqqpRCb/5vhwKOjq7lQDtqotpequw3HY1jWlpqB98it9qp9Enk/Lj+OZNwdOHr8G8hZCVBO1bgNuH8PqzqBFJCBnNEM1mTGYznuhoqD2WmR07EkSBNKuFtJw0Mvp2IKd7d6T4bONJnwfB5kCy5RKWlEuvvK7Mr7uBvUWV1DW4T15QcoDuT3xSLOlZSbhzMkholUkUMmeY4/h02RJ2LlqOd0cBSn3jP7qT7WThbx+USJJIZEQY7Vo147Ip92CJiDb8V1bMR5g7AwoLEXUQ4qOoHj6O2D6n07pzF5plN2Pt2nW/OJ4syTitYbTMbM7EiRM5Y9Qw1ECQop35rFqzibnz5rF571ZKa8vxBv1HnjXRdVSvn02r1xJUFSxWOxmNXioyk5B1HU2WUGwWUu9/hNS+g1FVlQn3TmVrfj5lGKqPJxIVOsQ1eIlZsYl3r7mOuP8+xeABQ+nbbQhdW/egob6WxFTD1GzP9u1ceP0NRJ2geYQBUUCJaNwGdN34v79ahSAa0D0+5n07m39fPpnW6S3Zl9qMIVffhmyz4akso7ailLS0PDRN45zbrqf0o4+Qj3Ch0xWN9fWN3PLEE/QeOJSEqBiGf/TdQWN6BANYzEZvh1vTj30RlUTMdiut4qMxD+/PfRMmMrhzL8ySsYSYO7Vm3muvkb1xDzsb3dQeJvgREJAlmXCbgxhHFNFhkYQ16arInkYa3bVEe+rYEAoSUn4fgzcd8AWCbN9dwJ23/Yu78/cx4upb0IaNRt3aDJPVbhjWiT/VxXesWkrLrgaBWVUU/MuWIQsQ1lDHvnY5DLnxTlJjDJ6Qe18BVkUhDUNz5FgQUIKE6qt59a57mfzM48QlJ2GZMp7AxaMQ0TE5w/ePFX7kQfwwC7bvg+Iq2FEI3dtCSEF56QWUiVdja9kKURRJSkqi9ncOSkpFkfiocHKzs+je93zMSVnGDnLJfHjzSeg1AJo1R+/aF3NELBdPuomFyzdgNsn4TpIAoGCSMCfGENmrHVLHXEoHd0XKSGaQNZZ7yCTKZOOmMy7g21WLuPquf1OxejOKy33EInknYcZHyRM55RL8p4AkioTZLLRv38EISAJehJWfw8JFUFUDkoxglTCVVmHaswv6QENtDdu3bvnFsURBID4qlpcfe5zTL7ngoHpaYqscup41mGseuInSzdu57vqb+XbJAnwh/5FlTHQdzRfAta+ErYX76JDVnMBpvdhbuBPNbCZ9824aE6NI7jMAgDtfe4ZZX3xJIKBQecLerZ+wDSgCMhu9VO0p4qyrruTccefw0DU3kpKahi3MWAS3rFzJyHPPwePx4DkB5xVFgQxBwG6S8FqtiKKAqmoEQiGCQQVFPbTp2J8RuwElpKLt2oOqqkiSxOk3/ZTadMQn4YhPAmDJymV89+nnhPxH4Uar66jeAEWbtnHp5Il8+e7/MJktKIqCqipYLFYsZguuhgZu//cdfDXru2Mu3UhWCy0Tohl0w7U8dOX12Kw2ACoCjSRYwnn8/Ik82lDLnNCnhO/MJ6/ezZZDpLdlSSLK4SQnLoPTouIJS84hIjIB2SzTrnszti1ayjuLFxJdW0qtu46g8vto1qiqhsvtpfmuEn545DHaDhhBasvWiE2BR2NFOTfccDmNIZHtJaXUJUXz9v+9wJDM1kiyTO7shRT99yHC33qD9NUbCbcYgdbnX0zjyXfeJkznuL6nuq6Tj8KT0z/m5blzmDhxEtfdOIXYRKO+73O52LdzB9Fx0SRmNGUcZBv4ghBtAlGCoAKX34il96CDWpB/5CUdDSIwOswaRZkySULX9aMqX/skEb/VQsvmedjSjMw1RfvgntvBVQ/7yo2W7LNGol97Hzl5XTh94BA2bn/NqPad6CWgqdHAmp6Is0tr1KE9cOQ0Y6AWzb/kVCRBxKMEcMgWzujen2dvuZ2LplxjCOQF/xhdJV0X0PWjILoexdg/En/7oEQUBGRZIrtpVy/k74LZc2D2CiipMohsZ/VFKKvFLBhkQ7vNThtgFQeTvkySiSvGnsOoyy4CQCkpJ/T8K6gRaUid2iC3zsKUGkdym1xe//Bt+vUdyLa9O1DUI0tGa6EQwco6NqxaRYes5nS48S5a+TyUlRZQtmMjZ58+HkEUqa6r5ftnXyC5ooY9J1FozA1s1nUElwfB62fpsy9x/vMvk92mLcGoSH7Yso2SwqITtkKYZAm7zYIabicxOoK42AjiYmK5/V/3sWHjem5/4H6qaxvw+gJ/ifbAHwmh2zZuYfDI4bz87PO0bNmSfTu2Mfb/HuSc3oO448IrAIiNiCJU24B+tPL6TcaDs2fMpEvvXoweNIiPv52Jrbwct2TCkZqGb/cedtbVH/vfSRKRo8I554YbuPvaWwHY6a3hNb2M7GdeZ+hZF9OsTWeuuXgKH1QXYfX7EQKFBr/kAAK2KIg4LHYy49IYlplHXnI26eFx2LJb02xcW+zpMXQ5exhVo65gvaYyVwlR72lAPRaO1jFAUVQ2KCpl1fWcfd45TL35FsZOuBwAe3Qs85euo7bBQ0AAuSGOSf+5l4cuv4oh2W2Ij0kkZeqdbPv0f9gGDSbcbgTtn7z8Iq6KKupPwPzqADQFT301jz31GC+89ALtO7TH1dhI/r49hDssnDWyL0+/+jG6psK23U18NxV6tkZvNwSh9yB0XeO7Lz/hm+/mkb9jN7t2HV3+RhZlBNlElNmO2WbDarKhaireoA9PwIsn4CNOCeLE2NwcCoY8gIIr2MTd87jh2kvA1QABBbyV4AvBzNnoV96GEObEHwqiaidHOiAOEMwyYlIs9pYZWFMTucQTyfiwFERBZHPBDvY+/gitw6LI+c8znD5gKJbYSGLLaygKhf6SRO8/K/72QYmug6KqxGQ28UhKCxA+/wHcjWCWjWg8NQE9IhxTV8PWfueSxdT9rFwgAK0kE+vX/SSx6zv3MuTduxAtVvScTvhjUmmUAjj+cxNRman8338eYdQF4w1n0SP51KoaqtvLZ+9/yPlnnY3FYkUOc5LToi05LdruH7Z5yWJiCkpxeX+djHtMaGKe//gDAmgquqJR5vNj0nRWLltBBcdWHz8cTLJEVEQYWanxtM5JpUOrLDKzMug/8jKciWnkdu9Jm+7duWbSFazbvB2PL3DCO6QOK5P9Yzp8vwTLUbYoaBoLvp9Luy6duHjgAHasXUOxqvDm9G9pG4QzLruCVXPnGTuuozhuPBADVOg6tf4gG9euY9P6DQiiYWsvAs2raggqCtE61B3jDlOUZcxxUbRtaeihNDbW89E37xMbUokrqqDitptJ+mgGMc5IrhtyJu+v20F+RS2ZHj/5TccQALNsorkjgkGRCbRu3YvObVoR3SobR+tIpBijldYSHUG7jDx8usKmoA93wIsaOgmf80NABzYAYiCEvHUnl1x9DVffdAujhgyhsbaW0opaVFVDEwQSSiqJmrOMx0squLt9C/Y+9DqyyUzjAw/S7fSxiKLIZx99yPzFy47YNuBIoWoqqqYSCAWZv2gB6CCIAiHVSlAzlnS1vAx/hB1zpB0pPgs9tiXSkDMBWL1wJo//9xHWbd1HQ+OR5zeNv6GZSEcEyZEJxMZnkBcRi81sJaiEqHHXUVxbSkF1Cbb6SuzK4a9b0zRcbh+CaGwE1dJCpPxSsJohIRqq6yE8HG38uUhhTly11Xzx3XdkBIPYgaOzePt1WIF0XSdR00ioa6Q6pJBhjuVCUyYAdV98hveZ/5JR76IkJYEcwGKx0ikqms3SXpJ1frPjUBAEJFFCEkQEQTDE4TQVRTt2TorG0ano/lVkKf/2QYmqaTR6/LTtYgQc9D0d/s8K770KndKhqgEsJkJdBmBu1QZNVZl811QKfrZ6N0fAJZvpHGukS/VAAEExQXyakRZrrEUIBZFNMvWvfEbCo9fTc8RQosMj8AWPsIQD6CGFL2fOIjoxkcSsNJIyMrj5kssY0LMPs7//lqI9e3n/zTep8AYI/+3DHRUEWUK0WTDHRiFHhSOF2RAEEdXnR6lvxF9dz9ZGr7GbP4HxgCgIhDtsDE6Ipl+rZoy6/R7im+ch2pw/1ceBvHad+GLGN4w7+0yWrd2IPxA8YbsmK5ALNHKAmJXYZIpoNhEfH88tF13M659/xq49e9ECQXRVO/K7vK4TdHt546uZGK1WApKmcfvlV3LnM8+yY8eOo35PgxgdMT/mVgRdRwasJplwhw2b1YwsQFYgxFZFweEL4A+Ejo4o2GQMaYqOoDjcSPqXbdtEh1kL8TvsRJVUY6pzsXv2TNqOu5DJXYcyd8AK/Fv2slmW9nfjCIKA1WQhMyyaHt17MfjmsdgzD02L7nj+meyZJpPUUE1pXQVB5XdoAz0AmqYT1BSCIcO9962PPz14gK5T5fFhL66iwuUluLsI9T4FSZbpddZ5AMyYNo3zrrgCxR84aZwD/YDgWG8yvnR7jcypnJyK+5xLCHNGEDZq3EGvK91dhG9XIU63h7qjmJssySRExvH2iy+Q264tEiZMgRAhVUapqWXPxn0sXbWGwo0L2B4MstTXAIcJKFVVo6a+kTinYe0nZjXHd1pXrHU1CGYTelUdAYuMEhZFGLB59UrKKmrRgwpdgGR+OxA4UvgxslCSSUaOiWBEah6XS0YJzLNxA/XXT0GOj6OiRTaNkXZCfh8mqw1PYjxRgviropUCAiZZxmYymiLCLA5kSdpvDFlQ81dX/Dnx+NsHJYqqgmhCko1LFSQJBg1Fb9sW4bZJsDMftTgDccxNAGxcspCde/ahKgfHlXuBLpKEo4WRcdHKqhBSmqM31CBUFaEjIFbsRfK48MtmGsqq/5+9sw6zom7f+GdmTtd2d8Du0t3dJXZgK7aiYqModutrt2IXxisiiIpId3cvu8t2nz5n4vfHLCCvoMTiT9/X+7rOBXsmzpw5M/N9vs9zP/dNRFIsN4wawRvvT/1D1cZDoKr46hvYs8HDns3bWD7rB1qpGjXAPk0nK+agtwo2FwSDhMHlILdbR75/8z2cLhfTtq+mIRRgZGoeiY4Izr71ehZ/P4dwXSPa78hmHyskSSQ60kFyyzRGTbyDpPa9Di7cugmWfY3coRVkDyAqIYnJN03k3GuvJRSSmy21HwD86K6sALECuGwWyuKjic5I4cfX36OgRT7nX30NvS84i31btiM3enXX3WPRiDmQadEoB8oB1q8/rmOub3qBPuibjAYiXXZSEqLJSU8gNsqF0+Vk5NDTMZisPPvaKyxauoK6Bg/hYw1MTAZCRp1DFXTaiSquxO5upDwrlRhfgLp332R7h/a0zG3DzcPPZMy7n6FKErD/OhEwGU1c+dBkhow7E0EU0AIhlHXb0dasRV66GvPDdyCmJpI0qgNxc5bhsjppKwh4NI21x3WGTh4CwLZQGKGuEcHtZeuG9bTu2IniwkImP/gAH37wIWozOl0fDWRZYdmqtQf+TmwqDWqqSun2LaTk6zYV3/wwB+oacShHH5AICJiNZh5/4nEGnn3qYdZIJ3lIBwq2dOfH50QafvLiqJIJKzLKYbIBqqZhc/v4+Okn6dJ/IPaYWIRbH6TmjmsQAjLmQIhQl+5Y+48CQJSMNHh8BOFA9q25UIAuDPj69Fl06NrtwPubqorx33kTkZKIMRhCDPgpz2mBrKkYAVET2CUIHInkIgAmo4koewQDLU7ikzJpe/rpdOncmpbd2/P9Z99wxvWXHfdxn2zxtP8v/NcHJaIGkdW11JWXY7XbWbV4Jt16jcAYn4T26meEZ04naDXijIhGCYd47bprSWj0Elb/o61RFNkrirRJ0H0u5PoAgqahFfQEsw1x305UqxM1ow2a30v17LlEXHo2PQYN5In3px7fwSsqogaiJLJNkgANo6IiiwK7mnP2JQpIdis53Tsy671PSI/TNQ+u6jLokNVeePAx+u85B8/m3ch1jc3WDmc0SMRGueg6fCip3Zo+c9V38PTLUFkOF4/BoHlRZn8GZ11Ll4GDcTmsNHh8KKHmS0run/EIkkSi1URkQjRy3y58fN/jFGTlA5CUlMy3b7/LGZMmUrxyPaHyGhRf4P9dtt0kCcRH2GmZm0aXtjn06tqe/Ly2ZHQYhNmpm8z1GjmWZ+65jSdef5sGj+/oMyaaihoM4/Lr6fiw2YirqhpnTS2be3UgY+NW/AYjGz5/n5Z3P0m/lm3pJ0j8qCjsT+ALgkDrSBdDL9Bn7f5VO5C/XYf0wRNoWhDBHyD48w9YizYiGCRiUuKRJIlGQcTd3CerudA0QdBkhR79B5CcnMyOHdvR/h8drrdv38Er99xD244dMMfHk5GVxUMPT+HnOT/SO7MFKUYzX8+eTQPHlphricbo885j3OU6n67iy8U4N69BaixDSEhFbNMKaWgfYguSOffl+3B+0pE1k+/C7fccNigB8MgKS1et49zTx/DNnAVYslqwKj0Hli/HKorEnXoW0QlJBHw+PvvkE4IhGQXYeMJn6VDUAT4gIvKgGeO0DXPZuHUt7TISkT1uHPWN1KYl0Kv/GKxWO7Is49yyg9hAkPIj3PuSKBFtj6BlUg6to5MZd9cEssf0P7B88IVnwIkEJf8QXY8O999/Pw888MAh7+Xl5R2wOw4EAtx66618+umnBINBhg8fziuvvHKIRXJRURHXXnstc+fOxeFwcMkll/DYY49hMBz74aYDxT4/5+dkE3RYkHLTGDtkOVfeOAlLTCymM8/D1LTuK48/wpodu1FC8m/Eq1RNIxAO4gvoChLmDrn4zxqM9uZHCLvWoPndaF1H4W3TF9/S6cg7tgMQinBRdxx0cYMk4bBZiHTZiXDZsJpNaJqeoq2pa6TR4ycQCqMci1hV03HkoLfu7t9SNOqeO+899jQZcYnU1VWxePU8stp2Jbasiqr1q8m48HLapmVzxQ3X8foTz+ANhFD216MFQS91iOKBz9BUVU9b/8H3FgRIFgRat27FKWfpqpRa5VaE996D4hJIiIXKWli7HamiAS3gxxmXQIcOHSn94bemaicMQUC0WdibnYw2qDufTJxMr7Q8guEgSz57i16nXUzrrJb89Owr9Lp7ArVL1hMoKkcN/Dm8h/+EBZ1bkm630jktkYHXjGfYiDOxxh+UFNe89Sj7ijC0bMeVt9zBF99/x7bd+3B7/X/My9E01LBMuKaelqquTrvLBpk2M4rbQItVm6hJS8YUCtKqQaf2NjTUU1ldd0g2RlIV3BWVlG3cTFKbVijVNYifPwfVRQiNVYAJNTETZfFypF7d6DK6I9M+e5VGVaVIEHXu118YHreb7duaz33qeKEBrzz6KBZgrSgiigKiKKBqGp5d++iIblFQfwz7TEQnvU+4+UYA9n0zH+szz0N9FWplIQT8KHHphHv2xnDLtRi7FDDmotNxRZgYdc45BI/ALakD6kNhti5dxb8/+ZgzL76Enk+9hiiK1JWXsXHHNtKAqqpK5nz1BU6HlcYmVdVjFen7Pew3XrjulonM+nYGANt++pGGaAtr+rcjJMjE7iunIimKszr3A+CWpx+hatsOxCN03oiCwP233Er7Nh3YtWIPOdY00gfq+lKBJdsQq4phQLfDbvu/jpMiwNm6dWvKysoOvBb+ymVy4sSJfPvtt0ybNo158+ZRWlrKGWeccWC5oiiMHj2aUCjE4sWLee+993j33Xe57777jutY9gBGYLvPT01VHWs27+G5qR/Ru38PbrzmUtbP/wWAuV9/xT1PPs2KsMImoPo/9qNpKoFwkEfe/4R5X/8IgPWC0dimv47hysvAZEOpqaChvobyjHTyHrkHgH2VlcdcDzcaJCJcNgpyU+jbtYBTB3dlyq038uGrr3PFeWPp0jaX9OQ4HDYLknQUP6EkIlrNWBxW0iMc1DmttLSaEYwGfZnFRGpBC7q06wjAUxXrWN5QwSu7VrD53jup/fADlq6YC8Dk0efSoXd3JLsFJPHA9hGRDjLjo7CkJWBOjsMUG6VzUgy/73mQpcF9Dz/C6+9Owxobj1pTBW88D3v2wZa9sHEXrNuu6yzkpRIuLwSgf9/+v7vf44Xu1Oxk8oQbWfX4W/RKy0OWw3w381M2VxSzavItAKQlZzDmrDOwZiUjOaz/4ZHx5yENcAqguuzc8/k3nHrxTXpAomlQUQy/TEd4/FakFx9F8/uIjE/ijFGjiHDakI7StVOTFcJV9biaqhFmt5+dXVpS2KkVewpyQVUoH9WPrLvuB+Cbb//Nmgb3Idd9WBCwhsO8/fATADiG90Dt1x9BNIHFiWYxIQTchGbo91Z06xy6dG5FhBxC+4sHJH81bAJWofPpwrJCMCQTDisUAyuBit/f/DcoB0RBoqGJsBvcWYLRW6+baKa0RItLQ9VktG3bCUy8n/JndVuDHsMGYzKafrdooAGhsMxNk+6mrqrqgMxCVGISffsOACAtI5MzTx+Ls10u1qwUjJFOBJOx2e+572fO5Jvv9KBk1OCz8O0spo3PQnqjQkV8AuedeQ2i0Yi7rpY3X3udtUHdwfhw6Na1O/c89QRjLhnHTS/dzaiHz8NgN6O5fchvfEH4vVmou05Mg1s7jtffASelfGMwGA5rb9zQ0MDbb7/Nxx9/zKBBepp+6tSpFBQUsHTpUnr06MEPP/zA5s2b+emnn0hISKBDhw489NBD3Hnnndx///2YTKbf7PePUI4e7Qsa1Dd6cXv9lFfVs23XJ8x792NCdgdVtXW/mybW0E28SmvLeOjeB2koKmfUlWdjcDkx3XcH4g1XIy9YilkR6Tz8qgPbFS1fRgc46pq4JIm4HFZyMxIZ0qs9o0aNon2f0VhdOinw+vZdSUl5lpk/zmPl+p3sLa3C7T0CkVYQEM1GzHYr/exWAlFOap12YhF4aNIDpCencsPdd7Fk7WrOGDIMURAprC8na9oMuv77JzQBGuJiCFjNWB58lJqXs4nJyOHL+56kxex5yA0enRgbH01+bCSmuAjklATUQIhQdT2B4gqCpVWEaxrQjtA2V2Y2c8HNExFFkarN6zD9+11cGbHgbaG3bHv8sGAd9DegtR6KMV3vAGmd0+Kk+BOJJiPGmAiG9O5/QHTs39+8jzhnDg6nAzZuZOO82bTpP5zLuvTj28wZeLf//6k7lgCpRiPW9BTicpo6zDYvQdi1HIpKYO128AYQEqPR1q2AHv1p26kDri+/pqqm8ei4JYpKuN7NazO/47VBQxmR3o4f8jrwXacg7ZZupGRQX8aMn4TFamfrti3c8dgjeknrV7+Ppml4lBDzv/uOn76ZzZBTh2N98m64/kLkz77C/+0vGMt2Y7pYJ4qWbNvFx7O/p1iRj1iz/wfHjuMlh1ZIIpVlZQAYomwEcztirSqDwvVgdyEkt4CKQsTaSsJb9CyxyWLBbrdT56k/7D6TASc6uXxfaSkpmRnEJCQguOycd8Wl3HHpVcQ6dGH+S6c8wMpF01m3ZDnuNVvx7SrRnyvNqRGiatwycSIjBg+hU7tOvFLwMgajCcbfQu+mVbxuN9fdehOhSp10eyTcdu01ADRU1RIRF41o1rOM8vTZCHu2IqKg/WPKcViclKBkx44dJCcnY7FY6NmzJ4899hjp6emsWrWKcDjMkCFDDqybn59Peno6S5YsoUePHixZsoS2bdseUs4ZPnw41157LZs2baJjx46H/cxgMEgweDCF3tjYeMjyCMCOPntQVJVQWCYDncDaM1iHAtT8wfdSVIV6XyPbynbx9Ksv8923P3D2eWfQ77zhmKIjcJ06/IC3xfrlK7h6wgSKli8j6nf3ehCCIGA1m0hOiOacM8Yy/uobiYhvciMNB6C+DkNcEqdfcDNGQUP0+Al7/dT7ApQf5pktmo2Yk+NIzkhCSoohLSYCT+tcru81ilFt9dvs5xmzeO3j97Ga9UtB9ftxVDcQt6cIUVUxBIJUZKUhaxrfvf8CY295iNjoWPp378726pnsy0rB2SEPS3YypswUOuXmcHdkPgt2bWLWF59TZzOzEcisqsMo61moX8MfDPL1tGmcee65eOrr8IXc5IhRmJPjEMYNg09/hHAYtWsPxBb6b79n2WIef/JxlOY0Idz/GxgkDBEOXt+5ktfz26KoCtvjXXQrq8bQ4MNnd+Cb8W9a9RtGt8Rs7u07lAd+WUG5KAL6AC82tf1BkyMy2knrHgkAZQaJjtFRTZ+nIrz+IrTOgAVrYdMOyE6GzfVQp7Ok0h1RtJNlzGisOsrPifUH+P6Nt1h13vl07tKNMRPuoWfZPnbb55A/6jScVjtrt29hxJmnUbW7+LC+IGvRsAd93D95Cr36dMMWEwVtCzC0vQfLw/ccsu4zV91AUV0dstmKQ1NRNY2wEkZWlOPzlvoHxwVRFLAC8UaJyn37ALDlpSPvag0GE0JFIWpMClp1CWJtBeGYFGxXXwDAj9/OpKb2yE/VevRncn3T34FQiEpfI47sOJYKDeysKibWoZNzM9Jz+DZ9Imv77+bsVx7FGpbZKiuEaxqa1Yx0946d3HXjBB599l9YHQ5qK8pxRsdgNBpRZJkxo0ZQsWw56h/43shNhn3VS1ZR9dmPJBm9iLt3om7diRCXjBqRAIETk5v8h+h6lOjevTvvvvsueXl5lJWV8cADD9C3b182btxIeXk5JpOJyMjIQ7ZJSEigvMlSvby8/JCAZP/y/cuOhMcee+w3XJZf43DV3r3onJOjfTADmMNBEmvLqfO5+b66hOU71+B89gk6dOtE/95dyU5LobyqknOvuw63R8+9HO3sRBQFCsxGHrj8SkbeMVl/U5Hh5xnw9qtgMMBjLyOlZTJqzGVUrd+MfVcJiwwiFWHlkMmkYDJijIsiokdbWowdxhX9htMtIpkiNUBPh57F2rZ5DXmtOnLdhZdSUakndbOTsvgxPoriNnkELEZ8ERFIggFNCVFjEamurybS7mJoeibr0xNp2aU1KZ3zcbRuQf8WHTnfmYvdZKFbbjskl43vZkzHLkngDxJqcB82W3Lfgw9w+tlnk9VrAL989j7anjIyAwFMa3cg2s3IXhOyP4gD8NZUc8c5Z7CpvKbZMxM5gEVWkGWFkupyFFVFEiVSGvy4qmtIrt1FZWY6hSIsXTiLXn1HcfHpF/LhM89TKYoIkhGzwYjNZMVk0NPLYTlMIBwkEA4SPlY/pGPB/ueNBkTaYfF62FUEFXVQ2QD9O0JMDACN7jrcRonDOzsdHnEaSG4vI049lbnfTKdNl67EJKUQc+7FAKxYu5qRp51KbWn5EVvGNSAt7Kd+61ru79GHjB69KRg8iEGXnnfIekGPF3/hbgbanIQioojy+lhptVPjqaPe24A74CUkh487OBEEAUkQkSQDYlPwqCgKiqaclED3ZEBA0DvLEZpag5tfkN8giTjsVrrYrLTr0IawrA+isb07Qe9OhOcsRp7hhF9+QqirIGy24enbm9QuBSiKwv0PPERYOXImw8evZPcFEK1mzKkJtB05mC8vv4MYqy56sGXNUoSYaFqm5tIhOZtx+fls215IuNHLdndTB1wz4rk33+L1Dz8ir6CALZs30dHl4vzTz2DVrl3sWbiYCHRjxcbf2cfr73/AueMvJ31YP4pf+ABt20qoKEI029CCfpCDIP5+afuP8A/R9SgxcuTIA/9v164d3bt3JyMjg88//xyr1drcH3cAkyZN4pZbbjnwd2NjI2lpaX+43bFW9RoALxoVAQ8eOUiNpw5JlFi7ZxMffPQOnWR98Dwe2qMkiuSZjAwYr6f+tPVLEJZ+D1/Phm179RnvjDfh2kcwJqWTm57KgqRYAuXVCOHAQYE2QUCymIjOzeSLOx+gV7uDhKr9pl1lH71LydRXWXXTBM4/5UJioqIPrNPCGc2+1i2JLC3HGxuNFAhRnZmG0+oiNyUbRVF4ZclCItMSMQ3pwUU9hjI0rgUuo+WQ73Ntt9HkJWSSfIGAv7Kahx58iB1zf/nN9968eQufffYp48adT/s7HqR+1VLqygoxrt6FqaQG2WrGNPJMAIp272K+N0BqWCYS2Hwc5/n3oKgqLreXqxPzkUSRyl3byHnhdcIGI16nk8SWreh17+OEDHrq1WqzM/LUs1i9/V84zVbinDGkRifitDoQBRFPwEuVu4by+iqqG6tJCwfZAzTXY1RD13woKi4hHApiNJnBlQGBXdDg1gmBgQAsOdh23Khp7JQ1So5hFNuGTkALlZbTtkcP7C4np592OpedfQ6hQIDzrryChrr6P5y1SoBfDvJS0W4SS/ehzJrJKd/PxOFysHD5ahxOB1JAoZUtmpwxIxn/2ETKF63kqxc/ZYPPzc7KQgqriqlqrNH1f45xKDaIBqwmM9EmK2kmGw1WG6qq4g36cQc8+IJ+gnLoL5uN0b2DJEwGI0bJiCiItA4HqdE0dmpKs2WSDJKEy2mlZWYyV99wA2eNn4CmqoSqqzBGxyCIIsbBvTAO7oVSejn7LrgJRg0h7jy9hferz75gzYa1R+y8+e0XExCtZgo6d+DTayYRY3VSV1dF+b33EFqymLqkWFwvvkFyVkv6Dh1LgTmGa65PZ/73P3D/E081e3nP7/ezdvVqhgClgSq+fv11NnH0VgELFy1i25at5BXkYxnRC6V4G2J8KkhWBFVF8LkR/qLX2P83TnpLcGRkJC1btmTnzp0MHTqUUChEfX39IdmSioqKAxyUxMREli8/1PO2oqLiwLIjwWw2Yzabj7i8OXFAOlkOE5blA0qfGhr70E/q8V5u2cOGY42JRXY3IP3rEVi2CUySXp8vroDoWAA0OUwgxoYc4aDcYPiV2igIkojksNF78MADAcne7RsIzJxJ/IAh+OtqcT/4AN6O+fgi9UCxZF8xLpud6PgEBt04GW9dNTu/+ZyIl1/BKIcJKC1JzW4PwJJlSyiqKCN2dB8ebNefMcm62myjz8O+Tz9k84aVdJlwOxnZeYxs2oZWMLGmlpm//HLYWfT9U+5n9PARRKWkEpWit40Gz7uC1W+9jCMljbZtO+H3enjx7juwmIxoES5CShhrSCEky8fWhXQE7AJETSPL7Udq2p17ywaStu/EExVFVVYG7e68B5PDya+ZTSN79yU/MZ3YpFTiY+OJiI3DbjEhiQIKGmFNIySHqNpbyKXnnEtGVflxG7MdDmFZobK6gc1LFtC+/xC4dTIs7wcvPQkrNkJVHQoCIb8bK2C2Ruhuq8rRZ5oOSVYrKt66Bn6e+i5rpr5LMdD4q+vv97C/nVMIBdkbDiEFvbz15WeIoojFaKaLK5Y+qXkkdx3IefdOwOhykjZyIEMKIWPHHrYWbWHdzrUsZasurPY7M/H/hFEyEuOMSQo/3gABAABJREFUIi06mZ6OSBJdsYRiUgijUetvoMJTzZbCbZTWV+L2e/5ygYkkiliNFqIdUSRGxBFpj8BsMJFBiPw+3dhSUcrH383A7fciq8evkSKJOq+tZWYyT9w7mX5nXASAIIoYzCbkFydjSMxFOFeX4JeSE0ia8Q5Guw2A+opKJt93L8Fw6OhDRkEgPTOTX555HavdSUVDDf/++l1yiwsRkhPxWs2EFy+BrJYMTWgJZ+v8qcykNO5/8umTwjkSAS+QBMw5xm0VVeGdt9/hiaefJPm2a+C2a1Cq61G2FqLMWYA8dxFayH9Cx3es5NW/CyvrpAclHo+HXbt2cdFFF9G5c2eMRiNz5szhzDP1me+2bdsoKiqiZ8+eAPTs2ZNHHnmEyspK4uN1tb8ff/wRl8tFq1atTvbhHjN+raoIhy8THf2+wJysO4sGdm7F3jpLD0S27IYaN1gNsHg1nAuCwYhgcmBr9OAKy9T++ooT9W4bY4RuClZdWcqOSbdhqXfjf3sqViVMQ3QkZkWjLEM/x2FNo8vl5/HSNRMYMHQk9qhY2l96HfNDAbRXXyW6soHWfYcC8PX3s9A0DYPLTk6Cno1asOIXal99maQtO0gyGNn4wCRK+/VHateWbl11UvP3y5dxSPT0K2zfsYPc/HwG9O9Pt25dOWPMKWQXFNDz1oNcg9cn34HaWE2vznnIskpdoxdjRS1VtQ00evyE/qDOezRQwzKBugbiY/UAOFRVRV1yAmZZwZWajDlR/30uXTKN9PnrOH/AGDoOGUrHIb+3Vx1JWencfvvtXHbXnXACg8Z/QlEVnDX1PH/VlZz92MMMH3sOYrd+yK+2IvzWU4QLixF6DcfRdwQAJXuLaPT4j79UIQCiSLDpX4um4RElNEU5apXb/TwbVVERAINkxGa3khibRuv0NrQdNBhb4kE2Vqur+pO9M48Oy1LInFqCVB/JDG8DcuDoMgOSKOGyOshPyqFLdnvaJ+UwdsJp2LNT9GvZqQ+oG+Yv48l/PcdXs77BHzz2TMzJgiiI2Ew2UqIT6d+pN+ecPpaErCxiYl0kttXVR5WwTH1OWyoqi5gfVDiGkOAQGI0GYqNd3HLzTQcCEm35DwgF3RCdkYg3PQrhEOG1yzF20Cc9RrsNd0UFLz33Is+9+QZVtdXHXKrMb9HygNHnL89Owe71g6YQMhpIKq1Aef5FSqKjMUVFEt+jLwA/LFrAyRpuVWDJ8W6rqbwzdSoTrr2G1JxsAKTYSKQ+HaBPB9S7rsYTDPz+Tv5H0exByW233cYpp5xCRkYGpaWlTJkyBUmSGDduHBEREYwfP55bbrmF6OhoXC4XEyZMoGfPnvToofdwDxs2jFatWnHRRRfx5JNPUl5ezuTJk7n++uv/tEzI/xc0VSU6PROA+tpKJFnF+sjV8OlPsHwT1DZASQlsWQcF7clt3Q9DxSu0CIVxaBq70Ou0AIgCctPDWhJFqlITkeJiyG1opCg9g/rEWOpS4nCs3QjpfclITiVcVsU5d9xGVJvXuP+qGxg/ZCw9L5vAnKBMl7MuJCYpmZrKSj796BM0g4qgamTZ9IEj5olnMZbsIWl3CX6XC9VgwPraG2zv2paunQcgiCJfNbXbHQlVVVVM++ILpn3xBXffM5lrrrySF15++cDyQf360mNwD/z+WmIjkvD7Arz7xSds2LqXnUXlVNe5j01C/XBQVFyNHhIj9XJWwWXX0titD6HoSGKT9ABsU9U+5n7xDdHz13DhcD243rNyPcEiN3EhFZvbg+r2IdZVolkdBK0ODKd0x5mbjDM5DYvRTDik4NB0/n39iR0xmgZV/hCbSyu5d8oU1q5exs13PoTVGYtw1f2YVAXJrnvLfDXtE266+x4iAsGD18qxQBQQTUYkuxWvw4YoiUQKIjZVptQf0lVug6Fj0pHQ0MsFETYXUck5xHfqS+aoNgDIs35BSEtBatMCa14ymXnJ2NOjWHHjXdgaKvEGfX+o4i4gYDaYiHPG0D6jNT1yO9H//OG42qX/Zt22/brzQb9PiDz/El7//GPCR2mmKQiCzu9oIjY3NxJFiTZ2FzHp+Tz+8mNEpif9Zh3JaGBQ646sddexVtOoOY7yliAImE0GBg/sz9mXXAeA9vqLCOt+gfxlcOO9+opGE4b8dnj2bGPZmlW8/94n7J7zCyVeL1XHeQbMTTpU5dXl1JgkIhtlIqvrCEoS9VFOfL4g/ndfpiI5nvPbd8FgtfLeRx8exyf9OaiprSGvdRtSY1PolZjGgA6daDuwLy2H9MGREAMnGJT8Q3Q9SpSUlDBu3DhqamqIi4ujT58+LF26lLg4vaX1X//6F6IocuaZZx4inrYfkiQxY8YMrr32Wnr27IndbueSSy7hwQcfbO5D/UvAgZ4e3AuEVY02LfSW15LCQoy/rMK4dCPSfZfDzefCy9NAMtBYuY6IgvbkdOyJMymDhq1FZPIr0pimoYVkgh592FFNRuL37kM1GKhLTWb5KYPI2rqLovxMzPuKATCZzVzVugMffvkFhXVubtp4M3EvWRk7aCgjJtwBwLYd2xk1ejRlxcWYk2JpY4vBIhkJBfx4y0pI2ltBQ2wsBkUmaLewvXsroloWIIgiu4sKKSrce9Rp1nA4zOtvvoFRk3nyxVcQBYF2p4/7zXr2+Gg++uBdNA38gRCNHv8Jk0n3KRoXnT+O2x58kJHDR+Jq3faQ5YZGL3VzV1JRWs1Ps3+kZYeO2AUR/6xliA1VqCE/4p6NqKKIlpyL5IhBbJcKucnIdY20lQyUarp+jsqJByUAVZqGz+dH21vGOx9Oo3L5au564Q0S8vXsYu3eQp57+kleeO99Er1BGoB0BGrR8O4nS/4RRAHRYsacGIMlIwlLRhJJObkkBcP0bdWRXzZv5Osv/02wrBrF4ztqIrKAgEE04LTYiXNGk9cjE0N8BGplNeEnXoEwCN3aIOa3xHT1ecT264KhZWss5bsQhYNdT0c8bFH33UmKiqcguQX9LxlJbEddXC702QzkBRtRi3aj4cc+7W1Es4kMp4sUQfxdSXNB0I/baDBgFA0IgqBrgygyYSV89HyKPzo/gkCM2UaqK46rb7yGyPQkVLeX8PSfYdtWtGVLMb70DFKLTM5641l+PPdyTFtWI8mhYzZ8EwQwmYzcdtvdAMhrFiHtWgpbimDlZthdDvc/DJFRCBYLjqw8Bqbn8tr7H7M8FDju7AyqRnWp3nKcGJvIuOvuZfGnb1BZXEHr7cVoDz6COSeHnz0l7BVlDFYrpftKWLZ0KWgaeeg8rT3H9+knBRoagVCQ4soSVjTUUFO4g+1ff0pUViYTl/5y4vv/Y23K36z/d0CzByWffvrp7y63WCy8/PLLvPyrGfB/IiMjg5kzZzb3of0lEYn+I0QD5ZrG/lxQ14uvoUYwU1G2B2FdKZbQFqTCSjwWI36fjYim9cKiRCm6b8v+OZ3W5Dbs2adzcQySgcYoJ5HV9dSkJtF24SqCRmj700LSB4wGoKammu9mz6bWFyQUCBOuqeeCs8/hmbsn07l1aypKSrjozjupra0FQUBu9NLHomcTArU11Me7EJUEynKzMKgqzvJKwuEgUp4+oC9YskRXYjxKCIKAzWqmc0FLJElnqWv7dutPzYh4BLtemmrVYySn1+0jEAxRW1VH2BfAdwyeHodDIzBv1Rrmn3oa6bnZDOvfn3K/j+nvfaQfR4Mb79ZCCCtMnfo+V996C/Gd2yBYvsW0fBVYbbrvSVURUsCL4IzBaD0dAF+jF6NkpEYQkLTmUyrIBSRVY5Pbh9cf5PPyGr7t0Z2OXbpiC4aYs24djbKGyWBGiXDRRhSo0gQygn5CYT8eOUyhKnPEJkVRQLJasKQnEtmvIxHd23Jn31FcnHuQRD0e+GT0Kdw+ZTKVa7cg1/6+FYEJfSARBMjWNPL8PiJCQQzRkQDIP69AK9yG4KlBaaxGm/4N8oDuGPKy6N6nM18u+JZMTcMGbEVvjz4cBEHEarKQGBHHmMtHE9sxFU3VCE95DOXDT9EK+iB63AhJdkSzibA/wM6fF5IgGdh7hI4po2TAaXUQ54wh1hnNiEEDyEhPY8WGTSxbuYJ91aXUeusJhk+cNCuJEj5nFNe/8hydRgzQz80r7yO//S5YIxBCboJPfYjtjcm40hLp12cQG4v3UOttOC4X2lb5BWQXtEEJBZELl2MoqdIfUgYjfPIxfP0FTH0UkrMJJ7TBGBXHnTfdwuIZszBznIGBprFg3gJuvuIy7nn0MeLiExlxxe0U1gdJevNjjE1E/PPJObDJd3N/1j24/sKDrYZGUA6xTQmzM+BlA2BeV8XyYSOI+x0X5f9l/Nd73/zV8Z8ekWMvvohXXn6F0884g/jLD4qweavKKRU+x56YQm5TJ8rzd97BF3PnUQIU/3onqoriC1C4Xu9NcVocdD3rYvxREezduQZxw0ZsNXUk+hS6jDkHgDun3Iunqka/IFQVTVXx1NZz9W23kY4uM33AC0jTUHwBli9ZCteCKzmV8MTbCNw1CUdVNRu7tyI+7Ef2y3TO0YOS+fPmoR0DsVIUBexWM64Y/WEkF23G8OoTEGGHRetBUWDqRwgJ2XQefDHuBoXKhWtxSAIrj8G89/egyQp7t+3kvW07aAtcNGce1zzxBK9O+xzVH0QQRIJFRSyf+RM9x47AeVp/lBmfI0rxqBY7oqZBQxVaTiekHL1U4C8pxYaKTxQJN6NUdgW6qZiGbsxWJisQkvHPmUsMAm2MJmJtERCdiJaUQ3RkNJ0cVryb11PeWEltXTVBfyO7jjAIC5KEIdKJLT+TqAFduHroWC6Oaf2b9cb1GEhows1MuPdefL4AiufwZL5UDmaKijQIaSoRcgDNXQPeeiAVLRRCMNnRAiVodofeYr14OYa8LDKTomjh97BNVQhy5IAEDnasjBl3Oim9W6OpKsGHXkZ9/2OQjJCYiRbfH9w7AZBMRtyZ2Wwv2XWw5fZXMEoGXFYnuQmZjBwwnEsnXkFGa32wvAgIBYJsmL+YS66+jsKyIvwhP+oJXJCiIDCsfz86jRiAJiv4X/4Ypr4HnjqEcAghOh6hYzsAwm4/wW17aIN2nMEBB8q+4aAf2SqieX0Idiv0bgtv7gOTEdZvQG2swRe0EBEVx+5NG4nWNEwcf7ZCkxXe/fRTli1fzFOvv0mfnv3ImaTLPFR5G/iyfDvnRGUR3UT2nz1rls5h4sS4fM0NAQFJkjBKBkySEUEQ0dCQFZlSJYyiKOycO4cWJ/g5/5Rv/kfwa+Er0MWv/kwWfnl5BWeedSbnnnIKF11wAcm5ObRsmYc9LpEWV914YL3J99zN4888g3KEgroaClO0aSuBQACLxULqaH2mntWjP4G6WmyuCESj3kOyY9NGvn/zLWKOMHM/XNu0Fpb58pvvuOeZx3nk1rsY1W8M4Vl9+OnuG9lT72ZPcjJX3nI/KYnJVFdUMP2rr4/Jwl0SRSxmE9UNum+vpBmgrh5sFkiMg+paeOoBuPE+xPQcBpx7DbPf+Yi6veU4NJrPxE3TCKFzdX7at49PL7zwYCeKplGoaUx960N6jh2BeUAP/MmJqNgRLA60EhEhHESMMSIlxBIOBFmyfCVVWvOLqdXCIQaSWtPxlQsiXoudtIg4WkQlkJTSkviuAxl+81is8VGs+3IuX3w8nXW7NxAq3oqpoYqQHP7NQCyajZjio3C0zub8/sO4oSkgWTp/FtP9lUSJBm4fqotmGbUwjvQEgmVVv1F23Y9yIAs9mNbQ2KOpzNc0rL5GKsvq9QxifgaBulJERUao2IcSFY9g07vFGhobcSsyRfxR8UY/G326deW863QzucZP5yLN+gkECVEVYMtStOJNqHVVBBeuwNynK+dfdDbfLf7pN+dBEARsJivtWrbhsYcfpNvw/rrjcTBEaN1WpNYtMdktdB42kDGDR/LJvz+nokE+ov/L0SI/J0v/JrKMvG4jkrseasvRRANayIelQB+oG3fVIIYVLKpGZ1lmHxyTQ7mGRn2drmAjma1UbdiFTRAhLhJh/lqwGiE2Airr8KzcjulxXYF32bx5+FWNrSfyJVWVhkCIFXv3cdp1V7PgqxkUZOnB3lszv+DlH79j65IN9OvRj8KYWL76fNpfriYhCnoXmcvqpLvBhMkZSZXVRVZmKo4oJ9/8+D21jXX4w0G2NlN5778N/+jcNsGAQL7RQowjiuSoBNKik0iOSiDGEYXNZMUgSn9anKlp8On0bxk77nx69OxFXnoaD19/LYVr1xLwePhl+nQefezx32+DVVQUt4+Pp75NSdFe3pn5NfM2rMIgSjhi4g4EJIqi8Oydd+IIyaznGGSoNQ3Z6+OJ+x/iwWeeBMAYEUnn+58mveNAHnjoZfIzcqiqrKTfkMFUVxxth/9BCIJAZVlTDig2CWoaYc4yWLoObEaQVHj0dtSaCkRJov2wUVQbDDRfX8tBbEEfSH+9bw291XfhquVsW7oaQRIR7puEFvKj5HVBHnUFqsWBMHIAABuXrWdtbRVbTkD461hhlAwkRMaRkN+VNudeTY9zxzNy4llY43WCcvszB3LnvyZxxtDTaJmUTYTNdaBcdgACiCYTxrgoxg4Ywp2JnQDYMesbIq68gbPufQbn+k2UBj0ADOjaj1SnHclu1U0aDwMZnQO1P8MRVmRK/G6WNlTy0y+LARA7tSEcl4KmSYQNIh45iG+T3lTsyExhjRI6qtZ7VVM59/yzESWJ2umzke+bRDClBUJqLigBhN3rkNYtRCzeitrEsZKMEmE5/JtBzyAaOOO0M/jmx2/oPnIAgigQmrME31nXEL7xftz3fIhSp4fEWdFppMUkYzNbD5noHCs0TeONDz9l25rNiBYzjkdvRbNb0Ux2xKgkcMYiL1gKQFTbJGJSIihBo0ESj1yOO+JnQXmlPhEwmsxEDb4QX24bfPFxyN1aoxbkEDx9IA0GAxXOCKypGQCsXLgQK5z4vaeoKB4/ddsLOff8cVTs2kk4EGDmB9Oo+XEpn+6r4Jb33+fWp54+Bs6SPskxSkbMBhNmowmTwYgkSroIXTNBFEScFjuZcWl0y+lA91Y9GdJuEBcMOJPXpr3LCx+9xZp1q7j5+puItLua+FDHj/3iacfy+jvgn0wJun5BB4sVQ0QiPVzRKLGpmA1GgnKYancte6tLqGysptHvJiQ3o9fCH0BRVZSQSkmogamvvMbjr7x2TA8ZLSwzfsKN2CZOpI3ZhNthw9SmNXaLlcrSMhp27yEtJNPo8R4f2VJRUbx+7r/rbkx79nLXSy8THxfPTZfp4m+b167hnPMvYMuWLX+wo8Mcu6YRCoepr2/KeYgibNsHNXUgh2GbGawOOOdyxBhd8XdPZTlbBIHAUWpmNAcUOURMXQVvPv40T331Idbh/SheuQN5ewWhrLbYUgtIHKi3u3/z5deU1pUTCAdPKJ1/tBAFEZvBRG9bJPc9eBuZfbscWKbWu5E//hLjhWfhSI/n4keuwR5j5OkXniLR76ZMkXHRNMsWBASDxMCOnXlusK6+uqJwM8Lku0krq6DUmUHcjr1898kbXHrBDSQnptKxTTvUhWvYqWlHpRyrqAqRPjfyvl3MWDibKwM3YbSYCVkFAjFx1GS3JNy+FannnAZAXFpKkw7GH59HVdVISNFlA/etWIlkseFqqEGKjMMUZYFd21Gra3AXdCT+9DEAvDz1XV2B91f7MQBX9ujJyx+/C4C/qJzwOzMQNu5E2rYJAh4sFZlIUXpba0pQoL0tkiKLnUafG+U4L0pFValx1zHlprt588NXcaYnYbr5RuSnX0BDRRA0/BuqkFfvxN4plz4Xn8arX7zPZk3jeJ5WtbW1TLllIpMefgRHp27QqRtqKEh44zq8hjDhffsINvpIH3EaAFtXr2ZhZdVxazP9BqqK6guwYdlKzsltgSKKbBUgiECFemy1WVEQsYkSrc1W6i0OMFsREAjKQbxBH56Ar+l+PPGjNxtMJEUlcGr/EVw+/kLi01Mw+PwYEmMx2fUMX3RSAg898yiXXn05N0+YwIwfvj/uz/tHp+S/FIYm/QJDfAaX9h/MgEvGkV6QBWYzgiSiCaApMj9+/hVX3X47Ne465KNsE2xO7D7eDRUVn6LSEAxT6fVTX70I0EDRsCoKXnRi53+6Ih81NA1NVnj15VdY9PNc3p8/HzkY5O177mHWBx+w5Ti1MBRVxecP4W861YLVjpaYgpCRDAZF12+56g7o1guA7796j0+//ZawLP+pGV0RCPg9FP3wHd+9+zFjLr+Q2MtGs3z8JGzr5hLKzyAtIQ5vo4dvp32CwV1/QsJWx3RsgkCC0UyMLYL0HrqInaYoqGs3EnrhfdTSGuTZizE+PAlj2yzOuGU80z/+kB01ZbRAVy+2AAmqhisY4pJ+Qw/su8wikC4IlKXGIwoi0RWVWGb/jHDetWCEsa27sl6eSsJRBiXJQL4qU+GpY2PxVmorKknISMP05EOoGZm0zs06ZP3nn3n6qLtbNDSWL1lCtwH9afvQPaj334WAzpMBvRXf8/1cDFmZiCYTW1etYe78Xw5LEg2EDpZhKqfOJmbODwilO6GxAVyRoIaazrNKl1P70v2aUaj3P8xbX3x83KOCpml4/F42F27nk3e/4Kr7JmC86iKUlDS0Rx7DLzlxF7TFFeXEDqT16sZWJXTc3T+aBg8//zxfzpzJ45PvofvQYcQlJGLu1E0n4rc7uO6mtWs5/6ILT4o5JprGYiBNVf/Ql+xwEJsIzq1tLrIjE4mPisfoiMIVDlKsqRQ21hKqLmZ1Yw2+kP+EuqVEQcRmttK1dUceePURjC7HoV8lLNPw/lyUcDWucWPIaZnL+598RHST9cM/OIj/6aBEEAQsJgtZiRm88uK/6NDEbD8cxl5xCTa7ldMvvxzP/0NQcqLYBrp2xK9KPj6ajyBWBBRt2UJKejrmYJB2qooHfdA+nrBEVTV8gSDVtQcdJoQf5qLV1SJceyHIZWixsQhA4aqFfPHSi9TUu4/O9bYZEQJWCRqJ/kbeuPN2ugzuT2JGGm0fmsDK8dfQ7bZrAZgzYwahqlLsynE3TQLHqoch4DaaaIiKJ1jrxpoQTeimyagffwwxiZDfA23vFkIXXIkw4wMM6Umcdc3ljL9jE3VBHxb08ko+IPoDfPPcM7TJbUFWy1aMTSxgQb8+JHw7C7XBTVW7fNIL2mGw6DPC73duYgsajUfRsgs66bUMWKMppNdX8sUzT3P9C88TOXjggXU2b9zEwnnz+WbaNGbNm3tM5+32Bx9gyPBh5HfqhPir8lTQ48PssOEcNRgn4G90M/6qa3QJ+/+IbmVg2oaN3LFiNXldOxFhCyIEgwiqgmA2obXqjbpzB1owhGA2kTioMwBPvPg0n8yaToP7WNyGDkJDIxAOUFpXzmfvv8XAXh1oMaQv1lOHEOrWjh03P0OnW8diahoIX7zhZozehhOb/WsCO3cXcvF1N+CwWenQoS29unYlNjGR5MhoFFFi1YoVPPHKKwSCJ6+LROb4iLMCeht4YkQc8al5tM1oS0ZyFmkOC7EpLkIGkdU/zGOZMwbDnjUsb6zBG/Qf9zmTRAm72cZ5p47C6HKgVNYR+nYpor8OSoqRl6xAjM0gaLazec5Ssv51J9J/BC7Hin+Irv+FkESJCKuTu2+8ng4jBujeDqv3IM/8BaGkCM1kQ9NUQlmJRN18MUPGnUOXF15mwfJFzaZB8N8Gv9+PH5jfDPsKBEN8+91sPnvxX5xy8aWYzRakqGhCj/wLuaIcW7YuNb17/mLKN+7EUudpFrn5Y4WmaZQA4epyRow9hXlzfya6SycGr1qMZDBQX1PDlEcepkgJHdcNJwoiRsmA2WjGYjQhCCKKqhAMhwjKQWRFPkI5SENTVcJoVG0tIT0hGqFTR5j9M4R8MP8zREFCTcoiuGAlhgtOYfT4C+GOW0EQ8TU9oOcBWRps3ryVxusu5ckPviAzKR1zWhogsi87mQh3A5aeenvwrKW/8MG0L/F6/GhNmTIbettyPYcnTu9tegEEVZlXX3yBTVWVdOjchR+WLGHBggVUV1cftzhZIBCgTbdupCSlYDIasZusSJqE7A8xZGBfnnnvdQCeeOYZlq5ZeWBwSkTPJO4XmlM0Bdmo29CHGxswGIzQogua3YW4eQmazUno0xlIfbtQs2EbCacOxRUfT8u8lqxYueKYj3s/ZFXB7KnHFvRzy9ln027kKdz27CNEJcXT47MnDqz3/KTJvPnay8i/Okf7mQtHc2eIgojJYCLbZMVpdWBMSMZiNFO1u46Pt3xNo7uWKL+HLaEgwb+weaEkSsQ6o+mU045777mDVoO6IpqMCNJBHkfemUNp/fgbfO2po0QTKFIq8IePT9DMDNiNFiJjdD2u8KZC1K9nosohRDkIe3dh8IewpOdjMTopX7uNxH6dm+Or/tfhfzoo0Us3TroN7g+A/40vUHb4MaycA5sWoaUVQGImapWbxlWbiejelrPOPovFK5eceFCyn/h2gP+g/X2Kfn8SVFXD6w9w3b338crzT9N/5HAefPEdTDl5mHLyUBWFH7/8jPeffRaptpHCE9Qn+TUEQUAUBARBRFA1ctEo0lR8RxAaW7t/u/XrGDV8OD/8+CP2yEhK9u5lyPDhbNt2fDkpg2TAYbYR44gizhVDjCOK6OhoLr/+EvI6tuaqS6/il+WL8R1mlqcBISVMnbeB6no36YAQ5USNz4CaEgj4UI0GwvFpBKvd2IEdm7b8pvsmAGxRVAyNXjZWVOMP6A9uxWRg1tkD6FDtI/rKa2nVQS+lzVqymEBJBYo/eKD+HwDC6K3lf4TyptemTz+FP9A9OhYoikJRSZHuEixKSIKIKIqoH+3iDZtIfo8ePPP0U4ecx4im1/YmV15FVYlt0lGJe+h2GlzvIH3yGUJZCDW7HbgbaFywm8b3/s32mlL6DeiOPcKFx9Mc/WAaReEAxW6Vxd9+Qa1N4tW3XjuwdPWChTz7/rsU/cf1ud+cYyO/j/3ZhfiIWAZYnOS3KGD8tLcwuxyUbtzBjI++ZtG/v2RzTRk5Sh1btODJc70+AQgIGA0GurTvxL/eeJmUnEONWZU9JQgRTizxEXR+ZAI7q8pZvDxApa/huM0YW6sqbZLi6TRSl79XisvRomKRFAWtZAeCIwI1Mh5BDSMYHVijI/5gj3+Mf8TT/gshCiI9evUgpVUL1FAYbcaPGAIKGgaEcACxdAeqMxJjyI930RoiurdlzOgR3HbX7SfwoSKiyYBoNiGYDAiiiKaoqKEwaiCEFpab/eoRAEHUB1kEATQNVdWaZp0nDwL6w98gSQe6DxRVt4dXVfWoZryyomJt9GD0+gjtO9j0unjhfO6ffDcr16wlwRfAoWhInDj7X/dhMZAiGck2mLAazTQajGjhMBFKiI1ymEBTdmI/YgGfICKLEggCK9aspX+fPlxy9tk89vrrlJWVHdexGESJSJuLrLh0CpJzyUnIpO+IAfQ6ZwBmly4e98K/nmLsqeeyt3pfk+T6wQeqqqrEB3zU1+yjsnyf/p7LiSoZIK8rWiiEWJCM4cxTcXbIBeDnn+YQOpxWiaqS7fUjFlWyb8tWCrJa0uHS6xFXLaZTt74Ym8o2WzeuY+2b75JdUYMY0ltS69Fn6cdOdz450DRdM2L/L7gRmPLaazS+9tqBjIgoiEiihCyI+EQJpySiqiqqpvHh629yxU0TiIiPI+L2ywm0yiR09wPI5UV4W3UnXLSNnQI0dsjH6tRT9LV1dSd83KVNL0EJI/oaeevdt0kSFNyaxkffzaS8vPyw91Q1R9dmaTQYiXVG0z69FSN692bgxMuxNQVgaR0KuLZDAZ379OTVBx5hwb6dmJtI2385CNChVRs++uYTLA47SoOH8NOvo81fgOr1gWRC9NVh+uwDpFbZDL93AsvPWsEugwm3IB5XUFIjCFx+711YIlyEKmrwrq/CHgqhbV+DFvYjlhciVpagJmXg638q2V3b4fMfl9HDAfxTvvmvhMaV1+hOl3JtA0pNLTRWQTiApoLoc0NVCcSlEczSSwWaqh737EAwGoiwWbAnRHPKZZfx6DU3Ul1fx4fzfuKz6V9TvGELoYpaFJ//qNvd/ggZAhhNRhodNqwWEwZJRFH0DIQvECQYkk/cL+YwMEgGbCYLLquTlPgk0uPikHftZrMi0xD04vZ7CISDR5VxitQgJKt8MPtHUh64n0WrV/PVzJmoqoaqadQ1UxAnCPpMMdoeSXdbBBkRMSTaIwjYXNRpGru9DSh15ZTUllPrqUNWFQyiRI5kwGaxs8/q1NPfoQClReXc98jjuMNBkgEnunbKH7VcJ6PPzD1AvclKTkwKo9Nbkde2Hz0HdiDt9O4AqI0eRJeDrE7tufisC3nr06kU15Qekn7W0BDCAZSqUmLi9KCh0uwkmJiIFNKIGNiB6DuuPrB+1d5i3pz6jt4KexiUqhoJbi+TJtxERlIqLTp2onu/YYCudTPh8YdY9e1MYr1+rLJCDs0no3+yUf6r/xslAw6znUh7BJGOSHq3aoXRZGLb1m3UNNTy7Ktv8srb73Pv5Hu5+NrLsIwehNC1He57H6Pu51kU2ly40+M47cVHEUWRbz/77IDTeXNAQ2vSJ1KZ8tZbx/TdjgRREHGYbWTHZ3DxuRcw5pYLECQR1RvAP3U2htYZmAd2oNupA5EbPFQ8+xyNfg+hP7G9/WghINC9axcsDjuB4lLc192LbdtmxNpSRL9fL12qCqHb7sPyzbvEtMwgIyeH2H3bqTzOcbsQjVUbNtDr9LGYEmIwd46Br2eBZELwNYJoABSC7loiEsBgNLB11V8lTP9r4X86KLFpGt0H9gPAlBiLNz0Tw14ZIRyGfbv0/LcgELaZSOynJ0Hfeue947oJBYPEZ++8w8hTTqGhsZ6UtEwAoiKjeSAzhwcuuZolq5dx+vXXULN1F7Lbe0ymZoeDwSCRbTERGRNBz3PPJjsnh43b11NSXERpZS0l5TWUV9XT4PYSDDUfedckGXHZnKRGJzF20FCmvPE0okFiyfPvMO2LWWxtarMuq6+g0e/5w8BkL3prasDn48b7H2i24/xPGEQDsY5oClJyaZeaS15aLjmShFUJUxOfRml5EcW7NrDIZKKiJExEyA8mK4bYFC659iraD+rL1x/OoH7+PGo8dRirilnld7M+FMCuqUc1ONcCdqBREHFZHQyyu+huddJqSA9ShuvXYGjabOR/vYJ003jM547l7MvOY9YP31PtqSUkh1B+dX0mAJW+BuyR+ow9rU976PMs3vIqjCb99l/2wzxef/0tVnz/LUW+RtQjZLA8gEcDx+5CTuvRg1GXX86ggQPZvHMH9z37LAGPFzUsU93ENdiLLiX/d4JBlIiwuujevitTJt1Gq97dsEe6AFBkhcrCYmZN+5pHn3+BBx98gCVzf+HBZx4lITONlNefIWLNWsRVa0gZMwq7y8X8efM5+5JL/p+/1R9DEkUcFjt9u/XgtBvPRZBEQpsrCL09HWH9IsKbOqKVVGC5aDhdTx9MtzkL2Fa2i3pfI+r/A4/r96HRGNQzOMGqGsLeIFpKLookItRVIQZMaGEf2tbNaIEQgtFAmdlGrSAed+ZY0VTufvRRRIOZ6+++jYhxo/FuW0/4g2nIed1QHC7YtYZawUDyCH3M+fyzz0/sW/5TvvnvQ2I4yIvXXM9Nb7wKQHD0cJQfnFgCeqaEkB+poQTXfc9ginFRX1HFB++9f+xBiSDQtnMnzr5QtwF3REQiKzKLl/6AVNdA7zG60VzPTt0ZPagvnzU2ou2VUbyHl+g+GkiiiMtuRc5JYfTZZ3L5HQ8hiCJnAr7aCoq2rGX+siXsm/oBO4JhvpMVGpuhrU8URJxWBznxGXTMbMP5l16MaNC7HXredDlZ3bqzcO4KZnw/kzV7N7GrohBf6PdN9I6Gh9Acx20zWciOT+O0QSO44v4bEBUVZWkhkqiRBXgLI6gwa5hsNpZ73ch+P/aYROLzuzPyiouwREdwa5f27J3RjyVvfEKlwYxQWcgmv4fdATfKURADA+iiYlaDCZfVQUJWHr3uvR5HN12uX1m0gvDjzyPWlqO89zna2WPIbJdL946d2Vm+B7f/ULLvPqBRU/j+gw9Iad0as9OJxWbFnthEyAsEuG7CjUhFu4gLeAmjEzt/Dx7AGwrzwmuv8/Trbxxc0PQbtkAPImsPt/FfGIIgYDVZOWf4KJ559zUsDr1EpgZCaIqCZLeSlJvJ5ZMm0rJ1AZdddz3TZn/L9wt/YdLkSVx53dU4OnagTccOAGxcv56xp44lGPwLljj+A5IoYTNbufqWK3X/n+UbkMdPAFVFjEpB3boSpbwQZVAHjCkJ3PjgTXw191skUST8F+P8axrU1ugiBxGd2iI8eQ/yBz9i2rUGQdBQ2/dDLNmKmt4SmoivdQG3rntznCO3pmkEwkEeevJJRKOFa2+/Afv9k6gXwZuch7VNLvbkWGJTEhAlCUVR+PSz5uNL/TfhfzooqQKemzoVd0ISkx+6j8SLhxHs1wqD2YT3428Q7BbMpw5DSkrA7/Fx1aVXUdVQc1SDy68hGCRuvmI8AJu2rGNNxTZ8pWUIhYWkRyYcWO+r+d/gqC3DnpeB3ODWiYLHwXDXzexM9IuNZEC7XM45/9IDypqaqmCLTiC/93Dyew9HveFutnz2CYuvvQaPP3hCegNGIF8yYIhMoGtOB4b3GExup/xD1kns2ZqzerZm4IWj+HzqJzzx0lOU15+4DPeJwiBJRNldDGjfhSvuvwFjpC6AJY3W9T0kwORrSaSnF65p31NnEpEdEQzu25v0FgVYfkVcyxjTl/j2Bay673kqN6wipXwXhdVhvMGjqyELCIiiSIQjgktefQRHaiJaSCb85ifITz4J9ggIBxA2byI8dymmwb2YcO+NzFj4AxWNhyrObAMkSeS+D99nyqcfYzCaiHBF0qF9e0a2ac2eVavZuHsL7eQwfg52wPweLPu/J7DjPx7iGeiBUBbHJm/+V4BJ0jkVZ516KhaHnVB1I55Z2zBMn4a0dwuh4Wejdswlemw3+owdwUvuxzjrissprS5nws038tLLL9G9a2fat2tHUkwMN02eTEPD8bUB//kQiImOIaWdfr+GHv4XQmMVUjiE5m2EiASE2jJ8dz6F88Onic5IweVyIVT89XgKGho/zJnDl29O5bRLL8LVpQA1N4VAsBD129mQFIN4xzNYhvZBMOmdVMXFu/H7Pagn0FEkqwp1nnruffA+LC4rl109nsj7JhH5H+s11tXzwauvsq/sqPWzj4Bj45TwD6fkr48KIEoOsXrD2gPvmTN1S3PXrVceeK+hspobrrqe2fPmEAwf++ApGCSSs7MBWBCuZp0xTPuiEuwNPmLTDornnNHvVGIkC9/8+yO82/cSqqw70FJ5LJBEkSirhdykaDq3zMARn6wveO4eBALQvgtax25o9kREk53WF11C2qsvUbpyDeoJdBWlAz7JRF9nNAP7DmDYNWOQHFaUPcUEbrwbQ04OwtDBGIf0ICY9nmun3ITiLuflF19gG7/1W/kzoZNKHZx30WkHApLfwGZDsNlIHN6dm4f1xtEi+5DF4W8WIPttmMe2xZoWS5dHJrLuvtdIXeGnuqGKcNDH0Vw9+8/D4FFDiExNRK53433iEwwfvwhyGCHoQxUFBJMRz+e/4OrcluS8HB584mHGXXj+gf2IgkC8QSTDasHvsqPZLaSEFYKhECtWLmbu3J8IBIKENI2Vx3CuAuiVzcPpR+xFvw7+bgFJPpCJgGa1U7JHl+oymAyYpn+BWLITrXwPlpmfEi7pT+We3STceiEDzziF6Nui2FdRiqKpbNq2hU3b/p48AQ2Nqppq6ssqiUyKR2jXGq2mHrW6HKF0J4IqQ3wGbN6A3ODBEOGgVVI87s1hKjk63sqfhVggPuDj7RtuYPmHn3LjG6+QkpeD7bVnCQyejvnMMQcmafu2FfLWcy8Q2LyWLDnE+hN8BoWUMPW+Rm64cQJOVAafNpZVa9ezeskylq5cwdoN6ykqKW4WSYl/FF3/S5Eqwrl9eh74e0fxXkRFJcnlItzo5u1Z3/PmW29Tumc33vDxiesIkog9SvcaqXMY6TZtEVmrNlKfEEfVwvnUmJ2Yu3XDkZlN/97DOWPfHt6etwrEY49sTUB/VJxGiaiUBNIHD0Cw2MHrgcoy2LEH1m9DWPwLmqwSvHIS5uRszh46jDWr1h6XLPV+FIoSnQwmLrjyYgbdeCGiJKIWlRC+8CrwhpHXr0X4ZgZyahri689iaZVFUnwSEaKAIAj/b+2FepeQiNNsIjW/KdDYWwjjL4b8fFi3ATweWLMBADG3JQ500nN45XqERg/azt2EX3oHMTGLwPw8LA9fhyU5mjEXjWTp1tV0MBioAlYf5TFlyjLnNUmeu2f9gjT7KwR7JKrPi1CyG9FsQuvSBdFbTbC4FENkHqefeyZtHi1g1fp1iKKAzWImPcJGu8RYonPTaNmrD10y8tAUjUfeeZltu/dRVFZNpNtHjKZRx9EPLofTGjmaZX9lxAgCRoMZd2EtajCM6LIhKeVoZbuhZVeUyAQMJdsRqotRbzwPk9VKemo6+yrL/j5P/CNAVRW8AS/Lpn/P8KsvxnjOaMJffYlmMCFqGorBjGax4Y2IwdDoxhDhwJmRioz2h+W+Pxv1QAywPeSjZvkifh5zJm+99Srt+/fEcvZYAPYuXs1HH/2b7+f8wLayXdhDfgLNRNhVVAVfyM+5116NeN21B95X/2Rz178r/qeDEsEgISUnMezyyw+81yJNN5iq9zTwlqeYz0PFxESIlDjNaH4JFPm4HkCx9iai4ZbdFOZm0nbOMqLLqtCA3SvWoFkMpNw1mZSxZ/HsOdfg3FnBw+sfOeaPcqDLg6ebjBjioohO0Vs9KS2G0krYWQJmM9Q0Inj9MGoPJGfTMjGRVqLI8cs76WWjiOhIhkzUOzoCG/YiP/QCol9ALNsN3joQzeCrg6pqIItGVcUtmYDj58+cKDQ0LLLM8PgIvBvWYc/KRMjIhKR0KC7UvXaK9/12w7JyJKNIcPIDEAChuhStsQahqoTw67GYJ11BSqeWOGwOdklmqgURjvKhZFVCBBr1x33kWSMJJMSiLtuK8OHbIElokdF449KIfWfKgRT0sp9/ZtuuXTo3wmzi0Ttu55xLLyMs+0lMTMdgP6ggeQ31fDPjOxat2kpZYRmCx8/xyUb9d2C7IFJlNNPZ6kQSxAP8GE0W0AQR7C6ErsPRNszHGG1ENBrwebwU7t7zN0mK/z7sikySt4EP33mPoVdcgLFdPqExI1FW7gSTGcURRSg5Hvv4M7GmJQGQEB3BVo5PsflkQkYvW7YB5ICXnft2M/nBh/l2zncAfP/1TKbcfg913gbqvA00+BqpUo9E7z5+6EHIySPc6ETXY2gJ/psEzv+7LsGCgGS3MvHF54iKPlhCqaqrIuz1EOmI4LY2fZl56URizhxJQWYihigngij9zk4PD01R2blzOwA9W3bB4nVTnxRL2GzE6PZiD/jQVJXdrzzHls1rALjirPPQjoPfUQtsNJqQs7O55Mo7caR01BesXQSbdoCiQVwkBPy6v49fLyg0iiJVx/xp//lFNTa5PexYuV7/s74OrbERtdcpqFYnqjUKzRWFkpFHWNYvvai4GP6oLJ3OyY+eL09N5u7580g47fSDzra1tbBhm/5vOAQN9YdsI6QkI3Vsh+XfnyEUtEUI6zozmt+LvHApqseHwWnnjAtGUyGJlB7BMfdwWCUInHr5eNbMX4RgNGAd1BP7pMuwrZ+HtbIIW9FW4j57GMFkRFNVxg8ZwzVDhqF6PRgkkbhoF6eNG0dCRhapOa30gKShDgI6r6V7l9acOqQb/dvlEpMcx16r+W/RunuyoKGhoOGXQxgiLIgWE5qiIOzcBFGxIEiw4AtURzSGAt2HZ+/Ktb8Rmvu7Qgb8IT9rtm5g6cwfAbA/eS/i9eewzxlNmRrGcMYgnMN0ocnVP83huXen/qVn/rVAJeAOeJg970emPv8CX7/3AddefD4b9m6msKqEWk89yYpMyn/Bb/jfgv/doEQUGDFyBBePPROA6TPe58eJ41ky8SqmvvYoG774EIDYiFjeu+xW4k4ZiTE6AsF4PEGJwp1PP0kwHCanRRu6RWcgBgPIFiulbVpSkZNG2GikLDUBuUktc1fhnuPikwAIskyvvNYktOt08M3tGyAYhggbVNdBrRtVUQiZ9aZNWZYpP8H7UtU0AuEQLz3zCpqqYu3bASkrHmHpDIjPREvKBcmMbI3CW6nX7ZPjorGEgkd8sLvQH5hZh13afFhZXn4wGNmPefNgTxFs3wPBENw76ZDFmqYRbvQjJkZjnjQeGqsQGytRvbWwdQ2eZ/TOlK5D+hAIHZv6paZpVNZUc9PIMdw0+hzmfDELf70bQZIQmrpC9mPu198yf9E8wpqCChgNBhJiIwmE9eyTumcjvP4vOG0oLFoEgC2hDa1zMukVHUGPCAc2q/lv177bnNA0jZCsq9+mt9Y5WPKKtaiiTQ80ywsRijajFm2ClpkAbFm6guCf5Ph8suEBNiOwy9/IxVdfy3vPvYoqyzjPHI3l8rE0dC8g3KENAP+e+j59Ro+hvPqEpzHND0EASUQwGSi3mCg1m8BoQEZh/MSbueDSi7F5GkiVQ4QVXWNlv2rv3w3acbz+DvifLd8IosgdV10DwC/rFzMzUqGfoBHv8eMsLmfjzj2IoTCtz7+MSJuT7257hHvDRh577CkIHBvZVZNVdqzbyDsfvMO1l19Nv/OuoDA2iY0fv43HZqGwIJN8wcbws68kIi4BVVV54803jqvzJhboISvM+uQTsseMZMjo0/VjuP0JBI8GSxdChzy0CDt+iwVTWh4A7sIiFOXEUo2aphEI+pi/aD4rZvxMt7FDME25Gd8zH8DylWA0oCp+6u0OnAn6wLppxQqi5RD7jvBgbwSiOD5TrmPBfDlM705t+f77H3HGJ4KiQMtsWNMkzm0xw9dfQVYcTHwQ0MtVgYYGjC4rYrvWaA4Xalw6gt+NrASpmfMLrik3E5mShGA6dqVIWZWRfY0snjebFWtWke2KxdmiFS6nE9O+IvwGjdm7tlNSVYon5EdGfyZHGCXiol0YQnpQIjol6BEHe9vAK/+CTp0RomKI73gWbSpkfi4qJ6eojGp0g8G/KyfkRBFSwtR4avGFvQAI2ZmEnXaMWzcgBD2oA4Yh3XUVli66Xsx3a9YQCP81pdaPBxoaQTlESVUpEydPYv3O7Tzz0r/IuHQcGb9ab/X0rwmEAsc0yOmCzsJBVw205i8nSCKixYRks5KQlkKd34umaajBEMk1biJ9XlarAkFV5ddSduub+TD+LGiacIzlm79HofF/NihBEPAG9Ie2a/M2cmt2ELQ72NatPalbdtLp+3lUrN7InOLdtL/oCmKTM8jIzKKjrFDJMT64VRXZ4+PWKVPwSCK3XjSezCGjSe4ziN2b11IQE037DD042Fu6j8uvvYq5M2cffWgrigiiLiEfVhSqVA05EODmiTdx3txvuf7myUSlZqPePoXgWUNRnXbcQQVhxFk4klOpKyvlgQ8+QD5BESQNjVw5RHRVMXdPeYgvOrUiMjUZ5+M3U/jWdzTMXY7ZV095VRHdm2ab81avokw9VLhNQECSJAyihCjoZSWDpoKqoKjKSRkEFEVl66493HHdJfzr9Q+wxMTDJRdAxTOgKhAIQ2osWn3jIRyChupqnGmJyPvK8cSnE45NR6wpoS47D8s5Iw+sl5CSpBMijxFLUJH8XtoEA3iqSyku3o5BEBFQ2KiqNMih/1DVFBAlkdzsHNLbdNXfWrgYSrfChp2wbjtcPg6efRkhK5e808bTc1cJP6/ZhlkUKDkZFvR/EyiKTL2vkXuffIrOwwaRmp2O6ekpBM8ZhxYRT8SHryFF64R1T109K+fNIVcOsen/+bibE5qmByZhRebF117CZoCb7rqTXbt3s2bdOtYuWsSH3357DI8mAbPJ2PQyIIkiiqISDIXxB0OEZeWEZAj2QzBIGCIcWDKSePbOe7jinAupaahl3sZVPDTrS9Qlq5EKSzHUNbLb7Ws2xex/0Pz43w1KNI3FK5czYuQY8vsOZdFH6zF5PdjrG7B5/PgtVmSzhS2ajw5N1twbi/cSFoTj8lfRwmECFTXcc+vtLFi0kFfue4jU1HTyOx3s/Pns80+45tZbaSivPLqbRhSwSyKJVgvFdiui0UBAVVkTDJMSCBJdUcv0HxdQXX8Hz731BWJ0DLviYmHtDsQ2HWnVZwgAV1x3DZVVNc0y2FcB/qCPup0bmDBkNA998DaZXTvhGtiaSqUeY5cEImMjsaWmUFdVzfTFC/m1K4gkipgNZuIsDsxWO1azDQB/KECj34M74CEQDhyzVswfQdU0vIEgC9ZtZu4vsxl55kWE23XCGJYhPhIMBujbG+XiazEAaxbN49W7JjPhhhtJ7dgGQ0oitTdcjRAZicNppcXIwRibSmNrFi9m+/btx31siqqwTlXwAJZwgCj081x5hI4lTYOOBe2QjCbUynLEr6aBKIHHDzkpoPrgzqtRnnwZKTOfyJQ0VFVjt6YdsWV5v3aKQfy1j5GKoip/aV7BsUADguEQu0sLGX/p5Uyf/S223t2x7duNEgwimc2Ubt3BK/dOYe7CBfgrSolAf4j+5zNBaDLwE36VHTheh+P/D6iaiqqoPPz8czz8/HPHtQ+DJGG3mkmMjyQxNoqYKCcWkxF/MISlrJpt1Y3sdHvw+oMn5u4tCkgOK9acVEZddgFXnHMhADER0ZzReyiDu/fjtUWzWLdqLakbdzL9y3+juH1/H+bnEfBPS/B/G1SNlz/9mLtuuwtbSirtUwvYoG4lZl8N9upa9rXMYU+Pdljy84nJagFA2d4iNnCcbHMNtLBMuN7NzI+nkf31dLr37MF1Y08nMyubu555ioXz5qMGQkdXthFFJKuZLJcDc2I0/sxkNJcdTVYI1zYSUbgPY1Ud28uqCSxec2Cz6EmPsWneHPpcqHccvfTi83w7Y2azDfLlAJqKwdfIjD3bMD/+BG99+RkxLbOJaXmorsf1N91IXX39gb8NokQ7oxktIpYRmflERsZi8gVx+Hwsj4impLaMvdXFlNSW4Q36mj0wsYZkLGU1rF+9kZFngnHgMKqGDcCe3xbD2ediymuNAQgFAtx4260UrtvMNZEHq9H5Ey4/ZH/Llizl4Ycf4btZ3x1TwCcKegAgigKC0MTiVzV2q+qhz9HD7lNDlmVmzPuZCydOQoxPRO3YEXH+Er2LSNZgcCu04jKULVuQMvMJKxrpXh8W7dBUdjQQhy6Gppot2M02HGYbZoOpiT8UJNtdS50cZoOm/lcEJ6qm4gv5mb90IcMHD+OtN18nt3UrJLOZqn2lXHrxJVSuWUWhHKbhCI95URAxGYyYjWaMkgEBgbAiE5KDhGQZRZX/NgPE8UKSRJwOK51jI2nbNpcBI4bRtddg6hsr2LFlFYYvZ7PeauGjeivFZdV4fIHjC0wEEI1GjLFRJHZty3MX6CX5zeuWsGPnRjqOPIt0WxR39j8N+p8GQL/a0Sz8bvY/2ZK/KP5ngxJNVWksr+KLf3/JxeMuot/5V2F481m219biiXKiiAJSwMuIjgMAmLt0Ad98O0N38f0VxCb7c1EQ9RmRpqFouguuEQ0XukvnASgqiteP1eun8dvvuefb79kjCvunUkd38KKIwWnDkplMY/s8Mttlk9gxH4NTD0oMe0qpKizFu3Q9EWu2ESwqZduSJeT17Elyh84kd+gMwLp1a7nt9jsJn4SbU1YVGkIBfl61nHAohChJzJ8zB3ejm34DB/DD9Ol88sknB9aXRIlYs51WEXH0GDyKq998Eslsxr+jGO+ydQyMSwNDkJ+mf88v095lY0MVW0L+Zg1MYgC8fn768WduuS+I0Wwm7sOvD34nWWbJL3N4/pmnWblmPcGQzK33Tuaa4mIsViv+cJhajxe1oZ4ZP/7Ej/PnHdNALQoCJpOBCKedSJedpPhY4qprKFcUCgMhGj1+PL4AVkUlDahB7y74NTQNgiGZtRu2sGXpAlr36g8XTECrKoOv9uhE50XrCIUVQqEwJkBu9FMSlH/TfWNqeiXYIohMyCA7PoOsxHRy83JJjY+gpLqKxd98TYQo4/PVs3vvnmYRhfo9CIKuKSNJ+7VtdDdkWTl+o8z/xH7J8PlLF9Guc2ceuP466mpqeO6zzwgGj0xsFQQBs8FEhM1FcmQC7fJa06pVPpVl1WzfsYPKhirK6iupdtcSCAdPShAnCE1u4NB0nCeBu/EHEEUBh81CbkYip6XE0WtQV9pfMgHR4iAJyO84AG/HXmRWVCEuXMjH//6eXUXleLzH0ZQuCIh2C9bMZK4673wSnFE01tew6dMPMJaVs+qHn6kcOZYWPfsTkaATmPsNGcziOXNRPM0vQyAI+3NjOjSt+VuND+z7H5fg/y5EaxqxDW4m3XUnJpeD80afTrfLbsT66dvYW4SQlTC53XqQnNGCQDDAlXffiVzvPhBdC4KAUTKSYbSQYjDht1ipk4yE5DDekA+P30tmk2Nr9WE+34PeWWIBVFU7Knnv/RDNRpJjI8jISkLp2x51WE8i42NIMTvI8ENmdDW2TDffW51sr6xjdzDE2f37oeW2YNigQdx0yy04XS7OP/+Ck+rLoaHRsLeQwTk5VIXDbP0dp1STZKRFbj7XTZ5M+4F9MVh1MXNbXjq2vHTimtbLGdqdiEgzES89S1LAx4/NeLy70G8IdeUqLjx/HO9/+BHhUJA9GzYwa86PvP/ZJxQX79Nr4U2GH7+sWMEvK05E3UWHJIrYrGYSYiNp3SKNh+5/jLa9B1G7ewdrv/+Gt2dPp3hPKcHCMna4fb+brZNlheo6N3fcdzdffjUTS3wy9fGZGJtE6sKxkYTWbEPIyMYJxMTEsyss/0Y4r0qUwGynZ1Qi4845n1FXn48tI1XnLzXhkruvx+S0462vJyMjm9rG+pNWojAZDdgsJhx2Kw67BZPBQFhR8PoCNLh9+AM6R6E5gxN/MMCbzz6LyJGVdOLRydhBQUJ2RtMiMYvrrr2O0686B6lJQ6axtIoZH3zL59M+Z33RFioaqvCHA812rJIkYjIYMJt17oaAQFhWCAaCBGWlWYO2PzwWUSTKZadPXCRZHfNpM+JsRIsD6qrB60VIzcDReRitgIIR42jb5TMm3HIb/kD5sWdLBAHJYsYUH8WlrXoAsGbBD8Rv2o4QDGJu9FLV+DEfxULriJ5cYcmkY9u2CEYjiAFoJg6VJEp0UzWSjGbmG80gisiKQlAO6pwvVW32++IfQ77/MoiAoGgEq2q56tZbKMhrRfvcPDpeePVv1n3lo/fZu3YTqj8ImoYoiFhMZmLsUeRGJZHncCFFxXPuLVfQqk9XbrroOuavWoK7rhIp6ONI1bzF6OZlNcdy4E36KpbUBOytcsjo1YMbnO3JEmOwCxawATpnlnN7jGL32Ev5+JNPeODRx1G3bGHjli08+/LLGAwGZLn5nIF/D+UlJb/7HQUELCYzV553Lj3POQUAtaKawAtfIXVsg5QVA0oQQ7d2AJz30F0Mv+Rspj/6KD9NndqsN7sMoGl8/tXXTI+OQpZlxCbuxv4ySnM/3AUBrBYTqYkxdGqdxS0330Lb3oMAiM5uwaDrbsOek8Ci9z9kflimvrSanV7/ER/gqqbh9QXYsnoDG37+ia6nnUl9QialrbIIxUWiVblJu+l2cjt0AcDsch5Cco5ED5irDSYKHJHkJmYx6uoLsGfpFgxqox+ltAIpNR6TU++iskdG0i89i00b13D87JkjnR8Bo0EiPiaC9KRYMlPj6d65CzEC1GzcwIZAgE0llewtraauwUMgGGrWB3AZ+m11JHjQs2wxZjupmS158pnHaTlAHyDlqjoklx1Xchzn33k5g8b25/47pjBj0Rxkt0xIPhENZR1mkwGn3UpstIuk2CiiIx0k+YPsC4WIKK9ll8fHal8Avz/0p7QvG40GoiOdjLjgYgadNg5DVKy+4N8fwNffwLiLIS8PLSMNISadkWeM49ZN27j5oUcOOg4LeulSa8ogH+moBUFAMEh0b92OmOg4AqEAe9etomVdHZEV1TQkxFGdmozPaafIWweWTNrmtESQmk8Nw2QwkhyfzBUjhrNo+QZGyhpVJisuTx2lnnq2+d24Ax5C8p9z/v/u+J8NSqqbXgRDiEVljL/mauZ88W887gZWbd2MZjLRq0U+Ab+fxx54EMXtRZOVJidRCwN79uWzb6ahhhVq9lRhtVmIb5UGwKXnXEBsWTXzDUa21lYgBTyHTWur6MqDxwK7AJlmE6auHbj4wvGcnd8Dg6DfYIqqUNNQi1JRgWqzkJKeS25OHvdNvp9nX3udhtLyA/HRnxWQ1PLHbrGCIGA2mgkaLAfe89/xHEJRIeo7/0IJ+xCcMQTNBsRLzsc66WaicnMY98rLXP7u1JM2AwgE/hx3V0mSiI1y0qNTAZMnTSG7Y299QeFScEZBTB5d+58B3gpqNdgrCFj3luP1H7kdNSzL2Bo8LPviS7qediaZ4y4l7ZyLcDc2YNA0HE2CgV99+SXXXX/9IftJQjcg9JmtiPHp5HTudyAg8Tz2BcKyReCuRouMJ9ShFdH36maTZ5x5Brs2rUPQlGYLEyOBTDRsCbFcffMNRAcaiGufT/cxOn9HU2T8tZXs2riWyY/cz4Zte9lXUUso3HzXt4ffd6r2AbsNJoY7Inhk8h20HNADTVbwfb8O7c33wV+HdNUlWE7pQ2JBDjfdfB2rNm3EHfAQVuQTCnJNRgPxMZHkZSfTs1Nbzho+hpqqHUiFxTQEghRX1GAoraKusJzCkkp8gRMz3fwjCIBBEnHaLfQ5/QIMkdH6gq0LoWIHuOvh/vshMRYhNwX/tbdj7dKPNJeTBEkkBgPFBhGzxYxqkFAUlVBYJhAME5bl3xx7jqoS6QtwXlu902znns1EbdtB4s5iLP4AXoeDyMoq4nfvJWHJKrimI7nJadhtNuprT9ws0WQwEeOI4vnJ9zH22su50O3l57dmsm9zEZbirRQ2VGH11LGzolDPjoUCzTiJEjg2k71/yjd/D6gaqj/Iql8WEJ2UgGAwYEEjTYXCcIiwIKKE5QO5L6NkINoRyWNPPYHNpRu3OWIiD9ll99F9sLo9qJ98Qr2qEawO4Qs1T/0yRRC47sqruG7KQwfeq1owF//TT7PbqGGpqcVWWc3etnks6Nya825/EgDRaIBfqQT81WAQJQxN5zi4YhOabACTBUQNFBk1qxXChvkozz7LetlEu3uvY1/JPv7K3+loIKAPLNkZKTz7wlQiE1PQNBVh8SyIaIQXXoQ7nkBMTKVTn1MoLC5ja20jlTUNBIIhZOXw313TYK+m8c3nXzDo+gm06tkTSZKIjNIHiaqyMq654Qa++uqr32y7DYhGxGaykBgVz8jxutaNsnEbwoql4G2E4i2IW5djqi7Hc+oAHO1yOP++Sdz9+qtQUdpsuWI/MOS007jtpRdJSE5F01QINwWLqowgGbDFJdN2YDJnb1iM+Pl31Lt9yG7vSR18fw0BAZPBSERyBnkjBgPgfeUrhIWrEdz1CHvWor7oRxvcBcFsIlDr48KB/Xj8y1KdsH2c50oSRZx2K21apjOyaz7jTr2Q2D4jAAgXLkQ2mjHYMijds43Hnn4Enz9IaWUtgeCJZ2d+D4KglwnNTbYG2oM3IvjqwWWD0hpocEP7XLBadE8pIDE7hxS7hUSTka4RDpxRTiriognLKlW19ZSU1VBV14jHF0D+FQcupGr4ZZne3fRAvmThPKJKy2lIi6fcZMbndGIKBMn7ZQm74vVrXxRFWue0YFHxsbfo/xqSKOGyOmiZmEXnvn0BMDntjJh4NoEtRXgaFOpLS2lbXMxH0z5hy6ZllIaD1PyTLfld/BOU7IeioiohEMIkahomoANQhXKI46nJYOKcM8+mTZf2qMEQ3sffwtypE2KiC3X5CowXn4UxxkXn68+h/aVjGD3rJ+5/+inmLV/ULGn/HUBibosDf1ft2c4vn75Nal05DlnB3OjBEAiQvLuY3ckH5fNF4a8t3quoKq4mDQi/GIEhqy2IAlp6PkLJDoQd61GtkagiWFvq+q4b1q3n7xyQACAIxIsCbQvyiExM0d+b8x6U7IYFq2HtDoh4Bqb8C2N8Ht36DmPRqq3YbRbEOjf8Tg3eA/wUDtO6Vy9MRiMxsTHExcUR4Ypgzdq1eDyHn/+rQIMk4hQNjBjcm/Ruup29/OkMQED0NKD6A2j2CNS0bCwxegfSriUraGxobNYwMTkzncenfYEkScgBHwaLDUxWPTDa+BU0BGGYXnLt3bKAvQmLKN1lYq0vQEj9c7KBOvlWouOY0RisZsKVdQiffozYUAc2J1pcJlKLVMQoFwAdzx5Cx7OH8GPhDr7/5fhYUYKgl0liopx0KMikd1YqUbl5B5YbM/tgbPp/RlQ81156JVt3TaGu0Uso/NuMQ3NBA2RFQVZAMjZpBG/ZDi2T4ZsF0OiBjATolA9JsdSUbCGVUXQ55TR6n3U6jfX76BofTXJiDLkDRpPbdShFm9fw3BMPsG3VZlZU1FD/q4CzSBDITUkjLUH343Fmt6A0LZ4N+dmkrd1JdGU1W1u1oePs+XS55wEAFFmmaE/hCQXOAjqnMNYRRbc2nUkqyAEgvHw9xm7tsBSkYwFiySIXaNkmnfsuvhSDt57acKhZsiX/rZySv/ZI9f8BTWMXUILO9fh1LK0bnVm5/e5bAXB/MRvxg3cJ33M34StvRnl1Kv6L78L//SaUqjoMdhv9zxrLTwvn0qF16+Y5PkFg/MMPsHCL3rwZl9WSQOf21KamgaxSGxMDRiMV2emsuuLcA5v179S5eT7/JEBXkgyi+NwA2DIcKKE6lOp9CHIQzE606HiwR6I88ggtztVFyVb+PPdvc6MdCQKQqsHAjt0A0MqKYPosmL8GflwBhWUw7d8w/XMAsjoN5/ZJj5OWmnqgy+JoEAqHKSsrZ/36DSxYuPCIAcl+pKsqoiJTtnErik/P8hnOGY2w4ke0XavAGY2Q0gLrhcMwpcQSqKnnvYl3oyrNV7oRAHdjIyG//vnunz6C9bNh3x547Sn4bj4sWAZrlgGQOXwcvXv2JexyYGhGzsAfYf8AM2JYPwA8y7aihRXUunLYtgzBW4dSpRD+4jvUX2UpuvXscdSfIQq6RoxRMmCUDBgkI1azibhoF23yc8gbdjpSYpMZQ/Fu2LMd9mw9sH12RgvSkmJw2CxIx+DBdDyQZZXW+W0O/p2bBkFZNzMtyISzhsK67XgXrEfhoGXCZaedzrj8bEaeOYbh19xNXq/RSEYTWe2789CDzzA2OYb86AjMJuPBQoSmIewpZM2smQD0HjiGgutuR3F7kXyN1MTYcXj9pDz/OvmjT0dVVS697mqKi4pP6DsKApiNJmKc0Yw5+1RESSS8p4rwxVfhP+tSQs+9RWjabOSduu92ZGIipsgEGozmAzo/J4r93TfH8vo74J9MyRFwJC5EfGwsCRk6d8S/rQJnRgFixW5QZRCMaCV7UJ9/ibqIKLZ1bEfvO89DMhjIjYhgzWH2d6zQFJUujgj6FLQ78F57ZzyB4iKsXh+CJFKek05D93Y82GIoAMV7C1m8fPlfNlTe3+Ww5NmnGTJ2JFFZ6Wjjh+C+fy9i+R4EuwNvj2G4rj8VRzt9Nvj6i6/yzNtv/W3EqH4PXpORfmeNAyD8zecY6xp1oTO7VX+1yobbbkXbsQvh1kmkFbTlmYefoMewYSfleCIBr6aSEfCyfPNG5jz0GsMem4jULh9B9aMGQwjuWtSMfKTOerD99dtfM7umhrDWfN0vDsDp97P0h1kMPONsnHH58PFbUNcAe8qhuhb8QfCG0GLjEdKyyOo/FOOHnyKK4kGi5EmGpmnIqkJKCz0okPbtRFUUjIIAwQBayQ6E1DwC36yk7pedxE6+AFtiLO1aZPFHOSWxqcvPaXEQHRlNcmIi0dHROCNdxCfEkBFtpX/vEdhzmwKcbdtgSG9IT4ShA+H+FwGoL1pOpsXEcqsZURSB5m3ddgAZQB1QLss4TdaD3+HOZwh+9wWmOg/EONF+Wok30o5h4oNktNafY0o4TOsRp9J6xKkHdxoOo62ZC50G4sotoOeooWz8cS67PXq2Zz/Ru8bn58Kxp9D3hut58alnaNOtH5bEVH6Y8w3O3UWcOvEeIqJjCQUD3HnjDXw09b3jsvD4NYyaRpYAMa5ougzS+SzhzbVojmi0zbthxQpUgxXplBEYnnuYxNbZnDr+QuY8eC9CwPu3T/CeTPwTlBwjKiorWfTTfHoP6Yf1zKGoxmSEHz5Aa6yCiFhEdx1qwIdsc2L95Qe48zwAVm7aRAv08ssJQdPoXnBo1qXd2Zfg6dybDXffzJZkF26ng/xRp2Mymti6dhX9zjqTqtITq5+ebISUMLsrSnl63CVM/vFbrHmZmD95iND6LXi/nkXUVRdhTIoj7PXyyF1TeO7tNwiG/hwi6smEpmm0Gz2GqIQkwtVVhF58DaNJA4ddr8GbTNC/E3QqQOvb/8BcZ9GiRSgnKQVfD2QC28JBfJ46vt+8jf3hT2DAORj3FaIpHrRzT0OM0+v0qqeSqsYaZKX5SiYpgFVReGXq6ww49QwM3fvChqXwxPPgD4AsQ6NXd78u3g5pWSiAouiB0Z8Zg4flMC889TyTn30M55Xn4169AWW9GTHoB5MFxedFy47Bkh6Pwa4P2AuXLPndMoooiNjMVmKd0TwyaRLnTrgKyfBbQ9BAfZPowPvvwJR7obIW3AGIP0ijF31eXAJINjOi2YigKGjH0H4rIDRxRZrKBhzahRZCL/uF0CUOnn//A/xmM3fedRdp6ZlI516OMuJ0Gj98E/fi9ciGFLJbH5xYSUbjwQ/TVFixEN56GUHxo01wQoee5Jx+LlF7duDaWUJdg/dAUFIL1MoqW155lT179/Llux+Qm55N7mUTD+xyy47tnH/JRaxbubpZRNOyAEUVuO7qC7HFRqJ6fKgff4ggGsDXiGqwItTuQ/16OoHhw7GM7Mvwi85CeOi+E/7s/TgWaav96/8d8E/55ligQViR+eTdjwBwZMWg7NmA4KlGDPoR6qtQXbGE2/RCK99NTJbO6agqLcVQX99spnKPfPQRA4YPZeJD9/HOjC9odDfgyM6l/Svv0bPdANq17s2g7A4A3P3Iw1SXlP4u9+CvAEVVmCmHeH3TOhYvXHLgfVO7AqKm3IIxSVcqufvGO3lx6tt4Q36Uv7mCqIheorhq/BUANJbuw3v6qQTatkdF0KXtG31o63ehXnQLYrdehP0+HrzjRiY//jhqMyva/hqFgFeVqWioRmwSrVVlmb2uaKpatcE89Tmcl446sL6tZDdud22zitmVArWaxqYt21jw3RcAaBfeAPnZkJ6gP5EDMjT4oH0vAJauXozHGzhhH6djRViReemdt/n5qxkIkoTtycl4srIIxqQS6twT8zN34nrgBuLHn4PJaWfT6jW8/Dvt7AICrQ0mxrQoYModkzh/4rVIBglVlgnV1B9YTw4EsEQ2tdxW7YLOLSEpHuJcsHMHbF0HgL3LIOoKMjBkpWBKicfgciAY/3hOKgoiZoMJh8VGlD2CaEcUUfYIHGY7Jsl4oIQYArZwUJNJVhTefOttunXpxJS7b6WqqBApIoqo6+8g/Zc1ZH/0JQANlQfl/4IrF8C7D8D918BTU8BdDet3ILzyMgDO7HakpiRjs5oPW4LSQjI/TJ9By3ZteOCRh6ko0ydiy2Z/T9euXVm7bMVvxC+PF7sBARVndKR+7GW1qIIB3DWIdeWItRVoBX3R7JFUTF+LGgrjioshMyf7v8bA8WThn0zJMUBDIxgOYo/Wu268hSU01FUQERGP1LgdqWQHmrMUvyuaKqNE5l03AfDp+x+wE6H5Sg2qxrw5P7NwyWJaRDj5uGNr3n75HTLSMii49CoKmlab+e03fPPtTLTQn0P4O1GIiozZU8+OLZsYPFIvPX395HPk9etNo8/PnvXrWPbxu8QGfNT+beL+I6M1euttekYmADHtOkC7DgDUfvQ8hvJSjAEN43lXYEjJJuj3cs8dE/jsi+knvbUT9IHF6K2na5ZOIhQNBtZLHk698UKMuRn4qmqY/tl0PNM+YvuC+SQJWrP+Lo2AT4XYRg9Pv/AsPYeegtFqI3zeGAxzFyEYzWhRVSiXXYjB7sTfUMt3M2dR7/aesOM16KWT/fV/rUkZ9UgDiqqpNPrdXHvjzcxumUNmmwJMU66n9Kpd5D41CVN+S+RQmE0LliBYjVx9/Q2EwkfugjFIEpdccCG3vP06QtMA7P3qJwIfzsTUpzOmWy4AIFhRhyFD/32UhCSkveVgM0O0E646B3J1R2NzTCqNw7phj40hMj0JYcNO/DuLCdc2oAZDh51GGyQDToudGEcUbcwOXHYnjRYHQVU3LqSqFK+/gc3hIPJ/SB5omt6WXl3XyHMvvsY7777PxGuu48a77sFgMqHIMqvmzeOhhx5g+GljuOHmOzAVdITvPoX1W2F3KfiC0CodKgrRdm9DyM6jc/teiJ/MPHJ3q6JStreY+++9j4cffJB2bduxbt06lGaWQAgjsFORef+Tz+h1xhgsOcl4k6Kxmc164GMUQA3i7tgPv1NENBkJBYIEiwr/CUr+AP8EJUcJEWgF1IaDdMnXmdaudvkIz0zErMqEH38K5aOd+DSZvfWVJDwwAVd6KtXl5dz72GPNz31QVBSPH6PHR2VtI+369OTU0adw4agxxEVF8dNPPzHp0UdJDoWJ5u9hz50JiGjc99gjRNttzJg6ldmr1uARRRRNQQmHyUXT/XX+xhAEAYMkookCXTSNJ08ZTcYZZ5DSqoBeXbvzf+yddZwV5dvGvzNzers72GCXhaVTukUMLFBErJ+BLSZ2dycqithiIRiAIN3duc12n93TE+8fsyyiIrUI+nJ9PoflzJl4zpyZZ+7nfq77uhLT0gm+5GZE6UCq3lVXwx23XseWn3/FUu84IdYAf4SGRrUi8/0P33PBA5MwmkyMf/MhAOorqxh//uV4c3YjOhpoazBQbjBilb14FV+Lyc23UhR8dY1s21OArKoYAWfbPmiKgJaSg5BbgtEWjgFYt3QhG7fnUt/gPK5MiSSJmE06kdRsMiAIArKi4vF4cXt9h6xecfs8FJQXcdkVVzF73mxCM1PwTXsNc6skAJ6YeB8LP/6YtU47btV3aLl6BEwGE3GduzUHJK5vfkOb+jW2PZsQMyKb1xUVkbpNOwju0Abxov/hLqtC+v4bfYpIiUAw6NMiJoM/j3YeS30XFXdDI7t27eD6Jx+lYdNuvJU1fxq4GEQDQdYAMmJSaRefQU+jhUizjfD0JNrePpaFn/7M4q+/orB0L2E15VR4nX9yS9Y0XV24weGk0enii0ceZ8XMn7jijjt4f9o0Zs2bh8VspKi8iPOHnUlcVnu0865CWH2bvnFDIzS4YNRAtOmfItz3BNk9h6CoDxw+S6hpyF4f69et+/v1jhE6Od/Ld3N+4aq5C+gxbCDmkd1wfvs+lsAApFbJuAYNQm6dQnAvfZpqxew5OCvLkPizgeOxteG0zPy/EjarGTR91Kco6jGnl8XfvbZs2czFTcsDUnTSq2nK2+yKjqfBL5DIzlm0GtQHj9vNleMup95+/CI9fwlNYwvo8+v7yvn0vQ/45L0ptFJUAtCpbCrHaCB4ElCMTrKsrKpizA16mef+22h/973zz5v9qyCKAlazif5mI5bQQExWM5JRYf78WdT++A1fxsTz7cw5SAYDPq+XmvIyavNymfTEoyzfsJH4GjsG7Z+bH3YDX23aRFH79rzw7LP0PPdcGqtruOGK66mqqCI0MpEERWa3wUxbj5PSunKqG2t1YTBZPu5gPAio98lYK2qhKfUe1PEM5MxO7Jj6OsakIJKH6tNI4QkplFTU4D2OzKDRIBEYYKNrcADB4UEQGYrRIOF0e6msrsdVWs2umnqcXt+fFHU1TcMr+1i9cR0DBw5mxqwZxDcFJAA2xU19QzV+aDj/pg2CoOueRCYmAmD/eRni1K+hYBeasx5l8ht4ZTfGJ+/HmhKFVGOmcs9eItLTsNz1KOqEO2n84GVsZ5/P/rBWMhgJx0g4QGggbXvF8tWg38grKmNrfQOu350zsUkgMi4kmu6pHenXqTdpiSmY7BqtxrbFFB/O2ZOuoSy3luo9YRh3rcJRWYyg+P7y996fYaoFAtat49px45oHFlluL8FVdbzz/ms8+coHCB27gqxAdChYzdAqHq2iGvfapZivuRlrRBQD+g9m256pR/3btjQUVcHubuTJF17khyH9CRjQE7/NKxAsZgSDAesf1n/3/fdx0zIByX8Z//mgpGvbFBRNw97gpKqugTq7A4/Xd9Spb5kD2YZnpkzBPyQUWZJoKC7lmQ/fByDjyfsPrC/LjL10LD/Pn9dC3+Rv0FSwvv8b+YD9FNCSpte/AX+lnPlfSnRKkoi/zUKv8GDOiAohtGsWKZ07ExIeSWlZAXkFRezKLeaaS8+n3uVj5Zo1uFy6e6pPlpFllYqTdEJKd+3itvPPpzIyhlD/cNIikhncrg+JYXEEWP3pODyboIgA3nz5Q5ZvWcvesjwqGqrx+I6PjLy26W+A28tHE24g/ayziMtuR5uOncmecO9B62a278iNQ4Yz5bvv/mRUeDjEAxVGA+EhAXRqm87NgweSnJWFFBdBREQyQUkZ1Obt5sunHmT+klUsrKyjvtH558AEDVmVWb9pA716ncHcn36kTYcObFm9msk/zSL/CK5oAbBarPQY1AcA329LsW1ZjGryRxOMiP6hKN/MwGdrheWOCzGFBjPng88xRi5lzBVXIvoFEHDrIwfts/iDybhWLqcuMZ6uDz0NwPCOnZk29zcCq+pwOQ/4wBhEAyF+QbSOSeHcs89lwLVnIpiMyAUVGOLDm/c56qpzCJobxreyi0ZHPaKj/m8zZHnoQab5d8tqAIfDRWZmJ/275ufiNIhY2rfGOLQH8u4i7NV11KsqgYUFRERE0b9HL15/94PDnsd/Al6fl3mL5nPTFdfw1AvPEhodBUBjTS11ZRWU5OQwb/0G5i+Yz8LFi1p0gPhf1Sn5zwcl/xvcg4TsruwtK2PubwvZsG0vZZV1xzUnL8sy9z6j39gdgQ6preh6zjkU79tHldOJ1tjIZ599yox5/0BA8geIQBmno/FTERaTkbioUHq3a81Vt95FSFIi1pQDlVSu3C0sX/4D389Zxqbtu3G53DQ63C1KHj1W5AHFBhPRikhmVCqXnXcBPYf0xBIahtkmYogKBuCOh29DeOA1QHfarZF9LUJIbgBu/PIrpOlfExoazIwvviQ2KZnaigrMBomsHj3ZuX49O3btwnuU+04H6oHze3TjjkcfpWv/QUiGP3eNoamZXHztjextrCNu0x7cXh9O118HXRoa+4r30atbN7olJLA6Nxf7EbQlHojUVNK6dcEvwB9VVpALS9EMJsSGatSoRFSzH2J5HvwwDe8ZaViH9yYkwI/bH3iUqd9N56UXX6JtepvmfTbk51L78guIqkC4vZ69nbuRNvJ8OsUk82hGEg15xQgVIlpTmbBBMhBkC+CMnr3o978RCCb9XBiSIg9qa/gZGVx8RgYXPjSe58aM493vv/5bY1EVWP+HZXmA5PXRu/8QADxuD5WB4TRabAQt2YnbYsbZCPKlV5PapTs+r5dn33jzlOFl7J/G+eCbL1k89xfOym5HjN3O1/X1WDwefPX1rPF5kd0nxhX6v4j/fFByzq2PExybwABg/AQH0z58m+deeJni8hrcnqPtvv6MncDlDz6A/OADx72vlkBW09+tJ7UVp/FHSKJIYICN9OQYhl19JbEDRxz4sLYSQiKwpmQzMDoJTfWjsqqO6lo7TpfnlCicEgURi9FMdHAE4y+6gDMnXv6X64VlteLSK0cjvLiP+upS7K4GFPn477P9UFSVyqoaeg9tOY2WAiDNIHH7w4/SY7C+X9VlRygvRGh0grsRzU9CaNOfiF6DGL5rPb78Uqxl1az1eP92cGP0+SjKzcUfjigokdGznBt37MBeVUNgeCjBz96F7/pKhII9EJ8BcekoFakIhTvAqe+1zO2mrrGBJavXHuR8K3vc5C5bgC8wgIbAIKzucEJy9DpAc1hYk1uu2DxPKiAgAtmaxvUPTUAyG5A370a+/iak8WPRfB7U5VsgKhLLa3o2RpQkAoODm1Sjj55LpCgqD9x7D5OnTSMwsw1pX8w85LqT7ruX1etbQvGphSAARgkhyIYl0ExVTQn+gkpQmzi22Cy49pUhFVegVNUhON0tUo68H6c5Jf9SiP5BaPYaEERMAcFce/Pd9O03lKuuupJVGzYfd8TtbqF2thSqOF3nfSpCknQ79+w2aXQYcM6BD564C0rzYOK1EN0D0T+EAeddwbaffmZXUABVtQ3/CKn1cNjPM+jfpz9Drr8IAN/K7ahLVsHujajrNiLdcCOm68aQdd4Z3N0pmcoLLmF3XQVe+a+5Bi2Jg1QyNY7qeF7AEBpCu67dDuxv0gSE2hqod8C+SgSjiDZ1KkJmd4ZeejMBYhCbJt2P6HCh/sWxBEAQBWoFgTp0l2lBO7zDdFnTy1xSzLiLx/HZ158SkBKPfN4w1C88iI11ULwXRZKo79ifoNBQrICjthKXx401OITMJrn5ZVNeZYW3npQNO4iyWgmqr6cuOIDgOT/BrRNpHZGAvyZS6ZP/NE8qALZwXYPGNX8nkt2Hes/daFGpEBmPsHsj8AiaqvLdm1/yxs+/UiqKx6zJ9sXMWazo1IlP3nufPkP1yjuv14vP7cbR2IjH0cj8b7/j51deJREoPLbDtDgEgwFjSCD+7dIQ0hLY0qk19nbtuD2+PR2Co3li9lds//gL6nP2sbWsGrnBcVDQeFzQOLr57VMjuXRY/OeDEj57FyFvCzQ48J15HuKZo8ls35HP3plMmz59W9RN9FTAqVaZ0h595Pd7N2QBQBBOmRTsPwFRFMhMT+eOe57GHBCsZ0fGnA1b90J2Kkz7Cq6LB/8QlNoyAhIiCcorwWiQaBkrx+ODIIgMGjiQx99+BoPNim9nHp73vkdYvwixoghUD94pn6L6BWG57EwCEmMZcu3/+HLiLZjQ8OPwbtFHC1EQMIgGjAYjFqMZSZRQNRWv7MMre/EpviOe+rpnwo34h+jeS+7FP2GxStAqA1Zu15VjNRVh6lto1wcipmRyxvhrab9wMas+/fIgDSBB0Mt5rRYTflYLVouJJEVBlmV2yioOlwf3YbIrAIrPg2vFYuZOmcaF992BOzWR0uQ0oswyhs2rqTJHsCchgWE9dS7GrN/m4fa5CTdbkCQJRVH4JEQhpciB5HXjDA6gPD2Z6F15SHt34927F1NaGrNueZiuMxbgajpPGhoKGu2vHKe3w+lGmTsDsSwHQdUQJBHVYMAQr/s0KW4vy+cvweV1H/f0RH5+AX2HDcPfzw+f7Gt2MldVPZgzAKm0/HV0zBBF0iwWqtMTCR/Zh9iBZ3B/cnd6Bic0r/LKxdfzcnAIFZu2w6IVbP5tGeo/5D7+b8V/Pyj59iuICIX6BgzTP6N2ywZCH3yF+PYdkCRRZ4WexgmDAz0oEQRBdwKWDBhE/bJTNRVZkZFVuUV4E22AcqBGFI5e7vAEQ0Bg0p33ERqfjFpfi/jRy1BRBSYDFJZBeCjklkFCO6SAYLTwcCRJ1FU0OfmDHEkSeX/qe1hsVhrWbUO+73lMgogg+1DDohCLc6G+Fu3rL+Ey3am2z/ABdJC9GGgSQmvJ9ogiVpOVYFsg4QGhRAaFYxIMRLsb2OnzUuqoo6axlga344hUZj+YM5sxk+7HYDYjlxdCfJT+2wT56VUgBgPMW45acgfChzMQjWZKqw6m0woCmE1GQgL9SYgJIzE2grCQABIaHVgq6uji8rC3roGVNXbq3N6D3G7/iFDA6XGQs3QhcAdhIwYSMqQPYpPyqVRYTGJ4KAaziT2bt7BoxXIURaUwL5/8vFySW6VwuRRL7YKZBDQ4WTuiL/5ehfKEcLra6wn1OAgDUlql0jomllV5B7xgZEXh0it02wPJZkE2axhNfqjJ7dDSu0N1EY3+sUhVdRjCgzn7nDOYPe+LFtGGAWh0OP5yuczBg5uTjVhJwBkSQM+0Vjw04jI6p7fHJOl926baEjSbjY7mYCYNHwvDwXmzg7RO7Sndm3/cMvfwn02UtHymPzk5udm6+vevm266CYABAwb86bMbbrjhoH0UFhYycuRIbDYbkZGR3H333c1R81EjrxjWbAGfD6GsCkJ1p06TxUorm+24vutpHB45QJko4We2cd1FY7j8nAvJikunXXwGrWNSiA2JIsgaSKAokXIsBxAEBKMBs9WMv5+FDlkZnH3WmUgBNgRT03z5KQBV0/CL0ImCdd9+qHuUGI2QGgeZyVBVCXfdgVZTjSEslrMuvA6PV/f3OBU6E1mWydulPxIanF7UumqErStQHTVQW43mtiPWl6Fu345zl55cNxsN+FSNInSiaktBFARsJivxITGMv+gy5i2aw8+r5zLt6w+Z+OSTXNquF73SOpMalUyg1R9J/LM0+x+xbusWfvzmCwCkuHSoqIOictiWq6fbPT6wWVFCohCNZrxuN9u2bTtIa8RkNBIeEki7jESG9+3IXdddxYvPv8PEKV9x7SdfcfWE6+nRPo3OsREE+ln/1hivAlgHPDj7Z95+4039exuN1FfomqmBiXGYbVb2rN/A5eMuR1Z8gIYmK3z4zjsA9B51KW1uf4Ct6cn4F+xjX4CJxDMG0XbuIsLadgDgocceoXbl6oMeBIqq8MZzL+Bx6IXLoV+/h/rYg/iuHI/h6uHY3n6Q0E8ewxAeDECP88/C6HIcUnflvwgL4G80EhZoY+iwM+mZ2RmTZKCwophp099l21MPkXvXbRSuWYazoR6Py4nN5sdlYy9D+AfNIv+NaPFMyZo1aw6KmLdu3crQoUO5+OKLm5dde+21PP74483vbb8LDhRFYeTIkURHR7N8+XJKS0sZP348RqORp59++ugbZDJDfT14FbQ2qQSOugaAtb/8iK++nmB0r4/jgiBgQcNjNNI8rFVUNFX9R0broiA2vYSmBIGGqqmnBNvbIBoI9gvk/JHn8eYXHwJQsm4rv321kMpt26gty2OFox5f6V6K7DUEoB7xAyxUgHCbhaLIEExRYTgz0pj72ocEBwXzzjdfcPdD9+OtqEVudJx0VVtFVRGa2lAWGIApwIZ/gE0320uJhzXboXgvvmcexPTCO8Skt8Xh9hHi9ZGAXh1yMku7VU3j5jvv4bfFvxHbtxMl112N6cnHkGprECQNENEEqO00GO/eYlIyEgmMjmJvYAAVNS2XrtZ5hUZaxSTx4gsvMvTCA4Th0PREQtMTSe3fjXY/rOT7b79FURT2ynk0epx/O13o9cnMX7aMUZddiZqaiauyGmtlPfjbwOmCuAjU2Ci83btjAvJ2bqO2vrFZxEsUBYICbLRJjWPoGe0Zdf4o0rqPahY/s0bG0S4lg8ZIM/a5i6lYvI69BaU4XO5DdhEeAEXm1ttvZ/1vC3Dt28eyrdvp3LsX8YmJrNy8iQ0bNyD/PkOhaTzx8stU+by89vyLpA4cxkVpmSzauJLRvQYQEq4Hxq7GRibecyez35tCo6qRAM2VM6qm8sqHU/hpwSLefvtt+g8bSMB14/7UvvqaOvI2bWbOtI+o1eRTInj+p5AAuEUBOTiARQYPtzct/3bOdKI2bCdr4SoaggOpvPVGtiZEo151FWePuIQrxlzKS8882zKN0AT9dTTr/wvQ4kFJRETEQe+fffZZUlNT6d+/f/Mym81GdHT0X24/d+5ctm/fzrx584iKiqJjx4488cQT3HvvvTz66KOYTKaja9D4S6D3MOjSA8HPDwPgsNdx90OTkLTjD0jiBIEMk4EimwXB3499NjOarKA4XChON6rLgyb/mUjWEhCaHERtJis2swWzwYQGeGUvTo8Lt8+DR/aeNO6GIAjYzFaSIxK4sSlTBhDbpR2XZrUmd9oiilauwlpXyWJBIF3eRqHHqVucHw6iQKTVQlR0KA09s/Fr35oPxkwgOCgYgAkXXUp0YjzX33MH9Tvz8dXUt5jvxbFAkRXKdu8is2tXUgdfRMWCJWiXnolfQhSiBNri9TjNRtxhoYQBhbl72VdSgVdWsHFklRsnEqqmsmLVcr56dwqXTriO2GsvoDG7Fa57Hof6ekxVpdS160Nth3Taj+wFwMv3P0RYTRWN8LdiYUcDQRDxM9v4fsZ0Utrr5dSOxdtQf1mKoWtXzH1bYYoMpd//ziS7Vzr33vkIlQ3VuH0efH9zXfl8Cr8tWAiANTyGipxSlFB/zFHBSNnpeIwiDZqAbYAeBC38dQ6NDnczN8QgSUSEBpKdkcSIM4eT1v08PSBZvQzW/AZDzkfIaEevC26h1wW3YC8vY9yV4/nl1/mHVZ9VVIWvZ3xHInpQNmP+r3/fnSgq77z+Btu3bOPbL74gKiGR0Qm6ENu+0hIee+4ZPv/kU5z1dlBUwuFPpbyhqoKQs5MrLjif/MY6ALxuNws+/IxlO/aybt06tu7eTo2jDpfX3cKewycfGUClINDQlNXQNA2lidsSjG6sGi+K1JqM7Korx6fIGCUD3Uvr8fttiS72h4YnwI+KlAQWBPg4G2iX2YZREZH8uq/4T5pMR4v/6vTNCeWUeL1ePv30UyZOnHgQO/6zzz7j008/JTo6mnPOOYeHHnqoOVuyYsUKsrOziYqKal5/+PDhTJgwgW3bttGpU6e/PJbH48HjOTAis9ubuvHr74HQ0Obl7tpqXnz8frbnF1F1jL9SetPfvQaJRJuFDIuRmx95lOwRI/li00o25+3BXOfg59lzcRSWINc1YHF7CaflWOP7SzRD/YNJDIsjOiiCQFsARp+M7Khll6uBktpyKuxVuH3uk5JaNYgSwbZAenfsSYde+u9W/+o3+I3qhyE5kvQbhpI6rg9hP65He6uEOXXlxFWXUKgoh62eEI1GCmLDcfTtRNjg7ozqN5ge8ZkoXi8Lti1jQMf+nN+9L2HvTWXshGspX7cN2e44aTwTDbj9jjv4vE0bsjp1JuGtT9j527cE1NWi7NmEJTIeLbUDQl+98mD9kiU0Ol1/IgmfTPgUmWvvuIPcknLufuAe/Ht2wjr7cxp2F1K7O4+i3fl0aDLp2756Da+/+AI2WraTEQWRIX37NQckSlk1wlczEEqqUGqcOJdtxJQqYbzmUkLapnLO8MEs37qG6sbavw1KFFVlb04+xUVFxCUkED1nBfaiXMqXz6dx3RJcNfWI8a3pEN8Kl9PJ82+/i8d7gJBmkCTCQwLp1qE9WX0uQhAl2LYO3n8e8othzhL4ZDo0Bc2BUdF8Pv1bzjv3bFauWgWApmr4FAVVUf90v9o5yjJ/VWPR/PmktG7N5eMuY9SQISxavpyXJk/G5WiqAGk6RtWhdgFUO+r55euvGXT22Yzr1ZucPblUAXWqgkf2ICsykZpGGPxJZv7fCEEQCJREIg0SYX4WSq0WAlSVALeHLV6ZOJeHRkXFApSqGn6NTnw19gNThDU1BJfXoCHgEEXqQwLIyW7F8IRsACqLChHKK4ihBRzj/6M4oUHJjBkzqKur48orr2xeNnbsWJKSkoiNjWXz5s3ce++97Nq1i++++w6AsrKygwISoPl9Wdmha0ueeeYZHnvssT9/YDCgepzkrpnBytVrmb1oLas376XB4TrmB7WKTsaR/Kz4kqJwxEWRddZZpCWn8VCrtOb1nst8j/cmv4trdyEBFdVoqobI8cu+C4KA2WAiMjCcNnHpDOkxgLPPHYC/1ULRsq1U5heyuqaOLft2sjF/G+X2StxezwkvyzyojQgYJAORIeHc/uidCJKIvH4rQk4tnpsfhLuvQWqfgRgSTIdLelNTsIvqd3ay3WRBOFx2RxQQ/SxYE6Px79meyJ4duDlOD3pyZn1DwdaVPJydxMNCAv1aZzP33WkMG30hJVt2tqhOwNFic2Ull111NRs2bgQgc9CFh1x3ytvv4O+VOZV4+pqm4fK6ee7F51m0YBGTJ79OSrssgjtmENwxg8Sm9WSfjxefe559mtLiV5woCozu06v5vRQdhvWJG3H3HgIFEahhsci/7EZsm4ZhQB9Ekx82s+2IeCU+WaF02zbiEvTqicCEFALHpGDvPxKlqorgrHYAfP/JxxTuK9anZ/e3QxLws5kZNHAUorFJs3TPTqixQ6MTdhTA2X2R26RTnJUGZ19JUloWM2bO4sZrr2Dblk3YnG6MDQ62uzzUeOW/JcIeKex1dbz15lu89eZbR7VdRdMLYNS4cQQGBNJYXUUsAsWCQISm4ode7WfiYJXWfxKiICAZJIyShCjqFX2yoqIoCoqqHtUYRBQErBYT7QNtJAT6YeqYRVtRI9zeiFpjR3G6qSqvIaS+ka0eH/hkfDV2XHklbK8sol1kIlkXXUber/NBA1UQsLicyJrKmHj92vnfPXfxm+w77iwJnFZ0PSZ88MEHjBgxgtjY2OZl1113XfP/s7OziYmJYfDgweTk5JCamnrMx5o0aRITJ05sfm+320lo6lwKc3bz0WsfsDe/lBUllVTV2HF7jr3sJkcQkPysWJNjMAzsSs6wXhRE+5PR9Hmj4sVfMtF+6GDSNi6j3udjk9tNcF1ji8gMGyUjEYFhdExuy82Xj2fQjaMRDHqnGztI11oYkFPKrPdmos3X2JC/lbL6SrwtKGJ1ZO008PQTD5OcnY7m9eL+4HuknbkIVUV4rrkVKas1lpmfAODvkokyWemjwY+iiPo3KW1BkjAE+mNNSyChSzvuDmlHlGDGbq9jw+rFOGKj8P9qBksLKuh96wNkpWXw42tvMWr4cAqOsqM/SP+CQ7vEHgk0DTZu2sSt48YxoPcZ2KKj6dK1KxEJiXjdbvK3biUwOopFc+aQu3oN4UD1MR/txEDVVBrdDhauXESHbt3p1KETXbt1pWOnjvTo1AGjInPzHXfwy9KlJ6wNP3z6JRlxyQS06kBi30yE0BCkDpn4vv8RIbM7BIWhVdQCEB0VTLjsJU5VD5txitM0Fk2dilGS+GLeXIxGA7fcejuR0bEQrfdhs7/8ggn33IssK3RDz2Ds36+qavhF/G5aevA58NxzYDZAZiJ4fIgeNzYjLJnzMRrjSU7LYspHn/PzF69Rvn49FTlF+FXWsaWkiorq+uPqp1oKXq+Xqmo9n5KL/iTcn3suQ8/+/tO6IaIgYDIZCA70IzwkkJAgP2wWM4qiUt/gpKrWTlVtAy6357DTYyLQGqgxG4lOiqZPShyjx11JhzHX4LVXUVmwkbKffiCjvJoFhWWs35aLZV8FLo8PX2UtDRt3sXzJAtpdeAUhXXtg/fI7cp98kH21FZRHR9AzoTOSZMDjdDLr+xn/muDgZOGEBSUFBQXMmzevOQNyKPTo0QOAvXv3kpqaSnR0NKtXrz5onfLycoBD8lAAzGYzZvNfx+vrfvqF3Us3UupwU+7RXT6P5+EiSCKSvxVrciy+gd25p8eZDLPo9uHbli9gs8HDpd3PpKc1HMuAHlTUNiCU11Du9ID3+DsZi9FMVFA4bWLT6HnRMASDhLJmE6pqxNhD13T1T43hgrsuIbc4l5LaMmod9fj+ARGr30NAoNfwQfr/TSZ8lgRM3s0I9mqwBSC00cM4uaKOfbUipf4h1JhMHC49IIgiMfFxTL/1YTq3aY/YFDgsWLcIv5JSsvbkk9Mmldjvf2FVaTm9X5pMx779GTpyJFO++fvrcT8kUcRkNGAyGZBEEQ3d8dTrk/HJf+0Se6T44rPPmP/ZZ7gFqLDZaNu2HZU7tuNrbGRfk9BWKKeeMN9+aGj4FBlZUVi2ejnL1ywHIExVCQEqT+CxVU2jcN8+pr31Mf36jyEiMgRbm2gID0Hw2qGyEC29M2pNnb6+xYTZ4yJEPvx9Fw7MmT6d56dPp1LQA9JXX32DceedS63Hy8q1aykoOMC+qAFqm/6vKCoNDhcNXg9++1dw1EBUEKzbBeGBEBeD4HbjN2sRnbLTqF46ncjQ/2ELjWfU5XdiH7qTHasXYlyxCtbuZP32XCpr7C2SMWlp/J2c/ImGIAiYzcZmDs+oc0bSqVtPEhPTsNoC+O6Lyfy2cBEbt+dTWFJJg8P1t4FJOGAQ4K4rLqffBeeTmBxPTGu9OskcHEl88DBio7OIXDUDcecuZFmhzu7EW11HQKMTT24xr0yejKbC2HMuJiA9g6xpX8OSeQzo0ReTSX8urfh1bgvz2gQ4KpXW/6dE1/2YOnUqkZGRjBw58m/X29iUyo6J0R/qvXr14qmnnqKiooLISJ0p/uuvvxIYGEhWVtahdnNIjDrnbBpXrkBQFLapGp4WeCYLkoQhwA9bYjRTe55PdqjuBLr715/wPPwgSQmJeD/qS4hfEG/3u5SxRZUY1u1ALK9B8fmOi3G0n0vSwWSjU2w8frFhALgffAFcCnLhDmiThfmjNzFHhXLR6LNYvnUt+cZ9ODyOfzRKT1Zk3rjjPia+/iLmQH+McQYozgFZhsZ61B05ABgig0ke0IYftoeyN184ojzjGw88QtcsveOoqChmy+Y1FG1dR2uXG58okpBfhMNqRSjMRWuqgNhYUqKLSfzN/gVBwGIyEhRgIzIsiKjwIPxsFgKDQykqKqassobKmgbqGx34fMf2sKgWoEYDURTB7WbturW0aeo0i5oujlNGIOpvoNGkUNp0On+f8j9RUFWVLSiYPU4SK4vQjPp5k8ZfibxyK2phIVpFEUoTf6TB2ch6r5vyI7imNvO7qdUmZ9tGh4PJn3/xl+vn/O7/PlmhstpOcck+ohNT8W5ZhWH3YsQdeRCgk981hwM5IBQhKoxwRSG6pBzziw/B/+5GSMkiKD6bnvHZJGZ0JrTiKcylVWxrcOCRFfKP+YydGLQUcflYYDYaiAwNolfXdrz+0ltEpLU56PNx191LQngAgbN/Y/m6newtLMPe6DrkQLRSAENYKLe9+iYmi+XAB7tXQXUVZPdFjIon4cxrGRb2CxU1dnbnl1JnbyTW5UGrtZO8ajNzd9/L7n0lvHTHJACy+up+Ppt3bOedyZOZOmVKy6m5cnr65qigqipTp07liiuuwPA7Y6ucnBw+//xzzjrrLMLCwti8eTN33HEH/fr1o3379gAMGzaMrKwsLr/8cp5//nnKysp48MEHuemmmw6ZCfk7LFi8pGXKfn8PUUC0mOjWriPZkXpAsmjK60iffEqrPXnU19Sx4PVn6HnbfcT5hfDRqP8xftoMtglQ2wJSWEbJQOuEOC5+R3dJVcsqEdcvRdMUVGsIuAQ8Xy3EeusFJPbrQqBfICaDEUEQQftnRl0aGhafl8W/zGb4/PPpfP5wTG3j8QKKsxYxLhXZFo+8cCmGAX3odH5vPjq/N2899Qy3PvT3PkIJ8fGMPHMkiqrw8+N3IezYjmQwER4cRKs1W/H5W9nbtR3O0EAc46/AZDCyO3cv+evXY9G0Q2YgBAFsVhOxkaFkpSUwbFBfhp95HkltumCw2GisqeCHbz7mk08/Y8uuAqrrGvAcRanxfrVPs8mI1WLCbNKFsGRZocTpQvH4ENTDS5EfKwRBD2rj0XAIAvWCgKrq5eP/lg5L1VR8LgcF5QWsy9vMOEHnNkjdu2JbuxB5bz6eX+YgDNOr/fJyd1HnbsB3BBOnxzO1KisqFTX1lOzOpUvP/siihYaflmAL9EcJDURLjMYdHIDLaia4sBxbgBXDz8vAagH7w5DRHgaeA+06Edu2NyPPv4TqHc/gNBmpdHlPuaDkZEEUBfz9LKQlRXPfvZOISGuD5vMi7FwLa9dAn6GI6Vn06X8ejY3VuNxe6hudOF2eQ9o1iILIsDOHNwck8trlGKwyvPkKFJSDLQAeex6hbQeizziXriV5bFi6CYsgoAI7ZIWQBie1DhfVM2fjvXEipSUl/DT7Z6Z//TWLly7TuWz/lpvsJOOEqLjMmzePwsJCrr766oOWm0wm5s2bx7Bhw8jMzOTOO+/kwgsvZNasWc3rSJLEjz/+iCRJ9OrVi3HjxjF+/PiDdE2OFnXHvOWhEeb10ila56w0FhUQ8P4UokrK8JiNaAaJun0FzPhUFz1qFRnHi/c9QkCLWR5oaB06Nr/3Pf8KWlUpQnUVBIaAx4Xy6VRUeyPWYH86dM7GZDBiEKU/cSROJNYKsMHjZOpnXwNgHNoPb0YWJGThiWuDS/FR8sRk5OoDeYHOPbodloBss1oB8Hk8rHDWURITQkOAlcjiEkRNxVZdj6XBQU77VFL99UzS4l/nEun1kfQ3+zVIEhEhgVxy1lDee/MDbpz0Iqmd+mKw6JVh/qGRXHbdXXz0wWd0bNeaQH8bhiMUQhIEsJhNRIQG0rpVLIP7dOHTye/w87SPGT/6XNq0iqVrkB9JJsMJ+Y0Mkoif1UJosD+poYF0igghNjKUkCB/bBazrm78L0Gq4iOxrpz63Wt57ub7WPj5z1TuKkRTFAxpyfjdcj3WdF2K78Nvvm6SQD+xDwRN03A43bw2+R2cDXZsbTsg3fwgJVddTXnbDuwor2N5WQ07CysoTY1HcfogOx3iImDzHvj0S/j4ZdisO4vHnjUGc+tUiv1tbDYcnqT7/wWSKBLgZ2XQwP607zVYX7j1Zxh/BbzyOjz3GCgyxtg0eg0+j4yUWCLDgjAaJA51WwmCwKWjRgFQ++O3qD9/BPNm6FwgQQO5ER6/E4oLEQSRmPgUtAArglFiJ/rzZRmwQtVYtHgJtsAAktPTuOnmW1m0cLE+ZXM6IDlinJBMybBhw/5ytJeQkMCiRYsOu31SUhI///zziWhai0BTVELtTvoI+sPRPyGJVq++zYZXnyE4rwg08GtoQNmymeLCvcQlptFoMrHvaPNtf3VsTaWdy0GCpx4Az5Zd+OasQjKZ0VARnA1oPjcCEsqPsxHHXsTZF53NzNk/45V91LsacHvdyOqJz5goqoLd1cDcZQvYsWErbTq1w33xeeT9uAKDrGAo3EHdqLNJDNNpc7N/mc348eMPu9/dO3eRt2c3rdJbc87YCXxbtIGMukYMfgEkdC0k2OxPUreOGAWZlM79ANiwfgN1qnbItLMgCFjMRlolRDPpyZexhoShKQrCljXQkAt1ZWjxHaFdb6LTs7jzrnu45dbbcDjdKKr3sD+ryWggOjyYNmnx3H/DLXQfeSFG/wAAnht2Frtmfs2Pk+5lhr2Rsso6PF5fi/VjZpOBoAA/khOiGTfybFIiwqlzO5i/ZhmllXXsK6uitKKO+gbHYUmBpwKqgCivC6FyH/PWLWJZ3h6igyIIDw2nY7d2DL7wTNI6tMNRX8/GbVuOSGa+JeCTFRavXc/5F5zP99//QHDn7gR37g6A/7Il1Hz/LVWL5hCaGIWcEoc5NR5+WAiKAkYJtuXAlPfRHmuHGBJNu4svxb1s/T86kDhpEIQDwpNoh0wm627bflx/3R0IgoiWuwmhohBGD4ZdhbBnN7zzKtx8F+EpPRh+Xh0LVmzFYJDA89dZ6uDgIPqPPBeAhgW/4FexDzQVSmv0YbtgAq8TFi2AsVcQ5heBIgjsNhioF4WDp2RUDaUFeIP/n/Hf9745AdAUhVqXh7e+n05sZiZp6VmE9OqD/6ZBeMq/JLCqjqCifURbMgjy102+pnz7TYuQnDQgwONm+9IlAJizMzBvm4+yej3eW+6Eei8EBKNFJOP+dTXGsRfRtm83xgy9gFUb15BTkU9hVfFhdRtaCm6fh+LaUqZ98jHPdnqe2Ksvxhlspe6119mMyvk3jgHg7Rde4tb77kU5gmBJkWVuvvU2Zv30E706dqdXx+4HPrxA/xMGzdVQO9at5d2PP/lbgSdRFPCzWjhz+FA9IGmwIzx2M2zarjufxkQgJG5EKyuAEVcxYOg5ZGe9TVlVHW7P3xOIjQaJxAA/zkyOoedZA+g95srmz9Q9WxFSs8g492JKiraxZf4iClZuobyq/vjMIgWBCDRUo4HY8GBuHH8Zl951P0Fhkc2rnF9WSM7mlXz3yw8sXbOVjTvyqa1vRDnFA5N96CWoBtVHXm0F5oZadhktSKLEd8t/4r6XnqBTh2zqG+w43f8s+8HnU5g3fwGXDBvKEw8/jBQcTLuevYjq3Zcze/flw0kTqassQHW5odEBDY1QZYfySoiOgEA/1M2LkfqPps+As5DE+/67xpWibhEhmoyIJiOCJKGpKqrXh+r26qKTf+RgCAJDevUhLEnPhGnvvorQNh5ECRwe/Zwu+UW3bhhyEdk9h3P/PW7G3nAjDY7Sv2xG546dMFss2EtLyKsuISzQhqnOAVGhsGEHyAr07gTFOwAIy+qOYLTh9cmEqNpJrJAT0P6DRNd/T872VIKiUuByM3PBEvo/fR/fr10IQPvxN1DesQ1yl07ET3qUzu98gn9oGBVlpcz89vsW08j4QdCYvHc3G5aubF4mde+M+cdvUXr0xNd1OPg8iA4B74bdCKLAxVdcwrDs/vRu3Y306Fb4W/xIRuBEu/9omobT4+b9qVPYvkJvb9oFZ9N10VwumPU5/kGBrFm9hjseuP+IApL9+Hn2bM7o24c5331DQ0011RXl7Mrby9pN6/hq6Tx27dwOwJ5tWxl24YUonr8vhxYFAbPJyMDeA/QFq5ZAXr5unFVUAqu2QGUdrF+NWpiDaDAyoN8ATIa/n24RBDCZDCQFB9A+I5kuMUFodU0FlLs3IM6bhlC+G4Dug89hcHwkMZGhWMzG5qqio4IAgkFCslmIDfRjXM9ufD1jJjc88+pBAQmALTqR7GGjefD5qbz25ntcc9UV+Nus/4qReQ56Ka5X9tLodlLdWEtlQzVVDTXUOxtYsGIZ67duOSltUzWNFStWcsmIsxjU6wzOHzaMhfP0aZkxDz6Ony0MT1wqst2LZndCSTnIKmSnoQ3rgdupG9L5BYXQzWw7rkqvUxaSiORvwxwTjl9WCoHd2xLUuwNB3dvi3zYVc0w4kp8V/jCtqGkaBdV6fZfm86J53TBriW7TkFMEYUEga/DaK3jefBGA3medx9P33HfIpmzbuRMA/8gockQT1SYTPqsZrbQKTdPQgoLQbGbcndPRNBXRYCDUrdCuwUEkBwY//zi0Y3j9C3A6U3KM0LwyQkU1PResQe6+CboOwGLzY9SrHx+03jdzf+a+++7TJZ1baMQjqwoNrkZevO02nn/jNfJ3FZIxdADh8ZFYX3sU+22vIBhFVECZsxo6tSamSxLn2UaT8OtqfLNlyuqrsDkdmDX5hCuGamjU1NWS3fsMunbpyl13380FF16AX2QkjsZGxo69FK/v6DVUVi1fwZmrxiCaTUg2C5LNgmCQ0FSN1g0OspJSmLFrF27HEY6WBUjJ0EWOhKWLwGbTO7gAf7CYYeNunYjaNPpODo867OBDr+Yxce211zH63of086E0pXfr66GwHBb8DGMz8cvswgUPvcKupx6hoPgbHC4PKEdxzQgCgsmAMcgfc1wUGd278MKr72O0WFEVGcr3IES31tVG66rh1xlo/c5Eioojq2MPnu3Yg1bh0dz84EPIR3Pck4w/VgH9HhnoZbsnuiroj6jigFLqjF9/ZdZvv7F03jx6DhhAr5feA0BTFcjZifbuZNi6FlITcH8+B154A4B5X3zC5vz8/57RnSjqOk8pcfi3TaVNr25c2W8YZyZksDF/F/OL89i1Yi3F07+jsKyaCqcbmrJ3iqKwctUaKkr2ERkbj5rQBnF3AYLsg6RoMBkhPAR10160Tl2bDzlr9pxDZpyKi4spzs8nLjmZLjffj2PBL3iiE1B8P2EIDIAebfElZ6Kl9EEQRFavWMLiNetA08v2T2QJ/P9HnM6UHCs0jWinhz3l1Xz44ku89u4b7MrXiwTt9nqWLF3EwNHnc+kll5K7dUfzTdVS8Mo+1m9cz5jBw7jx8cd58C69YkUM9MPTNgsh2IoRF8LKVcizfkYwSIRkxzJ44ijufORWYoIj8Vis/6jegKpprF67htFjRtO6dWteefRRLhw5kr05OYff+FBQVFSXB1+NHU9pFe595XhKKthSa2f6+g1HHJBomobPp2AL1vktskGB+AjdZVgQobwa/M1osemIrbNRFZkZ82cjy+rfTt0IgoDRKBH0O88mQTLqGZifv4M6B1TugyU/AOAXEcujz79FaEjQ0WVKBAHRbMIcFYZ/hwwiRvbm0QcfxWix4ijYBfZaxNg2ekACgAiL5yBMfRKmPde8m4CgQFqJAh2P/MinNAKBgJPdCPSH6YOXXkr1vn2oqoq9ogxBlBDS2yK8+AZMn02j00i104shQVeFfuuLL9jmU/5b0zeCXrlojo3g0rFj+Onh55h346OMz+5NZHA4wzr25rmR45jx5Kt8MPUTQmIikKxm9rNU0xWV8PoGFv6kF0d4OnbDGROOt6IeRTSjnHkBXksY6ivvYuk9AI/bzRXjLuWb2b/8bbPuuvVWnA4HHTp3p82dj+B/2dUY3vmY4nHjYeKLWMfeiq1VBoos8/zDD5LrdLMdyIMWUWc9VfHWW2+RnJyMxWKhR48ef9IQ+yPq6uq46aabiImJwWw207p166Pmh57OlBwH8oBQt4+thSXMnXgPd5kfICgomHp7PZrHh+rz6VM2JyD9qqGxU5WRFDd+rkoyA/SgR9M0IiYMR8zLhOdfRispRLlxLu533ke6/S4Mg3uS3LsjnTt0Znp5PrLXdWQGeC2M3NxcJv6VLcAfsL+MVWgmwh0wxmpGE4H497LfcHTZSlXTcDtdlO7cTkr3XmgT7kL5+BWkogqorgdUcMpw+z0ALP/tJ9Zu2Ijbe3iS6zmDBpMxcOiBBV99Ap99BCFm2Fepe6OEtIK++sc5C+cRU29n71G0XzAaMIYF4d+hNWFDutNjxFDaxKehKgqUlCIm/S7J7HZBcAi0ygS1DgQX7h1rsbTpSmVtDaoo4vuPWKytOdkN+B2WlJWRmpFBUGgQ/haJ3j27cNGFF3NG/zPxDwlDuO8RcjeuIz4sHGeDnd8WLjklhdOOB4IkYgwJIK5bNu/dfaCisiB3J/aSImyIyG3bkBESS/ve/elwxaXkT56K0pQ1bA0ILi/fzpnL6GsnYOzWm+I92wlu14Oga25GCghif9jtsdcz/qrLmfXznMPypL6cNYvN3bsz9ZWXCQ4JwRTgT3JmFkkX667ydVWVzPt1Dr+99z57li7Dc4rzrloCX331FRMnTmTy5Mn06NGDV199leHDh7Nr165mDbHfw+v1MnToUCIjI/nmm2+Ii4ujoKCA4ODgozru6aDkOFEDICtoioLq9lBdr88HH7WyzbFAEMBiRIwNpVU3fdpBlCQICID27SAiAMFuQ/BGINQ68bz4HmpkJOaO6fQc0Itv5804ZalP+zU9LGYjVosZc1OpbIDHBy43e2QFXwuOIlVVw+b28sqke3h6+ncEhMWgXHIbnh03Y8xIQLM7UG6+A1N4NO76Wt5841WdjOr9e3VgTdMYO/Zykjt2BkDesAJpxmcIBflQ6we7iyHMH1y6jG1dSS6vP3E/pYpy5Gl7AT1LEhNOQMfWBPbIZlyMbli321FJsi3w4PU3rIBeg6BrP3jjKWgVi9TXH4DiqgpKBeGkimOdKogErOjqpQKAIBzX9eYFvE4njR43FrOJ2rmLyV26mn59Z/Lwx1/hH5tAv1hdZuCTd9+lodFx/F/iZGL/QOJ3GT/BZMQQHEhc1oEgeeZT9xA6dwEBdQ2UhAZS3Ckb97UT6NCmK+MHDuPnr77FW16DpqgsAkKB6l/nk7t9GylZbUm5/s4/HbosN4frb7iW+cuWH2Sc+HfYvn07Zw8/k0hRwBESzDc//0KX7rri+NSrr+KtX37Bpai4Dl0c9I/iRIunvfzyy1x77bVcddVVAEyePJmffvqJDz/8kPvu+zNH58MPP6Smpobly5djNOoaTMnJyUd3UE4HJUcESRSRJLGZAKiqKqqqofx+ZK7p958oCM0dmJ7YP4FiWAYJY3AAftmptG6VgKZpB5MUX3kNfvkFYd06pFk/IToMyItWYO6YTo/eXVBV9ZS4uf6I/Zoe144ZTXbH9jR6HDjqq8nZs53M3YVU1TUwzy3jszewzeNrsfNboqhMX7Oehltu4KPPv0WKiaOx22AaOzuw9hyAraPeQf36zeds2LKL2vrGQwoy7YemaTz75hsMOPc8ABref4fAlGgkswB55ZCZBW1bo5aWIwK2kGgc8cmUbtqDdsQZNgHJasYUE46tdSKByXH0seojGc+bb1NZUkRMtz4YRl0EQUEQFqdv1qs//PIFal0tiqpiBFLik1BOdWLl76/xExj4hwF+QLnJiGTQ739N1fDJCrKiHDMBVVFUnC4PmsuNWRJZPuNHasvKsAYE8P3MmXz11VfMnDnz3zttIwgIBgnRbEQ0mxCaRAI1WUYQRQzB/ozo2QeAopJ81Lwc/BodWBodGD0yZZkuVpbtoUObrozo0Z9zzxrJl3veQUPXBKkDWtkbuLxrNwbefht33jERs9nMD++/w8wp7xLWtj2zVq6koqoGz2EGDX9EJVCpagjVtQwZPpxpDz6EKMvM++kXKlUVewufquPDscnM2+0Hf4u/smjxer2sW7eOSZMmNS8TRZEhQ4awYsWKv9z7zJkz6dWrFzfddBM//PADERERjB07lnvvvRdJOnKtHUH71175fw+73U5QUNBx7cMgiVgsJkID/QkMsGExG1FVDYfLg73Bid3hwu32EqKqBEhG6q1+2ExW/AWJGNXHTkXBKXtwez14T4DvjORvw69tCvc89yST+p6NKEqoPi/U1CL+wWlZ8/nw3P84zqo6QqfqRLq2aW3YmbsbVTt1UpGCAGaTiaED+zDzl/l/+rxxXy5IJr596RnmTP+WmdX1egffQpexQRLx97NSkJNPYHj4QZ/JPh9Tp7zNc88+S2lFDW6P74iyGUaDxPTp0xl1/gW416yi8vn7CQkKwDb6GsRh5wCg1NUgNfFZinNzScnMOKKS4FT00fyehCi6ds4k/KzeZF1xOU+bM/GVl1HVvh2+2CjC6huwjrsM8fFnDtpenfUp9V9/hiOxLfFPvkjeju2kZ2efcmXBrYBQATZYLYjmA+Wjmk9G88qoPl+LTpNKkojVaCAk0EZERAiB/jaMBgnJ6abI7qDa7qDO7mzSkzm240YDQYALqLJaUVUVt+dU8oU+BogCks1KfEYqbz/6BDO3rOHHvO2gacgNTuS6BgxB/ix6exoZYTGs+nYaBQvmkbJ6E7E79iAiUZYSx7rzBnLN45MBXQKgTacO7Nm6vfkw8egB425BQBIFJEkkSNOI0qBQVWlAOHBvNmVsDKqKqIH3KES1/YEI9Kn6E4X6+noCAwMPv2IT9j/bnl3xMxZ/v8Nv0AR3o4P7ep31p+WPPPIIjz766EHLSkpKiIuLY/ny5fTqdcCV+5577mHRokWsWrXqT/vJzMwkPz+fyy67jBtvvJG9e/dy4403cuutt/LII48ccTtPZ0oOAaNBItDfRkJMGG3TE2iTkUrfjj0pqa9i/cpllOWXsqGshuKyGlr5NLp37ErbIcOprGpEzMmjzuVlcHwYURmtmDnvV35dtQyPz9tygYkoIJqNXD/qQh7or4/CKxb8Ss0rLxO/bCWW+x/EcOeBtKZgNGKceBOW3TpTIW/jZvaVFZ9SAQnoWamgABu33347AN6KYkyRcc2f+8fr+gSXPfMKxSaR5R9/RZksH5Xc+99BVlTsDU7uuvkmLh03DtXrJT4lBUddLXc/9ghr167D7fE1ZUg0RFHAIEkYJAkEPTMiy7pt+v6RtE9WuPvuuxgxbDiWbj0IevAFNKsFsfUBL6f9AQlAcVEhPvnIvo8M7E9OB7l9xJVWM9jrB2Zw/vILquxDqq7Boyjw3Xf4/SEoYfD5SIHRqBv18tmouHhU9dS6JhAFPEYD3iB/bDERGEMDkawW4hsceBsc5NkdeCtrUZ0eNOX4ORiSKOJvs5AQHUbXTll07dAGo+bGqoFUXMG+ylqW1NjZvncfpZW1BLq9hKI/uI7GRLGs6QWAy3Xc7T7pEEC0mDHHR3LNDddy1tnncdbZ5/HpzhW8Vr4VX10D7oJSkkUbGWG615mWl0erdVtoiAjDXVaNoKqUpSfT9ewxzbstKy3BXl9/0KH27f+PpiErmi7zz++qrJpK40WTEdFiIik5iffvewCvy83Nzz7Lnp27dLL5YdDIKUxkPdoy36Z1i4qKDgqCjsW+5a+gqiqRkZG89957SJJEly5dKC4u5oUXXjgdlBwvJEmXMk5LiqZXp0yuuPIqsnueiWTWFVxHXVjCpjnf8vHc2azZmEPb+Axe/vpzTL+LWjVVRWgygjv3ynF06dydyoYaPL4WGgkJgl7rb9P9Gurqq1n8w+e0rq1CbWzAe989+HbvwjziLIThwxGsVqSYaGwx0cg+mQvGjcfhOvWYA/4Gib5JCfQbNBwA8adP0XL3IvQZATEhsHkL2hlDMKRkcedDz7E7p5Dvf56H9xD8EkEQ9Ck1QUAQdEKrpmlo6qHDQ1XTeP+r6Xww/WvaoyFpsNkgNfnEaM3TZCajET+bmeBAPwL9rBgkCa8sU2/Xs2gOpxufLKNpkJObz9gxFzPts88J7KDzSzxOJ19OfoFFK5cyuMdgzrrwEmRB4OoJNx7xrEQBgChg8snskgQMgf50bZq62VKaR1BsBLKfH2JwCAGaSmJeLoZWKc3bizY/AvsPIbC/bh5WVVFxailiiwKixUxNVCi+9umEt2mFJSEaKdCP1nuKabTbqa2107BhF+7CMpQG53EHJhazkYToMEYM6cPjz76NJTAY1etCqcinbuticitK8c8rQZJEPF4fkq8OUVH/X5cyGoDWokhloB9Cu1Q6Zrdt/mxcZi8yElvxsVbOuoI92EoOBBith5/Hsh1bKG6TTm7XbGoSYhjoH02H7gMBeOaLKTz35LPYS8v+eMhDQ9Qr0YyhQZiiQrn1snHcP+EObFZdlWnHpWO5ZcJ1TJ72CWafTCv0aZuqv93pfweBgYGHzcyEh4cjSRLl5eUHLS8vLyc6Ovovt4mJicFoNB40VdOmTRvKysrwer2YfleB+Hc4HZT8BWwWE0lxEUy47iouuuhy/CLjAdA8LpAkLJGx9Lj8FrIGn8NrTzzGJVfc1ByQyDUODKF+CKKI6vIgWs1EJsUzYfhI5vzwDStUpWWUVDUNVI1Fixcg33QXwUFhmOPjsf78Gx6rjcbAQDyb1kFpMfF9emNs8osB+G7aR2zZsfWoxMr+CYiiQGujkbvuuQ+D0YRaX4tUkodQXwefvKs7ppVXIUz9FPXDTzEnteaRBx7l10VLcbo8yL97GAlAbHQUEy69hN3lZWzbuhHJ4aBNg5MSt5sViorb40ORlb8NTsrQb5Lfc0cEQcDfZiE2KoSMVnGcN3wYqXFx5JftocHeQG5hObvyitmdV0JxuT7No2ka3/30Czt69uTDt9+mtLiYx557mvLyMmRZYfbMRTxzz/3sVTWOJmyNBeyqhsvhoqK8hm7+4QQZzDhdDsRFC6gPj8DsdVGQFk/83lyqn7mLsGGjSLloPLLPh8FoJHf7dpyORr6c8QPvvvfe0f5sTedbaPHpyf1lzpa4CAK7ZhFx3gCC26czJiyNfgGxZJhDUWQfm2tK2L1jJ/N/mMVnH32KbHccM9fEIEmEBvnTs0tb7n/8RSyBwQCIJitifBvCY1sTtnsl0a12ICu6hf0Wt5d9DY7/psjZESIQncQaFR1OwKAzGNpZ54wU5OwgKbUN3WzRdCOaspQUKsOqmb5rDaMzuuGflsG+2BDKYwIIFVTSGl10/Z9OrHzjp6/4/tnn8RSVoh3pdKIoIPlZMcdFEtS9LbdcfS2TmjLJO0ryMFTXkp7dmedeeoVZa1ZRv20XoqxwZI/LUwvHmCg5IphMJrp06cL8+fMZ1eQLpKoq8+fP5+abb/7LbXr37s3nn3+Oqqq6Azqwe/duYmJijjgggdNByZ+wX2787muv59IbdRdeHI3w45cIFdshJRkGjAC/dAJikzlv2HDSeuoiPTUPvo8UkIZh9Q9g80M2BGC89hxsZ7Tl1leeZuualRgLc1osKFG9PkqLy1ifu4Pu6dmEDhyC8NaH1IQFUdY+C8FsJqKgiIKl80kadg5Gmx+fTpnChDsmHn1AIggIkniAZLi/BLcFO2IBgXKTgZgM3YpcDAoBv3DYtQF25EJIELRP1zVfKvIhqTV19lpMonAQ91EXLDPy2qOPcOH1EwBwVFUw487/Iezcw1oEKhvdlJTXUGd3HJK70RY9uNn6h+Umo4HYqFC6t0/j5v9dR/eRYwHoq3hx5mxk9951rFizHj+rBa9PpryqvrkCYMfOXfQaNFjP3oj7z6Xuflt6DKcyCH1ufa/Hi7esmkRXE5mtopQdWYmEF1dij0nB4HGzOyqIXAk2rvyNSckZ9OiqE3c3rVrFo1dffZDg15FAFEQMooQkSYRqerXKDlVBRkNRW6AyqukBY0mKJWNAL57oNoL2kckE+f+OK2aS6BGdQo/oFC4feBZXX3I5E/53Ldu3bT/0fv8GBoNISICNO6+4geDwWDSvE+H1R2BbEVx2FcKQ4QiZvUmITKdtQSnrt+aSt6+cBocL9RQL8v9J1IgijYF+BCVF89iZF2ExmshrrOGTDfM58+03SBg+koj+Q4i2BBBtCSA7KhkAk9WGavcwPDyLzLP7ExKkT2M662qZ8uyziPvKsLo8uI/wWhJNRkwRIYR1zuLeG2/hph56xnXnd5+xfu73OGwW/Cc+SUx8Mi89/jjjrvkf22rsRzSVc8rhREYlwMSJE7niiivo2rUr3bt359VXX8XhcDRX44wfP564uDieeUafEp4wYQJvvvkmt912G7fccgt79uzh6aef5tZbbz2q454OSv4AQRDws5kZMupiANS1SxG/nQrL1kNmEgT6wz33wRvTQZTIzDiQpjRv247g24hWnofg9mAMj8U7FaT0BPyjIug+/gp+efZJXF738Y8qNRBcHoLLq/h22UK6p2fTunU2u1ol4A4NYmfXttg8PkoDDYRMeZtWZ18EQLDFjOZoJB3YcwSHiQWqDRKyzYLkZ0WymEjyKRh9XgrcPho9PlSvr8Vuapcg8MozD/Psu9MwB4VCh94w5TPwylBVD7sL4PyBCCn6eS9evZJ0WaX4d/swGQ10D7TRqU1m8zK/8EjOf+plcj5+GdVsQtyRx5rNe9mZW0x1XcNfEjvr+bO6oCgKBPhZyEyO5sJRZ9NtxCX6B4qMKJnwb92dzq2706b9XuJjvyM49y021jtZJ8sHjaRVTTs6tdZDoBawA5pPIba6DvcuXYguOimNEbc/wYq3X2R1gICvwUnXogp6jRzHA+ePxmg04vV6ee21V3n68SeIQ09EHQkEwCAZsJqsBNsCCQ8O4+rB/dm7dj1ycQlWZz0NHhe7Ze9xZeMEScQQ6EdCdibTR99EZLBOPPbW1rB9yTzWKHbCnB5iTFZMcUm069qXfj3PYPbMmSSmph3TMSVJItZmJjq96drZMB+qK8BdCU/dD/PnwENPIoZGkpqWRWT4OvxtlqaR4cHfdT/fSJJEJFFEQxdR88mKXvn2H0qsCKKAYDTSsW07RiVnA/BF1W7Cc4vwrV0LUz+lID6W4nsnEtm9J5np7ZunQW94aSqSQX8UOV1O8gvymDztA3buKcLncB9VlkS0Wnjollv53zXXExGgB695X39G/esv09Yrk9e2FQvmf8vYK+5k1IhzaZsUj69uB9v+hTHJicaYMWOorKzk4YcfpqysjI4dOzJ79myimoooCgsLmzMioBvuzpkzhzvuuIP27dsTFxfHbbfdxr333ntUxz0dlPwBgiAQGRlJRHKKzguZ/TksXA3b90CDA7xe/cHo8YDVhjEsrHlb4/Cu+D6fBfVVuvNnvRFDRRnuWQswX30eZ553Fk+98IxeWtgCPZK/T4bKWtZ98BGusdcRERDKvBGDcBXsJXhvDnvTk8gOi6bjI68hGQx6Ws1kIj4kgBi3Bz9FZZOmofmUQ6a7g60mIsKCKUxNwJIUTZC/lWy/EAL35GKrqmZrrR1vWTWy3XHchoMaGoFeH+W7drFr1me0H3cLdO8DAX56dBAYACYT2vZchKay1tVrVlL+O00PSRIJ9LcS1ioO2VkLgFJVihgchi0+jXaT3qR1aS59Cnbz4efTcHt9OF0eHC73n07BPv4MgyQREujPmWEhnDXqap03tGE5PPMQZHWEM4aiDR6KNT6N8669h84d+nL5ZZdiKCjGq7a8SN3+mXaLpqG6vcz54CPukYw88PiTxCamMOrJ1zF++wX7CvMZM+1FApqu15mzZnHnxIns3asTn+uO4pgmo5kwv2ASw+MYe8lYLrvpCkKjw3FVVPH0rU/TuHkVRXXlVDTUUOe0H3NgIkgSwVERfHrnY0QGh1PjqOfHLctIfultYtZsoH1UODa3F3toAKYxl9KYlI45LpFdO3fqGb1juMdEATI7diE4VdfREMoaIL8UTBbISgSxGr7+DK64lvi0PrQLnUuDw4WgyGzb325BwGwyEOhnJSTIn1SLmUCzkRKTgYZGF1W1DdQ3OJqmHP9LT0ONm/oNRxQE8h3VBHw7k8wFK4nLKcAnGpBqatm5ZzO521aR+fQHCIJAY0MD/gEB5O3ZzUuvvsjX8+dR39CI3OBAdXn0gOQIf0dBFOnUvSuTmgQO7Q47i3K3oM2diTczjei8AgxuGW3DRspGlhIdHsOoCy/kxy1P88eA8t+BYysJPhrcfPPNh5yuWbhw4Z+W9erVi5UrV/555aPA6aDkj9BAkppOi6bpvZTPoz8QXW7Yuw8qamFfIaRnomli809tvHA48j23I1iDUGU3WnpnqKtEff9d1PFnk9k+i1YprajZvL5FmloHbHJ5yNqxlyXz5zJsxDkEtevG5jVrMYkC3ZI6MeLOcUgGI8UVZQRabZw1egxrHNUsf/M1jE4vJocLudaO4vT8Kdsh2iyosRGEpCfQJTaC0oFdadftDJ5NH4CiqqzL2c7qPbvJ3bKdhT/MYtPq9ceVMdFUjWiHk5CSKtYuX077cbegWf0Q0hOgok63dw/yR7XYmlUbF+Tkku/1NWchTAYD4SGBJLdLISqlFQBSzk4o2AWjb0AQRMyxaSTHpnFrZBL7ym6nsKQSl8d7RGWwBoNEa7OB2JBgDE18A+bOhHXbYclGeHsKQv+eaLfcjtBvBAnde3HZhAmsfuDhA2UyJwBu9G41x+Pjy7feYe2MH7jhtdcYff6FnDvm8ub1crZv58aJdzB3ztxjOo4kSoT4BXHOkJHc++gkWrU9kJGwRoZz93P38d0LX+DbvZHkvevZXZqLw+M4Jv8Wo9HIty+/Sbu4JOo8Tr7//gNSP5uFpb6W4MpqQiqr2d2jA5ZBg8m+4Q4AHI5Gbn/44WP6bqCL6F122VXN77VtWxAUVbcZCEkCBNi2DK3xEgzhUYx97HW2zl6Gr1z3itVL2g10CAmgW1Y65467nIYdGzA47VTEhlNeXc/2PUXszC2moLiSugbHKVd+vR+CINCkunRYvSVN1YhweVk6+yfOGTaSZL8w+ofEYdqdj8PPD1dCIFsH9UKTRJLLGwBwulz06N+XEV268c5XX5Lc2EioIFCBAJp69Aplokh+eSlerweTycyy156hwCJiSk0kY8FK4rfm4upmIzgyBrvsIRo4c8TZPPn8y/BXjsTHAKH5n6bz8h/Khv1TOB2U/AGappGXX0BtUQEhCUm4xWAsoSHQNg1MBiivA7cPbcbnCHc/jvA7JrJWXQOyB9XrQBDMCDmbUIOjsJv9EHLyCc5I5aoLz2ftppYJSgA0RcW/xs7yqdMYNuIczug1gHDJQkKrFGLS9dHenHmzefGrD/j1/a8BuOHiy/hKLsFdWE5aSS19whJIMfvx6Cuv4GryihEMEoYgf2o7ZZDYIZ0Iixlr+3ZMTOiCKIiIkkjP1u3p2bo9jAT5zkmExkTRUF177N8FqNEg1+EmulovxBNEEXtwIDaTCaG2Fo+i4k5KIxRQFYX8orJmIul+n5mQID8GDRpGUOtOepBUmwdL5oMxANLagOhDS+9IeGpb7pn0BOvWXIBYY6fkCNooCBCsaWBr8q+RRD1oTU2AvUUgmEH0wZTXkdPbYYhJIDkxublzP5HYn9kpUjWK9pWw4KLRfHLO2bz3xpvY/P156NFHeOftd5CPsNz4r2AyGLnmkrE8+c4rAKheGc/MJWjzFmB97m4CkyIZffdYUn5tjf0TBxX2KjyyrtNztDinf3969ewNQO7a5QQsW0lQbTW7u3bAHh2F6PbgDgvBeNU4AFbkbOP2O++gYvu2v9vt30JWFDxe3RxSabSj9eqBQQCmfw1ON/hZ4ezeyDmbMHbog+z1MMvRSK4gAQoGSSLFZmZYeAhjrrqatuOuA8CRsxCfvRaXC5asXUbo2u0IwK48319m6U4mDKKEUTJiFkVEg05QlFUZr+zDK/v+WkZAU/G5PSyYO5eZG1cwqlNvkoedzbLZs4jdW8i6kQOpjw0nac0GTGV6AGcxm5FEkZemTAH0aUi7drREiYPhcDlZvXUDfTr3pP0Zg9DefRWf2UZAVT2i1018VkfaPPdy8/omtxtU5bglWgVB10oxGSQMBglBEFBUFZ9PRpbVg4U2WwonmFNysnA6KPkDVE3D4XSzedNG+ickocaloUSuRUqKgtBgEPLh3NFw3ug/bSskJqAMuxQxLxehpgTVYMGdmIj/TeMIzkgFoEOP7i1epVCswZc/zOK2qipCwsPpPmwEAI4GOxNfehahrozn7j1QJx7lH8S6ax7F5XETavVvXr49N4dpn3+pfxejAVN4MJ369ODMIYNR01rxgDGBAEHCW1/HwvdfITkmAS27PRntu6MBqlHSM0vHMeLYAeS6PXTxC2leZn3+I+TyEtScHFSrhdBe/QCoKimmpklVNQPw0zTyRBGr2USXfmc27XA5zJsHJVXw81dQVAEiaN16Ijz2Kpmde3LzuPG8/ezzRxSUaBrsNJtRs9sjSAZwOaC0EMwmuO4CmL0U9hSh9euHISYBVVF4e+r7LV+ZciQN1TR+/GEmCT/+hCRJeL1H78T8ewiCgNVo4ebbJjQvc3/5K3zxA+zbjuemGsxTXsKWFEG//42gQ/9Mxl91A/PXLj2moGTdgoWsWrqEHn360rn3EGpK8imracTj50dJRioCGg4/M+cp+oPzu3UrkHfsIszrpfIYn/KyrPLo888xs09frEHBMHCU/rKGwQ/fwIS70YaeicGsl+JPnvwGZeWVKKqqE6zNJob6WUlJjSW0XWrzfv1SBwAQDJyV2ApB+BRDWQ1aeS2bPb6DKsdOFgQEjAYDARZ/Olr8iDL70eAfQqMk4nA7qWuoocJRh8Pjwqf84ffUoMLrQzJYGJrREQCDnz+Zt91N9bQPCC7bR2FSKNWaQI3sJr4wn8TEZO7937WMW3cj8NfTpUeFJvL/iz99S5/OPYnuO5BFy+eQvGgVLpuFgi7tUduk0aZp9alLfuKZp58mTVbZeRyHFUURm8VEoL+NsBB/Av1tWKxWGuwNVNc1UGt34HB68PqOTl32cPiPxiSng5I/QtN0xdY5v/xC/7PPw3b5VdTGRSG6ajHvK0PNCMb2v5sPGvduWbSU7P59EGxW/L56E8dPi3DO+hVneBTRk67BHKoTrtYvW879Dz7Q4m3eB+D1ctawYQwaMIAatxt3fT3ztm5A6ZTG1tenERoYctA2VtGAtSkgkRUZg2QgzCDRGVjfVOdvigzlpbPHkZVygDBaV5BL4cP3Uxds4TdfI2GxwWTQne1FecgGEUEUdUv2Y4SmgUdV+WbxUq7csoWUtm0xWqwYk1IhSe/kVVXlp2+/YdLDD+Fye9E0jQZ0WfA0WeGswWcSnZCGpigIP30PG3ZCUSUEB+jmeooPrawW9+BzsPQbzLVPPsvWnXvY+O13h22fLCvU2R3Exutdm5K/E9HtQ7AYoagMwkPRkpMRJj0JwKL5P7Nx85aT8tDphj7Ft0dRUFrg+KIgYjGaWf39XM6d1BoAy1ln4P55KZozHnXtelyX3IzhvOEYRg0hKL0Vz7/6LGcMHITT4zqqwKwVUN/o4JLhw5j00gtcd8PN9BxwNrN/+RH/mjIUg5n1Z/bEWFlDsL9+ba9ftISSGjvycRCIFVVl6arVXDlqJA/edAvZFzURmW+/C+3WiQjigenavO1befHlV3A0KQpLkkiAvxU5NYHU9hlEZfY4sGNV1R2nAf/4jvTtVYBn/U725e5jZ6OzqVrpmJt93BAQMBlNRAeF0yGlHUM7diMeIw5jCD5Zoc5Rj7JrDesrC1lYX0F1Qy0e+eAgV5NlMhSwWnT5AVtIGK16D8Y/JBLHS8+QVG2k9Oqb6RqTTEJCEooss+iX2S32HTRFQatrYMmixeyaUEpGeAzVt/wPt8tJ6vodVCbFYlw8j9zhI0iJaUVGcDTW3GK2+XzHPM+yX9MqPTmGdq2TuOCCC+k3+FwCI+OoyN3J4rmzmDZ9Ojtz91FaUYuzqb86jUPjdFDyF5AVlZenfEhIQiJ333c/IYP+LM27a/N63n3iMb5esgITVs4/axQ3330ryW1SCbhgCAEXDGlet2jnbp4cfwVr1q5mwwlUUF25YQMrN2wAQLSYsKbGE50W3xyQ7JrzAzUvPU9xnzOoaZtOkMuDuGcXg/53J2EJrahSfNQZJNA0BElEtFkIjzggV7/v3TeomDYNVIWGIT3w+PljDNQDrhCrDaPVQqim4c+RVfYcCpoGu3PyyOzUkUB/PzJatya9dWtSWyUTHxDE5C++YOPWrSiK2nyDlwBmINbn47L/6SMvtbEesbEWwSPr87z+FnC60AQTSudMHJ5GLE3HfOajabz5/YzDqpnKikp9gxOzVRcfUiJjUc/ohOHDb0GSwD8QXnoPISwKT30tr7/yIvYG50nhDdSgVxC1JERRJPWMrs3vffNXo1UWQ1AEms+FUFCE7/X3KCvwEHvvhWR07cSgfn357pcfj6rfL0IPTHLdHu566ikuvugSQiKi6XjHw/w4/T0a8FG/r5Q2hbVoTeZfamktFY2uI64iOhQ8Xpn1y1fz7M5b+Gx/UII+lVi0bQPffvcFS1atYfW6LVRW1zdr2EhNI2YhMYqg3p0QLf761ED/btAqGUIC4JLLoNcwItsMwNRpMdXb8zCU13BU4jQnAJIoEWQNICshg3envU105gGBPcXpwVNYRs6c1jT8NJeiwh34ZJkaR93BJGYNarftYESbTCw9upKYkc6r9z5ERFY2/T/4/KDjORsbuWPMGL44Slv7v0OqqhHS6GRvQQkzFs3j3gsv55aATOZdcRVrspehVZQRnlvEqllfk3LdPWTEJrHT3ohyjEGsIIDVbKJVQhQTb7uJs0eNxT/0gHtuZEomF92QSb+h53DvpNtYuHwjxeXVh/XLOmL8R1Mlp4OSv4CmaXh9Mg8+/Ag5W7Zw2WWXoRoNZKRnEJ2skyc3T/+aLbN+QpKhVDLy2XdfMm/+PEaNGM45F4+ifZ8eGM1m5s/8iWuun4BUXoLnH5R0FyQJyc9KWvoBIuLCbeuIDw8n/rfFhK5Zg6Ro2Pv0ICyhFaqqsqailHyDgUSPB4OsYgkMJjJAD2hWnTUI2eelOj2J1NUbGf7ht+zpnE3DnhxcGT1IjInnwj79WZb7GQEt0H69fFKlrr6B1evWs2bdhqbl2iFFqvKAYgR+/vlHrppwMz5FxhcVjt8FAxB/XAqyhnZOH2T/IJTr7yIsPLl529eeeuqI5NVVVaXR6eLuhx/k229mEBAWQ22rzhgtP0KtA/PLL2AMi6KxtpJJE69nw6ZtOFyeIxfWEkAQJWjKOoHOG9IURR9tH0XHknPkqx4xFFUhoY1+TWleH9rGtYglOajhMeBTQZHBaENaNp/GnC4Et8skxmqhtaYdVYpcpimw1TQaK6r45pOPufaOiaRld+am9FfY8csscuqqGfzAA9gCAmm029mzaQvqcU5R6YfUMHplchud7MvJIT41lRlT32PVF5+zN3cvRU43gt2B7PaSrKhYgM1N20qiiNlkJCatKXBraIDiEti0AyJDwdsI2T0Q/YOIT22H0fQbonCMfCNRRBAFIgGDplEiCMesHWQ2mogMDOPB++9qDkg0jw/BbESymbFlJpGdmYQ7MoaS96dQ1VBDg7vxoKAkEl3nZuPuPQj5+YgWE4NSMzj/krFU1VSzY+NGVq1dy5KVK1m6eAk11dXH9r0PgWrAICs0VtXx5bRPufdCneA9JK0bqaqFJWaZZA+0s+paKItWLkeubzxmcr5BkggO9OOzqZ/SppvuD6M12BFmfgm7N6Gdez5k9yEyNZPHH3ueu8eOprK6ljWyQkOLfOP/Jk4HJYfA/sBkypfT+fi77zAaJMwmE9eMu5wzunXn7fc+INujUAC4FRVZ0W/SNz6dyuTPPiLdzwqtWlGwdg3Bso9taMc9gjtaCJLEaz3OaX4vhoUSUl5BQGk5fhUGLG4PUWMuA2D19o0UlZWCAIEaCB4vku9Ai3N7d6ZOFLA4XbRbtBxzXQMBFRXURgayP6FdZbeTg9CiAbkGTW65R7ZXn6zwyFNPM/rScfiFRmKe8CyNW5ZjNMeiBpjw9eyAJawt1rBovB4PX0y8jYXvTuGjo5je8Hpl1q5ZzyfPPM2NL75CY3gCZbUNJAw7B/+2nfC6XUy6+1ZKflpAel0DRfKR/fKCQUK0mkn2txJqs7AnLIShrdsQazQzb9kydpZVoDrdaC010jpKaJqKy+vhjmtu54mXnia2dSKWZybhkVS0d96FkBiwWPH6+WNHw9aUwfA4ncfe0Wig+WSuv+ceZq1YzkP3P0C3jp1of/5o2jetsmXDei68bBzF+QUtJuZXAJganSRntMZokOikqYQjUKNp5GkaYbLuGGvg4CszwD+AG2+4j4jU7vqCV16ARo/OtapvhKpaXfjPvwNhUgBdSsqp8vnYcBRtEyQJ0WrSdYP8rCRqIMgK1ZKA0uhCaXSieuUjftgKCFiMZrp27ELP84cB0PDmLKSvP0E1mzGkpCKdfybG4T3pMrofe/bsYXdZLsW1ZXh8nubvH9H0dx96wKr4ZC68fDzhd0ykqqpK/y3VIy/xPVrUAXUaCI0u1PmLuff6q2k/cACXXTKeVq2zafWH9b/7+BNUz7EFsYIARqOBiy66gDbdeqHKXtizEvGDd2H+akBEWLcRLasd2lOvk9CmA+cOG8acvVOow0fLlDqc+JLgk4HTQclhoKgqbo8Xt0eg0eHmuTfeQtPeBKAYXbxKQ9NH5YqM0+siXdPY1VgL5SWY0S+F/a6W/5THgqZphPsFkJGc3rzs6lFXsnnOYpSaejwBfkjllcRF63ofy3J3NYmgaWwFBE3FumEzG/Zsp1N6Fv6XXUbObz8TVuZjb4e2KCYJr6AR1bYLZv8AispKmTvvN73TOYnQNI2S0nI+fvwxJrz8CoIoEtChD3Toc9B69opyrr7uKubMmY9wlHwLVdOod3mY/et8bgQS2nfG/OWPBDaJCk199mkWT59FrMOJoh5ZMCoYDRiCA7AkRhOTnkivjp34YPSVZLfSK6gqKssZdsOVbF+0ArnegXYcFTTHClXTcPvcrNqwhkcn3M+dd95Exlm9MD12H+69OShLluMOi8Yd6kd5UjLhJr17yfN5/qSKe1TQQJMVZn3zLbO++56BAwZw9WWXkZWRwYeffsa7U6Yg+1q23joCaEDP1imKyh/N2vcbv/3ePUpRVUaPOJeUrvqo2fXrV1jq9yK0bQX7KiA8CAQBpbISKQXMQRHUeXxU+46MTxIPhADeQBtXjL6I/Ooy7F07cHW/YfySu52qlUsJbPAxIrYVs36ezdYt248oMBEEAbPBxI23XI8oSbi3FiDsKILiPASvB2XLGtQFv6B9+gmmbq256LZL2TFvJlsLxIP0YPbwB7FBTUOTFSrLyv/qsCcMmqygyApfTf2Enz77CkNBCVFdu7KreB95eXnk7tnDts1b2L5123EESAImg8RtN90OgG/LMsx7V4AkgNunB6EFpQiahrpzPUJ2LxIGDWLHx19gbHSTAexqqS/8H8PpoOQwiEBPS8ZqGtWSwG4EXAgoivqXvAlN08gF4mgyS0MfOQSicx6OxkX0eKDJMqZ9JdTXVGP088MkSRiCgkl64DHWvP40foIBR3gIiuAlG+iUkIrSeMDMTPMp+KrrefXzaUx75DkGRqazHB+Ze/IoSommPtif3CA/Hh04EoCPv/oC2ek6JQrzFVXlrldf5aNvptNl8CDOHjqUNlntsFqt+EdGUbh1Kw9efw1z84tweeVjymCpqsaPm7fwy/TpjBg9msjWOvGzpCCfj557AcHtYSX6735YiAKGQD9sqfF0GzWCL2+6n7AmKXWvx43X6yEyIoqfPviUEVdcyo7FK5EbHLrc/j8Mr+zDU1sOO1Yy5VkP1/lNIr1/Z0xvv0z+DQ9jjg4k5rkHibdamrdxOFrI+FEDFJUF839jwfzfWmafh0AQYEPn5RwpVEXl1/XruLvp/c6qPaQLEn4lVQiyDwL8UEacidhNN5tbs34tm7wyxUc4feMEYiLDeeWrrxg8YBD78nPwBFhJDYtlaK+BPHnx/7CZdMfXyy+9nHY9e6C6PEd0T2ZmZtBtWD80VcX1ymTM69YiuBoQTP5oJgtaVTG+MRdj2LEWU5A/rTJSEdYvPWgfxz9x1nLYBuCTQVa49MEHm5drTZ5hLdFPpaalkZyZhabIqO9PBpsIZTXg80HbVpCWAPklkLsTsnuRkpRGiCggcTog+TucDkoOAUkSsRgNtLWYSLVZwGwiTBLRNI0Khwt7gxOX+69L+WQOBCT7YW96/VPQfArqvgquHtob54CuXH7tTYzN7EVo22yGv/uF3k63iz2b1wAwqFN3Qk1+lCpNeRxVRW5wMP29qTx7zc3ExCdwVmxH1vXyp9W+UuoaGmjfsSvhHTrjdjh4/+3JJ21a4a/g1GDtvlI2fPoF0776mixBIEBVWWeQiHG58SoazmMT/WyGBlxwxRX0nTIFk8mEIAisXbuWMvcB1mLdEexHNJkwx0eSNXIgX9/yEME2f5zORmo2rqPg4/dZMqI3Vw4aTVxwGD9/+BnDxlzArhVrUV3uf5y8pmoqZlcDgsfFTp+Xu+++nxmrZyOFBpM6/fXm9RrtdvwDA/G4XOzZezy055ODXI7esl4DFi9egr22hsCQUOSYLuTvW0Scy40QHIwS4kdg33ORRIkNKxfy5efTiPTKpGoauw6nQCtAndXCxXfcxuABgwCIT9ar0RRVweFyEOgXiKppiIJAm+z2pLZvy961Gw97X2qaRo8+enanfulq1KWL0aoLQdXQAiIQNAXBGoDQtQei2YjX5eb7jduQ/0GO3DGjKVtzIuDXZHIqSAaEngNhyyJ9oJCZomdMVm+DonK0gaUA+DSdKF8kidS1xIDiNNH1/w8MBolAPyvxMeFcPvZSzh57JTUVxcz55UuSyivILSpnT34pRWXV1NlPUUVGTWO3xwNl1cSs2MKcqB/o6RdJSsIB7QSDxUqb7rrmR+7u3dRWVBzUMWo+GU9VLW88/xxPv/4mfc8cRd+/ONSE226jYO/eUyJL8nuomoYq614ja3+3PA4w0TLNdbvd/Prrr8e+A0FAtJiwJUTz+v8mEmzzp6akkO+/mUqNWaRLeTkhm3bzfd0HXHTeVcSHRTD70+kMGjGcnC3bTkq2ZJumUqh4iasp5Qz/g90/PU4nv037mIvvvItuwYE4PB4qa44m33Bq4GgDkv3weH08+cADPP/2O3QbMAJXp15s//UHyvM3EWY00yMtA1XTeDZvDbu7tCGjrhFfdT1ifSOq529KUwURyWYhMC31Tx+V7tzC0g/ewNyhI0phLr0vuoaYzHacc955vLpp6xE8lDU6tdO9pIL79aThsbvxffoDphXzQFNQVS9qfBu0tEysQF1RKcWVZQR6PRg07R+Zjj7VoGkaq9et56Xnn+bOe+7HPPpKZKUUKT4GYdFaKKkEtxctMRpvxyysQLW9nq2yQsvSe/97OB2U/AFiky39leMv48677yM2IRmAyNTWpLfvQsX2lSxbs4Cla7awauMetu8totHpPiVtyzWfzJ7aBvKFMvK/+5mnfpzD+wvXNZso/bxwLmcNGEZRXh79hg3F/Rdpds0r88xb71DvcHLVVVejmU0EWq3EJCQSGBTEx5Mn89EHH/zTX+244ODo0vInFKKAwSAxcdxVdI1Owut18+1vP7C5VwcSN20nccsO/Cuq2ZfdmhluJ2eNuZnE6Bh+/uQz2vTsjurynhSH0wbAp8psyM9h8jXX0BgYyPerVrNp3To0rwcnsNnl4J9nvpx8vPDOZMSSUu586SUiUlPpctEVyF5vs07LXmcV15wxHEO7vjzf+hfqf/wV45a9eKvq0Lx/zY0RRAHRasbQxNPJLdyNXFWFo6yMNQU7CZJl9lWX05gYTVBFDjGZ7Thv0BBee+Y5cHv/NgLXAG/jgTxuwCWj0Eafi3f1JnyffIe8aiNeoxFXfiFBQGTrVoTFhuEt2IqVf4YjdypClhVefPFFbvzfDVhDQ5H7XIi24kcMW3KgvAY6ZeA5ZyRi1hkA+Ar34XR5jqjK7/8zTgclf4DRKHHPmcOY9PpkAFSfBzF3A0SmI4WEEdNtGBe0O4P45K9QlG/xVdSheLxsPEVty1W3F29lLfucbtZbTLz2+MOMunA0L/3vShYX7WPG4KHM+HUeleUVf7MTlbc/nMrbUz86aLGfzYbD4QCgK/rDfscJ+yYth8KT3YDfQRAEBkfHcO8Y3W9l0ZJZKPm5tPI4iN2yG0UyYHE6icwppCHYymu/fszzF0+kdbtsYrMzKdudS5DdQfVJmDrbX3L85ocfovLn3/6UCfxOAj6f+QOfrljMuXfcwmPX3UxEqF6b4lJ8lBkEhiXptUP92nTh7tgkPnrlDRSXB9kn/3UAIQiIRgN1jiblmcAgPlv9K22WrqPnklUIHi/+bTNYfPX5zAuVGAp079AJQZL+vK+/wPO33srsL6bjl9Ka2665mjb9e2Hu2Qlzz054S8pRi0oxGw7sq2/bDF5dsehfaWPXUpAVlcTaeiY/dD+3vPI6lvT2kN4euf8lKEsXo0aGYx16NgD15WW88NqrTZYYLdSA09M3/33sl4keMlIvo/WV5mPIXwg//AZ55TD0HDj7fMToOHqMuIrkuGyeKL6NHbX1mHzKKUX0aoamoXl9yD6ZjaLApqef44EnnqK9CuUCvP/ZF0c+j/GH9fYHJKBrBDhAZ+P/xbqn8dfQNI27n34WgLqKUnIXzSG80omvtg6PxUxFciI57VJJyCsmKq8MN2AfUkVgSDiTnn6CRTNmsvXbGYRX1rHrEKPsE41jd5r576LYbMIWHsLwQUOaAxIAq2SknxTe/N5gMPLKBVeTZA7gwYl362TzQ7hta6rGZ+uWc/uYq0gJjiLBC7Fb9yA63JhUhZCqarp//Qv2rFRod7Z+Cx7hfehQVZYtW0zj6tXs+eEHstp35o43XiClYzam2ChCY/XKMlVV+f7td5jx8Uccu8vVfweNsso7Uz7gt7y9vPHcSyRnd8CQlIIh6YD43Hdff8l9995Lwb6SU8JO4FTH6aDkdxAFAbPJSJ2x6b29EtZvA68HwgNg3W/w0zdww50Iw88hukN3+pxzHjO27tbLaU9Fbsl+aBooGpqi4gJWQVPkfJzBgygSIOrnrchkwChJaLKC6vWh+WS9mud0fHJoaBopWfp8/ivLfqKmTSu6efOw2l1Elu4Dn5eMDTtw+/ux5cx+GFwO6kqLCAwJ58aBZ3PjwLP5ukt3rrvnXoTq+lOKbPxfgS5utr9CRjsix2PBYOClu+7lvO46C8telI/P48FssVGverEVlbDh0/dwP/YAZ0VmcvvIi3Fs381XDz9BoyBQIIpomgqKiqbo2h4JjQ7C1myixl5HRHAYXQrKMZWW4dfgZPOAbpg8Mv7xSWQPPB8Aq8XSVDp++Pbuz3qJspctjbWsW7uMinvv572PP2DTsuXMn/srCrBr5XIWbdrIkeVfWg4C+hSWQZIQxSbnYk1DVlRUVT1pY6DtgOhTKPptCd3696VVciJ9+/bljO69iAsN4/u332LWb7+R75VPByRHiNNBye8gCGCQRKrq9MSzGBSCUFYFBgNU2SHIHwQNPn4Trd9gBKuNaq8Tg0E8kCH4fwTBaECyWUj0t2EL9iM+PJQGqwml0UVkWQ1KXT15DjfqYea0/19D1Vi3YgUJqamM6zSAx3/5kE0d0+ixbBPVEcFENzSiiCKCx4tishC3M58lc74nwdtAfEwSKVFJZA0ajBIXidjoQpFdJ6SZAnomEQFdNwStRX5SAQFB0F+gP2j0fZ/c60VAQBJF3S3XaMIgiPirKo2aSqMi41N8B0us/xGiQN9eujbOou8/pv6HH2gIDkIUIDS/GIPXg8knM2PPWmIUI51iUunapRvVl42hzG6nbs8uPA4HisOF3OhEdXtp8PhAEYkIDgOg06THabhwLDXzZlNeuZfkmkYGP/gsokEfVVWVlqJ6ZVo1ncq8I/jeqqZSqamIHgffzfuF7+N0HSNNUYhHI/9YT+hxYP9g0WY1E+hvxWbVy569Xhn/ukbMTidrZQX5JF0yqqbh9njx+WTsW3exdcceJr/3ISgKaYpKjapxcnKY/06cDkp+Bw1df6JmP+nLraLt2Yfg9cCqrSBrMKibvubeHZDdBaPJTKTXh6qox+9y+S+CYJAwhgVhTY2n9/mjGNm3P1JkJMGyws97t5D36zwubd+bx7/4jPVLVh6xXsKpClEUEEURSRQJ01SMmkYJuj358ZKcb3ngAXoPH056chrj2w1i3lfvE75xJxWtk9k6qAttl20lL7sNCBrBpWVkfv0jeQtXMPeKC7nhghtoHZOAf6s43PvKUVyeFiW+iqLuHGu1mDCbjBgkEUVV8Xh9uD0+vF75mGzZBfRRr9loxs9kxWw0IwgCcpMAodvrwSN7UU9C2akoCFiMFoJtgUQGhRMdFEFrRSGxsY4dJjNrPE4q7VXUOurx+A4QWPcjHIjxKTQ26mLiQlkZu/p1JLC4hpT124netRd/eyM5nbJpu2w9bbpcCMDwQcMYPkhXVHV5PazM2cHipYt49+vp1GzbTWWDk2WF+1i6YildO3bGYrUR0DqTgNaZjHU2YDFbEaUDXfr0N15H88mY+IOo2RFA1TRU7eCgKx9og+6ndCSO2i0BUdQLD7p2bEdqciwpCTFkd+hEfHI6cZEJqLLCtKceI2/Wj9Q2uPAeYurrn4Ciqvq98LsIZPOhVz9+aIL+Opr1/wU4HZT8Dpqq4fH6KGlSINQkE0JuEcRFgtkMAUbd36O0EnnrVozZXWif1Ql/l4cQTfv/E5QIAqLNgn9GMk89/gQ39Btx0Me909rDmbp8vRAbw0Xbr8FbXnPIyoJTHQZJwmY1EWE1k2oy4icKeBQVVdNocLhxujzH1RnuKyxkzKWXMnf2bIb2HULN6tXU/rqCmshQXB4Pbn8LyVt3kbJ5G2EFpYgaRO0tQJk+C+/wcZj8/Hn3tvsYt+ka5Bo7LfUcN0giNquF8JAA+gXZ8EWGIgb645NV7A4PeUUllFXW0WB3IB9FwCmge60E2QKJDoogISyWEL8gJNGA0+ukrK6CktpyzHWVNHgc/zgx2WwwEx0cQevoVLLiWpMenUykotBpYBZh/bvxxQffMPu7ryks3cPWxnq8f3DLtQFGn4/4yGgA1PxC5JQQAmvrcAb6Y2t0IXl92KNCEM4fhaXJVRegsCiXoLAIgmwBDGzTkYFtOnLL6PGcM3EC6+YswFvfwNBLL2ZQaBCtOrSl/3UTuLjXEPxsf3ac2lVQCJrWokJd5qbXPwFBELCaTQwfMpDPv/oeg8n0l+vd/t5U9t16PV9+M4PquoZTU6LhNI4Ygnay86QnCHa7naCgoKPaRgAsFhPnnjWEL7/9Cdleh/fxG7GuzYGJdyC0bQsY0OrqoVP3ZsO0Lu3asmnb9v83THTBaMAcE87HH7zPxUN0dnnxrz9RoHkR4uPpntkZSdRnnXdWFNNz1Agc2/OQ7Y5/XbbEZDQQFGAjOS6SrmGBtBMBfxvFfjbyG13kF1eQv6+S6jo7Hu/xjdIm3nknL734Ij6fj2euuISdnjr6W4zEK2B1egnPL8Ha2MC+1qkUZ2fgX1FD+MiR9Bl9NQCrli/ljAEDUY9ztBiJTlo2BvqRGBtOp5QEzrEZiQoLJuCSMbTpNhKTnz/11ZXk5+dTtW49k+65lzX1R+ZJbJSMRASGkh6dQnZ8Jllxrek3oieJPTLZvXoXxZXl1HvtaIV7eOetN1jtcx8Rj6MlIIkS4QGhDO0+gGFnDKZjahoWrz+BMaFEnXXAsqFmx15mTn6fOz94jzqnnZ6aioCu1FkFhEVGUNVU0Zb/21w8yBRVF+P7/geiducREh6N76XnaN1WN+5TFAVJknhqww/4LV1FSGgU3Q2BJA4cgV9kNNuK8+k/5gLqt+egerwMNBqw+VlYnp7EuqlfkdQqlR8+fJ/r33iVK4aPpFOrVG558EHdc+ZfCqNBIi46nIWLl5LUKk3n2MgylBVA7i7UEAktpi2GiER8jkYmnD2Mz1esw3UEfja/zxmc7B6pvr6ewMAj0n4GDjzbnl44B4u/3xFv5250cP+A4Ud9vH8apzMlv4OGPk+5ZdtOVEXBEBhMYadeJF58I4YeB7xT/pgEGzNyJJt37jy1ia4tCNFkxBgW9H/snXWcFVX/x98zc/vevdudsEsu3d1pd2ELNj52d4vdLXahgAUqAoqCSncvy7Ldu3dv35k5vz9mWeQRkPSnPn6e1/VhZ870zDnf843Ph/H9hgLwil7K8niV+Ip6rGtLWbP4J/Lbd2Fgv5FoZgVbRjKW7WXUNPn+VjaJSZGJcTtp1yqNwb07MHL4UPr1HIMtLZuIHiHs81JdvIOX336ddz74lJp6D5HIwZumTzz+OL169uTMM8/kkidfYPQNF5PqtuH2BalLTaU6K528pavRLBYC7ihKOuYx96iOfBYJ4TBb6dmnH70SEthYXnFI7MHxQKrFRCQplt6d8xjRvzN9TCZSjjsTc3aPlnbR8Yl0jU+Enr25oLCQpY9M+cNcEEmSyDNb6eWMI7VVV/q06UGXrl3IO6UPkizRMzuFnr9pX2Qxs+LxRwmpf05tm8Vk5u2XX2DM6afss11chzxOvvlaHvx4Gpagj9aajsKusuheXbu1tM1pDsm0A4p7DKTypefJvGcKJocxoKwr2khMUirp9mg6bK0i6asFBGx2funUllXbNnDcdfeSn57DjRMncdfd9xKqCDAvHEEJBIn1+Dhn7BhOPvpY3pz6OlXBEFNWP3bYhAn/vyBJEhaLmZsnX0V2qzw0fxPyrx8i/bQMyiqh3ouSEo84dTSa6TjMsYlMGH80M5atIhSO7NGIlZsTZc0mBUUxJpR6s3f8cIRh/3T8Q0uCDzTU+I+Hputs3baDF59+EoDUEy9E7m2Q3wRrtu0mONdYWsSaH75j+/xv6BTlxGz6s3PS/1y0av5JZhPde/fC5YoirEbg8Wfo9MNS6hPiMAWC2DZuQl3wAwD5sSmM7d6DJJOZXHkvr5ssI5lNSFYzstWMZDaB8v+bPCwBDruNvmkJnJLfiklnncXwUybjaN0e2WbH6nATlZhG6x79eOSpV7n/umuJdjlQ9naN+4mJEyeyZs0akpOTefW6u/jJ7WJxr/ZYwn480VFs6deDmLp6Wi9ZiaOhntNf+xyH2YqmaUy69GKC5RWkHuK1NwF+l4P8NpmM6N+ZEQO6kHHGJbsMksKlMOMJgo/cSNO6lQDk9OuLSfnjazfLJuIc0bRNaU2/vB50a9OFVsfkIzVXVKirNhMsqMW/1qgHmXj5JbjszuYKmCMLSZJoo5hJcbp2W75T/DD80Wz8+cPw3P0mAM6kRLp17ELQbGUxMJ9d3Cy1VVWEQyHqKip47rmnmfnph4SDQTJzO9Lr0ecxOZxsKynilJcf5KKN84gxG1pBaYtXIlRwenyoDjtl8W5+/elrAEYNGoYpOgoFQ3TOElbp6Q0Q2bKNqU89ja/RiwhF9mqQSCYF2WpBdthQnHZkuxXJYoJDfGd33rvDCUkCh1mhQztDU0oK+pCWroHWKRATBUUV8NMypE/mIluNexcyy3SwmpH38B7arGbiY6LIzU6hT5c2DO2Tz5De+fTukkdudgpx0S6sFvNhv45/ceD411OyB0RUletvvY0e/QfQv79hkDTVVhKVYNSeC18N2GOJTs+mc3o2J595KmVvvkVRUQWeJv9BJf791ZEPtMVwTUerKid16w3AjoL1dP7me6LL6+g6az6KQY6As7oOb6/BuEaMZsrlN3HG9NksrajefaeShGQxKniy7VZ8djtNFhN6OILa5ENvrtwR/w+ldLIsE+W0kZ8US8/WOWT1PdrosBZ9D688Z8w6ThyNltcdpVMfzr7qOqa8/DIeXwAtfPDP3+/3c+KJJ7JkyRL6du3BaxtH8M30Nylql03b7TsIuV0EWmeTOWY8rYcOJ8Fm5BKsXbWCt99/HxeHrrFUaVLIcTvJyUiibU4qCcn5SIl5oGnwzftQvgGcDiwNVVSXrCIqvxttOnbEZFKI7KMkWQJMiomAOw65dWcy07PIOSsfJdaF8DQRHHoUui0RopPw5LTF/tx/SM3K5KpJk7jvqSfQxZFNYpQlCauiMPX2h7nYnEyHsd0BCF97O/rylegb1oOiIK9YQWDTaOzt0pl4wQTmL/kRbxB0IBejvHbpqlX0iY5GC4VYb7fS2WljarcXuGHKEwzqboRsvnj8Uaq3rOLsG6/HabLib6yniAhS2xya4t04GzxUZ6VRu3kDjDiBtpk5pEgyFozwmgkjXLQzkdW3h2tqvjBkqwWT24Up2oniciApCnoojNrkQ2v0oXp9iAMMP5pkBZNiQpEVZMnQBVN1FVVT0XTtkCbmybqgtS74aurL9B0zDmtcChx/Djz7KHi8oAgw22HkKUiOKEJNtWxY/hPVFvPvPNlWi4mk+Gja5KSSn5dJx7Y5JMTHoMgmPL4gmwrL2FxYyrJV6ymrrCP0N819+6fgX6NkDxACgqEw55w9gWVLlhIdF4+zuQxPbFyMtG4eOKIRvcYhJbai26mn0nbDUrYGQoTCEQLB0N8qTLE/qMaYQatAqqbT1Gx4+cJBytvkEF9YTvqGrdSmJ1OfkYLJF6DgluvJ/vRzkjOyuf72ezn21FN37VCWUBw2OvfpwfiRI1m6+lc0twOvw0ZeYSkrIyrFVfWESiqJ1DehhCPI/HlKpIoiE+W0Y2qfQ8fTzkM226CuAr55F6SgIUOPB+XDF+H+PlhsdlrnZFJaUUP4EHNLCgoKmHD22Xz5xRd0Pn0CtpRUPnv2YRI2F+K7bCL9Jl2Lubnscyfuuv9+9FDksIg+yrKMw2YlIdZNRlouppw+xorH74V33zFG31gXcs+OuO1GbLpVTmusFjOB4L6ekFFmm5yQyLBjhtBhUA/DIKmrJ3zHY4iqGggUIdsdWOx2pGbP44jhQ7m/2XN5ZCFRJJvIsjip31oKY7sjfAHU+T8ib9sIignhTEKyCEw2YzaumI0utALDIPmtEOeqULMwYzBEWTjChp9+Zdbw4Vxyxpl0Skziy6lvE+qYTapq7Mu7vYDkDVuJLasg6Ipi9Yh+6CaZ0NbNqGoEl9VOVGYmwU2F1GLo87j5AyNUkVGcdvpHuwh1aEVV5zzMSXHIZhOaN0CorBp/QTG+jduJ1DTsV/m+IslYzVZindHEuWJw2VxYFDM2l52uPfJRQ35e+fhD/MHAQVdPVQM5ksS2ump++eYDhp4wCdr2hpJqCAchKR7qG2CgEUIuWb+AIkX6nQq7SZGJiXIytH8PzjvnbHr1GYg7OaclH3C3YxYX0bNfb8oqa/8eybL/0PDNv0bJPlBXWsqD557JDc88S0LrdohNa5AeugeGdoFtpUiBCJx0FXFpufTt1p6SdduwVdazMhRB+zNKGSUJmxDGh/hHKqOHiJ0k9LmAKRKhrrlCqV1uPpGzJ+LL64T8yxIsRYXoEvx80nDSVJl2cc3slQ31BgkUgASy1UJer27Mn/YZMXHxbK6v4POGbbQPSaQVV/LtL9/zcV01RWu24l1XQJsKQ8bqSLGHtsYodaxrnmbJzYRw0S4Hzrg0Y+HzT0IwCHFR0OSD6lqIsqEFvSg2FxkZ6cjyysNyPrNnzWLi2Wfzwuuv02boCM5JTsVbUkzOsBEoJhNrt22msryckQOH8ti9d/P5F1/utRRYap47/nfp6r4gScY9iM7uZixY8SMsmg+BMDR5wGaGGBe2ZMN7GPI07ldHbjabeeP9l0lpk2eck64Tmnw7+o8/QsiP5IhGxMVjO2l0yzZ3Pzhlv8/7UCCEjqqp4K0nymTwvejlVUhhFd0VixwJIRQztvuvQs5OJeIPMO3ZV3BEwtRKElv29v0JqNZ00MIQCvP8K6+BBBaTgjUY4dOCdZw84lhi23bEXVpB3PYSgtFR5KzeiKJrxGTnYDKZUVWVmsoqSvRdT3KfBkmz4W/LSkFpm8WAs06hoX02O+wql1RIRJxOXvWXUrViPTWzF+FdvYVQZa0RAtrrLmWcNgf9XDFkpeSR3LYbZ5x/Ahld2xGdntQy2J9z5RWce87ZrNu08aAME02SWKfrmAIRklp13rVizRaIcYDZAiYZ4W1Cio3HH5aoqm0kEAy35IbszEvp3jWf19/7DHNzmKcFum7kQEkgyQqJmdl0zcnGV9tA3W/fZVlGMinGTwKhg9BUhKr/v+hO/dPxr1GyF0iSRCuTiZDNTFy2ocwpvfg0hILw8zrISoF3PoVBpyElpdCt5yCWz5iPxyTTWddpYhdL4mGHIiObTUgWM/lCJyzLbEBCD0eOOLNsIyBrOjNmfsbkiRfTKrs1vQaOhoHGIFK/fDGeKffgcTs46fT/YHM4WfPrzzxw1VXsrFWVFIWk7Ey+eOcDYuIMD1Tb2BSujzVKKGkPGX0GMWvxJ7jtVjIrajDVN1IeOvzue0mSUBSZJASxJhNhRUEXOu2QSI2EUTUN2dLcmRUUQbgGNpYYLL8xLhjYFcVm5CDkJKXSStMp5fCIlE394APWFRby5cyZJLfvQHL7DgBMn/EJT149mYS6Rm5xRbG0pvZ3TK6yJGNSlF2udQSabgy6uq7v00ARQhAMRQiEdGyJ2cbCV1+G/p2hwQO1FkiKhVVbMF1u0I/fNPmS/QhbClrn5rYYJAANt72AZe0m0A3mX0mR0G1RuM45qqVNuLLyT+Er0YUgpIZJqillyyef0vG841HyshHXP4T46nP07euRRg1EbpeH5g/y+LUPUbppHXFqhB37LdXQ/B8BEU0g1TRQuWU7AH6hUdUqGXd9A8JiwpMUTVVqNP3GGR7GD+fMomL7jv0OZ0qKgjkmCleH1lx7xz0c17n/rpXNLOjHCZVpuZt5Magjl1VT3uilJLwX/R3AZraS7E6kS3wa3dv3YuyD1xOfl9yy3l9ciRLnpluv7nz6wQd06dOHYCS0f/fmtxCCUFhl8iVX0aFrv13LjxsLm9dDWR1kpBOZ+yWW86+k8+ATOHVrFV9+f03Lu6IIQYZZ4eRTTsFstaHXViMvnguhSli2GkoqkLaVILrkw7PvA/DI3fdxxdlns6CmDp1mgkinHZPbhdtpR7OYCGk6qseL2uhD8weMsNc/zTX+/4h/jZK9QJKgSJF555obkRUT2vrlKN5K0AQUlsHyTZAYA599CpOuILfvMfQ6tYBPNz6AuVEmciQMA8mgrza5nZjjozHHxxBWZEJmBVdEI1LbSLiihlyPjwpNp+HwnwE1QI0Aecs2uo4fxcUTL2TA8OG0b51HW1c8sT360OPFt8n1ekiLSaSsuorRE86i0udvcR9KJhPP3n0PbTKyqfZ72HrXzeScchYipxUb7RI97XEkRSdwZbeh3F/fSOwvq6guraIs4j+sMxNFlrFZzcS4ndhtFrJNCil2G+VCkNbgwWoy4w+qKNFxxgZyEGKjoXo1IGDOYkT3UQbJqaZRXFqGOxLBz+FTTl38yy/07N2bGydNYkdjAz8u/pW1v/5Kv4hKioCl3sDvzAuzYsJpddDBbCfsdKNbrOi6ji/kxxNowhPwElYjex3oNU2nyRfAE9SRFBPC74f5C5D6d4aKWuicB2Yz4R5DsTRzcSxaux71DyjuBVC+aiVfPPs8x06+wjjXUX1g9udIDVVIVgci0IjlktNatmmqrqYufPBhgANFSA2zOhTAXFJM/vdLaDduIFqmk2B0IhZ3NPZhRo7Zytk/8f3PP7Ij6KPoICuDhK6hNjSRHja8C4GqKsqiHJjy0kmsrCeghgjkd6Zjq44APPbE42jewH5POmSLGVtKAi/c+l8GyW/glkxclNSRc6+8n+kxrbjnjruQfIE9yhUosozL5uSaSRM54eQTSemYh2QxIwIhQs++j/btN4QCOlUTzqH95cdisdlxWh2E1PABM/QKjNw+t2v30lV9ykuEv/oAseJXIgt+pvabz2l1/pUAnHjBxTz68uv8/OtiANpKkCRLDB84zNh461qY9yUM7wnlVfDLWohEkBoWI6oqkJJS6Dh6HAkdOyD99DOy2YQ5IQZnZjLRrdJoa7cirFY2R7sIlVTiLyghWFROpLbx/4e1+t/wzf8YBAzo25eOA4ciVJXgkm9xtsmEd74CDWNm5/XDrI/QsjNQxhzP0edczHX3Pcg2SToitMKyxYI5IRpXlzZEdWmLPS+Drm06cHxMJnmxKeiBIK98/AFrX3iFSJ2HhsOQsCUh/VdRvzHH1sMRfNvLeO6JZ3n1o4+wZ6eQ3ymft87/DxlZrXDGGh6Qcy48n6rtxbs6UklCtppJSjNqRBatXIBj8wZqJ17AR3dfbQx2wsm44ydwWmIH4gdJPLOtjl8KK5B8wd2qnw4FpuackVaZyXRpn02nlHjy07Nw5+SRltcJ4Y7FYneRmp6JJMkIXUMnglxaA3kZUNWA6JCPdNq5ALzwyF18/u0ckjRB02E5w10oLi5m8p137rasAPgJWmLocRhMokUmC1nOGHrHp5IXl05CTCJy63a069uB1OxEdpSV8e577/Hlgnn4Qr49ejc0XSet3kPJwqWooRAmh4PA2DFY169CEgpiyFg4ZxKW5jyrTSuXU7B9xz6TXFsgNB669jpWbCvhzicfwjGsJ0W5ebjra7A2VKCfcib2888C4JNX3uH2B+5lR2nJn0Y7r2oqy4NNlNeVkLvge9qNG4h7XF9MaVEsv7eSQccYHsFvFv3I+pLNVAW9hA62txeg+YMMzTY8R0WbNvGJptMlKoo4q5XTz7qSs4cYx/PU17Nm4a/o+8HBARgTGKuZey6+jJO69UfTNRZ++Bp8OpP4tEyi3TFU/LqQqMHDyLnuJqwuN2NOOoOLnnwcavYstWeSTVw64Swuu+/WlmV6TT3Bpz6ABQuQ7C5s4UoyJC8AobpGYp3RNAaajLDYAULXBSdccAHnvf0WUWqQM+57gJ59B2I7/lw4/lxsuo77N7khnz7/PE2LlxCHUQUVFuBGRm9qZtZt0wUafTDrJ1i8AYrKIT0BEmOJvP0MlusfpL6qgoUb1hu0B+lJRPVoT6+cVPK6dyW3QyeSnG5iFCuPFq+keNlaGhetwrNiE8Hiin2Gvf7F/uOAjZIFCxbw6KOPsmzZMsrLy5kxYwYnnHBCy3ohBHfddRevvvoqDQ0NDBw4kBdffJE2bX5DPFRXx+TJk/niiy+QZZmTTz6Zp59+GpdrVyne6tWrueKKK1iyZAmJiYlMnjyZG2+88dCudj8hA92EYGx3owSyatnPmL6eh2PDVqSIDq3SIByG6kaEP0hgzkxcY47HYrcTCIWPTL27IqNEO3G0zSZxVD8mHHsCE9O7kOLYnSDupTs6s+HEM+h77FFIpZW7KY4a1W67LIx9dfQ7acAtJgtmxYwsG5TqETVCRIugahp6MEy4qo7shiYcBTvw/rSCYR/P5vvPviIjN4/b7ryDebO/2X1mZyQrUFBcxBCguy2BpsISmpxOjnv8DRwBP01OOzUJmSQMHMLItPaMvPkRzi5r4teXXkFw6GGxKACblcy0BAb2aMdx44bRf+gJONPb7v1+yArV2Tm4KpZiiXGjKgqWm+7EJMss/mkun776BikNTSQIcdi8JPvCf+uYxAMJSHjsUQyIT2dglwEMO240UnQaWUPbYYk3Zpz5wJgzT+SU8Scy58d5+EL+Pe6/MaKydXsZn3/2KSeddhb6hEmU33MTrhvOI3qiMTNtrK/hjVde4PGnnsUXCO2X4VAKVOoqBW+8yhnnnEHbHl3xXXE+6icuEk88muiRg5FkmXkff8bNd9yBo66czkJj8cHfqgNGKBKmoqGabxb/xFXNyxxdOjLok2da2uwoLaC6qZawdogDkaazcM1aLgL6jj2Ku6NjqCgswB2JkD3CMEiKNm3kzptvPsDZuIQky0TFxgKwcemPBD+ZhrPBS5XXS6XJREN2Bk3BOja/9CjHXn8fqiwhmxR+z8RkQJZlevc1kp7DWwoJPfIWSlBCLJyBHAohMtogouKwDTGYZjavKiBPMREQxnM/GASDIWZ//Q0pNiufnHIyd19+BcOPO4H0dh1QTLuGr5Xffst9V15JhF15NjbAo6nc/+T9vNL1Y6xx8TD8OHjiEQgEISsZ8rIQgSDCaow95ZXlaEKgOO042mYRM7g7XfsN4IGex+12XgnR8UyOcSDJMmqjlzZVtVSFIlQc5HUeHH4rFLm/7f/6OGCjxOfz0bVrVy688EJOOumk362fMmUKzzzzDG+99RatWrXijjvuYOzYsaxfvx6bzYjNT5gwgfLycubMmUMkEuGCCy7g4osv5v33jbiex+NhzJgxjBo1ipdeeok1a9Zw4YUXEhMTw8UXX3yIl/zH0IEAsLXUUHiI6dyTpr4j8Fc2YI9zIQ3ojLS2FHHZ8ahqkMjipbvujz90RNgnZauFjjFuRp09gavOvJCs5qqHcCREQcFGNteXImekMTalIx06deGDV17j5NNPJ9TQhITBjmixmDCbFKRmzZZIRCWiaqiavtuAosgKdrOVaIebRHc80fYozCYzwUiIBp+HOl89jf4mAuEgpoiKOaJi8gXwmmS2VTcwcORIBnTuwodffvn7CxEChODV777mgrPOJ6tHP2qffB7bbbfga2xCVyQsusTCV58kY9kiel51MwBvP/Uc42Z9w46CbYd0H3MxvJjdzTJt46I469wLyR9+ApJiAk2FkiIoK0RLkFHajGjZzlNUyNrCcmKHjCDRHoWIjia7i1Ey+vQzz7C+poFYTbAAflcB8GdgqyRRYbaTF59KbF4Pjrv6IpKHdm9Zr1U34vt1E6bcRBwdWnHXfXfz6/jFBCOhPQrLbRZgCQR56OFHOP7k03H27ov9s7nozW2nv/MqTz37NFsKS6lr9P5h6Oa3UHWNBp+H62+6mZlff0mnEX1gRJ+W9fOmf85FkydT3ViLVQ0Tewj35WCgCx1rOMCO+XN479bbiWvdmvETDdbc6rIy7r37Xt78dNpBzf73hG+//ZZwIIDFbqdPvwHQb0DLuiduu5WPHnzoIIwyQxF8VZFRDxTjjEZsKUIoJprcLlSbhcxNW2GjIDLAyNnQdB09orEnP78sy5hNJjbvMPpEtaoOquoRcSlI9mh0JQDFG5CcMSg5mQD0HNaL9CcdlHPwRgnADgEloTCZ5VU8fc99/Oehh7FYLES53VhtdmwmC8ENGyhk929vAxCvCbQdJSz+/nMGH3MuoldfpDg3BELQNQ/RKgO9sB65mxHeqi0vIzmk4k2IxtE2m54D+nF+B0PpORIMoHm92BIS6RmbyQMWhZsbmghuKcK+ajMWfwj+Vek+ZBywUTJ+/HjGjx+/x3VCCJ566iluv/12jj/+eADefvttkpOTmTlzJmeccQYbNmzg66+/ZsmSJfTqZdTrP/vssxx11FE89thjpKWl8d577xEOh3njjTewWCzk5+ezcuVKnnjiib0aJaFQiFBoV0KVx3NoxZEbgO3TZ3DOooX0GDAQ69U3o1/6H4KbVmIKhjBfPRhJVjADsWdOAkDXdUJhFVmSkWSj5sEYg3V0oR98SE+ScJtNPP7Yk4w81pAl92hh5hWtQ376KdRgiKDdglBMvD+4H2cffQFHjx7HW69P5fwJE7CaFBLjokhOiKGtIiPMZkqBusYmqus81Dd68QfCaLqOIsmc0G8g195yM34VhE9HawoTbPCzfeM2iqtKKKgqYktFITtqSvGHAxQL3ZidqIZHZEfRDnYUGYolEhKyZMzapOZrQResX7uWxsZ6oqNjiR85hsCqlTRNe5/NPTtT0TqT9luL6XDaOS23YP3KFdTV1R1S5wZG59jXYiLO7WDIsOF0GtXM3LlxFcz/FJatBBmU3CzUMU5M3fsC4EzLYNSb03+3v9mfz2TW19/hDYSoPMRzOxS0RyLObCUxPp0+3fuQ2L8TAKKuHu3nJURe/hilrIxI2/bobz5Ct349OeHY43njg7f2qnYbjqisWL2WK86ZwOQbbyK/W3dkRaGkoICrbryFJm+AQDC0f2Gb/963FmHWvDm8d9/9nHP3XTRWVbNo2jTue+Mt1q5fR0gNo2oqPnYRkv2ZMAOarnHXQw8QC7z98Yccfdxx3PrwI9RU1WA2mbFbbCQIgU/TqBcakWZ+jgNFaWkpI/PyiMrOJiEvj/YdOtC9fXsqSkqY8sgUHAdzAQJEOML6dUa9WkJ2HvU5rWjy1JNSVIouSWiyhDc1kcL8XAYAZlVD8/l3I18zKTJWqxmn3Uac242v3uAaMuVkonfuh7L4W3Sny+Dw8TZAJIT3/hdw3j2Z1A65JA8dzIaCQ6+Z03WBCZC1CE1hFUGAmrrGfXrnNKBRVSmtqGPVijUMPgZo1YbQ4KHI2zdBSirSBZegtOrWQnpYtnQ5qhpmkC44qscA/tP9BOP4kQhrzzoV6/oNOE46iaz7H2a4M413ux3HwxVhZi3dTFVTM6v3nxRqlDBE6w+k/d8Bh6R9I0nSbuGbbdu2kZuby4oVK+jWrVtLu6FDh9KtWzeefvpp3njjDa677jrq63fFLVVVxWazMW3aNE488UTOPfdcPB4PM2fObGkzf/58RowYQV1dHbGxv5873X333dxzzz0Heyl7hcVs4r7rruXCiyaRkJe327rta5YSCYRp08eY2WxcsoSjBg8nw2Sh2GpHUkyoukogHMQX8hNW/0DufG+QJVLa5VK6ZiOyojBnzU9s+WUBlTFRDHp7JgnFZUQ1NBF0WbF7/ZScO4Gh9z4GwLKfFzH5igvpkd+aLu2yaBfSSO7YjZooB8Wl5SxftY7v5i9E2lGBxx8irJh58+lnGXHFJb87DbXRx9a5G/hx9vf8smUZCzb+Qll9JYFwcI/VHCa5WQXW6sBmtpKEICx0KiTQ4hxcPfFcbr/xrpb2X8z+AN/c71g+qg8X2rNpP3QcldUVnHbT1RR8/DluX4AmOCThQwmIj3IwoXcX7n1vGu6UDFixEG67AVqnQW46VNVDRR3aBZejDNlVBaJGIuwoKiLi9dKuWzfKt22ja98+1NTW/Wk5D3vDWGQSouLpdPblXH33f7AlxaItWUVo1HiQJIQ7FsnmRE/KRpt8PtGnH8WOTVvo2LXbXkM4v4UsS+Tk5HDRsOF8+8MPbC8owImR0LuzXPxgq9Lb5ubiKSrCoqqUSNKfpnOzP0gDnEAIKG9OIE6Miqez1Y7F5sSlafg1ldXhAD5PDeUhP2E1/Je4BslsIiozlTU//ERWRhaNAS/fP/cQiZ/NIqmknIKu7fh1/EC8w0cypd1IQn4/rvQU1EYvCIHZrBAfHUVuYiz5SdE4W2UxuM9gTrzsegDEo69AUgyMGYpeWk747seJ1AYJOhQS57yPJMv06dyL5etXHDFCSVk2uG92vny6EOi6aPkeJQmcdhttW6Xxysuv0nPgCPRwiOrl80jsNhTZZph8axf+wOsfvsdbb75Hv0iE2PREHpr/I1lZrSkt2Ya49lqYO5+Iy8GawX1wDxtBn3MvwWHZVWa8ZOFPHD/hLCorqxC6blRJ7UdS8sFq3zw091tszgPQvvH5uGXkmP8t7ZuKCiOilpycvNvy5OTklnUVFRUkJSXtfhImE3Fxcbu1adWq1e/2sXPdnoySW265hWuvvbblb4/HQ2Zm5iFekTFbvP2xx3nw+ecYPmwIF541gYToGN6f8SFrFi/GUt1AY1Q0I4eN4pclK+mYkEGePYpOsSnE6ipFJgsV3jp21JZS7anDG/IdhNtXol/PXsiKQlVFKVs/+4DE8gZcMW6yN27F4vej2azElNVQlpWIvbnMFqBn/wHceeIJONVaWo/qT0qHcSjRu57PmcCsZ6Zw95TH6BKpp8biYt2aLewMXAQXLMfksqLkpGGKi6X9Sb3IHNCWxKmfUVRTgifQREgN72ZsSUBPJCI2B5HYVLLi04lzxZAT8BHUVdaiUxVp4s1Zc+jSszfHjTQG/mPHn0lgwDjU76eTNcTQGvrPS09S/c087MFQi67IoaJj5048NfdnAPSAD/nL98Akw4bt4AuC1QwxGS0GyaoF3/LJ9M/59u13KatvpFSSSE5Oxu/34fEc7rTWg4O7TR6Pff45Ke3bASBCYUJTXka07w1aBLqPQRSuAjWI56OvcRw3gqx2bejXvx/zvp//hxwmui7Ytq2QT7cV4gNqATvgkcBmMSPLMrJkhAVVVTsgLZHNBb/JEvoLDOa/RRlGjpmsmIi2R5GdkMHg7v3Jbwpgs0ej2pw0RoL0KVpPOBTkS0lhSchLMLJ/OTZIOxPJJQz3hjhsVRJC1fBV1TD8rFP4/N0Pyc9qzbj/3MnShBTWNtURjI4iHBvF5S5jsvX5Jx+j+YMgBCaTQrTLQcc2mYzLTKZDVgoJvTuQ1zp/16nfsMtrraQmY//yHaRPvsAc7UKSZYrWrGfzts1HJMdOUWQsJhNOhxW7zYrZpKDrOoFQBH8gRDAURlU1hIBAMMy24kounDSJ9156jU5DhpPcb5e3/9ZLz2X6nHlU1jTgDYZYbTYRn5pCRmYOACtefJTsDWtxuJxIkiC+rJKCbRv5fuVX3NL1aKzN/Ce9Bw6i+4C+LFu2lESfj+JAiCZfED2yd+r/f/F7/GOqb6xWK1brkRHVjqgaTd4As77+jjlzv8ekyEiSRFxEJTMYoqaijrerZzI4PpO0/EG0Tm3NgG6tyerbnpVzVrC1pg5brODFDz9gc2kBnkDTgc0chCC92aJ3RrnRhw9hc1kV7pIqVMUEViu6YqGkbxdqBvXi2Muv3W3zfiedgdlbhqPHYCRzFIQCiMZqcMYgOd20HTSAvHcSWR1Ukc3RdBthmCTC50e77xk0nweprhTlkolYJk3AmeLm+JsmsGb7RrbPLKbR37SbUWJSTFisDpITMug9Yhznn3saKT3yUf1BQg1NhCWJquJibnjgEW5+4km+2bKe/p06cUznvsREx3L6+LMxW4xn6axsQKr3YD2MJdZTX5va8m/Z7gRfyND/8PvBYTZKvtPsCF1HkmWCksRHn80gur4RO0aYcqcB/VdBcq9eLQYJgGS1QMCLpJgR3cfAgo+QmxpAC8CZFxMKhDDbbZxxzFHM/X7efh9nefP/y7JEUTO5XLzLTltFodxmwR9R8fgCKGY7JaVlhA9RsfgvAUnGYbFz3ukTuP3Om4nNSgcg0uhH8wYJqwKtsozyuXMpmTUHEWzglxWLiexr8iFJu7RoLGZMCOJ1nfKIhh6OIFSNBCFI5iAJA5tzIPVQhB2rNzD6lBOY8dJr9O3Rh4EXTP5d86Dfz7N33kV0OEKjJGG3mklPjufEUYOZcPbFWALVmFOisST33rkByApYdu9zbaccCxikeK/ffz8E/AdE2rc/MJkUXA4bSXFuWmUmk5IQg8NuJaJqVNc1UlJRR1lVHXUNTYTCKpquk+7xoQV3MOLEE5jy0MOcf/FlqKEQn99zJ4vf+5Qdqko4rKIJnXJFYWjn7siSTFV1GataJeIb0puE0moCThcJZRW4/EHyWrfH1Jxs2xT00+Rp5IXHnqC4aBtPvvoMkS3bCBVXEqlpQAsE/zVM9hOH1ShJSTE4CyorK0lN3SULVllZ2RLOSUlJoaqqarftVFWlrq6uZfuUlBQqK3eP0O/8e2ebPxu6EIQjKuGI2qIT5xSwFWhrtZESnUyfNj0Z2Kkb7U4ahruvMUCM6N2ZEbKRU9FjaH+uPftc6kMBluuRA/hYBe98+QWT166hXafOXDHw9JY1FSnt2PTWC0RcUTR2yKP9sWdgsVhZsvRXin6Yz4mTryUmvxvQzdgg4IdbrkLyViFGHQNnXExSbByx7bIweYKcftr5DD7N8BCEbn8EqXQbUlouIj4Ndfo81B9XYbnlUsy9O3HW5ecwbfYMFHmXEKGEhNPqIJLSigHDj+WGp2/F7LQDYI124Uw1GF5T2udw/NeLmDPrIz596hXec5q4LtbNd1Oeo3OPXi37G9uxC2/sbxnkft1J+Obtt7nsoYdblumpbZCDPqj1QFMQGoIQ2Eho+utYT7qIvoNHc+MZZzPl4SlsOWxncnjx0kcfEROfxAUTJ5LTqT2yomCZcjehW59BLJuNUl+BHgmhDh5JxiPXIpkU/A2NLP1q9gEfy6TI9LeYcSTHM/KsU5h80z2s/vpTtv06j2BWDsPHnUV2u3xuv/xSHnv9jb+9lkiMO5oPXn2dMaeeuNtyc7QDc7QDG0B2PLF9OvP0LVcDMHrwMOb+tGCP37hkNqG47FgSY7FmJDNx/NHEa4LvFv2At7aeUFUdkeoGXB4v1uZciv027RQZ2WJGtlqQLCYkSUJoOv6CIq4eO46Lb7mFsSefglcXqH4fUXYHkUCAh2+9lZqiHdgAryIT77QzPDGWM8+5hNg2XX5/HNvumS5qMIjJZuObtz/CG/Lz7Wef8cNXn5OEoHF/z30/YDIpxEW7OGrEYG676TbSWuehmBRQIwT9DQR2lDB7wSy+mr+Qxau3UlXbaKgGA8GwSm1DE5OumMwLr71BSXExaRWV+DEKG3bCEQ7TKmRMsoINDYRq6qlPiCa6shp/jAN52Bkcc9r5WKJjAFhUvJHlTVVc2XEIANlpmbTr2Zvbf5jOwplfsf37XwnuqETzB/41TPYDh9UoadWqFSkpKcydO7fFCPF4PPz6669cdtllAPTv35+GhgaWLVtGz55G6di8efPQdZ2+ffu2tLntttuIRCKYzYbGx5w5c2jXrt0eQzd/NnZ6ZUuBfNmE1eKgc5uOjDh6DPlnj0FxG3E+rawGJc0YhIWu03nEQIYPGsaczz9C0tT9z0MQ0FTXwIgJp1G6avcgRlS/fmR/9w3xjz5BVFxiy/Kn33qDKVdeg2KxoAd9yBvWgMkMDz0ARZuhS1ukGiNtNCqrHZ06dULIMdxy3x0A+LeUoK0pRA40IBVvQmrVFeGpQQp6CT7xOqa3ppDbtT0DB/en4JPtLceVZZloRxRd8jpz5YPXYXba0TYWEn7tEySbHSk9HetlRufeQXKy3BZHcmklm8qa8KJz2Tnn8Mp7H9Cx+f159+tvDvuH/PrDj/DJqy/x6LRp9Bg+Gvk/N6MvnIcU/zFsL4VEF6oG5SuWkHnceZgsFvr1G0BH+MsaJZrQeeq1V1k97TNGDxrDZe8/h6lja/yD+yB9XIjWqi1awI8nECa6WVPm5y++4OP5cw/oOJIkYbdZSYt3MzgvkwuvvwObO4Y+p11EjzFHo0QnIUlG0uDpF13I69M+IraukXJdHBEyvyMJGxCSJN568QXGnHoiuqpR+8UPKAuLsHoqkTJSkFt3AIcVEe/CNqgVkmLc21FDhrDjpx/Y/N87VWRMbhf21ml0zkjiuKOP4saLbgBgcsDPxBmv8v2cuXjXbKWkoITtHu/+vf/NnhdTlBNLShx5nToysEt3finawvZthYSr6vCW1/DgHXdw9223UyJJBuePphvyD7/pi2yKTLbdSlarDOJ3GiR+Dzia8xA2boDaMoh4YZhR0DD7hRd4/vFn8Hk8rIiECEZCxCOo+u/zPETYrGY6tm3FC6+9i929Ox2CNTaJ6PS2TOjYBVW/l7pGL75AkEg4sqsyRxfousaSJUbFZPkejhEvYPnPiwBIzs7DU1hOlEWmOtpJ+ur1dL72HizRMVQ31rKpoojqlFgmpRrVOzv89eg2GzkWBy+PPhtGn40vGGB7YSHbVq7iwquuoqbmMJEG/EueZsDr9bJ169aWvwsLC1m5ciVxcXFkZWVx9dVXc//999OmTZuWkuC0tLSWZNgOHTowbtw4Jk2axEsvvUQkEuHKK6/kjDPOIC3N0Bg566yzuOeee7jooou46aabWLt2LU8//TRPPvlniHIdGLabLXTv1pNrP3kVa5RhjOjbiwk//zbavEXIY0egmxOwXnUipng3tvRWFDijkSPB/exrJIPATNOpKizmzddf4fyLjFjusrVLKHjvdY57/GlsMXFous7m4kJ+/PZbZs+cybP3PAiA/8m7cJUXQ0k51HmgoQkqayHZMEokReGymx9l+9o1Lcd1tMlAe+MRIg88hjbzU+RwWySTGYo3QlMNTe9Px33+6Vw26TzenPYeAFmABYmoqFjumHIr7qQYtNomgk9/grx2CaKsAGG1o4/pgZybzbBHLsPyRhw/33MvUmMd6eEg69Zv5KTevTl20iRiXC6+3FNZ8SFiNWD3Bbj8uqt57L57GTjuBOSBI1Bb56E+8wSRkcchd+pBdocuyM1G8drt21ly2M/k8EEIQSgSotBXz1crl9Lr6wX0O24E7uvOQrvwaJTYaISuY2/clQPTqmdP9kyTtXcoskRcjAt7786ccP1t2GMTWtaZYgwvpr5yMXK3PnTs2oMOuVlong2o4cjfxihRZIX2SDiBLYqJUccbHBXLHnmFnGmfYE5tg6ypiNVL0B1zkVJy0d2x1E2txnnnxdhaZ+EOhihjl2pwy77tVmzZKUT378LgPn245pTLWtY57A5eO/VSrkiK47uZX6AHguihMHrgj2naJbOCOdaNo00WucP68e2NDxEXFQPA+pJt3DLzXX767Cty1m1Dr21gxz50WxKEIE6WkJ2/0YqZcgu0bQ8vvw8VJTCiF1TWoHfojZychlUNEa6vpCkQxC9JCHH4DRJFloly2LnhP9dgd0ej1Vchf/I60sZCGNEXMrIRnUdgiU7g5JPPZ+W6LZRW1JLpDSCpGiv38zhFQPHGzdTX1hAbn0DHo89g9XdfcsoFlxO9bj32XINza+GKnzlh2DEt2/lrqln+wM34EmNpPO08MrPziDHZcNrs5HfoSH6Hjhw9fTpvffLJYRb1ahUAAQAASURBVL4z/zCIA8T8+fN32me7/c477zwhhBC6ros77rhDJCcnC6vVKkaOHCk2bdq02z5qa2vFmWeeKVwul3C73eKCCy4QTU1Nu7VZtWqVGDRokLBarSI9PV08/PDDB3SejY2NezzPw/1z213ix7kLhBBChGo8Ivz+dOFrnS+8Sa2EPzpDeDM7iaZz7mw5rydGTRD94tKFWTHtdZ+SJAmTYhIum1PEu2JFkjtBJLrjRYwrRuTk5YmK8jIhhBANVZViw/LFQgghNpUUiezjhgt763RhinKIZIdNaJpm3O/JZwt9wlghjhkgRPc2QuQkC9E5R4hHr9/tnm1aslhsXrlKFCxZKUIen/E8I6rwT7hcNB11hWg89RbRFJclPNGpYvX4M4UQQkTCYREbHSsAkQ+ih6SIZ+97RAghhOoPiYb7PxS+XkcLX1oH4UvMFr7YNOEbOEZo24uNe+bzi75tewiHxS4A0QZEBxBdjvBzk2VJOB1WMT41Xjx14ZnC01i/x/do+a+/iFNOOVlkyLJw/Qnv06H+zIpJxLtixY+ff7XP7+PXHxaIDu3bH/D+7TaLOO2o4cJbV7NrZxvnCrFhlRDrVgpx85VCnDJMaGXG833iwdtEZmKMUGT5//3e7O2XAaITCAVJuKxOkR6bIoa0zhezn3tJ1FRUCiGE0CIRMeekq0XloNNEU24P4UtvJ3yZnYU/OlV4+54gvBc9KmouM957TdNE3/yeoo1RsLnruzYpIjM1QQw5fqjoOuMxMbd6ixBCiPo1K8X8C04R5duMflLVVHHTj5+IpJNGCEtKvEDZ972TTIowJ8aK2BG9RfuHrxIrPMY5BwI+oapqy2MKhUNia8EWEZuTJiSLea/7S7SYxHE5qWLLL0a/pgcCQlx+hhA3ni3Eg5cI8eINQvznNCEmjGvZd9mGdaKXzSwSj+BzsphNont+nggF/Ebf8/wDQpw+XIjWqUIM6ybEnROFmPOGEM393k9ffSCG9M4X2XaryDqI413WPKYJIUQwGNzn9zT3p9li/jkni8UDu4lV+Xnik/NPElf99KF4/bpzxNzp7wkhhKisrBQOp/N3x2lsbNznvv8bO8e2h777Vjz588L9/j303bcHdbw/GwfsKRk2bNi+mUAliXvvvZd77713r23i4uJaiNL2hi5duvDjjz8e6On96ejXsyeDRhjkOgSDhLdVg8UNqhfhrzUkwndsQkQiSGYzVrcTVRJ0aJ6lrP6v/cmSjM1sxe2IooczlhSrA4vJQkLEzwLZTFWgiYvOPo8XXnmJrNatiU40KpmuuOZqyhYuR/MF0MMqrXWdmuJikrKz8XbugvWn+TirGyHaCWYTqALRsT8SUFuylVeffZI5Uz+gxBchNrUNI7oN5spbriCtZ1ss999M04QrYX0xhPw0Wh0ETcb5y4qCbDLc9esAm8nE+GONnJSGGd+i/DgHdqxH8jWhO6KRI35EUSnBkydhmfcJFreTrj26sWa7EZbaguFxMR/BZwZGNUkgGOYHtZG1M79i5qYxvPTEM2S378ji5UuYN28es2bNZuWq1aiqRnuM0tBNR/i8DhURTaXR72HmZzOJSUxg+eJlzJ37A6vWrMVsM2OLclBaWUZR8Y4DpuzfScI34YwJOGPj0asrkGd/AH0z4MWX4bvFBtNxWhLU7YDUDAb1GcBbttcoZ+99xl8BFiDb6qRjdAIZXfpwy/OPkNU2B4CIP0jB6x/hNlkR0QlQuR08tWB2oOsRpMZadG8d8snjANi8Yi2l5eWUy7IhR9EMSVGIirLTq3NnWvcaTvsYI2G28rtvca7dzJarryR8571k9ezH/QNOwLNuG2+t2UqkzrNLYXsPkCxmLMlxRHXO446zJtItKolQOMi8x+5hQ5c8hvYeTq/UPCxmC7mt8+g0dBCLZnyFFomwp8fiAaoTEsnra/RrYt0yKCtBavCDGgGHFcwW9FGD2EnyLiIqiWFD96n60B7F7+ACUoE6oTNu/FFYbHa0yjKkBfOguh6EgHXboEMrWLsGzN/A0PEMPOoMJm7czlX33E/Dfnib/hsvvvUWAUni9ddfx2q1Ul1dzeYli8nq0oXMDKOyU9M0FEWhduliJLsFm8lMUkkFqsWC9tFXpGzYQs/rjPy1Kc8+hd//x+X3+42dZs2BtP8b4B9TffP/hWAoSMjrw+pyYklPRDljLKEP30e32pBDUQhHFKL7UKTmMIBzYG/K5n+O6TeGnQlIAiokGbvFRnJ0InnJOXRPzaOt1U5+vJVAWRUZusISNcTq7RsY0H8wZ19wDjdOnsys999n7swvjEFG18kSEAaWffE546+cTMYF19CU1xHf3OnY1m1FjjQQUYOYRx4NwJczP+DLGV8SaPLiD+vklW+jSNN44n6Ve19/EEdOJvptVxP4bi6a3UZtaipZY4YC8Nabb1FbW0sbjBwbVdeZ9eUsJnftRNSYgTR+8ROmYy+DVd+jlG2DkIKIisHbbTTmbeXEdcujb/d83vpkV+e94895dIZhElEpb/RStWQlPYYNQ8JIav7vstZ6/kAm/kAhSdCcAL0TxvMTHGpZrKprPPnGazzz5tRmlWCpuf8y/idLYLWYEUKg67ohGbBfsUSQJYmM1ob7Wp32LpYNv0J8PyguB7sVZAmyUpBWrYb8AcTExtFaU9GBNb/ZlSLLKIrczDFhPAtN09F0/U/nfCmVJLz2KHrEptCrVUdu+OAlHAmxRLwBKl/8mPCsrzGpGqnueMwmC5JihahECPuQMSEaKtCL1mNrczYAC2Z9QyAc+P11KDIxvXvzyN1PYlJ2db21YR847LjKyln97BQa7riXLrmduPOU83jnhVeRFHnv44kkIVstWJPjOWXc0ZyV2RmAOd9+in3FSjqsW49y/3P8OHgAgx9/EYDbJ13GsV/PRfP69/iuqZpOQWERM956lRPPm4TccyD6pKuQnp4CZfVGCDjKjnrRlViAsqJt3D5sMMk6LDvUh7EHuDDKsl3AqH4DAQiuWYpNE5CWbHwzFTUwfymEIuB0w1Cj5LemtIQ4/eDFSd98800ay8sZ0Ls37z3xBCa/n2UWMzHtWjFy0tlMm3wHwUiI+f060t1TR1xJBbqukVRUSkmHPKLuuBNnahq1NdW88tabh34z/gfwr1FyiPh5+TIu6NmP9zcZXa6Sm41IcCPpOiIcgI6dcN52Rkv7866dyKMvPc76hsqW/qAVRna9S1ZIiE6gW3Y+g/P7Mn7cCLKHdMKWGoNa14jj9cUkFG+jtRphvqrz6vMv89ijj/2OkK0MsAKX3HUXH7Ztw4Ax44gefjThPkOo/Hoa+vRPkMx20q1WwgE/X7z2NlpZNTUhlVIB0UEfhdU7WLnkO+IeTubWKXcSd9RwOGo4YHgyAPxeL7fdfhsxGNT8qUChrvH4M89x+rkTSMpMRxrSCf+Pm7A64yBeRZJNaLpGxBkmsbPBRfPz0qWoB0MqdxgghNEJq39QcnzYCoB3loLarJiinShOO/EIJFWjMqSief1oO1VaD2Fw1oVA11Qimoosy1jMCk67jWi3gzi3C4vFhKpqeLwBGjw+PN4AwfAf6DYJY79Ou1FNpWdmQtFKeO0zWLIOLGbo3gFy0xC9eiIBDVWV1CG1JBTuVGaOjXaR4bCTZZaptlio1zQ8TX4aPD6a/EFUVf3TKEvMipl2Wblcc+PNjDn9eCwOK7oviO/JL4j5fJrxHZttRFLz0GwO/JltUMrAWt6IroCvU18cxwzF1snQTvr4q1n496Js/Mi1t2BSTBR6qgjPm4dj9rdkT59BxGzBpGvsyG9Dw8IfILcT9V6PYeTtCxLIFhPmODf3DDMSyFeWb8Py/kcEJZnWK9fiqPOA9BPvfPMO54w9h2G9+yPbLM1iWLvf5BQgRtMJNPm44c47UYNeTr3kGuSjTsWzcS3ykkWoTT70uibMmuFh+mXOtyzzB/HDYc8jAePbqwBMSKxYv44RJ4PcLh8tGESpqTNKk+t94A+CxwcnXQBA+bqVrPv0E6LCh1a9N+Obb5jxzTfEALGA0DT8dQ0MSMkBoKpwM8c8/SYmVUM3ywQS4gjYLCSMGU33IYZxdOuTDxPwNPG3cVf8P+Jfo+QQoeoauSOG7LbMOf9zALS6BpS4mN9tc97xx3LjYxtb/i7G6AxMNif9uvTihuuupdOwPphsu4IYprhoupzbh5zVyQw/ozeJU9+j6MsZ+EOB3xklKkYYRKqrZ+Sxx3H8ccfw4EOP0DqvDWknXwgnX4iuGkWGFruDrB4DWb/mbaqaFYDX6SqK34M5HOCxF57AooTp1KsXiQlx1Ho8bC8ro7qkmK+/+YbycmO40Wn2JAid6oYaPnrnfSbfegMJl52NflEEtaqOyNotaDNnUrG+iJRrzkFWFL6c+QXvfTYD/QgxPv6lIElIZhPm2ChsmSk42mZhSYlncm5nxvYbxgPffs43X83CX1CCWu9BD0UO2jCxYKgGl0tgtZhIio+mY0oC3ft0o2uPbiSnpuOMjsdldVO0ZTPX3HkHO8prCARDezVMBBCJaLz3wbvc26M3ljHHE1k6D7MWAcUE6UkGg2WVBymzAwDzFi1gi6rRIEkoioTLYSMzNYFuHVrTv1U2Tm8DEbeDCgHFZTVsKixjc7OeTjhy5A0TSZKwmMy8895U2vToalxnRCX03QZMq5dBdDyS34foOhRcMYQ3LqY2EkCJjiWx0zhs/XsRd+5ZmGOjAfj5m+9YsnoZocjvB8KzRoxkUHO5++yvPiDh+4XkL1qJzeHA73azcXAvfLFRuJr5ZkpLiw0Rvj/yYjUzmm6pLad7ei4ZdV6aqmtIL6tCRSEQ46a4bStCTqOMt7qy3HgXkX43RHqBaKA+rKJV13PXo08Qm5TGqBNPxzbpWiInn4szLgFdgLW5+qVN+3zWhVWO9LRC13ReffttrrrpNuyZudR36Y6ptBC5oATi3ZDfGu68G+Kz0TWVr+6/kwaPn0rt8LxEDc0/dB0lrHLhGIOTJTUrj02d8pEX/Up9Vip11TVUdchj1FmG/MizX33C6rfeITcQZNNhfJ8lcYA0838Te+hfo+QQIYTg2ffeJTYujp7DRpCXkUFSTiZmu22PBsmL99zL429O3W1ZECiWFbpkZvHSB68QlWAwsuqVdUTen4a+YhW2x+7BlJxI3GijRO/C3p1Z623gzc+mEYqE2RMfggBC4QjTZ37ON9/O4epLL2HixItJb9MW+TcKm5dcfS1PTn1rt201oaNFQoTVCDdPeZh2uo4LwdK90ID/NrQRUsMU79glnCdbzFgykrFkJMO4QewkOK6truHKKyfv9fz3hFwMV+5ftTR3X5BMCu+9/BJDRo/m2+0bWIqHvNQMJmf2xGQ282GPviwcPpYb7r2L5avWEa5pOGg59FYYhqJJkkiIddOlXTaTx4xh9E0P/K5t+94DuHjhPN6Z8TXrNY3gPo4ZUVXe+fBDLp54KRntOqBdeRf6yvnIP6812HBFLWrbbpjsLhprqpjx+Zd4/SEEYLdayExN4LbJl3PieZdgjYohULKJgK+YmpLNeLwK0c4M7nzmSeYtWnrAQn8HAwmJM44/njY9uqIGgtS/9x2OaR8jNTQitesHK74HkwK1ZUhNNYiuuWSedRXutq0NfoxmFG/fweMPPcqb776NL+Tfo5fEFtl1Xy8+9XIqpBhKNm6jslUmpe1bI2mCxtQYBue2B8BbWobm8Rl05XuDgB5eP1plLa9uXMwL6bnE5rUjEBNNvaxgb2hE1WV8ibGYLBYAPPV1iIi6x2/Oy668KTkUpri8hiuuv5EFPfuRnJWNJSr6d9tEu6KI1vUjrlGkC8GOkjJ+/OpLRpx4EvKZF1H71fs4fUGsqob00NPInQ0m6LWvv8CaRb+yKBii6nBbtgLsihmHzfAYmm12Rt/6CHVFBfz4yqOEjz2aYZNvwmq2Ut/UyJ333kOyx4/vn0Ak+CfgX6OkGZIktZCigWFs7O+73Njk4eZHHsb19LN0tTpxO6NJycjhqFOP5ZgrJ6I055MsmTefK++5Z48dliRJvPzSc0QlxBPYUU7g/XlYFi9D2rgMGivxj1iO+cbrkXLbYB7YFcVs5tzzz+K9L2fs8ZyyMeTsl2Mw0jY2ebnv8Sd54ImniI2NpVfv3ozs05esjAw+/vTTvV6bLnQQhsZJAPZL00PTNV798EM6tm3LoAEDKPpxESsKy+g+YjAjTzHKK9VIhP9MupiS8uI93o89QZZkLIAswGIyIYSRg7C/2/+/QpIwOe2cMuEczGYzF6RncsFvVtf6G4m1RzGw7xBmvz+Dy+67nWlT30GNaHst3dwXijE8JTa7jez0RPr3aM+giVcCIBpqYNsWIIho1QE5NoVL7noExRPi1S9nsV7V0PYSztJ0QV1DE/fdcztPvTwVe2IajJ4Ao431kQ1r0Px+TMAvn09nR3k1wVAYkyITF+3ixOOO4vTLb2jJpbFntMNOO2LzhiIpxndyfWMjGwu24QuEjrhRAtCvp6GmXLdsA9Krr0FNMcIVjTxnKlSXAJLB9TNkDKm334piM1hMS4pLWPHzr/z03Vze/HgaHn8TYTWy1/fxtTlz8I8cxh1THqV9z95knHEeniW/UFVdQlLhdiJmM+7zzyY3PoNQKMjd77+D2uTfZ5IrQuDRdEKNXk5PMTwsW2tL2NSvG6rFRP9Pv8VR30BUWRXJtUaSZVN9g1Fm/AceGF0X+AJBCneUMmz0KI4fNYrt1VWUlJQQDIURSMQgUb9hw582kITCEZ57cyojTjyJ6E7doVN3qrauwZychbnZYPrwjaf44emnKaj3UhPZz3ypA0RtZRXHd+tK+9496TXhTE4ZPoa47FyOf+Cl3dpJusC3rYTNwdBfTUHhL4tDEuT7K2OnaNEfQVFkrGYTDrsVu81Cuq7TqAsqwiqBYIhwRN3vl1qSJFxI5CgmihQTkqwgKTKarhEIBfepeZOUmERllcFau3nyfaTNno4cCIHVikjIQPY1osWng92BmHA0UeeexNcff8aEiy6g3tvwu1lPCkb883DpxRwMJCQ6I8hHZoHFilcxcePky0lJS+XhZ59ja0HBfnlITLKCzWLDZXPitrlwWI0ZSiAcJOhtoCboI6RF/t/yUvYHkkkhq3snti9eiS4ES8s308aZQH19LbXbtvBOsglXfDz/sWaSHJtMOBym7dD+FK9Yi36QjLatZImo+Bj6jezFNRMvoP3IMxFqGOmjKbByM5RVIm67DanjrvDju48+xMV33E1gH8dUZBmH3Up++1weuvNuunbuSsTTSExuWyyuqJZ2o4YO5MefF6NqGi6HjZ5d2vLpZ18Tm5CC2LAU6dUXoe9QGHcMRMe1bNdYup2LL57AgiXrqaptPCKDyk7Ikswx447is1lfEPb6qTvmQlyaQE7KQaz+HnnrcnSbC9r2QL7pauxnHcvWZas48/yLWLNxDaquGRMYxH4l6CbLEu44N9e/+CIXn3Im9fW11If9xJttuFxulGba9runPMAHDz3C5samfaYhJAAxskx9bhY1mwsBmPr4razNiSVzezmdflpJQ5Sd9JgUej30NGani3dfe4Xzrpx8wO/Vb7Nb/j8HDbPZxIaVK8ntmP+7dWtnfcGZl06kpNGH1xfYZ66YhNQ8GTXE/AQc0ATHgjF+ZNhtZHRoxxtvvkNOx3yavE2gaURFx3D7VZN54IUX9inMd7CCfA9/e+CCfDeP+R8T5Pu7oYMEKVYz9WmJpKYnMqBvP3JUjVXLlrAirFJaWUdlbSNNXv8fJkKC4V1pQrBGDSOpEWIRJGAkf/2R4662tpa1K1bRqXtXrK1SUWUrFlMYKeCHxlp0ZKitwDS4F+axRqne6tVr0fZi6OxMDvv/hECwGliDDpEgUgRuf3TKfldXOICQrBBrdZAcn0ZOYibpcanEOWMAgV5XiVSykbW+Rhb6G/EEvAenwvwnQFIUMnNbA9AQ8rNi6rN4lm3B7PdT0qk9CX27kb5hNl8qEideeTtx0fF06t6FkrUbDInag0AikGhRSE9JILfPWOM8fpwFi1fDmgKIsiE98wI80AbNbEVxx3H2Dbcwc/4PTP/6270+J03XifcFiF6xjhcmnM225HgUl4O27drzzPOvE5uQyKI5c9iw8BdaazrFgMVs5j9X30BsQgp6UwPynI/g+59g5ix46xXo2xts0XDT3bhTM+lut6MJ+EwIjqQfTAjB/PnzqS2vJD41GfWYcQQ212H3N0Fud0RtKaS2IdSxPzijsAPLVq2loLCAiKYesJeuUhdUNfmZ8uBDXHDcycTGxhNL/G5tnnnpWT56+BGKG5toJaBwH/uLBWJ0napGb8uy86+5n7K6Shq71iCdYae9bCEj1UhPX7duDTc//DD6AYYSOmEYIgelw3OYEYmodO7Vi142OyeecjKRzAwa/X70ujp+/eortlTWEtmHIKQJ6CybaDSZ8VjtmGTFkBFRIwQjISJaeL+0ycIAmo7F66di5RpOGzyIfgMG8tayJdjqG8ixO1hc33A4L313/FsS/M+CyaTQyWahTUo8gf6dufCcSXQabWSvt5v9Fjm//sSaTTtYuaGQTYVlNPkCe3Vp7wkCgYwxu9ifmyyEzvsffMiD3bviHjOYyjlLSDTbsP78BXLIB55azNdcheWOGwHwlFfy2czPCGsHoqHz/wMBLTOR/UUSRglge9mEPSqelJxOtG3VlZzETGLdMcS2isPSWMa6r76lqaGG4vICtlXtwBv0Hbn7ITWX8DZPGYUQ+1/CK0tkZGQA4PU10hgfg72xkeRtJURkhYTScpw1HgJOM7WNtcRFx9M+I5Ovf1MyfKDYqMj47Tau7TMMc1QcoqkB6eUXYdk6ECqkpkBkB9x/DdrA0SinXEQo4GfjtoI/3HcDYNUFAW8QguWst1jYsLWENWuHct3Fl/DQs8+ia3rL+5+UlMixJ58JQPibj7DFOqBLLqwtgNbJsOgnSE9GBLxIdhcdcnIpnrcYkyShHkFnrkAQioT55K13uOTm64mfcBSFD04jqWQL1sZywv2ORdd16tzxxGYanEAJkkYwEkQcZNjQHIpgXrWWk8aMolWP7pQ1NVJdX09DfT2N1bWUFBai+4O0Fruzwe4JLblVNXXMnz2L4eOPQpJl0hNSSU9I/V37gWNG46mqOeCQ4GEthz8MCASCLAsEWfrqa4SavR2Gt4p99jWKJBNttpFsc5AanYgak4TDYkfVVRr9TVQ2VlPtqcUb8hPR9i+fax1AREWua2DNl18RlCQ8QlAVPHyaXf9L+J80SmRZwmm3IrVOJ65vPqdccAnZ/ca1rO85+nRS42VyszcTHeXAHwhRWFKFL7CfcuTNqGn+7Q90IZj23rvc9+B9xHZqR/3tl+F99nW8/cbjEiGc5x6L5bTjAVgyYw633/cAm4u2ElH/3mJne0MVkCybqIqKY3h6Hp06DKRbl+5k984lqkM8stuoJMg59zjiPv0B75tTaQw0EYqECO9nZ7LfUGRkmwXFYUdx2JAtJhLDEeL8YTaEQoRCYURY3bdxIgSp8caM2OtpIKmkEo/LSZvqOpLcZQSaomlMjscbH018sxhYtcdjWHS/r9z8Q6QAigBVF8Q4m8OYJUWwoQDUMMS4YUAnyEiEjeWYxxsijy89/xTFpaV/uP8G4HOgDVCi6gS1ICCxev0Gzr366pZ2FRhhTUd9PQ3lpcSlZ2LK6AAvfwlbdkBhORRWQNtM6BYPzXklZWYTS+w2VI8fjnBdh6qr3Pv445x+7lnEpKWRe88EFFlGtlnxLl1HZO0G0k8ejz0xDjUUYvabUwmr4YM2fWMwcg1W/vAjXy1cZJTm7gwh/Iar5o9Nw99A1xlxzDHYXE6y8lqT1749+bm5RhiwXXsuv2AiP0z7mMbK6n2GEvaGP4s76EDQQkMm9m9iIEsyTpuTjMRM4jLa0TalNe11jYTsLKS2uchRFhBe3vloGl8tnEett2GfIff/hk6zvs4/MyPiT8P/pFFiUhTaO6y0bZfNUaedtssgWTgHOnVFjk4io9N4kpK6kJrSnu3ltdQ2NBEMRVD3lQl/iHCVlfDcf67hiqeeoPXAbjDwWSIeL5LZhMlu6FDMfPkjHn/yCbZWbMcT9P6l8ygOBZIkscNqZ1y3Xpx2xWTadc7H1SbViP8CosEDZjOWaAdDLxxPdLyVjdcXUNtUR0Tbc2XBvo4l79QYwjAQd+YISCYFJcqBLSMZW3YqrowU4pMTaa1KKKWVlBUU0LijgnBVPXpo78mDQtNJw6jW6NiqI8nDTiYw4z9UZaaydnh/qltl4o+LwdZQA83GS2l5OUJVD8rtGguYdJ2GQJC5Py+g+zGnInXoimjdGqloG2SmQESFRj/6sDHIThfVhVt5/bVXiBwAR4ql+Vhlhjvsd+vjgFQhkLw+HrjrVqY8/xqmfkNgzTJY9SKkxIHbAfExiBFjkSxWwo31/LBmFeFgmPaaxno4oiEcXQiq6qq5/YabeebtqVh/UzXnHtQDBvUAoLa8gqsvu4IPF/yAdgjeuCp+w+dxOBN5dUHQ42XzijVsXrWWjYBF13lGUfh0yuMUFhUdlEHyT4CEhNVsISU6kV6tujC4fT86ZLel/fBc3P3a7tZ2wCnHMPmCy/nwi2k0BX1/OpnffkNIxu9A2v8N8D9nlEiSQZWdabfRNTOD9oNPMlZ8NQ20IrjjPXj8FXAkYMlJoGtOV17rMZKjjz+Kusa1R9QoqQEeeeF5vli3jteeforMjh0wu10AbNu4lZceeY5v582hrL6SxkATkQOw4v9ukJCwmCzced9tdBzYt2W59tOvqM8/j1qpI0kCZeJ5WM8cQ7fjRzD4s8FsmbZt56Rzv45hNpmwma1YTVZMigmBIKJG0EMBUoVKidvJU1Me4ejjjscZHYuzORFxJ9Zt38wdzzzO7OlfEK6sMwyTPRxb6DqPTn2Drj17MnLkWOJHjUP76Rf8TzzI4lHd6LhgMZW5ycSur8YqG96C+rJKg0TtIGCw6wosviBzflzIlb4m7FHRqDFuzKUWcNlh9Va0pDjEBbcgA9O/mE5NvYeIuv9Drpl9dyINGLktdeEIn835jv7T3uaUsyehjTwK5dMPDeMoLgqR0waGGp7A7+d+TlFpNeFg0Ki24sgaJWDwDb30wXus2riBgX36sWlbERbFzOljR9CmY3s++2oWT735Jo1NHtRDDA8aRrDcLLbZbAQLfb8q2/YLQoAmWpxsrVWNgo0bKTo8e/9bQpZlnBYHY612+tjddMhoR4dR7XH0zgFA37AFtdaLnpKILS+Dp19/lhX9VrJiw2pU8c+c+P1V8T9nlICEosjUxkbh7tweaecgs3I++P2waDGcPwFGj0KMGI2U1Zqo5BRysrNYtnr9wXjS9xslAAgqFnxP2549cTlcdO/aDbfDwfKffyExEmKHGsGjq/uViHVI2Mk8ajEjNfMxCE1HRFSDeO0Iz7gkSUKWZbwBIy4b/Hkt4vHn0X/8FjkcRnLFIjVWE2moI9K6Fa6+bbjujmt585N3WrLp9wVFVrBbbCS5E8iKTyPJnYDbGUVmXg4piVHM+/RTagJ1PD/1VYYNH7HbtrquEwr6sVrt5Oe05ZW7Hya/YBONS9cTrqrbsyGh69SUlHP8FZfQ/4TxPHvDnXRMTKftfY9y8R03UPzrz9S1bc25dzyNw2EYoo2HYJTszAGIBIJsLixDMhkcFaHzL0PExUBNNeFvvqLSIZObnoOmqnz2yms0eHxoB2B4r/yD9ToG74WsC4K1jRQUGaGh+vo6Gvp0Iik2G1teRyzHngJA3Y5CHn/qaQpLqqgNq3+YIL5X7Mz/USSg+X3QdcQ+coA0ofPT8qUsWrG8hZ5/zjefkyoEG4V2yIaRLBmGtsvqwGF1YDNbEQiCkRC+kJ9AKEhQDZEqBHU0hwIOATsTZDsB/8wg7/5DlmRcdicdTFba2Kxkd8/DlmcoXIdvfwjttTfQUrKJZLfF8skz2FxOcnNas2bz+n+sN/qviv9Bo8RIhgpJEq17DjUW7dgM3y6EijpolQneCmgogQQjsW3Tj9+xZs2qA07WPOgzFIKIptLQ1Mj3CxcAkCF0fBiicPVH+PgtNOgxLiyJsShRTnp27MRZfQYze95cPps9G80bQA+Hj5iFtlOXpWzbdmAwIhJELPoeUnLQdZCCTeghGyIxi4a3v8LV92pSWmURExdDnbdhn/uWJQm72cYoRzRjuvei99ijSB/cn4SOrTE7DCP1qDNOwifptMtvTzgSZs1Lj+Nbs5aqaCfl6UlYPR7iJAtHXX8PCe5YjjrhOD4pKifS0LRnQ0KAHgzTprgC+b0ZnLBhI6/dfh9D+g4hdchofl44j/H9j2kxSADqqqoPPT4d0UioqsViNa7LNXRkyyrL8HHsPNrquXNYvnkbKRFtn9UeBwtdF/iDIVLdRumvIzsP0zk34G7TvqWNGgjw6HVXUbm2gHqvfzfjSPqvetR93ZWd76/itKE47UiKglBVtEAYzetDD4b3aezpQkdvNrpDHJ7vTZFlUk1W8h1RdB8xjhGnnEi7jm2pqmmgeEsBX3z+FQuW/UJFYzXRIT9ODh9B4NrDtJ+/M2RJwmqyUD9gON2fuRtLjPHmi4iK/v0P6LIJpaEWaVCqIaIaDhNZu4GDTzM/8viX0fUfBF3XiY1NoHXH3gCI919F2l5uzP7VMDSG4ZyrkBwugtUlzHzuUaRA8IjyJewJv+U++NMSzRQZJcqJLSOJlG4dOeeMMzm99xDaJaYBMOGMCbQ6YTR1G7YSrqxD7EVp9FAhEITVMF/P/pbjJ07APqQXwauvQl28CXnHNqRNP4NiQSrZSDjkJ+TxYnW7iIuPp6Bo38NqZmo6Lzz8CP1HjyI2JWn346oakkkho1nHxBcMcv+G74mVvXSvr0c1SXRYsBhTKEJjWjKrijfTv213zu89hM/iP0QuMqMHgnu+J7qOJahjq65lx7L13PXC88zvO4TY0WPoZTXTNSsXgM9efIGSrQXU19QehvsIEVXnh08/IbtzF376eSHFhVvo26M3o044uaXdk6+/QUxEoxjIYKfX7vBC03ReeestRh57HOk5OTgSEvE3NvDTpx8ze9kSFi/4AXV7KZsCQSK6jhBGUrpJUbCYTSiK3LKfcETdo5CgZDFhjnVjTUvElplCbE4643sP5OhWHVi7bSuPv/wSVVsKURu9f5ycfJggAZ1y2/DCE0/QuU8fopISWtZlAb1GDuCY807llouu59dvZhKORFij/6/7Ng4vWuk6mWqYlLSkFoMk8uVcIk++iLRqBbKiINJaYzra8Ir6txcTiERI3Y8KqH9xePE/Z5QIYTCcNvlChitXhnDHbpgyvkGxW6GmDiIC4fUixSey+pc5lG4vwdHoO6L5JH8JyBKK3Yq9VRqpQ3ox747HSY/bfdBWzCZOi3GwOiuVheGIIat+BOiThRCE1DDfLfqJnz6dxeBTj8F242XodQ0Env8IvbwQoYYICIkmby3W5tybHSXF+0xylZC4YeJEjjrnLAD0iIq6oRCxfB3a1ip0KQHb0a0w9TNYPgs3bcZcsoMto4dS1649nWb/gLO2Dr87mpK22RR6yuhPd3q17UQ/XacA2LyP69oGlER0wjUN/Dj9S17r/yITL72MrkMMscOrL72EGS+/gncf+zgQqMBq4NzTTicCNFhMWMwmZFnmyosWMPHCiUybOpV3P/kEAbQ7TMfdGxYuW07/du246KKLyG7fjgeefgp/RTmxumCrrqOqBkuv1Kxk7HbZiYtxER8Thdtmwazr2D0BCrx+PA0einy7DBjJpGCOcdN2xACOP/VUxvUZQN+UHMzNiryjBw5n0slncto1l7P4i1k0VDeg/QmMsYpi4s03p9JtQH8A9GAI35ZqxJI1yFF2zL07YM1J5o4n7uaBY9azbEsIzdcIh7uK7H8Yiq6hhoL8+OsyzguFUawW9C8+R6xdAdEJYHeiJ6ajmAyX3PJlm6gRKqV/j9zQfxT+54wSMIyS5WvW8tgj93HTbfdgOeZMGjauxbpuFVJtPcIE5upKzNmtcDhTWVBVz5ZA6Mjncfw/QzKZMMdF4+7VkVuvvJr0uCT8ngYKpn+AZ8tGBj7wNCaTmdxTjmf1mpXYVBU9GEZt8v2xaNhBIKxGCDRW88z1N9JUXs3Q047FmZKA845L8PRqT+mUl9gWCtEQbaZb8zZtJLFP0jhJklhTZPgB/KWVNF71EO4d25C2LYeczkjHXY76+bctRkmnrl1oqNjK2q8WELSYMKsquiSTUFqBOaKT+dJU/I8PwBkdS5sefVm9et9O9xZ9kIiKFlGZdPkVVJdXcN2tt/LCY4/x9MuvHMot2ytiMLwmlWGVUNgwIh946hkeeOqZ3doVYVTMHEm4wmE+ePHFFo2Vdhi5Jzs54nYaJCmJseTnZdCpbTa52cnkBENI/hCN/iDlOyr4obyW5OJKlnp8hFQNxWnn5Xvv4fxLrtzteJ7qCgJfz8I5Zhyu5DQmnHEanmVL8PiCrPH6j8i7uxMSEoN696XbgP5okQgbXv6WxLImHJ56JLsLGmqIFAQwnd+L6JREzn3gHn649EpskSCRoPrXrfz4m2GjLFGlhjlhUFcUqwWttp7wgp9RbA5EUmvQI2jhIJKmYQXK6msoDvgPqCQYdlIY7bRk/uoMUn9N/E8aJUIIgsEITz71DCN69qH3uKOJuvRm6l5+GunEc3B174s522DfTMztwPbaRkJ/gmLp/yskCdlswpwQQ68BfTm7VTcAKm++AdPc77B07tDSdPKpV3DesX6eSXuJ++9/GM0XQByBZDBd6KihAKVVO3hyykO8+eEMLr76UkaeMg73+KGEGyoxFZeQNmmXikxebi4/Vlbu4zIlVixdAYA9NZFw5TaEpxpJMiP8AaQdG9CWz0M7bhRKv54A9B91HOUhD0nPv4ISUpGERGNSPD1nfoMpEKB06c+0GXkUPQcM5vnX3jpAlkXBrffey90PP0z4ECXW94VtNDNQ/gGCQNlhOJ6EkahskhVkSSZX14jWVH6RZSp0bbfEyy3sbggpskJ0lIP8vExGD+pK365tadd9ANHJnRHhIFXrv6KguAzl21/50mYhZksx1kYfiVYzp004H4CK+koK1i5lTX0VUXPnk7F2KzarTN/Tzmdkz/7EP/QYW5et5Ko770boR66KTZIk2rU1QoH+NRuI+/orXJKCVF2MaNUZYpIR8z4hvHIm9g9fptPYwQwaMoTCGaV48f87rIExxu9MKmomRztQ6LogPeTn1AlGyLLgzWnEeBqR4tKxVBejW00EhYbDYVS++eoraQp60fZbl0tCkU2YFRNKM+GhputEtAiarh2+yqrf4l9G138WVE2jvtHL+VdNZuZHKbTp3pOkG+5sWa9FIvw8dw4PPfQQXn/wgNhcd7eW/yb2smTE41NtFu7rOxZFVti+agkrfHVkJcZiKixi04tPEdunP678zrhtDi457VweeuIpUOTDy7fwG1ShUxcO4airwB3wsu7aazh14Q/c/fQjJJx5Gjuj85s3b+bxBx9k6qJFf7zPqipqikpIyM5AjDseVm1BWjkPSVbRNy1DstgIPfUG9ve6ISkKimLi6DGnsf7TLwlu305Rpzak7CjHGvBTFx9FaVUpbYABbTogwgfncj+SBgn8hmjqT4AiK1hNFlw2J1E2JxaThczoKAIV5cSqIXxBPyE11DK46OxOMmi1mEhJiGXowJ6ceMwxZHQehOyIbVmf0nkszoTFIMkUWSyUN/ioC0VIbt8Oh8uFLgTL/3MxQauN9jvKsPn8+GOi2b5uBV39p5Lijmfc6KPRRozjmvvuRz3C6q21DY0AWJwOLJUlSJKG8PuQtixDkmSo2oFusbe0v27SWcyZ+QF1kvS3GUgON2QMYr4yk4LfZkEym41Sf01HD0UMlWNd2+/7IxCUaBE8Xi+pgD/kYUGrLmRZ7GSoQaxx0einnkzKoD4AvPPZTIKR/SPLVGQFh8WG2x5Fa6uTXj260SgpLFm9hnpfA56Al0A4gKodajH5/wb+Z40SgHBEZVNBET0GDeahu+7k2BNOYu36tXw5exZfzZqFKK8kTtP3+0VSJBmTYsJisrTEsVVdI6JGCO+nnsL/J1xCkJuaRn67zgDMX7mAbSeOxvrJbHKXrKHp3beonfYB/taZjHrtExLjEnC6XASR9v9j28le2eLhFH84+1F1FW/Qiz8coNpTy3NvvcbkW64hPiWFxT/8wNPPPceH06ej78f9FUInFAmxcvkaRmVnQI98pLnfI9zxSDUlyOXbEa4YAj1H07SilOReWaihEA6bg7aPPM1n999IXXo8fl2jKCmaaf068dSgUQD8sHAhevjQBzhZMjwMJsWECdAkCV3Xiegqmqb9pY1cs2LGbXeRFptCXnIOPbp058QLTiZ/UA9KNxbw4B0P88MvP1JSW4Y35P+dVpEsSWSlpzJj2me06tRl14qADzauge79kKIziLLG0EmJZkd5DRsLSyluaKL3UUcDoPm81Ma7Ud3RZKzbgs0XJBgdRSQY4qcZbzFqwuUALFqx9IjznwBUV1cDoMTHojRUQVQ0st0NAQ9CSKDpyG12ZfP4dxQ3a239dZ/zkUa8LJFnt+FIimF7dhrmuGhQZDRvgHBlLeGKGrLqPBQEw/v9DGuAl995myd69aTbrdeTdk4JG79fiLlVNq0G9EFu9nDMmT6Dn5cv2a/QjUlWiHa4yU3Opk1ya/q6o7l8+osoVitLZv3Iy0+8RHDTMsrrK1kY8hNS/6We/yP8840SCZBlJAxthBZK4ubvXdN1vP4AV910C/+5+dYWSm9dCDKad7E/5E1mxYTL5iTWGUOcKwa3zUVSJIQtLppllWWUVpfjDfkMttG/YhxIgFfAMb0HIksyWxsrWNw5hy5fLyJtYwHxJWUISSKYmoDfvuu1aZ2WSc26rX+8f8kQpZNtVmSrGclkAgR6KIIeCqOHI/vkPtGFQNcM3opQYx353bphs9koKjowSihdCPyhAAt/WMCoE8fjHtwZz1uxWLcuQ5ctyHoETdOIFK1n7axY4vJPxtzMputOSaf32ZeyfMMyrL+so8Tv5ebTJ9EmsxWNDfXcfO+9B6wp8t8wyQpOq4NoRxT5Jisxzd6A2kgYT6CJBr+HsHpwBq4FQ1X2cIRn9gRJknDZHOQkZjK8x2DOv+IiOg7pgqQYPDfp7XN55v0XmfHGx9zz4H0UVRXjCwV2F7WTJFpnZ7cYJKKuGunrz+GLT8HbAH36waTrkFLSiWkzkpPObM+4MyWmf/A+W1UjKyWiyJh1QfymIpK3l6KaJOrTkomYTDT+sojgcROwRUXzwkfvHaE7sQsCQcG2baihMKaEeAKjxiJV+jCXFEBUHLLPg2jfC+2081u2ufGeR6ncT9XhfyIkk4I1NpptWUnEtcshqV9ncnJbc01GF36o2M6HC+YR++saGjbvoF15NZURjWT2TxH9hZdfpk9+PseedRZJmRkknXN6y7qFPy3k/ffeY+qbb+6X7o0syTisdrLi0+nfphdDevSnU34blOby+95HDaZ91/Z8dM+TfDt3Nu6aYuq89Ydvcvpv+ObvCSXKiWKzIpkVhC4QoQhaKIQIRXbjKjAm67sTIJSwf6WRJsVEtMNNp4Q0usWm4cxsT2JUPJ2z3Ay76wrqyiq48OyL2bhmKZK3gc3ir8jEKtAjKouKirgcSHfFk9zQQOcffkFGUJ6ThS0cwdu1I33ufKhlK6sk/zGRmiwjW82YYqKwpSdhToxBcdgRuo49rFFbWEy4sg7V49vvSp7KPeSNtAOsGNUm+0IgEuStD99nwnlnkde9M467ryL0oIYIaejtOqJYVRwd2zLsmLGYLEaMWdd1ZFmmfb/BtO83GP28q/CWleLOyERVVa669FJqKqv+4Mj7hlkx0dNio5czjkBaLu0cLmxWJ/npWVjjnSz4+Sc2FG+msrEGf9h/wJ1ba45sv2SWTWSnZHLHHXdyzBnHolgNwjb1h58JfL0Y8xnHYOuayymXnEVCrJNzL7ucUCRM+DfvjwSsXr+OHRvWktWhE/qnH6C88TL07ghFxfD8VHjpHZjyCEy4EFtKOjZg4jXX8/133wDgsDsZfPokqp54FE+si5iqWuy+JmIDIfLvehhbVDQ1DXXM/u7bI04CKISguq6Gr7/6hmNOOpbkJ2+l4Y3ZmN7dBkKgC4HqqUcXgZZtBh4zim+eW/fPzmHbG2QJxWnH2y6L5F4dkccP5tY+IznD3QqLbGJslwEM7dGfuz5+g6M/m8+isIqrug6rpmPjjwnnQqEQZ15yCbb//Iejxo/n1BEj2L5jB69+8imF2wv32xBMi4lh6iOPEDRZCasm+nXoSPqArkjKLmYTvaaOqPRELnz+XrjVzfoP3yTg8+D9U/xzf1/8440SV34u1tR4FKcDoWlE6j1kml20S0gly2zlmbfeJhQ8eO5EWZJJNFkZ44xhoCuJ+NyupHQZQPujuhPbLQtJlkjIyeTdaW/x1KQrmDvvWwoCTYeknXFEIAwioU8++4xbrrue/Nx2jDSnsLFvPhHFjCOs0rNbf4YfdQpWpwtvk4e3p77GrwsXGSJie4NklBlbUhOI79KWo089ia4d8umUnEmH6EQS7FF8/fMPnHvr9TSsL0CtbzroEmMf+5fMGdFUqhqquXDipcyeOwtnhzys7zy/x7Zrf1nMKw8/xOvz5zJoyBBOGj2KkSNGkteps2GQRCKcdcF5TP/qCxSnDaELsiIRzKrGlgN4xIqsEGVzER+bSpeEdHLy8sk7fhzujCRi+ndCsVq4oLCUR+6cwhfzZlFaV/57L8MesDMBT5EVaoQgVdfJ0zUkBFs59HynFHaJ7lnMFt5+81U6D+oHgLp2E5EXPkD/ZQlyQgra+kKajh5G1MUnMOTkY+n50mt89/P83bSKBAJV01ixZjlZHTohEpIMjZ6wCmgQjoAUgfdfRevRE6VD15ZzGTZqLNsLtpCT24b0AUNxp2Uw/f0XyFy1kQ69BtLpzLNxJGTgD4e45tlHCNY2HDRj7oFA1SK8+OKLHHPSsSg2K/GXn0C5FkHM/g5bXTlayINWvAEYD8Da4qJmwb+/WB/xJ0AymzDHuWk3tB+XTziHk3O74/xNvg3A2IRWjL38PrgcZk2fxnHnn88Ob+CAEmCDwSDTZ8xg+owZB3WeI0eMYMzFF/9uub5pCzgcaIuWoj7zBuZH78A0oBdjTxrH3M8+RVHMNGiRw8Y79U+sWP7HGyUpZ43D0TaLlLgEjk5ozfGxrciI3kVe5HC6uOfJJw+aRMlsMpPviqZjQgY5nQeRf9zRpBzbDdnRPEvcXIKUnoA7NYmbPnyTJX2GY922Fn8o8Ad7/vMhVBVzbQOz3nyT/PsewpyYTs1Rx9DTpyI1eOh08vkA7NhRyO2XTcTz/SLC4cg+751sMWNJTSBuQBe+e/A52qXn/K7NuP5D+fS1tzjzioupWrqOSIPnoGaw+0v4JYQgEA6yZM0ybhk9njOuu5buY0chTCZqdpSwo6iY8oKtfPjVl8z99htCQiMIfPvlVxR9+RVPAp7MDI4eOZJtVeUsLt1OVM8OyCYTejhCdFk1Ur0HORhGD+5dpO+3sJttdHMnkJvXg0EXnEfbkwaiuBy7tYlvlc7DU5+g7/OdueGBewmrlXuNURu6PmZcVgdxrhiGA8W2KNzoxHjq+FmNkB3ysSMS+kPDZm9og2EIJgB1SNjMVtp2zQegbvpCTFM/xFSyGSnkR2ytRIpORJ4ZRB3TC1NOBueecAw/LlmIX/K3vEJCF/gDIUq2bTeuY9Aw9KNGIZftgIgGqQlwwUWIU09HyW6L0HXemfoy5150Gau//57+l13AiPNO5+0rbyU2J5chE6/GBKQmZQLQ0FjH6c89xKJPP0Ot9xyRqrH/hqbrfPf9d0weNY4zJ13MgNNPIv7Co1m54FtCAtrdcR0p55wBQPn2Ij7+8rP/TWpzSSI2KZGPX53K8BGjkCXD69BYUcrW996k9sfvaTzlRIaddDaJDjcAoSgHisuB7g8hDoJHKh+o5jcCifuJX1evafl39ay5uHQZ6ePPET9+j57dCbmhAnasR33lTUwDehGTkYoUm4KzbCsF4QB/m1jK/wP+8UbJ9GMnEZ+STKLFhdxcVqaGQzT5vMTGxpM/eCDSM08f9IzJYjKTYXGQFJdK1vBRpJ1uZG/rmwoI3fcUepUfPSsHxxPXYnU7OeXii1h0+80Ew8EjUyZ2KBAQH4qwYcUqAHq36Uw/pRtASxLpy9Pe4ZYnHyN9yw6CofAfeklkuxV7dipTLruaduk5BMNBVjSWY/n+R7xbNlHfuS1HjT+Twbkd+frJFxly+ik0+vzo2pFNCNOFIBQJ89KKJfx8ztlss1gxmSy0j4QICJ11uk5YDf9OjKsIcAENjQ188OsCHG2zyBrZizaSCV+si+IoB41FFQS2FGPbWEiwtAo9ENq34SZJOKw22rjjufHeq0kf3Ms4x+IKtIVL0TaWEl67DvtVZ2Me0oeT/zORl956h5qm+uYZ9e+Rp5hIsbtRU7LpH51Ee9nMcJuNorg0ArWlHF9agLe2hO+EYL0aPijDpAjIxMhRUSRITkrGGhWF0DTEcy8jhwJIJRvQhYJsMiPy+yGPH4YpJwMtEuGHH5eiyAr8RlFKAKFQhHenTeOcSZfjTkxBv+4+wtdegikYgQsvRb7u5pYZ4qy3X+aT22/n/UmXs1RRCDvt/PDJ51yow8c33k+rZmPE7/cye/5s7ps9g22LlhMqrkQPHDmZhP9GRFX5eP53LFi8hHey0unSvy89332OgqlvE3OyIUT41ONP8vTzzxFUwyDLh5yf9LeDBI/ccy8jR44BYENdCdt+/hHlrXdJ31iAKzaKlCnPsHr2N4x87zMA3l31C0mKTD0C3wEeTsYI99r/qOEeUFBQQFlpGWnpaXjen0ZYJBKzeQv0HAXJrWD+h2CyQ7OhpOsgmy0Umi0EZRn+F43O/cQ/3ijJiE3CbY0CYEdVKYEP3qH0x7mU/+dKJgw+np4d85EsZsPKPsAOqjVgkRT0qBhMSVnEZxmS89rGQkInnQN1lUjhEHJJaxpn9CPuvNGMO2YMN99zp1EK+BdUnywCPvl+ATesWkWHrl1RIxGEEJgtFioqKrjp1tvxVdexzh9E/IE3IwmB3WbmynPO56x+RoXKN0vns335L+R/u4jYkjLk+dFMDwU4/phz6dShMy8++gRnn34GevAgjBKpeXA7gDLBiKayDA1JiyBJsEHXaQQiOxOj/wtBCcJ2G47sFKL7diJmUDfcnfIYqkczLqsTbROzUGSZiBrhtRkfcN3NtxIqqzE8Jns9bRm7xca5119B+uBeCFUjPHsl2tvTYO1CRFQcpsZaWNsZhvShYuN2FFXCajLj3YP4oFkxkeiIoWNSJgkdB9ItsyOtZVBScmhvUWgMNqGqVdSsWMTPvyzA2ViNL+Q/YCM5zC4KbiEgp1V2yx+WowYhvTcDwiqypwLRoR8iOhnr8B4ALJ3+Axs2bWk2hnY/blhVWb+5gLPOPJFXp75HanoWyrNvEnrpOZQxY7EA9cWFfHr5RCp/WUrAG2SzgFpVA6+fwNZivn7tHfouX8t5x59A+7RM7nz/dTZt2ESovJpInQfdHzyomfXBQiCo0jVqfY0cdcKJvP3Ga4w4+ijaXjoJgNItm3n+hScQClgzk9H8QbQmP9n+ICVC7FdY8u+Ojm3bMfGCiwDwN3kI1laTZXcTs6GQkKcJYTYRW1qOKeDDW1WOKymVnvHJFOo6DknaJ5PynqADyw/yXAVGYuypp59KYOw45G9WIWxO5KoSRGImREWjO9zI8ckAWCwyITXcrOd0uNSgD3BXf7E58N7wjzdK5nzxPgmVtTRWlyOqq3GVlhPMy2V8T4PWu2DzRmSbxRg0DrBTjgMsCKpsUQRjkloS+0RJOcKdily+Az0cgMYarHYjT0Ixm5GPqNbwoaPJ56Njt270ys8nJhTE3bEjUx5+mPvuupvGwhIjHLEf9ypBlrEqCt2aiejWNVbwg+6hc1U9ceUVRHma2DB6AFv0EPrMqZx+6qWcPvZolpx/AY8/8+z+3SJFRjIpxk+WQRfGTF3V9tvQbNEYEoYrd+fSPUFSFExuJ878XGKH9aLrsEE8FN+dTJt7t3Zmk5nLTj2XSEUN1993P3pk79VFEtC1c2cGTDwHAP+z78LHM6BDX2RvA1LVDkRMPPLQIQBs/3UDqbpGCrAndRyb2YqenEVcxwEcP2oMPSeNQbaa99DyEuTHXuD6hx4gGAmjHwKtuUCwZt1admzYTFaHtkRdfzHakJ4Ejz0ZpDiwu6BoLXK2oaH064Jfia2rwBUOUvtft1rXBT5/iJ9+Wc4Jx4znzdffokOPXtivvamlzcoVy5m3aCnuxibWaYLynSs0HdXjQ/MHKS2fw8Nz5hMlZGrRyVRVGsMqxfv5/h4JaLpGaVU5o447lovOOZuxY8dQ52lgRUkBWf06ke0LsCrahVZVT/TmIgprG8jxBth8hBNy/wpw2+2EQyEsViuOKDfdo7pDm+5Un/IrwalT8TrtxNis1GWkkRYwmHeUUJg6XcfzJz9PIQQLFvzAqaefStaoAfh2lBOsr8AhyUjb1iBKC5AsdgKlTViafNhTExnauz0/r5j31/OQ/8XwjzdKGhf9RMKOUho7dURKjMdZV8fA088nxuFmu6eOS997pblk8cANhWVAjCTRNRJEMwuiehuuYn3tJuTaUoTFhGxLQI+y4zjB8BR8+e6nqPrhYYeVZYM1U5aMWb3QBZp++EoJl65bZ/xjawHTP//igLcvFAKHxYw9OQWA2rnf0KpwI/aGRuxNPsIWC1IEesz6EVtlBWtNMXQ9ZQJjBg42jJJ9QQLJbMbktJHgjgK3HYfJRJUso3n9qA1NqI1egzfkUNzgO9kkJQlJkkgxK3iiXTjbZnFqzwHcmDYIm6QQ9jZR+OuPLC3aSGmMg0EZbRjQZyTjho/k5qefNATg9jKwCPg/9s46TIuybeO/mXk69tnuXdhddlm6u0UJERE7MbBQX7G7wMJOsBW7UAQRFSQE6e5mu/vpmpnvj1lAXunS14/zOEbZmXvuiWfmnuu+4jwZdkY/AOqWr0P8+DP0YT9qSAVRh+J3o1ozEZtoRerlZVVYfG4ccvgvj6woiJgMJlKiE2me2ox2F/U6iEGiISU+kSYmK7WeuiMqgzwYVFWloqqS4UNHcu/td3PpzZeh69oJ0/xf8d9wF2G/iBBhRLBo5dV5eVux1VeiC/gP6JGSFQWXx8eGLTs5Y8hgrrj8ci64+BJ69OwNwOIFi/ne7SOkHKBcX1VRQ2EcIdD5g+iBOLTB7h+RGNhIVPjZ3FnM8lXwxaNPc2PrW/k9bz2fz/mGFLsVpaicqIwm9ItIYObcBbBq7b8+nLN07Rr6tmvLWeecjTSgKxf1HUgrezy+4cNYkmCi1eQv8RsN+Nu2JLKJJl75xYL5lAQ1qoBTCRWVadOm8eQTjxOZFE/Ew2MI1rsJ/LYSdekKdHW7UWWZQJQJRRCQgCZNkokOByk5bZQcEv96o6TDT/OwiyIR5dX4rBZksxlzRy1mP27FTJxu1zH3raLps9R5Gug0sjc6i5FwUQWhP7YhJDQBUUK1WAgajFgbS0un/vQLgdDxZdZLoojRoMNsMmIxGzDodciKij8QxO314w+EkMN/f32PXxRRwwqJZk0sz1FRQ6eZ84jJL0VQoaBDS+LzCghYDZSkxSMmaeJ/awryD92xAIJBjyHGQdvkOKwp8UhJMcTHJHBhzzP4bu0Kfl24EM/WAkJVdcg+/7Hpm0giol6HaDIgGgxECmATBVIcNmJbteThnL5IgkTZji2sf/V55NoqYgCbyYB4jhm6QiFhJKsZQRIP+nuoqkpeQz0AwYYGBKMZufsIDHo9itmMYIlE9fuQa53obFbqAx5WKQqbD0CkJgpawmlidDxDbxuJISEStc6J/9wrUSKSITED5ACWifciWM2kZTVlaI8urJ95KMWgI0NIDlNaW85bb7+Fu7ic6x65BUOL5hg+noSwuxBz/+5724YD9cwN+pEPUR4pKipNAkHKq2p5beJbvDHpbeLi4pB0OoqLiw+r2l2BljcQhhMmcHhCIIpINgvmrBQeu+EmerXW5Az6ZbSlyaimNKhhYmWBlEYW21vKSklrlkXYe+xVgv8TUMG9Ywe/fvgBkasX0tVkpdXAc0nv2I1RHbuxY8DZbHn3Vfo/+iIAO/J3sXP1ei1n628w2EpKS+jYqSt3/ucOrrpuFJExURgu7A8X9gfuBcDa2Hb9qrU8+uJLbDuRkganwzf/m1AFESEYhlCYmLJKSpulUR/0kWCxItR7CNe7GqnBj+0XC4QCxKfG0vksTQG0+qGnCKtWzDYHuvpSVGcNAWHf/KxX6wwKl/zK2mM8nl4nER1pJy0phsy0BFISYnDYLQRDYapqG6jeVkBDUQWbXV4qQydJc+EIoSoKYbeXDYsXkdU0i/iefcn/6nPiSisoymmCMzWRpcP7kbRpM+qmXZwRpXlUNm3afMifQ9DrMcRHE9Exl4gze3FXtzMQUpPoYU8m0hbJ8EEjuL3HFKZN/hznis34C8uRvf4jd9kLglaaGGknJimGnAgb/sRYSqLtxDs9uDPSeHHI5UiihHvndtY+eh+WmlrsDR6q0hNJyS8mvo9WXeV31mueOOHgc3RFVcjbpRHQxfTtRulFw/EWC0QazFiskQgI+NOaIxeU40hPIjZCpaS+gsAB5e0FREHk2luvJL5FGqo/iP/h52HVH4iSDqV5F4SABwwPAZDeqyN3tJ7ES6kzEQThmLxsqWjeilJVod7rZGvZTiZ++ykrt23h5Y9fIyKrCfosLd9k85qNfPjmW3yyaC6OkJ+iQ/QbiebZiADqGxPRY0rLaODwZIYAzqO+klMD0aA9v/b2zenaQUuMzy/JIz0xnaaGfWFARVFQVJXEpGT6nTmQOTN+PrqP7z87SnxAbFJUJLeX5juKefz1V6msraN35+40y2hOdvP2ZL80GYCKijKuv/M2AiVVKIFTl7D8ZyiqSkFxIQ888iBvvvo6oy65jEvPHUpCbjbm6EgkgxbOX7ngD8694EIqa6v552UR/vPwrzdKzC88zx9ROrKef5WA2wvBAN66KoiMJaMuQGZhGeX+AKXHqBQqKwpxifF7//a1ySa8owBfSRkCemqz2pB88Vl7t7fq0A7fMb5BOkkkwm6hVbNUhpzZhz69e5HRLJeImBSMthjKNi3j+/ffYNvKzVQUlVNf3YA/8DfKnysqKR4v0z6ezPBLriCpXWd8j4xDzisgOSwTabdizG6LFJFK275RpLdsg6IoLF++7OB9CiBZTZjTk4jp3o6PrrqTtD+VeIOWz/F6v4sRgzLfNnxA2OlGCYaOmP9E0EnooyKw5jbF2K0VNw8YRs/OffCa9ISCQdIkE5ER0QRcTpa8/TJ1qYmkbt6O12wkfd0WApERuCK0OVJQELR8ksN87KfO+JHfZ/5Mv7OHkn7PDVQsXEHpu9NwWB0IooivrowonYoDkNQwOa56Sg8461KRFRlBr5VTBhavRlmwAMHqgKAfoXgbggreQecTPGMAtrvHYHE4yMnNYenK5Ud0f/4bsWjeiFJAlsM4vW6C4SLqltTjunI0T08Yz/at23n/w49ZumIZTp8bf9CP8zDvQTX7a+IAnMA0wb8Hewze6Ag6duxIq2gtx6bgxWdxl1YidOmM1+HAWFqKZ8VSrA8/StseZ3DphRcyd+YvHLZISmzMsZIkMlExyjKbBUGrLvwfyUuRwwpbaxswrN3CE2XPkxQXRcvzzuODG+7Z2+buG67DO2c+ciB4UlWeDwdFVfCHAhRWlfDyuxN595PJmPRGjbfHbKJnqxzW/DabCt9pyrQjxb/eKEkZNIyrIyLYldGK0ofupTIxkjZRmhFRsHUboXoX8nHolaioLFi2lHA4jE6nI+O+2wFQAgHcy1eRkt0Mc6PR8vsvvzLmyfGHnB0eDIIAJqOB3GZN+eTDz0lp0eav19quNzfck8jPP33J7q+nUhMIUxlqOKyb+2TCFwqzeskyJrw7kYfH3E7mWefst73J3v+A1+vh7rFj2bblEITRoojObsWcmcIFg4eS5oglGAywY8nvmAoKWb9zE50uuIL0dp157azLUCrr+Gx3MaFa55EZJaKIZDVjz0rj6ltv5tYhI8m0x/ylmRIMkvfo/ZSZBfwWK8WtmiEIInXpIcIGA8kZ6QDoXF5kl/ewJeehUJCzzh3BvXfdzbinxpHQpwtGs45NV95EUFWJvvpyEru1B2D3wt+pkgMHHOQUVcEX9PPll1PpOLg/xt6d8FpMEJ8KDdUIHjcoYeTCItS0VCSDNgS0zMo8ZqNkPfs8FyqaVpE3IBMIBZkx71dm9pgNqkpYUZCVMGFFPua8p03HtNc/C4JOQjSbuKZ5R0RBoGT5YhrqatHVViH88hN1MTGkb92OzmJk96qltO1xBuf07a+VCR9sri2AoNMhWc2k2c0YzGb0Bj2mQBCzAOEGd2OOVejUf8T/7CQ8kkOrKoovQKC8hhKnh/KyatbvfJO4rUXcdN0NPPrUeGbPnovpODwkoiggiSI6naQ5lFRtghmW5aMeL5VGPa1QOITb70EQtVKGzqEQ5bs3EQBMnFpRzP9l/OuNkl3FebRp3pqszJZkffXT3vXhUJAF381gZyB03MyJxSXFdOnUiSGDh9Kja1e6d+tKfFoqEX16ArB7127uuftupv/4418EyI4UkigSYTPzzhtvkdKiDWo4DN5qhI3robII3H644FpMTZpx3o0PsLO8nJLKWuqcHgLHqFx7IlCpQpUvwI6HHyXd7SW2SRpVFiNhq4XIkIxTVVE8fqTKGiZMnMjWw4VuRBHJbsWYEsfoLC0Wv3Pat6xf+BtxxWX4stJY9+YLcMPtpHftxZuX30KXkIFb730Av+/gZbl7+9dLnG3Q8ehDT9B52Ii967fP+pH5SXay1mwmd+UGtgfqcTobiJYkVEmbiZa0bEr6+q3Y3W5atdDylj6eOaMxyfXQv7uKxvz5/EsvsGTRImbMmE5k5w4kfTIJY1QUKdlaYt9Xb7/D7dN+OOisS2kkhps17zfGbN5JZstmKDdfD888j5qUjSqKBM1m9BMeJrp7awCWzv6N6b/9dth7czAc2DhSUeQQITmE0Kh2+/+RofSAUAFFwd+YZ+YpKcDkdlPUMpvmi1cRMJlYe2Zv0jZvIa5EqyvyHIp1WgDRaEQf68CSlUonqxmHw8buzBSK7FZiK+vw7S4htLMYT3E5IZeHVFkhGtjO4anZjwmCsLcqTjToQRS0yrhwGCUY1oz0QxmmqooaDBEOy8huL4gin78xkR9feZ1SoB6OySARRQGTwYDdZiYywkpsTCRpqWnk5e0mWO+krMFDvddPMBg+qtC3CsiqoqnJN77qiUAIWHf0p3lEEFRtOZr2/wv41xsll140ku7du/HB25+g02uDQGlJMbPeeQe5qPiwXBtHirXr17N2/XoEQUASRJo1a8awM85ACQR464vP8QcO/0E8FCRJIibKQcsuWu6K+vIjiKE6bfYkirBkA3zyObz7GULTTPr1H8jsuX+QV1RBMBj6Wz8HaljG1+DiiYceodZixGsxI+h12owoEELx+VH8wSMjsBMERIOOztktyYiII+z3s/v32fii7QSrDZidXirSkpi25BcG6FVad+jNddfdxMoly3nr/Q8P271o0JOtlzDrpb3rtm9Zw6ZvPiOrpp7UzTsoTIxh69C+1EU1wx/wkb1hF52GXkq3Fm2obb4eRZYxWqzsLinip2++Q/b4jmh2qnkZZOYv/oOhQ4fy06xfyeyqGTcVFRU88vAjfPjRh4clOlODPkpqy3jnjUk899bL2K6+gDolhCu/ijoPZFw5EEen1oSCQe696TZ+/3Qy6nFU3hz2uk5XG+wHNRwm7PRQX1YG7UHo3JmGX6fTdN0WypukElNRidXtxj/8HFI69AIgr7z8oPkkgl6PPi6SfsPO4j/XXo+jaRoJoh6r2YZd1GPSGdDpdIiCSE11FR169SCwfRcyRybLcNQQRSSzEV2kDX1MJPrYSESDHjUcJlTvIlRZR6jOqeV5HW78VZTGkJV8xIzNBz8tAYvJSE5mGs/e/wCdBw4iKiEZQRSpLSlg6lMPsnLVOmaV11BRU4/XFziuKskpx3m+/1/xrzdK/PmlfFs+E7l4KNbUNL777TfqqqpQg+ETZpD8GaqqElZltm7fxtbt205Yv4IAkiQQDgbQm8wIW3fBps1QVwfRkWAyQkklFOZD00wy05qTEwpTBGw7AMHWKYeisluRweVD8AT2unSbyTKKuo+E6/DQyj37xWnlsdsq8xArq+g5ZyGyKFGcm4mjpIKV5/Zjwadv0bqDVkJaUP3f2QkHhiBJyNddS9O+A/euK1u6hOjiMnShMMXZTQmZLSiiQDgUQMgrocmt99OyvVZZEtOu09793v7gPS1sFD668OCekOA1Z53Fk6++yuyFC3n06adxOg+futkCjaFyo8/Nh59/TP8+3Rh6+SVEX38F0eyNlBFwu7l21PXM+/EHYuUQVg7MeXIaJxiqihoME6pp4POF87hp6EVkpGYxfUA3FEnC6vLgirDQZsDZZF96zd7d6goLD8ieLIgiepuZtHYt+fr5N4m0Ow55+JjYOEZdew3PPDaOymPUmDokBAHJasKYEk/H/j05d/BQ7GkpRFnt2HV6HJ4gr37xMb/8/Cu+/DJkj/eUhZOMej0JsQ4+evtd2vbqv3e9qshEpzTh2tc+otvSuURNncrUGb/iy9MmrSdKp+Y0jgz/eqOk0BvA4A2weNYcdEDNP+EDfYyQZZnSkgKaZOVC9x5QWggbd0O1E+Ii4bZboe8ZAJgMJhRFwftPu1RV3S+UIR6i6QGhqITdPlrHJAGgRyJs0GGub0AIy6ToBDzRDuzl5ZjLalFCIUS9XqvoOUI8/+jT6PV6NgXr2fL+JDI++RpJEGiIsFPbNA0kMDe4CejMZF50DX3bd99v/6Dfj7O2hvcnvq3F8I/xN1i/fDkje/bkaEzbCsABBOUQ9Z4GLr3hBm6fN58zBw8irnkOWVmZ6Ax6xo+6lmnTp+FTwhx/MfC/Dxo1jRZ2ilE1CvMTlROgBIJkV9UiTP+FDbfm0yalKanZLfEtXY4zKYIuffrvNUgWrFqKr7ySF155BRQVA5phWQCg12EwGbAmxjDx4ceJtDuobKhi7cYVmHcVEHa5qNUL1JgNZC1YgqFff/pceTNXnHc+34x7krwQJ4zfIx1tnlFo0GGIj2bwlRfz5T3jMBpNf71+o46llQVkOF1sCgQ0LqGTDEkSsVlN3HfffbTt1R9VDhOaPhndrs0ISbGoQ0YhxqTSuu9Qnuk7lCcmBNi0bBlLp0zh1jff/Gd6+06XBP/vIogW5iuD/1mDRFFU3B4/xRs30CQrF+HGu6Bbbxh+LoQC0DQJRlwCgKdwKzNff5Z6j4/qE0imdjJwtL4kVZahtoGtW7fRv2d/ctJz2NShDWr77jhyWxHatY2t1buxFBST0LU3ol6PHA5TUnj4+U48EOf3k7d9Kzmt2rBkw1JC9ZWEu7cHQYcYCuBKjKUyMYoOM+eSNOxchvYcDMBbE9/gohEj+e6993jnxReoVqHOd3yiizuOYZ/axgW0UJDL6+aZD97luY/eR0AjgIvU6zD7vKcT7/4LgqDlbhkMesxGA3qdhCAIpHt9BGWZDWEtZ+B43ycdkOryUlxQztxPP6XNA49yli2dbfHZ5Jx7ATGt2gKwZMlChl59JYGyKmSPlvmRBCgitLTZCMZHkpKWSP/zzmZQ934oisLu997ANnsupblZqKpIVGk5nqx0lvbpiKLU0gdokduSNJORDH+QWcd3y/bCCkiAzmal/5CBfHnveIwGI5VFuymrLCVyy3Y8PbvRMrMV+iYptG2bw5byGrJdPrY7PSddrVmvkxg6cADX39xYiLBpPvqCTQgBL8g2KF+IWh2LIsSjxqdhiIymQ9++dOjbl4+XLmXZihUn9fxOYx/+XxglwP+8Cy4sy7g8Pt755AOa5TYnoXlbaNcV9YMPEV4Yh9qmPULTLNRQkD/mf8vqbbvY4fQTOsrQwT8dqSqY3F5efORhOnfoROcOnRl599N7t0cCTYMBilYuJb2bFrr5+N13CB9Bsm8QsAXD/DH1e3JateGcpJZ855mC36QnsqqBghaZyDYb0cUlWMsryOmtCYfN/vIL3rjtdm657fZjvzABrZxTaqTLR+N5QVGOSZdpD/ZQ6Ct/ClVWHERZ+P8zBAEMeh0RNgttIm1EJMZgio5EVRWkyjqKGtzE17uod3rxBYLHZZiEgZlAjtfPix98xG33PEh0Ti49HhwHgBwOs2bVCl584AFaFpSy9k+ehDK9jnSHjejsNLp1bMnd9z1DTLom44AcxuF2IXjDlBtNJK3ZSECF1G27WXb+WTgVFyE5jF7SEROfwMr6YyeO/G9sAQS9DlOElatHXoTRYKR020bWPvkQiTsKEPKLMd5yEzz+DJF6M7X9O5G4YSfrYqMQPP6TbpToJIm7x96NKOnwbV+NqWA9wvJN4PZC01TYsAth4yzEsmpqnG6cV99G5jkXUFJQwPqNG0/quf2TMXHiRF544QXKy8tp164db7zxBl27dj3sfl999RWXXXYZI0aM4IcffjiqY/6/MUqOFaIooNdJ6CQJURQBlbCsaFnhinLKym0VRcXt9bN45VoeffweLj3/HAZcdBvCWWej5LZETGsKQEneBuYvXsOC0mp2ud2E/0e4CY4UlUATRaW41smP339H5w5aIqgvFGTKpmX0j00nLbUJTXtqtO2TJ3/E9WPHHpGHrB6oVlS+nTSJS++8m8TkdDJbd8H0/juE9WZiTToWXDoQnUPCtzuLXJtGdPXBZ58dXz5GY2KgZLfQTRJx2q3sNhlRAkHCTo9WyukPnPSB+/8z4uPiePimG1i9ZTUtVD/tunai3+j7UOUw83/7hiWLFxG9rYDNO4spLqvBHwwdt8dku6JCXgG333A9V196Kdb4eL79eSYffPYJZcUlRHv9xMrK3hCLJIrYbWY69+zEi8++RFx6Uwy2fTkkot5AZt/BuH75neytu7Bvy8MZ4yDc4OS8599lS/Mk/M2Ho4+OJS8hnrwdO0+oS1/QSYhWE1nZzQHYtXIRzZavw9DgpiIlHknWriRXZ2d0bHOey05DWrcddCIcXx3A4c9NEGjaWqNRCP40BXP/XPAHtXHhi5+hqAIcNgSrCTEhjiZnDAXgnvvvw3ecHs+ThpMcvvn666+56667ePvtt+nWrRuvvvoqgwcPZtu2bcTHxx90v/z8fO655x769OlzdAdsxGmj5CAQBAGDTiLNbCQy1oEpKgKL2YjVHoHJbGf5ytXUNrhwuf2ET5HaaDAYpqKilpJFa/movBpJjKT3iEuRGg0SgHffeYdfF66luLiCJk4vZjRSq38LgjSGNYIhnn7hZTLSmpCdncPECePZWlLMnRYzD55zPsYIB7/Nn8/0GT8dVULzLsBSUcVnz03gxvFPceaF1zEzKZXIjRtJi4mmhyGNuMRk+r8+BmukRgO+taycymO8HkGSkOwWzBnJWJo3RW+3YEmNJ8lhJ9zgxre7BHnDLuIKStjd4MZ32jA54dBJItM/+4yuZw3C72qgZsPvJHXsj9gosjjkstvp2rUHP0//il8XrMEf2ERFdT3BE5EoKitMmvwxkyZ/3JjIQuPHRqWKPwtEgtGgIykuituvHU1Ky3baSmc9OGsgVSsZN65ag1xaSWRMJEGHjZrMdJSwjLXBia7Kgqe+Dnt0LNGOyJOSYyBIEi3iUwBQV63CFR2JRdLhTk1hVaqDqFVLyOjUg1HJ7XjdakXQ6RBOgSJRSkoqEY5IlHCIQGkR6lfFGsFgYQ2kx0NsJOh1KAM6IbTrh2SxsHvrFqZOnXrSz+2fipdffpkbbriBa6+9FoC3336bn376iQ8//JAHHnjggPvIsswVV1zBuHHjWLhwIfX19Ud93NNGyX9BBJoBRTqJ+NhIRtrMxLdogqltDjmt2tPvnGsw2uysXTCHO++7k7otuyl2e6k5BR4TRVUhEKKmopZqX4A7Hnuc9HffYVDfASTExbNx82Y+nzqdmnoXPo+PhJN+Rn8jVJADQa4dcyuCTiJHFKgUBRoQuG/9BJRwoxDfMfwsVYrK+GeeJbVjJ84+byQj+g+D/sMA6PundgU7dzB53Hjq1qw5tmsQBUSrCVOTRCJ7dyCqVzv6dO3LmPgWKOEwr9Vv55c1S4kRwaeESFAgv8H1rxdmO5UQAKNBT+eBmmCmye4gpee52kZ/A9SUIqS0IKZZNy65MhVBfJOdBWU0uLyEwsdOAndANCpVHwiiIGA06kmKi6JtL03hnLy18OKzcMGovUYJ9z6IZc0qwkUF7G7RDH+EjY29OlJnFdhU10AfZwOJQExU9Ik77z+dvxoMEQwGsZrMyFkZ7Ap6CUh64suqaP77EuRnJhFYsQZjXDydY9PICwZRT8HYabFa9/7b1aIlUdNnoi+vhibJYDVAOAyltfhcHkw9tMq79z56H/kf/K4JHJ3A5J62/13FZzQaMRqN+60LBoOsWrWKBx98cO86URQ588wzWbJkyUGPMX78eOLj4xk9ejQLFy48irPbh9NGyX+hKeCSJLpFRXDGiGFcNvxc0tt2BKOEPiZlb7y/fd+BvDfpXR65+EKMskKdL4ByCh5gN7A8rKBr8GDwBigorWLJqo0osowckvGFZULhMIqi8v8iEqooqEFFS5gVGqeZxznGlQPICiMuvZRrLr+czj17ckZuLuXl5WwP+BG8PnZu3MjLEyeRKcvHrLEi6HXoYxykd+vAFddcy5U5nUi37WOPneCIo4cpms9KKqkNhqlWBcRtPhT/6ZyQEwVBENDrdVSUlZCUkoZSU43oqgNPHWxeAGs3QHor1CvGoI9PYcTlt/HDrwvIL67E4/Ujn6IkckEQMOr1dOrcGWtcIqrXg3DXWAgG4McpcMawfY3vvx/h+QngsFHQpRU7e7RnV6YDx4fTCDgbAIiLj9Pel6M5/z2eHNjrzfkzVFnTuvph5R9ce8YwEgYO4eeMaHrM+ANbTQ2xu4sxulx4fpuF8bIr6R3flK+cnsMSC54IrF+/nnm//MyAIUPJGHUPPksCTHwdnVGHEB8DikKorI5g+/5EOWJxu1x89tln++Vi/VuQlpa239+PP/44TzzxxH7rqqurkWWZhIT9p7YJCQls3br1gP3+8ccffPDBB6xdu/a4zu+oKzIXLFjA8OHDSU5ORhCE/ZJYQqEQ999/P23atMFqtZKcnMyoUaMoLd0/gNC0aVOERin4PcuECRP2a7N+/Xr69OmDyWQiLS2N559//tiu8AiQiMbvEAlU6I20jk/kgssu59G3JtPs7PMxpDbFEJemGSSrFiFPeQs1HKJZx+7c+/JrCJmpGA2nzr5TVZVQWMbrC1Dv9FJT7yKxwUOW108gGDp0nouwh+baiGSzINktmoqtQd9IY/0/jEPMNI8F4UCQ9ydP5uabbiKnb1/6Xnop14+6htE33cyzr79BQJbZQiO75NFCEJBMRt57YjzrJn3OQx0HkW6LIex2sXL2NFYtmwfAsLjmRPbuRrBHW8yZKYhmo8aO+XdjD2OnQa+pKBsNCAYdiCLRHMPA8ndBEDDodVSWa9Rc6qzv4KYr4cu3YMovMGUevDEJ4eUHUANebPEpXHrhZRiNeoRT/DsIgkCHTt0AUNYsh2AQdpVDYWNRt6+xnqpdF8zPvoAvKQaT00Pm8g00W7sbU1o8NWZtnIpPS9UIDA8HUUAw6JDsFvSxkRgTYzEkxKCPcWjjhm4fyaAalgk3uPnk888BaJnbgStK/JjLinFHWJANIkGrCVeapvfTNTFtPx6fjBNxkw4CWVa48rrryF+/DlGnx3rpdehmLyVwzVhcjmRcF1+H+usCoi7UQhULP3yfyqrav1XQ9LBQj2EBioqKaGho2Lv82RtyrHC5XFx11VW89957xMbGHn6HQ+Cov6Qej4d27dpx3XXXcf755++3zev1snr1ah599FHatWtHXV0dY8eO5dxzz2XlypX7tR0/fjw33HDD3r/tdvvefzudTgYNGsSZZ57J22+/zYYNG7juuuuIjIzkxhtvPNpTPizCaL+XKBlIjIonO7ct5w8aAoBaXowwcyrERMGGTTDjR6Sze6G2Xgm5Peh07gVM69iVa66/jl9n/XZKK45V0FymqsZPYT1MeyQR0WhAZ7eij3Ug2SwIoojiDxCqcxGudyF7faihw1BA/3/Cn2eEJ3jW1EwUOHPAmegk7TUs+PozlGeeIhBhI2S30fBcNI427Xit5TA+FqN5ZuMuRJMRwen5eynbJRHJZESymZHsVo1GXFWRfQHCDS6SnG7iZPWoy73/DghoDoCy4kLadeqB0K4d+PwwfyV0agmhIFR5oKAQdeEshDPPo1vX3hqHySmEikpYlmnbQisXlqsLkfp2AtcC8DV6zv40qdClZ6IkJFEd58CvyvT74lcqEx2UXq+VsMenpyKZjYRD4YO/66KAZDGhi4rAmBiDISEGXYQVVVEJN7gJFFcQKK9BdnoalXpVFK+fJb/8xkufvM/do66n7ej/UGk1sibZgSMqnY5NW2FwRCLLMhPfmrSX7TgbKOFPHCwnEFloRvLO8gra9uzJDddfyz23/oek7OaYBg3DNGifl8lVVcmqV1/l/RdfODE5Q/9AREREEBERccg2sbGxSJJERUXFfusrKipITEz8S/tdu3aRn5/P8OHD967bEznQ6XRs27aNrKysIzq/ozZKhg4dytChQw+4zeFwMHv27P3Wvfnmm3Tt2pXCwkLS09P3rrfb7Qe8OIDPP/+cYDDIhx9+iMFgoFWrVqxdu5aXX375oEZJIBAg8Ccq9yNhv9yDaqBelIixRdAsoQkD23QlPicXACExFa68Cd6ZBJO/gEgbbMlHePQRlKuvQzznChJS0/j5l9mcd+aZTJsz54iPeyJxIEXV/dAoNGdMisWcmUpCZgqpej0NDisJReXEbs3n11gHVSVVhKrrj1hR9zSOEaJAuV7Hvc88yhuvvEWkyYpgtRKqrUVn0KMPhih75kkMb7yFJTaOMW36s6vvNt6csZCjiySfWAiShOSwYkyKw9w0CVNaIlKEFT1gCSgUrtpAMK+E6lon/M0KrkcCFc3ruGuXxgqjxCUhJsVCSQUUlEBsDHgCqIXlqPVaOrOiKCT7/BSdQsNdVcEfCOH2aXwl3vhodJk9EdxuhB2NzDT/RVQWIQvs6NSSjHlLyVm1kcRIG3XDqyC2BakJcUg2C7LHd+CqLkFANBowJsdhbZlJ3yFnkZnTjPjoWJpJZux1Tu6d+gX5azbh3VFIsKIWNSyjyjKh2gYefvAhIm0RjD7/Ys66/GbO+lPX7oYGbrpnLF99/pWWhC4K7FBUsjgaZucjh9i4qKqKx+fjrbff49NPP6VXj+7ccuPNdO7Ri03r1zJ1+g/M+fob/JU1bP9nP7YnHQaDgU6dOjFnzhzOO+88QHvu58yZw2233faX9rm5uWzYsGG/dY888ggul4vXXnvtLyGjQ+GkxxwaGho0wqbIyP3WT5gwgSeffJL09HQuv/xy7rzzTnQ67XSWLFlC3759MRgMe9sPHjyY5557jrq6OqKiov5ynGeffZZx48Yd83nqJT2xtmi6tu7EiKfuRrL/ye9gMMB/7oDtO+GLTyDaAZ2bI2S02tskHA7/c13WgoDRpCcpMZZA9zY4urehdctcHkjriMUawaxdqymZM4cYpwvfmi241m4nXOc6JbHe/7doZAndHPJjljRNptptm0hw+zHmF+CNimaTTeKPSU/Sqc8gOgw4h2cvvJaPHptwcvRKjgSiiGg1YWmWTkTnFvTr3Ytbeg8mOS6JVIMNnSixo7yIz2f9xMdvvUfD+s0oPv8/mklSVSEQCLF+vZaBJZgike0WxDqPFt7ITAKnC1UU8RTmEwHY4xPBGzglCZr7zlMlEAyxa9NGOvfpR2SP4bjem4Bp8UakIUP2jj1qeQmB77+lbuMGvKVFXPfVt5jrXYjhsEazvnYLtOpLRGwcksUEkggHMEr0ooAYFYG9fXP6XzKSr84f85c2j8ZHc89XH4AgIHt8hJ1eUBSUQJBgVR23XH8DzQxm+p0znMqyUn5aMI+vp0/j99/mEHR6ABXJakI06BEkkUJFRRcKowSCGsvrCcjREwWBfEnUqinZE/oOU9fg4efZc5k193cEQUBVFGRFIRSW/+l29D6c5JLgu+66i6uvvprOnTvTtWtXXn31VTwez95qnFGjRpGSksKzzz6LyWSidevW++2/55v/3+sPh5NqlPj9fu6//34uu+yy/dxFt99+Ox07diQ6OprFixfz4IMPUlZWxssvvwxAeXk5GRn7Rxj3JNyUl5cf0Ch58MEHueuuu/b+7XQ6j9g6EwCDJNHFYOK84YP2GSS7dmgSqNnZ2t9vvAkxMVCxCwb1g6YaadGCWTO4/e77WL/pwAlAfzcEnUTzyAgic9PxDuvLVX3OZHRCW6yCFg9uHp8OPc5jAjBz2XwuH3MTNq+fEp9yOoxzAiGgzdhkQEDA4QtwU2YrjHoDsqKwtl0zctu2ILKiBnt9HekbtyMpIXaXf0KHAeeg1xuQZPWAGiin4uRteomoxBjE/h1JGdybN3tfQaTBsl+z7MQ0nhh1M/ddeBX3jHuct19+9R/Nr7LnY79w8VIAJLuDwuxMYju3RL96G/j8yLlNcakQym5PBFCQn88qWT7l+QahsMzm3+bCzbcCYBt9H26PiPnKUY2eAIX1Cz5EXLYcj0fGXFBMbH4JvqgIahNikSWBcGOia5Q9AkEnEa9oasFb/nScZMBhMiAlxRLq25Eh/TXpCqerngJvPQGPm86ZrTk3pxO6mx18nvw9M8reQfGXofgDWq55KEyw3kX/886jh9FIQzDIlkalYASBdnodxEdTkJGCIS6KjHAY0R9gmwKBsmoCpVWauvYxKpyLooDZZMRuMWG3mbGYjaCCPxCkwe3F6fYRCIYIhsKnh7iD4JJLLqGqqorHHnuM8vJy2rdvzy+//LL3W1xYWNjI3XVicdKMklAoxMUXX4yqqrz11lv7bfuz8dC2bVsMBgM33XQTzz777F9Kk44UByprOlLYgEwgQmek5QCNjEudOgfhnRdg5XJ45VW4apTW+Il93pg9TvS1b7yBdfuOfyydu6DXcdV//sPll11BdHIKJr12n/Kc1ZTv2kb79OaYY7TkpL5tOtMyykG9UU+Vz//3zcr/JRAEAZ0ooZN0NEPErsrkI1ArQHRI5vsvvqDfRZfQPDuXqwZcyJIVGyldtgRjQyQmtx+3JBDq2AWAnQX51JSX/z2GoijSxGQgIjoCV/vmPNikA5EGC57KcpZP+RTdihVYyiupvP92WrbqRpO4FCY99yJd4hK47t77Tv35HgVkRaGopILK0hLik1OoT2rJZn8RTe0WInYU4m7dEnnAEHLO0kqFxz//HMHQqTe0VFXl6ak/sGhgf+66+WbOvuhS7Hfsu7eCIGLKPYNfVUhbsJmOy+qQAn6s9TJ+m5n6lHgshUUARJqtKKEwZlUTcPwzqkSBGIsZV3oC8c2b0jVSS0wt+uQjKmf9hC/CTvlV15M4aBjDE3IYfsMDFA+5nIsuuZilS5fvez5VFWSVdV7fPkkDSURnMxNOiKHvJefz1Y23E2WL4OFZH1NdWUGdUY93az4NKzbh3VpAqM551KFkSRKxWUykJ8eSkZpAk+Q4YqLsGrtxaRXmjbtYYDKwtMGDy3PqeKb+F3HbbbcdMFwDMH/+/EPuO3ny5GM65kkxSvYYJAUFBcydO/ewSTXdunUjHA6Tn59P8+bNSUxMPGCCDXDQPJTjQQpgVlVc2dmYEuNRA0HUcY8i+OpBlOC+e+CZp2HTlgNWqCguL0nBMLEcJq/j74AgIOp1XHLF1SSnaTk9Da56iqZ9x7K8jTRZu5XFwQC2tCZ0m/QRFrOFjKZNKN28i606HZzOLTlmSKKISW8i1hGNRWci2Wqnc8vmGJvnkBIVwUfffM2iknwGjL6K716fRI/2XUgdMpwfXCVYfSGU9FQSNuURn6h55FatWK4J/P0NEESRGquF+Na5PNf3AvqkaKydVa++hOGPeeiQWNuvE7U7NjCzroA3Rt4JQOd27UiE4xb9Swaigc1ozssTCVUFrz/Ir1OnctWtt9F21E3ErV9DVcJO9Jelk9O52962y+fOYfr0GX/bBERWFObPX8iSJUt5ZNFi7n5mAgaLhbkzptH/7OE0b9uL32qLKGxaQ2xuBtbqSISwQlmLLFSdiFigCW7EmG1kNbgoUBTy/+sYYZ3EoFFXc90tY8hqmoVR1DyqwflzUFFJ3rGLte9NxLpyEdKoK2kfl0lqWjqvvfgS3fr0/YvR3ARNd6weEA16uvTsxoevTSS3WfO9be48/wbGutcT62zAm6lVBin+EEowRNjpPuLcJFEUsJqNNE2J567RV+OI0hNrF4iNtKMCrt3F1Bv01NW7KM8vZ3dRBU637x87oTwUBFVbjqb9/wJOuFGyxyDZsWMH8+bNIyYm5rD7rF27FlEU91LX9ujRg4cffphQKIRer8XbZ8+eTfPmzQ8YujlebAc6yAqCUXv5ZJeHYG09ZlcVQnwCqD7Qi/DaS3DnvXv327TgN6rqXby2Zg3VaBwiR4toIAFNmO6kOeVFgVBjQHH5/B/ZPGsmzRevoYPXiys2Cnt5NRU6icqdW4hv1oL+g8/hxTmLTodujgOJQLrexHdrVpPcPBtXTT0Wixm9dd+8tG1GUy67+35qdpXy1FsT+emdycRm5NC8xxA6dOtHYvz+BvgfP/98wiuAjhiCQNuePfjqhXeIioxGkWVKvvyE2tm/YBQlVlxwJta6BvpPnsb28/alNT735PhjHmQEBERRRBIlTCqYVAWjACEVZPXEEpcpisJ1Y+9gXV4eT40bT1LbDiS17bB327y5c/j444/5dsqUvYRaOiCCfQKIpwqyouDzB/j8tTf4/bup5Azox8fTp/PshAnccvMtXNZxMM8W5aHr25Ho8mpMXi/OmChW9WhHH3uq1omqInj9SAf52N99x10kpWrh77DbTfnCeWxslobB66UmIx2vw4a5vIj6d19hjt7MAw+8RNeevejetStLly7d248N0KMpV9eLApLdwpvPPE9us+aEQkEKygtolpZNS8nGFKkVG6UKfmufxJxaJzF5pWyubUD2+VEDR2aMG/R6EmIjmfDkeIZceBUASm0ZglEBtxulRwTqJRLty0rwPPco/kAIn7/8X1tp87+Iox4v3G43O3fu3Pt3Xl4ea9euJTo6mqSkJC688EJWr17NjBkzkGWZ8nJtjhQdHY3BYGDJkiUsW7aMAQMGYLfbWbJkCXfeeSdXXnnlXoPj8ssvZ9y4cYwePZr777+fjRs38tprr/HKK6+coMveHxlAmRyih6ceAF1sFMqsn/BPeBlTpROhbDs4a2HGb4R25iNNmIBot7N85RrueOxxPL4Ax+oAtKGpa1r4L6Pmv0sOj2cAVlSkxv2Ldm1B7/dhCPiJqK6nPsqOrbYe2WRgnRXOAgb36MeL4TBZqOw8dM+ncQAICCg6AzGOeCx2O6Io4ojTGDRltxfJpuVh6HzQIaEZq8q2s/qXeQQDAWyRUQwdrqk9+/1+wuEwRqORz999l4kfffy3XROqyqSnniMqMhqns55VLzyBd9t2mtfUUxcbRdaS1STkFxG0WYnPabl3tx9378R5tCRdgCiImPRGbCYrdpMVk8FEQBBJCwVw+T24/W58QT9h5cS53sOyzEsvvcyUb6dw/UUXoYuwE2xo4INvp1BUXPSXS8hCG0Br0X7zKFSNs0YQUVX1pJZtq6pWqVJQXMyvn34OArxz772ce8ZAUnOaMzqnL9u8i1Fik4nfsgNXahoXtRpAn1zN0Pr4tVdQPP4Dc+yosK0gn6TUNOb88Cn6SW/ijonF36YFer8fv91CbXIi7dZtJGNRKTXt2+N2OYmKjuH6Cy/czyhxA+sb/y2IInGpKbRr0x6AKW89TYPPg1MXRYex9+OwOehlc9ALGHt2FkUtzsRZ6+TG225l8/pNh70noiBgMRlo3SKbwedfoV2KHEaMTtIaWLWxFiAuKp5LL7qEXfmllFTUnHh23tM4Zhy1UbJy5UoGDBiw9+89+SFXX301TzzxBNOnTwegffv2++03b948+vfvj9Fo5KuvvuKJJ54gEAiQkZHBnXfeuV+eicPhYNasWdx666106tSJ2NhYHnvssZPCUQJaXXyWKrNpwVwWvfgaXf8zBkNuBkx+g9AfKwi/+BohZzJ+t5PaWQug2zRyR12JqDfh9vqPK+HtL+rFoqiRmxl0GjGRqpESKaGwRjJ0tKnhqooSCmMzax/CvLhIdKmxtPX6cDlsmPwB6pNiSbjhZroktQAgEAiiDwTZfZhjCYAgCoiCiNhIJKWqKrKs/LNJh04yJFEkyWQhMzKOpd8u5Ow7G42MiZ8SWlWI4eKBGId0J6Vde1o1bU2Ft4H1xVsZNngQZw89m6y0VKbNncs3P0zF43RpiaJ/9/1UVDyNZfal82axTvKTkBBN/pjriVm5hqQtm3FFOShtkUmPnhpl+x+zf8VT18CRpv3HAglmM0++9RaV1TW8+MKbNI1LJTU6iUiLA4vVTIduLQgqQd776hvWbt+IO+AhLJ/YWW5BYSGPvvTSYduVoREuGnQGLHoDkyc8i2DQ88gbk9ixawfBcAhZlk+aceL/8x8qrHd7GTP6On6Yv4Dcbr3I7dZr7+Y9/1IUhfffmcSExx5j/wLiP3UlK6xavZr+vfogxCbyzbXnEoeEIJpJ2JFHQn4xHqsZW2UNuuuu56wbxqI3GCgrLuLNjz46+AmLIjdefBmSKFJWVYpp/Ubia5yohWVsnb+AUL8+6Lt1J6VHHyItdiJbaQbUNRddzH3rHz/s/YhSVXIkgeTEOARRRA0F4ZyB0KETxMRCRAS0SoNmbSCxGZ26n0Vi3EcYDXo83sApY+c9jUPjqI2S/v37H9KiPJy12bFjx/0s6YOhbdu2x8ydf7QIo4VPAn4Pzz38II5vp3Htgw/Qf/hA9L27oO/9GbXzFrPyy+/I/2k3gxpLnH5ZvPjEfXwFAdGoRxdpxxAXhT42Ep3DBopK2O0loqQCqbyOPJ//qDPS1WCI/M2biekXT5oplvXCNrb0bIsqSsSVVBJdVEbKRdrM4qulc3nujrsQPX58hzBKRFHAbDQQE+Vg9k+/EJ+czJoVy5gz8yfe/eor3EfCLvs3Yo/u2cmAXtITaXGQHpOCtRIUpxcxwoIQVBB9AZT5q1AHdSWuQxYjrjifgteKCZflsWPBHzz2+wIyARfHFg7cgz2hD1EQkVSFVBXyBFBU5ZhmhKqi8Olnn/JCl67kjriYba4qQoPSOLPnubjyd7PuusvY0b09W5snc4ZJq1579PWXaRIMsfsIDxcFZERHM/LqqwEYfsHFbPltLYkxCURHmIjr0RydRaMJOOeay7n64qtZuHoJ9V4n8gn0mBwp/Do9XrOdLHsMjz7xKMNv0MIFQ0ePZtHMWXz41VdMmzEdl9d9ys5vxqIljL70Eq67/nockZGYHRHYbXbsFisrV63knieeYPXy5YeuiFIUVi9eDP8ZS6uslkz/+n1MNgu6CCuSqw6XQSBm8xbs/QfR6lYtnP3Tr78w6qqrqK06eFZdRpN0Hr5La79m53pKM1OILaxANuqp8TiJmvwJ1hdeYdrNlyJ17kKv9DY0adeJkHRkn6kkQcCBALKWni/oDVBeBp9/rpFfpsRAZXto1RsAoyOGKIcDnST9ndQ/x46TXBL8d+G09s2fkA8UyyHsm1az5KYbaft6W8beeSv9hg8mZUBPUgb0JOR/Gr1Jm2MsWrToxBxY0BLADAkxWFtkENU2G12TJPRxURgQyJasnOkU8O4u4KFPPsVTWnlUGemqrPDGZ58yuV9/RvQejBoKURiCVZ2z6bUhn+aCHZ3NBsBDLz2PtCMPh+/gWuKSJGI1m2iSEsfA/r3Jaa/NaAYMO5cBw84lOi2R997/AFd5DeVeP/Ipehm0iNe+0eXPH18BECURSRSRJC1ZWVVUwoqCLB/bh/pgSAAS9AZCiZm0GNoBMcKC6vISLhehy1CURVMJvvExxrHX0u68Hgxe+jvi2rk4EShAU3GvOY7j70mwtRjMWIxmslWFGkWlpRyiMBTA6/eQov41wfGQUFVeeuttslu14sYbb2bElbfu3WRvmkltejxbOuQwILk1DovGzmwoLmf3UZQD7wDySvZJUiQ3TSX5+tT92shV9aAXiUiI5e0vPuC2IcMp3byOpcgnLyfrANBJOrLNEbSNTGDQdTdyWaNBUrejiKjsNPqOOJu+I86meOcu+nfoxG53w6n5JqgqH0/5jo+nfEeOKFAhijRTFWoEgQJV4+M4Eq/b1OkzcDY0kJCUQpuAgYr8ncQrKl5FwdTgIUnU0/S1zwB4++1J3DL2jsNOlhRZIRQMoNPradm0BfNbbCW+qAa/RY+juh5BldGFwqhuL4Ur/qB1aqPn9giUZmMBp6qySxLplqg9M6osIxRVaNebHA8VNWBKgKg4ADbN+wKX260xjx7mluwZP8RGWRRFVVEVVfv/aQ/LCcVpo+S/EJbDOH0ufEE/lUtq+H3FH+Tm5jL2xtGccfYQYlM0We4Z33xDUVHRCTmmIEnoHDasLTK4f+xY7hp0IU6/G68SIt4ahV7YV/Ez5PqbueW229j440/UwpGV7KoqX3/5FeNvu530du24dNglKIMvoKqsmMjeSRgN+0qpgzuKKPP4DjrAi6KAxWQkPTmWvl1a0rNd5t5tgZ1bMDZrwc1jxiK6G/j9i28orKhjjS9wUl9cSRTR6SSMBh26Ri0OWVYIBENEBkNUqWA0GbBZzUTYzKQYdFhVzQh1uX3Uu7z4/METVhooCQI2u52rH7+R+HY5AAS/+QU2LIavXkA0mFA2/oGva0/MPZoz4qFb+OXHb9i+sx7C8nHRs+tEHTaThZSoRFKik4iPiMGmN9DR42S7omCuK0dXnsd2n5s0VeZonmA1FObWu+6iSVoag4cO229bu5feZ2hEFHq95slYsWQxc7ce/ZWkpu1jfVaCQYJFTqRgGEoLkbeXE95cTihUj+2J60hISeSpt99g9FmDwHfqqpJEQcBiMJESncTwwedw8cOageb5bja+L2cjR+sQzh1EzDn9SW2WRcfkNEw73Ww6xd6c7YoKiswq4GinyT6vl+lff82VN96I1H8Qc198imEeP1UmPapOZND48Vgjo9i4dQt3PPDAEU2S8vML6Dl0EMt/m0/TpCbU9uhESWEZ0RUNlLRtQXVqEuLiVcjhAFE7asnJbQPAjMOUnoI2EZCA0rDCQ+O13ENBklCjoxC8bnC6wW6BRqLCYG0RRbNnYckvJRAMH3J80kkSRqMem8WExWRAJ0mEZBmfP4jXF8AfCBL6B3Px/K/htFFyAMiKgqwECISDSH6VupVLuGHlEpxATk4O1dXV1NaeoJx7AUSTAUNyLLdcew33DrkYgChLBHvqjNwBHzpBwGQwkZ3elF9/mM7l3TqzfuWa/UiPDgW/x8tZvXox6KorufrGG+ncoSMJaU0BKMnPo6C0hOULFlK6dcdBZzyCAAa9joRYB53bNOOOkReSELdPAt1YXoQaE4slKo47nnqVa8fcw6hLL2DjstUnJbtdEATi42KIjY7EqIMou5mMRiVTV2wcSgjCu/OoqqjCl5JIj64d6NQql2Y1dZRv38j6hBgq8sup21nIxup6drs0QqXjRRnQ+4qLSW2nlTzKeaXI3/yMUFcGLk3kS4hNxf/oU8jvTcCWkcK1Lz/H58OHHbrjw0ASJZKNFvqmN+PMS66mVW5z4hPiKN9VR/nWYnJdtTh3rGKXLCPVV7DCXQfy0V1v2OvnvMsv5+uJk2jRqhWqADlt29MkRiNUWr9uLY9OeIYfv5961PwSAgK11bVsX7GanC4dEQ0GJLMZ+fdFqO9OQvXUISZno4uMx/v4SzjeeZa0Vi0oMNsQAl44RR99naQj0uKg6xlDuPDlx5D0OgLr8lE//Rm7JIJLwPPzOjinPwBtsluyMX83YsiPov7vqM5++NVXXHnjjVxy3gXoqmvY+uEH4HRx4Ycf0b7/ABRF4frrryfgdB9ZzpOiULFyNa66WqITEnlC14xf61yYC4qpN4ro1SA7urQiumtvUPWYzBZqq6oo+C/dtANhCxrfSuvsHAx/4qtSFi2Gya8j1RRDVQNKhBkRMESn0enaB1hV/jT+dTsPGIbXxjs9URFWUpNiaJHdhM6duhCfkEikyQqinu1bt/PCu+9SXeskEDq0cXMaRwj1X4qGhoZj0VD8yxINaitQm5yAvg64SKKqj49SW406Tw0EA6qqquqGNYvURU8+oO669UZ106Uj1d/H36fKsrz32ryuBnVkt/ZqotWk6iTxmI457asv1VAwqL786CNqkkGnJkiiiigccj9RFNToSJt641Xnq5WlBX+96R++oaqPjVGV5fNVOeBXVVVVJ00Yp0bYLKogHLrvY1kG9uyhhkOhfb95wU51y1dvq2s+mKCGG++lqqqqt75OleXwfqcarq9S8/+YrM6beK/65uWD1Yu7tlCT4qOO7X7+12LQGdQLWnXceyzfnMWqO7OT6snpqnrjm6nu9NaqO7mFWtain5r/0Td72yXEJxzzMQVBUK1Gizo4KVPd+P3Mv/w04XqPGiipVn2F5ep3t49Xz2zdR42PiFVF4QDXKwiqIElqtl6nNjHqVdFsVAWDXkUSVYR92yMMOrVZi+bquAfuVS+88nI1t30bVdDrDvscHfQaEFSHJUK9s+cQtXzJGlVRlH2/4QWjVXffS1XvgCtV16jxqn/9Tm19bZ3aNDZNlUTp5LyfB1isRos6csAw1VPvVFVVVYM7y1TXo1NUb+ehqnvQaNXd40LVdd4dqn+L9o6s/PhrtZ81StWdwnM8EYsoiuqy33/f7zlyVlRoz7THo9527bVH3adOQH3g8ktVd329qqqqWleQp866+Gx14iVnqc9P/1Ctdtbtd7yf3nxTbX4U/ZtMRvXTN15Xf/nqM1UO7xsb/OuWqA03XaSW3XmJWv7Dl3vXF+7coYoHeV6NBp2amhijDunTXn16zAWqK3/HX94rVVXVF596WE1LilGNBt0x3eeGhoYD9nsw7Pm2vThltjrx58VHvLw4ZfYxHe9U47Sn5DCoRSP9OVnzm1xZwajCrWeejUFvoGbnVopeeo7EnYWoTg+61EQ6GLruR+drtkXQrHc7ShrqiCyuZLvXf3QJpbLCeZddjslkwufzkYimMnw4iKKI2Wjg5Tc+wOqI1FYGA1BVDsv/gLcmgqpASTHqzfdD515ERlgxGnR4vMIJzW6XJJGuPboj6fY9whHpWUSk71OiVIIBBJ0ec+O5qkE/eOrBZENyxJLe4Qwio22kte5OmwoXRRMm0ODyEj5EPs2RICyHydu9ndrCIqLT06jeXYJZAH0wCMmZhCJjCXucGK8YRuI1FwHw2dvvUFl5JL/CgSEJIjaTBWNKNpn9emrXX12HvLsKXctUJIcFyaFVYJ3zxFi2BkIU1ZRS720gGP7T0y2JiCZNSbqlAHqdRE1kRKO2iQfZ40MJhlBRccng2rGTJ158WZshKirHWyWkqgp5tXVMf/EzBo5UyLyio7ZhzWIERxpKwI3+zG4Y22i/8x8//IKsnjrXuYCAJIrcf+9YLA47/l0lhJ75BClvA4ojEVy1CK4GRLOAIVMrRd2wfidegwnB74ZjJg849VAUhR4DBnD22WczZswYhgwZgj0+nrrKSvoPHMj6jRuPus80FX774itmbN3CrOkzSEpvSu8PviaropTMrJy97WRZ5pkJE3hm/Pj9q4wOA78/wHV33UU3ixHv5k0Mum0s1rgEjG27oz49kV0zvyMucV+I8Jlx4w84dgqCgNViIjMtgV6dcrngjIHYmjQDQA0HUNcuQ4mOQZfZipv+czezZ/2M2bONXWFlL4/NyYbAUZKnnbQzObE4bZQcAU7mIxYUBQS9jjbJGlFRwa4tFOdk0GbOYiK8XoiKwJz0VxbbwX07Y966g3VeH/khGX/g6AjhVVXF5/MBR862KQA6nYSwx0B67xnYtRVq62H5JiipAasRIa8YQdJeAclsQieJJ/yN0OskEmK0AJdr0RykWVMw33k7gi0TdEbUqlLCP76DPz6KcEoa5snfYywpQ8xOha49YeTNCJY0HC3ScLTQOCfGWR1cfuXV+P3B46qqUlSFjaEgRcUlRKenkXT1edQEXbjmL8NX4QSvk8gbLyHq+isBeHH80zw4/gmO53MuihJWo4VrxlyHOdqBUlWDd+TNCPkbCOsNCD26ocYnY3z4dgxxMdz7ykNs2LmeooWlpBMiElilk5AirHuVpCuiI3DodMTGRxGsrMNfWI6/qJxQTb1G4tb4HKh7RNRCYY4nq1lFJSzLlAT9JPdpR/oILdFR3rARxaeCaxtiVAyG264G4I+vfuOV194lEDq5OUt/hYAlViOF9H34FYZls1FadEeIS0GcPwXFXYX+zhsQDHoaimrYuKWQat1fh1pB0AycPZREKloy6D+mnF4QUASY8fNMZvw8k4ymTRl1znA+//FHdu7efUxdegATsGXtBjr26snUb6fQvUtXMm05hEIhXnzjNaY8OR4xpLDS4zmmY4RCYVa5ZO599XXu/2Qyffv05qmnXiAxvQkdrroZgHAwyJWjruLrr785YB+SKBIVYaVzYjSD+vUj5+xrtA2VBQgfvoAggRAbjRI7FltEDONuu5OxY+8k3eMj75jO+jT24LRRcgwQBAFRFNBJ0t5KDkVRCIdlZOXosrHzRBG9qmKI0ga5mOxc0n+ejmi1YGjXAePIkQijrvnLfmcMu5EUWwquF14g0ruF6nCY8DGwfcYCceyjgT4UVFVLIK0qL6WJPQJqPbA1DwrLYUeRpqZsskN5PXg1g8ck6JDCMsf1xf0viIJWjpyV2RQAg9eNIdqE8NRTEGmDkechLFyAIdqKPjkaygvBLCI4LLB0g6Y+2rwNpLUCe+Tefs86+zxuv/12xj/1DMpxlgyFwkEGDhvG5MmTOWfEcOJvuRb1plEsvOUebPGtaNFokDxwz/288uorx821IQoCGU2aMvyK8wDwT/wcoaYMggHUumrU+QsRUpvhH/MIlilvoTebSE1ORBRFPGjxc11UBNbcpji6t2bkeSMZnd2JADIuEVqZYrDoDAQDfmrKy7j/yw9ZvGMTqqwQrncRLK8hUFFDqLYBNRg+Zo9Jk2CAhBg7w8Zq1SzholJ8d49DVBVUvQnhghEIEXY8eSVMeed9aqsK8QS8pyxXQ0VFVmSkRl4e2d0ArmrEjQshKhHCPgSDCbF9LgC7l26hztNAIBTcOy5IoojBoMNqMeGwWTAb9SAI+AMhGlwePL4AgWAI+e9i7xVFmtht6FSZYrtVU0tWVUrc9Tz1wXsogSA6IB4oPVxf/4XKxgVFobygiP59+/H8Qw+R07Qp9734Ahs2bsSgqMetuO5TVPLcXnS+AF9+O50Zv8zlibvvpn3XblSVlPL2u+8y8xCUEzqdSEykndYxkXQaeBmCpIPyIvjhXfhtCbg8COlJsL0Bnn2NLhdcRr+vv2HiT7/8fazL/xKcNkqOEpIoYjLqsVlNRNgs2K1mzevgD1Lv8uDy+PD7Q0fswlMVBcUf4P2ffmBSxy40yWxB9I13Ul9ajumbn/+6Q10d1FchZOSQe8ZI7mrSglVXXUndqvXHZJQoaDwtR7Kn2qioWr9zB02ycwlfcDnSssUICTEQFwm+IKQnosbGIPYaCEDH7FYkBIKEFOWIQkRHhMawQnqONvALEQJC62awbifMWwm7y6CsEvR6hDYZoIqQEA3BEFhtMGclbLwX0hKhWxvUilr8PUdg7nsmDz82jmnfTWXVxsMzSB4KKlBbX8v5F1zA2Guu5YqrrqB9v770eH0C+sZEvMcefpQXX3npyDgsBAFBEhH0OgRJBFV7dtSQjBAOoyoKzZtlojMakL1+/BUq+hH/QfrhddQYEVECRRDRXzoSgIq8EkoXLEIny5QLIjkGie4RFhxnn8kLo28nNy71gKdhNZqIiojku8dfYNbOtSxwlbOzqJDNq9ZQumID7nXbCdbUHzEt+J8hAlYUKrduojy/gMSmTaitrKNOF0lkTDz6+Bjkzl0xAatWrKdi13qEugr8oVMrGxmWw5QVFtGyUwfkgf1wLVqHvaoA0VOPYjIjxkQjdWwPQNOezSl5qhxv0IeiKoiiiM1qIiE2kozUeLLSE4lyWBEQUMurqS6sYGlNPYbKenZ6fdSdaqeJJPLB669z3S23snXjOlbu3saW8mK+XjSX2OJKttbU46uoJau2gXAwjMjxeZIDfj9jH3tsv3Un6tdUFJWgEiYnFMbnD3DLAw8d8dxIEASMBj3xJjOS3aGtrK+DuUug2gWV1VrFly9AaNFc9L3O4NYJL/LOrLkI/tCJnIMdHHuyUo6m/f8AThslRwFJEomwmklOiKZ1bha3XD+G1p260+CqozRvF0sW/cFn30+lqKyaBpf3yGY6iorJ42PJ+x/yUnoKd199C/aWbbEfyCAJBuHJ+6B0N+oVV8EZF5Kalcu06T/TqXMndhccfYlyLUeu3aGoCj5/kKfffJ3P+g/E0KwV8t0PIm75HcHtg+p6VHsc6hVjEABFDvPtD98RDssnziBBi+sLgkCT9AxtRUUJSEFIi4Mtu2HdVm3ACIfA7YFm6VBQAnWNwl5VdRAbAVvzIT4Srn8Yc2MuStDvRz1BhG8qEJZDvPLRB0z87BOmfDeFs4dpFTYT35zIU888zZGwfQo6CdFsRGe3oo9xIFo0nhzF6ydU56R1TQOyrPLLvPk01NbjiI6EzBjEz94Bix0hpyPqznUIYS/6s/sAsP2ViaTWVxGnKDQI4DIZadOtMx/951FsVjthv4/6j94n5PVS0q4lc5snkfzrLKRQmBY9BtK+fS8GNWvPIIAOwLnww/LfGX3/PSibwoTrnIcm6DoAFGA1IHqc3HLDzXw5fSrxnVoR+eXL6G0WBEna21Z0GFhfX4kz4D/lxGkhOcxnb77JwJHnEjukL7saguhWrUC3Yxf4wf72vo9sVEoc9jgbvi0BVFSsJiPpyXF0apVJt/Y5dOnUgfioOLzeKrw7iwgEzUQt+oPty9fhrFCo9wVOHZmvKBCbmswVo68HILd1O3JbtwNg5LDhvPDDxwgbtrB7RxEtVm3BHXSz4xSd2vEggDbxOtrbKCsKBQ4j/rIdmJKyIeiCkAweDwRliIuCM89G11njy03NyCI3OoplrmMLO52GhtNGySGgxXwFJElEFEUsJiPNmiRy2y03c8HlozHbNAs6mnQyctvRa+j5jLrtbj549y1eeX0iNbUNRxQfTguGSS2v4fuXXqZP5+50bdXxwA3vuwWWLAKHHQo24f2kGOuYR4iMjSMxPoG8wr/qcxzNte6NbascMASlquAPhliwfAXPjH+YJ559BanXIFx15YiL56O/4T/om7ZDFES8dTU8/ui9zP7yezaeYHemqqro9AYcMbEAhDZuwuAwwoot4AlAu2zweGFHEao/iBwMIRiMiA4VIa8MfAEoroI+7VGbN0dIz0KVZX6a9jUPP/Ykm7ZuPyHnKQgCekmPSW/ApDdx+423E3ymltqaGh5+7HGtzFtVcR2qD70OXaQdU3oiXfv0YNgZZ+KyGvGHgjirqpg5Zw7e1ZsIFlYS467jx29/4MqbrsE0rAfyF+8g1DvB60bJbIthWEcEi5m6/FKW/DyLqnCQPLTckBqrmatvuhWb1U5l8W62PnQfCYuXE7KaqMvKYOtTdxO/u4iMVRvYsCufpcE6ukSlERMRTaLBgikqhvO69sP/8ONcf+cdKF4/suw/6jCOAiiKzI9zZzNk8FCmfvMlkY3K4OFQCF2jQGf3gf3IC3jwnyqD5E9aVAoq6+fOYfvipeT07E7OVUPhqqEA1G/ahZS9L9naV9+At6qUUDiETpKIjrTTu2s7Hr7zAZLbdtHCAoAaCkA/AUFnoMUFBTz68FjWzV2KvqzmlInFiXo919wwGqPRSF5VKTv++JWW7XuQmpFL55Rs3h79AE9vW0jV9OkYKmpwyzJ4A1o49B+MYzGcFEXB7fVT6vJpIWkAVyUkxUFNA8RHoQYC0KM3gtFIdVkxnz34AO6y49XDPo3TRskBIAoCer2ExWTEbjMTZzYSI0lISXG8MOElWnXvB4BaVYYweyp4AyjxqXDmUOITU3jwsae48cbbOOvMgazZtPmwxysAlGAId2EFk554gthxT5LZst1fG8bHQFiB2gaQZQLZmViBrWvXULR2LXr16FyfAiBJGumYyWhAr9PolkOhMP5AiGAo/BdSoHBYpq7Bw9vvT6ZpZjOuueFWrIMvRTxn1N42SxbM5qnxj1O7eiPlDS5SFe0aTxQUVcVqiwBADYfxz1mKsW0zdA1uzTNiN4Pbi5KRgjfgJ1BUTqhFFpa+7bDklyN99xtCpA0luzlBRzImNKKlTydPRt25C+EEDLKiIGIxmLl51DXcesdtLPp5HovmLmfqBz/i8rlomZyNoaIAr8fJOjl44N9NFNFF2rG1yqJrdiqf3D+e+MSU/ZqUDzyPe2Z9y+bX3qO8oJxv357EpddegaVlFsri2fjemYznk++RO3TGfoUWuvn67Y+Z66xhbajRy6CTsEbYGdhN86JsnfIJpoICggYDsqAjcXcRF417DUMwiIyAz2qjyavvUC5KKHkF7IqPwXPrTZwz8EIuPfMcZl78B1+9/g6yL3DMuSVhReb3P36nf/MWdG3XltX5heysraVv3z5cev555O/YgS94NHUZxwBRQJAkUtLT8YdD1DvrQVFRgiHWhhVGXD2K+2+9lfQWrclulklaVgaRrTSDZPvyVVw3+Bya1FdRgIIqgMmoI7dZE55/+V1ssRqvC6EguJ0IUZqBrSoKjuQmPPb48+zIu5zqOtepEYsTBSSbmdFXaknEK3etZVdNIWvnV5C60MLZQy8mKi6RF9sN5by4LB51Bdj5/W+IxRUoR5lk/7+AUFghXN2Ac812JKPGdq04FUS3C+KjoKQSJRxEzi/A0A2WL1/Ci7/8TMWplNU4Hb75/wFBEDCZDMRG2WmSHMdZvXowpEMXtq5fxsAb7iQ5ty2qLKPO+AJx81LIToVN2xAnvoUy+zs8ZwzFcOZIYhITuap/P1ybNh9WadeLpr0jeHx889s8/P67+OrHOfs3WrYYqgohOgIEAd/Pi5FaaRLxvy34nchQGEtjP0d6nUaDDofNQmJcJIlxUTTLzKRt204YzVa8NXVMeGsSFdX1BEOh/b4toVCY2noX9z3wME0SUxgw/Ly925696zY+/P57autdeN1e0hVOitJwVXU1wUAAg9FIIC2busgEIu8dhi46HnXTZsKm7fj9LkoKd+OtrKaktIJom4k0ESJzmqKLTsEy9ilMf9LVuGr4hVz742wyOLbZ1R4ICJj0RsbddTd3PTMOgKYtc7ni7jF4KutQ/T5WzVvO6y++gli6A527nlDI/5cPj2jQYUiIxt6hOSPOHUlsvFZiuqu+ArcOWuodJCal8dnVd7Gmy0AuPfdc5uRt5+oLL+Oxp8bTvG1LrHfcTMGGLVgvORtBp2PdnIW8/+lHqA1VRAf9VKAiAAadTqMgB9pfPJq873/C4nLiM5vBYMTmdKH6gyTlF2FrcKEoMrIo4HNEkt+xHfNyEvCp5VwiJPHmHQ8xf8qPFNe5jmscVFWVdc561i1cgBVIA37++Sd+/Pmn/dpFNC7FR9hvK6AKqNJJmgekUcVYleV9gpeSiGQ20a57Fxb/+AsIAr/+/hsrd2wjXFnNrM8+x1VcwA333YtB1LxhN426imcmvg7AxvVrWemuZRMyQbRnwmjQc/M1o7HFJqC46xE3/AKvfQC7iqFvPzDqEIJ+1CdeIbZpDrffdT9rRt+Ay+M76SEcQRTp3ac3uU0yCISCeH79mVBOU0LWCEIr1rJwyd00G3ExOWcNo3dyDl89/io3+u/hp48+g+DRq0D/06EoCri9VBSWs2bR73Q9axh+RUCtcyFbLUj2CMSBQzFfohlxkUYrTvcRhuxP45A4bZT8F4wGHWlJMXRslcX5I4Yx8qo7kAxGuqCVkqmhIOqUtxA3rYa4GLCYYM1WaJGB6DCjW78Qb9vOOOytcIaCKEeh/KaGZYIuL+VOjSdD9vspf2cCUSvWIi1diX5Eb8L9O+Gsd+NeuZlIq+ZW3LZlCw0cvnpmDwQBLCYDSfFRtGyWxpCz+jNs5GWkNWu3r9wXSG7ejIm33k51XQNrZWXvuKMCobBMbb2L4ZdezocffsjFl1wKwPJf5lBUUkFIUVEUlRMTCPkrUusbWDJ7Fv3OGU7y5C/3v76+gzGAtjid7FixDPPaNRTv3kbh1vXkNGlK8wceR5B01FaW4Xe58TpdfPvzTCwcn0ECoNfpibFHcdVNN+xdF66sRRcfjTU+Coii39XnEZmWyg/ff49zzk+s37GF0J/ZVUUB0WSkq81C99wWjOl/AQCFu7bw7fwf6P7DLGY3a0bSzWPo0LwjHVq2IzUzlfx6J9/PmsniefN47+MPOfP8ETjuvIm4ZtoM/qFnnmZrTQkRAR8VjQ+mqijUlFcy8sn7mPLws0Qkp1F77VVYJryC1enCG60jJOkwyx78UVGsGtKPrj/MRjAbwR8gcncBw17+CDHkofLeZ4lvmsX1F1zIE5ufPs47uQ8xaM9dLH8tYU+CI67W0AFGnYTNasEVHYFoMSGIAoo/SNjtRXZ7UcMyRouJ1gnRvDRuHMZGratzBw3j3EFaTlDPli0Zd/+9qDVOfD4//qCf59+exFuffUKfLl34Y9VKAuEgexhvJEGr1ktMSgZAKd6G+MkU2LQLyqvBsATkMLh9hFNeRH/nOIaeexFn9v+Cr6dORznZ01xR5Pw+fQEo2LCS5LWbsJeU44qOxuLx47Fa2P7lx5SuXES7W+8lISqOaa+/y4hdRUz/+deTe25/E7YFwxQ3eBi0fiNdzxoGzVtTZInBmxxL61eewpCkeS0DHg/fTv4Ik9eP6xTaZgJHx7RwmqfkfxA6ScRuNdOyWRpXXHweQy+9DVFn2NegtBDh2/cR1q0Gjw9MJvjkZzDooaAUEuzoHZGoFi20sNvtpkAUj6pETJYVli1bwY7Nm8hu2Ypw5/5smTMHR8fmhCMdeENhfHml1GVkMyBbozHPjk+k8CiuUxJFYqLsnDNkILf/5w4yWnXeu03ZsQlFDqDL7ciIi66kfPp0Zs34hU0e319i27Ki4PH6uOzyKyjZtp3M9HTWbN1G4BTMmlTgwxdfom237pitVsLBIEVbN1JTlEdsYir2hERiUtMxRUTQZuBZtBmoeZWCXi8Gi0Yi5nE2cOHAM2jYnU+eP0C9cmJE5iMkHR0tDrYu3Uhck1TkHXn4n/wcITkdIdGO7oyO6Fun0+6MzrQ7ozO3FN9KZrOc/Y2SRtXoBIOezOh4ACrLi9nyxIP0LyghoagU765itkba6fB4RxRFocEggkFHQHbjCPhY8sG7nHHecFJatwRgx9q1zJo/B1kJs18qnqIg+/wsnfM78y7eyLnte2BLSmJ7+2yiiiqw+IIUZ6di8caxs0ML2ixagzMhhuQtOwlaLSRLAnmtsjBV17Fx5lTOuOUeBvbtz+PqUyfgbmo41POdB0QeZv9EwAG4LSa2JMaQ3Lo5z114CSUWHfkNNezanUfhlq34CsoJ17uwxUbiyEqhW5ceAHy/YCptfCLZg0cA4G2WSnG3NkQs20hDucbTggr1zgZ+nPPbX46voom3/b50AT2GnIuUkquNC5IEkgBOJ1wyGGIdyBs3Q00V+pg47h51HRu/+4F1x3DPjhbbajUZyHBkJDvbtyS6yknzFRsweL34bDZqkhKImjaT5Rs30HT8C7TMaU2/AWecOKOkUSJCS2o7MV0eD2RFwe318e4XX3PtnfdiaZZD7tc/7t1eXljApHff5tPPPsdUUEQkmgfuNI4Pp42SP0FLRLPRoXVzhlw0BlFnQN25CWHOD2Cwwptva/oaehGMJo0oqrwK8sshKwW2lyP3SsDQ6GbfsvVIlWn2QQTaBoI8e+cdfPjrbJr06k/l2Ed47b0X6bhwLVbRQE2rtlwz7jnMNhtb16/jmbffPqpjGPQ6unZqz0tvTkbU6VBVBYq2IEz9AvGHnxFkFeWDjxGz29J+0EDmLVmMMRQmFA4f0EurKAp3Pf74UV/r8WAjsPH33/k0IQG9TsJkNNBBJ6AzGNlt1BEMankxzVu0YkC37rTt0IEBZ55JXHIyoVCIH6d+z/MTJlC8eRuRihbCOBHjoCAIZEt6oi0RlK3aDZeAlJ2BGPSgzp+G6ogivGo9crsMzPdoeTj5m7dj0BkQgr69IZwMRcEeCrMpMYbbOmofRqWqkqxFKxFUFZfNjl5VSFm7CUWWESWJxM5d2LhmG6gqVcDMmTNZnpVFm0suYUTv3rz3wguElb8mTVpUaOrx48kvZcuiJZzbvgct+g1l8+ollCdEsXxwD1KKqwmFAvSa/TsR1U68URGErDaWD+3D8gvOJGHrNiI2C6QsWw63QMt27feFQk4ygjRyXxwCbiBVhOYOKys65vL0LXdwyYBz9mvjCwVZt24lY15+iprYCCr7daJBDRGHAbW8kgWbN+Js05JOydl4osxcKgpUWox8YzWhhEKHvF5V1cKeC36fz91+H3q7A+zR0CwNdpeA0ws6EdbvRHYH0ds0L+i06dNOTVmworBrl0aIFuuIwWu30G7BKhwVVRg9Piy6evLbtWBzTEfCbjfCjq20zGlNbHQ0oqoee1mwKCLoJUS9bm91lSrLKMEwajh8yp6hg0FRVJavXsPoiy9i9JgxdOrRE7PFwvo/FnL/Beczr7qGoApRnFySzQPidE7Jvxt72Eoj7VYGDj4HyWhGLSlEeO4RTWHS5YK8IoiwQZeWUFYDlbXQ4AOHDZqloQoCQUxYJR0uZwO7du0+Ovp3tAe7Adgw6zdeuugixn7xBV0GDqZNj96YLNb92s6dO5fzR46kwek84v5FUSBZJzG8QwdEnQ6loQbh20kI27ZpA0BSDEJRJQS0uXRK125IbXIx16/E4/tr3sPfDVVVCYbChMMyW1FxCl7CorhXWnzxkqUsXrIU0AyG1q1bU1FRQVVV5V4Dq+QEnIcNSAF2qiolOgOXde3M4DHnAaAUl8K8r7VSZmsMcnQipi4apba31sWkF99DJ0l/MYwURebhS6+jV2ZrAKqXLMKoKIiKyro+ncldv4385Biily8gp8cAHjr7Qma/8wmgkVqVAuTnM+O553jtueewHeTclcbjBuqdTHjtDQafMYj2LVpz0W2Ps37RXM7v1puo6DhKK0qoy1rO5ulfIfp9BNtloFOCDFi6kZys1iTdNZqYxkTcqKgo0tPSKCw8Gh/eyYNbEok2mwg1SSK3ZTNatm0PQFV9FTpRwmGPxKw30L1zT3558R1uXTGNO3sMJc6gvXMxNW5S5i4nfmQDJEO63sqO5FiqnG503gCyy4t6AINvD1RVxR8MUVJeTd76VeR07Y182WjEZx6E9DitXH3qPEJdu2J46H4ko4mNK5fz0hef4z4F90dVFFYtX4Esy8THJNC0uBJnXAQml4eiZpnYXR4s9XVsa9UEf/N+XDxQM+jEvHyGoHmyjpZ0XjDokaxm9NER6KMjiEtMZHCbDqz6aQZieSXLfUFEj48kWTkqT/DJwOTvvmfyd99jNBpo3jyX6k2bcMjy3vDcCZJnPQ1OGyX70Ej5bDIaaJndWPkyZwYsWQvRdthZon20UxIgPhbSk2D2clSXCxKiUPNLcDdNIWCJxgrsWL8er//Y6K+3oX3kfpsyBW9cHI9OmrSfQeKsr2faV18x+vbbCYWOjqRKQMCi19P/HK0Sg7LdCEuXaxwoXVqDWQ+ZKQgrV0PrHqQ2b8+Hn0/jP9eO4qPvfjj5se1jhKKqGheKqh5ULVZVVTZs2HBSjh+D5uWKBUKiSJcLhuHI0PIH5B9/hmAQQadDdVagb2JC1687APPf+5GGuvq/eKDyEJAUuPhcTRtn3h8zUX6cQnyEDY/djkVVyevQgqomcWzFRw4QabWj+AJ7E1b/DG/jciD40VRWCYbJ3F3IneecyyezZpOWlUX3oSP3tktOSCF56EiczbL55LM3GZ7djgEDhpKc0nS//oKBABsWLqSsrOzobuJ/QUDYLxB+PAaxqNezIj2Bwb078+j1d9AmRiOHW//KcwirVuNOTKDh9uu5ovUAEpLTeHfItUQbrchymG0/fE1wzmxiGhoonzWTtHad6Z/SksUXX8COqdORCsoRJBH1MK9iMBimtKKWSZPe5IV2ndF37oE6ZQ6CKKE6GwivWIJh4BAAwuEQt95xO75TVdmiqFSVlLJmzSo6d+5K03Mv49u1s9AN7YHDEySiuIxWC9dQl5PN5Wdchtlo4tfffuO5559H4ig/yoKAaNBjTI7D0rwJttZZdO/Rg0mDryDaGsF7PTvxyZefYS8qJ2VLHq7aeiyyetDn90D9C5K4VwYBVFRZOSHaTIFAkPXr1wNHz2Z7GkeG00bJXqh7tTecDTVajLpNB0iIg607wesHgw5cbvDLKE0yCV2cjLx2LYrFQLC0ijp3EPug4QCsXbGCYOjYORTcwC/AL2+9xeRff0UQBOrq6mhoaECWj4+boUISERvdw5TuBqMRdhZD0TwIhcDtA+sKwpKC7qr/YLRYGdilGx99N+24jvtvxp6SZ0EQiA4H+fHnOXQfoXFX+L+dj5TYFKWhWvvIxkQDUL+piKJlK4mqKcccCu5v7qkqSiDI9s2byG3TFqsisWXEEAqLi0nctBPJ78UTZadj94H06nE2ANOn/4DiDx7XwFspK+h355HZqiXDRpzLzVdfQ/eu3XjjyXFsdTl5f+Lb9MhuTeSou2jRKKAWCoeZs2wRX379NXN++pnSgkLtI3CMEAURnSih1+nRSzoEQUBRFALhIGE5jKwqR2egCAKCQYc5JZEX732alPhkFEVh/ftvUlNTTnIwhK2qivzf5jCjpJxzh15BtFGbBMzfvpot+Zvo4PQgCwLW9z+irGc/knr14+Eu5xHeXcXLP/1xRKchKwouj4/vZ/2G4f6xPPnMyxgbJxtChAN9o0EC8NazT7N85epTWs2hBsN88NZbdP6gK537DyY2OZ3Zy+ewIVkkprAMX3w0Y+96ElGnY82G9Yw8fyS+4FEaTYKAqJPQR9mxtckiql8nrh5+Pvc264le0IyI64ZezBJTiJIFf1CtgnXTTrz17sPzoQiajphkNiJZTYgWM0ZUHMEQpf4gisePEggeNanfPxanwzf/bqgqhMPaoDH395lc074HQocecPtY+G4KLFgKrVvAK+9AdjYiYGzcN+RxEyoqIDkxGXNkFMFAgI8+/1wrKzsB2H2M4lcHgoqqGTWN5xaob8BcVgXF5SCI2mzCbEaNi0MYqH1U64oKWfjyywgHMoYEtLiwJCGIwj768z+XV/4/gqqq+EMBfpk9mz21J4HYaPQmG/qKAnDWIIQ0p6/eJlFQW0a1rx5P+K9eNTUU5qV33+G9NybSte9guvYdjKIoVOVtZ9vGlSQkp9KjS38APvriE8a//IomincccNNYVh4IMu3bKUz79rt9GwUBd4OL77/5dq9B8tHbk3j4zdeoKilD9vmPS/cGQBIlrEYzkRYHMfYo0vRGvJIBnxKmxlVHracel99NIBQ8cr0bAQRJZGSP3qTEJxMMBvjxl68Ib15DRL0WHJF1EtkVTvpfPQjQ8qREUSR503b0c/5A8vswe7wYfT5KHrmfmjffpHWrztx5zmVMfO4VvEd4ycGQTFWtk68/+ZK8X2YTmZlOwKznujF30f9M7X0bf+H5zP9hGsFT/f6oKu98/CkVPh+fvPUOTXNacEOOJorIeRAOBRF1OsKhEFdedRU+95EHlvYYmpJOh85qwZKSSGzH1rxxzhUMyO4EQJ6njgxrFJIo8V7/y3lN1fNTfinLG1yIHj9KMHjwD6sgIJoM6GMjMaXEk9wyh1CEibTaetJtMaQ0yeLnhQvZuHQl4QY36kkkpNsjtChJGvO0qmoGqaIoRx3O//+I00bJnxAKh6mpc/HHgkVceaMXndkCI66AM0fAC0/A7Q9CdKM6qKueoNeHPS4BvdVGVG4rADasW8fV117DmjVr/74LOQRUVcUfCBGb3hQAn6JHrKjFqAApMWAxo0Y7UIdfjJTcjHDAz9P/uZGK2hpy0PIv6hv7EnQSosWELsKKLsKGaDKAohB2+5CdbsJunzZz/4cxPgoIR0TvfqwIhIOU11cQ9PsxmEyU2GzE7VqJEBGPkppDVGoyBsDpclFcuAV/fTX1Bwo5KSoff/Ah7Zo0pX2f3uTmtiDWEUlCVi4JWbl7m935zBNseeYFYj1ejl5o4BBQ9/6n8W+V6d9P5fYxY3ht4kR+/vprRt8+VuP4UJTjNkJ1ooTdbKN7i47cfOVlOOtlpLVbQBApszgoqC7Gv3sddTXF/OJuwBPyH7mirgoFDQ0ABEJBdvtqSJFEFEnAFWEnpryKmL5NMMfEAbCwJp9+cZmEEuIJqyoxdQ3Ux0YRVa0SVMMs++Z9Wo/rTKQ9gnvPOpvXNrzKkQSr9uhHuYMh8lwe3CXl1Br0zFpwOc88/CgZWc3YOGMmBbJy6hMn0ZJMp379Da2XLeeB//yHPgMGEJ+aRlxMDDq9AWd9PTecNwLTuvVHpHsjCBpnT3ODkSS9hcroeCxx0bRItdO1U3cG5HRCVRQWLZ/HljkzyPFB7jU3kdAsl1v6nU/RtOkkSiLfGHQowRAHs0pEg56IuCiyW2RgHD6QOTc+ijsc5Nfq3VyY1AK9Ts/T90Fe3i4uGXUlK5YsP+HCeYIABknCZjXhiLBhs5ow6HSEZBmP10+9U9NGC4ZOARne/zBOGyV/QlhWqHd6qFm7na8fHEvn4efQfOAITcTtiRcB8Ofv4Ovv32HuHytZsymPmgYPqelNycrIxCYIfDL1BwJH69I8hdhDFf/Np58w6pbbiL7wWhpqGpB/m4YxKRb6tMe/Yhfmcy8B4MNXJ/DtilW4wwpx/Mkg0evQRztoFRdJMCsVQ6c2jO1+Bo6YeKy+AJ+++TqLVq2msLKOsMv7txsmoiDgQCBN1FEgioQEAVlVCMthFEU5oUaKLIdJz2yCwWQi6PWyfNnvtK+vwauo1HTtxvmjtHs797e5rK8pIhD0HVS/JeTzc/sDDyIY9ehsFpo0z+bmMwdx1tnnkNG8Bfc99ADffPABfX0BWsKJNUoOgknvvceyr79GdTpP2F0TBAGTwURadDLjR19D55u1yiQlEKRh3kbKt7kpa6ii1u+lUFbYLOrZUV9BMHwE75qqoobCrFi5glpnPdERkdya2Yvffl1EQ3Q0ZuoQAn6UEi1LwOV2YnP6IA6SsnJJmfgBDT9Nx/v1p1QlxbLmsnMZ1nfE3u57d+3OO0dhkKlqo+ZUWNE0owSNmfb6O+/+Z3jYFZWC3XmMuevuRjIMAbPJTFpqKsVFRdi8XmI4vEEiCiJGvYGUqERaRcbTyWjBGJeG0q4NXc9qR4vumoekdN5sbPffSydBQJVg7fbtDP7mJ0x6I3J2E9xbd5FUoKdIOIhsgSQi2S00T0sgontbxgw7H4PeQLTewGVpbQFwlhRiSUgmIyOLG0ePZvWadcjeo5dBOBgEQcBk1HOGzUxSagIxTRLJMhmQImzUigIFXj/b80qprPOxfXcBfn/wyA3qgx1T1Zajaf+/gNNGyZ+QpqrYfAFWV9cR9/2PbFy5gkc698XqiAJg2y/f89Wv37Nm43ZMG/Mw1zspD4Yoq6xh+YpVf/PZHzlkWebWe+8lpJMYfeMYHDfdwe60RHymACn6RCKevhdRb8BVVclr739ITb0Lr6LuS2aTRCSbGUtuE9JS40kbOpCHz7+RJHPE3mO0bZLFtU/eT+WSVXh3FaMcB+X4f0MSRXQ6CbGR10BRVGRZQVYOnGugE3VYjCay9Sbi9CZiTRaqRAlf0IfT58LpcxMMh448HHAYqEBhSRGhYBCDxUKgXTPytsnkPjaWPsM1F70sy8yeN5utXjfBw+i3qLKM6pMJBoJUL13Jd4uXM3v8U2wTJfJVLYlvDnDkNVjHjzKnE/MJ7E8nSjjMdjITmqD+iYFKNBqIGtKRqCHQAlAfHkn+0rVMv+E2ir31mlF5uN9NBSUUoqGkgiveepYZdz2JpUs3UpZ3Z0mghuzSUizp6UQN0X6bQDjMpzOm0WlsK+KS0wGI+c89xF10OXlVxdzUogN6nZ6g38+sb7/hjXHjyTvG69acUf/Qr8VevhAVn8fD9m0aX7SXw5dgA+glHTG2KNqlt6RVZjtaxcbT7oz2xAzpgc5i3NvO4vXjqGugOCMVQVZI2rQd2etFslgI9OpO/pK1VDRKYBwIJlEkw2qhvksbHr3sOoY17QCAx9VAWK9j65yZbFwym6ih53B+r3PJat8OyWpG9gc0WocTAL1eIibSTlJWCl075tI6NY5kWcWQEovHbKSuoALrhVeTO+xCnn3iUZ564UX8x6Ck/f8Bp42SP0GPVkFR6gnwc1gmIxBg+vvvMvKmW/hy/KP88etPrA0EKa9poH+dkwxZE1NzceQU1/8EqCr4/EHuuOsuAi4Xt9x9H5lnX7pfm9Ktm3n0wfspKKlE7wuQwr5rFA16zElxDLnkAs47azAjMtpikvRUe50U79pE+zY9SEhtwievvMcbt9/EvJJK/giFjzuOKwoCBoOOCJsFu9WMxWQAQSDS4yXPG6DW68cfDO0Xt9VLOuwmG2kxyaTEp5MUEUeENYKwLFPnqSe/uphdlQVUOWvwBf0nzDApLSvjhRde4KGHH+a2Lybvt+37Kd8zftw4Nm7edOQKtyogKyTLmreqDnDKMqIoogoiLpRT+nE7msoDHZpK6yHbSDqibJE8+cxDtD6rz37blKISxDSt1FiQRDJ6daRn1x5sL9uNx+89oqhRQjCMvbqeZT//xuT2XRk9+AJSzjob4fNXqe/QkgG3PIYhwgHAtvxdvP/O+6TtKCIyN4fixCjuOvtC7InJtE3UKqqWLV/CTXffRWDpCkz/lsTJE4QINDI7l9FManQynTPbMaBHPzpf2wcpQiMuVKtrwWZBMJmIGj4Cvd0O4x/DWVtHXFklrp9nEHnBxYyOzWUajRIAB3q+BWiqk4jNSOeb+54lMUmrqtr52Ufs+PE7ils3w+LxY3P7kNauh17n0iqjmcbkWyceV0L2HoiCgNVsJCMphvOHDOKMm+9CcpUhmGsQRBk1rJBqz8c46CIEUeThJ59h8bJlzJw997iP/W/EaaPkT9i15x+yTIlPpiwQouq+B3nlkcdwqyqiILBTUQiHFWYoKhY0lshTOUM9UdDYWANMuO8BWscl0nfUKDxuF6vmz+fVtyfx2/z5+AMhwmGZHP5E4y2JWGOi2PTLPNLS0vf2t6u8gB8WzSRj1u+UJn5D64fHk26xc9czL7Nq3u+IwRBy+CADyxFAp5OIsJpJSYxmcGIMyWkJiE2TkWQZcXcJ/oJyvqh3ESirZpvHTygsa7NvSwTNk7Lo36YXfbv0JCcrCVUXASI4shz4wwEWLl3B1B+n8vO8Wbh87hMW733q6acZc911RCVpZHo/zZjBI488yrp16445XORCILtdO8b853a8/gBffjuVTRs34Q368AZ9BENBwqdKOfcI0R7NcD+YLpOAgE7U0dtu22uQqLKCsnoj8oKFyI89jpCZiZzdA90D12Ps2oYBA/vw9cwpiKJ40BLwP8MB2Nxe8jfn8dX7kxk9+ALiMnK46OL/EJmZjcFspsHVgM1s5dcvvsRXUMb7776Hy2igOsLGD+9/wvxPvqS6tpa7nxrHjGnTNcFBWcFygu7TvwVJgAkRndVB++gUBqSn0enafkgRJpTCEkIvT0Q3dw7isDPg2WcBsPU/A11hEd5nx7Hp/LPpPvBMACqqKgmUVDVWlR34ePmSyIWdu+w1SOZ89BruBQtJKKsgdcsO8tq1wB9hR79qDQDxjijiExMoKj0x/KuSJBLtsNEjJZ5WXbtijE2CWO2dR5FBVZCG6Pfb54knn2L2vD5/ETw9jdNGyUGhqhAnKwSAgD/4F/ess3H5pwtVi4KI0Ci7rqrqfp4AVVUpUmHAtdfQ6sUX2bFju8Z7otKYZ6EhD232A5pwV+u2bUlLSycUDrO+ZCuhaTPwzptN+7CA2e1C2ryDLaXXk/rOlzjiEyno0oEWM+dhUlVWHss1iALJRj0ZidF07d+Nh8Y+jM6oIyx5UfxO9A0Sbq+XyM8+4rtFK/CVVlHgCWDUGTl/4Fm8+PYb2BPiDtr/Je1yuOSmK5g3fQZnjTwPWT0xA4XP5+PqK6/kyssu49UPP2TJkiXH1Z9BZ2DcSy9x1a1jkBrZL6+69Waqt+/ihSdfYMa8eVQ0VOHya+GofwrqGpeDQdPEE6hz+9gxfznZ/bsSWraV0C13gsGCYLaibtkEtS6Cf3TG2LUNLTq0QBAEjcvkCLDHIBLqXdT9Oo+a0lJikpOJb6XlHOzYuplR143Cu2079R4/SijMVkWFsB/BH2TdvD+IadIERZH/wnlxxPwZ/2BY0AQPd3F4r9bhkA/E6fREGS1kpqXS/u7L0EWYUHYXEug/CLWhDiGzBeK6baivv4pw+x3ajtHRBCJsNHt8PLbIaEprKvg/9s46Poqr/eLfmVnf7GbjHkIgBIfg7t5SCvVCXalSt7f2q7u7u5dSalAciruFQEgg7rJZ35HfHxPS8pa2QKGlbzn9pCQ7d+/cnZ2588xzz3PO9a89R7CsWie5/sbDQlgUeWfLBm4L+LFZrAghGcUg4Y2IwF7XQFNyAvXxMZi3bMEb8GG32EhNTKL4kOXeDgxRFHFG2IjtnE1izoD/2igBEmgqWkUpTQu/x376BfTu25/hAwYwd8nSw9+xdoi6K8fqMuF/4XhQ8juoArL4WYPinwIBAYNkwGI0YTNZMRr0KD0khwmEAwTCQV0yvjnsUNXfFxULATU/d05qqp5KL60tZ+nX7zL4vR+IQsXniECWJMweL4FwiNK6ctJiUzhp+Gjem7t0f7+VQ4DJaKCjy8GQLtlcfu8TuBLSftXGAZzbewg1l57FXmUTltIarAYrl15wXktAonp8UFKKFpDBZEBZtJyg0YnSPQtX7870GTYUo2Q4+CWVg8DsBQuYveDPp2ktJgvvv/cep5x+KgB7l2/EJIgk9ulEbLs23PfykzhmPMAPS35kd+UeaprqDygp/1dDAAqag2Ld1uTXE6NeMqmwUxSoqm0gC8DvBiSoL0UwmkCUUA0ScrMUemRKIqGD4ZP8977CMjVhmd453cjs3ZuY2FgkOcxXc+cS9PjQgs2l2c3DjNc0rLLCXhT+l59p94Xs+xkeNouQCZJEB0VBU1VyBVGvtPqdG1wIgXpJIlaUOOOOKzEnuFCr6vBffiuiIoHFhWKMQJJF+HYeUnNQYjlxIh06tMealoU/HOKa+25jwDeLyG9oYvlvZRQ03ci0vrKKr1cu4sxh4+nWdxjr5sxFMAjUJyUQWVWHz2rGaXFgt9gIy2G2b9t+xMj3oiBgMhqYdt61mOL0uZH3X4OnnoLWqaCJ0CoaocmLbDXROHQs0SmtaJ3263nsOI4HJb8Lld9OOR+rkEQRi9FCTEQUyVEJpEYn4bDoAuON/ibE6mLKG2vZ4K3HEPIf+tKTBhkuXfxLDgaoTYhlybmTaL9oNUn5e4mprKGkUzvmXX42nsa9TI1N4cwho3hUuAtZFA65bFQQwGox0XvEMG58+S2Mv5TaL9sBYSM0VkBqOwzRcVx4z8OsuvYy6hq8OEyRdBiuO59Wv7EQ++vPIviaULsMhuKdaOEgWkwSVSvzcPXujN3pINoVRXl1xbFRBdEMURB4/emnOOX0U1FkmcIHXsa4fhcGyURdfBzOG87ClJXGjY/dhukmI18v+Q5fyI8n4P3TDP/DhSAItBYhaDTiMxl1J15VIywrhMMyYfnnskgNjbASps7TQEZbnbMRECwIsXEYzQKS3QYmCbVNW8jTc22OqEhcgkKTohy0O/Y+7AWoqqHwu+/5L8nYX7WNAez88x5MDhV74ecSX1FANBoR7RaMkQ4kuwVBVhBkGVMgjNLkRfEFdG+aA5xeuvmgSlRcFOk5HdFUlcZHP8Ds8aOmtkEo2oFWsImgIwqcDqyq2uJObm2TBcDVD93Dklk/0KvOTVHg9yustEAQR0Udb8z5ljOHjcfeJgvFCKaAQmXrRMJWM1F79hKb3R2Adbnb8FTXHBE+yb7PO6jvQJLad0GTw/DpCwgvvgZNjVCg6IKb3lQ0QUDt34vYlFaoqsr3SxYfkf3/r+F4UPI/BAEBi9FCclQCXTM6MjCnP53bdyIuKR57lBVJC7LslfdYl7cVQ9kuKhpkHGr4kLxfNFVl4cqVqKpK2/Qses4O4i0sQbUYMMgysiighfy0X7CcZaeOYSrQpUMnkJXDUhQUEDCbjJx88WUYbXbU2nKEj99AWLdCNzHbWQReL1x5CVx/H7FZnRg0cBAbtxbQf8BAbA47QbcXlvyEZnGgZXaHsB8hbw2CAGL+OhytOiO7mzA4HbTOzKS8+thalJNEiZEnnADArifeJParb5ByhiPFpiKu/IbgDYUIrz+KJd7BDc/fTvbHXbj5zlsoLNuLqvz12RJRFLCYTWRYTURFOqhPjMFsNOBs8uH3eNnoDVBb30QgGEZpflqVFYVGXxOiUZ+SnCO6I2c/jlBbixjpRGiVDhs3ovn8AJQVFTF50nj2bt/BO4e7LPbfOiwHwKFbah460tGXTP5u2fJ9AYlktWCMi8LSKhFbVjqm2Ch8JgOKL4CrpBJ/YRnB4gpCNY1ooQMvEyqqQk5fveTXu3MP4XVrUM/4D5YtCxHqa9A0GdUVjycxHfaUYMtMZ+uGDXTOyeH1V1/i3WdeRPH5+f43+v8l2qkaUoObmg16ttdosyNNOYXSqlJafTYLa6OfwiQXjim6fcjSpUt1PtARCNijAUWWSY1PBEAwGFGy+yCZ3wZPADSheT8aofatUTv3BmDDujWUl/+5eeZ4SfC/HYIAotAS0aNqurvuMaTQJ0kS1194EdfdeQdRSQkHbJOYnUHj3a+zZ62KHAqx19sAh8KhUDU2rN/AB7Nncs6kU+h+8lSW33sDMSWVaIrCtqG9ia2ope2SlXTKGQjtYOlPS1GChyl/LgiYjEY65vQBQLnzZoyzvtOl8TNTwGEFuwnmz0e79FqEiFhMRiNpqsrEAfp7RDSM3dughkKIJbsQi7ah+dwIwQCaKxbR20B1bgFJfbsxeMgglq9afujjPIqQRAlPQFeBtda4MUTGYKgtRQr4UJvqEHauJ3jvy2g3TMWYmcyk806hW+9OdOjenfBfHJSIgoDNaiYpLooh2W0ZPGI41ZqbkKRiKq6kvqIGi8fP5ry9lFXW4fEFsKkaKZpKU8DDZZddwW233UbvkUMxpCRBSlJL38bu3dlHF0xOT+fe198k4PHwXlQUqvz3L1UdFKSf1Y9dikq9qhKtqIT5+4MS0CvrTIkxRHTNwtWnMz2GDKRPWhu6yyZyfXVsrq0kuaSeefMXsfqbHwnXNR5Qtl1WFHq217MejTt24PXUEfXh/xGMTcXQrjtqwE8QFY+7mvg0PTt23sWX4Qv5yMvLa+btHFwmoxgYFQixc+V6Nm1cT7fuPRhzxqX6thGTqXr9FWKio4kaqGdNF82brysPHwEkAJqq8fjrrxOTkcbU8y9F6jkAJa0tUu4eCARhUB/UM6ch9OhNfFpbADbOmkWsrByU4N6/DceDkj9ABJBiMVFjs+B1RtBaFNgriaghGcXjQ/H4dGnvvzk4ERDo0b0Hdz/zBJJRn7rVQAitogatpBytuhLj5AnY0hMZf8JISmsrmO91Y1KChA4lza9pqIEgd9zxHyaPGU9GSia5XfqS6w2SHQxQkBzDqnYppJXWc27f4QC89Pobf6IcWMNktmBx6F49is+DwWJGUGTdRDAjWQ9Q4iPRZBUB8Pn92ANB9i5YQOCC87E4IzBPGYm/TMVcuAU1LhnR04BqiySUkEZhdh98azaQ1Lcbw0aM4OHHHj3MsR55COiS1YpXp1NqmR0wLPsJsbwJVd6FULITwdOAlp9PeEUuxkx9gm9qaKSVphMYt6Hzgv4KWCwm0hJj6ZfTjqsfeYHoTF15VvHVEi7fTZ27nPRNm/h6zk8s35BHYXElkk8XD1NUhd11lWR2zkZRZWrrG8Fswh5UiIiKPvD+IiLAKMExHJRkAxKQ57DhdNhwREbQYLPSzucnGAixzRdAcXsRQrJe+vp3QRIxuBxEdGlL0oTBfDD5Ejo3GxcCjPhF07vPvpx58+Zw7qWXUb6n6FcPHKqmMuvHHzn7qitJGD+Szd/8gG/bLiLVeohPgbhU1O6dierTCdFoYPeOPLZs3qgH0Yf48OJDX2b3uj1Mv/JK/nPTTUQlJtCrVx/SOnUn7amXfm7r8bB0wcI/nSURBQHJIBEWBcIGCUWWefzxRxkwaChtsjshvfs53hefQAj4sJw/HTE6FtMv3r9pe+4hLzv+W3A8KPk9SCJ2kwFHrAupdSrmxGgy27fn/zr14sl1y8lbvxFffjHh6gY9Hfg3qpZKksSrL72AZDRSvWwN4Vdn4szdrN+47XbEYADy8jHeeg0ZY7rTZv5yNu3dTlFtGd6g/5CyJZqsULIrn8eefYZ7b7mNgWddxO427QnYLOSYzQQFgV7tumCJjqGqpJiZn3122EGbpkFtXR278/No0zYbpV0nyNsJVjNU1cHeShjQFW1QDph0Oa+qmnrWqQqV33xD95mzGHHuVMr2ViEGPThGTcOauwIl4IdQEJ/NwVqLmZ1LVzDiqvMZPGQwZrOZYDD4ByP7a6ChoWlgidC5NEHBTDg+HVPBVsTqIrTGGgRLBGJVPuYJemp4/rvfcP2dN+NHv8D/ioAkHjABYbuVtq0SmTh+FNGZ7fVsIgKSLQapTQzJQHLOJMZOC7P8u68569JLqQyGyFNUEATG9O5JQrpeap5gbS62/YOa26j4eGqLSo7Z6oKQAEZnBNaMZDokRONKiKW0TQpDolMZ0bkXz3w3iyXfzyVYVo3s9h5x+fODhWgwYIx2Ym+fwUNjT6dzTCpKMEjVru3Y125AysxEzm5HuMlNdGY7Ro0ayz1XX83lN99ywGzJZ1/P4uq5cxk0Zgw9Xn/2d/f9zosvEv4TFWN5ABqUrFjFiaefgWA0kNYqnSsuuoRzTz2VyrIyZs6dy6effEpT458TcZAkkQSzkb4WE6EoB40uJ5IkYZGV/Up87Vfc0PJ7fcEuZn7xCS5PAGLieGPOHPx/ahQcN+T710EUkCxm0uOjierSBs/YASR1bM87OSdhj4zi5FOm8dXaxVz71CM0bNhBoKQK1R/4a754UWhOAYv6shIao4YMo1vvXgAUvvgJmTX1CBYHmFWEhDQ0VSX09UKkqadiSEtm/KUTmbdxMQbJcJBFlftDCys89uBDXH7WVJLS08mZcPKv2uRu3sSEKVMIeA+/aHKfV8/SJYtp0zYbuXtPgjO/wNw1C0qrofdQuHA6WK2INgdNtdUsXroMbzDMJjQimtP/xVs2IBXnEd8hiuTdmxA8DSiigXqDRHnxLlYUbaW8vJykpCQGDhzIgiNQMXOkoKgKscn6mnVoyxoCqe0w796iE0Uzu6J4GxEzWyNGOZG9AX74ZDZx3kaKVYWiv2iMcejigwGnnUED+jFuwjQAhE0rYea70GcgZHdBi0tDiIxBMhgZfNIpdHzycWpWrENuDkpq/T/XaC1f8i1Ov0LnsSftty81FKS4YAet2ndjy7YtNAV9zaU9f9GHPRSIIsGMdIafPAFfZhKjOnQizmLGEhPDqHZ9EAWBscPH8UWf93jqjv+wMqyg+Pz7BfFtgEp0s8SjCcEgYXA5aNuxPRPSmr28HryL3IZyMtdtx+jzI9vMlLVNpe3zr9M5Ip4tZSVkATsP0J8GnHTmmTxxzz1MPvNMXPHxBPwBfB4P4cZG1qzfwOy5c/nu++8pLT8UZtvvoNlSQAvL7N2xk1tuupn3brwJA7DxCHRvkER6ms10jnPRLs5JVGoCgS5ZpJsc1FRW4CvYCc1l5k011fg9HhbP/Y5nXn8Fefde1AY3bvV/o4z8aOF4UHIgCLq3izUpjqfeeod2nTqxTPTQ3xyL3aIvIxgkiVP7jiD2bhfn3ns7Vf4gofLw0bXFbrZgNzjsGBx2+vXpxd7KCiqra9haVUZTbS2OmBgiWyWgVtWiJmZgcFejGs0IBRvB3Ujohjsxv/cSqTntGD9+KMt2rD68sWgafncTo0aP5tRJJyHZrBglCbesoPr9RFRV8/lnn7HH5/t57NK+IIpmEzftoLJLoZDMDz/M4fwLL0XsO4ii/j2JrqvD1rs31uvvQDD8fBq/8vSj7C2p1IXfFIV5s2fTZ+QIOvTrzK6nn8WvhNBUFdFdjxaXjLW6nIQIFybJyOIFizhz6lmMGTPmmApKHE4HdrueKfGuX0akwUFIEDAlZqBGRKO27YHWSV+rbqispbJ0N16/h3hV+V19kCOJPMBuEOnXKo3r//MYBrMFPE1wx52weg188i0kRCFMGo6aHI+SczLG7E5MmXAiy1dvIAggQEGRHkbJoSClH7zN2s4dydu6kZGjJ+LqmkOgqoJ1j95Lv4eeAeCmD1/Rz6tjNCoRTQY+euVVhowafcDtgaZGLI5IRo45gSc+fRtjKIQaCrcQSE3NPyn8BZWAokB/X4DYnQX4QwGsJgv1EtjdfraMHETWT6tptW0not1Oe6u+nJa/ZhWtZAUrsOkAXdbX13Phtdfy0IwZuAwGtiC2GGLKqoKiKiRpGnaOQtDVTGTeyi/EH/8ERFHAbrOQGRNJp6F9OOHsqcQmJeHI7IjRHo0a9LNz0xLWfvMZz731Oj+t3UyD24usKITDCiFZRj62vEmPSRwPSg4EQUSyWXnhwYcYOGgYAJObK/m91ZV8+ckbxKSmMvbEsxnWoQffPvUqZ195Kblzl6AoR87kaT+IApLNiikhmsjObXn4hts4b/AYKspK2FWUT1R0PGu3b2H44GGIrZMJrN+Bfc9mNJMFQVUgKRstRSRgsGIo2IOhQzsaA36C8p8zhtq+cyf/99jjv3o9Hl3bpBNgNYhsdEZgsFvpLIoYNJVNBgOK14/c5EMNhn43Za2oKj/M+ZGG6mpccXE4nn0fJRxCMuqrtLkbV/Hx+6+zaftulq9a1zIRtAbe/vQTbn/6KeK6d2VZcmsiRYlQh76Y2+agGMyY6kvpIBoYbbWRu24rTIUxY8Zw6623HvYxOdKQVQVVURAliX4rviVc18DeR17F+fXXhBwuzMYA5injACjato211UWUB/00/IU3aRkISrpIlNAs7MZHL0BlCXj9evVVWIWP5iBccjLhNUsxZndi6OhxcO/9ABgUlYSGBv13k5naNhlsGdUfafZ8cq+7HGNEFH45hKlNJpLRRDgcYkPejubSzmMvIEEUEG0Wuvbp0/LSGl8VXkEguaKW0nUraSrew0nX3YM9wknE5PGYy2qQGzzIYZ1bEUJ35v5LVKPDMjEeH632FLM73ERnk4Vku4v5GYkkVFZj8QeRDUZcZ0/DIBnIL9nL0rJieghQ+weHf5emQfjAyzOR6GXXu47Qx2iNfmPLR9AF9pqzyaLGn7KRMBuNDHba6d69PVc+9zYmh+vnjZqKaLbSvs9YvOV76b95Ddt27qa8qp5A8M+b7/2bcDwoOQAMRgMvPvMs5552NgCvhYroVuImudaN8ZzzGV5XS37PLqzauZucq26iS1I6s558kfY9e6AcpSUc0WzCFB9FXN+ufHnf4/TM7ABAYnIqick6GU3ObAeAc2AvqlZsxWCPJKJgK5K7Hk3dDaIB04ShGDq0QwmFmfn99wTCwaNio10FIAo0mE0oMS4cbVMxpyZgsVlpk5KGt7GB8l0F+POLCVbUojR5fzfL1OhuYtiokbz17LPkDB3WEpDUFO1l+hWXUVxSQW1DE15/ELm5n0KgY2U11WXlxCUnkTJ5CtY9PgyKjBAOYA6H0eJSSAuHaKcprNuTD0BOTg4Oh4OmpqYjflwOBw0NDbz46KNcftNNGAwGjNEukmacS/iSM4hJS0Iy68dClWU+fu456urKcf8NUvOaplFdXcOOLWvplNMfrc8ghCdegpACThOYjBAMo+4ooqGDGRuQ3S2HhIQECgr30g+YOnIMAEXFheyMjyB5+w78djuaCmpdNbIzktaTT9PblJeQVVhKjTdA3jE45wuiSEJyMq5mT51Pv32b3Q11eJyRDHvzEzwJsSw4/xRyaitIi0nkm1Ov4aSVuSzML0EQ/aAoaPx1NhY5soItGKY2IZk2Bl3byJ8Qh9FTTm18LM7keHYPyuHESbqA3xvffk68L8gyg+GwiOzR6Mt+AkfW3dqEfmOLsNgwGUxECwJxqsp2RSGohgnJoZZS9IPFPhdga5yLlHatMEY0a1xvWAVLFoJcBf2GQo9R2JNaccmN97Nxxy4KiioIBI8Oq+t4SfC/AFmAJAg8/8WXLboQX896j0KpAfOSLXh2FZIUDpJQ34CAysyebVmy+H1mDDuXzIxMxo8YwddfzuKIRyWiiMNmISc+mqnnXUjPzA4EwyHMRtN+zQzNyxgJnbJJeOshvLuLCHz6DfKrryEoCmFJxD6oHwBfvv0huQU7Ccmhw/Zh+cNhm03UJcch9+pIbM8O9O7bh//LHkybZkXWsroqrnnzWeZ+8iX+/BJkt+d3CbGbNm/h1GHDaRXlojQ2ljYRNhqKi/F5PFSEFQKatp8ZnyAIFJssLJ79A6dedgE9zxpN42OzMTQ1ITRUIIR8WMNB4uMy6KapxMbHAuBuaMDv/9M0tCOKq2+/nWfuuINxQ0fw3MJ52JMSW7aFQiHKC/bw4RNP8e3CH3HKISr/hsyBomg0NvmY++1MOuX0hw694OILwKtAVQV4iqCyAaVnf6IG6o68oijSv1sOBYV7KQW8Zt09NjkxlcnlYfI2rCatpJL6uGiCMU60Dh1IHT4WgBs+fh1vnZtA6DDLzY82BIF6j5vaqkpi4hM4ZcxUZl5/IVuG9seoqHidEeTMWcqPO/Zy4fnXYzKZ6N2lK8tmfodoNCNI+o1TUVUURUY5QmaRv4UqVWVlRASzr7sbq9lKbXU5c5Ua1Hat6Dl7MV6LkbSzzsXpisHn9fDTRx8T0eg97IohGV0bpRII/IlxJ6MrOtcDNYJIsdGMy+YkyxVP1/Yd6Z+Rwpb5S3CoKnt9jVS5a2kKeA6pXF4QIMko4Yx0YEmPA0UBgwifvwG7dkGtG35cBpfnow44HSk+jenTr2PW94v0TM2xeH4eozgelPwCMpCYltYSkACYBJEu3/9E+s4i1k4YicEfQtBU/E4H9Ulx7HDFM622itTUDDq3as3XR2FcgkEiHBOJ1DGTs4ZOAGDO8jmIeTvoq9qoe/s1wnfeSecTTgGgocmNw2bH3iYd+21XUNM1i9KHnmavN0xKWKEnUFtVSqPPfdR0LASDhDHKSUTXLNJPGs5rY6fSLWZ/WeXk6Hg+veH/uNkZxcvPvIgaCOrGW7+DAqCgvgGhvgEztLgXx0ILqdOF/rRUg4DZaOLj977k1MsuwJgQgzEhGVZ+j9BYg1C2Ey0uHXNjHfGCgPPC0wFYvGjJEVN7PJJwaxrzFs1nxvkX4IpPYHv+bgryd7Nnzx78oQBhOYxJkQ9bzv/PQlFV6hqbmDnrG86/+FqiElPgxnuaNypoj/0H9T/nYsrSs3xyKMjcL75g9oL5gJ7ZuvG552g7aBAnTp7C4NvuJ6epkZqiAqq3rKc4zsXIXnqZ+ea1K1nw6Vf4G5qQw8eoALymERkIcfot05n/1pdIRiNR/hCJubuRJRGzu4mgxYRcVsKa+iJ6R6VjMFpIjozHZozljBPHUVxZw5KfllPnbcDt9xAIB4+oDcIvUaTBtE7daJWiX6dNjY2cPHwKbZJbI5wxg/qKUqIT9azsjW8+z9Y9pUjB0GFX1u3zD/uzcKMv//iACIudlKhEhvYexMknTGDkuSdhMJuY98xMtq7dQkHVXjYVbSOvvIB6b8MheEQJxAExokjb7B4IzdYdbNgG1dXQ6Id4Jyxahba9FO2WR+nWfwhZ7bKpXrXmCHzKfw+OByW/QCFQWFTEGZNO4ppbbmHggIGMnnAGP65bTaWq4YuNoi4lATEcQjEIdFyygvb9+pDaPQNVVflywfyjEhELkoghykl5t3YYmtfrE9asY2PYR/GX32HxBpjpKUFeMY/u/Ufhcjj59uuvqNm8nXNuu4XYE0YTe8Jogh98TGa/HADiDeJRNW0TTEaMcVFEd8vmwzHTaBuTihIOU/PTIrYtnsuSAV0ZMWgMQ6wJ/Oecy/l63jwK9xlvHcQk1x5d++EHdC0ZLwKioOeo4jQNEYjQNNJlmdZtMwFQ/SGMP30HDRWQvxENESw1CBYbJq8be+/OACycv/CY5E1WNf/seOdtYJ9AerPZYvNg/04bPk3T8PgC7C6q4JMH7+OMa67DnpSMye4ASUK49SEkIBTwM/O9t3jw6afJyy8k+AshKyUsM2XqVF55+inOufBiIhyRRHTKIaNTDr2b26iqytuff4a/oATF4/tbS/F/D5qmEe3348v9uTZl58AetP12AdF7i8lYtxlRlCgeP4JMUa97TlJNDMjM4abrp9NpWF8Airfk8dE7H/Hhl5+zt7IET8BzdJygNY1dM2fx9euvcdLFl5DRtv1+m2OS9VLtD2Z/wTvPvUSguv6YEK3zoPNRzEYzt154ITfedy8RUZH7tRl+8QQ6du7E+rmrsBjNWP1edoYC7FWUg+SZaHQcOZoHP/gIaV9AsnkjFBRDWAajAQIyrMtFPikRYyiEYDWgqurRm0eOlwT/e/Dp7G/4YtECvpw5k5NGjKbtjNv45KtXcCdEYvQHcZXq3ihJFRWc2Fp3hXz+/bfZmbvjqJFcRaMBg9VCgxIiwWAizhFDlw+/w9rooSYtkfRNeSyuqaZ7f93ye8OObXzy8EPs2rSZ0669mm6DBtJn6pkA5G/bxi3PP3/Ulm0QBUSzEWNMJBP6DaRtbCqy30/uVRcjr1+Py2im+94C1Bfeoeq194iPS+LBi6/knCWrcaCnYj1A3e/sohG9BFUSRMKSAbtkRBJFNKBJDiHKMiZNof+I4Tz4tl6pIZdWofqbEKrKEAQDggiktkdLzECrLsTaWZ+EF8ybf3SOyxGG9ov/HysIhxVqGzw8+dHH5H3/DTfN/Jbkzt1atq9dOIcHHn2ANRu2UdfgIXSALEfYH+Ci6Vfwyq230qtnD3oMG0ZGn74IksjevXv55JWX2bZ5C9mBEHnan3e1PWpQNUpCMhENTdQ01BHrisaUnIQnwkoMoEgSUjBMh4uvJCYyFo/XQ2NhPffeeA2thvTQS1uBtC7Z3Pz4PZw+7TROPnEKRdVhGsL+o8MFUxQuvfQyZr36CuPHjaPAJPFF/nZ8SpgerdqShpGn33uHQE29ntU8Rk4/QRCwGs1MmDiRiKhI1LCMWlCMunYDhuGDkZLjSB7ZjvjeqUS8bkYr2Um4qYaycJCg/NvZWQuQBOzR4Ixp57UEJGpVJcIl00CUEE7oB74g7ChAS03Al5BElNWGHA6Tl5d3nOR6iDgelBwImobqC3DNjBkM+2kFbaMSuWzSFWxcs5ANvTJRFR9Co4/Ow6fgiIxi954C/nPHHfpT/tGAqpHU5OWq1j1IMEfg9bgpWLkEi9lA0OEgNa+QpMISfjplNAE5jMVgZP3C+XjDQR7//BMe/PwTpk2dyiuvvsrKxYuZfNZZNDY2HpWhtgbiVI0aDdx2K30T9Ker0kU/oq1ei0WR2dmhDVnrcmmymil++D7in3iRE4eNpmdUFO6qOjT0dOzvBSXlgoDZYCLeHkmsI4aYiCjsZiuKqqL6GtnrbSS1roLWnTu2vKd+/nLs+WsRGqtB1FDi0lGze6EEvAQmnoRLkijemU/BnoLjE8mfQDAUpqC+idc9fjIffYz+p51GQ1MTe9et48vXX6EqrFIZCuvaJL8BTdXw1jcyZ95Cvl20mCJJn6pSZBlFUclAT9ubOIaDEk2jMRTGW1nPvFUrOHPsCYxyZuA58RQsUSupXjqf5YN7cH1PnedlFESu+8/VGMxGNEXF99xM5CYNx/UnIjpsxMTHMz6+FVu8jfzoCR+VTGdh87g/XLOOD9euI8JowC6JlEgS29U5aLKiE9KPoeyUBcjUQDFayNuxlz5jIbx9N6EH3sGwZg5KbQmG9z/GeNJwDE4b3Xtksnp+FkJDFSaPm+DvyAumoZ9fZk3jkhnX8HVma9p36owQG0dw3ASMs2ciVtVBTBTalVch9+iDKVbXRsrfsgm3x3dUgsf/ZRwPSn4Dmqxgy93Bg1dfyR3PvUBsdByjxp5O6+Q2/GiZQ15TPY8PGgnApddejae69qhdqJqiYm9o4oycQQD49hZSlhCDFBOF0eMlZeduIqtraJ+QQXMxJg5HJCFVY58u6XsffMAnn31GKHR09T0j0PkdeQIYZIX4WJ2QqezKQ9A0gpJI8p5idndqiy0cYnnHOLLcDTidLsZMPoW3HnmMOk37Xc0CgeaAxBlLp9R2nDXpJNLbtsMiSKRnxhHXsxPfPvoi77z6Kmu27+CS5vclXHY66mmj8Q2ZgCpGoHQbjLBnKz4VhPP0ktp58xcQksPHJ5I/CUVR8aphnnr/A1768CN2iyJmRSFB0wgeZHZj675fZBWan2aLASdwbLkT/Q4UFcXr54fZ33Dm2BNo1V/3X+HUcwh98yX1sz5uaWq26Us4mqIQfO87WLAIY30N2gnZ0KsbgZogCQmtKK3ag9HfRFiWj1q2MwDEatA/JFPMb7gkC/v+p/2tGRMnur9VpCgR9uoznmQxgs0FooZqtGEY+HO2rqmgEUNUPEaLhe5olNAcjB0Au9HlDQLA7j176de/L9++/TYDp5yG5d5HCfTqS6ixCvuEU5Gi41p0ZUJ+P5dfe+1+Cq9HGv+r1TeHrCmzZMkSJk6cSHJyMoIg8NVXX+23/fzzz2+pDd/3M27cuP3a1NXVMXXqVJxOJy6Xi4suugiPZ//b0ObNmxk8eDAWi4W0tDQeffTI+5EIgoDY/CMIv9Y1lWWVLz/6mFY5XXniuacAaNOlJ5dfcTuP3fAQkmRgwZwfWDjnxyNm8HQgaIrCHn+QL77+HIDo9p1JnjiRbhMmUXXKBJadNZ7gudPoe+PdGA1GVq1dxY/LfqJJUfZT6D7aAQnomgrrAY+iorg9pFn1td0aTz3bRvTDLMvYPH7MwRANsU7iPGEczeV1ksHEHkHATbNj6W/AIEm4bE76d+nN8++8zDn3zmDoORPoO20sSQN6YDCbOemOaxl17iXs2F3GukVLcNfV61of0VEUXXoztaPGomVHIU4/k4h7r8Q1QOfazP7++8Mn/4oicZKIy2xEtFkQrWYEo4FWQOofvvnvh/ALXQfhsHR+94emaRRqkKuohMIyTapGvvbnyz//qhLZIwUtLPPlRx+zZuEC1q9bw6I536EoCh1OnMJ9r326X9vQwuV4zr0T+aPZ0FCJsGcbysxZAMR1TeWEM8djtEViFUSOwFf0u7Cgf1f7qQILAoJBorXJQCeLGYPTjsER0XKuc4B59E9BFBEMEoLJiGA2IhgkEPffRxVQKog0iCLdcnQSdXjjTsT8DWiOOHBFo9U3tLRPu3Ak3fq2J4BIQBSp/Z3dq8A+L19V1fD6gpx88cW899ZrAFgmnoJz2nSk6DiaGuuY+fZLPH391VyQ041VK1Yef7g5DBxypsTr9dKtWzcuvPBCpkyZcsA248aN46233mr529xc5rcPU6dOpby8nB9//JFwOMwFF1zApZdeyocffgiA2+1mzJgxjBo1ipdffpktW7Zw4YUX4nK5uPTSSw91yPtBFAQMBgmT0YDVYsIgSUSpCkFFozwYIhSSUZr1AXYBhGSEolJuue0OPvlyJlefcx4nnjyZqOhogoEAl117LVrwKNMLFZU6j5+rHn2E6A4dmNRvKKMG6hVC2XKI2Wt+pG2qLgv9+dxvOH/6dHx1DbTX9IvqqCtB/gL7llzEYJhQVR3pzigAsk47F/s9/8HnjKAiMx13TCSeCCP9xpyCIIrk7tjO/c8/94ckVwEBi9HC0PRM3vjsDeyx0aghmfCWIgQlDE0e6JCFKdnJZXdfTd/eHako3MtFl1zBY888yegJY2h70VhM9l8bqgQDAeYtmHfoAkuiiGg2IkXYSLEYESIdFDjtaGEZudFLXFUtgUCIkoMk8f6VEAQBgyjhECRaSQYEo4FiwUBYkQnKQUJyGFVVjx7/6K/CvpubQXfoRdOzoWooRHZzoHQ0pb+NdQ1MGTGSjpJArcFIjwsv4NUXXwYgb9NmVL9Mh349MA0fQPjbjWCPgdICNOMu5K8Wo2XOwnzRJDJPPwHpyadRpKOf5C5p/mmBKCJZzRhcDmwOG84IK5FxUWiyQrjOTWJFDfY6N7uDIZr+5HkuSBKixUhEbAya1YRi0J+fVX8QucmL1e0lIRhiV/NuUjWVtgEv0bH6Q5B/bymm8t0IYS+C0ULgzEuRzjgTYexwTF3b0P3EQXiffpRcDk1JVlYU6t0errrmWr79+mumn3s+7dp34Ls53/L6u2/iKa+mzu2hxh8idDwgOSwc8pk9fvx4xo8f/7ttzGYziYmJB9yWm5vLDz/8wJo1a+jVS/dqee6555gwYQKPP/44ycnJfPDBB4RCId58801MJhOdOnVi48aNPPnkk78ZlASDwf1M1NzuXz9PSaKI1WoiJtJBYpyLlIRo2rXvwBUXXUNMegbXzLiCb7/9gXq3l1Ao3DINa2EZJSyzZvEyzl28DOP0Kxg7bBiVVVXk5x3I9eHIQw0ECZZUctHFF9P6ky/o2uyvYDSYmNJfD1BkOcxNN9+CvbQSbyhMPX+dO+yvxhuWCVXXs3LlcoYMHkZUVnvMjz7FJ0/9hyaHjb2tEohu05mcDj2RFZkLZlxDsMnzh0RhQQC72co5p5+KPTYapa4R//1vIOzag2AwoqZmwzNvI951CYZeXel5sp6lW7lmNbvWr2X0hDGY7DaUcJiNq9exYdNmivYU0jk7i4Xz59PkPUSxa0FAslkwJ8VibZvGqSdN5vpzL6e4tpKvCrfx3U+LKNuSR+n6rUglVSi+o6T4exgQBRGL0UyUJYJBFhtZJit1zhhSLXZyenZixAnD+c99D7J68wZC4aOnZ3NUsc+awW7D4Iog3mFDNBrxWq3cOflM5n37DduX/kRCSP7NFP6RQB0QA2xUNBxKiNdefoXt6zaQEgyya08pme368P6cj7BEOVETUxF3zUdc+71ux+DxEn7zfQxnjkWyWzB1aI+afyBR96OI5vN80qQTCToMbI+344h10V9WqbOaqKp3Y9y4C+PWfEJl1dB0+MaCgiTRtksnbv/P7UybNIVgOMyi3dv5Yf1PzFq3En9BKSm5hcSXVxPhC1KKrh6dHAzgb2g2VmiVgGyzYapzo1kNCBVlyK+/RSA+jZiubQiEQ9R66g7LBFBRVJq8fj6f/R1LZ39HkiSyHVARaBsK4wTKDuuTHwccJU7JokWLiI+PJyoqihEjRnD//fcTExMDwIoVK3C5XC0BCcCoUaMQRZFVq1YxefJkVqxYwZAhQzCZfhYHGzt2LI888gj19fVERUX9ap8PPfQQ995772+OSRDA2myr3rV9Bpefcz69Bo4kIjWjpc2Lr7zF7TdeyUefzqS63k34vysDmm8m4VCIb+bOPZxDc/hQNRRfgPrdRfQeOZyeZhPL95YDkL87nzVrVvHj9z9g3b4Ta1imip/Tjn8LVBXFG2D0qafQYdgAvn/5LZJS0uhx6U3sXrucMqvI9M665sRzr7/KmiXLDkobJEbT6KRBsPnUVYsrkBbPQ41OQAgGEfZuRUAgOOMeAldcQMTZEwGYOW8BlTUVoCoU5u5g8w8/sNTnQ1VVFFVBOcxsgGAyYEqIxtGzPdOmTeWWcVMxSBLtbJncnJbJzUP0/a/dtJ7BJ09ELatu8TX5u2E2mkh0xZGVmMm0UybR7/STKNxYiCpK9D5lMKIkMat/P04ceyJrt2wgpBwb4z5oCAKixYQpLgpLRjJJ3dozNjWN3JoyTphwGlcNm8hFl1/JaRedw/ezvoVA8KhmsvbJqFcBaPDT6tX0AGSrA80iYolyoqkqSkEB0to50NSAZjCiWewEIqKQ91Ti6tSK3u3SeSsU/EuDW8FkoN/IoXzx/icATNj0BZFmA1EeP+MikxHtTpSxtRSsWkvuq28i7yo+vABcFLl++uU8/ORTGIx6pYvBYOSEzr04oXMvovt157PF86hJjsO3bCPGPaU0+JqpqprMc6++yUujRxB9xok0hIM0ffwDYkjFtO0ngiYJ5zC97P/jj7+g3tuIfJhLtZqmBydlQNkv5q1qfn/p+YjieEnwwWHcuHFMmTKF1q1bs3v3bm6//XbGjx/PihUrkCSJiooK4uPj9x+EwUB0dDQVFfpttKKigtatW+/XJiEhoWXbgYKS2267jeuvv77lb7fbTVqaLgLkBNpoYHXYyOjYmptvupVugye0tFUq8lE9AUxtO/Poky/TpVsvbrn9P1TX1B9bVRiqhhoIEQ43skkUuO2iC+jVPYcr776Lap8fVZZxKiquv3uczdDCMuEGN9sXLGPGf27nkxdepVu7znRr15l9C38FO/O48/Y7dP+bgzjWAQQ0QaBm8zYApHYZhGISoDgXVbRAVRHEp4FkIpy/R9/Hpm1UlJdT723gyrvvOnIfUNQ9kqLaZ/LezfcwIqc/AMUFO8gt3U12RntapbUBIDYhDmtGMrLbQ2Jd+IgJRx0uDKJE387dOXPSafTv35+uo/Wxx7bPbGkj+wJExcfxwRuvkDN4GLLffWxdD38AwSBhjHUR0aUtw0+ZxCunXkKUI5IybwMOkwUAq9XKJy+/SatNPagvKP5D8b4jjQ2AVQkzuYfOhfDsLqbS6iAxuQ1Gdx1CVBSKIhAe3JPobJ2ZFAj7iVLCf53TrKSf59POOrvlpe+6nfLrdslAj5HsKitn7hsfoAZDh2xQKhgkzpg6FYPRSG7RLhatn8/WCYO5tEimW9tu3JjZjz02jQ1OO7VhmdomL+FwLYRlKlWFD7+dxZRPvmD0GafgmnYK8pQJNK7diiRcgrNtayxJCXiqqnjl9VfwBn1HXCW36oj29gc4HpQcHM4888yW37t06ULXrl1p06YNixYtYuTIkUd6dy0wm82/4q7sgw8w2CzEpSVw2YUX0nWgntLXvvoEqgsQFy5A9IVQrrwNafQ4zrt4OnZN4JyrryFwtPkihwFNUfAp8OabbzOTt/Hzc3T+d9/s/htaSCampoGtL73GSdt20GfcOIbm9CClVQZ527dx7vQr8NY3HPQF4xUE8tHYvS0X2efHYLMi2kGrLIf6MjBYEOxOVKuNQJGeRI3NSENWlT8kne0jeBo1jRRgjyCgadpvZlB01VoHV19yaUtAsmLHWtx334OqKayLiSbx/57CHBfP4sZi7B0yCBRX4Gxowq5qf9v3JAgCI0eM4uuvv8JktbS8HlqRi5TkQrQbCc9ZQs2avSQ8cgUZPbpz5gkn8dbMT35X0+GYgqgvN9jbteK6G2/g5iEnYRB1XkKy3QWAu64aTZKIjIxm9KmT+fKVNwnLjUfX6fu/oAHBcAhJ0PfpyGpF1qPn0/hhJErViURcdxmCKOJobr/oi6+Y98QTlB3t4FASESQJwSghmk0405M4c9wJv9m82NtAstWBJEpcOvk0Fn71DXJD06EdS0FAspmJjNWz6qvWL0TZuRMX8JHNRqZgw9Emi3dSh7FkeCozPAG8eXuQGzwosoKqaXgCPk4+9xxO+vRTnnnmSeJTU4gZ0rtlF976eq48/yL2lBUdNTXr4/hzOOpsqczMTGJjY8nPz2fkyJEkJiZSVbV/PCnLMnV1dS08lMTERCorK/drs+/v3+Kq/B40UaQkwsqlp53GkJPP119buQjh3ZegshYKyyA5DnHBh/irCrFOnc6QE0/CdP31BIPhYzbA3KfweawjACRqsHDxUmYvWfrzhsM4sBoaTeEQK5QwFXmFpOZ0hDGjYNkiBKMZTVVQm+oRpp5B5LlnAOCMdBITG01j0YHDAAEBgyRhNpixmiy008CDRmtVoSkcwBIOU3SApKwgiVhckZw/Qp+sPy7eyJ51S0jMSid9RyHG6DjMcfEoqsL71iZ6yAp7jAYqTEYa/uIn8l+iT+8+fPHlZ5isFjx5BRiKSuHzr5FrQPR7YO33CGYHtgGT8K/YSMTwvvTu1YsPZs9s9ko69iGIIsbICD74v4cZN0BfJswt3I60LZeQ3Y6xspLq1T+h3XgdgyOjGT1iJF9/+jlyo+ewghKhOYA9HCiaykMvvkD/AQMYfdopiJJE1Dmn/qpdad5OLj/nHMLh4NH7DgQB0WREirBiiIzA4HKQ0iqd5266A1eknqFe/8V7WF99k+JYJ4Mffg5rWjppzYEewMCsThgibHqlzKFAFBDNZkzNHl6956/GvXkT/sXrUS0WyhpeI/Gm24gcN4Eh8W15c9LF3PnZPNYZJcqb/WVUTcUfCvD5rC8p3b2Lb+b/iN/r5eUHH6Gkqoov5s/D7XEfsiHfsQiBQyvAOsrFWkcMRz0oKSkpoba2lqQkXVCmf//+NDQ0sG7dOnr27AnAggULUFWVvn37trS54447CIfDGJvXFX/88Ueys7MPuHTzRxBFAbPJSJdu+v60ogKE0E7wB6GyDqKc0DoFwSChxiiocpj4pGRat27Nlq25x8u6/iRi0HUlkgDPnzyUmqbhDwcQakpZ/91cUnM6Ypx6MmFkQt8vRNqwGnXSZJwP3NbynnWLl1JWeWCGjSiIWExmomyRxEfGkhgZT2xEJA5fE/lyiNZluwk21fORKuv6Jc23AxPQWtPokdOTRIeLoM/D+rz1KInxZK7ciKHJQ8SSn5AVGYNk4KWYXnzVZyu5q7dSK0n8XW4tycnJzPn+O+wOB9Wr11F6y+Ok+7yY/V7EzC7QUAlRyWiqjKipCIqeXRCsNgyS9Kduvn8lBEmia/fuLQHJ7E2Lcb/3Pqoo4qqpoynCjDmkEP/9j3BRB8Z2yiHTakUSYNNBGqhJoojBICJJEmJzKaysKMiyzlM6lMMUCAW57PTTyIhPImf0KO578TksERE8ft+jlBQXM6BHF956/z3yg76jd+4I6BychGhiOrShXa8eXHbyaUzu2g+TwYCsKry74GPav/wiUlUDPdt3wpqW/qtuqhtq6ZDRmrXbC3Qy30EeCEnTSEbDG9DNMG0GE0JFLXKmjcq4aFAV9r78BJZNqxh40110j03l4lPPpnHlzZT/4o6roSErMnWbNjC6dWs2BYO0C4WQgQaEfyZh+1+EQw5KPB4P+fn5LX8XFhayceNGoqOjiY6O5t577+WUU04hMTGR3bt3c/PNN9O2bVvGjtWdPTt06MC4ceO45JJLePnllwmHw1x11VWceeaZJCcnA3D22Wdz7733ctFFF3HLLbewdetWnnnmGZ566qnD/qACkJio96/mrUR64UNYuw0MBkhPgIpqsJkRsqoI+b1YHC6cTucx6YHyT8NuoE3zv0cCITlMkaeBzz94j4Hnnk5MWjKG6edhnX4eoUYPpkjddn3FZ7N45J7/48f8XIKh4K/6EQQBq8lCanQS2Ult6JDclt69+zLp5jMQRJHa3cV89+iLbFw8j7jGKqrdtS3LF/GAqijUFu1FVRXMtgimLNhC4/ateFwOEnYX4aqswfPZJ7jOnEpbewynjz+N/3vhtb/1pt4zO5vI6GgANKsF1eFCbKhFMNlQA16EgBeUMFqnIQhhf0t+SJKkZu2Sf8gFIUBBeQmKoiBJElWrfqLd5lzqkuKJqKmjMaEDzqJ8vKuXw0XXkBKbwJ1nnM0Hd93LH9W1iIKAyWTA5bAT7YrAGWHDYjYiywpur5/6Rg/1bi9+f+iQnsgL0SiuKmPZxx+yZv584iMj+WHPHqLkMB++IVMHR/WGKhiNWJPi+OS11zlhxNj9tpXs2cnu998kLPjZOHEMg3/aTMwzzwOgej0E5s3DetIkBEEgO60NC159j449e7K3afdBjzhLA1WRKWtqoBNQ07MrTbt3UJKdhUlVKGvTiuT8vdi75yCJEqqqsnzrJvJMRuDXrt71QHVTEw7ABqzh6B6/vxyadmhE4n/AwwQchnja2rVrycnJISdHF5u6/vrrycnJ4a677kKSJDZv3sxJJ51Eu3btuOiii+jZsydLly7dj+/xwQcf0L59e0aOHMmECRMYNGgQr776asv2yMhI5s6dS2FhIT179uSGG27grrvuOmyNEk3TCIVlRENzNU9OH+ieBfExkBoLmggp8VBbj/rVkpZSNkEQ/ynf4zGPIxWQAKiaSnHYz1eFOxk6eAT33XAnuT+tRpHlloAE4JEZ17Jn51YC4cABJyOjaCDWEU33Vp0Y1XkwE3qNZuJlJ2GwmJFMRuI7ZHLmY3eSNngS2UltcFodGEQ9JV0CFGgaS3bl89GKhQB0Ov0c0nblY5LD1LdKIWg1Edq8sWV/81cuQXYf3vLAkcLshQu5cOpUfG438V06kX3vFcgmE9QUIxTv1FWJ41IR3JWEo5ORmi8ZU8DXwsvpAXT62z7BH8MEoKh43R7yigoAaJ/Rjpq0RNovW0Pc3hIstQ046+vZ1rktgeaqIoPVTsMf5LjTgN5GiVED+jCkbxcmj+7LeVOGcdFpI7lw0mBOG9uPYX0707ZVEg67BUk8tClWBsKKzNKKUr7I24436MOhhInmt7lNRwSiiCHCxtvPPtcSkKhymL27tvL82u/4/Ot3YcVKIt1+um3Jp+MrP+tQCf4Axrr6/QQorQ4nkwYPRxIPfglnj6ahhjXcVTUAeDLTSNpZSM85C6lLiKbjivWASsf+wwB4dtMivl+1nHRv4IDlx2Xoy9uRQBbQ8VctjuNYxCFnSoYNG/a7T3pz5sz5wz6io6NbhNJ+C127dmXp0qW/2+ZgoagavkCI/LwdpHXqihTbFu3mxxDO2QRL50FhKSTEENpRDMMmYXHpT5LuJs8/IlX9b4SiqniDPnaX7eXpV57nlbdeJyY6hmGjhjPt7NMpKShgTk0FwV8sufwSAgImo4nEyHg6pWbTJa0DPU4diCnBhVrnJvjUh5ivPh1LfDTnXHcuhbcUU1JXTtMvHFoVFUS3l5fff4epA0fh6N6DpsmTkHbmUtY6heq+3TnxvocB+Cx3Dc88+xQptW7y/8agBODtDz9iV8EefvjhO+w5XVCuvZDQE29iVENoGV0QUFCMNhSTiqW//vDxxZwfCTcfyxqOYb8ZdAdpRVXJ9/n5YOUiHmidRds+Q/C/8CKSqrGnfVtEg4QQDDEqZMYiGWny+3j+3bdY/QeZIE0Sufmhh5hy/Y2oioyvsQq81cj1e1C35xJx0VkoFhuVJcVcdOVlrF6/Fa8/8Kcebio5+sdbMIi07tCOU084GVVVWfnM/ZTnbiV3xEAiq2pJ3l6IEJLpNvcnDDY7vzxGwp49GC+44Fd9lpfXYjGa8RwkoTQAFITDtIrTKy1tNhdKUjxaSTkpm3LJz2lHY1IiHUI+UnBhLKnCX92I8AfX024gyF9YqnscfwqHnCn5J0LTNHz+IFfffgubZup19oLNBW2GonUeieIN0ehyId/yIBFTzgJg8UcfsmXr1t/p9Tj+bqiaSiAcoMHnprKxmtw9ebz4+sv0Hz6cUy68gEAo+JtPl6IgYDVaSHTFkRmXTqdB2UR0itN9Ry6fgbZkOeFb70cLhYnv3oYrb7qUWEc0ZoPp5ydCVUX2+Fg3ZyG7du0AoO/9T5M+42YCdguh5GQESaKqtJir7roNYWcRkV4vQvP+D1aRW2j+TzxC8u/paLhXruDq6dcC4Dx7Cg3dOlCf1gGPzUmgrooGlw3rnRcjGg3kr9/M4hXLWnRKivjrxaEEAYwGCZvVjMNuxWG3YrOaMRkNLXyOfWgAKhUVpdHLgjm6nlCCK57kTl1QBLA0NRBZVoKSnk72xVcD8OLH77GsuISg/NtW84Ig0G/8OE6eoUsPiJKBiOhkItK64eo8kagJF2BKboU1Oo6Mrj146uHHiXZFYJAOkfD5X6jj6FfUCZJEcobOD6nzNuJZtpSUXUUkbtlJ9+8W4Gx0E+HxYm104ywpRf7xFzpNzZpTmseD/KP+IBnyBwlV+3BY7IjCwd1mLIAaDBFp12uN+nYfSOeFq8j45geiJ51Mg81C2smnkRKbrC/dLFrMnvpGNit/HOSX8D8oaKYdxs8/AP8aQ75wWKakvJob77iNE7dvZMiIYeT0H4vQaxj+kIaldRbmpFRUVeW+C89j1nsfoBxjkuDHcWComnrImleCIGCQDNjNNnqP6UHcOF1UKfzoU6g/zkWQJJS9UQTufBrrIzfRfkQfkhOTyC3bhfALspwWlglW1jL4lJN5+P4HOP+kU+g8YCSdB/xc/l66cyfe9Tuo9PrwGo04DRICYArLxIVldijqAcmLAgKSKGE0GEhEIFaA7aqGrKnIqoKqKoc9zyhofPblZ5zy+cmccOrJ2G+4hE1PvEeKTSVh0pkkjx2GIdJJfVkFl11yOW5/E4r692R4JEnEYjYR44ogyhmBzWpGEMDrDxJd20i5109+IIzcfHPa59Ui+AMEin4mOHd88BnWaiJ1uesI2iwMue9xLJEudhTs4pFHH0Vxe9F+5zNKosD0Cy9CFEXC7gaUT17AMnkcBCIhtS2CU3/C1wrzEFpn06nPAOKindTWNx1VY7YjAkHA6dQl2gOKzPpxg+i4eB0dVqylKSaailbJYDYT6NSJjrKIcfDQX3WhDB+Het6lMHow7vwSou0urCYroiD84fWZhb7sZlNUHpo4kY5XXcHICePJad8JR3ZHBmd3pMfISdhjYgGY8eh9fP7hZyhNvsNWjj2OYxP/mqBEBfyKyqZQmNqVy1jqreSskIdThp5CRDNDH2Dx7Fk88/EnhI4HJP/TaA4p0DSNjBG6g6jy1TcoTz6HGBWHVlMC5fUo335L+OLTMGZl0HNAb+avW7J/9kXTUP1BqnYWcOkFF/L+qA949b6HyGyXDUDQ5+O6hx7A5PbS3WYhwmmnKjKCjGAI1eOjzBvA5wtQEgjtd+MSBRGz0YTT6iDa7qKtKBGjqiiSREPQS6OvCU/Au19F0MFin+OrFA5w4+23MmLcKOI6tWPUm/ft165qVz7TTj6Nyp3b/zY1V4NBwmG3kpIQTdfsVrROjSc6yoEoCNQ2NKFuzmd7VR1VlXW4m3zIv7hBabLC5pVrGH7yCdwy4zrGDRtFt3seYs57zzMpZyDJbdrjaXIz7ZILaCwqQw2Ff/dpUhRF3nzndQaMHInF6UJK7wIXzACLGe55HCw2mPkhghqAmx8m1NSIw27905mSvwSqhq/ZFDUuwkX3Gj/tFq9G1DR29onE7vahGAzYMzKIvP3/EP6LK6NVVhPetQtDuAmAUHUDZqP5oDk15ejVeVHA3sJCdt10M6/eczdxbVozYupUbrvsqpaA5I5HHuClR59A8frRwsfyQuLRxfGS4H84BJMBMToSstLxdcmCvj3p131Iy/a6+lqCgQCf/fAtbkH420o2jxZMQGv0i/9YElf726BphBWZpoCHUIMbk9NOaHkumqKgCkYk0YCmBREaqgjN+RFj1iX0790NWT3AJKhpaMEw4bDCgq9mk/XN93Tr0pVrzzmHmd/MZsemTWSlxNM1NY7EjCQiop1EVjdQFZLJrW0kUFKJd0859Y0ewrKCJIhYzVYSIuPISmhN96xODBnUi915ZSSWlVFeX0VhdRGF1UVUuWsP25dGUVV25u9iyOChvPDsM/QZPIjG+nq+++Z7vvjsC+YvmEc/r/tvy/yKokCEzUJmWgJD+3fn1AljiVG8OIIehJhYarQwuzplom7aRemKLeTvKcft8f9c8aJpqMEQS+bMY+O69ZRv34nF4eCOi29s2ceXzz2Hb8Ua1ODBmSUmrFjBT68+wcgb/w+hazfYtQeCMtw4HarqwGmFvn0AkCwWohWNbEWhGP3aO1ahKQorVqxg7fZN9OrYjYFX3ELFrDkIxSVEVdVSlpWOwwNRo8YgiCJKOIzULNcAoMydj2q2Q6Tu+B0Oy2gBH+mhAKWq+oecGA+6DP8udEdtUdXo0OSjZvN2Hsq/nxeefZ7Jo0ajBYK8/cUXOln8f0Br5E/huKLrPxe68qaTiO5ZxIwbyLCRI3g4ayiR4s/eOtFRMazcsYn6aDuSy4Fa0/C3VkkcMTRbjUcZJIyiSILVSkZWG1qnpNMhNZWy1WvYvnw5m/n7zPv+DqiaRpavCVNDBbbkOABC69dgsEUiRDhRk4YQdsYQri1CSs/ADsS2SiEYDv02+VlV0UIqWkhmw+rVPLlqNb1yuvDBCy/QZ/gIIqJiUDz1hGo2o/iraWxsoltRJRmbdvLD4g1s2rGXBrcXi9FCekwKPVt34fSTT2PMBeMxRTvRVI2m/Ap2fL+GxavWsHznWtYWbqLKXUPoMIzFdGhs2LyRgcOHkZ6eTnl5BaGQ/hk1TSOPAxVb/jUwm4ykJEQzIKcdt119M7Fd+uy3PRHo5PfQPXc5ofALKL4Au4IhmoK/uFk1WzPElFQw+623mDx9Ojt37WLTls3sWLOad1946aCE7BKBhLCMEg5TUdBcSxafDK1TIL8EKmogwgbJ8WgBv84bMpppDMsowt93DA8WmqISrG3ktFuvY8kbH5AWl4Tn+RepPW8a4W5dGD3uNJKHjkJorqbZvWkP7XplASB/PJPwXXcjqgpaQD8PU4flkPSShc0BH7FoLUtqB4MSdGuQOaAHih4f9R4fb771zpH8yMdxjOLfEZSYjJjio3F0yaLbsAE8mzUco2igorqML+d+zpikNrQdcQL92nej3wPP8EBkPHfdc98/PygRBSSrBUOUA19cFI6c7sx78GkSEn5WxfU0NtI7Oupft1yloeFWFTLT4hENBlRZoalPT2KuvhgpPQXv1hIq8+uIGN+d1H66L4mmqQdv4KVBlCRwz0uvkta3X8vLBmcsBucI0DQcATdJGTVk9W4ku/Vi3nr0KVb7Q2Bz0qtTD268+Qa6jPzZuFIQBZztkuideQImRyTeoI/yhkqaAl7CinzQlWICIEoiJqMBi9mEyaCLorkbapBEDVESUGTdoPBoOuf+7hgFAavZRGpiDJ3bpRPVpsP+DWQZDAYEawSte4zh+utj8a89HZvJyE+hXx98TSfdAAD0WUlEQVSLUuCOa6/ljBkzDruiTgVmSQYaqyo4Sw4jGoxot09HuOtZ8PvBZgNRRPYGMAIGo5EKn58CVTvmgxJUFcXnp2JrHuc8fBfzHnmJpF79Sdr262L+xvp6ls1dQtturRGNBoJf/QBuP0KrVIwX6P44ktlEODaSbXKYxsMYzvFs7r8X//tBiQCSxYwpMQZbVjq3ZQ3GKBqo27iOZe+9REJYZrl1G7mrl5M5ahydeg3mphk38dwrr1FZWPSPEZz5FQQ9ILG0SsSWnUH3oQP58JJbiLVFEPL5qCgrJr1tNhGRkdRnpMOe4n9EOjQevXTwSExa2zUNrbwUv8eLNcJO6oO3tGwz5XTCpap6qlqW+fSFl3n9sYeJ0lRqDqJvQRAIWS3s2rKetL79UH1NcNe1iCedCX0G6fwDaySSNZIEYGKbHkQZI+h12lmooRC2ZoEzgPDn3xP+dD5CsA7TpWcgnTCWrmcPoKyinPJd66gyWvAGvMjawQXRRqMBR4SVvnGxRDosBGOcSJKIxxugus6NobKWpiYfuaEw6t8UrMZpGq0FgT6aRpYoIVrs+oZxQ6CsHJKjICkZ3voKgChXNG0sZlZazAhe/68u2wDNLr2HeT1XAJUCOAIh8veWU1eyl9iMtgSrg5j7d0Eoq0bzBgjtLUfp2w4jULkzj9qGJsL/EN6DFpIJV9WzZvZc3uz7MZeePg2AsBxm/eZ1PLzsB9z5JQhFdST7rfQf0psOg7rCxedRm1uI48yTsDV7Kd1x0dW8+cUn+JR/U/71OI4E/gVBiYhgNmJ0Obi8Yx+6GV2EQ0Hynn4Y1WFDU8I4q300qipz536KM7kVacnpXHzW2Tzw8COgHHtBiWCQEIwG/UcU9bVzWUYLyWiyQqqmUWcyQHIcrkE5dBw3jM/Hno/TFsHexmo2XzedXJeZq+5/BZstgux+PamuqET1/7V26L8HQWA/MSZ9OUEnwqkcmaBEQ2NH/i66d8/hobvvYeCwIWxZu4m9hSWMO2UCKa3SaKyq5tzzL2LVnO+JVOWD1joQBMBsZPWXHzHojLMxOVyQngWP3gtb8qFbF+jeGZzRaNOvR7BH0HniJCwRuvibpqoE8ovRHngUbe48hHY90bxNBGbcgTm9LYYubRh5+QRyNyyisDyfEkGEg2BCmYwGEmJdnDxhDE8+9zohdz2F+WuQgz4CviDrNq6jeMEKdu8upai6jmR/iF389RoPcUB2agoDzjqXzkMH6+d5OARN9VBWAXIYxGYzQVVl58KPqYmPoqGsprls+sifx5oG/kCIguJK1mzdwviMtvh8ErW7S/BNHIJdi8DsEaBVG2zA8mVLaHTvT749pqFpKP4AgZJK3r7ldkZ27EZFfR3nPnQ3NTXVdKmsxecNUquIhE12XnjOzvODXsU+agD+d58mqpsuTxZoamLFR+9RH/a3VEQdx1HAcU7JPxX6NzGkY3eu6jMegJ0bV1EX9tNt9gqc9W4qMlPZMbQPNq/Ahp0bSUtOZ+yAgbyhqEShE9Qa/rbx/wKibpZlcDkwxbqIiLATirDg8AdR3R6qG70oNQ3YgkGcdguVbVNJHdGXN8ZMw2lzUFdRwuL3n0dNjUdw2fFv3YKtT39e+7+H6bNyDe6isqOyZCUgIAgCoiA2W2FoqM2chf8maIqCgMEgYTEbMTZrUCiKSjAcJhSSaZCVI5oKVzWVXbvzOf38c4kURDINRkokA+/dcQNte/fi+107qayqQlEVKv+4u/0+c7HRSGGklcqCTaR1GwpjxsC6JZAUC6VFIIT0m+u1uk+PKzYeb0MDH592DlH2FPoX7SWyZId+ky3bhSYZERtrCfznCawv3IM5NZ6Ln7qbDwctRmj4Y2tGURSwW810aJPCzdffhMFqxWC10ilhUkubXsOm8H3y09TOWUq3ZRvYGaqjtaIdUUXeg0Ee8MPM2aS2bdvymvbNpwip8bB1N4SD4PHt+2Ck959I9TcLkBX1D0m/Aj8HvPo5ePCQZYXaejdLFyxi/ImTcU4+E68rmqjefYhNSNmvbYnHRyB07LmM/y5UvZqsaU8x47p3p8BkbPGvKQ3LBGSFGMAtNLL0288o33EDSe2zie32s17q7vUb2BNoIqj9Q4KxfyiOV9/8QxGlaoihMNePP7nltaycfpiiU4iqWYDg9+NoaCCvd0eUgIcxKfokmF9cTAj9CfGYSEAKAqLFjCk+ioiObWiXGIM1IYbLug6gsGg3c3fnEWpowrN1N6HyWmqinXR12Llz8Emk2aNoDPp4b+2PVHdoQ0xxOW1Xb2bHhkfp8dybtGuTxTN338uFl11+xIMSgyhhNuqqmQlGM02SgTYBH42qzA5FJiiHUJsnL0mAeIuJ9hFWDInRSFGRZPgD+ENhNoUUqmvq8TV58QTlI5rR0dBQVIUIFDxKGBEoBHYsXXxIgciv+lRU/IEQ5aX5elCS2hZ+2gKBIMQ5oK4RMlOgoRbidJ6P3eWi5+03IeSXoC1ciSJIGKoKIDIerbYMzV2HWJCH5/pHsD1/O5GpSZx2wTlsue+ePxyTQZKIdjnI6diG5Gxdl0VbPg8hLRPCYbRWbZAinAwbOYmysgp27S0nvsnP9ibfYR6Fw4ciCHibmlr+9jx2J/ayfKh1g8Oq3yjDISjeA2kZRLfpRLes7syau+o3Tw1REDAaDRiNEgZJQtM0ZEUlHJaRZQX1IM4pDQiGZJ5//U0mnzyF3kOGknbiZAD8TU0U78ilXW+dkGsNhf+xitBbQdf/8P/sGbWn+d8aIFJTSPY28OjV19D/jNNZv3MnGzdsgE0bya2uPiRi63Ecxy/xPx+UxACmQIiHX32RS7UQPdp3JjEyljZPPk+tJ0Ddoh9x98phiBiJ2BSidVZHgsEgzzzxBHWCQN0xMqkIRgPdImy4kmPxD+wKfTtzY2oO47L7EQz6Wb7kXWIrqhCtZmo370K0mDh12ChGJLdH0VTe3raMSlFDsdixN3qxenyUxzhZ8v6LjL3qDqadfQ7TZ1yH/yAqEQ5qvAgYJAmn1UGiK56eZjs2mxPFZEUKuKnxunH73FS5a/GF/Ng1lRyLieS4SJIykunQpxsDx00mTjCzc28upYj4tucz+6NP+b62gUAwfFA3kUPBkZxINU0jEApRXdfI1i2b6D1WRoiIRGvdBmHjBvDb4Nwz0E6ZDFExgG7wJ0oS3YcPgeHAJWfj/+QblA++RXClIRRsRPC7Uc0WApXllL75OR1vvYxrrr2C9++7m21/MCaT0UBMlIPevXIQJf3SF/5zK9TWQ0wUQr8B8OCzRLTqxlkX3kxqSldufuhhRF8JKMofLuEYRInOGgQlA3tFEVXT3XL3eeYc6vH74sMPuL3ZY0sYNZHw3TdgFIDB3aFrVzj7CoS0DADqigr5euFC/MFfV0cJ6HondquZrEgHYlQENrsVTdNo8vqpa/Dgq22kNhBEPshhNjV5GDNsOHdMn86AYcOYtWQJiz54j1J3E2369ef8KVN49MUXf/P9gqC7DIuiiCjqz7CKoqKq2iGZ+P0dkIFa9MXCF+fN5el5c//UgtkvBXmPkel2fwgCgiTqy+WSCAhoioImK2iKclCl5EcF/6OGfP/zQUkdIASC7J7zIyubqkiaNJwnJp7LCEcKcW+9g3HnDtq1a7/fe5Z+Mxt5V/6BO/wFdFVQEYNBwthcwaCqGmFZJiwrKEdqLVkQMETY6NCrK2effjrKhJF0dyWTbtT5B2azlUsGnci8xV9TnplMeX0jUbHJTD37EgDWL/mBDi8+T7aq24OrCKApVKUmojbqtE05FCIUOnI5IaPBQLQ9ig4pbRnZcyhXP3ANZrOJmh2l7PxqEeU7thEb8rN69waKaktBCJGYHEPvTpmcd/v9RPcY0NJXLONafu/XfzCWd97hizk/EgyGj9llUk0Dnz9EYXEV67YWcL6mIQBqViaC04hw2wMIvfq2pFR97kbeuel6Fm/JpfXAIZw5ajTdxo7EesaJBHv3wvPAe0hmG0rnQfgMVmobKslbs4aOXIbRaiXSaMCkyL+Z1ROal8VaGw0kBwI/b0iLh5IKqKmDb7+F9HS0S2bgSM5gwgWXk5e3mxcefxIR8HJgqW6DZMBqtOCyO2lrtCJYI4g3W/GFAtR5G6j3NuDxN1cIHcI39unjTyB6PMx44knsOX0IPf8e3g0rINSEbehExPgklICPebM/5rkHHqFpVxEJ/gAF//W5LSYjcdFOOmQkMT41jpTkBFIGDsRscbJ191Y2bdxKzYotFFTVs9obIHSQxFRV03j9xRd55MUX9yM/l/70E0t++uk332c0SLSzmLDYbagxTixmE5qm4fEFqG1oosnjxx8MHbn54yih4Re/H+p1KAh65s4iiXQxGGgwGagRRUJhmWAoTCgs//2fXwDBYECyWzFGO4mIi0JxRiCIArLHR7i2kXBNA4rHhxoM/WM4G8c6/hVBSRtFJaq2kfCmPEKiwEJXGiMm6MxyV3NA4vZ5sJl19cXX33j9D8vYJFHEbDYSExlBlCuCyAgbA3r0RlEVvlu0mOo6N26Pn1D44Es1fwuCJJLWJoNn3/yImF+U86qqQlN9LZEx8ZxgTWH0qItYlr6Bz/iYp256EIvVSr23kdyF39KhpFznRUlGDJqCJmvk9epAjEkXOyreu+eIpZpFQcRmstEqNoXemd25/PbpONP0cafER5PcvwPBghJONBnZumQ5r737NmuLcnF0bUPfuKj9AhJyt0BaAprZiWC0kD3ldN6ddAplI4ayZNmKY/qpUpYVqurcYI1BNBgJ1VZT4SknumNXInr1RfX72L52Aeu++YbPZ8+hbG8Fxb4AptXrWP3624yedhG3PvcA5sxElEtHIc8O0dAYxt21M852aZzQXS+TXTJ/PisDgd/MZLgAt6BnDCyqisOpZ2bwe6BfF53XMn8dtE8HqQ71gxeQztV9cT6b9wN1gkAsHLDqyCgZcFodnDJqLNfddD27Nu5m58odSKJInbueoppS8iv3kF9ZSL2n8ZCUYauBl199lbXbt/LmZ1/iTM/AlJ7Rsj1QX8c9d1zFT6s3sKuwhNhAkKr/OoWNBoloVwSdstI4efwwJvcfjqNdeyxJusZGD6CxaBdfPv0wlQuW4CyqpMHtPShyqptDJ1zvy1b1cNlJS03A1LktkQ4biqJS09BEXkEptfnFVFU3sMsX+PtvzEcBoiBgNhmJdkWQFu2kq8mAvXUGgydMYvb8OazasJmK6gbcHt9BB4j7IAgCkij8zBkCVFU9rCoywWDAGOXEkpFEl5Q4YlMTKO6SRd+MDoyNTGJ3QSEzX36RtbuLCVbXo/2BIvBRwf9gIPQ/H5SAbvQk+4OYiiox+QIst8VQnjOcnXvyqQr4SLQ7ufXh/0PbsRuvYGBz3q7f7c8giUTYraQmxjCwdTLdenZnwvnTaZXVFYCerz/Ju++/z87CciprGvAFgn+utFIUmXHm1JaApPC7mdRt20ptwS7Umkoy+gwmcdr5uJJSGdGxL1XjvFisVgCi7JEMmDSNgGrF//0PBOJs1EbG46ypxm8xUNelCwBb9xQeMT6JUTIQHRFJVmJrTpo4jpj2aWiKQuipN5BOnYIhIxZLdgYWYEDr0xhw3mkEvF7yvvmMrObxAPDsE7Doa7h0MkKr/tChr344JIk77ryLnyaccEwHJYqq4vH6SXTo5b2mmDgsNz6IT1WJAMp2bOP5u+7GXVBKZV0Tm4MhZCBZCdHgruODD95ixIh+9Jk8EVvfHOibg/O/9tFYV8dzTz31mwFJKjovKlrVqFZUCg1G0sefoW/ctFJ/ZK1uBIcF7JHgdUCKTtisqSynrKISD1B/gL5FQSTCYiczvhW333Mnrbp1pP2A3nCFvj1QXkPhtmKW/jCf9775jLyy3dR7Gw+sinsAlAGoGralyzmnR3c6nHE6/QYOoFf3HlitVmZcO53lK1dDg5vBTX5K0ZVB90EQwGox0blDFvfcew+9B45G+G/Jd1UlMj2Ls+9+lM3151PqD+ELhJB/waU4UpAkEZfTTpfsVlx3+92069kXLeyFhhpwRSJJdtx+H/WFRaz47nuue/lV3F7/P5aXciCIgkCaycDEAX1pN3oo0VFWWqWn0XvoyZjtDsZPu5C3XniQz2bOZsfuEmrqmwgeBFlYFARMJgMRNgt2mwWLWVebDYVkPL4AHl+AUEg++PlCFDG4HNiyW3H5xRdw+djJ7PJW0zMlmyizTW/TZzjTRp/I4889wTOvvEG4tvFfLXt/pPCvCEr2rbW7/EG0ilq2fv41Y77+DoNkYIfFiBqSifb4cHn9lP1B8CCKAjarhew2aVx09mn0S4ij0+mXIJotLW1Ov/Aa7GaNjz+fxZrN+ZRU1P45roYApWF9klxVsYvQk48RU1ZNjN2KMRig0u2l9odvcV03g04nnkHrlAxmPPZ/3HPxVbiiommb0x9y+pPrjKRu6XyiS8upat+Gwb3H0Kuf7vtTsT33yAUlBiPR9ihaxabRfZjuKxN+/k3kWfOQTT0ISxsRPCUwpCeW/noQYrHb6Th2EkZX1M8dVVdD3h6YuQhcG2HoJqoMArEjL2TkqDEM7NePhUuXHZExHy2EZYXXPv6U4WPG0n/UaOK79mjZ1uQNMH/9DizBMLlhpWXCLAPKNRmDu4YJ553HKTMn061HDh07dSQ7qw2783czd+FCfpw/jzVr16D8TtllGdAG3e9GCMtMPf8ynPHJKA31hB5+AKvdBG1S4NSpcM4lYLWx77YdaGrC4w2gqCrZ6DyCX2ZLDJKBeGcsg7r2o9Uvqi/2wZIUS4ekWDqMyqHHkO5cdt31+EN+vEHlkJZxcjWNHaXlfPfs80jPv4gk6X4qJlkmUlbxaBp1/DpwEgWRCJuFpx95kvZ9mrNvK3+C7RuhcDdsXQddOsItj2KOjGHs6FHsKCilvLoef+DX3JTU5n+bBPCLIgajPn2qzYRZRVF/N4BINRoY7rDRIyuVbqNORDQ0T7/JP1cYWYGEjPa0Hz6GD9euZslPqw85W3Asw2iUyEqK48lvfsBos+23TVPCmKw2LplxNykJ8Tz32ltsyt1Dbb37dzNXkihis5rpGu2gU2IcYlYq0ZERCIJAY5MXd1E5hXsr2FrvocnrR/6jeU4A0WjAnBxL6pDe/Of0i7BbbLRqPgMCDfVsr9hNZno74mPiefSeR4hzxXLb3feiyMo/hrtxrOJfEZTsQwNAWAHZR54ALkEgKIqgalSoKhUHcTIZJInoSDsvPf40OSPG/rzBUw333ApnXYTYcwATTptOZVkxdQ0eGpt8BP8MMVPT2LIjF4D2jkSW9+2BYdFybE0+VFHE4vODpmF442048Qx6JbZi+qwv6fLK63Q5aTzTz5zKxD5DaDvjVvakJ2KxuRg/6kSMFj2bsmrZUh587rkjJp4mCSIWk5n0VqnY2+l26MrKXITiXWhfPonaWI0QacZ2y/mAnl7d9MXnxJsh5aTT9U7uvhE++0y/wHcVQ2oIvvoOySDhyxxKRNt2nDp69DEflAAUl5UxZNx4UtNSmTZ1KhdddDFt2rZl+658DG4fufxaYUTTNMJKmHpPI29++C7iR+8hCAKaqqFoKqr6x6WvoGdJ9uX9OrbO5NLpVwGw+5VncVVWo6bEYY5ph+FSfbkmXFdOIBBGMFn54r13WrJ8TvQqtH1BiYCAyWAk1hFNz+56oKWUVhIcdwZit2w0v4LQqy/i8IGY+nWk10mj+L9N07j/4QdYIwqH7MCtoS+Hyc1HSgBSABE94FpwgPcIAljMJrxuPVzRQkGEGZeC1w9xkVBaC41uGLQQxpxE/yETmfn+p/glkY0CeASxpWRY0zSiAZMk0tZmxhxhozwyAlEQCITCJDR68Lm9bFC0A2pziKJAskGijyQypHuvnwOSTYt0LaT6evDUosbFoCR1xti6HedMO4eVq9cTluX/ifucgP59GDJSWgISra4CwhpC/maEiDpI7osYl8mJ51yD1ezkhrvv1QMJfxALugjefn0KYLHoyr9njh1B+4QoWg0eiDXKgRLyUlaUT9XqLayzWPCWVFFYXLm/P9JvjFQwGzEnxdG9X2/sFn2sVfPnUFxVStU3X+OsruaLoX0ZMG4KHXoOon+//kg2C4rX/9dpWx3XKfkfgqYR1qAa7ZBtr41GiZgoB0mJSftvWPoNeOrhgTvghXeRktIY1X84JcvWsdtho77Rg3q4mQhFY/2KFTTUVuOKiWPEPU+w5qUnqZszh0CkEzHgJ760ktrOOj+m1t2AuawGV009Cz6dyfIVK/j0hVcZ06Mf40+/pKXbbVs3c9P99zLn629RA0cuXd1BDtM/zsUZt50PgLwhD3XlPMTGOthQBiY7QuvBAITcPh698h4Stsxh2lczf+4kVAWSBm4/JMVBcjQs24xl7ETsbdsR9Pt45t1/jheGBhQXl/DQw4/w0MOP0Lp1a0pKSvijxLSqqahHiFdQUV1NbWUlMQkJxJ5zMTuNAoleD6nTLgegavsaZn31Fhu3F7Jzww6K9lYQCulP6Wv+uzMBjKLOJ2nXtpU+1r3F4PWgLV4GBgPqujWoPy5Fvv5ybCcOIL1nD8ImM0LQx5+VY9OAYiD6D9qJosCceV/Tc9QJYDRCt44wfwVs2KlHNJoMb72KNnQ0kamZTDn7Ap7ffDtJkRHUCQKyqhIKyciKwh5JJC46kk5JsaR2aMMJp04lwhXF1p3bCZdWEemM4YZnnqWopHQ/x2d9HCKyzYJhcD86XNasHFy4FR5+QC8ND8gwqAtiSTWhrn0w3nAPY0eNxWiQ9IP9T7mj/A4EUcBmMRMXFfHzi9+8hrB4NdgskBQDxZ/DuNNh0hmMPP18Llu2nLfefI+1gkB7TSMI5P6iT4PBQHRkBM889DCjT5v6q32mttpFTUwUjg6dGOxqhdNg5+LLLmNr+e8U+wu6HpQpxklEvH6G1ddX8/WqHwkBPUvLmD91Cu02bGXnjo106DmIPj168+Ytt/HMu++xZsOmI3K8/q34dwYlhwkBnagWFRmBKbp5meGbT8BXC7NnQ34R2C2wcgFMPo+E5EySI23EWs0UiQenuHkgaKqCUFrBuWdN4eFX36RjRhaDrrmN+bEuViVaGft/z9PosKL07Q1AyYb1WGobWOULgD+I3OBh6uln8tXrbxEdF0dxYQHvf/gBa2bNojwQ0ivajuCcV6tpXPjwPUQm6lbjvoeexZDWETW8BYIeBKMBMTke0Kt+CkuL2C5KnBwOYd33mW96FIF7Yd5C6JIJe8rwdumIZYY+oT/y6MMUFO45coP+i1FY+Ne7ytTV1dG7f3/mzplD26ws+l1/137bH3nmaVav30B5VR2umgaMvuBvnrH7BMjsdjs9Th8BgLphJ1pUAlpNMcgqQkJrtJS2aIpOOgzICtWS8YiJOAU4cDWQBWgF7FFUQmGZgoLduGvLcMYkw7CR8M2PIIngtMOwsXDuNASzfuaNPusCPv/uS1w+LwZJIhAKUVnTSIPbi81ipkt2BhdceD49Bk/E0Mwt6DJ4TMu+u0+cxOTJk9iam7dfYCIANSYjiYOGIposaL56hOVfQl4R5BXqN2VVhV7tUaP1admVkIgoikfoaP39EAQBi9lIavLPZH2hth6KKsAbAJsRGv1gmgOTdN5T787dmSt9yFr05bmmX/QniRJOm43TJk/aPyCp3AuR0WBxICVkkZCQRcIv3nfSBx+y7dNPf1vPRtT5KVGRNvrG6PNUg9dN+y07SVm9gZDJwNAvv2NHvxx2R5kYGvThMtuYOuMGOvTpT8/Bg/6SMuG/QjzthRde4LHHHqOiooJu3brx3HPP0adPnwO2fe2113j33XfZunUrAD179uTBBx/8zfa/heNByaFAEFr0N2zW5mj/409hy2YIBUCUwGoBpz6RiAmJeOJikA1/8jBrUBEMM2frDtZfeRHbP5qN0xnJyLOnM0xRKHu+G8Wb1jLgRN0My2WyEPL50VQVNFBkPzWFxQwePVrPdyoKfVUNC2D+cyM7IPZoCms2bqL9wP4AqGOGo7z9IZLPAy4bpjdewzB8EAAGi5GaskJ2Buq4+dJzufDmGxkw/ESk6ES0B56Hnm+hffkpfllDeuhRJIeTvE0beerJpw55CeA49GCo/4ABPPfA/aRmZeGIiiLGGcmSOd/z/hffEgiGCATDVIRljL/TjwakK2FOG9YHqZlbYRw/EPmD9xF9XjSHC8FTC7mrMaSfBoDVGYGsqhxtbckE9KWmWMDrC1JWVUfB8oV0nzgVrdsghJhoCKkw6QR45IX93lu6dTXDe7cnOtJOhCMSW3QqojWamOgkXPFJ2CNdLRovWm05bNsImdloqoDicNKqTVu+m/sjE088kbXrNux3vBRVZWdpsxpOQIZnP4bKOohyQFCBugY0RSHcT894mi1W7BER1DV6+F9CRobOodEa6hCWrYOCYjCbwW+ClHgYoStv+xtq+frLD6k06PPp3ub3i4KIyWAkwmrnlIknctfdD+j9LfoB4Y3noUsr3RxxwAnQuhNExaHJMkLzPFxfspdETVfq/m8IzZVBcU4bHeId9LdHAuDI20EioMVGE5ebj7XBg2I00JAYxYZtKxneQw/MewwYQHxyElXlFYechT9kHOXlm08++YTrr7+el19+mb59+/L0008zduxY8vLyiI+P/1X7RYsWcdZZZzFgwAAsFguPPPIIY8aMYdu2baSkpBxgDwfG8aDkUKBpqKqqC3ftW5NMiIW5Vfo6Yqc2cNpIWLURRp6DwWjDrSiEZJk/m4rQZAW5zk31hlzuf+YxbrvyOtBUomLiSOucQ1pnXWRKVVVmLVrEcvm/LghVZZ/qczz6E6YR+GNx8kOHrCrcfPfddO/Zgy79+uC6+FTCo/ujfvs9xjOmIMb8nHR3l1dSXVOGFKhnW9DDV3fdS97ArznzpvuJSMkgmJxFhdVGzHnXYGnTDm99HWdMO5smr+9/piqhWcX7L0NNTQ1nXXZ5i7+QIDS7xWi0yP//IS1bA1mWKdiZh6emjojYaMTMVli/eofQyWehFRahprXBdO05GHM6oKkqs7/4Rs82Gox6bKwqR6V6ai9gQg9MbIEgRWU1fPDNLLqMOw2pY2fkfgMR9+5EuPQKBECpLaFszxrC+cXE9x7BqRfeiEEwIjhiEIRfZyo0nwdh2XcIqxfonJS6JrBZ8LlikK68k8TEFL7+4ktSW2e28MhUVVf33bBBD1SE6Di06BiE+iadaBwdATuK0KrqEWatgw6n4mtsoLHxf8gvV9OJ3x0z9VJ2pWgHhtgoSEmAxBhd0rmwAtYsRjvpFKyuGLxt2rBr9ZaWLiRRwm62EuuI5r3HH2HAOWfqXTfUwstPw95SUMOQ0w7eel5fJXQ4kFtnYbzsdgKeJvbm52P4jRUxk9FAXJSDLpkpjMpOoVWkntWJWbcRJwI+l4tw63TCBiPVbVrjqqyh5KtP+ayxgQn9x2O3WDl/4gSe+OAjFI/v7xNWOwJ48sknueSSS7jgggsAePnll/n222958803ufXWW3/V/oMPPtjv79dff50vvviC+fPnc+655x70fv/1QYkALRkQ0E3ffotAqAEhWaG+sYldu3fQrddAlCFDkWZ9q6deU6JhawF4A2jBAJLFTqc+I3l35iKUP0t+0jTUUJhwbSNPPf0cc196Bclpx9WuPScNG0HPbjksW7uGV958G23nLgzoyosHQhXg5OjZg2uaRk19HcPHjOPKS6Zz42034GiVAldcDEBNcRWrf/yJ9j3bMfODj9jqa8Af8NFRDjFbVSkLBJgw3UcE4I1LJOb/niMiJQ05FOKCc6exPW/nP16/QZJETEYDRoOEKOqESllWCDf//BUBly4IeXhrdxoaeZrCSwsXsnbcNM7q3psT7rocS3oS0uUXorz5MZaHbkLq3xtNUfjuxY/YtXgFXVwJVDhj8AS8pLnrqVZCFKBzLkRBBHSiqKzIyKp82OTwfUFVMBSmvLqeJSs3sGHhHHqNmYh203+oeeRmoiJcGIHcpd8hr/qJduddiy2z8/4dFe4CcwitJB9t8xbEcBBB9sHuEqhvAJsdduxF0BRsqYlUvfsiETc/gKppiKKI2kx61VQNXyBI2Y58ardvIaZjF+RrrkN85WnE7Fawaguy10+osBRtml5TPfu7b/EHgv8zwXeEqpLq9lJSpi+6yRERiK3TEIorEOq9emAWaUPesY1g/jbsWV24+KyL+O6tj6nRNARBIC4qlu+//ILCDbkkJ6e29C24YmDKGXDf/VBaAylxUFqlk5mz0hFOmALAzi3r2WYQKRPFX2UykoEoi5HkjCSGdG/H8OwMzGZ9mV64+Q5M69diSkgk+OarVLurSS0oJHWzmx29OvBTqByrp5QTLW3JHjsK07w52IMh6oLho2hmeXipErd7/5nfbDZjNu+fMw+FQqxbt47bbrut5TVRFBk1ahQrVqw4qL35fD7C4TDR0X/E/Nof/9qgRF+GMWA2GDEZTbgQcAsCYTlMIBxEVmSUAxhKhUIyFTWNLF28mG69BhLukkMwNR6zSUJsCiIHqgglxeF/5Rlir7mF06Zdygfvfcqe0gPVBxwiNA0tFEaul6kSwFddT2phKe9/9yPvqCphTReLswGt+bnq4kA42s9fsirT4HXz9EvP8tVXX3HHHbcyeerprJz1HU/e8zDJFcU8JgdZ5fcQVPSbz5ZgGKnOTYU3QPLjj/PICy8TnZUNQHVJCWdMm8qSZcv+0QGJnh424HLYSYxzEeNyYLWYkRUFt8dHbU0DNbWNNAbDf1y6+DdDVhRqPfXkF29nia8B+0cpjLvlUsRTp2A/V19KlD1evn92Jnlbd9IvKQtBFLDkdCK7d3uckTZ8oQBb95ZQXlxGRXE5BbsKKKsopc7bSJ2nHk/Qh6wcfkmsoqi4m3zkFZYx4867mNNrAPasbCpOOIvGvFyyElJI6DMeS/cRmGPj9DcVrIGVK2HpMthbBH27IJTXIKgqJETpSy6SAewOnQehKFBYihgM4Zx0FgDrNm7YXz4dCATDlFfU8t6zTzDj5bcxjp9CQ2M1xq6dMJ4CvrJighFO4puXL95///1fE2YFEUnUvXv2PUjJqnLUsk5HEmHAFw6zYdMWzgQEexzu0gZMkoTB3QT2OOSQgi8pCZOkSywYBREtqNPBTZKRE8ZOoPuQgXQfMpDqH1ahevyIEc1MtAmnQnZ3qCyH5x8Fnx9iItEkAbVJ72NPwW4CwQN7EvUCMswmnD06curp02jVoS+C+ItbZI9eAJivvp60UUMIlVewcUQ/2mzcRWnXThQ0D6NH9xyyk+IQKmqJCYbJOwrHEjjs5Zu0tLT9Xr777ru555579nutpqYGRVFISEjY7/WEhAR27NhxULu75ZZbSE5OZtSoUYcwyH9pUCIKImajiZiIKOIcMbQ1mklPTuaE0yfywuez2bB9E7WeBnxBH+H/mhAVVcHd5OOHH+dz1Q23Y0prw97M1oixVuxbdqJVe9kTHUlEu/bENr/npDHjmDV3/pH7AJpGuQaoCo3oX2Iy+tOhG13B86+nUf4aiqrgCfjIK8rn4iunc+WMGWiaxtBQgGBI9/qV+bkOY1/Zp0cJ8Oxb79K4YTMjTprIvIJCZn39NfUN9f/o0ki9RNVIYqyL9pkp5HTKpH27TJJT0omwRlJeUsLmr2azY+defmzw0Njk/dVN6ZD2xz5Vy98+aL3Q9UcO53zR0AiEAux21xBUZNi+iXGAZLOgqSqFi1eycNZPCD6JTqnZxGZ0IGNsF+KG7p+N6PGL31VFYdN3i3nu6deo3rmB3Lpy9v7JwERWVJq8ftZv2s5l0y/n/U8+o+vkM8lfvRKAuGR9ktb23dTvfxjqq6GyBuo84PGC3abzxXp1gJJq2FsOqc0S/aoK6QloA7ohdtOXUTeuX/ero64oKgW+AKXCz2wd15mXtfxu+kXbNXPnMmfujy03T0EQMEpGbCYLcVFxmAQDRsmAoiqEvW6qgj68QR9h5ch7Qh0p+ICtikZg0VLubmrClpCE8YnXaZj3LerHHyD27Ic07kRiWmcjiCJyOMzFN97ITlXPkiRKRgYl/Vz1GDeu7/47iHBAtxwgB4IhuOlavbQ+LpIgAibA4/Hh8x9YzLLAKOFwRfKfGfcQl5ndPGgPhMMQ+Qv9JJcL6wWX0PTR25hkDVSVfp99h1rtgxn/IS0iEl96Iq3zClnh8R1zhVPFxcU4nT/LMP53luRI4OGHH+bjjz9m0aJFWCyWP37DL/CvC0pEQcBqstC7Sw5jh48lMymdKMlM1z4dSOjXjcGXnM9dl93K9wvnUFRbitvn2U+BUtP0lPDipcvJXbuGDr160/rNLwj5vKg+L7K7iXaKQmRWOxRF4YvHHuOJhx46qp9JZn8zuYMxlhMFAVEUkSQBQdPIVlRKgdqWlP6RgaqpBOUQITmMN6gHInM1lVbwmwZyunurwnvr1vHGunVHbCx/N4wGA7FRTs496zSuvnIGroRkJMv+AlIDB4zg+f+7jfydxezaW47b4zskNWAB/Xs1SAYkQWzmbqjNT9K/dsJtYv+KhkOFoqn4gn72KDKzF3zLvTX30lBTyz2334e3rJFbLzmXVv364kyJw+SytrzPuyYf36ZcgkYJQ2oi9lgnlvhIjElx5EwcwR0RLtZ8/jlSjJUZL79ERU3Fn7rZqqqGPxji4y++pNdTTzHjuuto26fffm0EUYTaGli8XH+hfWuwWcFigaRoaPRBYakeXZ45BmoaoH4LpKag9euPMnEU5gydpLpq9Sq0A3xv4bBM907dWv6urqpk3dqVNFVWkhCXwOaCAjasXcdHn33REpAKCJgNJqIjXMw47wJueuoh9qzayFtPvIuxqpzaxmp2u2vY1FhDTVPd/7N3lmFSXFsXfkvae9yNMdzdXQMkRIgQSELc3d3d8+XeeLgxuCHuCsGCBHeXYRj36WnvqjrfjxomkAABAkRu1vM0Q3edOlXVXbLPPmuvRSAS/NNO+RiGwfYdBQwfMYwXnn6Gzn37ET/mFBhzyl7tVv60kKceeZR5ixcjMLWPkqwWRpw1oamN9tnXUFmJkpmONOoXo/GRo+Gumwm174iW2Qy5ufm7bNy4eb8KsQUWC+3aNCdxNxF32ktIL7wAugajx8LdTzS1VeOi0DPTSCrYRXVUFHVxcbTwmCoqDUIn1aoyPyYKX7UHjlLGUxLm61DaA0RHR+8VlOwLiYmJKIpCefnepdPl5eWkpqbuZy0TTz75JI8++igzZsygY8eOB7+DjfifCkpMkp2V8eNOYcq0/6DsoypGtVq478VHaHZfKlPem8rW8gLq/J69LnJDCHyBICeeeSbLFy/BHReH1eky55cTTVayYRhcdOEFLHnjTf4M3PlszJHYtkb79iiXgxZOK3EOOy5FpnltA8skiRURjQSPly2acZgFzPuGwCRQSpKEX5bYKEko4ufP93UPPXL2gH88ZEnC7bLzr0cfZdw5FzR9LgwDKeSFSACiU0jq2IuRZ42n4v3PsNY34PP5qWDfpa+/hCIr2C02YpzRJDtjcDjdKJKMPxykzu+h3u/BG/QR1iJN2ZPDTS23xxQjLMIMPIOREAXFhQzOyKTOEGhR8Tz72JN0u+C0vdYT1bWEn38HsdOPa8Gn2FObEcntCqUbCTVUEz7hJFy3nUf+kK7kDzFzKAV+P3c99zQh7fefEbpucPMttzCwVy+69u376wav/gtaZZtlqkXl4HBAdgaUVCJkhUBBCZbyWiwd8yGiwWU3w9DjkBSlqZIt4POyePHSn8nwex6/gEtvu43pX37JzuIifJs2YpMldkoyumGgaTq6Ifa636iKQkpMEu0zW9G/zyAAcnp15qYHEtgxYyOlixaxLOjFVriOlTvXs6umhFDkyMvkHylousFPS5bSZ+hQxowYzr233EqH/gPYsGY1H3z0IdOnv8uWrdv3Eo3LEwJFsmC4owBouO0p1DdewLC4sAQ8WG+4Dm69xsxqhMPgciEWrsTu2Dvo/+/nX+w3+ziwZ0/efv9LJFlBLy5Efv01KKuGvh2hZif4GswpO4CJ5xJYtZhArYf0dVvxRjux5JhCkVani+gOnTDmrz46X+AxgNVqpVu3bsycOZOTTjoJMJ9pM2fO5Morr9zveo8//jgPPfQQ3377Ld27dz+sbf9vBSWSTHZGM5779zMoqkqosAy5qBjJ6UTJy8TYXoRAwtK5NZc+chNd+3Vm0kUX4w36fjWNIwRs2bqNoYMHM6hXT75fvBir1UqUO4qoKDdbNm9h/UHOvR0LqJhBic1mISE2itZ5GQyIdtF94CAGXHA1nl2FvPDG80QtWsGWgmLa1HtZpx1YNvtQIAGKqmC3WbBbLaiqQn5Ew6fpbNL0P4cr6FGEJEtEuxyMmXA2AJGSdVjmfYt03/9BlAtG9oLTL4UOPel7wiXktOzHo/fczYKvvsfn/6WO5a+hygpuu4u02BQ6J6YztG1HTrzzKhxJ8cx561O+m/4hyzyVFFQVUempMm/4vzOv/Mu6FCEE1nAIpyST2jyfk8411XmD736KWF2IkdYVpj2BXL4LOSkVkjKRffXYti1F1FQihRsQb08hnBaF9dxTm/o17C5sFithLXxEMuGRSIRegwYxYMAAunTpzFNPPW1+XluNZtRjj4pC6hwDS9aDzYIIBAlHDDzhAPXBEFFVdUhrd+Do1JGoEWMBCO3aTlF5KZu372D69PfweH373Vev18vn33wDQDvMKjjfftqamV0HOYmZdM/rRLzr5zl+d6ssOrTKouXYjnTdXsQHH86kIeij1ldncuKMPy8nyTAEwVCY5V98xegvvsJptbBd1xvJ18avBikuYWAToukeYeg6RHRkKYQWCiL+719YRwxC6tbZFMkDJIeTcCDA1pXLcSenMO/779m2ff/GoyeNGYvFaoaWwmbDaNkCpVUzsFjB44U3XoArbmlq3/zuJyg4bxL2QACbP0x5dQUtDZ10ZwyfXn0vY2ct5ZutB5O3/nPi+uuvZ/LkyXTv3p2ePXvy7LPP4vP5mqpxzjnnHDIyMnikcSbgscce4+6772batGnk5ORQVlYGgNvtxu1273c7v8T/VFCiyAovvPIisUmJ+LcVUv/gO8Qu/gZhCKSIHxEIYKRkYbnjOqwnjaDn8SMYO+o4Xpn2xq+Ckt1Ysno1S1Yf+YjYJMntZsrtO5NwKNiOGZAkx0fToVU2owZ0Ydxpk8lub+qFRCWncV/Hzsz56l2mPvI4M3eUYq1rIBT+/b4bsixht1qJjXGRmZpAcnw0KSnJXDD2NLZv38bT702nsKScem+AyN/I52NPyJKE02HD21BPbEIS6hcfwfIV0CILZBkKi+HzdxGJ6UhpmWS07czZF1zMuzNn4wmEDlgzLAEdZAtd7S5o1oZzJp/FgAtPQVJNF5vjrjyLyMqdRNeUsdBiIxQJUef3/C6extr9fL4EsMgyt59/DqrFQsOC5YTf+gZHQx0MzUMOeBG15UixiRhtusLq2UiblyGpViSrAyM1A+2x/0N79nmkaW/gaJuLHjGwKBaOpLKppmnMmjWLJUsWc8fNtxCfkoIlLgHL7c+gr16C9MLzYNkMgQj+nt1pcMZRbo9CsjqJik3AkpuDrZGLUrJ5Df+9/RrK12zjPW+Aipr6g+YC7W8KczdkWcFlc9IqLo2e0XFktzf1How16zF2FqEePxJbTgq2nBQmd25JwWXFbC7dTkPQ96cOSnajAJMDV/wbpnurJZl4DDSvOdmodGyJEZOEHJcIRdvR6ysJXHMH9k+nIifENq23delSLh46hEWG+E0i8E0PPojidnHuJZehJqZgPPR/GLP/g+T3wdtfQ0fPXgo7sstF3nufsHlgL+RIkJXhSmqeu4+Tr7sfWZYJBUJHzLpjnzAjuENrfwg444wzqKys5O6776asrIzOnTvzzTffNJFfCwsL9xL3e/HFFwmHw5x66ql79bMvIu2B8D8VlFx5/nkMHTGMSCjMrsdeI2XzOohJRMgyUk0phMMoAR/hlz9Ax8A5fgwj+vXh9elvI0Wk3z2y/C1IkpmqtVpUbDYLVosKAsKaRjAUIRyOHJSl+r4gKzIxUU7aNs9i1MAuXHTJrdjT8s2FO1aAJRo1M59hJ06mY9se3HL7jXzxw3wCNR4MTJLaYW1XknA7HWSnJ9K5bS6njT+ZPr2HEp/dCtlipQ9w4jU38N6rL3D3U09TVXNwrqB/OTRyeDy1VcQmJCEVe2DRakhJMKs3flgKrqWwfi3hYSdgPe8q4jMymyzYD4RmkkKeI4rWcem0SUiny8DeTQEJgGK3csK/b+K4iM77z7zB01NfpVXARzUaRyOXJ4RgyPFjAKj+8Aui6srBFYvYsgjhqUbObIWW3hwaaiE6EYRAKi/A8Dcgr54LniqMzFaoinnsoUCwibR7pOH1+mjVri1nTjiNc08/g879B6F07AEvvUX1lH/jHnoc7px83EDaPtY3DINpb73N/HmrKKz3gGYQNH490j9c7M6A5btjaNWzPfbsZIQvQPCZ6fDTHLRVBdjvuBgAR3wUNzx5Oz+duIIKTyUR7dchnCRJfzq+iQfT7LDoAG0MYeAPB3hrypvc3+1p3GedRP3ipYgSDUt9JZLLhvXZh/cKSAB8usFCTT+oslyPp4F3rrmWhdPe4on3PyY2NR2/NZeIdw3WuBj01auw+xtQnVF7rWc9bhT6huV0aN2dlh1Nwci1q1YyZ+6PfzqS66Hiyiuv3O90zezZs/d6X1BQcES2+T8VlPToYjLjhWGQcMEE7KvXID76BHlXMUKxIqLjQTfQ0/MJR6fhBLyKQlPSYn8n2O4Gu9scxkUvSRIOm5W4GBcpibEkxUcTE+XE0HQaAiHKKmsprazD4/UTCkcOeRMWRSHb5aRrchzHDRz+c0Dy1Rvw9ZcQiMDg0XDWJSS1aMuVF17K/GWrSK3xoLG338ShwGpRaZmfzTP33kOXfoNwJe1NkhI+L+6YOM6/8Q6qa2t4/MVX0XT9oKZyZElCUWQURW662eq6gWEIjH2kgP9ICEMQCkeIVFRA8zYYNieyRTXLS+saIBICezRYbPiyo7ACeW07EBcXT1Xt/gu4JaDSYkWPTSKubTeiuwxDaaQThL9agAhbsR7XESXGjQKccdN5fPfTPDZXF+Pzhjkad80uXTqTkWlqSFh7dkaKTyCyeCvS6h+R4tLQ49KgeCuSvw7R83hIaQa7NiHbXBiWMJIzGqw2DIfJ2vf6vEd11J9UXcOyF19m+rvv0qtHF6b99yPcsXEknH8FAJFQiI1rVrO1sJDCHQVU7Spkc2kJpcXFFO4qpKqqGiMcJlMzmlRHjwQygVTDwIdEMDqRxEZHbW3WQkRZJVJlAcb/PUrgtX9jdOuD7YUHScpK4YarLmbCZcsAiWYI/LKEz2JOmUpCICSa9HAM3TjsM2B3ebLSOFoWQpiEanFo0775mNNXv6WdFI6EeX3aNLr168+JE08h6sFbqLjkFiJJqcROeRa1dXO0YIj1S9cxd+5sPvzqU378acFB64QIoETTKFq1lqeefZIHHn0a2nRm1iuf48pIxlHrJ+nLj2l12t5CYDm330/OHu+1cJgnb7sNI/I3HFwdA/xPBSXX3nknHdu0pd3ggST2agu92iLOGIt/3PnIpcXgq0ZyxKBsXoxc2RroghoOmWm/fVxkdkC1qATsVnNkapY6YIQjGOHIQcsMS5JEvqrQKtpBxoCepKRGkZuZTLNACNkXZHt8NJu2F7OtuJZN23exZfuuQ7YzV1WFQcKgd30DSdbGKoiAD558DirrTbGhJT9A67bQfQAWQyPG7aTcohCMHN4DQZLA7XIw5bX/0KG7Wb4nwkGkqq2weDbMmINkt6Fdcg1qix5MmHgOU96djtcfPGBQIklmJYvTbiUm2oXbaceiqkQ0DV8ghNcfJNSo82FWnjS66v6BQYohDLz+IAVlpeQD2shhWL/9FGo9YLdCrw7QrR1G83QMv1kc6vfUU1fvOfB+S6bezr1vvUynwf333uZPSzHmLSb4YClSVhqWh+7C2rYVl116LhNX/URZwAf6kb9xxu8xf5x+xjjzWB77P4zlM8GioNudyFoITTMwdm1AlRUUdwwi0ABpOYj4NEKygqMx9e3xNRDWI0ctU1kLhAyorfcya+4iZn72GSeeM5ntW7fw1euv8um0aSyorCIcjqA3nke7RRdNmNOrB9IFOhzIgNJYOeVKiCKmcz7CMNCmfo60ZRlIKigyhj0asW4VvlenEnPHNcQnmOWriiKTLIPT7aQqIYaBgBtY5bBSp9jwByNsLyjcr27H/iBJElbFgsvuxG1z4bDakSWZiB7BF/LTEPQRCAcPOpDcien4/Ftkbs3QqfXXc/NNN9G6eTatenYj8d8PgWGgJibgrWvg8esfYNGs70go20Z1yI+2D62pA2GTANUfpLXdzIY481vQ+5qHiU9Mwmrdu3S2orwUXdeJj43H5nSyefNG3nznbVZOf59NW7b85bMkfxT+p4KS6ro6zh13EqPGT2LY8DH0GzsQa6wb68UTEA0ejEWL0ef8RL3Fhlq4i2jAmZKIpmt7n1+ShGRRaWG3YkuIZVt2KkqUC0mR0X1BItV1hEoq0eq8GKHwb2ZOLKqCOyaKcy+7mFPvfRQt4CVSvRPVkFDi0xkgC/RgBFt8MrqmcfZJJ/DeN98dEjE0HoFTMi3ohbvxZur3m3wGXwB2lUHzLFDMtH+9HsRqValUFAKHGZTIksxDDz9Ch+690AN+IrPfx165E5augW8XgapApxao876GFj1IzcknJTGG0spagqFfPyzdQAiw2GwkxUeT1yyFjm3yOGHwcQRUg2A4jGYoaKhYLTbwePloyqvsKipmrT+MPxA87Omv3wvDEDR4A7z90YcMO2UC1u4D8fUfgDJnFlabHWN4L8KaiohpTUKjh9Fzjz1CbV39b/adnJz0q4BEX7IS4+UXkCINoBkYtR5CT76Ec8ozdBraD0VWOIiZocPCt3PmcOPZZ3PKSSejOaIYOGYEzluuhluuxvB68c1bQvmM+UiffoJtx0qIz8Semoe9cAOa1YXPnYg3OZasKLNyotZXT/gIVN7sD2W7/6PpaLrOpMsuJ+exx9iydSvNNQ2nIQiw9zNGwFH3BigESmWJpEiA1p1yAAit34FWXY+qhxEJ6YjkDCjbhfrsI7iPGwxAQkY6AoNotwNHUgzpzbMYkJfJya27EBsTz3J/BSNOvghnTCznnTORL77+lgbfwZURy5KM0+Yw9Z1ScshMSCPeFUtMXCxp2YksXbWapetXUVhdTL3fQ1j77aA3zMHr5IQiIXZVljB2/Gl8+8Wn5Hcys0flOwu5/dzLWLF2FRZfPXLQywF8gA8ITTeoqK5pep+6h3Lsbng9HkacNI5NhTvJNAxyHC4WVlURCEcQ4X3Mmx0NHGXvmz8K/1NBiWEYrAsFqP/6S7ZuLMTtcNPjlAFYJjbWyF9yLtr2nUStWY/WzvRnyMvPRftFxC9ZVNJio4jKSibn5LH06dGF7LQMWisOcuJSyY6KZ9XKZZx21RWUb96OcQCi4m7nTHtmEsMuNtPFqsONmtmuqY0MqI2VbYqq0qNvHz6eMfPQqlUMwRa7nZR2+fTJaXRt3LgGclKhog78QZOUFQw3HqMF7XfKnZ81/hQuvtSUzK5/8j6iZA8gYGuRGQxpBmzZBf55cD7IVivRbicWVdnnbFkOZhVLTKyLlDY5DOjbkckX3UxsVsv97sPwscfzr2svRttRyI6iCuob/IecZdov9hgpH8wFHwiF+eLLb6ksKSYpPQPXQ89jRMKIYAA1Kmavi/H5557moef+D03/7YCwf/9+AFQXlBC47mFi3W6UjasRQoeAHyk5GxGXhGhn3sCrSivMQPsoPlS/eucd5rwzlQJ3HI888ggXXmnyHmS3m6jRQ4gaPYTwLZdQ/MAjVH38Pfa4eGxpOVTkdSTzuK40nzweWVWIhEIEN23Aqmsci2S4EODz+6lfv4GWwHo4ijLhvw3d0GkI+KhsMB+SSlo83igVZAXhigJvPbTIwdUYkABY7TZUi0x2RhKdu7dhWP/uDBg0hviWZrYyf4/+X5nyFmeediLf/TDvN0ntEmC32kiLTaFTszaMHXQcPQf2IaNDDtFZ8UiyxHnhCAs/+Jq7Hn6Mdbs2Ueur/12E6l/CEIJAJEhByU4GDB/Og5dfzsxVq/nmh1lk+32EDZ1NQscJVP2O7Vz/r3/x2apV5KWns6moiOLiYgIlJSREItRbrZTrZgCLJNEgDMpENUGO7XP/cHVK/uz4nwpKBIKwFqbCU8WaXRuZ+sqr5HfKRrFYCZZUEdexBda8bGLyspvWKdu1C2PPFKAio0a76J4YwyOPP0fboSP3sSXo138ws979gP4nn0D1tkLEfsibsizhsNs4/vixxKVnIcIhePFxpFbtzJp7vQZSEhCbdqF1H4KlfVdcUU5sVguh8ME/WCqEYLWAIel5WGNTEH4f0t23gwhDTT00S4XsVKjeBUByZgs8Xv/vKtM95YQTAPCVFuMr2EBUq2xokQFL15tW5Tmp0DIbNDM7o1isB+oOD5BmtRCXkcSYvAxOOfsKYrNaIoJB2LYZnDaE04Jhk9C8HizxucTn5HPxg4/ie/5h8pduYv32ItbUew9fiEuSkBQZyWohQZawSRKlQpASimDTNHYcoFtdN/B4/dx/2608/+bbAMgWq1lyCAQDfjzV1Ux58QUefOaZg+MOCUG35uZjJuDzUSZZse/ahT0qHikmAUmxIFJyCDdrg3OYScL75uuZ+MOBvc/rI4wNgA2B7vfw8A3XYqmppGXPHkx772N69uvD2BNGE5+cRO7zT2OduJi5Dz1LktNG+1snkdrVDJ7mffs9999yC8VbNpLMsVUp/rMUpxtCEIwEeW3aVE69+DzcCXHEv/kM9Xc/TP1PG/DkdCJuVCeigbDXxyMXXsqSpT/htlsZkp7EFRddTW6foUjKzyqyIhJGajznXO4oprw5jSFDBrNh45YDVqgoskKMI4qTBg3jjsfvJaZZ+l7L9coalKR4+k8cx0ttmnP+2eexets6vEcwKGnalmFQWlXBhfff12RoKWMaSfo5fGL+npg9bx6z93gfjSmVHwiFfvYVE4IKjo6x6f8q/qeCEjBPZm/IT1FNCRuXzeL64cfjS8zC5XCh2iz07t8Z3aawfPNGNm7ZyKKfftprfdlqwZoUhyM7naxGL4Tthp/ygJdanwexcgWW8nL6n3wOrVq14eZrr+P2m29Fi2j7zJZImF4op555LgDGuoUoP82Fl141vRvSk6BLW6QFK5FfN1P0jkjEJK1x8JG5phnU1HkpKqs2t+t0ISacCd9/Y9bg9+oIhRWEm8vYgIzMHKJrPHTVdJaxf3O/A+HWBx9k4JixxKZloF9zF9rmGajRbqSCUpANMxjy+BDd2jXVVhjI+51iKVEV9Bg3w9OS6HfeBcS26AKahnTVxTB/HuSlIQ3ujjSyF8oHPyAc8XDbE6S278E9T76OMyqegh9m0uq44w4vW6LIyBYVNTYKa1Ic2bKpmOpRVVLKq7DVNrAzoptTdvtBRNN5ceo0ln37LZdddDFrfR4KCrazdctmqmvr8PqCNPgCB23KJ4Ap73/ARbfcTGa7FmjDOqI99yKhZm1Rs0wVSxH0EU6LIbajKZ39/nvTCYSDh6QUezgIARgajrDGv++5k9WqFVmSee2d/xB9ucTlV1zOTfffR0afnpz5xbSm9bweD9ddcz1vT32bcCSCwuGdf78HJRycYN2xgKbrLN+4lmEDh/OfV1+gbe8exD39EL55S+g4oEdTOwP48NtvqA54yE2Lp/eoUeT1HwWAKNiCtHI2fPopkpBgUC8iKljOvpPE5FReuP1Orjz7bA4kbpAlyXR1uLnpsXuIaZaOiGjo6wswZsxF+/4HhCUO47hhuC89gVZd2vLu9DeZ1LcfS4I+fltp5/Ag9pBL+D2ZkYOBh6PvGXZo+HvO3/zPBSXQmBIN+lgVDFBfV4ko245TUYmPaPzrx8/YqEeIaJFfjyQlCcVhx5aZQrvLLsYVEwvAf1bOIWbJMvq+9zURu8r2ru2Y89V0Rp9+EedPOIuHn3ySOq8f9uUULEHz/Hxate2I0HWMhh0o7XJh8Xqo84JFgdUbICkZuXM3ABauWoJ8iIQAXdep9Xh595MvuP3hEFabDemiaxBnX0xo+huEvv6EartKcpee2IBP33mLIm8AN4f/QNi0ZStnTDidzz//kuiOPaiy+bDO+w55eC+kWUugohpRUkXYugmlpgo1PpHk9FxCoZX7vHxURSba7aTlyGG07GWaljH3U6gqBLcVVm6CokqktdthxTqk2FgYOR+69cMZZTpVOlNTcTpsh+zEK6kKqdEuMpPioHUukSE9yU1JpSHk48S4FPJw0Cqs8Oo7bzPn2x8OyCXSdYOF5ZX89NDDyLLUNA1kknEPXZNm5fp1XHXV1bzy2qvkXHEuO5x2dr73Lc4IyOmZZJ3Sj+Rxo5BkmXULf2Lp2hUEwsGjXuK+G+t3/2cPXkg+MP2Zp/nPRx8y5YUXGHzccdSUlbF84UIuvfEmCnb+LHL191SuOXiYHkMhVmxYSb/hw7ntttu54ZYbyNwjIAGwu10ktGtFwcrlGHEx5LUypzXFtnVI91wPHVqaarVRdli0DDUhmuDGFdhbd0HXImiqaqrU7gdWRWX8WRNJys5A8/jxPvAulk0rkf0+hOoCKYJzTHekRl5aQkoybquDaCSCR/hckyUJSZL38HcyMIQ4qlOS/+DY4H8yKAGzfK0MnWpNp7kWIgJEYUbb+y2UlECyqiRmpHHb6InIkswiXwWutWsZ9OZHpG3ZQU16Es5W+Wwu3kSP+hoSY+K5cMKZPPXQoySxjzSfEHg8XgxdR1YUdEPGUloDrbOgIQBuN2SmQpdeSIpKYFcB27bvMB+qh3K8mJ49xWXVfP3efznx7HPNQ7I7sE++DPWE01n34VTy8loQiUS4+eFHKNUPrr5/fzCEYO68H/m/Z57gxtvuIjq7J7VzZhLVPhfF4oCieiI5WdRHW3E0eIiJT6R7+0689d/3f9WXFein62Ta7Zwy8QokWYGyLbDsB7jiVHjtE6htMP1IvpoHwRBIZfD2S7B5E5x5PgDfzfsGu9VCgySh/+IGJkkSsiw1ua8KTIKqABSXA392Gi0yk+l04blcOvxUou2uX+3n6CEjGNmvJ2JLAT5x4FJqQwiMfQWqhwiB4PUpUxjcqxcTL7qQ3PMmUL9jG5KngRZ334g1PhaA7z/+nOtuvAlf6OhO3RwMajGvs6qdOxk2diyqqqJp/+vhx/4hEER0DY+/gTvvuZNvvvmS1199hdzWZjasoaGBz955h6WrViJLcN4Zk+h2wlnmytu3mIaCThus2AQrN0IwgiTJGG37QusupHboyA5FZn/EHQmJUkWlwW16pkjCQKkrQSrdjiFLyIVbkLLTUHJ/JoVumjGXraqVGlmGI1TSLUsSVtWK3WLDbrFhUS0gIKSFCYQDjQ7v+jELuP9Q/D0TJf+7QcluRDAfHHZgKweRnpMkerdpj6qq1NVUMu/TKTSkpJCyvRDFF0C32EjYWURpmpvy4gISY+IZ0rU7nyHhQZDM3oGJYQi27ihgwTdf0H/siSjOfAxDIGsC8jOgdTas24YxJg8Z2FawiapaD+FD4JPsuS1/MMR1d96Fpc7Dwg/+S7N+fTnpsmtIympG34uuBmDOnNmUllcckfR+JKLx2JNPceKJJ9OibXvizr0TEQ6hNt7cVMCxR/t1a9Zg7GP6Jg0I6QbjTjsTd0ISWlUZ6tMPQXklzF8Lq7ZAZiKkJcGKjVDpgTgnbNgEERXOPJ+Iz8OqZfNRVJk9tbhkScJiUbDbrORYLBhWFR2BEtIoiEQIGwIlMZboLq0597LrGdF94F77VuOrpyjcQMe4TGITEhk6ZAirC6ehBY5W0vrXMITB5Msuo3XHDnTt1Yv2d92M2ii3vW3NOq69+nrmLJpv3rSNP/7h/8upkX8CkoODGchqzPpxHnlt2pCbm0sgEGiS9JYkcDnstOu6RxZl3UIQBixYDcEgWG0QFwXZKQRXLcF51iW07tqNdm3bsnT5yn1ud7dH1fy3p3H62ROIzc3CNrQT2vcfmFPB3mrE0kKMLduQW5gcp9zBfc3s3xE6dkWWcVodJEYlkBabTFJ0Am67y3RuDzRQVldJSW0ZdX4PIS38T9bkL4r/+aBkN4KNrwNCgNB0UqJiAYiNT2JC+wGsWzgbWdNRFJXN3duRWF5Fy5oQ7dqahmKPTHmVnULQjF9rGRjC9IB46Omn+Hrsiahde+PfNhbbuS1Q8ltDTCxIMnJjSnT95m2UV9UddgWJYQgKdhVx+XXXkW1Rsa9aw4qNm3jhoy+a2nzz5Rc47NYmrY/fc2nrhkGdx8t/Jp/H7V98gTslxRTG0nVqyksJ1tURl5LKrm1bueTGm/jxx/n73N5OoFaWyRo0BIBQZTnatkLsoRBU14LTamZHCkshrIPTAhEDbFZodMSMeD34A4G9gi1Vkcl12GjudmLJTKJdtAuHy4EQ4GnwsUm1M6jfYKriojnlpJPpmdMKQwg2ffkR5W+/iT0UpiwpmmXH9aVZj3HENsujoFkKPyTEEC7XDpgOP9LQdI13H3+crh9+iGqxUFtbywuPPcFjzz9PIGTqRvxzo/57YceOvem/QoCm6ZTXm8OrkuUzSPA1YE2LRyreCDFRcN8FIKuEl1cRe+FVAHhra6ioODBdUzM0PJ56vn9pGqc9dguWE4ej33kfRuEG5IgGNjvBK25FeuJhHJ1aUF5cij98ZByLZckMSLITM+nZqitnjx9HXGYzXLrGrh21bF23mZ0lW6jftJhFksw6fz3B8JGeNPoHxwL/BCWHAiEwgiHSnT/bPmf16EdWj37Ud+jNxscfIGfjdkqzknCMNDkP61Yu56eFi4iwf3GlcFjjx5+WsGnFMlp16YarcaphX6hatY6aeu+vSkUlSWqqUDUtEfZ/OQoBpbKM32knLTmOM7t2QY+EUSxWIqEgFbs20Co3g5KKGqprG0iNaPg5fCKZpul8uXQpM3KzCTXPJy0lmarKSsrLy3AGQ7j9QQoiOjW/cfPyCsEH702na/8BuNp0InzLg4SvvxRrlNvUV1m+yeTgxERBRjI4bKBp0KkTAH5PHRVVdU1iUd07dODtN99k9cK52D21tBjQj/ScPJzuODw717Nr43ISWvUmq1PPpn0IhYO8sW0x6+IMRiuQvGUbdXIumesKsXQyAxAlLhrF7UCqlI/5TfHLb75hxPTprN26lfuffJK6urpjvAf/4I9GRNPxlpqZE4fhpnpbETFWGZcAthcj3p1JsE8/HLfcB0Dltq2cMOF0pKISYjHdn/fZr66xRAsiZs1ivH4TstOBnhAD4XQMTSPcthea30/l57No26kF7vgYvEEfYLqDS0hNtgmikf9xsNMsVtVCUnQCvVp35+HnHyK59c8Vks2Bdt9vZvPH37OrspT0gB+vobNFi+wt4Lann9jfITg/yt43fxT+CUoOEUYoTErgZ8LeukA17RwJxAwZhn3ud6SecAp5hoHc0pzrfeH9d9H9wQOeEIYQBAJhzr/wAq695BKy01IJlBazqnInxs5CSkMhtOgkEuv9fPfRx4SCP29fkWWsFhWrVcUqSXRXLaR06cqMjRspLSvbZ0mvIps+OH2apfHIY0/SduTxTcssNjvPPvkv5nz7GS+98w6rNu4kubqOgPh97PbVAIEQ0toNrFu/8WeCmjh4SXjDEDz72uvsLC/m7anvYe3Zl4YzzyHw/lRUA+QYJ/ZwBEkBWmZBUhyEdIyho5GBWfNnUlhSRTAURgg4/9zJtO7ShdaN9gN7IqFjfxI69v/V5+uW/4j67ef0qfOhqQohVcblD+Cqq4WQmWvLTU5FAeKFcdQrAn6J9X4/IydMOMZbPTaIxrxh1fxWw/9x6IbBy++8w5mXXEpc9954z7mC4nVLSO7hwlpZT6hwK9bh4wH48bsvOfeiiygsqaAl4GT/QYmia6R6aqjeuZmGmhpikhJRnnuMwMdfEwxI1FY2kDJ+IBm9zespIzeHjIw0thcUYFWt2CxWVEVFCIGmawQiQcK/DBwaIWOSoXcAOhJ2i53hg4fz0CP3kpiXheH1o305Ezk9GXVAL5KGtUDUeAh4qigVOiklWygINKALAyQJlyKhqipeVQEhEJpuvvR9q3X/gz8O/wQlB4lEIAnYENZ4/amnkGtr+KZoG88/+iwAu7ZtpCovh05dezWtU1Nbw1uvTcEI/rYapW4YLFqxmrOvuoYOqkKCKrPVbiNX1wnqBqs1nUAgiKoLDMzMiM2qEutykJ+SQGxKHBlpqdxz0/2kdzGrdF5+/FGuvetuQpGf+SeSBA67lRbZaVx5w3W0HXk8wjDQC5eCVUJJ7UZ8TktOvuRGOvcdzBXXXMmKZWuo9Bxk5b/UWE2ynyje9Kc5/JtAOKLx+Vffc++9d/PQo0/guuRaxLmXorjchD11BAp3IG3dglZXglFbgcWdjjPZtFL7afrH+IoqCIc101m3x88ZEKOqHNYtRdq0AUkIGH8WJP7agq1TzyH4HA6Sp35Aw6bFuBt8OHwFNMREsX7Henq068hVA8fwhf9WNF0/5kHJXx2SJKFIctOI2mgKWkWTId4/QclvY8GSJZwz+RzeevsdsgaPgsGjmpY16jDi9/u48vobKC6vIqLpFAPeA/QpASEtRF1dGa8/+zxX3XMHjj7dcfQxpRHSf9G+cudO8j0NhOJTSYtNITk6EbfdhRAGISJsLd5BWV0FdX4PYS28l3ZQJqYfTgawS5I4ddgwXp7+OgBGvYfwOVdgrFwFzhjEo/dgOXE4SWPbkVxsCjQqAQ9WTwWt0LG47IikOOwxUfSZMJGTeg9g2rdf8uY7UwlW16H7AqAbOIF4DmwM+KfC35ToijhEzJkzRxx//PEiLS1NAOLjjz/eazk/f1V7vR5//PGmNtnZ2b9a/sgjj+zVz6pVq0T//v2FzWYTmZmZ4rHHHjuk/ayvr9/vvhzOKxdEdxAyCGRJyDaLuPX8c5q25/HUi+raaiGEEOu3bBKRSETcfd21ooXUuM4hvCRJEjYQiiKLuMZtSr9oY7dZRLP0RHFBl5bi36cNFbM/nSKCfu9e34HPUy/ys9OF3WZpWl9VZJGaFCsuP+eEpvbGt/8V4uPHhJjzohBbPhNi2ffCiESEEEL89PWnYkxKnGinygfeZ1URstMu1Bi3UOOihRrjFrLTLiSLKpCO3O+w+/uxWlTxwxefH9I5MXvq2yJbMY9DVRXR4KkXQgix6bGbhP+EfkJceJIQY/sJ8chlQtx+jhAv3CFEsML8jgxDrKko2Ku/0rffENuvuUwsHNBNzB7VR/zn6VuFEEIEggGRmBwncmTpiB733/klSZKwKBYRZXeL1JgkkZWQLrLi00VKdKKIdriFVbGIeBCJf4J9/au8JAlx7umnix0bN4qtG9aLxfPmiLWzZwmt8dp+4f77hEVVDuu3sltsokvbTuKLl18X639cIOqqa4QQQmjhsLj3kstFm5atRb7DLQbHp4tTex4v7jnlerF82nciWF0n9IgmhBBi19rN4tzjJ4rM+DRhs9h+tZ3oxr+qrIiPX3xFCCFE3dK1om7cRcLXfqjw53UT3uR84UttLvR1G4UQQoTLa8W7t74kxnYdLhKSUkSLrBTRfkBnceXjd4ii8pK9rt8du3aKEyadKpRol0CRRQsQrf6A36m+vv6Q7mO7n20vP/uFeOvlWQf9evnZLw5re8cah5wp8fl8dOrUifPPP59TTjnlV8tLS0v3ev/1119zwQUXMH78+L0+v//++7noooua3kdF/WwH7fF4GDlyJMOHD+ell15izZo1nH/++cTGxnLxxRcf6i4fEexgD0VJQ2CEIzz29jTqFZV77r6XlMwsAPweDxcMG8riiiqaBUOEMEcQhxJ9CyFM4SndoHYfyy2qQmung95JsfQ7fhgnnn0ZUS1MFUzDU4n3+6k4h5+DMyaesyaezsuvvUFVTQOarqMqCtEuBxMmnYfN4UJ4a5BWzYev54PXZ4qoaTr0XQtnX0vnwSNoER/HznofkhZG/HJnZBnZbsUSZwqKqTFRSFYVIxxBq20gUlVHpNaDEYqYMvZHAEIIwhGNMaeeSvdu3Wjw1FPvqSc/L49OHTswqG9fjj91ArIss27pT2S3aoskBLOWLKWwcR8yMzJwR0WjaxrW7VtRHQ5w2SExBlZuBqsKsgUWfw4DzkeSJDYumIU/pRk9ew8FIPWsyXDWZOILC1hy8yWk2k0tFL/fT60/RNWvvqx/sC/IkozNYiXeFUtKTBI5Kc248LzTqfL4+XH+IpavXklNoJ6S6lJC2m97Sf0DE0LAG++9x1vvv48sy2a5uyTRsWVLTuvajWenTiVyEDYGv+5XEIyEWL1xDeOvuMzsW5Jp164taQ31rNiylXLVQr47HmezNgxs3Yte3XrQ+YxhSI2OwgCZ7Vrw6of/4Z1b7uXR115myy+0oXZXQgoE1kYF2sjW7WBNQk3WEDW7kMIB8HsIXX4dtnffxJKaxOhrTuWTJTOwBGKpb5lG/qgBPHrB7bisdhrCAXYsW0CLDj3IyWzGi08+R6vlSwkWlrPLFyD+d33j/+BI4JCDktGjRzN69Oj9Lk9N3dua/tNPP2XIkCHk5eXt9XlUVNSv2u7G1KlTCYfDTJkyBavVSrt27Vi5ciVPP/30foOSUChEKBRqeu/xHLi4NxczPXjY8sACRETju1ensGbadFJHjSIuNobSJUtYt6sYHTOI+S077sOB3WYhNz+LSVddRd8zzzOlynUd1s1HtlQQvXwVhuU7GDeByRMm8flnn+H1BfEFDCRZIjMjg76DxwAgFS2H6jrT/2ZXOWwpgmE9IMt0xLTaHfQdNZqvXn7152mZ3ZBlFJeD2LxMHrvlNozkWDboPrZ4a9hRXoK/qBzfhh14120jVFplpkmPoIpoMBjix/kLzOOQJHbtKmHejwt4+ZXXGPDCS0R0ncUrlps27RF9LwntmJgYsw9fA/gCiHY5EAjBthqoaoAopym9X/Rz9cyKTz7iwRg3n+e3ISEmjtW1xXSMTSemWQ7D3/22qV1dZRVGcP9+R//gZ0hIJKgWejtjsKS3JD+nHSeedgL9Jpv3mLNvuhRD00GWeP6eB7jtkYcJHkXH4L8jzDJiHRrjjyVr17Fk7brf3a/pwP3z1PTi5UsBM8jMUSw0d8XSLzaFvt170PnsvkiyjDZ3KZGX3yM46jysfRJwtUhm4kN38fp771MQ9JpB5y8gBEz79lvGXDCZuHEjqC+ogs+3gGpDNGsLBeuQtu2k4eK7cb58P9FpSVx36xVUvDeFtmMGc27/4bisdsoqS5j29dvIDV7eNkp4uM9EMlLTGde7J5srv2N5OELJMayW+934h+h66CgvL+fLL7/kzTff/NWyRx99lAceeIBmzZoxceJErrvuOlTV3J2FCxcycOBArNafvVBGjRrFY489Rm1tLXFxcb/q75FHHuG+++7b/840epYkyRKGLJNoGNgFVBoCYRw+2SkAlPt8/PjRR/tcfqQDElmScDsdPP/fj8ho3mhEV7IL/u9BUMMgKVBajbRyPmLsqeR27M7EcSfw+CtvEGjktgwdOBjFaiNStgvLq1Pgp3Wm1LxNhYQYU3m2tKFpm4am4ZB+LWqvOG0ktMrj47en0rd1h72WGUJQHwnir6pg+cIFXHLvPVTsKPpN0q8EyLKMosh79WXoxgH9aoQQ6EKgGwbhiMbOOfOwAQ37ae92m5k5Qzeos1lJbPBjsVmQQobpy6Np4HIivvoGTr8ASVFwWuMonzmfbmtOJDE9iTinnQEDh/LoJNNIsayygsXz5vHv555DaEdGLOrvDlVRGJiZw4k9+mCtlUjpPJROvU2NDb28CjkuBtlq6q2M7NOb1VYb70TEQbnP/oM/BrIkEbQ5yYxNJLNjDzpP7o8S7cLYWkDoiReRgwLL+pVEZm7DePUWrE4HOR26sGpOGWE98qvKQSEEX3z5Bct/mEPXoYOIu+lcvDF25CeehIAX5eQTsd57CzarFTnGvK67DxnAzOGDm/owDIPV/3kJhwgRU1lN0s4yCnL70iI9nxFjx7J28TLkQAhdO0YOv/9gvziqQcmbb75JVFTUr6Z5rr76arp27Up8fDwLFizgtttuo7S0lKeffhqAsrIycnNz91onJSWladm+gpLbbruN66+/vum9x+MhK8ucUpEUBdlhRY12k2FVEQ4bG60W9EAIi8eH7vVjBMOH9SA51v4YkiRx4qhRZDRviRb0I83/GuWdN2HLDpAV82FqVZE8DRg/fIc0Ygxjhozi2f+8AxI4NY20KDNLYEnNQlx1H1LGR/DqayDqTOVHXYPqAAANNZU8OeMbtv4yKJdl1Gg3bz7+JH1bdyAUClC0bCGWNm1JiUrAplqIszqIS88mY3w20Tm5nHTa6dQVFu9bbh9QFBmb1YLLYcPtsmNVVQxhCr55fUECwfBBy8M3cGBTrpraGgzDICo+gfxHX8H3+TtY3vsA69ZCJAOIciI+n0eg3outpholKRklPomGXeWES6pI27CdsN3Gv+ev5Ie3PsDb4GPz2nXmefRXGm0dIiRMp2ZljzS8YYjDkviWMNU5737jdToO7Ef9jgrkSj+uXPP8DD/8EvrmHcj33ISzd2siDSHczhhsPlPd9FC39w+ODSRJwmK1Iee2ZMz1E8yAZPM2ApfcabqQV+xECXoRKbnoJRXIORm0yM9H/VFBQvpVFkwg8IeCnHzGJF544UXGnnYCUZeeiddbQ+SjL4i++ybkpIS91tmt6wSwdtNyKmbPQqxcRatgkPgdRWh2G4Guc2FCPm1btKEoOQ6puAIOyVHsHxwNHNWgZMqUKUyaNAm73b7X53sGDx07dsRqtXLJJZfwyCOPYLPZDmtbNptt3+sqMkqMi1aJMQRbZKNnpkCsmySHnUhVLYGdZQR3lBAsqUCr98LvcMU9VmiRYwZsvqLtuNcvhIpqqPdBIAxxLvMlGUiNmZSyhjrTYwWI0Q1i1Z8zUFJOC7j+FjjnfBg/AiQJsauKUFomdqC+uprqBj/aLwI2SZFp360Lxw0xXZJnPf8I7m9msKVPV+weL/62LQm0yEPt2IFzY5ozqFtvnr3rbs679HKzDO8XsKgK0W4nqUmxZKUl0q5FHrktWlBdWcHGzVsoKCqnqKya6lovgdBvqzX+Fodnw4aNnHH8WP718iukZGURdd4NhLoNIbJjK7K3AW3BLMLlRegXXIIzKZmq8jJeeOttgr4AOZppjV6oKuQoMvb126mXJDPW+hs/KGVZwmax4HTacNpt9O7Rk+uuuJoGv5/FP/7IQ//6F6Fw+KC/AkmSsKlWOg7sB0BMbrI5rwro839CfPcVkjCw1JYBrQlqFjak52ErWIs/5Of3yfr9g6ONa++9htjsVISuE3rkZSjageRrQGhBROk2pKQsJMW8L0V+Y0CoGRqVnmquvvIqagsKOeumK3BeczHaxZNRot14y6v4/s33OfnmywD44MvPOHXsOOoqS/loxQxSq8vpWFSCq7Iab3wsNl2jYVchABmZ2cgWFWTprxWT7KbKHkr7vwCOWlAyb948Nm3axPTp03+zba9evdA0jYKCAlq1akVqairl5eV7tdn9fn88lP1BjYnC1aoZaXmZ9OrQjrPPuJB6m0ywrpYqBZ5du4CdC5ZRv2A1vvXb0Rr8R4yQeTQgEMxYvJjrAVdGLsFaD66cNPOCUiQIBMFiBWsUUm5zhKHzzntvEY5o5OgGBcDT/51GWscO7CraQl56PN1HnwWJSYTOPA2lywDUXgPZHUYunD2b6jrvPoOSGy+7EoDtnkrqi3YQJclUpyfTbmsBbX5cgicxnoKOLZmV14LRl93KyaedwVU330JD1d5FnYoikxPtpE12Oq26tWbcmLH0OW4SisMsXtTCQaoKtvHJ1Df54rX/sLaylp2R3z89svDrbzilUwduevhhTrjgImwdu0JHU4VXnXQBasCP2rgPjz72COWVNeiaTjXmhVOi6WiaTjwQIwQyfx7L+yMNi6oQHeUkIyWeFjlpnHD8iUy6+HrURgLiyJNOZshxozj+1FOp93gPKoshSRLRUT8LEWrbC8HjR3/9LbTv5yKHAoiAHznDLAYO+AVumwuLojbym47Osf6D3wdDCJJSk8nv1hGAwOP/grk/IIVC4K1COFxIip2wzYorw7yfr123Du0A2a/d5NrS2nJufOg+Utu3YPjokVgtFras28i/L7+OzZs3MWTCWHTgpbfe5NSx47Bb7NSkJ1KZm0/PD7/FVe8l7HJQl56Cb9c2ADLjkxnXqQdv/7T2n3PqT4CjFpS8/vrrdOvWjU6NapoHwsqVK5FlmeTkZAD69OnDHXfcQSQSwdLo3/H999/TqlWrfU7dHAi21ASie7TD3rEFF5x0KbkJjdX0jaIHQ7Lb8UrrLrwaeYVwZS2pgSD+sPGn1UIQhuCnxYtp8NQTFR2DxyvhSoqDYT1N8a7FG6GkAtEsuTHVrrB9ZzGx/iDlQB6wYsUqrjnlFOzpCXTIzaDriAnIqort0jv22taqnxZw5e234Q+GfsXnyMnOZsLoEwDIi05ic3wKmryT1gtWELZbqU9JoDotBVkYLKzfRbfSIpLTMjnztNN45cWXm/qRJLBbLXRMiOXSsyfR5/SzcWXkmMdaUwVR0ahWO6kt23HBzXdRtHgRO39aieLx7VMY7lBQDJTWeZh43XV0eu1VLhg7huZdOjP4pNMAUB1OtEiEmZ9+wgsvvtwk7V/HzwJTFY2vv3NAIssSMVEuWuWm06tzSy6+4jpadR0MgH/JfMILFxF18RX0Gz6Se26+idvuf4BQOHJQGZNAwN9kRln19IdErVsOpduQJRnhjkc2BFK0aXwYDgSbqjMOzSP7HxwrNAP8hk5xWQmVOwpIys1BHTEQ3wfforqjkRy9ked/DqGt6PEjkWQZb2U1mwu2EtYOTGA2A5Mg4YYI5194Ae88+wzbVq/hyWf/j5JQkKRIiHM6dqQQaHHyOAAa6qpxFhaTXrWVoNWCy2mnoFNb1o7oR87qtU19xylWjIjGXyoq+ZsSXeXfbrI3vF4vK1euZOXKlYDpvbBy5UoKCwub2ng8Ht5//30uvPDCX62/cOFCnn32WVatWsX27duZOnUq1113HWeddVZTwDFx4kSsVisXXHAB69atY/r06Tz33HN7TfscLKzpScR1asXFJ0xqCkgK1ixn14yv8TfUE2dzcUvbQSx84N+cddJJxKsqKYe8lWMHAfj9QRYuMKtOOOcS/MefiR6fhVi+CeHxItrnU5OdbBJ4AX9YsCOiEw1swzQfDPiDVJRU4dtWtleZ3qpli/i/667gzZuv58yTT6am1rPPh/+J/Qfs9d5nkYk4bDRbvpZWPy7DGx3FipNGsvCkYWRuKmLF158BcNZJJ++1nizJOB020jq2ZsgVN/8ckMz5EmnC8UjtmyMmnIAIBLC4orj9/S8ZP3kylj3mjH8PDCEIBMMsXbmaTx98mBfOnMRJw4dw4TmT6NWjG3FxMYw9YwKBYOjA/RzsBqVfvP7kkCSwWS1kpiUwdEB37rjniaaARKz7EVvDKiwpQSpnm0TvM8+/kNhoN7L827cWIUzCqr/BlOwKO60YVjuoLvBUI1UWYuR2QttlStDFJ9hIqC4lK+g7IOn5TwlZQlIV86Uo2Bz2317nL4hoTJHJ6rpqTptwDlogiLV7F5wfvIz/zvvxd+mCFpdMxBaFaGbyQFatXENVQw0R/be5WALQDZ1dJUWMOf00Hn/wfrZ566iPhNiC4PP6eirr68ltfLQl5TTnxpOvZkD73ljym7F01ACEbNBi7ny6tTSzooXlpbw8bRoiHPndMUkrzMDsHxw+DjlTsnTpUoYMGdL0fnegMHnyZN544w0A3n33XYQQnHnmmb9a32az8e6773LvvfcSCoXIzc3luuuu2yvgiImJ4bvvvuOKK66gW7duJCYmcvfddx+WRknP2GheOPES8hIaVT2nvsauebNw+nys27WOoc5Eup1xLknRsdx+0eX0eOMtvP5j5+56OAhrGjO//pqRx40mvn3Xnz/X4/H95wVqNu5grcfHiY0PhqSUDCIr1rGzsV1N40sOhgnsKOSG40bSefAQZqxYyvoZM1EDARLCGpqA/d0mXn7/fSafdRadBpvngiM+DrvXS3R1LaqmkVxYQvK6jSSG/WyLcpDdaGK4o3DXXv3IiozLaWf8pHNRrDaEFoTPXkKqKgVZgM2CVFOOuOtq9Ktuw5mdx73PPM8bH31C4a5i0oRABQr5fdB0gw2AGoyw5Yc5QOOU7ZF6+EmNDyWriqQoSJKE0A2EppkjtD8pl0mSJJwOG6NHDuO2ex/DEROPCAWQZk5HkutRBDjDIWyVW9ECPlJS0xh/yslMeeMdAvqBlYyFEIQiYbzVNbhjY4gf1ILQip+wxcWBrxQRkwxRFpTWJmE9EvaiNdQSHwqRIQx2HbD3PwEkM1Mp2SwoLjtJqWm88+AjdOnbj9jERG68/FKeevnVP/V08aGiAJNgLnSNJauW8ulb7zD+kgux5WaRkguMaEnwyvFUzZ5P4qhBACz5aSGeQMNeGiUHAx+wsendz9dpHDDrww95p38/xp52BvHRMcQPHwfDxxFduInNX35EzKwfyTn1LAAefuYpAlW1++S6HSxkSUZVFGIMsKoqblnGMAwiegRN1/8pYT8ESOJvSmH3eDzExMTw2rTXueDM8wn4Gih85AH8X35JjMdLYfNMJKudqrQkWnfvQ7uLr2H+skUMGzeOUHn1n/YhsRsOh52Hb7yR6PRUMpMSGXbiKSiqOdXlLStFj0SIyTJj9oduuIE7Gyub9gWp0ahqd9VvlBAEgAM+UiQJW3w03777LoOGH0fA18Cqx+8mL689ro6dqdIC+Au2o69bz7rqKnrcdCd5zXIYf9qpfPTBh03d2KwqvVMTeOuNN2k2ZBRCjyDN/wQ+fA8WrIW8DBjRCzSNUFo7bCeeQ0XhTtp0ak9tvY+2QmABVv6ub/PoQrKoKC4H1pQErMlxqNEuJEVB9weIVNURrqhtFJgLgyGIx8xmHevKrn3BalE5YcRgpn/yFYrFgigvRnrtSXAKWLEBPH7IToP2LQh1GoKt53CWLl7IiOEjqPf6fzOoU2SF+6+8mtufM8/P4PadKLqOpYWpa6TX1KHExxKorOaCM85n3uK5RPnq2YH4bVfvPxKShGyz4oxx0TYhlsTBfXjihntom9eiqcnGjevpOKAfWr33b1mxJUkSLWSVId160vz4cYwYNIC2vbpi+UVBwg1XXMkzL7xwxB7cTszBVMRqwZWcwKlnnMZlZ5xJ9269mjJ4eiSCYrGwY+sWWnXpTMR/eBpKNgDVSrQjigR3HGmuGFS7C10Y+II+yj1V1Prq8YcCaHpkn0dYX19PdHT0PpbsG7ufbS8/+SkOh+ug1wsEfFxy44mHvL1jjb+9983YYWMBmP/fl3HMn4OWGIe9wUvyzhLKWucTiHFT2c68URQ1eBo1Sw5zYyaJA0mRkWTZvCELYUbgR3g0FAgEuf7Bh7BaVOLtVnr2fImHHniYVt264041s0KhYJCF33/Pq++/f8C+zOeGaJpyrD+YHRCCsNfPuEsv4cfPvqRD2/b0vu+ZpsUugB794TRo3/iZpmnM/H7GXt1IuoEtovPTS8+Q1rYdlpRMaNsfPv4AyqvB7wenHWwW1LGXAPDVR9MxGm8gv18C6uhCsqiocVH0PW4E1553PslpaeySIlQ11LFg23oWrFiOb/0OvGu3Eio1RddaCLDw5whKJEmiQ4dOKBYLkZJC1MmnQ1qsWTo+d5VZ4tm9PdTVIy+ejdF9KN179qFV61YsWbbiN6exdUPngRdfYENJGc+98Dzxedl7LVfiYwnUN3DxpEuZtWIRNSE/xX+BcadkVbEkxZLYNo/rrryO00afjKKohBo8fPPKUxx/zV20bt2WdkP6sW7WfLTaBsRhqKse/g5KP7vm7nYHOcJfqhCCgB5hwZJFTF29kkcftxITHcPIQf0ZOHIEI0aPIj4pia2bNh7RX7RJCiCi4Suv4u1Xp/Duhx+Q16ol1004i7MnTMJmd7BiyWImnXfeYQckrYA4ZArdcbRMy+dk1UJWbAL+ngNR3G40RWf95nV8N382hdXF1Pk8RPR/9HV+C3/7oMTWmD0oCHrQBvckvrQaRZHZ0aU9XqeVnHWbSLCbgjv1JaXmaPUwkkeSqiA7bLicdqJddurcLjAEejCE3uBD8/gwwpEjmoERQhAKR0gNRyj4YQ7d5g7E4XDSq3t3rKqFH+bNw+c/SCO9w9l+WMO7s4jXxo5l8gsv0GnkcWzesYX3Vv+ExWqllSOWzOg4YmLjSU9MYsa0adTX/xzy5AOxukFdRGOOEaH5im/octyFCLsTqbgKslOgsBzmLcc4fiRKVh66pjH14w8aSwj/5I8mRUaNdvHRG29yfCMpeE9c1HkQp7T6lO1LVtI8GCLsC7BSgBEMEfMH7O6+IBDU7T6Hysuhvg5sCsRGQWoCGGHQI1AfxthRSuWapaR36sn5F1zIkqVXHNQ2QlqY9z/5kKVLl3LfzTdRV9PAjG/mEJcYz7gxg1n03ntsXbiAmpCPiKYd2V99t4Hkbn7PbvLg79iIHch32KhsnsX9N9/GhKHmb79j+3q+Xz4LtbSAooKNZDdvzzlnTeKe7dvxh8L7VTyOxqyUrgN2SeZIX3DoujAAKDKy1YJstyLbrEhAjK5TE9YwQmGMsHZEB1C7gF1CRwr58YcC1Pk9vDr9v7zy7jQA3FHu31TfPmwIgYho6LqOEQixsbyGS+b9xD33P0iXVm34euYMUy34MCcLaiSZGFcMo/sP44JzJtOmcxti8tKRfsF3O+n7Bdx16x0s27yKWl/9IU9T/a/hbx+U/PDTAsaPPp4+Sc2ZUT6XeEOjZPIZbHMKTn35A5JPOp2kLqZOwvxZczAChy4PLllU1Bg39uw0OiTGYkuJZ2fLZoiIRuaOEnZU11O9rYhwWRV6Q+CIj4gqgbAhCIU1QmEP38784Yj2v18IgaEJqgsKuerkk1gaH4visCEpCkLT0QNBWtQ14AtHsBkm90PlZ55KCNOVtDwcIaa0itXrN9PlOMDhQug6ks0BOekYbfLQr7sNGVi/aA5bthUQjhxcdccfCdmiYktNZPQoU9J//cblaAsWYo9PJG7oCJKi47m0ZW/eLS0j0L4lFd4QsQXlOKpqaQiHsaETlqQ/VCTMMAT19eZDw8jIxLj2VpSKQqAaSmogGIBNuyAuDqN9f1LbmNV2F19yGTfedDMNDQfynTUhhCCkhdm8cxvnXH0lqbJKvWoBBNO+eZ/scIgSQzvwdOKhQpKQrCqyrfHhrMjm+RyOYATDv8urKVmVkWKjyM7LoFdn00F3WtVmZkSKsbXMJsFuo/P8uWQ3b8/FQ8fyyucfsqO82hTeM/aexpElmYgkY7VYcUgKaapKEDOQC2thNF0/6IecZFFRo1y0iIvCkpJATV4Wn11zB4FgkIvuuJ4dpdVEl5u6RJEjfM4JIcxsyC+6PWoByZ4wBMLQmqbISnbspGTHzt9Y6cCQJImQ3cnNTz3JyRdM3kusTfiDiAYfIhBGbpZKzxF9ecbyMOMnnYM36NunlP4/+Bl/+6Bk6tRpjB99PO3OOIe0Hn2Iy8lHkmUCvgZsx1+KrJhfwfvTpzLtww/MkcKhQJZxOGzYc9OJGtgV0Sobe0oCzds05y5bHnnOBO58/yVWzpyHEo6wXdOp9gePqAfMH221vRzQQhqRiloiSuPI0xCmcaGuIwGbMEd8e367u/fbFgxRUFzJwmXrmQxIikrklgeQwwaR8m2ow07AEpuEoeu8/NSTpNQ0UBjRaQVUA1XH9GgPHq0VBTkjFUU2b1hrX3qekNVC2zmLCC1YSNLjzzLGnk5Fbnvm99NJrNVo7bdgx0F1KMRF3hqWaRo/GdoRH11JkoQsyciS1EToTTXMCq1yaCqJNwyDmto6AGzJaTDxXFM1eMFccLaE116Ecy5DnHQGjj1sIQDy85s3VekdDAxhkKqFCRImLgw7JQkhYN2RzohJ0N2i0pAQi5IcjyvGxc7keEREQ6ttIFRWRbi8Gt0bOCyV5yKrlbjkOBLb5pMTkwiA/tnnjFq9llWjB+PyeFlUVU5+SSEx6c2YNPZEHp2/nEhV/V7cElVWcNocxDpjkGOT6S9MWf4tVjs13joqG6qp83vwhwK/fX4oMpedfy4DhgzmrU+nIuWmMmnC2XTu0BuAh198hcuevJ/0BauI1w3WB0J/KwLukYYsyUw+80zGX3w+AMGFKzCKQhhz5iF/NRUjIQ3ZEYN+yhlEXXsyrfr3JCc1i5qqYir3oVp7WPhHPO2viS8++YTVy5bSsVt34htJZv5gAKfLnLJZsX41z015hf9OfRfdGzjkC1G2qnR32VGyUqkb1pMzOvTm3KR2uK0OZJNBymUTL+L5rdsIVNWxQdOQQpFfjYj+yqgGgmBmgPa8h0uwQW7k2EgSDYBkGCbHZo+RWDiiU15Vx86yn6d2LD3NkmMFk6Hvr67iqQfvYtGc+UiBIBI/Bzl/xqAkFrDIEp1amqq6WiRMSXYafad/RVJBMZXGTGo2rSe+VVvObzWIxMQ0/Bs8xBWF0CI2Nlsd1NZWoHurcDbU4A8Hj0hgIkkSVsVCbHQski5QFRUhBBE9ghTwI2shAntsxzAEGzdtQtc0hGGgWq2gqjBwKAwcijh9IlJsHBJQVlTA3A8/pFv/QZSXV7B27dr978h+UIw5VbENjk7ZryyhOB0YCTFY2udz1cSzGdF7EJstBuHiYhYU7+Dtb7/Gs2wDwZ2lJgn1EAITGWgpBNV2G+lpaVgVC4aukTRrHj6bhVHPvY4nOoas7Tvx9BtDTHozRrXqyON2K8gSiY19VEkybruLzPg0Wqbl0y6jJdmqBYfLzUk92pKQ6uLfr7zJojXL2FVTjD8cPGBGTbHb+PdLrwKQOrA3z0S2c3F636bl49p257iXP+Dufz3Gm8+/glxWaWaN/8E+IUsSp55kaqGUvT4N+1ufIceloSz5Eqm2EikShoxWsGoz4ZJqrOkJnDFsAN61i6g8QqqxkhBIh3CNHErbPxJ/+6Ak4gvQc+BALp00kYDDzux1K4l46ujYuRtFxcWsXbkarcGH4Q8d+rSKJJFjs9E5ykUkJQ65dx+uiOnSNDL2lJfiSkike0wGE6+4nueff5K2Hh/LqurR/0Zs+306LSsyit2GEuVEjY1CtllBCHRfAM3jRfcGmlLkQgi8/iALlqzg2w/eIyouls1bN2ORBENGjiUmJpZnTh7HM0uX4Y3o7KaKLTmGx3ioqJMkfBaV5yaZI6lN29bQdu4y3HUNgEHWui0U33gdPPs88fktGe1Ip6ptN/zxvZFnfU/zqhLWZ7ZgV30Vnq3L2FX92w+eA0FCwqKqRDnc/OvxxzntwnPRNZ2q4jIqtxbw0UdfM2PWTIpqSpG9tch7BEGbt2xjTPt2WCxgz0zi/Amnk5qTS/uug7DG/ixmeM7E0yhfuY6QN8Cmw7z/acCWw1v1oCDbrNgyk6nq34Unb72b0/I7A43q9lltOAFw5zXj1Xf/S92cZfg27UTzeA86s5kF1BsGqf4QbWJMMchARTnZS1ZjDYYIOmykxgXJmfoBthZmwPrN/Bk4Qho+IUgAFMBntdMnNoXWeV0YMHg0g04cQHROIkq0E0k17y+PtW3Nc+dcwfeRAGvqqwhG9h1ESKqCGhfV9H5wWj4DRS6yJFNfVsKs8i2c1GkQVouVR6+7i7zULK667kbCR5gD93eDJ2TeiQJBgeqMw7llGVIohJAUcCdCQio43YjKakhPoG3bVngUFf7huh4Qf/ugBCDkD/Dca1OQFBmXIpOFYNParWwWAhHREYZBduMNYfmhdCxJ1LpslGWlcM5F13BcTFcUWaZkwxrmfDYNZVcJXVp3osWV1zMqrwvFo05g2vKNWK0WAofBXfmrQFIV1GgXtoxkHPmZOPIyUKPdYBiEK2oIFJQS2FFMuKy6SdbfMASeBh+nnX4GyapClc2GrMiIm24jMxzBEgpjiL/S9WwSEZulmJVQ7tgEats2pyo7jS5fz8UeCGErK0desQLyW2JxukmqqiP0/TwoLUfTIigJ6RTnphGuKiLFU8PCcIjwYQyxTOM7CylxSbz22quMGDcaAEVVSc/PJj0/m06jBnH5xm2s3bKNTRvX88Vnn/DNj3ObCJUztmzBbrUQU1aO2FxAMDWe6MQEBg0fwwljT8Hn9bJ09UY8/tD+/Bb/eMgSSpQTd14mU2+8h/75nRBCsGj5XLRAgI6tuxCTmMJNHYYys3Q7G8urCVfUovsCB53Z3AkkCkGBrvNatumcXbtrB+g6SiSClhBH0uuvY2vRkogWYeqq2cya8S0pXi+VhkEx4AY6KxbaR8Vz1vHD6HD9WSbnpRF6eS1SbBTJbXIZf/YZ7HyulG0BHxFdQzd+PbCSVBU1Noov1i/j+LbdGr8Kmbptm6m/4XoyKov5YPw4Ek89jcHN2nPxmedSV1PPrTfc9Lu0O/7OEAK8ZWUAuDq0gA++wlBsyN56CAWQijdBRj5Sl5bYOpnB548zZxP6Z0rsN/E/EZQAJhNb0/FqOmGgHG0vFc4IEDiMbgNWK0OuuI6xXczphupN6ym46WrSdEHEYcX703IKHHZyLricft0HcEfmm+gbd/y1jJ8OBbKMEu3C0TyLYaedxNWjT6JO1VntBL/QSPDpuHZV8NSH71KxcBX+bUV7kYvTBagRnZSI3xwxSxL1CCTxF5NxF2Z10uS7buaLV98mOzWHyLW38vG375G5tQDD5aT4nDNo0UiC5fsZyJ99jlJahbF9I2p6Lm57NF2DfkriU/GXFWAPNBA+jIeEoijEOKN548UXGTJuNELT8NxyP1qtjjUlHmvvjljHDCGldT4prfMZdsJILr/pWrq1b0/DunXmVIohCIQiJIUjRGrqcZTV8IOjkBnzlnHL7feghcIEdaOpVPvPCEmWUaNcPHfbvfRv1QktEmbJi88Q+v5bvDHRvN+mBceffxWpac14ptcJXPvDQqpcdtaryiHpiFQbAlutB5/PrFraGqVQO6gbSdtKSRw9huQ2HQgaGjdu+ob133yDbUcJBf6geX8CEhULbruTtPQc2l42EUmR0RatJPKfaYi6EEZDBOWi83Cc3IO2E0+E6Z/irq/EG/LtMyhJlATZwPbKIqAbEb+Pr5+6l8Qf5qIGQ0TXNeBcvpofU5wU9Q9xVnY3br7iGj5/bQqLV64+sgTjvwkMYfDclCmcftnFJA/sydaTziDpjX8jx6ci1ZRAyIeo2oncrTkAiz/4hrkzZ1GkR/62g9Ejhf+doGQPbNvHZyUcpi6EYXBi38FNb79+5990KShCICjPaYar3oP8rxfggstplZjB+b0G8eyspSbjv1EfxDAMNN3AMIy/9vkqmRybxBa5PPXYY0wcNKpp0Ul7tmsDrZu35uz7byNS10C4vMaUeMYcaXbG5KhkAEWNX8jBfC1K404oqqWJz2MIA91o/G6PcRRohCMsnjuf0++9kQ8feIbmSVmc02EQ361ehzUtle5d+yJFmWl1sWgpuj+EyO2ACEVAknB5K0mQFVLsLjY6ozD8dWb57SHCbrExuO9Ahow/AWEYeK66E+mnldj0CHJdNfrijvj//R9om0vkrEnEdm+LoWmk6bADyMb8K4Rgp4B0YIs/QG0w1JhJgW5C0IBJaP7TQpY4aehwJvQfhqHrLHnxKUrXrCBGlshfsoroklK21AdIuP8JOiVkcsOo8Tw5ZymyqhxSQCx0A622AV99AwBSZR2FbjvNqiqJcroBWLNtLXPXrCV62XpW1Xrw+UNNU0QVqkqMM4YWp5+K6nZiFJUSOvMcZMNA2N1IQmA8V4UYOxV7YiwdO3di6Y7VyNK+pf0tSFgsFgbltQOgqHArG7KSkCeMo93sRWjlNdQmxNJ52SZ6DzdVTgt3FhDcsYNc/uS/6R8EIQxWrl3DB2++w+nnTybl5B745uUhjR+HrVdnLC2bYegCNc8UsJz/2WcsCzQQEsaRuwv9Tb1v/ieDkiMHU4fk1n8/yUu3P4jD7mDI8JOof+8r6pPiic7Lx17vxV9f17RGs5h40uKicMW6iVJkkkJhNkZ06n1BPF4/gVAE46+a4pNkWndoz0dT3qBVWzN1vbG8AFFRSbQ7BocAraKChG69GJrXnlsvvZI7N96IVu81OTbCVOksxUwk2Q60rV9AkRX6yAqK3U2JO4ZOqsq5F5/HT7uKefX99/H4GwhGQsdUI0BoOpHqeuZ++DkTFIUP736clE7dyfOcRmp8CvHtfrYIYPwpSB9+j7L1O7A7MOIz0NoPgp3rabNxCcXhIDOlQzfLkSUZp9XB1ZeaPlT+2T9h+eY7CPoAAfVVUFeKhIzYuhH7JRcB8N1n37J45y7a8zN3pwUQDyzc3fke52k10HDIe3esIbG1sqzpXVl1KTHF5WRu34XF4yUrGCRcVkVxZjNyrr6Zjl16UNIsBVtBCYZPPvjrUgh62V2MGToCAG3tFmRXEsEHHiDjJNN6Iy8+g4qPZ7Ft/Q5TNG+PbKFiCFrqEXoNNs+PyPtfIOsCwxUPtWVInir07Hboqzai9ujAdU/dwtLNy9g5Z991eOWyzCcvv0GnrOYYho5/2jukhutotm4L7ooaytrks2lgdy5OaUNiSgZltdWMOv8s/P5Ak/HkP9gbAghrEW64/Q5GnjCW2GZpRH3w4l5tdoeIYa+PpV9/Rqy3luKD8Pc55B35m+GfoOT3wBAY/iAff/kV4WbJTL3gJjIGjSAwcSKtO3cl/sTxezWvrqvhox++oH/HFmTER5MdDBGb24KM3LZ8NONbvp63kKKyavyBEPpfMDC57fLLefj555ve79y4ijkfv4mryoOr3kvS9gJs/iDVEyfS5uqbuar3KL7oOZ11WwupF4LdihY7MR+A+8po7QuqrOK2u3DGJJASn07L5GzGjejH2NsuYyzQLDWLJ159hdK6CvzhwD5T3EcFQmAEw4RKq5gx9QNuiUvhmZvupN+A0b9qKkU0VEUgJAPF78NIt2NsX4VauhVLQy0RQz+sahRJkrBZrKTlm7Lt2pwlqN4GJCMA9hgQEnjqwelGHnMC9jY5GLrBp//5gDRZphRIwfxNqtn/FNqOQ96zPwC6zroNG1i1cQ2dWncgd8TxRH6YT21aCkpmBjH1tURpBo52ZkDdLDGdx8++gJvX3UFpIIw/EDzo6an6cJiasjISMzIYdvnVDPvF8tmzZ1H/01oiVXXogeBeo1jDMNDCIaIzTGtQf6mGzRkDOR1AD0GwAbW2HO8zU3A9cQuWjFTOmXQqn83+dp/74nY46dzF5JKsnfUNM6x+WmwvIba4HDWs4ayup9mW7aSMOQ+Am5+4H8/aDZSKP79y7h8JQxiUVpZy/pkTeerpp8hu15ZdW3awbvl6NixbS9hXT1yMnaVLF1NWW8HW/cjM/4O98U9Q8jvR9ND57EumturI2QNG0/yeh/bZdsnsb+mTEMXAvsNp36Yr8aktUBPMG0+H4ccRumgC2wJBNugahaG/3lTO8JEj93qf3boTveKbsW3XEuJKykjdWoAnMYEF1btw7dxMs+yWDGzbkTLxAU4JtuxxvAdbgSFLMi6bg6yEdJrld6FTs7bkZmTT56TBTW3ysloyKL0FK4XO+rpKfKGjp3L7KxgGRiBEqLyaFx57itSwwfBRo2nfrj02h+Pndp3awvcfIi1fhbJoJfKnXyB5omgQBlscLmYHPGiHMMpqg2kXUI75HUXFxwIgb9uC1FCOpEXA54OQFwkdIXRISzXbKDJX3nIZepLKu2+/QYNmbne3keNfEW0Ah26wzutn9rrVdGrdgfTkTF6+5mzabiuh3/SviL/pdtTRY5BjY5vWO370qXz18XvMjSyjqKyGQCB0UMHh2tpa8tq04Yorr+SGa65BUVW+mTWTb2bO4LsZ31NZVoERjphclV/0F0awtHHaEUAOFIHNjlRfjiQpiMQstFAQpWMOojHzt6WoeL/Bdl11DbfdcxdPPPQI7QYfR5FDIaWHj/hN29i0egmWXcV0ssdhcTgpryxj7SefE9vgpeQfkutvQjcMPv1hJoXduhOtWNjqjsGqWhFCkBnw4Qv6WCN0IsYRViIG/q5CJf8EJb8TQtOJ1NTTsGIT191/H3GPxnJ8tz5Ny/1+L06nm61rVlK/aSU33fgQrvScn9fXzbK76JQMrrrpVt599jnKFqygtLqO8EGS66yY/jK1/LEj1rPPOJ3BJ5+IY0gPHjvrEhLsbtx5LQmvWoqzsgbVAN1hJ3vFOtRGpc/SoJ9aZOoP83qxWazkRicwMC2P40aOo8fIvsS3SUZ2/jz507plB4ZmtyU64MMTidAQDqIJAxko23/XRw5CIEIRwpF6br/3Ae5/7HE+eustRp10ClpFOWpcnPlgio+D4YPN17hhiJvvZaMzhv+qEkWhhoOydt8NW+NLCIFu6MTEmcL1kfoG1NRcRGURkr8GgQwIhK5jvPIyDQSJuuM62vXvySv9e9KzfRsuuuGGo/ClHFtUAw5Aq/PSI9eshli0axNtly0jP7MlsY89jnXEmKb2wt8AnnrU1EwuHncC7tJyPtV0SsprCIYOjtfT0NDAo488wqOPPGJ+sFvO3lSr2+96mqFR5/dQV1WFMyaKmOcfIvDTagLvfovy3ZeISBAtxkHirdcAYOg60z76cP/ZVSF46vEn6NipM2effgZj+h5nfj7K5AsZuk44bJYT/+eTj9hZUokl+A8h82BhCINdWhinFqYkEmwSJKzVNez8hrHpP/gV/glKjgBEKEJieTWyL8jZk8/h3cefYtQYU1jH2Uhsq2uoZ/z1D6BarAhDR1q5GObMQFLrIb0jjD+HVgPGcs+AsUzeuIFRXbsQE9Go4benMcKYlUP1ALKEJP9MeBOGOGbKjK5AkJVffkGNqOPq404iIdNNqa+a9O0FJFRUsqNDSzb1606HmXNxNrpb1lZUUWoYaJJ0yDdBSZJwWOx0jkvi/JuvptP4nzM1RkERxqZtqKMGkTYgnzbLBlFXsZMennJW1spkYVDIMQpKmnZKIGHgsqgkpJkZMn3W56hffgYuF8SkQrvOcOLJSB07YH/lWWquvYni2lK8Qf8hTTutbPwbIwxOG9QHq8NOqK6eMjmK5CGTsG1chLLyB4RhYCTnIgU9UF9OaMlCoriuqZ/18+bRDCj8je1JTf+Y+LM9z3Zr6WQmJNG3aw8AuslROCbfTHzrDns3nj0T6am74a77ITWT5i1a0yUjkaW1DdTUeQmFtcPTizlITx0hBIFwgPHjT+fBe+9hyPGjcfTqiL1HB6p+GED1My9Q46khsbH9ie07UbjxwLq3QtO5+MILCVdVEp+VieawMaJbT2LjEpAVBbvDiRYOM+WFl6j1mXWIezKYjsbPmYkpgLhRlprcexECwxBHRzjvKKJJq8nQm/Qja4/2Rv+eiZK/f1Bitaim6rkhGqswjs4vExfRodZDsT/IlaefwdWXX8mk628gPtVMiXfvayqT6qXbUJZ8CVM+gMJSGDsA6hfC+yE4zSQZJqSkolkUEgMHr8uxodFoy+JyIDts5AhBfCRCTShCSUTDG9aOuj16JaBENLTCMlyNtTC1zbNxOKwICRw+H0okwLaLJtEvvxUAW9euP2wTRFmSadG8BQ+9O4301mbpnTZjLvrUD9CqdOSdG0C7HXXscNpfPJLKuiJmv1+KbC1hUUg7rBLw3wMJsFgUEuOiSElKAsBaXAQr14FqgaR4WLoQls1DPPQMlmZZnPLsY0wZOxat4vB+u3hg/FmTANgxZwG+ravwZvkRNjv2pEzkqiLk2mI8rbpRgyDnqccAmPvtd0y+5BKidxZwIHN0WZZQFQWrRUVRTNl63RDEh8N4IzrVfzJeQjgYbPp/xpDhv25QWgwXnQ9hP9SZIas7twVRPduTWl7L1p1leLz+ox50aYbOinWrmTj5XHp06sEtd97CgJGDSRrem6ThvQk0Sv8DeHduJ479iBjugWCDl4uuuZZoi0rI5UByO3FHuYl1RTE0M5v6wl3sWLcRq6RisSrIsoJD13EInVpNI13obOLIlOZLEthliThV5fIJZ9C9c2eeePHfeBo8BIJhfIEQoXDkT11i/ofjn+qbvybatcgCwOcPUdfgo8EbME/2I/wDbcS8WI1QmK0huPqJJ7n6iSd56KEHuf32OwAIF+5AmvoUyk9rYdkGiHbCqx9D82aQnURk0zIsrboxf873NKgqi9l7tLInJCQkCQQSkkXBGuWkdWIsNa1zEM1SiTYEcbUe5PoGostqWFNZS7iyFiN4eAHAwaAOkEIalu3FvPjhdJ685hbGtR9I4I0PUfwBbN98TmTHJpTs9gBsmDcH98w5prLrYcCiWnj//Wmkt2hOuN6L7/WvsT73EFhs0P9kDNlC+PWPUQb3RXE7GX7/FXiS7Fx46w3US/Kxd+uUJGxWC8mJMSS4o82PVq6FnaXgdgOGOZrxVGC8+3+I8ZeS2iybV55+mjHHHUf5YWxyBzT2Da1PHE1hXAxbXv4vCau3EaeDWzcwCFNauAXtmstw5udSUV7O+IkTqaqpPmDfFlUh2u0gJyuNs08YR7ishNL1a9hktxJVXElZXQNLvQGCochBE7elxu8JOCpGhN6KCl546CFatm7N9ooSThg6lNTmrU1nV28D3Ho5xNuhOgJzFsDISSjOOOJi3ORIEjtlqDhGIkMhLUy1t5YfFs1m4SmL6NGjJ/fddRs9Bg/EERcLQKChgRLDYPNB9ik0nSxNRw+E2FDrIYA5mNi2eCVWRSXeEU1SdCLxrlgcVjuZAS++oJ+KYAM+bx0ZoQBFQv9dRy9LEnabBSUzlWtuvY3TLrgUgJ5DB/Lqsw9QVFbNlp2l7CqtwuP1E4kcI2L6P/hT4G8flPz3zalUV5exfs0KPv7ySzbvKKGsqo5AIHxEK1z2N4695+67schw0613oCQkolXXQ0467CwzPUQqasHjhW1FaDllWFpBqw6dAYmaX8xoSJilrxbFgqooZspTkSHaSVZ6AsPOOJmJo06kKsZOgQixLexh1+o1LNm4kbR5q9BWbaKopt7UwThKELqOVuvhhaefpW1CMpPPPAdHTBzExJF13iVk7dG2aN16vP7gfvs6EBRZ4YQxY8lq0Zyw18eW6x8n3WcgSxKGzQHlBUgBL2xbSfDk81AevBVrzy6cctUFvPTRf5kx5xg5Ke8BSZZQ7VYmjT8de3yC+WGiG1LizCqYympIToSaOpg3n4bkZsSdcDayEHQXgi8Pc7snTJjAXXfexeVXXE6zgX1pNrAv2776Dt/Hn1D/1dfsCgTZLOmMG21mDh69916qaw5MabWoCjFRLlrlpXPHZVcw+oIrAdjw2dss37aCmoIyEnPa03fjNl5/6x0qQ5EDBhmyJGNRVFRFRZUVBJCoRYjWI6w29CMmnJcL/OvOO9msyDRLjmPzdx9w179eJyajOXw8FVwyJCWALkFdFRg6kmJDtrpw+ANE6eKg9W6kPYYUh5sv0g2DoBEipIWZMXcmM0f+gN1up2XLlnRs3YrQpk2UhA7No8aD6c79s4S8hNViITEqnuYpObTNaEnzzFxadW5Ls/QY1s9fwjcr1rCteAuxZdux+BvYLg4vUJAlibMmTmDCmWcyZOgw7A4nAELXaNOxBzffcS9zv5zKyp/WskUIZpdBrceH/g/pdh/4e87f/O2DkrSW7WgV3Ye+o06mfbt2LP38axbNX8wnW7bjOwaGU0LAiy++YAYlrij8NidWp4E0uBtIAoQBmo6xsRCPZzqWHkPJzW/JiSNH8dq77zX1I0sSVtVKlN1NQlQc0Y4orKoFYZGwJTsZc/6Z3DDpol/vQPPBzK0p5C3ri6ytrKYsohHRPEfV08IIRQiWV3Ppddfz2JTXSM1tRoucXCYNHEZaVja56ZlgGLzy+ecsPoz+ZUnGYbVz9vEmb6d65nziVy9HVawYsUmQlg/VhYiqUshoQUiNpeq253DceA6Zo4dy7TVXMmP2MQ5KJAnFYef400/lopvu/vnze56Fk5bAyiXw4cdg1yEzBbF2K/bGiZPN69awtVG07HAE/mpra7n+huv517/+xUMPPcSEMyeQP2YkjBmJoeskb9lKz4R4khqnlN7/4osDPkRlWcLpsNGxdR53Tz6H5r16NC1rM+5sWhuTmnhNp0fCLP/0E36qqqNuP/rzzWQFq81Jms1FltXOztgkhBBE++qgoYaCcAivFjqk6qP9YXdZsxCCjEAIuSFEVGoOAEJtQApGIBCEFs1MBnlxIWTlYgg7q4Vgja4fMNEoYfIjVEXFIitIjU7HET2CZugYxqFnGXZL/e9e0evzsnzFcpavOCRTjCb8kh+kyDKxzmhapuVx3cWX0n/sUGJy05BkM6hqM3YgqW//wPzp71DRUM1yLcTOyOHJFlxz7mSenvKfpvdaTRXagi+xVNQgn3cNqfldOfncDNokvscP+heEgmvZEQixVv+HLvq/gr99UCJWf49o3xcpNo3eo8+g9+gzOHNnAXP79CAUDNFRmDeqnUdp+4ZhUFldQ01NNfHxCTR4NSwRHdupE5ECHqg30GvL8AfDhDv1QbWbZaLlFZVNfUiShNPqJC0uhX6xybSPS8fIaYvD5iA6UoMv28nxjZUDq0q3Etm4ifjoeJwZWSSnZDAwvhn9bniIb3oM4Ypbb2XXynUYR/Mib6w2iWgeti5YSnjxcrxCMP2J5wgYpty/LARa+PAyNlbVQnJ0IvUeM6iMycggLEnIlYVIQiBsbqSIBkYY3VeLJy2H6jgn2Y2mZMOOO+7YqrtKErLTRnTLbB688z7AfChKkgQxsTBwhPm6+nbYvBHWLkdLXgjtTQLmrFWrqJeg7Hfu8vYd2zlz4pk8+dijTJo4kVHHHUfbjh1Jbd2qqc3sr7+mqGjfIly7YVFVkuKjufHCixh0/uV7L/Q3IDl/Nn/z1dWQnpEE/iCSN/CrbIlVtZJvjyIzMYPEtDzyXLGcMXAA7Xq25LMPf2DFhtW0LttBQVURVQ01vzsw2U1slgxBaSBEem5rZEUlUl2O/tE32AN+kBQoq4KqOrTtW1GzcpH8EsquSvyh/VelKLKM3WIn2hFF7249OfW44ewoqWDOrHmUVJVT662jPtBA4Ag5Ph8JSJjXU0Z8Gs88/QgdRw5oWqaXVaOkJqA47Qy8ZAzdRnXihctv5evl87HWlBIwDi3L6QYKFswnHAhgdTgQmob+1E3YIhGk6nrISoNBJ2OJTqHDxKvoMPEqhn79OddNmsiGsPaX1G76FSRAkpAkmRhhUPd7ODN/z0TJ3z8okd57D6m6Ao47D2G1Ikkyhgz5MS6SyqqI5jDl5Q8SAgiGIoR9PohPIP25/+zdYOwktO2b0WXIyjFLFR+5716+nDW7qYlFsZAUnUDn7Lb0ScunQ3waCcjYjAjhNt2J2jmX5ESTUPtlvAXb1jW0++FHbF4/23LziLv5FtpmtmDsoJE0ezaKLiNGQPAYjDx0A0MP4w2ZN6QMTI5DmMMny0lItFSt5EXF07JlGwBsdhUjsZk5Kq0qRvLUIBl+Ikl5+GOicV0/id4DugMQDAS4/ZprjsDBHcI+W1WsibFcf+stZKam0+Crx6ivISY9F5YuAaFDVjakpELL1tCyNfZTJjatv2jlSsqPII9h2apVLFu1Cm65hczMTNq1a0dpaSmFhYXU1dX95vo2q0pyfAxx2Rl7L1g8F36YDhErnH0x5LTBnZBEhxNP4LsXptDgD6LvkS1RZIVoh5uojJZcftP1tBvaF9XpxpFs8m0ub9eCL5//gjVL57IlEmZh0E+B4T8iD3QB2CIaeR1N1dTKnxZCeS2O3BSscbGmKWJFLfL6DUQNGoEek8z6Wg/B8L4FsHKATMVCZXwa7/znVbqPGtK07OZQmPWLVvLeq2/y4Q/fUlRTenQCE+kX9TIHcbpIkoxNtZEem0JGfi4A+obthO96ClFRhRT2otx6I5Zxg3DlZHDZG8/y7ciTKW+oJqiFDon3I4DCXbu45dwJPDP9UyRVxdo8H2nBYghEYPpUeOUNuOQKRM/+SNFxdBh9An3OO5+5//fvv75hsSwj2yzIdhuKw0aGrlNX/juUf36jtHyf7f8C2LdZwt8J67bBlP/C2P7wqTkdogcacMZHI9mtrOHol4Xqus7X06c3vTd0nW3LFlC+eilGJIwtryWxOS3RIhHuvOUm7n7ggSYirixJOCw2MuJT6Zzdjta5nck3ILVyF0lblpPx6WskpCYjywpafR09n3qZ/tM+wVVTj93jJ+nzbym79CI+ePEhDC1Ch1596NGt6y9uYEcXVZgk2AbMwOT3QJIk0mSVUX370HNsfwDCH89BLtsOW1YgI4PuR7jcWO+6lqQv/0NiY0Ay+/Mv6NK5K8+8+urv3ItD2mEUu42cju255sQJAHy/cQHhjz8zl3fvAT16Q2raPn+TxbN+YMOGTUeF9AlQVFTEt99+y+rVqw8qIAFQFYUotwM98gsRuiXz4dtF8N0MuP5SjGXzkWWFq299iDGDhzT5EYEZXNpUK0lR8Vx1/dX0Pv9UonLSmwISAFtmCuNuOZ3evfqTn5qLyxWDRTly46idhmDTDlPZx2jRhrmKRMGGQjYYMgUjx+K//AaMseYUYUJ6JqLBj0vbN5dCyAru6ER6tOzSFJB41xUQrqzHYrPSaVBP7nv9GQZ26UuCOw6Lajlix4EiI9utKG4HaowLNdqF7LAjWdTfvM4lycyUxLqiqd9u3gmN7UWITWuQtq/DKCsj8sDjBCbfgeHx4k5OoGPHTlhUy16cmYOBH9iuKmyuKCLoN3WKpLRksNqgdTMoqwFvHXzxNtLD1+B9w5Rtn3zu+WZW8a8MRUaNcmLPSiGqYwti+nWieljPP3qv/pT422dKiGgmcTDahdRQB0BybmvsUW62KMox8esQAi64+Waee+45OuVkIyJBtkV8tNENklPTOfOeh4hLTuH8Sy9h1qzZaHsMCUzFUieZcWk0T8klv6LALK3dvgoR8mIJ+1Dbm0Zb+pIltH33M4yqKopz05EF+OOjUSIaawwvQwp2kNC8Jcf37sOi2fOOwZH/jCI4IlkpSYJNNiftjjNJmcGF69BohlqyFWqrMCQZObMlyvgxWMcNBSDkaeDm8y7ixU8/InIYhna/a38VGdlp5+Hrb8JltbExWMPK4gKazf6OqN59UROSoKwUqiqJ5CVT2TqK+EAmblcMzz/3JHfeefdBi+gdC0iSWfWlKDJ6uLGo2u+Ft16A9cvArkKZB0LlSLffCN8uRLFa6dK6DfONjyihsUoLQVdJYtjgwQw9/3QAQp/NQa9SASvyxjnY7r4MNT6K4fecizU3ge+eKsHqqyesRY7I9JsPeOSNN7nygQfJbNGKUVM/Iyo2DtXp/FXbZQsX4tB0UmnUA9oDsiRTb3ejp+Vz6smmtYSIaIgbHyIkJELZqThvPA+1RS6nn34667duxBv0YURCB13yv09IEpJVRY12Y0uK47yTTyE9KZk358yguGAn4cpatLoGjEAYoe+fmJpm6GT5GqjdUgQjuqN0aElYdYFWArIOdVWI7VvQisqxtnWTlJJkVv8d4u7mA/ERDcMQSI2aO2LOCqSSMli1EYoqwOWGiI7o2JzgskW4z72M+PTfO5T5gyFLKC4H9px0oru2xt0+H3tOOpKqUDbtmz967/50+PsHJVYFLA7IzYTmpv9HfUUxgWDwqI0+9wUhYFVRMduLigmqCoqisAZBm/XbeXfmIAqF2CfDXJYVnDYHSdHxJEcnYA0EkZfNQPg8EAkh6iugW6Ox25Kl6ClJ+BUIu534ot3kL19PyGkllJ1NXI55/B/PmXvMjntPeI5QP0IGq8t8cOg7diIvn2VmqxUZ9CCiZCvEmCPuQE09Nw4dx/Qtq46d582ekCSiE+I4ebAp7FZ/3z0MXbWGgtwsSqb8H8LtIkrTcEYibD1lIHGkM7ZtO6qqq3jg4Ufx+o7tefpbEEKg6QY+f4iaxiyDsDmQli8BqwwFpRAMQbd2hOOjsYSCyDY7CxcvBkM03XAkJKJcUdz4zMPIikxg5mL0195HUR0Ydie63UngyoexXT8ZpWNLhlx0Cp8d15NeffrjK/Efse+ktraWaa++ygXXXktc48PPMAzWr13D6gUL+W7+jyydO491hYU4MUf7v4SqKMQ4o2if24axF58MQHjGCpR1PyEJDQoS0DNjUe66nu5De9PrX4m0KdnOTuD7w91x2SROW1MT6HDcYKbfdC852fkA3Hjl9czZuIJ/ffERP3z4GYEdxWh1XoT26+BWCAhpEVQjSO6IxvuI24EUn4rwVCOX7wB3BMPaAq2qFisQHR+Dpmscqt+tAMK6jiFZsLlNhWEqSqCqwZxObpYKdjtE2QnuLMFjjyIRiE9IRFFUc4D5V4MkITts2LNS6dyxOerI3rSwW0kOhCmJjWHVH71/f0L8/adv6rxQUQ2ahPj/9s47PIrqa8DvzPZksymE9EIIEELvoQiiIkVUFAuCCmJHVARFBLEX7NgQG/aC4k/AAkiRItJ77yEJIb1utu/M/f7YEIkECEUIfPs+z6TM3Jm5d+7MnTPnntKxJwB/LviZwPwSjJ7/Ih/BibECHq+C0+XG6vLg9SioXuW4Lm8Svi+xhPISAotzIciM5HGBvQzCIhHNmiMl+wYj1evC2r0TqtGARgiKYyIpjArDqYFhsW2QtVoW/DGXDevXnbsGn2WEAJfHzZ4sn85FawK2L0MEBCFiEpFUkDRa3NsPAmAMCcKdGIdHKOfNuNDhcGK3+dTV9XcfIDI9k5BDuehKy5FLSrE6XewJD4Ulq7gk0pc47ct336aouLRORrZ0e7wUl1nZu3Q53vISJI0GUa8+bN8LBgOUVSAyc7B2aY6oVLvrgyzskiUKK48hyTLeFi0wR9THa7VRPnsd1EtALTqMvOEPWDMfVi7Bed9Yyt//GoD68XE0aNDgrLfngXHj6NmzJ2lpaSQ3bIglKIhLW7dhzIgRpH/zLWWZmSRQs0AC/2RijouMRWsyIFSBZ8onvii5OQdRA4LwZLoQikJIfDh3vfgEbnMQufLpfxPKOh268BC6XNWL+a9NpUFiMk67jYz8LLQaDVc078DMcS+z5uffGDHqIbRmU41TOUIIAlSFBn16EtY4AaXMin3iG4jwaISlHmpgMJ7ml+Bs0xFdi8YAWPQSbq/nlG0U9gM7BGTn5OO02QBwDh+MGNADGsZBSBCYdCj7snEregLGP1+1b6D5RCH8jkKSkLQaJJ22akE+j685WUJrDsCUEElSVDi3rN9Bk6xiWq/aTv+pM87s2EeCp53KcgFw8QslLZPB5UFNaoGk1VOem8kfs2ejyy+hifv8S94bOLHnj0DgUTyUCwWXw4Yq6yCuMZKsQ87LQG11OcLhs4I3PPAgAYpKSVggVpOeglAj5Q3jiXrhdVLbdsbr9TLmqacQx5kXvxAQQmB3O9m2fRsAmnYtkUc/jGbMQ2guuwyiYhHmEMqzyilftQFJlmneOrUqt8e5pAOQoih4XS7W7tgCQMmtN7P5ii7Y64Wgraig0aIVhO/aj1xWTsu4FgTXi6C4IJ+3PvkYtY56G3i8CoUlVjbml2C3+iZA1eEPoAzsg2iaiCcuEpuq4g1oiEZvQFVV1m7fUS06pwCMJiMAzgonTnMEUl46cvFhhKU+cs5eUN1QkI14/nkUm08kKC379+TJmeN2u1m6dClr1qzhQHo6NrudYsAIrMOXM+dE044NhCBRVfDYXAhVIMkSclkOQm9EBNcDWYKSEjyf+WzamvXpgbZ7D/afrl2JLCEHGrEkx/PZE88RHGAmJz+LD3/9lNcOrubjOV9wYNlCvG4XKXENeGfi8zw/9jEkzbHDvUBw0OOmSac2vmuRl0fFpg14dqxAKs5CDQlHGnY9YW+OQhcWjLPcyjf/+x9uofhiJMnS8SM81oBXUcjJK2TO77MBcNRrQnlWHs72HXH3uJKK4DBK+15K4JcziGrRDpfTyYvjxlJYeOJAfkgSkk6LJigAXXgIhtgIjAlRGKLD0YVZkE0GX33PMZJGgyYokITwEILqWcBgInHnQew6Pa3+OLdT6BcKF/30TYlXQePxgMFAIHAg4yAb9h4i0GrjJLd5nUBRVWwuOztdNrplbMOdtQNnUisMZYVIuQdRMw9he2EappE3oImNIn7iyxTO+BZ12UJSo1Po+tjrmM0WVFXl9UkvsX3jJjiHoZs1soxG41skQBUC2eMlWhUnzelTEwKB0+Nk9ca1AGgT49GOuLVy63CEquLasA1xKA9LZ586ulXjJFIUDwqw7Ww0qpYUATZVoNicLP17OZd27Epw2064Vy3BXj+U6LIyVJOBg62SyWjekOuu87Vj0idTyS2z1tkvG0VRKC23sTozl68+/YD7nngWXZMWeKOfIG/fw4gD2QQMvYeoQXcB8OHrr7J9565qxxBCkF/gC4xuCAnEtm8tIQWH0MQkIxfmoManIrxO1IoyxIB+aAIDUDwecnIPn7PprCMfCyfKWK3RyATptVg0Ar1OwWt1oAsOwPTnz3jHPY937nxEVCJotXgrXOgr92vcMPG0NXeSRoPWEsjlfa4kMSYBZ0U5O58cR6Is0DduQGmohdkV+0j85Xsib7mdbh16ct2gITz50iSfbcm/Ll+JUJnw6mv82vNSLE0aoXw1hYIhd2PMqUDbKInwIf2RZJk9S5bzzgsvsCZrP5qIECQEwuNFdbpQHK4aMx7/G1UVWO0O3pvyAQNvHkJw41bkXn0rlsv6IWl1yC4HWqcTbXAIe7duYdDQ29i85SRPrSwhG/To64cS0DCWN0eNZeAV/Shy2sgqLCAzO4vcTVuZ8+57iKzDbODsTSWfDEn2GbqbzAGEu7002rQDo11Bqyro7P7YKzVx0QsluWEJhL92P/orfIaRklfiQFYeXo+XC0FfoKoqFS47GYWHKbNZwaAhYMTNOJonov38Y8jYiivnADl/L8T08njiunWiw5A7YMgdVcfYsmM7Ix5+kJVL/jqhwdvZRJYl9Dot5gAjIZZAAk1GNBoZp8tNeJmVwgoH4W4vRcqpzkyDx+th9YY1fPrqm7Ro3RbhgXpBQcQ0TcIcFY6xQytifQ43FOfl8cn06VVBs84l6ZW/ZbuTmb/P4elHHqdBXEPmGw2Umw2Y6wfxV5MeGCrsdAuIxhwWTk5BHgvffQ/J6aqzLnxC+Nzcc/JLeP3jaazaupU33nyfqMQktCPGId3pJrh1WwBefP45nn/hhWNiTKhCZdPWLRQVFlEvvB7acAl7cHPkEheB+zeimCzYG7XHYztEzOsvAPDJ5HcoLCk+tzFmToBOqyUo0IgtPBRdXDQtNEWIjAxolYqk06F76wU0ndvj+GgmcowF0+g7qvbN37/vtG2cJFlGE2AiJCoCgDx7Gau7t8NcWELKqk0kbt5JQWoyf99xPQf3rCatXXeaJjeiWWoq2zZs4t83lkDw9/o1XH7Flfz6+69EN2qAbsHP7P36B1JuuwlJq2Xtn0t55P4RlAVrib28E61atiAoIJAgr8BWbiNj81bmz5uP4nCdNDCj16uwavUadq1eRdO0zsReeW3VNq3BhNZgoij3MLfcOojdew+cVDaX9XpahVqgaQMeHz+RwT37A2AJspBUPxpSW0Gv/jQPCeXj0aNx2J3n7sOsMjP04bBgFIOOnd070HrZRg6HhBEpr+WMXkL+3DcXJqkvvEmgxWf0WFyQz7RPPqHc5uA4wSVrjYSEXBkEx5eDxidACFH7MNS1QSBwez1kWgtZER1N/+mfYWzYALmwlEPTv0LjqsBRUURWRRFrBg+j+TW9CB1wNR06d0GWJJ6e9DJvv/M2Xqf7nGULlmUJk0FP/XrBNIyPpEmDaDq0bU9ceBR/rl5KdlYulgPZlBSVoS21nnJuC4EvL8hDTz1JSICF8KAwwgJDCDCYqBdVn8t6XUJsbCTf/PILP8+aidPlOK+vMdXjYeuqtezdvYvGKU1pc+OdzN2xijKDheC8ItTQQLpd79OSfDT5LXIKi4lTxX8W0O9sIITA6XaTW1DKnAVLsY4cwU//m014U58nmKqqPPPYGCa9+95x7aU8Xt+0ycAbBtLkg1cAsG7aQcmg1chl+WTnHyTi8XvRhgSzd/NWHn/uOZRzJFSfDK1G5orEeG65fQjte/VCL6nUryhH3yq1Wjn55uswJsRj27YfE3Bg5Uaeu/NuVhzcc/qG15JPMNHrfHoXa1Agm66+nMu+mkXq32sx5xRgVhTk5dvY2bcdmQf30rBhU265biAvbNyCq4YQ8YqqsnHLJnpe2pNZM34gtW1bWjzoixC9ds1ahjz2CLbkcCxpzVj92GsEmy3HHKPHTQNYMW8hit1xwpe+JEkYtBreffQhbrlrOF1uHoou0IyzOJfi3H2ExzajXlQMd918Ey+/PwVvcfnxPdA0MhpLAObY+kRemsYN3a4EYNHq+ewRTmJdCsnBkTRv05VGl1/G6qQY1AOHwXZu0nEKVUV1uvGUWll4ZSfun7sWjyJI2H8QBQ1nJpVcnFz0QklFeTkzv/mKad9+x6o1a/CeJEz0yZDwZUU16o0E6gMwGwPQylo8qheb04bN5cDhcZ6VkNhQmYVVK1MvMpSxP0wjMKkBAPrwEJa3boph3hwKPW5WCy/B5UV8NXUqe6d+gKyVQQiU82A/YjLqSYyJoGPLZHpf3oXrbryPgKhEAC69agA718xnwfK/kNbtZO3WfRSVWPGcYj2FEDg9LgqsxZTay9FqtGgkGbFXMGvp77i9HrzqaaaYP9uoAsXu4PZ77+HvRYvp2roTXVsfG6PgUMZBXnl/CoGKOK3ke+caIXxGrx6vwm9z53NNq1Zc0r8/rVNT+f3HH/lo4cIT7q8KwaL5fzDwhoFV64LaNINFP/nU25lZ1OuSBsD9o0ZR4bDVCS2JLEsEBZqY/vdKgiMjT1pe07k9ls4+A+a/V61gTvZBSj3O0zZiFqpAcbmQK58Zt6TSfu5Smm7ZRYDNiU7WEBAaTmO7QoOFm/D0SYCGTRl+zbXMf+UtVjoranSNV4XKnv17admxI3fccQfPPvkku7Zu5b5HHsLYIJJOSRG079mTYLMF1eslN+sAxcEmovRBhJtDGDr0djZu2kh8Zi7pbg81xXuVJDDq9cRGhxMbHUzjFs3QBfoSRhrDoogJi6oqe8vd9zL7j1/YtPMghSXlNWYMlvU69BFhHLq0Pc8OfwC9Tk9BVjqe997HfklHdhhMFLm207xNVxo3bEKPwTcz871PfBqdc/CRJrwKLQuKSVi+ETnQxOFQMykVVoQsEPIZ3st+TcmFSUrTplRUWnqfKRKg1+kJDbAQXz+WuLBo6pvrYdDqcXic5JUWYDm0G1tFCb+7HXjOUDDRaTWYA4ykWgJ49aXniU1KojjnMPmFBTRt2ZpGXVsy/6evWO/xsMvj5qBQ8FZ+BSme82MkqdHIhFrMNGsUx2VdWjHwtocxhvwz0BgjE2nT/04MgTKqqpJTUILd4cZrOzYEeW1QVAVFVXweSVUWd3Xh1fUvVMHqv/5mwiOjuHfkgwijAZ1Wi0mjwSDJFOTnMfaJJ3BV2Dj3JrlnhhACISBvzx6+2rMHFQit5b5ffPMN7Zo0YemKlaRGRDJ+6hSC4mIAMCX40jfOmTmTxUuX1Jle1Wo0XKrXYc04UCWUiF0bkZq2PeF+JYeymfzhh5TZrWf00SIUBaXCgVTmM/61HMoh7deFNNqyF6OiIsfGEhhWD3bvRb3heuSePu1BUP0I4oLr0d7jZI/i4XixRBVFYdq0aUybNo3mRj2/LF5MozZt8bhdmC0hAJTlHOLHWZ/jDgslOakxN/S4nrv6D8R+IJ0pTz1HtNtTNX15NLIkYw400iAugjZXX05U+8qw9j99BMFx0CAZ4bAhtWpPWFQcN904kMMfTKO03IZbPfaaNZNl7ht8O1fddRcNI+MA2P/he4RkHCa0cRGBxaUoJiN/Z2yjW2ILPho5jozl61i9YDHiXGiOVYFic+DOLcK+J4t97Zqgv6ITzTfvJEhvANe50dhcSFz0QskRgURC8hldypXZdfGpmH0vNbVWA55GoyUsMJghV1/HpI/fQXG6WP3JYnQ7duL0uNiV2AKdx81hSeLvilKKnRWnraLVamRCLIEkJ0RxTddOdBt4EwDWw3tIadsDgIj4KLKCtLiLbHi8LmL573L41BadVkNEvWCaN47n6qsH+wQShw2eGAEIeG4yUkg4TVK6krZxC3nBZnICjdgdTrxnMKcmjvpZZxGC16Z8wBtTP0LW+O7FeCEIUFW2C+G7V+p4E07EptPYx263c/djjwHQHNi4ZhWFlmC8Xi99evakXYvm3PfYY3VGIAHQ6bTUCzCw4cNXies0CwDp0D4wmCGp8THlXdZyPn7nXd6e+jFhhw8RhSDrTCqgCpQKO7YDvqc9OiqRnJgIApdtQEpMxNSsGQQEwiefoNH94+Gzdck2et16G1tm/YR+7zZOGq1IkjClptK8c1cADJV5ucr37eHQN18QW5RNutnC1sIcOqxYTGLXyxh402Cefv11yuyOGm1LNBqZoEAjLVIacUX/4UiyBnZthmdehdJyiKqH1K0VDH8Q2l7KwCF3M33Gz6Qfyq9xCqfLlVfy4IRnAHB5XCzY9Bf1Vq9ERULRajEXllBWP4zFK+bQvl4iwZZgZkz5iIQmTWp1qWXpH+8in2LiFO9DIVinCja53AQcyiU9PJiSMAuHmzTgqj2ZsPN8j9h1j4teKAHQylpMeiPBAUG0ad6KyKhIDqZnUJp1EJfDTobbgcPtxFuDJH4EWZII0BtJqp/A2GcmoDMZ0ZmMXDKyLyXfh+M4VEz9EAtSp8bIWgd/Tn6X9Qd2YHc5TnlAlSQJk9FA4wbR3HhtH0Y88gySrMGzfyvRirsqA6tOuGg36n52ffc/grbvYs8p2macbSRJQqfV0CDQxKXdL6deamffhtefgzmLwGSAiNfgydfQxqbS5br72LpyO+asPNwSFJz48Bc8RiBS1lJmDCDQEECAzoAsyVQIlXCXDZvTjtPrPmtTf/8VsuwT8GW50p5KUVCE5BPuz0BFvB3YvuGfzLd/La97LpOSBDqNTFF4KHK75v9ssOfA16vgiv7QvgtUvsABDEEWmqY0xpSXTQTizHNtCYHqcPH19B+Z8OBoEhsmk3rXI+h69McQEQ3h9SEpCXTVXY67DulF1yG9WNcjjUUDrwPPyXVyad19qRzSc7OwLl0Im7ag/3kWOq8H53X9UPQ64rft4nC9BBKBTXlZuE1GXx6qGo4nSRIpEoy4ZwzG8GhESSHSp+9AfQuUWcFsguJyWDUPkdKesPox3HDjINZtebEy43L1o+60/6MFf3LepxgFXClLxB46TEZhER6DlvDsXHIKo8nesJrkHr3Yd7AmHc4/yHLlFL1Bh0GvQ6vVEKooBDncZHu95CoCRTmFbM+KilLhwL7/EDkOJ1FBAXQrt3HYdrzIN7XEP31zYaLTaAkNDCG+XgwDr7mecW88WfX1kL9jD+/c8yh/5GSSWZhNia3suIKJRtYSbLIwfMitRDby2Ueo2bloYqOoN6wLSqGDuKjAqhwNL0dFctPQ23F53CcUdmqss1ZDaqCRcYMHc+1jvq8AivPQLfgBiiqgky86aGKf6xnZ53qG3/coTVOboOQWnDNj1uPRAEhr3YZLrxvuWzF/FixbCB4FZC8sXQyesfDs6xiTm9Hkqmtpsn4HGUJg4/gBqi50JEmiqc5ImCkIT0QiiRHx9IyOJCK1McYmyQQYJV5642327NhMZkUJnjqSRfZoJElCr9MQZA7AEmgiMMBAlFdF73JR4PKwx+nG5nDh9Z7CgH3BISHJEhUmPfUbVGZX3rsTJr7t+6Ke9weYzHBlf3CWoU54CVlvYP2yxQQpKvs5OwlAhVfBWVjCo2Mf46f/zSS8eWto3vqYcsqGbSgb9yB3bIm2lU+Ls3XnXjK0+pMLJRLEhfs8fA7nZrNm7xqa7TtAkldB41EIzzwEGpnYfQdJGnA7AGvTT+RADRohGDnqMRq0T0OoCuLLN5AOHoAKpy8icE4B9OoI23bhmfU9+iH3cN2Amxn/9Is1pqQ8lJEJgNfjQdl/kBiXF2+gGa/BSPSedIobJnA4sh7N120j9p6nAHjj04+PeUEfidar0cg0MOhpGmjElhBJZFQ4gSYDRpsTb1EZxjIrSrGV4rIK3B5Prd/zwqvgLbOi2p2s0mvxShB9wWcY/G+46IUSs9FMw4gEbujdn0deHY9Gp0MpLkUOsRDRrAn3vjWJsqfeRCPLuA+7sTptNcYP0MgazMYAel19BQCOb+eg/rwQw7jhaDu1RBvtM9byZBejiw2j2zW96dypM3P+nIf3FO49SfIJJQlmEx0q54JxOWDTbMjKghXboO1XENsI0bAFUpAFWZYJMOl9+UjOs1CSLQQDbr8bWafHs3cLOvteUGXQaiC2HmTlwepliPJiJEsYrgATh2UZryRjv0gt0SUk9FodanB9miY345p776d7/x4ERlS3vPioWVNeuOZGNnud5Dvs6BAnjJFxLpFlCaNBT6+uadx2ww0cyDmAtSgbAwJ9fjG77E7SdmSwp6iMxU4XHq/3QvkwO0UEiiJwOt3Y3T5jUVFhQ3K4Qaf1eXUEmuC3n1EnvoCsN5CVvofFP/6IVSOz+yy+iIRX4dff5/LKmHGMfe0lNNp/hnOhqnhefA3vjHkQHIE89xe0P32By2rjh+kza3kCwZZKrUKkOZio3RkElpbjCDAhCROmigritu5E71XQJ/oyDG/bswvhPn6016YtW3LVaN90nX33VowZGZAQDRt3Q14pWEwwaymMvgf9EJ/3j91uQ1FqnmI/fCgba2kpQSEh3HfdPfxavo/9Li8enYzO7sZYVETElhzUW27BaDSRefAA8+fORRzVDylACJANlJuMdEptwt29Lie0aTKFGisa1YkqyRQUVxC9YTvGA9ls3Z1BYYn11PJSqQLV5UZ1e1h11LTQ6eKz5TqFLM0XyAN50QslEZYw2ia35KEXH0NrNOBdtQ7nAxPw3PYgIaOuITGtBbfdOhjbZ3YKyotwely4vMcGtZElicCAQOJa+r6O1LkLELs24O43A/W2m0CSUTbuwRMUh/WZ0YR1bMz4555k3uL5p1hjCa1WQ3lMFGGNK90LD/0N5WWwdAOkH4a33oOWjeCG4XBJb3auWYZW9r04zitCoGi0JHTweZaU/vwt9VtGwU2Xw6wlYAkAjR6i6yN2rkNK602L1HYUudxkn9+a18jRmUnP5IGWZZnkepFMfuElug25EUOAL5KpcHvxZhfgOVSIsU1D4ps15o4XX2DU6FFYvDmIWqjXzxV6nY6o+iF88vlXRMT7NIWeijKsezdQqlRQWFBK9jc/oF2zmY0lVkrKKk7Zo+pCQAjweL2UlNvQm0J869wVSJ1bwK50sHvg8v7wwCjkYJ/Q+fmHb3PI4yX9bH8wCIHqVfjlzyU8USmQeLbtRvw6B+/6HUh/LUQyWFCDwpE6dQTg8Pa9FJeW1C5asIA9u3xB7+Ljk9CPeZaAChtl078lZ+d2dnfvRMqqjahp7TGafGHgPUWlKDYH4jiavu3bt7Nny2aatGqNqkrYZA1B2TlIKYnQoRlk5cK11yNueaTqnb159erjCrluh4O3Xp3EM5NepWmDJjSlCbkhKcz5bgrk5mGwOYmKjCPlmsEALF/8J4rdWU1TkgPEAyESGOsF8+GcP7BUaogAlLJcZGMwILFn1jQi/1yIzeHC4XLjtSo1egWd+LqepZDvglOzQbswZJKLXyiJC4uhWWwTtEYDAMofS9EU5SAtW4KrWQOMfVvRYWB3/vrjL3bn7KfYVopb8dT4EmrVshlagx7h9uD2mDA4KxCSBmXmfISqoEYlIxduo/DdaQR9+hwdO3fi+qv7s2zm/zBArSOYGlWVFx6dgDE4FLW0GHneH5CR64v+ZTLCjv2wMx0mvgPA5h0bz87FOkME0LZte0ymAOwlxWQuX4FkbUK4wwFtmkKjGFi/B4/LA1HJyMDB9HTKrPbjxrI418iyhE6rRa/zLRqNjKKohDhdZLo9eE/D2M2g0/O/77+haU+fgbKn2IGyJgPt7/ORJQ365bPxdGqF4cM36Dr4Wvr89TeffPsZxYoXzkcSwX+hkWXCgs0Mv30IEfGJqB43kuJFZw4mrO1lhAENAc8lV7Pz6YdIXrqOnfsPUV5hP/UB+wLA7fGSX1RGgNGXVE5qfwme4aPQ5hYiXX0tWHzr7aWF/DZtCmtn/Uq6w/WPi6wESDKSLPnCtANJXgWpMsqxFqjt97eqKkg6DQDeChsHR71MzO61SOUlqIkpqIZAJGcZmqGDAFj792qKKopx1zJb9u7tO3BUVGAym0lo6/vYCO9+GdbNKyjeuhSp1wS6dbgcWZYpKCxgy7KVKLbjxylxu90Muv12Vq1cRVDz1igvf4p910bk7evQ792BevON6G4YgQSU5+fw/vNP8cH/Zh9fwFUFz73xJj8t/pMRDz/IHQNuICohmead+7B7zV806X0N7Vp1RJJlsg8e5LEXXkR1V297ObAKSDCbaJwYRWCIT5gU1mKkoDA0wf94Dza+ajBWbQW7XB4Ki8txONw43bW7ln5qx0UvlKRotERJBsrXZhHaoxHa/pfhnvwG8tp5qKWHEVd+hzbIREpqU0J2rECv0SH5AihXO45XVdiXkYGqKMh6HaJhHCIjASm+OQgveFxI1mJcqiAs0lD1UPbp0Z31lUJJbQlTVeJTfUZ0wutBXHITUvhW2J8BiZHw9xZo1hKpXgSqx8XmDWtxu+tGTA6L0acFMAaHUJLWg+BfZkKIGX3nlmhyinHb7Oi6X405MZmKkmLGTHwSm8N13hPPJQE6CXIDjNys1RBqNrEtOQ6DToe5zEp2mY2UgmKW2l04PEqt89JIksTQ6wfStGcPFIeDw18tInzVRozlRUh5+6G0AKylaLLjURevRb6sI0+8NJ6tS+Yzb29ZnRBKtFqZiHoWhgwZCoC0ZTnSc89Ct8ugz1Wg0UFiQ3SWUIbfO5rM/Gc4nFeMze5ErQP1P9soikp5hYOnX3iWN0KCSWnbEd3l/aq2u/Ky2bFqId/+NovDf2+m6HARHqfbN6JUhkTXmIzIAQZknQ4hBIEVNoTdRXOXG52i1tqTSRWC7Tu3YystJTAkhENX90GreAnJz0CJaIBiDiGwZQTaqHDKi0t5//MvfbZztTSmrigv5/Fu3WiZ1pFtjeK5qtsl9O12BW1ad6VN665V5WYuXcBD48aSu3PvMS/9oxECtmzbxr23DeHl198gNrkRga27QOsuAGiOKjv/nbf4efpPFJTbTijcCq/C9nUbeXjESObPn8+sL74lrWcf0nr2qSoz75dfGPHYGHIyMmsUmJxaDeWBAbRt0wrNkZxEexZCWTnkKmDWQN8hyEFhpDZsTzvzejaEBnE4vxiX53yNvRenquSiF0piXA5iD+/Da/d1iJyUBIqCaitGXr8Idf1mNJ3a0nf0QNJ3/4VzzzqW1WBRpagKO/fuZtUfi+l6VS+Ml7VAmf4JUlgMUngMlOTg9XrQP3gn5pF3ArBq6TKemPQyOadQXyEEBxTBfQ/dz/c//kxgeCSER0LrTrBpPWTsg4gwxJMTkYC8PVs4eCiHCruzTmgbfpk/nw+nTuX+ESPoNfEl7CMfJW/LOjzpewkymjG3609gX18Y6Bcnjmfv/oN1Qs1vAJrqtLSpH0pK/VDimibRqWtbNKoHc1gc3XsPZvPiBTw16mFWFpdjPwVBKrPA51ekeBQC5v2BsewwUv5BsJdCoBkaxSEZ7UjffYOaFIW5QTzPvfEy86+7/j9rb22RJNBqtcRGR9CwWRvfum+/hAOHYM3b8MN3UFgKt9wCr71HdGp73nj7M/IHXkNeUWmd6Nv/ArfHy5+r1tH3mv70v6oPD9zzAAkNGrL8569ZsGopmblFFOzPIiO3CI/d6dN8aGSatGxO0zatSGnbmmbNUklJSCIlMpZAk4kRE8ex4Iuv0ZSV+wzDa3l/We0VfD71Ix4cP47Ow69m9fKlZGkb4wmLQessJ22EbzyaNuVT8jL3YLNX1D7vjoCvtmwhcucOMuoF8+VPP3JFn968M+oJ4sMjUVWVB199js8/+gRPURmK4+Qh3FVV8O3sX/ll0UJ697qcu4cMoWWHNCLi4pEkmbXz57Bu9Wpe//pbcqx2PLWw2/DFbrHz6/SfyHnxVaLjfDFLpk/9gJenfcq2TVtOmGIj2GLh1y++oU2fvr7jFRYgvTYNcvPA7YGgQPDKMPBOAtv24rY3LsHwzTQeenwC1Bgmzs9pIy5SysrKBCBGpl4ifrvhceHYnSWEEML97f9ERZcbRUVsM2HTBQlbw1Th3rJDCCHE3r9Xi7QAi5Al6YgIWrVISMKkN4q7Bg2rOodj8V+ibMi94vBlt4ni2FRRcPeoqm3vvvyaMBlMxxynNotGlkW9kCAx7IbeYtmMT4U1L10IIYSybpnw9O4kPC8+LYQQQlUU8dFrT4jWTRsIc6BRSDXUGxBIkpB0WiEHGEV4fKx497VXxJNjRgtJrxXI8mnV8USLLMvik8lvidLi4uP2z9wffxABRn2N17radZckoZHlqqXS0/CsLpIkCXOAUaQlxYrvn3hQ5G5fL1S3u8Z639m/q2jcIFoY9Foh1fLYoeYQUV7kuxbeKZ8JcdMwIfr1E+KN14TweITIPCjErzOE+Oojofz+mxBCiPysLBFgMJ71tp7qEgnCYjaJ/pe1Fx6H3XcRHr5TiFt6C5GWIkSERYjL2wjRJlmok5+quk4rf/xeBJgM573+/+UiSZIw6HUiNDhQJMSEi+4NokWvxChxZVyEiIkIFe31WpF65H6VJXHboJtOOGY5XU4x/KUnhTExWshGg+AU7nWjwSg2rV1XdSxbUYkoWLNeVBQWCSGEqCgtE63rRYtGyKLR6bRXQkg6rdBYAoU+MkyEpyaLjya9KF66c5iwBAcKyaATyCd+lv+9aGRZmIx6ERZsFrGRYaJ7QpS4PilBRIYFiQZGvWghS0JzivUMAfHYTTeJ5X/8IW7s2FGkgNDXYr+nRz5QrS+8n00W4s7+QvRuL0SvdkJce4lvWbtEqKpSVe6tpycK+RTb/e+lrKzshPfFvznybvvo6W/FVy/PrPXy0dPfntb5zjUXvaZEU5qHsXF9jE18krPcuCGytRgRGgVF2ZCbi2PZSnQtU9mfn88OVa3xA0UgcHnc/PTrTG78she9bxuMseclGHtegrRtJyVfTyf6SZ9V+WcffsoTzz6D0316ErSiqlhtDnYtX8vc3fsouGEbA5+djNy+O97XP0RXObXz6zcf89UPs8g8XIDD6a5RhSjptGgCjOjDQ7jrzrt4ZuQj1AsOASA2sj6j3ngdxWpDdXk4W+4Sqqpyz+gxjBg7lksu6c4N/a+ieUoKe7KzST94kF07djBn7jw83uN/Aem0Ggx6HSajHoNeR4Qq8CoKWV4Fs82BxatQBhw6C/XVaTWEhZjp1rsHN7/4NrJGc9yyl/fqiqGojPUFpaz3qif3dhLgcrtY8/mXXPHoI2geGA6XdYKgIIhL8JWJT/QtFaVgLQFg//ZttJUEmXBmgbbOgGSgFIhVFITLTeH+nUQ1bwdPT4J7bwMPkJIERVaICIXDmVX7rt688T9XaUvgS1lfOd16yueTfDYdVdO1AhCq73ctEELgcntwe7yUWx3kSIImSGRWurcLVeAAZCBOp6Vzn95V+2ZtXM1B2U2eYueAxsuQgETiGrfgswkv0rRBQ54ZNwFXbiGilpomp8vJQzffxEdff03jtDQCwkIICPNlyfZ6PHw2aRJ7inKI4zTvJwHC40XxelEq7BQWlPLchIkECTBzell3FVXF4XTjdHkotdrIrZTCEIJYIZABHaeWHSYamDtjBm/MmAFAGFCbXLwfTv+BGwcOpOXlPu9KzfBHIMwC734AZRVgMUNoMGz8g4p5Mwic8C6yLGN1OJElGfV8eA4eEWtOpfwFwCkJJZMmTeLnn39m165dmEwmunbtyquvvkpKSkpVGafTyaOPPsr06dNxuVz06dOHDz74gMijckRkZmYyYsQIFi9ejNlsZtiwYUyaNAntUS5tS5YsYcyYMWzfvp34+HgmTpzIHXfcccoN3OOqINP+zyOj6dgGV0QccoMktI/cg75HRwIaJwNwYMcO3F43xwt2pgqVCqeNm+67j5bvvM/Dox7m+kEDCWqRStCrzwGweuUqxjz2KE6P67jHqQ0erxelxEqWw8WOH2ehaZDCgDvuR9/KF8r6wLbNPD3pVbLzi7EeZ+pG0mrQhgTRplsan732Fi0qvXlyy0uIsoQy4vHx7NYKPnrnPdx5xaius5NKOxGfe53Xq7BkyRKWLFnCUY4sJ5R9JCojZoYGERUeQkxEGPVCzMRbbdhdHjYrKoczc9GX+KZQzvRBkwCtVkM3nZaH730YWaNBHNqHtGYuHNwHm/bAgRz4fTEEhzJg6Ggo8rDjwFfIbs9JhRKBwKt6eXvSy4TFRNHmlkFIlUIlJcXwykuQmgo33QLmEGRzCAClxbnoTHrcThcy5z7DMfiiAzcE8j1e2uaXMH/aO9zy4rvo60XAhOfh+/ehqBRsdtiwB/HUa0jA/j07+ODbb/6z6UQJCY1Gg16jQ6fRIkkyQqh4VC8erxev4j3xsydJSDoNstGAxmhA0mp87pVuD6rTjepy11oYAJ9wogiBAmw/6rxHpm0bA26TgeZNfHFCflwzj/RNq/GaAtEIibC9GWSsWU/Fo0/QtPc1PD7kTrrUi6LfrbdhKyqpdT02pqdz/SWXcMhgoFnLVrRo1Iid6els3ryZJKeDBGB3rY92vMZS+QCfhSBwRw5Zmabg6Ic5i9MTnvbiE5KOcLxQ+v+msKSYngOv495hg3jkvgeIbNYOcdm1SBMnQcYhCDJDfiloLAR99E3VfjN/mUeQ0YzN5cCreGs/LebnuJySULJ06VJGjhxJx44d8Xq9TJgwgd69e7Njxw4CA30uYaNHj+b3339nxowZBAcH8+CDDzJw4ED+/vtvwJdXoX///kRFRbFixQpycnIYOnQoOp2Ol19+GYD09HT69+/P/fffz7fffsuiRYu4++67iY6Opk+fPsetX02sctpw/TyDjN0HeHae72aSXhpDUMeWSBpfZFTF62XrilW899mnNSaqOhpFVbC5Hazbsp47772LJ596knvvv5/77rsbu9XKTTffTLndesZfiULARreXQx4vQRk5jBg3gblLl/P4Y0+wb8tmHn3+WQ5k5OB2e5AVlRj+FZRJktAEmghMSeTbt9+ncWIyboedjXN/YvvSebTtdwNt+97Am488QanbwffvfoinsBRxKn73NRAGOPAZjh4dY6O2l0Ov1xFRz0KHFo3ontaG2268E3NENG6PnYrsTBatmMvytVvZuCMdsvKQy+21NjqtEUmigSTRIrUZie06I1QFKnbAgb0+gaSgyPf1PP9/MHAY5rAYBj/3Jj+s2YRm6QpqY3evCIXteHHYSqu5GaOoUK8+eBXIy4OG/wynTZu3IsscQERZBbGqYEMNxz21dh75IWotyHmBPYBWUckpt/PXjr20/GsebfsMgvadwWWFVX9D3n48Pfqh634ZitfLpOcnUlxm/U+EElmSMemNhAWGEBEcTkiABYNWj1vxUO6ooNBaTKG1CLvLgbcmI1uNjCbQhLFeMOGxEbgSotAEmtAiYfaCweriwObtlGcdPmvawwwJkgNMWCqzlXsbJZGjWGmweTcR+w4SsfcgssPOut+mk12SwxWD7qV7n6u47YaBfPTJNMwCKmpxngoqhQ6Xi7Xr1rJ23dp/mg0EwrHjxEWGF59271RRVYHd4WLVrN+YXJDNC5/MQGcJxzX0DuQ330SHDA89BJVB4gAUt5ueLS5hq3Yb6QVZFFqLsbnsp5/9+VTxR3SFefPmVfv/iy++ICIigvXr19OjRw/KysqYNm0a3333HZdffjkAn3/+OampqaxatYrOnTszf/58duzYwcKFC4mMjKRNmza88MILjBs3jmeffRa9Xs+HH35IUlISb775JgCpqaksX76cyZMnn7JQYnVUEJqfQaH1H5k5uHNrAHav2sD/fpzFz3N+YV9WOhWOiloZLwoh8ChePIqX9KwMxj85nolPP4kky3g8Z889TAGCBch2F3lON9O+/p5pX09HIFDVf9TVR7JtHP1FLem06OoFc8vtQ2icmIzT42LBy2PJMelIzC0l+5svKe3UlsvCGvLxo0+xf9NWVs5d6MsqfAY3bzE+TUlt3Z+PxixBVKCRBkmxDG7ViGsffhpD/crkbEBwQgqDW7UlOvITTMa/cXu8uGxObGcY/8EiBOFNfdo+SdYgthzwGW+63ZDSALILYf4v4K2AwY8gIRFaXo5Uy+hHQgjivG5CG/oCTIn1y5CCIqBJU3j8iX8KqipixzakFq2IatwUnV5HiSShORN1kEZG1mqJiI6iuLQUxetFeL0Ij3JCw7+jUYB1NgeF6dn02L6Htkcewa5X+hZ8anaA/33/BQsXL6fC5jzrgfxkSSbQYKJRfDKP3H0Pnbt2ITA8nECTHq3JgKTTkr17L/fc9xBb9+/A6qioLpjIEokBRqS4CBKS4wlKTaLg8k7cmdKJYbGtMOr0AJSVlzHp3cm8+8ZbOMqsZ1TnMHyanYxAE99tXkW7lm251pzANvdGGi9fi6m0HFO5DXQByHojxXNmk5nckoQOXTDXj8AooCu+KYglZ1CPvfiey7oSMdkXO6zSaKaOvCzdHi+evCI8i9ew8NMp9Bs1Dv2j4ylyOzC2bIX52psBEIqCpNGg0et5evILfP3sh6zcsY6th3aRUXgIm8teZ9p0IXJGNiVlZWUAhIWFAbB+/Xo8Hg+9evWqKtO0aVMSEhJYuXIlnTt3ZuXKlbRs2bLadE6fPn0YMWIE27dvp23btqxcubLaMY6UeeSRR45bF5fLhcv1T7Cp8nLflI0iVLa5HWS53Xz6+pt0vbQHGXv38+lX37Nh40YqnDbsLgcurxvlNFRvR9TEXkWBWg7yp0IWvpwpqipQEViAWKAEyD2qTATVVfyyXos+IozHBwwBYNOmFfzZuzvWsGAMZU7id+/nt60riGmmI6V+PDdfcw1rli73xRg4g8R4cHpJASUJknVaEgOMNEqK5rKrbvQJJE4bzP/JFz6/z03oAsO5/PoHCAyOw3EwB0NWHnkeL5knP8VxEGyXZebt3sltpcUEhITBlUNhytcQoIdAO+QVgdUGsu/V67HbyDuYWSsBNgmQVcFhVWAIC/etPLATvpgATdtA32vAXgFb18HMXxFaFXXxWowBgSQ3asL8jJxaaWOOQZKQ9Fq05gDuvusu3nv5NQ5lpHPf8xP5a8VKPKVWny2R23NSbwkhwOF0UZadz9fvfYjk9tKmTVvMMTE0aOWLXWErLmTZ77N56plnKSgpP7VIl7VEr9XRqW1HZs6aQVBEeI1lmnRuz7RpH3Ld9TeToRzC5rRXPaOSVktksBljcjxhA/vw5CX9aRSTREiAT4MhVBWP4iXYEswrE5/l/qF38tRTE/n2629O+yVTD5CEIEsIViyeR/nA27AEBNG63IM92EJQfhFRBzI40Kk1h5olU2BKJgQPCfg8QpyShEaI07LZOBonZ2Hq5iygkWV0Wg1anQZNZQ4vr1fB7VXwnucowKoQbHN5ESVW/nrtDeTIGPrccjvhT75YVUbZdQBN04YopXYkvZbQ+HBGTn2Ca3aks2jBQj75+jM27Nh0jvJXXZxGJactlKiqyiOPPEK3bt1o0aIFALm5uej1ekJCQqqVjYyMJDc3t6rM0QLJke1Htp2oTHl5OQ6HA5PJxL+ZNGkSzz33XI113QNIKGx4YpwvkZhUmSVY+AwV1VpmCT4f2Kn+dePFJ3wcbf3hhOovZUlC0mm5uf81JEXG4rbbyJjzM4fvuoXbnnobR6CBNQOuoN/732C7wQO3DKdxanNkowFJlquFYD53SFTotGjDg0lMiiW4RRvf6pnfwg9fQVyUL5vo3U+gCY+i6zW3ExgQzqjBQyhxuE76Yj0eQkCU243YtJXnxt3Ly29/iSY0DHHLTUgrlsKBLCgtR5gD8ETEogfKSovZoqgotRBCjfiGgkOKilQZ/6AkMozQRrFIcjHM+gQ27wNJRbRqgKPChdZuQxMQSIOomNOO3yIb9ejCQ7h60I289/KraDQaEhs24rdPvmLUV1OY/sMP2Pdl4c4tQnW6T6od8yoqZruT4px8nnp/KuGhFoItAfTpfjkF1nLmL15CQVGpLyeI23vW485IkkTDxCR+/OV/BIWH4T6cj3PJRrS7dyEV5qOExqHqdJjHD6NRh1Zc1rUHG+bOpMjpYDcCJN81OZQcR/0rOvPVdXeRGOIbY2z2Crb88CUZ6/7GZZQJ7tidblcOpEFCAl9/+RVNIiJ5+o03TqveRZW/VaebAo/AEhAEgLuwADU4iKLEWOJ2H6TRqs2UhgdT1iIBfUPf8xdp8N09c8/04tUBjiTrNAcYqRcaRKjFTIBJj6L4jPrdJeVQYmW3VzmvoQ3KgFVuL7rCUm4f+RBfWerR96qrEKqK61AB+lhfIDXlz5V49xZgvKsvmvAQkto05u42jRn64HDatGnLzj27/vvKXpwyyekLJSNHjmTbtm0sX778bNbntBk/fjxjxoyp+r+8vJz4+Piq/wU+e5BAVSEEzuDL+vxipxZfPEJgEILhvXwBnfbPnYXT6eaGSR/TZPkaTHYXQflF6EusuPfvASA1voEv+7BUuymJs40kQZlejzssmJ7tuqOLaODbMGcBlFRA2QHYth8yDiOuHYzU73paX9GPdu3ak7lwMdYzeOIcHoVCq53CddtwOZ0EmAIRg+9E3bUbac12hCqwBwdh6Oibkvz4048or7Cj1EIQ2ln5W+f2sGrTJpJatKJIDkK1OgjNzkEODYb6QQirA0dxGcr1txMYHkFJfj4z5y9APY0BWjboCG/cgI/ffIurL++LRpZJ37kJjctNQptOTLlrNMmtW/LGe29T+vdmXIcLUB0nD2m/R0Coy0txbhGhecXYJXh+015UIfB6FbzKaYTcriUaSebTSS8RFu7Tylq/X4xpxg9I2btBb0TyeNCholyVhtyxJX269+DgkgVYK0p9NkGyjCbACI0SGNt3IIkhkdjsFaz54Qvsa1eRF2ohPreYgvhIrIv/4LdPv+DyDz4nsUlTZL3+tOt9ZNJYa7Xx6CV9q9Y3sbvZoXrY0jON0MO5mItLiNibThdF0O0BX2beX+fNu2BeJCdCkiSMBh0R9YJp1iieiWOfoNOV13Jo5zq2rF1IRlYWpRt3s21XBkUFJRRXOM5rfBtVCFxuL8VlFdw3/F5eHTuegfcMxZhw1IfyqiWIH2fjmvoSpKSgXDsA492D0JuMxMXEsnvvHr/R62kin85ODz74IL/99huLFy8mrjJIDUBUVBRut5vS0tJq5fPy8oiKiqoqk5eXd8z2I9tOVMZisdSoJQEwGAxYLJZqS01E4zP4uphJBVJdHuqbfddgl6uU/WmtUfQavLIGY1kxqcvXkNUimZ97NgMgsX4UgQbDeTGG0gOpqqC+qtAh7RJaXX+Hb0NmBhRkQX4J5BX7XPNMEqxciOr2vUSbNE3lzGb9fZ5Ca90eDh4uZNfmjQDIIRFo3vkc99jxlF9zNeqTr6I3W8g5lMnUjz7G6ao5FcHx8CoKy1esBMBoDse6bB2l6bkUexRKQkLJSYghM7U55tt82ZUfeXQ0+fkFp/xOigFStVpeGH4nA3pdhUaW2bdtLd9tmM/0TYv487DvC25Mh168N2YC5kYJaMwBoDn5UOAFCvBFNM3zKhz2KFTYndgdLtwe738aUl6WZLYs/bvq/+D+nRCyjGowodZPBNWN6nGirvb1X9uubSi0hHFArwckJElC1uuw1A9jUKP2AGRMeg7LlE/Q5xcRtyedkMO5mIvLWH3NpRAcSExlkrnvf/nljOuvOFys/e23qv/TRj5Bt3tGk1RUQHaD+sy4+3r+atmIVvc/hlar5fc/5vHbggVnfN66gE6rISzYTIsmCbz8ymt07X8TWr2BBq27cc2w8dx54130vu0mOjZLokN0OOZA4/nP4wUgwO1ys/zLH9EHB1Wt9q5cj+fLb5APH0B12PG6dNgWbaxyEig/Qzuk2tdPnPpyAXBKQokQggcffJCZM2fy559/kpSUVG17+/bt0el0LFq0qGrd7t27yczMpEsXXxjhLl26sHXrVvLz86vKLFiwAIvFQrNmzarKHH2MI2WOHONM2I9vYL2YyQOKhKiKM2iXICM5kuzUREqS4iiKiaHcEkTszv2YNm2jvMI3Y90oLvG8TN0cUddJquD2u0cC4Jn/G9xyrS/zqkkPIWZoGA/X3A5PTUbWG9i3ayuv/fwTZWeo3RGA26NQWFLOvYNu4cXbB7Fhme/+M949gtC3phLcqh2qovDihCcoKCo7ZSNOIWD90mUARKe2pGjkaLZe0o210XGsNZnJatyaqBHjkLU65syayfc//HhaamyrLGEJNPFb3gHcHt8kX8mMGbSdu5y4LXvY+cPXfFO4C1UIbmjdlU+ffRl9qAVJe/zYLDVxmNOzHToTpsyew1+zfP2iaRCDlLETTBZAINnLEYHBKEt9mtv6TRoiSfIxpsgmvRGtxnfHidmzEVpQFS85DROQZZng4lKMboVOo8ahMxjIOrAf77ZtGM+w7sLjZd7CRXRJTWby/77BrXhpktyMQfc8RWGT5mwICuHqEU+S0LEzbqeT0WPG+LyzLnAkCYwGPQkx9XnxhVdp0/kKnzC/fiGk70bS6Qls2YWO/YbSrkUy7WPCCQ+xoD1BrKBzh0AgaJQUU7XG+cqnuIeNQCrMQ6gq6I1gDEbRatGZAwAoLam9G7efYzml6ZuRI0fy3XffMXv2bIKCgqpsQIKDgzGZTAQHB3PXXXcxZswYwsLCsFgsPPTQQ3Tp0oXOnTsD0Lt3b5o1a8btt9/Oa6+9Rm5uLhMnTmTkyJEYDL4MMffffz/vv/8+jz/+OHfeeSd//vknP/74I7///vsZN9gLFJ7xUeo2xUCJV6Gw0hDZVGQlZdY2/ho6AIdeQ1BBCS2WrMFUUkrshv2YR/hcUQ8dOOhTdZ9j7MAOYORNg2iY7PMlcjkcuDukEOhy+cI8JzWDl16HeuFIQFH6Hp598lHKyivOipeHqFTZWotLWPjTLD6Zv4Bbb7mFl9/5AIDFf8zj0SceZ9u2HT6j5tNgzc6dbF6yhNY9e9Jh9Ngay1jz85l2/wi8Hu9pae4rdFo8AUZc9lI2lx6mY/0GuNu0wrRxA9awUCyH86n48BOWJiRz6ZB7ubbzpXzy1jsMHTwEr6vuJhZTETROTqLr1ZcCYPvmV2ShQGAIWAuQPG40dhtUftGWlZTj9DgrbVt8nmqq04Ul+x8N7PZL00jcsJ2Y/VkoWg0enZbSsCAeMiaR2ONKFK+XN56cgIwvtX3uvyt1KgjBYZeXvKwcNj36ONN/+onPnnqB5s1aMmrUc4yqLGavqGDYbbexd+fOEx7uQkGSJIICjdx4dX/adLsCoapIGStg2a+wMwMCo2Dyh8hBIaRcezVbPR6iymzkFpb+J8bSp4IQ4PZ62F7q+2gTqgpt2qC5YQDKl3lQUo5cPw6vJONU/7Hyq7DbzomNoi++S+3Pc6F4BJ2SUDJ16lQAevbsWW39559/XhXYbPLkyciyzA033FAteNoRNBoNv/32GyNGjKBLly4EBgYybNgwnn/++aoySUlJ/P7774wePZp33nmHuLg4Pv3001N2B/7/jFCUqsBLnsg4tu/bQvb+g0iRIYRLKqVN41ELgmnQMAVZltm2cweHDh48b3PYAmib2qzqf/OAm8hqHIP9j/8R4BYEvD0VyWjEW1rI33/8wJczfmbdpl2+ZH5nadpACMEer2Cv4kEuLOONDz6msKCUS7p0YcLYsQS7XEcifZz28TtceSU333QTo0eMIKZBA0LCwtDrdBzev5/PfpjO1o8/YWNe3mmfQ5IkrAF65PqhVRloS5MTWX/rddRPz0TrcNBy6SqEvIrlRUV0e3gCg/sPYMXNg3h/2uenedb/HlVVaZycgKYywKLhmsug3mScX/yBFFIPYQzCE9MYpXlrTEBudg6ltvJ/vCBUQYLdSZtYX6BEm81KduMYLIXF2MusRB88hFsjEZXamsSrfDmH7nhkJN/Nnn32AtepKordgXrYw5ZZc3kxPZvvV/0TS2TNX39xy/DhpO8/HYf6uokkSQSYDHiVSr2tqsDM/0GJFdo0gkXrYdkC6HEl4Q1SaWCZT0uNzCGNRIV0fmcchBA43S7+2rebnF37iG7aCGPfDtC3A8qAK3ENGIzisOG0l+Kt9EAtKy6hsLjwHAkAF6el6ykJJbW50EajkSlTpjBlypTjlklMTGTOnDknPE7Pnj3ZuHHjqVTPz9EIyN7jM2IddNNtNG3WimnffMQcYaNtTj6BpU7a9bqK/jfdBsDWufPQK2qtQjL/Vzz87LNsWrSQpM5pjH7mOeKbdWNfQTmGK29DMhqx5mbx5UcvsHL9LrbuySS3oPSEoepPl6oInSp88v33fPL998TgCz0WQO3CVh8Pr9fLd99/z3fff1+1rkXl721ncFyABMDi8VKiqCgaLVGBvhTsO0NMbL2yG+1/ddLlx9/IbZRAaEY2upUrEQ+pgIadB8/1ZMypIYRg6nffcdWAAfS4ph+6yHpwfT901/dDuD24tx9AtTkwp/iM29WyIsrs5f/EKRGCdKeby2J9U86BgUHcc98zbLwpixUr5xG5fA3x2cWkjfAZy0+d8R0//DjjjIMJHtsQ31SO0wNdOnerWv31pEk8NnEi+Wc5tsv5RsIXuK0gPxtPWTG64DCIToTfvvZ5tiHD+r+hx5Xo66fQqteN5G85zKEtezl4fquOQOBWPEhlhbw+7F6uu/UOGnbtQlyHxsgd2mHcsgp3di5hoRYikxIB2LR5C171/Gp4ziZTpkzh9ddfJzc3l9atW/Pee+/RqVOn45afMWMGTz31FAcPHqRx48a8+uqrXHXVVad0zos+983/Zx568kkOlpQwYfx4WjdvxbuTptB/1v9wFBbSe9AQAoJ8qu6i7GyWTpmChfM7tWWz2Xj/jz/QLVpEqcfDcy++TKNL/0kJP+Orafz5yzL25BWRVWY7q1qSk3GY/y4S5pkKI0coxxdiu8zhpmdoLPFGn6Fz7wcnkBQTgbG0DFXWYq0fjk0r0eWqm9FqdSxdvZLFf9cNL7rjIRDYXXaevPlmOne5lNufeYpWl6YBIOl1GNqmYDiqfOs+vbC5HdU8IBRV5cFXX8UTEkzPPv0IDw6he3QKTXuEsIwQWqRdhjkkjH2ZBxk/YQJKue2Uws2fKo998AHL9+9n8apVFBZenJPKKapKis2B0+VGdVVqS8odUFgC2QU+qWXuXBgwBKlhE5LSenH7tM58Gh0F4nx+IvlQVIX69nIKNq/l84Iimv3VlbEzpiJptUiR9TFG1q9Wfue6tWc9aOBx+Y8VJT/88ANjxozhww8/JC0tjbfffps+ffqwe/duIiIijim/YsUKBg8ezKRJk7j66qv57rvvuO6669iwYUNV2JDaIIkLZaLpFCkvLyc4OPh8V6NOEBUVxcuTJjH8X7mDtm/fzptvvcX8b7/F7HKRw+kl1vov0MgyQ28cyNhHRhMUGsavM3/mhbffIqq0DLdXYYe4cOZIzymSRO/eV/DLL79h0Bsonfsr2994CZPDSWFMFB6TgbLwepS0bcK9tz6GTqPliuuu5s/f5l4QhpXJkkyAIYD+t97GpE9908nvPv4qzZo1RG8x0TStHRGxMZQWFBAWEXns3L4sozEZ0IeHcPlVffn46ReJifrHkLHCWs6VA69j9bLlCI/nQtF411kigOSwIBK7tOKLb3/BEBwGw26ENWug3AYBRgg1ozZphLNNZwIeewoAizkAq81xfiuPTzMaCZgkDTkBQYQFBjP0km7oo2LJKi4jKS6SQ4V5KChcfVVfRj0xjt0HDpzSOcrKyo7rLVoTR95tHz7xBSZjQK33czjt3P/KHbU+X1paGh07duT9998HfFOo8fHxPPTQQzzxxBPHlB80aBA2m43fjvIy69y5M23atOHDDz+sdT0vWqGkrKyMkJAQsrKyTqnDL2oOVebUNRohvOaImHWODRt89a30zCI725dh19+nx6e4GCrnuAFfuPyjkSTQVQaG93pBe4EqTIuLffdBSYnv79hYyMrytSc2FgJqGLB37gS7Hdq3/2ddRYVvH+OZ+tj4OYb9+333W8OG4HDAkZAOLhf8Oy7SkfvQ4/nn/qwLHDgAUVH/3E/r14PZDEcS0WZm+tp2VGLa2nAkllZpaekpfUAfEUomj/4Ak6HmEBk14XA5GD35gWPeiQaDocrJ5Ahut5uAgAB++uknrrvuuqr1w4YNo7S0lNmzZx9z/ISEBMaMGVMt8vozzzzDrFmz2Lx5c63reYGORienqMgXS/HoAGp+/Pjx48dPXcJqtZ6SUKLX64mKimL05AdO+Vxms/mYd+IzzzzDs88+W21dYWEhiqLUGFl9166ao9UeLxL7ES/d2nLRCiVH8vFkZmZeFNM4R6Tqi0Xz429P3cbfnrqNvz11l9q2RQiB1WolJibmuGVqwmg0kp6ejvvfGtBaIISonqkcjtGSnG8uWqFErkz2FBwcfMHf5Edzomi1FyL+9tRt/O2p2/jbU3epTVtO94PZaDRi/A+nG8PDw9FoNDVGVj8Sef3fHC8S+/HKH4/TCjPvx48fP378+Lk40ev1tG/fvlpkdVVVWbRo0XEjq5+tSOwXrabEjx8/fvz48XN6jBkzhmHDhtGhQwc6derE22+/jc1mY/hwX36uoUOHEhsby6RJkwAYNWoUl156KW+++Sb9+/dn+vTprFu3jo8//viUznvRCiUGg4Fnnnmmzs2XnS7+9tRt/O2p2/jbU7e5mNpzsbRl0KBBFBQU8PTTT5Obm0ubNm2YN29elTFrZmZmlZkEQNeuXfnuu++YOHEiEyZMoHHjxsyaNeuUYpTARewS7MePHz9+/Pi5sPDblPjx48ePHz9+6gR+ocSPHz9+/PjxUyfwCyV+/Pjx48ePnzqBXyjx48ePHz9+/NQJ/EKJHz9+/Pjx46dOcFEKJVOmTKFBgwYYjUbS0tJYs2bN+a5SjUyaNImOHTsSFBREREQE1113Hbt3765WpmfPnkiSVG25//77q5XJzMykf//+BAQEEBERwdixY/F6veeyKQA8++yzx9S1adOmVdudTicjR46kXr16mM1mbrjhhmMiANaVtgA0aNDgmPZIksTIkSOBut83y5Yt45prriEmJgZJkpg1a1a17UIInn76aaKjozGZTPTq1Yu9e/dWK1NcXMytt96KxWIhJCSEu+66i4qKimpltmzZQvfu3TEajcTHx/Paa6+d8/Z4PB7GjRtHy5YtCQwMJCYmhqFDh3L48OFqx6ipT1955ZU61x6AO+6445i69u3bt1qZC6V/gBqfJUmSeP3116vK1JX+qc3YfLbGsyVLltCuXTsMBgONGjXiiy++OOvtuaAQFxnTp08Xer1efPbZZ2L79u3innvuESEhISIvL+98V+0Y+vTpIz7//HOxbds2sWnTJnHVVVeJhIQEUVFRUVXm0ksvFffcc4/IycmpWsrKyqq2e71e0aJFC9GrVy+xceNGMWfOHBEeHi7Gjx9/ztvzzDPPiObNm1era0FBQdX2+++/X8THx4tFixaJdevWic6dO4uuXbvWybYIIUR+fn61tixYsEAAYvHixUKIut83c+bMEU8++aT4+eefBSBmzpxZbfsrr7wigoODxaxZs8TmzZvFtddeK5KSkoTD4agq07dvX9G6dWuxatUq8ddff4lGjRqJwYMHV20vKysTkZGR4tZbbxXbtm0T33//vTCZTOKjjz46p+0pLS0VvXr1Ej/88IPYtWuXWLlypejUqZNo3759tWMkJiaK559/vlqfHf281ZX2CCHEsGHDRN++favVtbi4uFqZC6V/hBDV2pGTkyM+++wzIUmS2L9/f1WZutI/tRmbz8Z4duDAAREQECDGjBkjduzYId577z2h0WjEvHnzzmp7LiQuOqGkU6dOYuTIkVX/K4oiYmJixKRJk85jrWpHfn6+AMTSpUur1l166aVi1KhRx91nzpw5QpZlkZubW7Vu6tSpwmKxCJfL9V9W9xieeeYZ0bp16xq3lZaWCp1OJ2bMmFG1bufOnQIQK1euFELUrbbUxKhRo0RycrJQVVUIcWH1zb9fEqqqiqioKPH6669XrSstLRUGg0F8//33QgghduzYIQCxdu3aqjJz584VkiSJ7OxsIYQQH3zwgQgNDa3WnnHjxomUlJRz2p6aWLNmjQBERkZG1brExEQxefLk4+5Tl9ozbNgwMWDAgOPuc6H3z4ABA8Tll19ebV1d7Z9/j81nazx7/PHHRfPmzauda9CgQaJPnz7/aXvqMhfV9I3b7Wb9+vX06tWrap0sy/Tq1YuVK1eex5rVjrKyMuCfDMdH+PbbbwkPD6dFixaMHz8eu91etW3lypW0bNmyWsroPn36UF5ezvbt289NxY9i7969xMTE0LBhQ2699VYyMzMBWL9+PR6Pp1rfNG3alISEhKq+qWttORq3280333zDnXfeWS3L5oXUN0eTnp5Obm5utf4IDg4mLS2tWn+EhITQoUOHqjK9evVClmVWr15dVaZHjx7o9fqqMn369GH37t2UlJSco9bUTFlZGZIkERISUm39K6+8Qr169Wjbti2vv/56NXV6XWvPkiVLiIiIICUlhREjRlBUVFStrhdq/+Tl5fH7779z1113HbOtLvbPv8fmszWerVy5stoxjpS5EN5X/xUXVZj5wsJCFEWpdhMAREZGsmvXrvNUq9qhqiqPPPII3bp1qxaWd8iQISQmJhITE8OWLVsYN24cu3fv5ueffwYgNze3xvYe2XYuSUtL44svviAlJYWcnByee+45unfvzrZt28jNzUWv1x/zgoiMjKyqZ11qy7+ZNWsWpaWl3HHHHVXrLqS++TdHzl9T/Y7uj4iIiGrbtVotYWFh1cokJSUdc4wj20JDQ/+T+p8Mp9PJuHHjGDx4cLVMrQ8//DDt2rUjLCyMFStWMH78eHJycnjrrbeq6lxX2tO3b18GDhxIUlIS+/fvZ8KECfTr14+VK1ei0Wgu6P758ssvCQoKYuDAgdXW18X+qWlsPlvj2fHKlJeX43A4MJlMZ709dZ2LSii5kBk5ciTbtm1j+fLl1dbfe++9VX+3bNmS6OhorrjiCvbv309ycvK5ruYJ6devX9XfrVq1Ii0tjcTERH788ccL/uGaNm0a/fr1IyYmpmrdhdQ3/5/weDzcfPPNCCGYOnVqtW1jxoyp+rtVq1bo9Xruu+8+Jk2aVOdyldxyyy1Vf7ds2ZJWrVqRnJzMkiVLuOKKK85jzc6czz77jFtvvRWj0VhtfV3sn+ONzX7+Gy6q6Zvw8HA0Gs0xFtB5eXlERUWdp1qdnAcffJDffvuNxYsXExcXd8KyaWlpAOzbtw+AqKioGtt7ZNv5JCQkhCZNmrBv3z6ioqJwu92UlpZWK3N039TVtmRkZLBw4ULuvvvuE5a7kPrmyPlP9KxERUWRn59fbbvX66W4uLjO9tkRgSQjI4MFCxZU05LURFpaGl6vl4MHDwJ1rz1H07BhQ8LDw6vdXxda/wD89ddf7N69+6TPE5z//jne2Hy2xrPjlbFYLBf8h9zpclEJJXq9nvbt27No0aKqdaqqsmjRIrp06XIea1YzQggefPBBZs6cyZ9//nmMWrImNm3aBEB0dDQAXbp0YevWrdUGpyODcbNmzf6TeteWiooK9u/fT3R0NO3bt0en01Xrm927d5OZmVnVN3W1LZ9//jkRERH079//hOUupL5JSkoiKiqqWn+Ul5ezevXqav1RWlrK+vXrq8r8+eefqKpaJYB16dKFZcuW4fF4qsosWLCAlJSUcz41cEQg2bt3LwsXLqRevXon3WfTpk3Islw1DVKX2vNvDh06RFFRUbX760LqnyNMmzaN9u3b07p165OWPV/9c7Kx+WyNZ126dKl2jCNl6uL76pxxng1tzzrTp08XBoNBfPHFF2LHjh3i3nvvFSEhIdUsoOsKI0aMEMHBwWLJkiXVXODsdrsQQoh9+/aJ559/Xqxbt06kp6eL2bNni4YNG4oePXpUHeOI21nv3r3Fpk2bxLx580T9+vXPixvto48+KpYsWSLS09PF33//LXr16iXCw8NFfn6+EMLnQpeQkCD+/PNPsW7dOtGlSxfRpUuXOtmWIyiKIhISEsS4ceOqrb8Q+sZqtYqNGzeKjRs3CkC89dZbYuPGjVXeKK+88ooICQkRs2fPFlu2bBEDBgyo0SW4bdu2YvXq1WL58uWicePG1VxOS0tLRWRkpLj99tvFtm3bxPTp00VAQMB/4nJ6ova43W5x7bXXiri4OLFp06Zqz9MRT4cVK1aIyZMni02bNon9+/eLb775RtSvX18MHTq0zrXHarWKxx57TKxcuVKkp6eLhQsXinbt2onGjRsLp9NZdYwLpX+OUFZWJgICAsTUqVOP2b8u9c/JxmYhzs54dsQleOzYsWLnzp1iypQpfpfg812B/4L33ntPJCQkCL1eLzp16iRWrVp1vqtUI0CNy+effy6EECIzM1P06NFDhIWFCYPBIBo1aiTGjh1bLRaGEEIcPHhQ9OvXT5hMJhEeHi4effRR4fF4znl7Bg0aJKKjo4VerxexsbFi0KBBYt++fVXbHQ6HeOCBB0RoaKgICAgQ119/vcjJyal2jLrSliP88ccfAhC7d++utv5C6JvFixfXeH8NGzZMCOFzC37qqadEZGSkMBgM4oorrjimnUVFRWLw4MHCbDYLi8Uihg8fLqxWa7UymzdvFpdccokwGAwiNjZWvPLKK+e8Penp6cd9no7ElVm/fr1IS0sTwcHBwmg0itTUVPHyyy9Xe8nXlfbY7XbRu3dvUb9+faHT6URiYqK45557jvm4ulD65wgfffSRMJlMorS09Jj961L/nGxsFuLsjWeLFy8Wbdq0EXq9XjRs2LDaOf4/IgkhxH+khPHjx48fP378+Kk1F5VNiR8/fvz48ePnwsUvlPjx48ePHz9+6gR+ocSPHz9+/PjxUyfwCyV+/Pjx48ePnzqBXyjx48ePHz9+/NQJ/EKJHz9+/Pjx46dO4BdK/Pjx48ePHz91Ar9Q4sePHz9+/PipE/iFEj9+/Pjx48dPncAvlPjx48ePHz9+6gR+ocSPHz9+/PjxUyf4P5EsU/ewkVJwAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
    " + "
    " ] }, "metadata": {}, @@ -749,7 +778,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Save your `SpatialData` object\n", + "## Save your SpatialData object\n", "\n", "You can save your `SpatialData` object for later use. This will create a `.zarr` directory." ] @@ -809,7 +838,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.9.16" } }, "nbformat": 4, diff --git a/docs/tutorials/comseg.ipynb b/docs/tutorials/comseg.ipynb index 8e130e67..d4a0ea1c 100644 --- a/docs/tutorials/comseg.ipynb +++ b/docs/tutorials/comseg.ipynb @@ -35,7 +35,7 @@ "\n", "First, follow the original [CLI tutorial](https://gustaveroussy.github.io/sopa/tutorials/cli_usage/) until you finished the \"Cellpose segmentation\" section, and then, continue below.\n", "\n", - "#### 1. Save a ComSeg config file as a `config.json` file\n", + "#### 1. Save a ComSeg config file as a config.json file\n", "\n", "We display below a minimal example of a ComSeg `config.json` file\n", "\n", diff --git a/docs/tutorials/xenium_explorer/explorer.ipynb b/docs/tutorials/xenium_explorer/explorer.ipynb index 0592073b..e604a3a9 100644 --- a/docs/tutorials/xenium_explorer/explorer.ipynb +++ b/docs/tutorials/xenium_explorer/explorer.ipynb @@ -18,8 +18,6 @@ "outputs": [], "source": [ "import sopa\n", - "import sopa.io\n", - "import sopa.segmentation\n", "import spatialdata" ] }, @@ -175,7 +173,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Use the coordinates of a lasso selection in `SpatialData`\n", + "## Use the coordinates of a lasso selection in SpatialData\n", "\n", "On the Xenium Explorer, you can use the Lasso or Rectangular selection tools to select some regions of interest. Then, you'll be able to analyze back this region of interest using `spatialdata`.\n", "\n", @@ -252,7 +250,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Cropping a `SpatialData` object from a selection\n", + "### Cropping a SpatialData object from a selection\n", "\n", "You can also export the whole selection as a polygon and use it to crop the `spatialdata` object. For that, click on \"Download Selection Coordinates as CSV\", as below. It will create a file called `\"Selection_1_coordinates.csv\"`.\n", "\n", diff --git a/sopa/cli/app.py b/sopa/cli/app.py index 3c6bf66c..bb857ead 100644 --- a/sopa/cli/app.py +++ b/sopa/cli/app.py @@ -178,7 +178,7 @@ def aggregate( ): """Create an `anndata` table containing the transcript count and/or the channel intensities per cell""" from sopa.io.standardize import read_zarr_standardized - from sopa.segmentation.aggregate import Aggregator + from sopa.segmentation import Aggregator sdata = read_zarr_standardized(sdata_path, warn=True) diff --git a/sopa/segmentation/__init__.py b/sopa/segmentation/__init__.py index 5b55fb9a..cc09577f 100644 --- a/sopa/segmentation/__init__.py +++ b/sopa/segmentation/__init__.py @@ -1,5 +1,5 @@ -from . import shapes, aggregate, methods, stainings +from . import aggregation, shapes, methods, stainings from ..patches import Patches2D -from .aggregate import Aggregator, overlay_segmentation +from .aggregation import Aggregator, overlay_segmentation from .stainings import StainingSegmentation from .tissue import tissue_segmentation diff --git a/sopa/segmentation/aggregate.py b/sopa/segmentation/aggregation.py similarity index 96% rename from sopa/segmentation/aggregate.py rename to sopa/segmentation/aggregation.py index 4d47354d..94c1fa12 100644 --- a/sopa/segmentation/aggregate.py +++ b/sopa/segmentation/aggregation.py @@ -73,6 +73,24 @@ def overlay_segmentation( ) +def aggregate( + sdata: SpatialData, + average_intensities: bool = True, + expand_radius_ratio: float = 0, + min_transcripts: int = 0, + min_intensity_ratio: float = 0, + **kwargs: int, +): + aggr = Aggregator(sdata, **kwargs) + + aggr.compute_table( + average_intensities=average_intensities, + expand_radius_ratio=expand_radius_ratio, + min_transcripts=min_transcripts, + min_intensity_ratio=min_intensity_ratio, + ) + + class Aggregator: """Perform transcript count and channel averaging over a `SpatialData` object""" @@ -151,9 +169,9 @@ def overlay_segmentation( self.geo_df = pd.concat([geo_df_cropped, geo_df], join="outer", axis=0) self.geo_df.attrs = old_geo_df.attrs - self.standardized_table(save_table=save_table) + self.add_standardized_table(save_table=save_table) - def standardized_table(self, save_table: bool = True): + def add_standardized_table(self, save_table: bool = True): self.table.obs_names = list(map(str_cell_id, range(self.table.n_obs))) self.geo_df.index = list(self.table.obs_names) @@ -269,7 +287,7 @@ def compute_table( SopaKeys.UNS_HAS_INTENSITIES: average_intensities, } - self.standardized_table(save_table=save_table) + self.add_standardized_table(save_table=save_table) def _overlap_area_ratio(row) -> float: diff --git a/sopa/segmentation/transcripts.py b/sopa/segmentation/transcripts.py index 0dc43d09..31cf85e7 100644 --- a/sopa/segmentation/transcripts.py +++ b/sopa/segmentation/transcripts.py @@ -17,7 +17,7 @@ from .._constants import SopaKeys from .._sdata import get_spatial_element, get_spatial_image -from . import aggregate, shapes +from . import aggregation, shapes log = logging.getLogger(__name__) @@ -58,7 +58,7 @@ def resolve( geo_df_new = ShapesModel.parse(geo_df_new, transformations=transformations) log.info("Aggregating transcripts on merged cells") - table_conflicts = aggregate.count_transcripts(sdata, gene_column, geo_df=geo_df_new) + table_conflicts = aggregation.count_transcripts(sdata, gene_column, geo_df=geo_df_new) table_conflicts.obs_names = new_ids table_conflicts = [table_conflicts] diff --git a/sopa/utils/data.py b/sopa/utils/data.py index 75d4f320..5b667744 100644 --- a/sopa/utils/data.py +++ b/sopa/utils/data.py @@ -158,7 +158,7 @@ def uniform( def _add_table(sdata: SpatialData): - from ..segmentation.aggregate import Aggregator + from ..segmentation import Aggregator aggregator = Aggregator(sdata, shapes_key=SopaKeys.CELLPOSE_BOUNDARIES) diff --git a/tests/test_aggregation.py b/tests/test_aggregation.py index 300a2b66..9bac58b3 100644 --- a/tests/test_aggregation.py +++ b/tests/test_aggregation.py @@ -6,7 +6,7 @@ import xarray as xr from shapely.geometry import Polygon, box -from sopa.segmentation import aggregate +from sopa.segmentation import aggregation dask.config.set({"dataframe.query-planning": False}) import dask.dataframe as dd # noqa @@ -23,7 +23,7 @@ def test_average_channels_aligned(): # One cell is on the first block, one is overlapping on both blocks, and one is on the last block cells = [box(x, y, x + cell_size - 1, y + cell_size - 1) for x, y in cell_start] - means = aggregate._average_channels_aligned(xarr, cells) + means = aggregation._average_channels_aligned(xarr, cells) true_means = np.stack([image[:, y : y + cell_size, x : x + cell_size].mean(axis=(1, 2)) for x, y in cell_start]) @@ -50,7 +50,7 @@ def test_count_transcripts(): gdf = gpd.GeoDataFrame(geometry=polygons) - adata = aggregate._count_transcripts_aligned(gdf, points, "gene") + adata = aggregation._count_transcripts_aligned(gdf, points, "gene") expected = np.array([[0, 3, 1], [1, 0, 1], [1, 3, 1]]) assert (adata.X.toarray() == expected).all()