From 4dd68e611470791adefb9b5070a33dd797f40c41 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 13:52:27 +0200 Subject: [PATCH 01/25] added readme for dev res (file format) --- .../storage_format/Readme.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 notebooks/developers_resources/storage_format/Readme.md diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md new file mode 100644 index 0000000..8440091 --- /dev/null +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -0,0 +1,17 @@ +# Examples covering the whole storage specification + +This repository offers comprehensive resources for developers that want to interface their methods with the SpatialData format in a robust way. + +## Why this repository +The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses some less-documented features of the OME-NGFF specification that are still under review, or experimental storage strategies that will be eventually discussed with the NGFF community. +This repository addresses the need for communicating the storage specification to other developers in a complete and robust way. + +## What this repository contains +In particular: +- this directory contains notebooks that operate on small datasets which are created, written to disk, reloaded, rewritten to disk and checked for consitency, reloaded again, plotted, and finally the disk storage is uploaded to S3 (available here); # TODO add link +- each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks; +- the notebooks are tested daily against the latest `release` and the latest `main` versions of the `spatialdata` library, and detected differences are reported here; # TODO add link +- also, detected differences between the previous release version are reported here. # TODO add link + +## How to use this repository +Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is then guaranteed to run correctly on any SpatialData dataset. From e0b05ac781f4a7922c01215464e11fc34bbebea0 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 14:24:58 +0200 Subject: [PATCH 02/25] updated readme --- datasets/README.md | 27 ++++++++++--------- .../storage_format/Readme.md | 18 ++++++++++--- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/datasets/README.md b/datasets/README.md index 369cdc7..3dbe187 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -4,19 +4,20 @@ The example notebooks operate on a set of spatial omics datasets that can be dow Here you can find the dataset hosted in S3 object storage. -| Dataset | .zarr.zip | S3 (see note below!) | -| :-------------------------: | :----------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------: | -| cosmx_io | | | -| mcmicro_io | | | -| merfish | | | -| mibitof | | | -| steinbock_io | | | -| toy | | | -| visium | | | -| visium_io | | | -| visium_associated_xenium_io | | | -| xenium_rep1_io | | | -| xenium_rep2_io | | | +| Dataset | .zarr.zip | S3 (see note below!) | +|:------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| +| cosmx_io | | | +| mcmicro_io | | | +| merfish | | | +| mibitof | | | +| steinbock_io | | | +| toy | | | +| visium | | | +| visium_io | | | +| visium_associated_xenium_io | | | +| xenium_rep1_io | | | +| xenium_rep2_io | | | +| [additional resources for methods developers](../notebooks/developers_resources/storage_format/) | - | - | ## Note diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index 8440091..ba66519 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -8,10 +8,20 @@ This repository addresses the need for communicating the storage specification t ## What this repository contains In particular: -- this directory contains notebooks that operate on small datasets which are created, written to disk, reloaded, rewritten to disk and checked for consitency, reloaded again, plotted, and finally the disk storage is uploaded to S3 (available here); # TODO add link -- each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks; -- the notebooks are tested daily against the latest `release` and the latest `main` versions of the `spatialdata` library, and detected differences are reported here; # TODO add link -- also, detected differences between the previous release version are reported here. # TODO add link +- this directory contains notebooks that operate on small datasets; each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks; +- all the notebooks are run every 24h. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it; +- also, the disk storage is committed to GitHub so that the output of each daily run is associated to a commit; +- the notebooks are tested daily against both the latest `release` and the latest `main` versions of the `spatialdata` library; the corresponding produced data is available in the `data` directory of this repository and at this S3 location # TODO add link ## How to use this repository Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is then guaranteed to run correctly on any SpatialData dataset. + +We recommend to: +- implement your readers on the latest `release` version of the data; +- set up an automated test (e.g. daily) that downloads the latest `release`, (optionally also `main`) version of the data and runs your reader on it; +- if your reader fails, you can check the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, to compare the current release with the latest release you can use the following command (run from the current folder): +```bash +git diff \ + $(git rev-list -n 1 $(git describe --tags --abbrev=0)) \ + $(git rev-list -n 1 main) -- data +``` # TODO: test the command From d8c5abbc06d1aa3d8ad81788532c2b957cd8a706 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 14:30:00 +0200 Subject: [PATCH 03/25] update readme --- .../storage_format/Readme.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index ba66519..f31fd0e 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -1,20 +1,20 @@ # Examples covering the whole storage specification -This repository offers comprehensive resources for developers that want to interface their methods with the SpatialData format in a robust way. +This directory offers comprehensive resources for developers that want to interface their methods with the SpatialData format in a robust way. ## Why this repository -The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses some less-documented features of the OME-NGFF specification that are still under review, or experimental storage strategies that will be eventually discussed with the NGFF community. +The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses *some* less-documented features of the OME-NGFF specification that are still [under review](https://github.com/ome/ngff/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc), or experimental storage strategies that will be eventually discussed with the NGFF community. This repository addresses the need for communicating the storage specification to other developers in a complete and robust way. ## What this repository contains -In particular: -- this directory contains notebooks that operate on small datasets; each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks; -- all the notebooks are run every 24h. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it; -- also, the disk storage is committed to GitHub so that the output of each daily run is associated to a commit; -- the notebooks are tested daily against both the latest `release` and the latest `main` versions of the `spatialdata` library; the corresponding produced data is available in the `data` directory of this repository and at this S3 location # TODO add link +This directory contains notebooks that operate on lightweight datasets. +- Each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks. +- All the notebooks are run every 24h. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. +- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit. +- The notebooks are run daily against both the latest `release` and the latest `main` versions of the `spatialdata` library; the corresponding produced data is available in the `data` directory of this repository and at this S3 location. # TODO add link ## How to use this repository -Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is then guaranteed to run correctly on any SpatialData dataset. +Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is guaranteed to run correctly on any SpatialData dataset. We recommend to: - implement your readers on the latest `release` version of the data; From 1850c77b3a957536a775e7944e15e0695451d8de Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 14:48:38 +0200 Subject: [PATCH 04/25] improved readme --- .../storage_format/Readme.md | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index f31fd0e..e30dd31 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -11,17 +11,24 @@ This directory contains notebooks that operate on lightweight datasets. - Each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks. - All the notebooks are run every 24h. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. - The disk storage is committed to GitHub so that the output of each daily run is associated to a commit. -- The notebooks are run daily against both the latest `release` and the latest `main` versions of the `spatialdata` library; the corresponding produced data is available in the `data` directory of this repository and at this S3 location. # TODO add link +- The notebooks are run daily against both the latest `release` and the latest `main` versions of the `spatialdata` library. +- The corresponding produced data is available in the current directory, in different commits. Specifically, `release` data is tagged and both `release` and `main` data have the commit message `autorun: storage format`). +- The data is also uploaded at these two S3 location (latest) [release](https://s3.embl.de/spatialdata/developers_resources/storage_format/release) and (latest) [main](https://s3.embl.de/spatialdata/developers_resources/storage_format/main). ## How to use this repository Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is guaranteed to run correctly on any SpatialData dataset. -We recommend to: -- implement your readers on the latest `release` version of the data; -- set up an automated test (e.g. daily) that downloads the latest `release`, (optionally also `main`) version of the data and runs your reader on it; -- if your reader fails, you can check the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, to compare the current release with the latest release you can use the following command (run from the current folder): +We recommend the following. +- Implement your readers on the latest `release` version of the data; you can checkout it with the following command (run from the current folder): +```bash +git checkout $(git describe --tags --abbrev=0) +# TODO: test the command +``` +- Set up an automated test (e.g. daily) that downloads the latest `release` (with the above command) and runs your reader on it. Optionally you can also run your tool against the latest `main` version of the data (`git checkout`) +- If your reader fails, you can check the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, to compare the current release with the latest release you can use the following command (run from the current folder): ```bash git diff \ $(git rev-list -n 1 $(git describe --tags --abbrev=0)) \ $(git rev-list -n 1 main) -- data -``` # TODO: test the command +# TODO: test the command +``` From b75745c46efe6fdd891c238c2cb4bc9d21c24c65 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 16:55:13 +0200 Subject: [PATCH 05/25] added multiple elems and some transformations --- .../storage_format/__template__.ipynb | 121 ++++ .../storage_format/io_utils.py | 57 ++ .../storage_format/multiple_elements.ipynb | 550 ++++++++++++++++++ .../transformation_affine.ipynb | 227 ++++++++ .../transformation_identity.ipynb | 173 ++++++ .../storage_format/transformation_scale.ipynb | 240 ++++++++ .../transformation_translation.ipynb | 255 ++++++++ 7 files changed, 1623 insertions(+) create mode 100644 notebooks/developers_resources/storage_format/__template__.ipynb create mode 100644 notebooks/developers_resources/storage_format/io_utils.py create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.ipynb create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.ipynb create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.ipynb create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.ipynb create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.ipynb diff --git a/notebooks/developers_resources/storage_format/__template__.ipynb b/notebooks/developers_resources/storage_format/__template__.ipynb new file mode 100644 index 0000000..6e74e0e --- /dev/null +++ b/notebooks/developers_resources/storage_format/__template__.ipynb @@ -0,0 +1,121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "\n", + "\n", + "Elements contained:\n", + "- \n", + "- \n", + "\n", + "Annotations contained:\n", + "- \n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = 'name_of_the_notebook'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "332c9c62-7451-4d8e-ba9e-13c12131c312", + "metadata": {}, + "outputs": [], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = \n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py new file mode 100644 index 0000000..3e8929c --- /dev/null +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -0,0 +1,57 @@ +from spatialdata._io._utils import _are_directories_identical +import spatialdata as sd +import os +import zarr +from ome_zarr.io import parse_url +import tempfile + +def delete_old_data(name: str) -> None: + f1 = f'{name}.zarr' + if os.path.isdir(f1): + store = parse_url(f1, mode="w").store + root = zarr.group(store=store, overwrite=True) + store.close() + os.remove(os.path.join(f1, '.zgroup')) + os.rmdir(f1) + """ + Safely delete an old Zarr store, it if exists. + + name : str + The name of the file (without extension) to write to and read from. + """ + +def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: + """ + Write SpatialData instance to file, reload it, and check for consistency. + + This function writes the input `sdata` to a file using the specified `name`.zarr. + The data is then reloaded from the file and written again, and the two outputs + folders are compared recursively and binary wise, to check for the consistency + of the read-write operations. + + Parameters + ---------- + sdata : sd.SpatialData + The SpatialData instance to be written to a file. + name : str + The name of the file to write to and read from. + + Returns + ------- + None + + Examples + -------- + >>> sdata = sd.SpatialData() # assume SpatialData instance is created + >>> write_sdata_and_check_consistency(sdata, 'testfile') # will create testfile.zarr + """ + + f1 = f'{name}.zarr' + assert not os.path.exists(f1) + sdata.write(f1) + + with tempfile.TemporaryDirectory() as tmpdir: + sdata2 = sd.read_zarr(f1) + f2 = os.path.join(tmpdir, f'{name}2.zarr') + sdata2.write(f2) + assert _are_directories_identical(f1, f2) \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb new file mode 100644 index 0000000..78a3017 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -0,0 +1,550 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "The data created by this notebook is for testing an object containing multiple diverse spatial elements.\n", + "\n", + "Elements contained:\n", + "- 2D single-scale image (cyx);\n", + "- 2D multi-scale image (cyx);\n", + "- 2D single-scale labels (yx);\n", + "- 2D multi-scale labels (yx);\n", + "- 2D points;\n", + "- circles;\n", + "- polygons;\n", + "- multipolygons.\n", + "\n", + "Annotations contained:\n", + "- table annotating the 2D labels.\n", + "\n", + "Note, this object is not meant to contain everything, example of features that are not covered by this notebook are:\n", + "- multiple transformations (transformation here are all `Identity()`);\n", + "- 3D images, labels, points\n", + "- channel names for images\n", + "- table annotating multiple elements\n", + "- elements containing annotation columns" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6c3ef5f8-a334-4bb4-906c-db3d8e50e571", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = 'multiple_elements'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b7f6b9fe-c7dd-4177-a533-941a42984ff4", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + }, + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ ├── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", + "│ └── 'blobs_multiscale_image': MultiscaleSpatialImage[cyx] (3, 512, 512), (3, 256, 256), (3, 128, 128)\n", + "├── Labels\n", + "│ ├── 'blobs_labels': SpatialImage[yx] (512, 512)\n", + "│ └── 'blobs_multiscale_labels': MultiscaleSpatialImage[yx] (512, 512), (256, 256), (128, 128)\n", + "├── Points\n", + "│ └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "├── Shapes\n", + "│ ├── 'blobs_circles': GeoDataFrame shape: (5, 2) (2D shapes)\n", + "│ ├── 'blobs_multipolygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", + "│ └── 'blobs_polygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", + "└── Table\n", + " └── AnnData object with n_obs × n_vars = 26 × 3\n", + " obs: 'instance_id', 'region'\n", + " uns: 'spatialdata_attrs': AnnData (26, 3)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_multiscale_image (Images), blobs_labels (Labels), blobs_multiscale_labels (Labels), blobs_points (Points), blobs_circles (Shapes), blobs_multipolygons (Shapes), blobs_polygons (Shapes)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs()\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2952c64-5502-4462-9be0-a32fdb61158c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "no parent found for : None\n", + "no parent found for : None\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", + " \u001b[35m/tmp/tmpgoqskqgb/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "no parent found for : None\n", + "no parent found for : None\n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "176f3917-21c2-421c-bf16-3455fafd7500", + "metadata": {}, + "source": [ + "## Single scale images, single scale labels, points" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "621f1331-c83e-4635-b8a1-9a0f6011ba83", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images('blobs_image').pl.render_labels('blobs_labels').pl.render_points('blobs_points', na_color='w').pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f5be69e1-94fb-43b3-9709-ab90f0d2629c", + "metadata": {}, + "source": [ + "## Lables annoted by the table (var)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a0afa793-0cca-42a3-9f0e-dabd8775a147", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
instance_idregion
11blobs_labels
22blobs_labels
33blobs_labels
44blobs_labels
55blobs_labels
66blobs_labels
88blobs_labels
99blobs_labels
1010blobs_labels
1111blobs_labels
1212blobs_labels
1313blobs_labels
1515blobs_labels
1616blobs_labels
1717blobs_labels
1818blobs_labels
1919blobs_labels
2020blobs_labels
2222blobs_labels
2323blobs_labels
2424blobs_labels
2525blobs_labels
2626blobs_labels
2727blobs_labels
2929blobs_labels
3030blobs_labels
\n", + "" + ], + "text/plain": [ + " instance_id region\n", + "1 1 blobs_labels\n", + "2 2 blobs_labels\n", + "3 3 blobs_labels\n", + "4 4 blobs_labels\n", + "5 5 blobs_labels\n", + "6 6 blobs_labels\n", + "8 8 blobs_labels\n", + "9 9 blobs_labels\n", + "10 10 blobs_labels\n", + "11 11 blobs_labels\n", + "12 12 blobs_labels\n", + "13 13 blobs_labels\n", + "15 15 blobs_labels\n", + "16 16 blobs_labels\n", + "17 17 blobs_labels\n", + "18 18 blobs_labels\n", + "19 19 blobs_labels\n", + "20 20 blobs_labels\n", + "22 22 blobs_labels\n", + "23 23 blobs_labels\n", + "24 24 blobs_labels\n", + "25 25 blobs_labels\n", + "26 26 blobs_labels\n", + "27 27 blobs_labels\n", + "29 29 blobs_labels\n", + "30 30 blobs_labels" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdata.table.obs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0256ddc3-edb0-4293-b478-2bd16d20d6d6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['channel_0_sum', 'channel_1_sum', 'channel_2_sum'], dtype='object')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdata.table.var_names" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a37e947b-f9b9-462a-af04-a8c23a3293d5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_labels('blobs_labels', color='channel_0_sum').pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0b3ff656-7198-43c2-a501-fc4dd6c6cdb8", + "metadata": {}, + "source": [ + "## Shapes: circles, polygons, multipolygons" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "75166a2b-00f5-4cca-9d63-108f93036dff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes('blobs_circles', fill_alpha=0.5).pl.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2a14b388-ca41-4d98-8199-f18cec3473b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes('blobs_polygons').pl.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a91e99b8-30e7-4b14-a010-b2e8ef8c255f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_shapes('blobs_multipolygons').pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.ipynb b/notebooks/developers_resources/storage_format/transformation_affine.ipynb new file mode 100644 index 0000000..b254048 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with an affine transformation to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = 'transformation_affine'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "import numpy as np\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs()\n", + "sdata = sd.SpatialData(images={'blobs_image': sdata['blobs_image']}, points={'blobs_points': sdata['blobs_points']})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "matrix = np.array([[1, 2, 3], [4, 5, 6], [0, 0, 1]])\n", + "affine = sd.transformations.Affine(matrix=matrix, input_axes=('x', 'y'), output_axes=('x', 'y'))\n", + "sd.transformations.set_transformation(element=sdata['blobs_image'], transformation=affine, to_coordinate_system='global')\n", + "sd.transformations.set_transformation(element=sdata['blobs_points'], transformation=affine, to_coordinate_system='global')\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_affine.zarr to \n", + " \u001b[35m/tmp/tmpvrsmf4sn/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" + ] + }, + { + "attachments": { + "cf537745-91e4-4390-8c4b-30a9b5be17fc.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "b762fac6-00c0-4e19-86dd-b6dee89eea3e", + "metadata": {}, + "source": [ + "Note: the above plot is wrong ([issue](https://github.com/scverse/spatialdata-plot/issues/103)). The correct plot should be the following one, made with `napari_spatialdata`.\n", + "\n", + "![image.png](attachment:cf537745-91e4-4390-8c4b-30a9b5be17fc.png)" + ] + }, + { + "cell_type": "raw", + "id": "d7c6bdc6-7766-40a1-a46c-60266b4b14cf", + "metadata": {}, + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.ipynb b/notebooks/developers_resources/storage_format/transformation_identity.ipynb new file mode 100644 index 0000000..a7d430e --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.ipynb @@ -0,0 +1,173 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with an identity transformation to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = 'transformation_identity'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "332c9c62-7451-4d8e-ba9e-13c12131c312", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + }, + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs()\n", + "sdata = sd.SpatialData(images={'blobs_image': sdata['blobs_image']}, points={'blobs_points': sdata['blobs_points']})\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_identity.zarr to \n", + " \u001b[35m/tmp/tmpm0ue_qgu/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "af8d7108-8b7c-461e-871e-77d82de82af6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAHrCAYAAAD1z1UvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9edxtSVUejj+rap/3vd3NIDTaTRuaQVFBRGQQgSAaAUVEBQf8EYMYSBCCiogRgl8mERDUaGQSARGNCkbFIEQlEtCEODWooIhCEBBoGwHp6d73nF1r/f5YQ63a57y3uxHT3PSp+6m79xneffZQtZ71rKlIRAT7tm/7tm/7tm/79inTyrV9Avu2b/u2b/u2b/s2tj0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvu3bvu3bvn2KtT0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvu3bvu3bvn2KtT0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvv0/2m5xi1vgYQ972DX+u7/5m78BEeFHfuRHPmnn4sd8+ctf/kk75r7t2//LbQ/O+7Zv+7Zv+7Zvn2JtD877tm/7tm/7tm+fYm0Pzvu2b2dg+/Vf/3Xc/va3x+HhIW51q1vhJ37iJ/DUpz4VRHTav3vf+96Hb/3Wb8VnfMZn4PDwELe5zW3woz/6o2Dmre8yM37oh34IF154IU6cOIE73/nO+J3f+Z3hO+9617vw7d/+7bj1rW+Ns88+G5/5mZ+JBzzgAXjb2972Sb3efdu361qbru0T2Ld927dr1n7zN38TD3rQg/ClX/qleOUrX4l5nvEjP/Ij+Lu/+7vT/t2HP/xh3P3ud8d6vcYP/uAP4ha3uAV+4zd+A49//OPx7ne/Gy94wQuG7z/vec/DzW9+c/z4j/84mBnPec5zcL/73Q9vetObcLe73Q0A8MEPfhDnnnsunv3sZ+PTP/3T8dGPfhQ/+7M/i7ve9a5461vfis/93M/9J7sP+7Zv/0832bd927czqt3lLneRm93sZnJ0dBTvXXbZZXLuuedKntI3v/nN5du+7dvi9ROe8AQBIH/wB38wHO9Rj3qUEJG8853vFBGR97znPQJALrjgAjl58mR879JLL5Ub3/jGcu973/vYc5vnWdbrtdz61reW7/me74n3/Zg/8zM/84le9r7t23Wq7c3a+7ZvZ1C74oor8Md//Mf4+q//ehwcHMT717ve9fCABzzgtH/7hje8Abe97W3xxV/8xcP7D3vYwyAieMMb3jC8/6AHPQgnTpyI19e//vXxgAc8AL/7u7+L1hoAYJ5nPPOZz8Rtb3tbHBwcYJomHBwc4K//+q/xjne84x97ufu2b9fZtjdr79u+nUHtYx/7GEQE55133tZnu97L7SMf+QhucYtbbL1/wQUXxOe5nX/++VvfPf/887Fer3H55Zfjhje8IR73uMfh+c9/Pr7/+78f97rXvXCjG90IpRQ84hGPwMmTJ6/Ble3bvu1bbntw3rd9O4PajW50IxDRTv/yxRdffNq/Pffcc/GhD31o6/0PfvCDAICb3OQmV3m8iy++GAcHB7je9a4HAPj5n/95PPShD8Uzn/nM4Xt///d/j0/7tE877fns277t2/Ftb9bet307g9o555yDO9/5znj1q1+N9Xod719++eX4jd/4jdP+7Vd8xVfgL/7iL/CWt7xleP8Vr3gFiAhf/uVfPrz/q7/6qzh16lS8vuyyy/Ca17wG97znPVFrBQAQEQ4PD4e/e+1rX4sPfOADn9D17du+7Zu2PXPet307w9rTn/503P/+98dXfuVX4ru/+7vRWsNzn/tcXO9618NHP/rRY//ue77ne/CKV7wC97///fH0pz8dN7/5zfHa174WL3jBC/CoRz0Kn/M5nzN8v9aK+9znPnjc4x4HZsYP//AP49JLL8XTnva0+M7XfM3X4OUvfzk+7/M+D7e//e1x0UUX4bnPfS7+2T/7Z/9k179v+3ZdaHtw3rd9O8PaV33VV+FXfuVX8OQnPxkPfvCDcf755+PRj340PvjBD+Lnfu7njv27T//0T8eb3/xmPPGJT8QTn/hEXHrppbjVrW6F5zznOXjc4x639f3HPOYxOHXqFL7ru74Ll1xyCT7/8z8fr33ta3GPe9wjvvMTP/ETWK1WeNaznoXLL78cd7zjHfGrv/qr+IEf+IF/kmvft327rjQSEbm2T2Lf9m3f/nFts9ngDne4Az7zMz8Tv/3bv31tn86+7du+/SPbnjnv276dge3hD3847nOf++CmN70pLr74YrzoRS/CO97xDvzET/zEtX1q+7Zv+/ZJaHtw3rd9OwPbZZddhsc//vH48Ic/jNVqhTve8Y543eteh3vf+97X9qnt277t2yeh7c3a+7Zv+7Zv+7Zvn2LtWk2lesELXoBb3vKWOHHiBO50pzvh937v967N09m3fdu3fdu3ffuUaNcaOL/yla/EYx/7WDzpSU/CW9/6VtzznvfE/e53P7zvfe+7tk5p3/Zt3/Zt3/btU6Jda2btu971rrjjHe+IF77whfHebW5zG3z91389nvWsZ10bp7Rv+7Zv+7Zv+/Yp0a6VgLD1eo2LLroIT3jCE4b373vf++LNb37z1vePjo5wdHQUr5kZH/3oR3Huuede5fq1+7Zv+7Zv+7Zv11YTEVx22WW44IILUMrVN1ZfK+D893//92itbRXqP++883bW833Ws541VCXat33bt33bt307k9r73//+a1Q571pNpVqyXhHZyYSf+MQnDhWMPv7xj+PCCy/E+3E93AAFQIW6zyfrBwBWAA6tnwXBCTScjZM4GydxDq7A2bgSZ+MKXA+X4WxcjrNxBU7gMpyFy3GAK3CAy7HClag4CeBKAKfQcBIzjrDBGmsc4SRmnMIGV2KDKzHjCjCuQMOVsRVcCcZJCE6BcQrAEQQbCNYA1hDMAFrqbF0WfbhTAPJ9orRNnUjvCxFARXux16UAtQCl6rYWYKrAqgAr6vuH9vqgAIdk+9Rv8cpvuwAkQGGA7BqEAbY+MzA3YGPbNQPrBmzE9hnYMGhm0EZAGwY1Ac0CaoLSBIWBatsCwcRAFWAl+vOT7a8W+yv0zyfo3xQARezO2e1l0TvvT2JOfWM9728W39n1FI97mvmJ7vQr0Y5e7HFWHfJUAJqsr7SXA6Ae9m09BKYTwCr1gwPg8BA4OAROTMDBCjgxEQ4L4QQRToBwIIRDLljNBatNRZ0r6lFFOZpA6xXk1Ap8tEI7OsR86hCb9SHWRyewXp/A0eYsHG1O4Gg+G6faCZzis3DEJ3BKDrHGAY7oAGtaYaYJm0LYEDBXgKug1RmtbMB1DS5rSDkFKUeQchJCpwBcCcEpACcBOQXwKYCPQHyk27YB2gbUZtA8A8ygudlYYqAB1AASAjUCuIC4ADwBMoF4BcgBIIcQnADkhMoPORvAORBcLzpwPQhuoK/pehBcH6CzIXQ2hM4CyiGkHABlBdQKqUVF1cTAqgEHG+BgDRweASdOaT/rJHD2SeDsK4BzrgTO0X263pXAWVeCzr4SdNZJ0ImToMNTKKuToNUpFDrSLmsUPkKZNyjrDep6Rj25QT05o17JKFc2lCsa6hWMciWjXCGgKxnlSgGdFOCkAEcAjgSyBmQN8AbgGeAGtKZbZqAx0ETnTbMucvpxv2t4ZwleTZysUj8ART+BEttDqjhExSFVHJQVDmiFVTlELQeY6gmUehaonA2szoGszkFb3QDt4AaYD2+AzeENsT7rBlif9Wk4OvsGWJ/9aTh1zvVx6pzrYX3OWTh1PcL6HETfnA1szgI2J4D5BNAOtPNKx6zUk+B6CkInIXQEoTWE1gAYctllwGd/Pa5//evvmunHtmsFnG9yk5ug1rrFki+55JKdy94dHh5uFdcHgBuAcIMtYCoYJJk9dkHFBhUVEwoqyIYAY4UW20PMOMAc2wkNFTMIKwhmMFaoaChoACYwGA3V/l5sOAkmiP0OYwLZORQUSJxfPkcGQJBhyJ6uLT/Pf7MA5SU4k0n3AOtqfbHvYF0LMDlgO1BDATpmkCji1V3gbDO6sikDDSgU1ww0UJq5BICEQVLsjlgnBWkiPXxhPUxloIigpFOox4BznCbZqZLqE7CfFzJBA+0Fi8+tL4HXn+JSEJ3uaRJ2gPJS3zqmk2/z4/Q+QYF76mBdDgA6AOgQKN5PAPWAUA6AaQKmibAqhKkQJhBWTJiYsJoJq4kwbQiVCEQFRASRApaKEuBWIW0C84QmE5qsMGOFigNUOkChA1Q5RMEhKh2g0oRGE6gUlEooVcCFgVpBtYJqAcWDEkPUpheFGcAESAW46u+3AuIKzA1U9BxBRZU7IR1DQn2WNAIVAol9rxDApINCig4G0fkjJkckus5v4ACCFQQHEDq07QkQnQWhs3QfBxAyDZaKTXsdwEIboGz6Q6oroE56Dyabf1MFVgSaCLRS5ZhWpM/zAKCV6LOuKkGKCAqLzg0IqgjqzKgzUFcz6iSok6Doz6BU1mdQGFSg129aq98CJgH77QHQSLvfTJ8joA7IJF2y7WrHDW+fSwRKrwkFhGqSdCLdn0jH6kQFKxSsqGBF+rraPyo6GZhWqLRCKyuQaa5SToDrWWj1bLR6FqZ6DqbpemjTOagToawQnVZ6v4spvnyor7ES0LSB1AlU7EEUUy9oBaABR03vyTV0wV4r4HxwcIA73elOeP3rX48HPvCB8f7rX/96fN3Xfd01ONIuRrnsKkIFjAZGS//0ndlgdzZG6zocxd/rQBEQGIQZhDUKNiBsUDDbe95b6hxb2Xluu1jxNW1XR6KXHT3rqkm6L9+HIUCAvKND/glJPYEzWvqbtuPU/G9gAsG/W0yASUc/sW08C1I1HQCEQCLDLaXFLd5lW3AEzeyZEmDn16cD2atSp5ZAfFWvj/2hq2o7LjIwJr9O2CNKHnsnU06KsaFkbJECFDc3kIBJVFADaCTRGb5lMGkX0jkoSK8L67kUghQxBW7RC0Mqd40sPVSSPn700kWHsECHtAioiGIiGzayjMOYTPGLuFiXGfobArb5q3Na0CCYY7ttS1GrGNn8EagCoIBV9DkLAGkgCCSPW/aHUYFW1ZwwV9A8ARvttJmAaQLVSQmGTKBmCg11ZYXmAloX0JFuy5pR1oSysT7DOqE0ATHZ1NU5J9J73BY/Vf8MfbtL6gjGsZ3fW7bFzwzv71KMl0qyP5kSQyKNEdH73ITRmMG5twZuvm3gWbtsJshGLQfi1sFqc8ZPzs1sabxKloMuiI4+MRl/rZm1H/e4x+Ff/at/hTvf+c64293uhhe/+MV43/veh+/4ju+4hkdagtzxwDwP0KyAzNiAsQlgFhRjsAKgmb42grMC8xoFaxDWIANqB2gYSGcDJ8W5SAycPng/UZDeBTlXBdAJjLHs0/i507IlQLs0zCiXgZl81Ga27hLxmNNyVbug0+KiqjoNtydNefEtAqB9bvjjz8C5BFLXD/xyQhAlQM53ededPt2TWQqpfAVIn+XfuKpRQLtOBth5kQMoLwGZAC4CLtRBuaCDrVhngEjZqz8SvzlsYDxH53jdwB2sDaDZLE1CDUwFQg1SBGJsTZxR1gapam2R6maSPrYoo0dRiwpIOkD7OChjLwHQaSgGQNtW+uARm79ic7kDsyryjA2ANRDbNdQmPKmSL1WtDPFkiwJ0oBuDRCCMBMxqBVBg7qCMzUr7egVyKicziDegaQKKgjXJDOKKMleUTUU5aihHCtLFQXpDqAbSdRaURmqVakhGL4KwQPUflX/IoIy+z+OwO3bsHwfMu5oMknIbjLtkF3syOl4L2V+JWhHI7rMIg4XRhDEzY24NzTrPs4LyZoZsZvCmgTcT5AiQybrNH78QYUBmUbfc1EKRhCmeIYSIgSuPsx+cvl1r4PzgBz8YH/nIR/D0pz8dH/rQh3C7290Or3vd63Dzm9/8Ghzl6uhYKhJmNOt9r9kEY6zBBsx9+LABbEE3sbAx5U0AczFwLtbZ2LRr2p05qyaV95d64haDOu0nu6DDXy+R7zhgntI220OXoG1/G2ZydJTYxZopeV9pXoCz9QzKJvzJHcEBzEUHvV9ZXJqkmZ9YM1NIDBL7flJg8y1f6hZC46H9+L6fwXrXU1je+eV3dj29JbNYHm/rb2j3/q6h4MCcAVlZau8DWy4OzjpyZzFjhj0nIaAWY5kEiJk6206AdmBmMLUOzmQARw1CBLHn7eejYDwDtWmfbFvaAM5dOor6IczlARPnJB2gFZCNPRdJAO0M2p1Jrs3ZsV1+UIOInbN0YBYDZLHOAcxOs/TGSRxbIJKsciIWjyH9J5s+CJor0CYF57mDMuqB0l0yAsCzfj7NoNKUHMgE4qZ+9o2x5lMF5Yi0rwnVepkJdSaUWUBzB2g0AgyY2af1gj9kKRsuHeljOg/Jq0s7lhJ8KcnzfiiQrkwaSDswCxyc1b0mxpQbMxo3NG4G0LOC9DxrX8/g1QYyTeBawTUptn6NfgIrQKamCmRtqly6huNaDglw5SdCvK7lgLBHP/rRePSjH/2POMLxj1ISMG/Qos/2T1+t0TAZMDtr9uOqV5kMnHVKKdh2k/YpA+gj7GLQo4nbtfB+rmT64fY1XFU7HSCfBpQHhrwE5l09g/mCOTtiAbYdpg16SFU1gM7gfJpTLZJOm/usGBDVjiEJpAPpXPCl9zJA8zEgK6NmHPqHP44E1ksQPg6Q059tfS7HfHYcUO88+PKHjumnNWMXtaAqOAsaEWYIipAKN3sWDuJdgZJgzo0YGwPmGaxbapipoUWfwajaaTZTNsClAIUgVVTITQ2oMzA1yDQncDaAztxJWEG2qRCM+AQByHyvVCUAuhhAEwOFyIaRKxwG8tIFq4AB2c2Ye0DnGowjFIs14Zg3Poh9+AoIE0SqmrlD0utYJSYIF1BbAvMMrA9AddZ7kIG5zaBpBtWm4EyzMufWQG1W5rxW9lxPKUjXI2XPdW1AHWZuB2goMBt7Jk7WKLsYEQ0FEHRgPo4971JAl20p9Y4D5RbbzpZVwuiTKX5yJBBhFLNMdObcMAcwzwrM84x5s0GbNmjrDXjagI824LqC1AIppEYN1wcbIDPM3C3ANAN1VktP6cAs2bV3xRnGnD95bQnMJYC5JWBeo2GDGRvM9v9kAV9rNBQwsrHZfcsdnAlizLmhYEYx1lxwCgVH6bVO3g7SI3umwZ+lQ/LqaZfH8bbT9V0AvQTg1THbDN51cawlnAgG1kweuzwDtEH3Vy/M234o92Oa0EeFCS7S6C2CqsiUvs9kYGvfY38fFuSjx3ATZgB0HjLc76IAg4k7g/KSTV/VE9oFzFcFurLjs+N+Ko6/gzEPoEydQSOz5gTQLW1bAWbqOhIJgtlyEbTSgUxI1CxOjLkoMG+iN2PQDtAzWpnQxECazJReGFIKpCo4K3NWUBYTephM6FUPCFPFzxkR2IB5AGfzPbJF9lcHZDXNa7KCjw2yv2VVwQfm3GEgM2bCGoIVCEdgmy9iSr4GgZb0IPrT1Pk/QUymiI9fM2tTM01pNjP21EC1Ww+ITJZIU2CeZ2XNdQYVA22ZQdxQ5gk0N5R1QzmqKEeMeooVoE8V1LWgrgVlo7eZzPecvXHCdnoCNFd6pTNkn64iC5B2nX0xB3aN6eVnp2PO7vlnY8wOyDWUZh2XCsQqrztzbsacFZg31ud5Rps3aJsNWt2g1TVaWel4pQLGZGyZzJQNyEYgB1Bg9nHqTvw0Rk3TgVzRjpnJp29nODiPzNP39SE6ODtAz9Y32GDCHFHXxSDTYdN9TApKhJpgqYNzNdO2AvNRADQFQM9m3t4G6BxwstQbr74ZaBd3K2m7izUvQXlXXwJ0YtCnA2c0xOgl12k3+ncO0GESX3bpiBCnLQmxzBbJ3GdqEYiDcjBlCq0fBQCTTlZX67mT8LDHcf8Z/0yWkmTJoNNnuwA5P5Hj2PFxjHr5neGgu9pVMecEyLtY8wDMJdz8xjj0BZOgkn7mJmJxX3LRuebgPNM2c55pthiPosBs5yFFFJgzc67GnOumC78yD+Ds8RtgBjGDyLqp2EWkA7NvE3MuBShM6p90UCcBEWMwaS/8zEwzRFTxVjP2CsARiDpjVoAuCaB9qCRLmSxtpViYMSZNPdxwDzYKd5HRtzZrZLrdL6I5mHNpM6hNKPOszHndfc/1FKGaibsey5yNIbIHivX5JZBheroks6l07DDcJdPyPLg6wDyG5nXbXEkyVMQURwNmMgVOSgOzseUyY24z5nmDuW4wb3Tb6hqtrsFlBS4TmIr+ttTOmjdQP/PRDFltIHWjrpgAZ3c7JIC+8joIzrPBqAOzxYKC0SOzuwF7xhobbFCxwdo8wwWeFuXA3B/5ChoMVhLccfxFMXCuWKMZOBOOkt95MwCz+7BdBXBFYtu0vWy7hvaSKvn2qgB6CcwHO/Z9m0BaEsAPUUZ2ziI6cn1ASgJmbFQQgTrVC9O2dPXbhDVVP57oKTjrZYYwdWngoCz5PWXUwUbIf0tGEPadHQBtw2mwpgsQsWe7HssSO7eJ7PjHO4VV+qPTgfbycfslwrfH9Myas8+57QBnSvdGSDCZybuUHjjl0dpsPuaZTBEmcx/RHL1R1VlIpggb4HOpkFLApvdJYs6YNtqrUbtghybwpCkwZ3CWDMzWmwQwlxTUpiw6AXQwbwNCaVBXV4PQDBEPHp2gLqwpOi9iORjFWLjnFewAaVGrXCiYTNAobfRoPA84UjOAnRcDrYHmGbRpatYuG4DMlSYbEE/GnCeUzYyyKShHY69m2v7Bp/wS7vIl98VrfumFeOmzvl99965nJ7O2iycRUgBEly7OlgkjSC+H7dUhHdugvO0wc0B2JTKCwBwHRFPISiBqg7D2xjMaKzhv5g02dY25WKc1Gh2hkabQshCYBcwr8FzAM0HWAlk1yMrGaF0DZQ2UDaTMkABn3QoacPI6aNY+gpb06I+lA3RPlHLWXBNAF+O1HS5H1qzgQqYFZ+asuvFs7HmNFubsbNpem2nbo7c9DcN1Px4GE3BNGbNvT0OXdgJzhUYxLME4dfFu3xMD9ND2swPTgbRPAgXmuf/eEASz5I8IQd9BWrpZ24BAhYTTLR5VdnYGrd8TUYCW5n4zFTLSFGiE+iEE6CCU3pN0egMo7wLo+NJuW0b/2jbcjoeW8WcWXx/GBg0b3d/WCOKWL4PCPGfVeyNgLoJSCDOlcxeNpOYANffNst1L1hkTvuam4EwzNpjUhRTgXHQW2G9qGlUFl6JDqtp7ZsZVRpIBemOsROcnIVXDIJ1PHgg2AHM1q7gBdB0A2pQRMn8lMYhsMBBDRH+Lzavp4MyoaFa/gGh0/wgpMBdTRGjH/Ix6BgKL3s4PBN0jZDnelGsHcAM1Y85uYSjOmjcgWYF4Vp/zXEFz7ex53VDX6nd23/Pd/vn9QUT46m98BF7+jO/XwizGVjj8zTrXJfRoitoC2dh1OomUFc7jWPTpWHNTdcdCdJX2lH4n4UFgDMZEGpVdQgAswLnNmMsGc9lgs9lgQ2vM5QgzHWCmSeOQpKiOz2oSl7lCZoKsRIPApgaZ1pC6hpQNpGwA0i4JnAEGTs07rviq2xkOzoJTAzhzmKg7cy6W/DSHIVp5bQ7bcsbtuYsb04o9jSpHa2e/82YAZO+e/8wLk7bnO3e2vLttA/UuPfSaAPMO5ixWQU0O+lYO0YHav2MAHfkESbp7OCer0Oga40ZZxBLMvTnjprTNAC2ixRcaMFQzEAakQITV+mhfRVgjDZhZQcVNcwrMgDQzcyPczQNLdKt5xn4n55FCQsoejn08Mj6N5cdZUOXtyK97Mt9OtM/HowTMi/1lHwB6YdYu5m92owaKPV6CmbQlgAwGzBIR2W7GNmXYAHqmqs4kKn0WkPqamSZjzpTynMWiXhPw1MSeSzIZigVBNZtbZsIkFgsSc8YsqEVQSRmWX0s11qwzZcGcQQAahJSfKWv2YLYNmlQQ1miUlF7qxY5AnT2T5XEJjfDlUSz6uO3BuOXHAVIpYp8nuajPPHeLAm1AtFJglpWmVzXNj6Z5Ajl7Xnt3s3bBn/zhm3D7O98Tb/qvr0SdyW6vzhkl6xQKcJUewV3SFWTJwzvG/+maLPYzMPu094JAfktMZ7exPkr/yZhziTGhSpxQg7hZmzZotMFMDsxrzHSEhlWw5iak1c88F3pTwRsCTwKZWOMi6mzM+UjZM61V9sFA2usGXhfB+SS0Vs82c+7seQ6AniNMS+HTSy6qzyyDs6QgKEKx/8W6gnNNsF/NcD76nK8+QG+Dsbddn5wOqI8zaS9AmYwxBzB7mVPbl8SgeQUtbagFDiJsN8zHvADnDaJMFWoCc3RTdJ6GnoJVfNbb07QZSDx+XQygvbCACo7EklvaFoE0UhNq81OwnM3l3WTTN/w0t7YUYG2kZ3g0wZEoCQ/7zINlvI9Moqtp/TP9hAjHjxF75IHFvr/UChbDYyvXmQRMymi12IhqIaqIUERkF+s5dS6KjECZc4MC8sa2MxUFZjHHDqHnPZcGoWopVWT5zgLx4C8DZ6nrDtCD+bZpyhA6OBdmlOLdgJkMmIsqGdUAupqyUU3h6DyX7cZ7Bm0JScJmOyNSCZBjMXIVMX9NVI3vWW0r6gqzfq+rZSIl0UX3NRDclEEWqKbBYGbWrhszaR/AC6AQq1mbmhYnKXMFbbQXT61yoN4wnvxvHoi6aSgbjnxnn69sCq+bstnynT1Y0AF6mWZ43H5usuPzDMwEZcz2RFRPR2bpKQs6/MwdmAuNzBmsMQNMM1rboJGasWdSxryBVrSbMWGWgsaExtLzoFcVsiHIpLERYlkFUtSsHeU6vWODMMQfbY65C6dvZzQ4nwJ2gHNmzy1gcUZPdNoYOCtASwB0r/qjEygz5xGcOQzjPe/Zu6dULdOpuvHcgTnHhwNYwAaQRfjYroo5uyQug0DoQJ39zAmg5YRtM0AboPOEqF4U5jdBzz811ixeSzAFvAzOI0ZPFrTuiZRlwaSpGrJJvx0CBWOzQ4dV3TpXATc1xbIDswchwWMUOiw6kIZs5K6tO5g7gxxZNO220ttz9FRuXnzWgbg/dT+OLD6RYUzI8Pd5JDhI58IaYxWssW8DdCdsAfJ2Jkw29lO6kT/UKCwSkdmqBOs2dfIAHgf0BqYKdnCO80mBTzQrGA9dWaKOMw+6YQVpYlCxnpQJ75UEE0kHZyi4OJQSgGKh/SQqSZAUdqaCJsXcVf6X2desRc5V4agopBHcRBVCE8heq2l+ghdTGZ0ZNghdoXXKaDmA5G6jMGcfALQG0YFSDplsnk6AgbNWGCua8zxXlE3TymEbAlkwGM2a86wBYRQ+Zy/IpvPNTdlekMkV0OXrPA+uui3H85I9E7LPOVeioCQeFZgnUcWvwNKo4p5ZrjrPavmgzTZAW/bODFMmObHmeQPZVMhUDJzNwlNnM2l3UBYDZkGy8qyvg+B8peqnAzhngFZIbAGRDpdeZE9voXqTeilPq+4T07ebtXs6VTZtjyDdgTqz5hDz6Ix5N1fu7XRD+ypAeadZexGpHSZrB+EE0Hxo/cC6T/hIiDXB4eBsBieZEbW5w89sl9oyy05oGgDdGbTAgMBMqwR0s7JT1gTSOatGWjbZOjCLad6aNhN30WotKykRi2amHQCdiP9CgQoTN6WnYUILdhdyyb84fz9O/gxqq1sCuPMrAYbzz8NkV/G1+MoONr0TnI2pICkiDAucijNg9JnQ3UEtZoQ6k3xWNFLzYEOqFgYLtiKN3laAVuDXsp5m2iZzkZQNwmTozBlWeEPaAMq7gdm4KvWZPRG6mTtGazZrE5YRLIQ5MWYv9Ws1EmhRe5smBWiaQLQCzPTca4R7qUd9QESp7r4AlAHa54YHW7bZgpCswLZVJdOFO6w3LQFKs4IyGUhj40CtW8wSi8tQ89iOGOw9Q1JE54tvfWSmsb6kFrvarm9k9eR4YNbX8/BXndywaIBihdUXdwRws3aKuFeAXqO1o2DLTSyDZ8ma2wyeV+CpgGtR71610rN1x/iEb1PE9mZ9lfdlVzujwfkklM32x8SJqBF2M+i80pBXyfV/k3ktvFqYTpbuc9bJ68lXGaBpAOlt1jwWosssyPdGMFYQ7xwG8V3fXl2Ati5du1d2m4E5g3Nm0AbObaXpHTWB84yF0NgYOBtb9woeUWghATN78Jiq6JH/XabBtO2XLQB+5nufj2/5sm/A31z8XtzhEV8EAXDnz7sL/vaD78FHP3qx+ZYt97ZIr3yV2KDBm/rOAHzhP/9y/J+3XoQrP3ZpfMrcZaILBc+tDEs+jSbuEE/OkA3McqnD+Jj600V+H92W4gKnF6SUNEKcaSclw7f5WtM2/ezQdrGUlj4VuGOnW3lcuRyBq9j8KQbMWRlOwIzuPvKKfFnZkTyenHmEq2SjrDkLPvHc366Kh0nTgRnmCaZuUM7Jgd7V0uFn4wpIS3JEQ5DIttm/HKBME9jAmGK7AlmQEJUZEhWkVPnUamt5/pb+VOPhiPqZXamOlRhsPsNjQiazbFVTpKuVAS3RadbgAorXDJpJP/di6o0jMHwYJMPg8Tj0NEnRWfTp2mgZ2v3+9piUpATk03CTtlnGRPT5u0zxcl7SwDJD2JNr1+pjxhFa1LwomLnoalssVm97Blu1MKlFAxcdnEtT5kza3d8sAzjzdROcr0yjJutRjBwcFsYv12Ns6kvqqvt39mwTLwGfC3fXrkMzg1cNc3GUt93P7ADtg1fgQ1ni+Fetdx4HzrtiJRN7llSyU3xCeyT2gj3zYd8GezZwbsaK54JeNsgdvBXgDVKirH0mHYhZfT/qx26JOZvAgvSAsEA63Xzlnb8CRIRbnH9zyEHBsx/xw/i39/+3aNxwp2/7XHz0Ix9SuZR+RoG5CxG/yyKEH3rFf8Od7nVfrE+dxDfd/PrgmVWHKN363pPgHJgzRC2eiSgoh+AwyRPPNT3cUSnbFkrj666kLUF6J0ADkQ7l26HvkJzZyeKw5P9raorXVtYe/8TmmDQ0IbDYLJCxLl6DGLNxcFZgZvR4265iZ67U1Wgatsv69XmeedQ2G4OyLn1W59yF8BJLn99+HjrTu0LR1ftiYKzSo9DGWPIGhTbmf1xBTKEg2hgwK9uXqBUuSZ829rwIHNPTYbVcOQjzdHpgzuAcdbpVqRYDZd+iFUgUUveoyALJ0ZHRzZxiWql07TSN5VHxPK7JYpsbp30fi6PiuFRoZQRmSeDsI9CAWYvFbMCk1SGbrTzYkjl7FrEyn7Mx5wlSK7hqGqBU6aU6k4VHkJXHBM7tOgnOiIGQwXlk0M6i5wTU3c/swKxFSXpUpj707uHwlgG6a+xtsd/il7ZHONAnX9cGtwcpLb6//Ow07Dl8zceYuCWz59TZ1hhkWxOt2fpoZaWsdq6dFRMSAM/6mw7M4Tt2zXWGB2Xo7zQVMMGee6a5EJtvEyGbiID/7xeejac/5An4zYt+G1hVfOFn3wEAUEvFhTf7LPz9ZX8HDubMC8ZsLfnObvbZnwcAWB2eQL3eOTi69DJAKJgzO5GwqM0mNo4IGiCDDNIdLgsoZJj95PgI40GPlpFlDH8G5hGks+gb7S95ZLh+lBwMacWexX2x81T5q3aMhMV6pSGczZUgBBHSXNBkmdIlN92UDTTxgMu+LtxS+Y3r8iC/NC5IzF3i3eM57DWJmbY9WlusEEnqMfKlg3EsLQpKsySbtbOLTM9c86ttwQ5YKU+qKJjMjWURLeQR1MqWyQS4ArOa4XVxcg2C0x8nRD35AtgakAirl3dOijbS+6LxIMIV0gqkOfDaawfkVjQtqHF/vwkkKpUBWu6ydLdRjIXtPBMfM13B6qNxCdKng+wtYo6uqh33TX1aqvg1EsswL3Cni678ZVRMKoAZLBsw61oKLGopbVKs27hlAVdlza1uwNUyCypZAooFL5LlwLv7xZS1CAYjjbLAfOo0V358O6PB+XKYIBmEWg8QYyyBekaP5u5VxFRzqqFBuVe519peGl/0iCpWsk955OmjOXvJeFyEZgOOLPpxfPp04Hwcg14CtHfXvBNA595WHZzLlMDZzlEczQh9PWfzq2U/t+zqFkAGY9HE+l1C+CB1qULCS9/4KrzsTb+omvGq4uHP/w687DE/hbf/zZ/hD979h5hWVVN0CqOVcS1oPU/bWFDLU7/rwfjup/wk3vybv45Lr7wcKBQAxVCW3ML3bE+YqJu1xczLkeOc4XH8P4YNJIF0FjI2YimHCmZ3TX5vKfhcyUsjQ0ZALvk1EkhL16/Iotcihs/yWJu4UYMQEfIiYANojt4sKltfey0NF54MBstkwOYpSpbj60rAMrrPFbqiW4ogG1X2iL2ru6SnU6WUKvZyntpjzW+fCTIuEqv+VLb7rQlRLc9tKiE5ikkMphkldbZqXZ5/jNICmJGAWbfoxfc8jrIUxKoj4SIypXu5FY30Ftae67GKVZZxsJa5gNO+NH1NrNkMw2qvrM+YpQwyk32OyO6xuR0nsS2/drHmpaQ7Hpi7RK3pN4udXxEvSKPbsJWKKVQ8g8sGwkrCGopZfDSvWYFZy3wyz+C26uBs9eCFAF2P2+MH5p7bnALBNNJFgHa0dSVXp53R4NyZcx4UHI9KX2fu6utBbadceVjLWNKzBOxmUaqNh6NngM6R2VlwZmAeB2OJ90dwBsYhm9vVBGYhk7zko0o7LTTyQTufummsaOTnsFpVBhhuOopY9HulIdaGXmr4WSlwBg8D8byKS9A8ZxOabgMi+IpG77v0Ytz3hx6AKoy6qmDWxeJbAYjcWzjeTnd9FwHe9rY/wr954JfoPKpOc9NTZYCL5ToK9bxHA2Z2YCZKtbwXQG2XkJ/YCNI+ZmX4v+diL0Ea6Zt9zPtoCsDFyJodkJfdl0guAYzUFzhwo4d5Jlwaa9qaAq7WMKa4PyzNmLMyZgdmCWB2RlaNeTu4+IU5OEv3T5Dl9RoDuuOFn4vf/J6fxRVHV+IuT/0KXHrZR3ulsMYa2BSgDAVldnDGUDyjivnUDaD13jmPd7N2qGuoJjGiSiCpz7vAFp0g32qxlABmavCFO8iXwazc6fugLWBh9PJxb2PNrQ1muZBIbdStNOpg3Ao4wLmC56rbxtY9J9ymHkMDwoTCOsJWp5pNMZN4piZLZde4RIxbpDHcR/y2VFu+Zrv8bYAej6GS3iLJrZgMJYAeHZkVgg2Yi1am4xpEjAVo1RRJ0VQ/5g2krCBt0hrwpfQKe7HAhWX4xDYFgl23wVlCgI2mFB8MvEOw+cDxAVaS4aoX51x4sXYIx+0jLgE7D7nOrMqOM8JVvAfkY3V0vAYMOkzdSQuPdCd7zW62LgrMZD4rX9eZEseIQC/r1c3a9v2SlIDQ9pdhOB6k1iCYVKmxKl5KFsgKjBHIhVQhFfIg83k2q/+r3yFSpqO3zIU9Ippbl10VUCUFpaJC3AHC1SzFI2eFMPCxMSE2JsSegZU0JQc3WmzjKfRnSeKjtQP08p8n2oyOEQnzYjwHKONzRTDyUHd1Tt1eE5tOFSNL4FXWrJJlgLWwgTOzrdTjCozpZ74PZ1nGssEKysaYx0pzCLZGLJCm0dfSnM6ZeVIa/sNXPxo3PPsGuOHZN8DD7vEt+MnX/qTm/TZny2MhkrzEuC4hON6PKmIA7SNbQslyeHYIkC7KUagHhcaCFGQpXWQFUgqDLG+bqgFzWQIzgyx3toN00qyyH8LGQChQPmZ9mDda9M6OtVfrDcwVjeNhaRU+aTqO2MHflS+rBAd3UWDou8aoEw0H6L7f2/L1kj13gO7yPf+lxHd6XEEUkxF9Dip3MjhbQixbtoDNZy5qLVK3WAOXGVIOrFiOgrOuQe4i09ZJGBa66MDsa4EDDPB1EJyvgN6GMQN0GQnLsZe4SfqXs5d7DPYYztWN1rLjSH78/MmyjYbH0wHwVYG0t6sCY0e4q/qOCUm27/uWKIU60/jTAkRFo4l0PBqIuqZ/4xse4nsedDu84nfejr/+wBEGoA4bnvfJUCINRwLEQdm0VpQCKu7z02haEQKXpmkgy3NMwS2et8kJnMjWjg4LvfidVqaiy+0aGG8BM1kald5H8q3NXrf85zS8qGokhp7+oztBedfWz1HQx7kCtBJxW+YRCZz5NL0BpZp8IcBXHyagS94Uth4V15jNjGrAG/ep62vuP2Zbrq+XxlVglpRsnU2pkgHac56FFeC44fmvfym+8gvuhaPNGr/0e6/UyOKZoZE8DDTZZtDR7bmLWxko2LXfM4o72+1vxaxxDtYRc0LLnhiyazz5hhtjDvY8MTAZSPu26kpdVAUR1d1vEDwgj1JgXoxdU5aECcxF8/w5gTIXNK6WatWBWZmyKblWTs8tG2xBf03YAvs8SM7dFV2JVLDcNnP7nEL63raERIL03pYMuh+3f+ZzxGMGen6ND1yPKOhVuT0YUZi6u6q4NUhN2lI2YJogZdJqcZH2h3g2Er7lDtIyxBzJdRecNe9t12PNjdF5S9bvst61TJJahneNxuptoO66Yf4fYSjL72U98nTA/I8EaKQ/Pe725AIfXnuPgbCRtsW55IRjrxBW7XthLxW89Xn3w4XnXQ+P/4bb4ayv/gk7XTuvzMTJTOfgUTnOS0waOJOtrwrqMfMwbZ/JqJ8rHS7LbJUqbqzk3ol97fgYOGm/K4SYtLIAZxda4taIBTBHBwVApnRWBYZ8L6mPxfx/B+TOVAabiwW3qdgzgHbAYenAfBxAG45QQ4/qdsOKj4VGFsmrwEw9+y2BNHoXMZAQM1278uH0u1tRyJWbYTETZbtCYsBs7KSaiZIa3vS238OnPexCi8ZuKM2A2TrNogtGNLFFHDowk5nmu79dAqCzOyAi09GzK3IMA1EHaB9osR60n3u6+ZSAGQHKqdfWt5U6czblJFINYdql2HuDYtcBmoVQHKCtByi7ZUFEGbL1IsWYs3NVLxnjMQTFAJpHt8WCSfcz6spjl4vbQug4iZ0bo4uGLkn70RgUtg0y9gwI+trcFsin+Z8WL2Lz28UFGTAXLVjCtILwClI0yM4L5niKqNaWFwBNTdzZlE2LO3JdBOcrkSs+7UIgZwKErn/R8FnX90ofjMiJUliA9AjU46D06Zy3iN/cPRB3AXDXQ3eDtLfTAHK+xGN/swuh7uuzK6LlFTJ6eSwHP0bU+nVpb9L/cFUBALUUYJ1PMYNu1Q5lzcIGECb6CMUmhDPmBNZQc5WAwJwsAaUNzlaxNYNLhZlLO0B7R813hjpIW3pQ+PfQA3Dg/nxbcYsMcIqBcxEyYKbwdXafZorBtmTSzEE0KtwjnIEO2EuHicQz6QUi/DdlAOaaAHkA5hm9Kpi4KCXDU9Fi/7PuuwtYO6fUm8VQCRpX0rZnTPtiDypDqQ/1iBgWoLFG7vvYLMZMHQzdT8EGygmYKQFzJzGy4zztXNGtJ8MUk8VcyXMvNDv0ymnOcgOoHaDTg5iWIJ2AeSKzQBVdoS2WifQgOEvHsjRErW9ui5A4QKMDNEnBuefeGD/zsifi0o9dikd+8+PRmFOWY0G18VyEFZh77dvOIsFg8TIsLguNSdv41NGab+3xAD2SmG3JtJtHiHFi/SzrkWTnEXNLGOREQFonBW718oDOJKNDJW4auKe5yyszf9eQPVHRDjLKSAPowZwd4HydrBA2MmdaPNpR2/JH698bH6/rYqoP5xKg2wC9NHXn7QjSDsqZPY9omb2O28Cco7l3CIg43mkAOn7IhIcsfyMoJiIXGVZiEHOiU7DvOSiJCTyX9hZVa0Ew9/w3r8NT/s3t8eJf/1NdlzaDs/umuWhhE6924Ky9GNAGyrrZyM6HZssHLWbWpv4YdwW0FlZNuRRd9tDqLoel3W8NyOawTWRnyXYuMh4UQEmgrPvFWEsJUCaVy/DEvC5AXEqK3X+H4x5WyGmbhKBk3BgBOvyqTCgs5mPXR1Pzo7KUdSLg39/3p3Hv2/5LvPbtL8FP/u53DWSXZ0BmAc9kGCHBonswEXc5JT1CuvdiQXPFWL69ZhsP/rdNOn31MS+dgXrJyygu4ZYbTU61nvYjZFyC8e/QpvVnfIb6OBhVoD7rKLmy7A8kNBs7fwNkyZFnyceswGwPZPI+o1dKsbFRGAMwiwabia/MJU1dBpwVO6MjNh6f8uSH47a3vRUA4Fv+9TfgF1/0y+g+5WLA7KloVlFLKpyd55gcX0woovKNRXP6XpYs26btJI4W26tqPr3dioGQ5m7ZcCuShELXAdotEKUDdJbV4kzYArxag1jeupdjBUoAs48Dh3Qf/NIH8nAXdBHoa97OaHA+iV7OLQNzh8H+OkOjdo69XAykA/Q2OI8lRnLpgw7M+jhKGgB5SPVBAeSBuQRoTlsH6asD0Pm1H1q6lj+AcY4otBxStpV/ZDZtzwe3S+uqAsT9zXUBzl4PmWb89f+5Et/6H14PLWtnA7i48EIHaDhztp8oZBp8UT+YpUBENiq530i3TAqEHKx8eMhaPch+qhCDF6zZwVlvG4XyIMaKY5uC2iiYYDWgKSAuKAbOlWxrl1zJrZwSaT0QjyY1nyxt5w44MIcuLu775PBGxDN2YHYwXgBybB2YLfavEPBVt/t21FLxgC94JF70O99lEdlk4CzgDWmJxxkah2DAJ43xoqe8Dnf7wn+BP/6z/4V/+e/uF4yY2JUQYzJQVqblQfWZRe6s64YkVtBpoUCyA5WxSb9/Bs7Bkg2YxdLqJc4zbmAYiHSrvkYnvXFPbRtGgAQumWkJEMDsQtuXJe3jPIM0m385AbQD81SAidQXXUj/jhhefEVkA5IN0CynVmZIURatJU8lovy757XgDW/8M9zvfneFiOD3/+efo8kKrmCKNLC7BySvAaDKsIgt/CEKvh2YU147eu0IHc3LIFyXbTTsd5m33bokH1/nPWfKS5B2gEYowKRnmJVv8W0+R4GY1qnrd/c66VoJzixnxgO6kiYI98tWd83vOrkqVa61Oj6sDMqUPqcd/5Y62W6A3i7KuW3i7ibxDtDdp738nbEdB8ynA+g+WMcrXX4nsWMPv6Ud4IwNwFHQMJ2bTUGpKo1MeITQ3AJn61E9x9AiopQMLaszY81tjqWRvDi25K7CQqPMfS099SHluzPcTdMjyCaUxrpxL3NZSANvgA7MxpqduXe2bCsMWRoY2SLEJNXAuSo4M6GUgsqEShRkqUAjg4k9FCVr2ZZ1L2amh5oQmVQI+rU5QLOHKqVHTIkxUzBmQm2yBcw1seYC4K3v/i3c6bO/Cn/017+Bg7XdKxZd0WtWgG4bQjOAbo3CZHyX290TRIQ73u5LUJghsUKIFrHwIDM1w2aLRAdnFhuWRTpIW9StiI0Z5kBQgvlbLdBL/c0CMWDOzFls+UM3y4c13A7pBek47mMfQLtmIfu4gps3gbx4hyuI4gYnA+ht5szJrO0ALTonKpnGYNYi2QCyVoWZ1hBbLpJkhrDlUBODrS6AAzOj4Bf/y//E//idt2J9+ZU4+Q+XouLAQLcqKCOFwIZJuwc2ef3EvqKAy76G0ZLo+evbAK23s0Ouy1j/dBfVuCrgdlmO2Nc9p0j+GgHQCtIZmP28xP7G49HFqiiK1G6hMwuiUL+GgT1vye10B66LzPkUNEBe2xKUnTWnVVPQjdn94WaARnySwdkBujPnYsXZyB7n+F1lNz1sfwTqpcqg57wE01ETc9Wf0AdAHvrHNR8cJv2cMXtkT1Sz8YKGBkRM6W8ZVu09AaWdQo4wsqILUQ85QNrfd/OkdGt1+Gz9lrAWTygKdrAF0olZWYI0zet0Bh1ACg2CMSGroKBbN6yx6RQKymradlOw/z6ZP7ufVwdm+CplKV+b7L4oa64oXFC5ogqhcjGCRH2pQk55mJx5hwehaP1fLYujY62imXWWeuxUVOjqj8ndnZrXuw3KdVZQdmCubiQQ4JmvuH8E0h/4CLOh0ppiQtkIyobQNmKWVmXQP/8r/xHfeP/vwK/+xstRmLtiYwDNnj8NDSwi8qyHrgg7a/XFRzoDVOYtki7SKoBFaHhb9HkE5ABmTsCcAFpJusCrvg2zUrLSvQBpfxZpu9VL6Hhp7Huec+t92litHjZwRpjxBTNI1gbOa0jb2OuNLg5SZvScW4QFiSyYgiD4uw9fgTLPqDiwsazmcF29yao6yEg5xFb9YqkJoGeThZ5q2hb3pSVicnqA9hu9S4I5cLoUGsFa38kg3WFa0vNzBbgfRNIhHFx9bPVsAstXFmPNYqzZtS0az0WyC2Zr6zL0OsqcV/Eqa1KZJS85a+8GCwNQuy6XAdpL6jucuaG1A3SvsO1rvjJq7GeQhg3ekT37ANmlq3uUaw40IPQBcFwbwb4fKwWYYBPAk9UWRTv7G5qhFb4cnE0CZOYcibJtBOgA5hyJJN3W608hGIcfq6hJz/J8tKRnMTXI7qMHh6VL5AiIggGvRgyTg7XV2UaANExOUD8H8yN3DcKXDvWiKbolODBPyp5ZuwK09UYa40O6tKmWktSCGaUwtOpVZygiujShrkKuyyxwOhPPHXZc8mUzyczZ+hgIpSlzVtmvQD3NiGj16sYPmLWY0dPR/XYywE3QGukiSH3VRtBGGTQ1wote+gN43gv/P7QNoTJFifQwaadZOFY4N3CWJMqWIN3UJOxpQ13Y+TVL8iknYDYGrXVMJOIWt4FZQrnz3+6BYWM89hgMulDGyfYjYMjHE9yCHGUfe2Uwe0Duaw5wTg+GkgLNRxA6AsGAWTY6fqLymPtN/bwLQFOSiBbsBTZgTrUQZXTg9brQWpJUR+1s1cK6K287g8WfEsfzVQDLAJ33j+HICbjjGztFnQOzjN+NoydbmiR/sf+tQAHarIpaiqahrzam81/EhQXQV6GzX3KX3yBrF2rJdRGcj6BDCPDn6SLA3+uvywKsM4POrDu/O0KlxOTMw/c4YJZFdxE7mrnzI1wCs4OxAzOlrfclQPuV7wDmMGWrVqh+KwM5WQCz/w03aGCYpTw5ODsokoF48e+2DtI0j68jklsQcW7OmkObLohAmNg2YwXFgMzA04Mz4lITe7IiGWQA7d4uQjELl2iBCFFBqJYqRSxagHIHZwXkAgfmFXz9XAfo0ioKV5Sm4DwRRRDuBF2yUFfMaShmjgSroiSu0MkGbMC8BGetUGZ6ftAzAAaKasQQlf0ZlKu6NKt3l//pFrsnI0aNGGtugjYT5g3QNoJ5Q6Z3SX/UphiQCJpFq3sJT1VFzQdKgFC/LrHbTvGEECZmYRnM3BHj2/OFEAU0LDpbjUESllmtGd2BucV5JhC2k/BRH/Jbxhk0+ljNnEsjQMsCoLupW0IpjSIk4WcoPX0qp1KlSG3BBkRHAK0BOYLUNYhVU4qSoMacVXcuOl9DstUkV5wl9gyBvsCuBZqhQWK1e2fOG/RU02xR3GHIjXHEIed624ZRbL0aJRnQRU5/OJkj+xEl/e2OOB7HynRK4lGCZOAs7mNOLq0kr+Poko49DiaMcll0MH4C7YwG5zU6XAH9oSjMbEfzbQNz70hbPUq+zTpcfTBmLXpOwNwG1jwlkO68KS9FObZd4NywfbbLB5110as43gDQCZhj5Mv4fWwAWClP8sK/1MHVpZwDNCWQppZAO5Cj+9/ijrtZW+wSJboyZquSAWPO4rnO6RYamngBCy1AkSpFSVEfpf+EUUUPRPeUnrwEApGBM00gUlAGVhCs1CdltchJJhCvQDwpOLeKWqqCIxUF5ubg7PYUXWqUuCkdZRXA4uZCcXBGAji9A1FKEa60M7yQyk5gLsBUCVMR3SfEKkxV7FFN/dHmQPzGCtBtFpSZ0Ny8PQNlJsyzaPGXlgLRXD8yZViBy9PDFJzVxUBhEi40GgQdiPt1poScsDUbc2aklCnpSQcWSe7DL7KuDPdCZzWs7/XGR6HfrWdLK1kqUpSZMzI46zgdQDr8DwbQZe5m7FJMB3atySO1bZ1gHEHKWs3aZZPWvG4g89MzCIVc1hCYHJgdqtI/q/zlRmpfSASY8RkXXB///Z3Pw8HhCv/um5+O3/q1N0C2wLkfj+EBaf6vS1/x75FL5xwMRsOrfO9dLAyvfT/mfgZ7St91oObh7+NF+ItNmEnyHVNLwNwtnf188xFtAO0Eaf/8OgrO+QIyyGZG7Lc4A3bBaGzLfw/kW0ymXy5NXMuJ6sCc2fOUemfQOZrbf62b7Tx70IOeluC8bLzjvXwVfsYu6ud+rIEFA8MSjrBFKXKxkBwwtRQ27tfOPUBb4GU0UySGjd8yXl50MTbACpIafhs2WSFKOoUdPxBFuzCDWCOpvWCDmrCL5qZa6c6uypXuq6MKMmAGrcC0QjFwhhwAsIVBRBcHKbwCtYrSFKRrKygzBVOtJJgax/IqJBa5wBN0uTlLazEhXyQM+KaW6LiNpBkvQiJk5UvF0qcQ/uapEKYm6tKkDsyTgVFlA+aGofx6kFIGZvM711kwz9RDCVoGZk3b8uFQjEGHKR6kRR7I2KZ7Rwpp/B8ZQBNQqEdbKBh3vic+flI+dI9rlIEte+oU21BsLJG+lWVoUZ1N89NtFCCGaGfUI0B383YL9lw6MDsgDSZuGfzO3c1j47/w6GvYBc6yBooGhgn1RTXgBTHMV+O/zTm6bUsy9HgMGa5Ozej3fuA9ceLsQwDANz/ia/Dffu3NWr5ScoaKgCmvV9CPCwdoGoFzCbODqXkHx0ghIYpz8dd+fP9gm433Q/LiHQdUmM9Y7GpMRkZFMTerhXa1+AV7RfmYMv4OYHL1mrczGpw3WJii0n7X23I8dmfR2czd/66bt12U+xDOHHSpSY81uSdjzRMYq9jfZeIGuiY5AqmD6RzfO33zv82vc/fjJkAOgEYHzxwoJhuESdvP2f82C5ych5Jthr7PkszY3in5nHfYMChdg4ilVCnLF5PkzhRUgHOXxFwB1mIC1GoHaKNI+gtst8CKT/iCAqSMGcWAuUwgWqHQCqADCK0AHEBEO+QAxAfKnJv12czbc9VobQdEErOlNFSZUXx5QVtZWFhr9xYYcyYFuRATFvnsayP35RWtIpkBc2miJuyZ9DeNLa/IXmMMHPZ1SpDAOTPnyQC6zgr6ZUPGnPW3PJ96ZqAw2RKR5iOnDszBnIvYlqyOscpCD9BnggbsUR7VYgy3bztqKlBrIoIgDwWvCuZDsbEJcRuugh5EWNJwDmlh38nm623mnOvwl86gKbE48lnZoT7mecRadCWVyFc8SrEh5MC8hq8TrUsU+oX6aRfzgfviiSqvEECp7xU7n5LAmcJatsEvvfQP8a/+3X1wwxudjWc/8ZfQcAIeoe7AnGG476lrqpMN/+0um5a+5rPPPgc/9cIX4W1vfxue89zn7BRvfh8HwowuLgLkJf5bNE7fTueS40s8Mhud0rnLL6PEyJEknUwWcuk8rovg3DA+BtqxHc3aS9DOkd1ZL1oGho0GYgdoj1zcNmkvWfMKMgB0Dw6D/U7X3nJQxnFseTkIsoqyHCj+WfJXyzhZAlgDoK0ISQ4Wi4Uz0P8+AzRkG7D9Eh2Qc88WgViGMgWHxTUwYKySmGIeaYlHEyzClmZVoWvaKjB7bW2vr02iokiDy0z9shBustJhRBXky2MWXS6TywEKHUBwAKFDQA4AOdTOB6B2ABg4lzopQJeKQoRCpJHaEFRpAc4VGnVLsgasApFQj98eivgPxsRiVcscnJW5EnnREfdzGzDPBs6wmCPpJZ29tnY5DpxFU4c9qFitsGridtJW3KQthFmsKhlIGbAgVhNlEgWtAGIZQTmBc/Q0fxkKyhxDXzpRMbCOVbS4f3dI8U/TJpuzSxqu8CHrchXQetKU5/w2QDuAy6L3GZlOJKxLswGL2/Hse+R5IAtwNuDU1zMEtuJVklsZSDwwrJDKKH/IYzGmPL7mOP6Vp9b48tv+EESOABxBDJz7bcz/jDNT5856HSM/19tBi/MVvPIXX4n73//+EBH84R/9Id74pjfiuCbpTwmqbPX7S0YU+m+MUnEpJ0fWoP5n93V1GdWPRPlgaWfXNiHTdRGcZwyVFwEcB9AAApCXAN0/7zC9G+JcC93uOfbR/c3OmFcBzsuUpT558684MGdz9q4zyt2/J4vvnw6g01ddslGDRiQvGbMDswN7GqTZVxynIl2dLegDfYiCzrOM0vsLhSSoEOnKOR7J5MBMDsyTplpZ5LSwpl2RrXNLrIDmVXj1Z808XkjTt0qF1AoqFVSVORcDaCkHAB1CoB1yAuBD7U0BmuYVqK707xM4uyNDTdqzgrOsUUQDySC9qD7b5TWygLblaBM286KmU/lCJVGZrEmYsLWTG+PNa57WWDBgLovHK4i4OlRjzkM97lksxo8CZ2Zj+bPd4Uowk68E2O4CYymIJYgdnBvlUSAxVNzsrYAJS7Pqw1xiK5FscCwoo29DDItJgADmbqJeplXmLYP6gijojHuU4fkk1O5ODizSwVIg8NiQDJZq2vbudQnUdt8X9ylp6wTAA5x0q4zaZA+pXz8ni4IsVctGTHfFJd+x3ZHuo82FZs0KAMtrDwV8Kcf6NP+7S/4u3vrIP3x0EVU9fLU3HxbpsJFglQBaln8HoKt9foAsR01WyiLPh3ac1HA9x2399655O6PBedcl04794wC6v87ALPGJv1rCnGvI3ZS1K31qyZ5z3xUU5gN8B0DtOIMR5JagnP9ulznHPzbK4MfcChirHZglDdQluO/SD9z8DWPEYTZydSr5mhulz9P1W66sgzMaaWqNL0ZsAscrdYmne5nUJytTmBm7wHNAJcXE2aIatYA8GbhOQJ0gdQWUA6AYa6YTCsxiAN1OAM0Aej4ANh2ciUoSk4IiDswbVJkGcPZUDxZGIwEl/79nPPsyeJrSUsycbz5nUpdlJctxNmB2U/YEYCWESQQrtkyeaulVNelPadQ0Qa/L7SZw0+EoWDMF+5zF/OMEO+MOzLtAmW1FUq8707quEWoqLD3OZSab8jeESogPZVmANBLT7u9FXRMk5jzMOlfffWaOaVXbQI0uD1yoB8Cn+WuKJkXtathr39dARnHrFZLPWbQqWGwTMHcfumlAkQo02VNY9dfUl0osMWHtbtMMkg3Egs8QUcsdmAcZFAs++N9bqqPNYyKP1lbLjof1DaQAhEc86hH4/T/6ffzlO/8Sf/b2Pxt19/RNb7TrAxMX/Uuy483xd/vRBsE1gnIc/KrAOe/L4kT34BxtF0D7/gjEWGwHOjncau1uuvIJm6MXfSmybNauxp67abtPnGwy8avZBc4ZkJd9y5m7uBOyOIZfaevv5wIlHniFBMxbAWmLOzeAtE88/55JXXdqUu3vx/kvvj+AM0zCUtJHdE1cImP2kfLQy2p2QC4BfHGvPEgmSDxZSHOxnKMKTJNu6wpSlQ1LOdBuzFnkLAifAPgsBef5ENgcgMrKfNU1xB9BbGGBhiIb7Typ6TtCltVMTVY/ujl7GsqsNrtOVmFniou6+JMJ3VK4agLm6NJN2wHOiTmD+uiqDrrZEus9Uqg8EMyiyynKqhjYUgJk9TFz7SBdbL8VfRTOmiO+NQ9do0s5gEwAc2+k0S59hFGaBsNMcfD2ESf9uxR/kqONEwDnLmb2TseOnxx+SEx5YFOqmr5mjaMgi8ITX3oSusiFsmYrp8vGmMVywyLI0s/VgFkqgBW6zWQFChnk6YEedeMHUH+zYAPCEbqFj7oG5A+DFmOSTBXzyHCyO0+WNGdBch4cRtjGupe8/CV9Xu5S/JNo2wnUWVPLf0xLgM6f+wjJwbmnkXWnbTtAWnZ9dvXbGQ3Ou+AIO947HVjDhuhxx8+/MwJ09+k4SPd1QjtQSwJqNxPlqG3/BYkJQotfZehj6kwqIQvyABv/dnklS1Um0wnXhFOw2mDKLuih0fl30h0dgNklvR+PAZ5s4jkTLv3PM6AnX882OAsQhUmqTf7uMPUFKgKkTeON6IJg8v5zZAUgioFyAVYJoFcTxNizVDVrgw4BGHvms7TPJxSc6yFQ1QzeFRGyfGurX8wbFF5rPrTV4qYC9R+bYCaxYKBwMcz9XkoBEZn/XJkz2FKvSP29y7DDAq27natHuh6SS3mmgmsx2jzIeNfSwmN4gWC23w+dhxBBX9ErwJViv5bOnmP5cJja6kM06Wr+HrOCcrzvo9pe5JrZ/v4SkLfVzm1JMIB5ujdivxG+5lSxbfSFezfWzM1uBCBNLTZuphBbF1qgzJkMnAVW956jsko6rs+ppJCGA+Mg9VXquUSv3SRj6uQ5MGSlev2eUJY/Vn7JChQRJoBmU5ibLTihhYRSpR+d7s6gY84v0Tc9aDnmK+nhyPJz07B6StwI0LI8wE4gXoLyNQXn5evrIDjvalcHrHcDctaoxr9zUDaRMYBzB+sMyp5nmMWkA7Oz522z9jYwi323pW3Z0TNAL694ub8EaunHEM+pcYBOgOZmbVd7YzJQeu3XlM+r9nNwQcKJxfoa0rBjtSRkXMAVA/OSaF6kjaT85Iis7KAMeDqLCRovXkKEAUWmAqy8V2A1gVYTZFoFOIuZtgUnIHICwmdB2lmQdgLYnIDUQ/NNeyUxU0DE0IRnEK+tmlix1FbR9X65WYnSWSNxZYUOyjWsA2p67ImA4ilAAvU5Q3pGjncD2ILOht1UXdt4S102BjgDY/rmwocL/w75k5e4pa3QAMpuyuYqaLUzaH+sUV51OQVaB0YFP+kF4kZ03Wl99OsIrJd+KT5aYe/vkgo+pjLmak7z9u0Qf94RrOfP3p4xW2BjE9NMKFF3A7+q7FhI/cuEBMzNWHMoSTSCtMe1iAPxAYBD651FgyqiWp4I+soBpliaEqjlLbt7xQuSaDDbCqCNKshULdBS0xE11TEp3NbFwFKfR3dPpJtt+9Tfy0paGnfHAbb+uaTBcDVQ/rTgjGNeL0/6uPeug+Dst1EW712VznJ1b9UIzuP+KKuWUZq9lnbyOCKLTAnNVQdpf/A1HXkXEOfud6Bg9yjedUVLYF5cjSQp7dKO0mANQF5uCQPTjqpELsEdcN2/zR2YB7f4QpMVmOSWJL1HNNkVjw97Lo4c3adKcTooMD9zgUwEmipkVYGDCqwqZGXseVqpidtM25pOdQjwCUg7AZnPgtQTypwj5cp9yYCX2yKegVZBtVhusZmxrewpyawCmVYmmLW2r6CgDsF5er8FHiRnfmcfFWTQTRhGCAF9DZJq2wSO+fYtVb2BBNrr5cQj6CMq5KArCZjJgNmMKG7OrovHmX7Xh4mQpnH575KkvykdoJeyfcmLluLZR01Wi08nfuM+kCoIHtmeI+ezGVtN2dzBuTUdaxqOD2olFedLzFQ8f9missOU3eCLfLirV2vQA2BNqYMvyJLYMxk4Ex0aoK5AqGaBgdILatDUvmqsU+8SWXqlYGNjco3iLjqawDShoIINnAtpSiBFhR90Zdi3yFrQDtA8TtguAXop6POAzYcGsIzi3v2U87nsGg27Vbfdx7o63zt9O6PBOcsT4PTQJIvt8v1dr5d/o8fvCQgvevlz8ZCHPhBvuegvcM+7fNsOkHbwKGmb06iKHTuDscRnfbsEYlp8xov3rioAIf9e1v0NKZe+4xiveXAugdnRrqjkX84eB2+piALMWEj8AaTT37lpO1MrP59QJMY52SU92WnpeUbYHynYUyFIJRWaqwJy9nyoQE2rCZgmyDRByko7NJVK+MD8zScg9QSkHEJwAK0iprnLEVm1apC2gSc+UxVQY1CZtfMGQirwSlhcKip1gO7RwHrdcYdN1lHkPKdUQelJOhCE7rcEuIE5261e/EkH5sV+AHrSnZwRd1O2gC07r1mUOC+ixXNAbAyL1gG6+PumQ+4Kh5A+HAACbvVZt8bFH/gATl525U6Qzmz5agN0PkdKZSKdLSczdi/s3TRjoJECc2HIXAy/LA1JDJyLLQdpazeTgbNISyVqVSEbrUxkVhU3W6vf2QGacAiiAxSsIiZClTm2JSMneJwESKJamILyAQRrCFZgmgycPQq8DyI2xlyIdJ11Z9AB0Hrnw9gWhVLs/AFj6+lmL/jDsW0LoAUDNXeTyU6E2HWghfZ5tcH4mn6+u53x4OxwBuxWqLD4/HTbq/tdB+ivfdBXgohwxzvdNgLFkMB7/DsH6i4i/PuI7XL/mnYH28ykT9fy5ynNajgv/yqNA5+W5+qSMjNmWXzunzklYmDJOIYJSP090xv6JKf+84vzzaZOChC3z8TfN4ArlJgzQVbFmHMBHVTIgTJosehtFC/huYLwAaQdQDYHCsxk4CwGzq2k1ZFmNZ37couFoZU8VvBKZES6hixT1RKMomkvZZfSZ5Wa/MIIpvMMLZJzQlY52nog/C5jzGCNTE9v6JRAO3/fQDaCvgyEZer7ZUKYtb0qbAbXgYCSkkg3z/vyklG3Y8GeM0D/8A/+OL7jEd+Fed7gVrf6dFz2D5cOI3bAizSCtsHZFUk7NpaA3McxWcAXSQdlBeYZ0iy+oIiOu0LG8PWiIl+/qsLWC5EoMFOsdQkLbS/GmDPoqILsi7UQrRb9AEQrFEwoVKzYjTLngh7AqKmVMxBpVSsIaXooYTKmrGyZqWKp5XGhmGNeS0DSDScfNwA8iSxutSv+S1DOcmAnWCdZEcfamhLoAWJXBbi0eH1N2i5UuWbtjAZn99zuAudkUB3aTg14sX9VWx9IP/acF+PxT3gkXvua303HkJ3HGz+5ug+OFvunA2U/bmbOefAdJ3qW50Jbuzs/z+dE6TxI4EX39WOfsMYKYtmiHWqxYAHQcozu4n+fTyW9zoLaHIoRZ+ZKE2GbOVcFaKwIOCiQAwPolQaISZ0gJeWu8wo8r8BVGTXTClo9bAVmBWdugMwMmVQBkJnNhz0rSnkVELPzqkDVsKpiaSwOzgxK//Ilp5vD/UltyTfpsj1bX4c6MlnPcnDOQE0dnAOkHVQTevvaC86Qw5Ttpdp96zqbPy/0YWBlw+O3ovCcxgRuZ955t7tyj7t9KYgIq9UBbnGrz8afvuWtMRYyIMfdI2wNo7GluSum9nh1PAdkC/oS6gubiIWj65gTSGmabkSuPFl1amFAtOa6LgfZwbkzcdEqeUxm0iZ4JHiUHLCHGAANL0WrJWgLrVDIwZliMRaNuBdQpFWpCRxRRGlCIU0XVb+yma99gIRli+LBMVGvYe83PilQHZiT3HFZsNTxMxj7fsnv75Bd+W8XrRTC8573k/jbv/0gnvnMZ+7+0ifUlse5DoKzB/vvEkT5WS6faW5LuDwOqPt+h+BnPeN5eOYzXgwx01H+DMicpVfRGV8rcrzqVd+Km93s0/DAB74UF1/8sR1ntWynA+k8Yo9rS4DddUfya4zvBUim3/YVpYbv+PsmqUO6el8iw+KOu4/Iw4aNtexUGpa6R8HwnvpIk4nX33fmVaHMeSoRHEYO0Cs1eUstkJJWG2s1ANtNfczaZa7gmZQxTsVYI0Nq1WOUCilFEWvBOnT1LDNRL/9Jr++kATs7np6YHMeuroVBmmAYOXHLXL7ZvXGwk+G5J8B2WVwW4GysWJwdT+il2tNCZ+GaL2Zboa405HLThmsaG+hxhrviIxNQ/9vvfhhe9vxfwFvf+sd465++BR57IAL0qoDbQ6dvx5lPfocj/dB8ym6Sdr+wm6Jd+7B0KV3aUrULAaV76+Cs65er4mZxCGhWeUt/Q3+O4BHfkKKpdXakPDa8KwhX7aWiyIRCE6ozZ9KsgWJ17Am2DCrltM8e7Op+ZTdhZ3bsGpuHRuiwVqDuih91HDUzN0FiLJNHvmfh7QLdH9gukOY0GXw3/93ivZ/+6RfjX//rbwcAvOtdf4VXveqXFyPgnwqsr147o8F5hW1wzlGm/kz8OfbAD9pxu2g4zukBOm/HCrM+oiSJQ1mIx55TB3zrt94J3/RNXwgA+OmffjAe8IAXpivZdUb9fEdQziPvOFXEP9/VFldHiyveYqq+tUnp5xinRCMQl7xvx+tLASGo4M5i/dI1asCRdrwvhMU+tgeHPSFa3DoZGDSivJYYixbvU4GUHuynZmtlEIICZu3SCngu4Jk0PXUy5lwJXAq4qDld3KzpgivrOj5Sj2N5frmueKTGbvLlCDEaQhHjOF1Gxi3yzBc/rucSR9XVxb3LfmYHaGfMkXLrTDkXyUuf19KP73J2AGYfIgmQKf1+Pqdcc+Zt7/gz3PletwNmA5A0qnJcUuiRIvq9xTCiYW70IpZelsQBmmLFDWXMYbOPkmcMsSIgWgPbpYbKCza/soiu0Sxu2g7ZYafAZL4CKDiH2mXnZ0VatOvY1vtJqaSsgrauI+NLmboTxf/pgwlwpr76VoB/gDJ14DVlN6cNcNFz0RXlsmaYJPVyWmdwTrdgaP5oWBDLm+UPl8Cc2kc+8hH9lgg+9rF/2HHQa7ed0eB8gNGqkZ+jD+lBmFnj9N5xlcCW7+lrSdslMx4B+nM/96b4y3d+GCMoL/OYGRdd9F5d3o6A3/u9d6En9+cReTqA9jtQ0nFPp/nt+mw5gvtnb7no1fjCL/w8vPCn/jMe85injDczJDyNk40cmAV9bWY5zRZdAhcH+TSJ/dq3QoRl8Rm6UuFaNKF/ljeuUxBl5IqALXGGNyEAGpUgFYiSjpUgs4lGAYRJXYzTontAVNGtFuPQ1xqnJmMMHnRRjzCZwgBiuH6/bgSQ5iefdaxhXQRFoai65T5eT7XK88Wrgw5VvghjXRffLszZmRm7ObsswDkXdPOy6nEOeVjZNaS4oxGY8xKiC6D26/BtBL3ZEIt7lvBCyIK60n12A3RnqGbCRspNx6yMMzHmuAAWoNXIz8/lMBleI751gC7aOdZ1TuNeSn/gKIg1sqiBLFdau1bTK6ypZ0UklgrVlDorWEOiEfs8jgFVVtJdMOzL46Etnr93qcaeC2HpkvYH68/jW776wXj5s38Gl11xOW7+5bfC5VdcrkM/i8AcErNr342GIS9iMiXZMH707//99+Ov/uqvcPHFF+P1r//t8W/+UW0pdz8xsP9/Cpxz1yHbn2tvIxgfo1TtBOYMzdug3H/9b973C7jZzT4Dv/+//xJ3v/uToIuW0+LoOorf8Y4P4KY3fSLOPfcsvOMdH0pnvATp5RllSVTSe7tA/Li2Sw3hQcLf4Q63ARHhId/ytXjMdz4FgxQbuowAexww51UGTsueTXpuKQwLkBKkzxfXPuT+LK85nzeG5a0dWJz1ySS2DogooNiiDoX7svXCAm4MmQQ8MXgicC1oVcCV0QqjVUYtul9sOUwuKkTFrQpg9GXslj1dg18WAWz5RWKXI8fctuVhc+BVQQfofm/s+IYzyxrYuRTnqOBgNFtnU/ZyFdJuzR/B2E+Bx+9sAXHp5ynpnP3eIL3vt8Ojh+N+Ad2cL1YDISt1CaCztIk1qcRKrEZkteUyE0WxLC0yUs337MtLmiKAzpwVoFmBubYYJz0qHIAtfKKPycCZZgXkooFjVBilWBS2bYuw9YYiRRc/AWlNQ2Zjz7H4ZVxzLFRKtkeqXDafx3nwuJsiKV/6nClM3GLf9YIkj/qXj8JUJ9zoBp+G+9/7q/HK1/2y3uZGXfwRRmG+tOTtYmIST7w/z4XAf8lLXjIe5xME0n+KdkaD8yG2wdkhzcdM5qp5z4d2VsJk8fkSukYw7hNV0q8LGj7zM28CALjdF9wcHZh3gbMOmks+/DFc8uGPhnDGVsnGJUDnlqXUUiJflRa4FP55FqiK81//6+/g3ve5B57zIy9OP7cLoHeBMNLETaAcwJxO3Y8Rp71DcZBj9gdAtv+iNNTwwTBhQyjn61legzFdqQq8KC4oGdLUGsLC4KmB54ZWG1olAzI2UGvg0sBlBpPvNzSaje14xSVlPn3VZod+Hsad6hue95vybe16HHCqI3jS2fRvEJWyWNISJ6TdrQpR/bQmUDaQHoA6dfF07Np7/EBeTyV+FGEWH58h+jTh3czYAbaPS3udwXgAaOr3Im+x2AdCkEelMghAXrRTfc3FylYWWzSCLLqezLRAFitBLGqebnrBDs7qMlAW7ivGs7FgFp33yp6lj1EQhsI+sJXUaDKAbqAyo8gMqjNIGkrV1yXqupP1oltiVGoopGuMlyhI0mWQgME2NlvRfbKUMNqaK0mRrQh3kbJoMVN4fzZPffHT8V+e8yr83Ucuxq+86dXAQUl+ZDsFIs1yiJYevuQHii4qKT3U5Xf8Vp429/nabWc0OJ9Af34ZnOe0dbkPjDXBXDd0oxDQAXobpCX2Ea9zkNcI0E960ovx8Ic/AE95ys9BfOlH6kcb1Yf8S3aMZe1aB2hZAvQuYM6NFtvc/Pv5mM7eXEIzvv5Bj+lKw2C+lv56h3nztJ0W+8u+lJR5Eg6YfBqgXn4er8eDxi+RmpLJBKGEsqEsRAqHqVFIKyUJZrDM4LIBlwlcq/mUBVwbWiloRcCF0cqMRhu0skYh7xswNtDVgFQY+r7+hoK/kEbyZsDusG0mdRP0fo0FEqw6LWOs+3DwVtyr1h2chyJx2fxcE4Oux4BzAnTZwaKcZUt69mEm96cSw5v6e1m/DcAdhbx/lv3Ow+f5dTp+F+CIgDEQzLTtip7gwpv/M7zsl16Cd7ztnfjef/sfUMwUrZCs63EVWNCe/xmbCZySSbvRAM663rWZotHAyTEnojEaUtydSmk+6jVQschsmUCxTrj2Ilo0pIjmzxcpZtaWAGdfZ7xgg8Ib3doKWGTlQ8VqfTMpm29mOvd4Ek0PE9QqkKkDtEfpR2BgobBQuVvpjX/2uzj3q87X+16g2RJMKeiPlvb2cR7H4HElhhIw25xwK1wkWH9qAnJuZzQ4H0IvIJuvveChA/O8ACZ9JGMx+4IO1vrpNtQd728egRko+OFnvxzPfvZ/BshTEfyXHYA9CWxUFwaA3sWcc5BWSKxdwLxDksU+0vf99zIwmy1hmUdMwMJ5iR4AYpNn2FI3ccZrRwF08+QSoJfNpXU+VQ/n3YHJ473c1eSY7/auIO33XM2KziKEtKyiYAbTBoU2Fq1dbZEHUXZMFVwITIJGjEYGznSEQmtUrNFoDaI1QLrgQCED6iiTqILaQZkDmDtAD5AdmoaOSBKrb52e9IRxFPo2wNn9gsk87eA65C6bgN0JzA7ICyYdJTwNjMOHTcsnQFuP1d8Hdj9ZgYK1DOM1g3RSJn1oU1fO8jHJhLhYPi5Ez+hFr3ge7niXO+COd7kDXv2L/xX/+41/GEFUHaB1+U71kzswMzxy29ftFiJwMwWq2Upkzda5cp+xsVWYglVgQYQxVwEULTwCj7ImB2YFZZIJBZOCMmwFMbCuLe7MGbbWOG1QyhqFj1CwhtbZ1rGpFcJmMM1ofTFvc1SzWpaqQKqg2NbjDDwTgmqXCUNuejxE1yApOIoU2i0bhkIlBsCFRoD2ub4l0NObZL97rLy49toZDc5noQsYhzFfaE3ly/bqU0gTPHtW9PnT4jlujQj7PwnyBTCrAM+I039Ne0NfYGJ5/CxGk8oh+bVr8+kclxLp2L68ll0KgTsDwrmzOIwN/sFsbVI9069Mx4Z9/75tIz8y/RZoKZXTrZFufV8CdtaGCTj77BO4wfVviDI1fPTKj+EUXzGCvf2deFUnt0549/sgc2cPIazWEGgKFcMjWQWMhkYTmhk7GwGNGvTfBg1HKDjCTEcgHJkAXAO0hhhT8TV7OXozaPZ/Iyg3ODvufkl/XAwN/mFZLJ9CGpTeSKOlqz3C4j5C97un4C1egLQcB8wueOuO9w2QfS2TeKSkXtxsbu8+cRrCB+Cv0/AYRjaN3Rmm57wDim1SoMuKQuf+OPlNKohFP0Nw0R9chC+5x5egtYa/+et3m3+2GejZ4iNwr41lpvtiF2QV4wycXSnhJgHM7IyUDXwjKkpPiiNEvUGd+H6xnm9s5u2U31zsrFwWFhE9Z5lQUexbgkkaKmxRlnKEwqdAOAXgyMb6GkIbMG3MfD7D1g2FFI2dKJVRDJwdmNniNXL6nGZGmHLk8z2uBToYBsZM8ZX+kG0AVB8IDtDSATowOD3YISgjP/Asqz812hkNzifQmXNmzTVNkt5GtuwuDd/vlZn7vyVIS/q/A3MyrFPDTv9yMF7nKTnEEON3B4DOZm4Hj1HH102iCVuO3KWikH8r/Y6Hw6L14xGZILDf8Cjspf84g7CDdHWpn18vkYA6QEdK1mKiiu1n30XWVQgLFq3358ILzsO7f+fXUYve47k1XPiAu+HiS/9ut9ZtVZ7ElnaUSInRLckMkY12A2YRXZBCibwYiM5gTCa2damAJoyG2cB5jYIjFJxCwSgAC9Yg6uDs7Nn/MVj922CLbug9e6Xz6HCA9iyTzJZ58ViGdUVyQJflKGc/8hKUnQ27uTpM2Gk/0qVo+zGy+PKLHZiZ+3vCNBbjygpcGs27dNKYFpLeKwmg7Y9TcHIiVuboEsHTvv/J+PVf+jV86P0fwsf//lJoxXOCLw6a5U4R/zvuN4wKhJ05u5KiPmkmRvPkblY26sDsp11AYM9ZG0y7Vlu9aKQ4kfuhfU1xB2YNBqtu5h5M3IyKjQH0KVA5BZJTgJwCcAqCNZhsfJYNvMSolIZSGupOgO7ArJ1SIGDPhY5690JRYGWwri1lV8xbjIDsPQen+uv8t/F8lwCNHa+vvXZGg/NZGMHZ13DZIMNRf7BjvGVnzaNZu89qX/lnu2VaZ75Y5FQpB00svpeiYLYY7eKYy+3g//KvLqRQhBvv6qcB5zBnJ5vmVuJt2wbobLbOYDwds02dMkBHtQL9LS9P2U9ROt0LrRoL6Z5uF4Av+aIvwFRrXO1qmnDHz70dXvdHf2eXnzVuNrRh5BWEtOtausITiNcQK7EpUCYkTGAWMDOYG5g3YJ7QLOimiaBB12du2GB2EA5gPgXBKVQ5guAIJGpK9KUCGbMBc4do59FN1Bxq3skA6NwKuqxjdNZaydhz6cBcDZSLR1WnhaADnCeE/3nJhgOIqQ/NAGgH5jSymwFvI3MaiL9HffGlRvFIxMB6J5s25huzKM5BOjBnXdiJVQbmNOZ0mrnw7iD99j/5UzUHBzC3EaClr09HxJpalXLGhBSAItpdFJxbca2DY74PLjSClsSMwjVZFtjiJ1JArCyaihWyIQd2ZczFVp4q4v5nO2dhVFHXSg2rzkkQTkJwBMEpEB2FGwa0sTzsGVyagbICM1UBZWBeGTAvAwItjdFpkZjGQs3yoQfWTPHcQhlnA+ao65o7p3vk93VXE9cQuvD4FGHRZzQ4n4AWIrEMQ0xQsdahT2+yg7AO+3Hrpig+hjkTXLM7BtwsYVTcDEyLB+sJpY4kOdrmWOBf9J3aXxq0AcjmzInlCrMi4JKJFsdf+rhTGN2yDBS1bsKOhEmM9GuqqSsw3/CG18erf+Tp+Mill+Obnv6fOkiX1BNzppDwCESRRskNn/ZLOvV0aa/6rdfjoW/6anzuLS4EEeHt/+edeN3/egOwShJd6ZkenxnUFJSlNVBrwDxDpo2uJDUrKJNUoFhADwPUBGUJzFxRuKAZAWrMaDJjlhlFNpjlCCRHykwMnAWnUKSbut18zhZ0loG5d1Hwp7HMTeKR8eSL3TZ9VJrb6gAdj6Pa43B2k8AZO9jzkjHnfOIAZ4z77Ldd1Ew7hD0KdYBuhObgnIBa15KgVM56UTwo/TaKfg77zT4n0eMeOU0vgWkZ9h2BmqelrzVXhLWQB0RTkDJACzRnGIjvqmm7xQ0SIbApFo0BLtJ/QzJA96vKpnmUAnZfr8eAwM+1s86uS3vhV1t1Sg5QpINzD7RuGs2NDQrU76zK40kAJwOcQUcQUhN3oRnFmLN2S+FygK6yUPIyQHtt8UQA/PwraeEYV9xjIPkgN2Xd/TV+EbHSHXcS4a4BXTQdIbO3cLdL+952yfz/e+2MBuezoOuuuJ+5A3O/qTvq+RgUUXx3BGVgm9Vi+/VWLqoz6Na/vsVMHTxdZFL6bmpbxSZyS+fhszYAOamltAugvfsxd7HmxGJ3dkOcYZFgUgdmLboW8lRBU4395z/hO/Fld/wCAMB3/uVf4Sdf9yag1h22VIORTLMMnKnZhG1k68JT0iMoBG1MXgBf8+8eA9AaoBmoMzAF7VqYydlYebM8IQPmVkFzBepGI23hJTwNEKwcI88NZd6A2wrcJnCrBi6EwoLGjFkaCs+YeQOSNUiOABwBcgoiBs4GzB2ct03bDsqzjGZtNW0Hz9oaLU5EOnsmy1c1Y0QG6ORzDnBe2fBygM5mbRq7j1rXIYeZYvJUSIHYGXQDYRYDaFbgas0Y9EydQRtAh5kbI0BnOe+MOe6IR/Gyfu6pTk7nySJ5Q5/2w1EH6WHVdune3QktZ4ehijLnAgVmkmJs3wFaTd/NFAAH5ZwJ4sVpXPkhY85US8w/vWa/ERaIFp4pB2aGpnodoshao7pFFUg9pqWGWbqVZhKooggDaMYpFDplwLw23/NG07YihYtBlTswh2uEEkjbfnF2nDUpQlQ2cXkTN8DknQOz+ztCDpn1K4DZwdYUGDHQ9sHpDzeUNkrb/KXcloL6mrRrDuxnNDgfQguRODjrxPAbqNsOyK6l+4JqFACt7Dn7njtgp8X3EDN/eEaD2p0+E8TSiVHeyKmeA+oS/P3v+m58lCXPEmydOUfljB3Fi4e/SRrkkjVTsbvp15p6IXh0ZpQZcuY8ETAVkAEyVhWw9ZD/9zvfiYfc58sBABe9772gs+w7tShIb4GzsQyWxJQpAJk21HWRTbolWwxatnUs2PuhhQO3Of+z8Mc/9DoQCHf9T9+It3/8PcBcgM3clQf4Obm8EAPnBpln8LxC2azAcwW3itYoAlobM0prmHkGyQZkAA05AuQIIkcQcXBW07ZIB2g3bY8AbSANDwpz03YSA9TBpcD8zt4LLJocw9rLAzgbMHtdbOxgzgMwp9/OYIy0r8yZQi9qMDO2ALNvmTAHOO8A6PBFe23xruSG39vJUWbMACJf2MaGCGn6XGbOAjUJh2VUpYDqgaKVtcRLXtJgqdWu1deLmGRJAaJx7Ta0I10rgzIElSyn3Z6XlkbVBVoUnDW9z1P/yI/F4k7vnnFgTj+SDSArEE8gNveSULB2kqbjUzYgWhs4K0AXnALTUZi2qaj/mSxym0pLOc/cFzSJcUTJCkM9TiWvXhLl4pJ8zIp6I5U5DQmUnSlLJw5s150B3rWtmPiLFjLWv/N/F4h3tTManN2srebszJetvGICZMsgXQRw6GcEwufc5vNw2y/6QrzqF345Halvwy+yzI2kVFN7+MjBL4FORFsugX7HQBAgTOSSB5k70Pq1ds2zYIjiCZBOjDSdd6eOiTWrE2gEtQGgE3OuksxVpOsgrwyYDxSc6aDihb/92/hf7/k/uGye8Z6PfRw4+8BM3ok972DO1Egn2qzALDMAA2ZsrK6vXbbWT7ZzzoHtfq3+TJbMuQke9S/+Fc4+OAsA8Oi7PQSPfs3TrHCC1wLuAsINEgLWRQp4Bs8zaDOB5wm8qdpnAs9Aa4K5CQorc6YA6DXAa0DWEDkCy5HmpIpFb0dUeGbOvADmHhjmAJ1FfTw6uAIqmm2CJUgDtZAu5xgALb0MZ4rYzsw52DNGcI708vS6+4dT4Bc6MIdJmwkzO3tWcGYDaZ6hOcJN/bZqBaY47pb+6pyZbAwUmNnTTspfF+p+TEJ/1vbcicliIMWisgWFJAVSaZWt7lJ1dt1rVdugCdbspL0NwOyArACtypQkYDbfci1A1TkYZV5tbGvqsRMCl4A65sBrUKopS7ZGuhcT0UU7dLlKYK1jFBoLARwB1P3OBGXNMNYcZvYkG6jImJ0xuMBoVHzhwJxe270XNuXcY2mrqLkls+ZUYW+Ij8liUpDkHR+DoUtg/kSAdhewX8eY8wGcOVPCEp2kVm0WM4AJZD5pslIBZLnQun/e+efjjW//Q5RS8JVfe3887FseHsy5R23vANIAL0lbB2np2pwDcl87DceDswOy7WdgjuTA9KDj/QVzDrqTjG05GjqEgpnbMS8+T4AcwFyUChZR4TCYPktazakCB5P2wwk4qHjbJR8AVivQ2Qdh7lZwtp4X9vWKC6Yty0zABqCZgPXistZ90YghPi4jlV9vIAW6WYwJP/LrL8D/759/PYgIz/2tFwKbljR7P7j+jZoXRSFRGqTNkLaBbCbw2sDZFr1oM1BmMYBuIG6gNhtz3gCygcgaLJr3XGRtzNkCwsTN2jkorCdXdZM20CO2ZYsXEEw+kgU/kgJIJiZS9DvVZGSplOpkS9zvZUGRzJo53d4tUBaEKbpHZXcG3LiDcwdoCvM2587aB2AmRBS04aDNQZ2XEkAstqCUDMBMxQEZQ5rs0n3pTLosTNxutau23wFaFGSI7b5kWaU3RkSZNqe/0cUoDKBDfHTmLAbOlMEZfmOzu0rtiiJrQFaQXuy9a2gD61TABW0gtFH2LJrqpwCtPmd4VgH59x2g4yaNsalWs75nb2Sl3OVT2newzqmZYXh0xuwPyHtLD8zrNQBDQnuWBf6APzlE95PeznBwJhyg+46B0afcDJC1AxuUYM2Utje5yWeolgzgZhdeaNANjEC8AFDKW4QQ0P2F3yNeOyDnbf6dxdaZco648fwPtxcGo3a6YIPbS/IEkmXTNtDFqZvb0zllrdMHd+Qkl9COI/jcwJlWpIz5oAKHFXS4MnDWLTlgG6vupu2FBu3SvgEyky5pu1GAlolAa+pgQV0AR9ClX19GC1eYAPRcHdXA33fx+/Hpj/h84EQBDgvoxGSnQZ1ws6j+UrUUI5GD8wbSVpBNhWwqeF3B6wJe64pUbRbQLCitoThAswI0eBPpWSxrFKvopBeqwo9lTny5780JmLtZezQY+ANUnJFguEhAVpNCI24OdV0viEy63wbUQzAYxlsd+0kfiiAudvygtLXgLwfpLYAmtFbQuIOz2N9x+JupTwH4NeqPq5lb+nOP/TwWkOg8glypeduinpkGXOjBVAqoyqKdILrLrMOxQ2gBrBLlyJgDoCmtLFUcoL02tfuJK7RcpgOx6M0tog77UNlmHUu8grQJqBPQdLlS9/l6dS9hhhbZsQge8qwBc7GQ5jvDcp6FltXsnD2PQWwasZ/lR+rhmE52cK9eE8Gn/rcuIroCMIKyybIcwOqDgXzwoz/g2NqTie/kGbTr9TVtToKuWTujwXll3dnt6Fcee89D9LT87l1+59v/Es/+D8/Ane9xV3zXw7/Hvgn4g+hCPwHWcjuAs6QBghHwAtT9WMccLKSodCowvIcFM3Twpi5ZA6CPA2eTQEmXj+bXs2TOVs4yfM6TCm5aFTNrG3M+rArIJwygDyfQ4aTvrwygB9N2UlrCxyQ90m9jCvwkJpTQATmZrftaP3aN7NdqNyoLZ41ESr8jdpvm4TaJ2DyfTBgWhUOSGcITpG3AmwraVNC6gNcFLZGKMjPazKCZlTm3nKKl+dPFuvr89KJzQFjPb2ZLzxoDwRqAH/u1X8PtvvguePqjvgP/47Wvsfvh45cCSP35RjRvAmgQRYxOnQqe+YP/Eze5yc3w7Od/Hd71txfBS2ZyClbKSkFOOWfDC2bSlRTNHehA7Qy4GUi3AGpC4xLArEtxOmMuI3MG9WsrxqRtiqBY1bQtCt+Bmlh7r4SiY6ZPC7PMSAZoikDp5AzqUdqwiG3SyG6KOd7vC9BhuadeGTAvABrkihKZYlxs/nUwDHAWCVsKoONMqlp3UCdbg7yqa4BKWnUsLcYCDfLS4jsK0uzZA1aIJLtcNHithTneU7/ymArL4bC+uwU45CDWrRVRCkZZ6nIps+ZqoJzN4n7jDKRdQY86EQbmx6ZYLYXh//12RoOzA69ATdce7NWBONfIoa3/86sXPPv52OAFVu6zAq7vUi5GIv05UX89kNfE5MYBRbu3xyF9JIhmCkKdNeeFxYe/dfbpAO0DtvZj+rVkW08oFzJu8/kW6sDsK8tUxPrHtCpatP6gKks+rArIJ1bAiUkZqZm56cB80znRllKOs0fMODivRdOgJoRpWfWRXtQxx9b4En+BrrLYZ04KgAs9SvcBiQqKRnpP7lNrEKyUOXNVgTdXY8/Kmou6+BJ7ZlBrKI1B6oxW4WddwdkXHJj7Z2Y+ZzS00xQgOf+Wt8SXfs39AQDf+9wfwe+87jXxbAl6af5CH6mHOFLIPk5jWUjwJXf7BnzOre8KAHjYN/8YnvQf75UCwFJtaGwDNLODs6ZCibk0JQd18biv4GwMmQkt9guaGChLMfN46eBMCaB9WsR28dzFCs1k68lWR3ddMgBO7DmYNCUmTX2qCDo4Y1SH+2k5KCPAWVe4MlWDfLtUnmgEaE9pTPEjwkpRBKzjs5oSWCZwqZBSwVT1+RXqUfvW9aKbWYdmVUCtMh6TV6yzFD+z3+iIzBXfkbauQPW7IhYy131TO5YsC7B2UF/cxcyawVDzmt3xLRlrc9oDROMwbiJJ8iEqiI1P7B8H0HLVX9nRznBwVoDWWzxGXo/LhmdDthvB/dtd/81x2r0R4uYmQO4DBLu3Jb0ORS6DNfqAG9izI32iAA7MTOilJTNoA0MwYmagzqSR9/3nllpjBmaMvRCIukkbKWBIA8IKsCKN1nbwPawKyCcm0FkK0Mqgq4F4MfZMwZz91goDtgYEZOPA7EpBD4Yh89lBxn19DX0d98auzQsWtKUiRf2Z+b0U6PcmgTg4E5tZe+rg3ApkY31NYHPLqfVawDNrDWV1ogJm3gY3A2dbSciqkWEBwV6409YHSiZt1WE+8N734h8+8hHc8MY3xut/7dfA6SLUgNeBOttKklEvdV0r6c/e/kas1yexWp3Am/7gF5HtEn3YefSxdGzLpmtGFFrznOVY93oAaWXLnAFaiu2X2FdTti1sGOBcBkW343MC5tiaW4iNZbJouUwWkOV2kSuGBamKro1PGyfEJlM8eNEBevjXFaEuUiQpR7mAsKc9Ld/T8emKQR+nbsZ1kNLrUauOyggtEjJpL7rwBlPpdeBNwfJKZQ12rBSxo+O8l6/VwMTZeqpch15Wto8jKyySgkEkFV8XD1z1tIBcim5ITMuCKMkoH/2eBUPzApBdpvnc39Wy8KQd31+Sp0+kXQfBGQGly1zlDLZlR1exlOF8iUYEGp4HUcopDGBe9C1AlsUWi7F2GnBemrMj8MskoAsb33cp6/QlZLNdR+RE50FmQO1R5e73icFf4zzJBUKs1GQfW+QlRSpVAVYKzm7GDoA+MQFnVQXnwxpm8ABn1xtEbNVMgWwYtNGVbpSxuxnP6I0XbQhBq9swW4pBSVsI6gBov+0SSo0AkZYiLKCVQGYBVTZTYoOggjArOHNR5jwTeFNAGwKtoex5BnjWtZ7brIVOiBnNKpAJN1QDaLH1fHtOmLGfJP7SWlWjr5kZ9zj/AlAlNOEYSmRiNkBYXFR0IFvmRnu79NKP4Ju//foohwVcOEkLgoiM3pXwIWtvucCaA/OsW2kGyim4y83VCsQGwKyhVh2YFZQ5wrB8XeTEoKkP+1GQu8ZnW84OcOpuDt86MBdo1gBBv5dzcKkoqzaLFkkH6y6b+pTrhGwbmPvEdZXH931E9ns/KpISIK02jMmCzxqEKoQamGaUAObUQf2S7F4JGJXG5FNXFFl0VSqtdte6u0XYlDNX0CSC/TRoz8qW+pqiUQPWV8bwRPoFQA9LmWW5Zfcrgt5aAuYY+HG7dLtQujPJEvtcBsE53vOtdk3A+joJzoAb57rAWaJgNjDVxeveHaA/+3NvhR9/6bPwxjf8b/zgU34Scdg00Yk03aFrrQYaw89KD16IRSIEO/QAjCOJEIma4cAz9ZZMoPik3AnS6e+GwYfTjJE8qO0iqMZpkUsYi8Z0k7ICtKZ4YCog6wHOBw7EE+hEBZ01AScq6EQFDo05rxTYwy1u5ysaugvZMGTNoMlWvokAmGTG411buw/FADulmwz3yydpPAfq9957E4tOd+bcANK62uR1k1uBzATZaHS5mEmbNgbOsy1uYOyZ2BZEEKWWIk3NrWgIB21wkZGZZMa8NCk3diUjjysMQOpDopuAaURuUw59eMssoBUF8dTxTnB/frhw3aecgLnnKC+AOkde+9YBeQBjBWetx2WATBYLHSs86dbdEtnFJJFBIXj59z0LF9zkM/BNT3kULrviUjNvM6QV29pYiVgE7Rool4B5AOkCX8VC2LiuBank9C6KeBS75YNCJGmr43NcXAexlUFWiI0Rt41Ue10RJWbR4PHkhK7cNIy+cP+FCgVoL17SwdkiHqRpHXBpmGWsVBfAHMF/FhfAFOAsXNTSFMFfVt8TEyArBWzp6V5baQFZwXbWnOtHODDn9Mkwaadt3Hb7nqRtvr3RlmC8B+fTtjyEdFti27047uMYt0jb7CV62X/5SdzmdrfGF9/9DnjFy/4r3vPeD9qvuSDPoMwJtGwb1bPQgTlX08qrOQUoIL1YsGab+Krdm/SL37bzYBPNDjgukJwpLAdnNBnH2BgZBKCoUHFwJnsdcReed0la0MABeqXFSMhyngegPlFBJwpwooAOSHPhJhgr9vli7Hc2cJ4apFqENJmp122lXoS5MaQpM5WmEdJSeQTowbyZAdofr3QhkIF5Eosqd3AusPXsOitotk6v5WPLhqDZUmLsmUFNwGZGbW7vFV25SKtDNZD0Ee0Vo3YvERn8IXgWI4uB/mDJEWLXoxfX9aSbZkXUn8q6zWlnyq4o2Ebsi0AYuNftH4THPeT5eOtf/R7+/X/6ZgXoGcGamwO1gzQTpBlbjghsBWYRTUxim6tMNYCZM0BbRK94ZLDNMwVpnSffdp8H4KH3fSAA4CXf/1w8+Iceg2RbNwWLEfVDkwtT56qCrpACsxBFUJXXy3bgFun+737rO9A6yPo7MfQEapHwOZDcND2eoitQ+jnlo5jcsPW/pQUokxVEUWBOJvk0UsSUAq2EZuMwxqaumuVsWQMTLTiRDZxZBpeGWNldqZ6rXNVPnn3NZnbvzHkFNAfnCWCtFx7mcUGM+p74nMzZDsx9YPcewGz3kOxYEaGd5IHLw3g5CMpj9pfN/3jpPrx67YwG54Yene3VY33fNUQOjds1yd6dTefwjb/6i7/BbW53a7TW8OEPXw7QAfxBE7mm6n5HNgZtOX4ByGR+Wd9iG6wzQAMYwZn6OOlOIRUeOdl+6MajfEUbTp9JCuMPjXA5IBeDcoiw1O8HMBtYR2qHFRTwHEyq1UC6KlA7OB8U0GEFHRbgkECHCZwnsUs3YcQMmTswS/EUD2OWnMC5NWBuCuazsexJwVBaV6QIo096CATxy3fTZDZ1OnO2NDKxqNBeA7z0KmYDQAMyi+7buXBjFLbrYzUJkpnmHZgpYLZHvw7rNgNwI+a2sPdnC3h6oX+eXmzH/nEvYJGBmfKiI8Y4yL6vMQL6nhcFecw3/yhufMPz8BV3+Ubc6Kzz8OGPXWIATQsm7X5nT43qrFmcMds8ZWeCVME0aRqQvYat0iTDWuFQS0xYtARv/+B7TTkDLnrPOzQwkYuOpea2+ALMgoOywtn1AFd8/DItfFNgwJ96M1BuBWygzWwuBAHYortZPGJeWXyoWgSIcBAMgWwFlAdYCwDuked6ryWUabFVmdTXXAAuYNZ94gbmaoqXBtaREFqP7At9tcDXjWZ4udKwUEHsfG1pS5EOzEVBuQl1XcctIn6vils6XN5WiGiAWhRLkBXAxp7bgj07SYkb43ItC9HFwB6iuncAc4i8DN75fQP88Ecst8v9Xc3v4TVvZzQ4exERjW/1JfpK6hUNfaIzpi2A7lGDOqsf8eAn4xUvfS3+9E//GldeyR2c/SZHRKODcjMm6Vq7g7H04g0FPcLZt4S+JR8R44RR6WtC383axhL1XLyASALhYqA1LLBhTey/ZeTjIOa9uSdf/56MZpG9IO+++k21lXBqDZAutYCmmti09QMCDgjk9VdXfp/YlFg2cHZgttVvYBHMPGvxj7lFx4aBVQLoqmZwKqzCyyYnwQXZAqCr3wpBWCoaqdLQkqLlzNnvjYGzWLpQLzUKaNC1mD6h1oDowiZ4dcvGD/uz6DCcAVngMoqGJyZbgoPs8hbKXtrvYJz2G1CaoBQNkKJCFm+hv8CCIbslhpAF3v2vt74OD/qK78DHL/8I/v6jl5jVwIGZApjb7Kw5+Z0dmKWX9lAQnow1W2CT6DyGC3sqQFWGplss5hrjove/C5/z2G/ATa5/A/zhu/4UOFypf98Ys3ADNcHNL7gp/uxlb0QtFY//0SfhFb/yC2rgKKZ0lcSWyYC5kflxzYfL/R57apQDgK77zV2tFnRzsOdti4wYFHEUSGMI3dcupjg5eJnz3xUeCJuipSy0BdA5MOtYKSK9EpqrdM7ek/2GpZuxXXeNeuiMDsqFFJRnu2dhoTTAjVqxXoLOTdorUJs0L9sWDyf24LIki12+JV4zAvKy+/dHOac31v52AG4/6K79vL2qdh0E57XdME9A2UQvBtYO0ArMI0DvAmp9eG94/Z+AQVD0kNB6x4eck93JgDoJhFoMnGmosNS/A0SgWACmT7CiICxQkHB/V+GRPTtIO5sMYPYa2ZS0Pvu9CK7YoW268pFEvTJmnQDBmAOY9TMFaN2WsgDnSijhj1b/Mq1I3UwrACsLuJrs3hi7EO6MmUlTOUhmcNtAmpbMxMb6qgEr224aUJsCc1VgVgtHoJNeHydToE1KylFTZq3QEocZnE1JglkVRIWGmn8Rq2cpW+6PJgccubkyTJbGVLLR03s2h7rQGNWoHm/hJmaB+xO7EOkmayzM1yNIF3ZQFpTZrUX+08aorVCJ/qKzGWVzP/rSx+BHX/JYnNrMEDdnh1kbnT0vqn0xOzD3+ajgnKKNy2TAPIVSLbaUlpTSgTkqyElyNTHe/Q+X4N3/8CEtjhP1R90tUiCNcc873gNTVbF4/y+7H372N16lz5LcbO4gXBIgF70WIvPl6lRy5pudDtk83NyBIWKmfOnmfWPHnpyhRFFM0bSpLaImY5dBAc56Pdz6vo7PxEDdT27AzKKrapFJQbKYAwdDEZWBEfjFooqIKEtW9kx9cZJCYLNosMcEhEJbIGz1DYYVVipIJqtiNhlAV7VoSEmGLicnFCOzA/Kkz1uqfq9Y0ABVm7ce8OqNx4kVPMllZ2bPuSNtr6pdB8F5AyCDs9VYGgB6NnDuAD0ZQI8g3UtcLtgmgK6pdcZKZYZQSaurQMs6OkuOAh2UUvlkh4nbfoJsZPjg08VezUztAO0mbTfnmFlOTFnAbAMx0RpK5y+WNxjpVNmGsw0MfRwmIQ+LgCfzW5Ev7l5Q0rYEWCuIF/NNl0oxF2kSW/FIIk1KCxkYOJspm6CFOpg3oHkDnjfAwQzZzODNDKwNmCfvDFjw2ADQzkoNFIdFBwTokbvobNnKeJKDc1JOfGLHOsDxt9RztL3ISUP8blSl2nXP87Mg+5vFo3LrRX9F8WzELR5i52hg3McW7SAWBswOytaJPOeWQ5EoZXuI5XsnDMytKTDbCmLBnhNz3hWprYtCpDgRSh0rBWmbu8BkZm0tqqHAXIYlLjWIT8y6ZZYmco3J5gobQBvt+8+//1o89D7fiPM/7TPwfS9+BuRgGs3Zcwmw4aL7jcx61Ow+sxliDMh04Qwb1zYOm5ACtCT2GcDngXIAV1J3iJ2qDjVT2ar+BsiTrgxwmVA8oHJWpYOb+9RJwc58wpWh3zeAjjLVDs42N9wfLTCTdYEBNOmSpY3QIj3LmLMpLmJyVRyY477r8yN3UWgJOhCrdQStKkC7UmF55YioCwPOIQ5IgzU/97NvgZf8yGPxW//j9/GM5/60zdWq47TUhJc+sWxy5eyWAaDT/jUG6HbVX9nRzmhwPoXIxgvmvDZg1l4XAD2hBUCvgkUja+LuwyDPU1SNMfuXaREdOoBtFdUIPfVnSiA9UQfuiNyW8Vn7OIkiGejgHEn3DsYF4RTD3Fm3H5DRWbHY3w4rVOXWgSF/MsJyMudGmZde6qUggzOlLUC+Ld7For1FTc/GcsSqbwk3M2XrSjnCM6htwKsNYF1WG2CawdMMTDNg/mnUBqrNzOQeGyBhns0APficPQJeTNlysA7LhT2LnLKBBIACZSju9UjgF4xcnHH24in5daTYhAZvzFV65C8kZ+Q7KGeLiJ9XBAgkxkzdImh2VR1Wxoip92LeUGVarPem6lzIY9bjD/14D/3678NDHvhYvOo3XoL/9LKnqFnT8DDnO+ccZzdpi3iwl4FymSCWbiOyUqENCyIyRg2qwZz76keefqcKWiwR5iuvuTtCioGVVnBrjXHfZ/xrlFlQNkA9XCk7NQbIhVCKA3JfdSq7gDRwTCw2VBXsAOfIW1e/bwSFOzizdwdo6aDs+hUMLLlPd3Hl3hgxN1MWZtEV1maxJVeLpig2QrUFRAqTGRe8qAqCjObpAng0RE+V0uXQKeJVW6PBsuCMuQOzjcuiAE0e0IeC//CN34B/9zVfhRe+7n/gGb/4m8quuShYO+O38ahjXqBVxszdVyzYQBp+7WVPwW1ufSHu8cW3w8v+86/jgx/8kAtqRBolXMF2+WcDegDhNK9ibYM9OF9lO0IPBOtm7ZIYtAKz9imxZwfmVdLEXXtbmn0BZ55koftiOXVkpi4loya4ikUJV1EGNyWBMZjcEGbcEZxdGBb0lVfMhBMLtSa2LAbQbqryZYcI6FGKjKGM56AFWtsaY32gpoxNjPniVhBVOjjrAu5FV+8R+6Z07zfBKyLprCd0FBOrvsXQqGyGFubgOoPrBlQ3oGkDTGugbsB1g2LAzFMD6qygbGZtlIXP2X/XTcoDg0U8CxJBXgCZzJxNAzjDFDi73yB4iWM3cYdT0R+zZABOWxqrQcUShklhi580Rkw7nosLE0mvh9xb60EyCOFnzqBM5MUwKILVXPpKY3NjpFxd6dcqTHjktz4VBweH+LcP+X78xE89NVi0M2cZgNlZc89f7mlSbuI2IBads7C56xWl3LSN7HOeYPPPYg+quXtKgVi0isgMckrK5gppAqnWCyBVWSCRgjKXgmbWos6aLRXTHpI0Cu8qsZW7FdW0+1IZFsCaWHPjqgFWrIuldPZJvVyqq5f2WLyMbQ84NvlhsQ8c8Q8WOd0wrOxVmoOzr7zV3R8+VsTdFuIKgprcI6/ARA83hA8+3AD9TnRgNjlFTEFyiAg/8C3fgINpwpO++QF4xs//tkVpG4jb2JVkcVJ3mwVouknHvvdX7/kAbnPrCzG3ho9eehmGdaN9vrObtPtbgCvedqwA5ExMri5A+0Gvg+B8Cj1C24PCjgPoJXNWYM7g3BeICEFHgAt0MXOJlolzYMbCRO2aejWAzpo8YfiZnHIdz3kUdKhsKR3UpalHKfpAdFbt+xmYA/i6ySgGW2yBPLgoDThKg7LrEAbQor2Ip2rUBTCXoWZINRahmrloZLL5jgievWtpUgbMTNqpzArMdQNY930F7RmlzuDEmJ0p6Zq3YauDm7YdpDt79suWYJYUz5YSQIuZtQHPEw2YdAbdfy5NY0lTu4OwGl/09RYpR5e1QZtNsRJTDDRFxkE5F9RZ7Cdg1uBCO5z7mD1gjlwRtZvArH/HrBaBsPYYe/Zb5/jDgj//yz/CF93+n+Od73qbrooZoAALtLc0G+9W+Suv8yQGus6glTkbg8YKIAVnoUnNlFbOUgqSaZutN4gFLEaxCnRBrs7Toq6Qxrq4iafY1h7YxKWEG8cBGgbO8CAxUzsLENYHeD41rNgMzRGl7W7h2fHUgZkEXMRA2UA6GKtY5Unpl+HjN1sxjJbzzMBcVHQ1NvZsz8NcEZ7koeOWApyRtgqJKTLCgsJCdzPFhNGB2ZXFXhnM4zj02TswCxHe8lfvwZfc9tZ467veB2oplkNgKWM60sUUY5d73RfdZ9vXP/IH8dVfdke85U//HKc2G/SFddxs1MctYMo429+73Mvlj93iSOlzZNm5C6D9qcw7Prvq9v8MOC8B2sHZmXP3O3ffs4KyJcBbxCChBiPyMSDkCf4NLiB9AQAvSEKlMz9PK5JJJ3wAsy8+HdXpZDRtJzNSpHa4IARgannfDlGXZEqhdHO2s2b/QV+M2GFiETQ0dgNloKNDmLto6IXL0Ktp4rUZKDegsKA20drSja3GtKexaKSQFCvGgVmrESWAbtiAyKp6FO1S+z4XBfFSGriYXdmkTRSMwY50Kjc5B3u22yL5es2UJtIDxIg6003adwRdBa813pDAtxTpGXcksY5Bji+MQ4Y/Ef4GhNQqIVAXAqCskwaANgWKDJh9yzDmbcMqlTIlezPnWYfU9SU0Q1GEmWmTfmN/8ojv+Beo9RCXnzw1sjXPe/UobQt+Eg9Mci5OxpwNpMFmvk5zVvK8pTEoDOYuiXrok1pTUOZ4CNk3L9nvPCtrdnnMlo3A1IGZzE/a0lKH3R4Uag0iJYlVUbz+Dc7Cw7/vIfjd3/w9/OHv/RFYSBMxgjkLGrMycha0uadasd9nu8fjsp1iI62PWZgOH272WRScZ7K0PlIvV+vAzFbtjLiDogJWn/7w8ygw9jz8ZNjDBN1GlhWhWJ+5dpB2HfJe3/VUHB5cD6fWAsKq/64zeUi4glFszBWdEz5Devwr4XVv+gOgbRJrdrkW6pPuc574pfdhAaEE0Fuychcwx4SFyt9r3s5wcFadJOc4z+jBYJ05e/R2j9p2xhyTHJMBcF5UEjHMgjYMwVYMoSmAmUpTIVIbYt1SN2uv6Bj27PTKhr7YbHXNOPx7BJ1xCZhdQ47xYqO42CyOFVuSSTvR9ec8+9twxy+6Fb71234SF1/8cQsgKqac+AA1oHFwygBkky3MYq13tS4T6mygPAvqLCgzo8wMmpv2qQHzrCyXLFWqGDjLjCYzWDYgKEDrMna63qz2GbBUKyoqichT3LLjN7xlS9YMbLNnpMhthO+NRJ8JiTNoAzqSxVT10KzEoOyYYWQpiNQVHwYl/T0AYxZmfdvBwQVq9svrrXFeDxdJGevOSVPeTDA1wEVrZFRbAQuKpNWmoFrGw2jj7rZ34GDBST4KYI56K2bO7tUzzVQqWZj3wiIiFWBLlRLNiw0GnSO/aILnnqv2A2RLlsaAaOQwuYLh9zL88EXBuYrmpheoidyijqnU2PaVk6Z+nxM4l+GVucO44fm/9hzc+vNvgW96+Nfhbrf4ahwdXRFTvbF5o5tVgiMBo2iwlY9aWURwGzDrs9Dx6+lGPv1h6X08i66H3nSryR1koSjqXigW0d1jE9KDtq2IyhlxUZSZNI3gHONOek2AntmQn1OXYUftSIE5YmU6YxEfth5DUnVSqu9Zz8sXoFKFs09pnVJLgE5z3hfNznMn5k9Ffs6gNJ+OZc7p2Ba6fE3bGQ7OulZzrwTbg8OcRY/AXBfAnB3BHaDdf9RFIcfE1wcPHQjGzoQqiBqkqOnMKxZRyr3sP0PKoLNp25kz0Jlvg80uG0jC2HLwRLAYencmRAtw9ih0i9i+x90+H9/3vV8HAHjlL3w37vUv/j/0gavfIwesYOfFmICn4EiYwjwgtqrr17oC8rQRlA2jbhhlwyibhjLNoKmBqi/WbsBcZ3Ax1iwaBNY8F0erekAHuy2rSFqQv9gxmLRYf2fMZsb2wL400eN+e6CWCZ4g0a6DmYYd07D0R+YcLAgAOWwqAC908UEWVUl5ApIrvEv8L6yAMvqOXfwvq92Z5cdee1xAMJdI/TJghBXGoF7qRMG2WXBWc0eiWjXsMGGwges2bMcUjbg2gO7VSZUtsYFBL+uIxJpTnexsEh2AOZd9NCbtiyb4CkYOvrFACnfWP6UH4fPYfZlsZh6rq+0lO11RYOqRxVq/ugeQuFJRpIROXTxKWxhaL30eLCANB5hl3cPErEa1MmdGa15EiSP/eUixSp6triihPxTuPRj0DKARaNZgMWXPxfKfNSjPc6GRxxvIEa+zZ1cGuIOzvyvxPR39kUXgg8drCqRJoZkujCFt1SOyvbmeYK4qsWqJsW8Fh4gkDIzRWwLRnOngiO9+a87A7Gle2SVYEdr7VnDYce06yJyP4NXBRvbsIN23xYqRjEEngZg0GczrpPPlJJkQATKuhpFrqaSgHKkAxSMPSQE6peB0gKYUGCYdnIsd0zdMCbDdRoVx0jU7ToN+N0C+m3Ajr2/Q+lTyvP/9HwQzo5SCv3jHewGs43skhj6oQ5Rv+InNh1a4gJpo0Qpjx8qQ3TWswFzXgrpi1FVDnRpKnVGqpqMRdbAVniHTJsC5yQbEM2ieocss6koSugZy6rZiDkFZM1mJTx8ZT3zI4/Gkf/kEvOUv34J//m33AmBpVAv2HNGpZqRw9kwJvDOL7nFhZiSN1wgDhsn4UYeiraeiIj4UQoqhoKdmbCPBfC9Hq71YqUuy124FGv5GzMzoAO0Rv4k1a3R8gQiD2aq/cVMGbwTTWZICi4KrFtKgAOgIjeBjeigIlDwI3aQNA2qwKbtWzjMWREBa1WjUdHUekZjA5cSmEZZKMwopPgdT7A9NTLsKcIYyZaKu0EcgqVQDZwuCZKS4CnfuVnzrg56Jxzz+6/A7r/sDXHZKIFhp6hQEzL6wSQs51cRLmbIVJ0nKjqVtboOzdM3JgZkRAWInDs/GyaOjAGhqFICsoGwsNwVhdRDqIsr3BNBAwIDn3LJSb/u1zykpxn5Fi/GQuIuwaUyFx/XExPQHptYdIh1gurylKePsAO3gLeP5BKPPFgGbW1wSGJvC5+NrsD7W/jfHMud8N8qOz666ndHgrMwZzm0Ns2gB1MXey8AcTl+LtKyL3s3axaYwm7ZVIODIp9OZLpRSApw15/znLk9sXieQTkUFANikyu+Z/coCchSQF2w5KFdCEFcowi/mJhrt73v/B/A5t30oPvuzPhO/9dtvQZixYYCeTb0RTKTCkmxxCWqMwgxyc7ZamFE2hLoBprWgrgTT1IG5VgNnA2YidURo5S8rMFJ07VjCxkB5BmarCtZmVAdono3l+bbXpu4jQvCor30kVtMKd73dXXHW4SFOrU+iQx8CoCOv0299BmKbzJ0td6IWpu3FYyGBV/yEV5esZl0IYCYz/wNWTYpMAXT/qwJdF3RkrLYa2HaApnDNTMMYz88dSKwVMEhWWNblKqsG1cmsjJ31JDNr7h6VtJazcGfNIhiLaDibBmIhBAMbCBAmULJ7Xiyyly0Vh80v7FYDT4Hy65IsONNEoiTQw+VTzcGfPkfT++pWJzeBWMQ4U0WBVSrDwqRurN5rrLPQyJrZVhqTDT52+QY/+ORXQXgNDUa1JU3EalazW/fsXwZmZ81lCcyqCXYIIucOFqBnD6wBb/utP8Zn3fyW+K3/8Tv4hoc+1AC5gloBuMZrBWa7v9J983788G3bPRS32A1zyr6d2aXfchMvCsysgXi+AEwtYS0Sc72QW1AC/3pMhEbc29znBmkeEGqR94M2ne6RtxhDJiN7EQYMVlUX4CHMl+w5H3dUUa6T4LyG1XaAA3QXyQ7QeSEM92v5jV0uJVm20E4FUPF9A+Nix4wqXJFS1fdHE5sNtiWZ2TJr+6CH/idOvRixsHrU8EZSBJeg7MqDUWuq6HVoe3/3u9+Dd7/7vePJmLMq6jvH2HaALuilAD24S01lZVa2XCbSOK21oE6MWhlTZdQyKziXGYU2KAbAmmuzgbQNeDJwLjPIzdgOzpsZMmvZztJmCDewrYtMttyisxWPBAcYL37NT+EJD3kC/uSdf4KjUydBWYAcB8wARvmezNoGyOFHLpIfdejUUUa9hLxQ37wDNZkbAPa3TVWkwCkyYEu0LxbagK00RFUBlSaQqPVHQqg4UDuIawoPmQmdWYGZIFbj24GkW4AoXZSbsxv1JSudPXfTq8XYRTGNJSgbaIjdVXFHA7pJ25QRsZvQFz2g9NoE6jIoMrorl/4AXfiKKtNFX4tim85yBxumAZyBEZQFmm8tVs3Klw1lVuas1lZTYKsneJu8sBxoMfbnK3Oz1MjvZmnI61eLWFEP7n5/LSMKu54kFCXdM6YBpD/r5rcEEeEeX/wlYDdnNwdkLf6h7qyStjaaBWHRST+k3S0OCaApvtPBmeJEe0lQYyOq5lGLa+yXYsAcUd0Sf+Mh5wrQKg+oNEiqoqjFh5LJa5jhNCp4Pm/YwHkZ25AyeraF8CA50m8t37/67YwH55rSF/SR9TCMEayThg5K/4qBr03I2Lq24764zpnYimuwf9dB2aSqR9sP6cRLphvS239q1DghouOA83fd980dlAPcvdvnwx9vA/N2V9MbxWx27d/HNdl479GcFL4sQamCsikolVAnQl0DtQpqZesNtTRMxaMANijizHgDtA1kNnCuGzTzIXuJKQVlqwo2NxSrqV1aC5AuzJ09J/vps/7zM/HMl/4Q5Ch5/ZLgDkGSlOvub+6v8/DwIipuLPF9orFUC7k+5dsm9jcUf1uKsWkDffLlCNuo9CkQmamVNY1NRBeDcGCGuWcgPa6CfAUnccuRzhOCRggTGI1GYeem9KgCW6x8IwRM1ZPeorOQmWFVRn/TQx6Or3ngg/G0J/97/MmfvrWbZGXR4y5Tl3PFWDUbAHmKoAWTjZPaJhmnLv5++lxM8bQnM4Ax6cwWU5Ip5r/7uPW+sq2cRLKCL28oPOkzsEwF9jAPU1ypzPBoco187rYKga8c5YVJmoI8FXMVGDAHY7ZOxp7tfkmYHKjLELtf/d4U/KeX/BQe/HUPxA/96I9DjC0LTx2cJW0DnHUAaBGcEXyy1AWL5nNzfl+Cc+gx+t9m2SRBcPx6vEsPDnRlxGUl2SpuPmY5A7RmfqTcMKQfH8dFdeXDANoD/ciXsuwBw8GgByvkLnBeMudPrF1jvv27v/u7eMADHoALLrgARIRXv/rVw+cigqc+9am44IILcNZZZ+HLvuzL8Od//ufDd46OjvCd3/mduMlNboJzzjkHX/u1X4u//du/vcYnv4Z6K717tUTful6WRTClPsAT9bIa2WMXrAZArgOUt9FNvsQETwJ92M+huXkbVMu36K93FnJ303WO+LBOdlco3aHYXw+dhruYel9aqbNYmwTUei+z+YXnGbSZUdYblCPt9WiDemqDetK3a0wn15hO2ntX6ut65Rr1yk3fnlqjnlyjnLJuxyvrWfsm/aaBNHHrjCWt9oQwM6aOfJtloapYVALt6AlQS0HU7S+e0TOJ9lXaWlpuWfYJqNbLRMPrWknfq7lbzfJYYMR6qaCiJ0GkPyZ0ANABhFYQHEBwAMYhGAdgOQSLbw/R+BCND9D4ADMfYG4HmNtK+zz1vqloc8U8l+htLmibYqtOaQcXPP2HfxJ3vds98bJX/EpPp9rpd94G7AhhdvT2RR9GspW69L/JMRleNnUJ5LKY/W7OLBUoE6ROkLrSPq0g00F0Xp2ATCfA0yHadAI8nUCrJ9B8672cwFwPMZdDzOUAMx1gplVsG1ZRd6FJRRNdpKL56lxs9brn0u/fjGFJUmx0eup0JVuilOwz0qKBG9ISnjPh8U9+Ci78gi/CT73s5yGtgrlCuIJNyWBeQWQFFt8egOUAIjp2fByJHADi2xUgB6qw8EqVRGPhxfzYmlZJPT6vAbUJKrN2adGLJOWd1mphK2vtdYNS1yjTGjStQdOm99UGWM0gq7FPq2Y193WVOk2rE2wLdrdo1EV307bnwC77gXayLQ77e8O+92verjFzvuKKK/CFX/iF+PZv/3Z8wzd8w9bnz3nOc/BjP/ZjePnLX47P+ZzPwTOe8Qzc5z73wTvf+U5c//rXBwA89rGPxWte8xr80i/9Es4991x87/d+L77ma74GF110EWq9+pFts88zdJ9L3/ZasP6OfrUnoriJhFLn8FGgs9Ph6IK+vHnfxufUfz/aUnOL9/Pn6Wfy+/46ukcq8eL8srnHhU7W7pammPRa0jFhoOamoGQRIqbI6IriFbNqzGXW4LJilbRKAWoRlMIo1FCooVJDxYwiG1SZQbwBNe0yz5CVTzZzXlsktsgMbgbAm4aytr5pKBvWtZK9Wx41WW1BcsG9oGsRiY4eCOa2ESdxwG7GjCTLabLrNXK0Zd4WaMqUmRhLhafCq1yYE4MmQkmWmKiglBaqL6yRw2Q1iEl0sQCyNKNYE5dSqcvwmfXqVDrW+pjxkqmFZj0P8dMwdsleF1rQSNfQsox0K0NZYhnBWQTroyMcnjiBD37gbzXgO26/8Srpwx3Sx5pZUNWQ4cBcVOmPg3DqXlQj71vxjZ6nJKOlyhkaEcii/sT5Z1GXjeZVV72XVVdKAh8AvALXA1BdgSZdOalME6hpEChVsoI1GthEkX6pc1WIoXnaGkAi7rOGrVstvZgJ1Yq3/cEbcdPzPwMP/67vxH95za+aG5jsWGbzWbJCoLsCLHe517N2d4Ax51TLmsxUr1tj0M4q4TkEFFaGvKRkOBKtIhoxx3cBzZYgC3QlY75uERETWb1+t+h4pAqhpib9SnHaKIJCvU55rg2bmbMGhvq5eX0DYMuq4kWcMnuOHHpnzAbSQwDRkp4tmz8X3vHZVbdrDM73u9/9cL/73W/nZyKCH//xH8eTnvQkPOhBDwIA/OzP/izOO+88/MIv/AIe+chH4uMf/zhe+tKX4ud+7udw73vfGwDw8z//87jZzW6G//7f/zu+8iu/8mqfywwHwdHc4jdFhtc+KJQV+T+KrfonSpjCbYUZB+7w5TpAqyfbfXbxa5LMOX5sFzQYMbgLSPQvYDnRaHwPsPPIppQEzh4qPIA0YSxDZ++FaUa/SxZkEWhlh4No6hTSvqZTOUCbIDIfZSijNokKFJwLVDOuslENuW1Azczas9bKppXmYUnV3OVCM4o0FFZwLhsFaFozaN1AG9Y+cz+XZsEgdo4OyhSIoPfTATpAGVhYPxIwJ10nFO0JoCrw1NcwVTtAY2HajlAAioXDOkArMFPKxZWmP6YuBCso4l20GAbMFBmgbKxHRKvf6SL2WmWrp1m5BqnPWYRRrSytKwheuSzHMvQVlTRoSQ2xJQF0N23f/fa3wV3v+aX49V/9L+FzjkeRhn7ISDGQMf9lgDGpktULOe/ojVVTr1Ag9v3Zb3zexgOHm4TVdG+ACNJ7ZUtUokyAHAB1BeEDEBsw1wNQnUBVmTbZCmy9brw9bH+ecQ8naFqVPjuPBQiXg1jEOgj/4svujlve4kIAwPd953fjl1/9q5FfHI/QB2uIjOTbzT56B2k2ABrGjSkfvu/KXAYh6VALB2ZSZO3RPQUEnaua/mdygngs1+CKGDd9JtLlpgMzBzCrTOEUsyPFg3KTmSSt8S5eRz2lUvbBhm5FCRFJXWGJyZ2AWmoCaQduV1p8QI3PYZTZ/5fA+XTtPe95Dy6++GLc9773jfcODw9xr3vdC29+85vxyEc+EhdddBE2m83wnQsuuAC3u93t8OY3v3knOB8dHeHo6CheX3rppQAsdS3uR8+uA1zYLoDZNCgPQMi9RIykp8SoCbvBY8Gb/X3XFL1+TzGw7seXAaQjE3BZ+CIPGAO+4bTtuhaXYt/LPrQM0JS2PvqS/XwB0uTgLLWDsiskfs4O1DbZ9MaosCGjgzQ7cFCKhdP70YG5gcxEXmwhi9JmBebNDBg4l8nynS1nOYK9mhUumVnB+aiB1gLasK7nvJEAZu8wgJbl4hPS/WERfZ2G01Cty4F5YflCNXO2VZDUFZ0IC7I0eibcA1GgaSyzgcPsj8eFufVCuuRfKRFVG73UMXhF1IfoQtZBWj9XH6JEjIXfDkYlhoi+X6QDM1nOKKBpg76qEhsoq9plAC2WvCaEBsElF1+CV7/ql7U8JRyYR9YcyrPYjfK5EvNElUWRHWBcmrFkSquASc9p9kyI0Iq4P4QtZdcflldYM2WGJgh5qdAVUA6sr9JWq5e5YuolX8krBfog8NWwKC+yo75LsQUhPN8b5t9945v+EO//wAdx3qffBP/xeS+ImtVh+HAM9n1Jr5Ov3X3HHuFOnpbGanGRbHGRzBR7FHzkKscPZMZcoUmrPc+lSFNyXJoql4CyZ6uT0NmqP/WKKIJDBbluBBcCVYBt+V22VdMyQPecfLZiRBGqGIxZw2kIkW7gwOylOwslgC4doAdb+K7UveOYs9+sa+w9BvBJBueLL74YAHDeeecN75933nl473vfG985ODjAjW50o63v+N8v27Oe9Sw87WlP23q/mVYfrCeBiqT9DKqEppPdAFesGD07TJFV5vGBCAQ4a/DBDOl2MwRIe+6dO9EsSMIXSSdGHyQi3X8GwBDCdhcaXvjKJAZyB15KarTNTin2+5S+V/r3d5q5y/iDqSoPoCYp/djupeV+U6sG0KptxjrPDmrw0LwOsEVmBWZOzHmeQZsN2HxGNM2gOptZMIEzNwVfY8tYexd7T0Ab0VKFCZwNIRSoDR2CEC6AObR72zrQZi8BJUWaEjinEs/dtC1ALCbABsjNt0av58SYZ+p/3Dowo9mBY6GGmrbqO4TY2scyQdgZdK+opULUUrGALgyFoYuWGDCLmSHFlC9P1yKfK97H2gLOnlkouYJlcB9nc3avLpWzZJ01K5h6oQmQCd9mZTjZgNkXZYuya8lsMWQwGEAumRRUaegKkRVwcRNvrIB1MIC0lANQWYGKBdwlxbTPCRsArtzTDAQwu6nY2a2t2NRnHXjd8Fm3uTvEKuE5CIsPTrhp2++omwPSVvpvdJD2gK8OzBTjZGTQ5OfqKVWBQRzjQ+e357tQPA6CRBU8ncP2KM2UqOZ2sXM0iW0Kkq+V7fOCXeGqAKrmSIPUkuPn4uAs/h6stppzDAZiKd4mPWY2T/ylqSxAeikvU4/I39yyAnj1XbW5/ZNEa/uCAN5EZOu9ZTvdd574xCficY97XLy+9NJLcbOb3WyxCFOf8oAnT/FWd4BW01KBV+7RKdt5NBHZc1P4dkeWeMiZ+TlkSOHJmn5nACQcIB0DI6dPAcEcRlD2vgBsWX7WJ2IH7wVoZ7AmZd2R20zFTLwFOy0OEUBl5iz2WVaVzfoiAHB7g12SWxI8tUnsvnnFr1lZMzYzsDFgXs1WC3k205Ted/KqFo2BWZkybQRYM2gtAdBaQ1ggMxScmytHCaCdRKVuls2dfQnMzqAzOC8BOpgzqBskLN90YHthwiZjCmbOnj1K1XotFmFrgNyKpfB4t8jhovtsIM1mrgwfoi2UIaL2IxWFLVUos1pdVpOdqINJ1LsOlauzZ5ZQXw2kZSuua6dhKL0TFqZe7FnHGbcOzjyborLp8jHM164Z5eEvCSA55mRK9I5UcOr+mLhf4YPFBIqa3r0LTTH+xfLdDYFsJjCi1kDqCpjGko1BSgBpVmCS3N8CZqSWXmRwDpDWZ/fKVzwPd77j7fGwh/8A/uf/eruCNPqiIrq/gkf+i7g7hOIEyBT2MGcLRUBtBFOK6JKx4gBNZq2yHm48U0ikjysxYPbejDl3i5WyZ3ebOTkK94ezaZNdYfis1FfNrdTlcPbuDSQ43ficehP7p2POwbZ2fHb12icVnM8//3wAyo5vetObxvuXXHJJsOnzzz8f6/UaH/vYxwb2fMkll+Dud7/7zuMeHh7i8PBw632xVVsi6GDY6gMrAcxqWgUaiGyhdbMlumjwYgxsxpnmkzuBswKzV6VSJtgBWkNSyZM7zQwnFrxCzTS+ouNHWpJWDtQC9EAWJILu7JmAbKKNGYt0oNOBc36dRCUpOPv9GyeQfe7Vwby4ApnvpSUTTwglZycKzl5kQIG5ae6yd89hXs2QVdO1mav5jYregP73ouA8M2RjgHwkCtDGnJVoiAptj9p1gB4AubPmPM0CqJMnwM3aAcw7AZqGwDDyeyFArKOcgFkB2XorvY6zsWRpqXPRCNumaTtcK6RVCxTzqNsKaQbMVMHmaxZfvJ57gR2BKltiwBrAHD5E40BeKtTYgwrQzpxD3ZVkX5IwKI4sehxxvRMGn6OOGzdVmkbkY8fTzOKBmTCONEPXqtKc8nGYf3V5AvYcyJPXUXqwFFvuazb/LnJfJe6ryR4AajPYlReLkDsdnPppLcE5XlN/b1pNmOdNFh7D8fSNVEBECLf7/M/DNz3oqwEAL3rek3G7O3wL3O9NHjwoK5CxZ0nrDXRVE0lGFLWGkbPl8KCjgFGlWMyJGzIkCrTkGBCxe6XMeQHKZnqO2NYKW/tdu8p/A+fw67vcMZeWxXnIsCZ7P0YQpWX3p5BFpt3X/xvtkwrOt7zlLXH++efj9a9/Pb7oi74IALBer/GmN70JP/zDPwwAuNOd7oTVaoXXv/71+OZv/mYAwIc+9CG8/e1vx3Oe85xr9HvSk3Ctd9OtB3hlUVJgPk+XuHbve2VhD3bxHGjgFp99Hk7c4BB/9if/B7D4VI8gFtlAbM1hz6+FVQSSCGIRM6HI+DqYsg2kePCS3Tmpi/lKpF+qXzYEnT2n11tanQsH8x5FQIf7n2s6aBcP2fcc+cNcAWqgLHwi3xtxjCg2IJ6PaN2qfWFuCs4GzDJZr83qOTeNyjSLhNfQlaY+ZtkIsF702cEZAdAUAO3zUro/GEl0uuzPrDntZ/ac1l3QlEiP4K7o5n0YMAvgqzsNKzV5DmdTYC5V015QOzBz6g7SAdasgC1sYF2q/o2DNXWAdooYPkADTyK7H7BAM/QeY0ZyIZ8OyrzYV5DuwBxwu8RDm3dIY2UY8DnnihsGU4ZbIOIBmtk7L34RQiLNsxDa/jN2rFRKV6zYRTBcA2h3HYT5d+gVEI9mttEvPqcWc1B0RvWbIMg6sFffCoDxmWgAcXjiBC5531/jnHPOwQ887Wl41nOf23XzzPTEnzAFSL/rr9+PK688ibPOOoH/9ltv7tYUixon96dKNWB25SNfix1VGEQU7ypT9tI4auCuKKhicQyuAErwY/TRkUeAjR+bPy22aZL6ajEW/R7uS18QQzrwdpZM4e4gUkVsy4SGtEUC7KVih/Td/HB2NjnNZ6dv1xicL7/8crzrXe+K1+95z3vwJ3/yJ7jxjW+MCy+8EI997GPxzGc+E7e+9a1x61vfGs985jNx9tln4yEPeQgA4IY3vCEe/vCH43u/93tx7rnn4sY3vjH+/+z9eeB1WVEeCj+19jm/twcGaZBJIKKCmDgL4oCKMhmnKEacomJUiCCKQEDgKogICkaMJPE6oCBDUGO4gijSRmWQKEpijBIxURNEIQgiLdL0e/Zadf+oeqpq7XPeHvi8fjSd8/bqtc/5nWHvtdeqp56a1qMe9Sh81Ed9VERvX9tHFLDhzSmiw/fo8QSF7j419wvBIxq5XrSAs3YDZxF8/KfeBT/yy08AADz5W5+Fn/zRl2KpAB0g7QA9jCEy1zaCVxYDZPXCFSx2UNTGAtbeCuOzfeVQGDNZNOYW6t0ptuy/Eb6j5kpBK5PPhUthHDmuNFH7tTUPSqo230k4aAgYA9WOoQONVb26pUeJgzP2PcB57DrGYnsxa/M0H79DOoZZHLoa8K4OyATpAyAO2hGDU/z+RrISmLechgBdY7KkvmnDojNGRGL3QgZ7Gkb4mHhBCO2WFjIiGMzSb7D6NqOrpdBgLcA8mjHmvqCTOffFwXrJ9zV/b1v8c/Y3dZ8oggl7QRmku4JbTrIwj/B9+S7wEyNmRM6MoRWo4c+TQavmbJrWsDg4SQZRhqVk0HxUb0YB5vAnh0a0mYcxref1EifZEqAXArSA5Xg5XsoiHd0UIFbT4utZS9NkiYRFK03WR+cyqScaryk1mejm47t+3MfhRje6EQDgS77o/njK9z4dF3zEYNt5vOfKq3CTy+6Kyy77QLztL/4GwBk07jXnRg16yuAnr11XZkESmCyKzK2FegKzFPV9A9DBMKgvSdGZqNaIZOCv8L77vGmmEHAsBxKYtSxu7hcNlgCN4wrMLhww5tcmH2N9jnJSlLUXugnjAn+7+sd1Buff/u3fxmd+5mfGc/qCv+ZrvgbPfvaz8ehHPxpXXnklHvKQh+Ad73gH7n73u+PlL3955DgDwDOe8Qzsdjs84AEPwJVXXol73eteePazn32dcpwBRI3c2dRCo7SLG+2ITfU0xU+mGyhYTm9gsb1UXeu8y8feLvzgH3O3D8Hyo+ehsGR523P4YExcWT7S67wOr/M6RZeOYkax84ViE5SgZQ4QmMtxzNwTIF0fERBWARoIIefgGb5moa+5juPikbq+kJT8yBcrte5RoE3ENo2CpMLj4Dx0oOnwcpvdgJng3Dv0YOBswDwwFu896ENl+HdpALSu3g4wBn1Qr0yjUY9FgjlTUdY5s4ZrWDZAvcGDCaBdHiNAWpJF+3NWCwuuwWhcMmcPchGPOFY3Z8tive7MXTBK6w7U3UG6+2vdgXoUkNZmRSxUWkT5KhyIKPgGZwXXBErv8yWYQc6MiUErqLZNDFqLaTuB3L9DZTLyxASOyB31+dYRFqGRynQynArMJ0zHlbSEDCcCNF9Xi/UBztbUgT6qZLmlwu5X+v+Fdb8DWUb+Bq+NgKv1+qi46vQ33b4HhHA7fvWrX4Nf+dVX4CM+4sPxLY/85yk7yjDGWmcrLHoMxdv+4q8APUOqo3RZZLodpt6Ov/Fh98Bn/8OPwLd+48/gz974dlfj0ozNgDCrRF6LOYl/U9n1mlYRlNzmKvJQ5mCZitwiM3ZTE6qO7gdvnkI5Xb4t4HQbCyYwPmp90xaEkjgB8macjx58Tz/xt2t+iKrqNb/tfetxxRVX4KY3vSk+9KYXYSeMECymFDQsWLDoznrssGCHpjs0WPm9VvL5VC29YWjuBmM7WgFPeu5jcKOb3Qjf+uXfhSv+5l1YW8cqHWtbsbYVffG2s37sVytB6WbasXNGuO/Q/QB2A7qzPqIOK2ADmGYpS57NOyVaBaAojSalRJpkn2poMDcTyH5cghqSLXlKlI+mwPJpGxY0WdCkYYm+YWkNu9awNMGObQF2i2K3A3bLwG5nNba5AUbbD7SdVfGR/TDWvCNrHhjLQPe2toFVhtspBlZVrEOxdkXvirUD/aAYq2IcgHEgWMN90DZGsgKtG5tuHVgKODP7hgWDWkmRYoDuUcGfcy7f9oCeSanyJ276zsj1SFHy2stWLalZ35vvge3g3N2H32m+JjDvMMaCte/Q+x5r32Hteztez/z4DH09Q+979HWP0ffQdY/Rd8b4GFDmc4PWnYiE94ET9cpxeh6299t5QK+C4jzUq8oNHKA4uJJq8RdZhnKkYgY94WsmG3evvweaEWQ1zA/MUfN842XJfvF+twC7VprY3ul7V5j2UuK3eNz8780/z7Jse2DxdCk5B+AiAOcgehEwLgLGOaCfA9Yz4HAGOeyAwwKcb8B5Aa4C5PwAzq/4nE+4DD/4qI/By171JnzTE14JHN4DHK4E1ncDvbYroePdgF4JjPcA+p4Ya2itgZh1D3O7ka3orpYDujHIgH0QdA+pE1nP+XOraiXeAAsKa+53vvWtb4o/ftO3Q0Tw337/LbjHxzwNDSwsdMBODt6fxyLW7+Q8lnbA0s5jaStaO+SOdEs3Gbgb0L1C9+p1XqzvZzbM/QxY+XwHrHu15bGoZ9KxzjvQPTtmdGBEgUOBnreG8w16fgHOL8D5HfSwA87vgMPe7+k+f5TNC89YHrjVDDBXxmyJuvpo7asAPB3vfOc7cZOb3OQEop1+/H8Srf139vCIPQCur1OHIXNmFKr1xp7TtBJRmxhQNXDu6vZI9yF9x1c/yUSQDM/bZcCMb1EYzNkaE+FlDGi3ajn0P8cuKUlNUmJFlZ/KnjdNSx+MWULDDo3ulCInfs1iKmi65UawJUjhRMGal9RKEQln4ZuMzQdCf61C2JjA8Ij1zmj2Mdy6MCDdIrB1Nwyclxmch6izZw/Y8+/TrhjDorLRvT9oKC/ix8GYfe/pypiDLLGXBOqtaTvGtK5H91HmBkkSPi6JGJrCNL0IxGA+ZZOIxB4E51HAeSQ4j76gj5ktR1sbxuqsefEyms16ks4wFIHrJSefFYpI2ATNg7yTxSl62nfs01JpZ5H59ZgLJQgqYhNQDD0lIIyfHmLalMIYLrhWFMlqNoKSwpJMuR5z38vRSuT8cL9zMaXEGpIgskJf9yqMC3XrDMIFxbX+b77t43C7W16MBz/gznjs974GV/yVF8rY1jAlT/TYjBoQl2NPBp33LB917eP4WLd/qx+X0s8tjdbW3nXFeYyhWBbBn7/pnabOM0Lb+8UL2NQdcs17naw54/2LkFP1nbmAoZYPUycaxZ3tLukM22NGTDYB3Acg0lXB4eP1tDLzBWGVcXlmGwORIVdWNE2GMv4nLDXTONd7dMB787heg7PsbDHl0BTTtvKW9DRdqk0SBgRZ5HGW0ItdWNSFh08MK78wB5Y1tTZgJm0Mz8tVBoRZzl2UkOzDWHINCquzT5AAPYFzlYZSjjkKZXFKnRCY1lsAc3wmF6G9oT7bGi+bLwL3S0a5T9+nFSb00sFAWape5GmAW+hZ9Lo16W7y78ODwAZ0pwbKy0BvirWN412Q1IG5A7oFaAaBudCUCaCR9X0LOJsQmY151byNAtCRsdaAIQnMCdLiZu+SO8tZqQ7ILMdJYB4JzDLIcEsE9qCveYfe2Ryk19oEfXFgdvxRsYhWlqpV8fFRu1PCXch8w5PqC5QADcYPII5PgzRXn5z4+8ZxQlMr52QAdF0AHHRs3HY8xwbPR8MRi9mC8haYA5xh4706QFdfR0h47yxfzIIL12zatQQfmsL56v/0Vnzp/e6Ad/71eVzx11ea0h4Fsns0DaDeAHcBaK2KUjy2z6/hdeo1Jz7Bx/Hf7BUR4N1XnsfH3uXp+NR7fDB++nmvw8KaBhx9V2ZrKMYCM2TkpqZpAq8RCuq2lhGKvIb+pT7uLB/RhsYGfeY6SWC2AidA7t3j1kEtClboO4IA5fBRrZt+y3I4EdPUP7/nQuB8/mpG/cKP6zU4x2JC8rbKoJm7WcGZeXcBFg4YgzcpbqYVZGhatb05NYvFNbJAiZkHA5QjutjpWrdgg5oyByDN2hU7T+ae1Bsu8yGBOUOEE5idwXHC8DB6wK+J4T+tjOcWpBlUR6AuGsBIQauxeDjWJmx0uA+aQXMB0IqxDOg6MBYD6N7UmoNzF6vdTNAPgPZGZVdoAXRSQlM2WfNSm1jv1ugpcYT1sSf/FfJSWeTIUj8KQJN2OzjTfwnfAlBabv04uKfuknvpsrRibkW4i+jr2d9cWPMqGAfBOKT1enAnKRlFceJFBOI4CJtjPuML/NglXRbuITAr8lsE09aP2FpQUlTx7xPDdYAOBs0JRIDmhwe/wdnOpEa1XFS6aVEVqgDzWApz7mYiX0dhz1qUXT8fV6oZkCjrcPeSg3NXYLU9hb/icf8Rj3raa/GWt7wDOrIuwimAtsm7MZPpyEyHOopaR/PaPlJGnnr99PF8/QLF//qfb8ef/s+3YykWtuY+39gYBrlJzCIOyqLY+fOJOVMm6EBz9tzp0nOGTGBm6nsbamsZrvgLwCJJ1YWc1cCAjC+goiU+7oEUSPPXmvPmaKw2wBygfnp083M3SHCG1bHlc6G5tejwSqCuzQFjLCaImJnuJlpl6H8o0D4RA/z73JdCJCjHkU7Fhb1tYZ7zEzylGF9wLfLFEyBNROHEpXpbftKAWTN6ffrn1+xj2ep4RkhdpolkgJ2YhtvgNR4yKAzOANQDxGJjip0Ddh/QRaGLg3PTGZyLb6nuZTEGMLpOAK29MOYTrDnM2khg3mr81Inr0iMwW7yPhLm4ZviMEkWmkbLBspAClk8UXSynWVvZwMJBwy050LJzkNK0vQtgHuuSjPlgrLkv4sXDrFADsxAIpblaFCisTZoP3lgTpEsgYJhci+mZDDqnayS1FDCW0AUoFzlnA6R1w6BjwF0gEoeBvOmTSbEymKL5evGNBOoKzJqsuTcLQmCLcp/eOFas792HBTG6eRureACivc78/T9/y99YgZ1h+5VjuC1ci00cZdJqh5JBV1/WxJyrmsNeMA9cvSNl3Op3TG4MKgCuqGXVHLOo+PcLg6/o4mKqKtOZCjgvcgKkMROdWvqJrq8IjhumfAcgD1Ow4xzgTJkKNDRAWTxNMZUvYBMKDou/sf2j5zmy0cS1zMMAZ6rxWwlx6nFDBee9TpXRbHjGjFG1V5o+rHKNmZzNvNg84lJFLA9UN5/xRSIym2QyqvQC5imqfZuoTLBGNdfVkVC6hkfO0HIsJ153Sjh8oUoh2fWjUzMWbVaDBGgLbMo0tS2ck/RgICyKo17zUnzQZccoXQjMiuHVf8ysDQxxgIb6OlNz7zl7noZ6G2RZgFm8QlH1N7t72MxvegzOR94mP0jPO2dbuSFeQEFLmDeP1Rc1ffVS8kxZvcvKJrYAaIuF8HxmZ9CdPui1oa8LxqGh7xq61RnJMWzDFISQMxpAGfEWMWdXK85T99HelKmdQJpfwbFBplyFPAug1jhGeb2a/O0tJwA6lAg/Zl3mAOgtGJcW+xm3TdMiuAVYm1elqyYWAvPIMaBpuq8p9NcGrGLZAqt63r7tT45+gFiUojVGKnr65cSit+M8RWyXNjHnLUCfgogtsOf3sG46wHh6u+aoqMgymOJ3TJjeNIOzeDxOc6Cux4sMB+rhQE3ro80YdUCOLV6d0OgAlq4WmtHUsx80rVmqcw176Hy7vEzuBNLlVtq9RJknQFkoMc6tCf7Dy74bl93sJrjf5zwJb3nzX+PY31xlQL0vfNxgwblqjXwQIex4qkgzFrAEpfhita357E5bgQYH52HfVk27pnXOwkqo6dY+WgVlzI10gv0WmDdy/2qbA3AFZPITqEOn+iJTmq+9V5TnG27sAG0l+Rj8MSItLVLT+P3ldhiLVpOjDg2xn/LCMXHmHJGWDtDd2F8XdZDeiC8tDHoIojxqaMlagJlsuQA0kjkToCdwlvSlbWcWgTn/FCOdIrKyZ/EKW1K1biaZGEOuO4jHxgjctWgC6JLv7L7mcWjoB8E4LwnOYc7myI8AQZM7nJvJ2kSro96Z3RFwlPz1MiYAEOUnTezOfytjpRyjCsgEV2qQ8SGf05oMLjcp4GsFnPm9V8eah2YKYxcD5u6gvDhFK6Vjk916Te/hoM4dsLo4MA8D574C/TwwDtBxPsH5CKQ9pBgbM/eR1YI3rc7CGMXN40jIHL0W7oqqDFRkE/fjMxVQFliwKO+PkxRx117tCb4MoCVYF4BuEVzq8ykIi5nyR9nxziqq6hEIW2C/zmE0FM0eF6ArgXkkWAd7ZuuYlboy71TxsG/8Itzz0z8aAPDMf/lP8SUPeBrmOttbYD51P26AAWE4gzEuf5rT1xeta+kx4AMmVHwT8EwrKQsubJTlSzl56iSXsnC2wBzavpbnm1aBmY9tQBcQ5ugA4As1Lb3SnCX5tcIgi1JWQlFFW/xE/JT/3dhy5olzg4TpOX+NAtaFt8nUGrhRxqC5kG8wc/dwYB4aPtMhQGcPTeuUiuc9c5gF9NMLAZpj4QAtCmTdKz0awoBHOR3uUUQbb1jMCCozLsLAfAGgBTgr04SYm8tflN2mzxjXQWNgAHQWIDF/szFnA+YMBLMgsBFwyqAY5XymNWc4EGl3NlfZ8wagmNlQ/KCEiNy0ofnrKawqjNTwTcAAPd9KwK7zaP6WeMMAMhgACcz1+AiYG2gytcBcsXSqTta8ZrqW9BwHLDAAbSkrBtyE3ZxBF3AO5nyVg7SnRW1BWbcKkAPzkVk7xxsnRnZ+1EG7kPefwpBmbI+bCVC2ssbiQoLBoJU5YwvOG6BOYNYJoEXSRThdU7ga1f3KauA7mbJNZsoCRM1Znk+5rGTMCjmIux+ag/Q81HWYJ1nvMvo/vOI30cdD0ETw8y/9j7C0qA1rPvJPbx83QHDWM9eAZdbUk6TaVngagUjqBQPUIy8H0FpoVhDxgg0bBWpQDG0nt/W6eZ4+CoLwFtj9Aqrkr8f1QaTkx68NOOcIeSflpwnMG/Ys4iUcCVylaEsE1sncHKCzUtDmMqh/wAQiN4UXpbbsoLw4yDYH5vCZIuN4xEOUJKFhBOD4Dw3P456sFBTYUxgSooCCJEOuAF1fi/uAxA6WF6nibxT2FuLEmfPYAnRuCA0Idz6qz0vpTc/BV4Lz8LSptVkQ2K5hLC2KVY1GP7NAQ4ERU4Tc7KBT/XdnbMPA6LR5e5tfq9NUq6Cba1E2f98AM48V89wPgC59nc/1lxmEKOW7CMpLAWc1V0GAczCo5qDcHJgdpGX1+0FwPuT3xt7SLcHZg8HS53w+gXlc5X0BaOYuZ4oBjpFjliPHQDsPhw3BdtCOAZmmaxwB84rY9tVZsoRvz6KzkzlrAWWPUwiAHtkXf3TsZic0qSOAMCOtFQy8E6nnj3iPxSBoETb8O9J6VgJEbWiHuyBGWtdOArSWfuD3/usb8AEfeB9cdO5ivO0vrsA1m7S3cxV+Atf9cb0HZ91RGFg/TV+FAbNHXw+/+aMLGn1XnX45K6moKOAsBGYYuG/+BR3bBFHMC0Lzb5HfzImlxzS13uNqO63gTJMcj/k3979XIhKBXwrIpOEVYMaGMSOD4czvTEDWAs40E0vWjq8MOn4m74lAg0nbGZTQIkUw4aGYXYSjWqJkgocEHg69wlIoOOSEgJomlgCbykgxZW9aHVAOuyJvv1BBUcSvQGsYoQHyEK99LYuBcdtFD9lBmxXd0HjOrRpbAeiGMcTzmi1CW8maF3EXmm7Gx+dx7NJlAXgW3OSsMRi0+0Mp1aRE2nGe6wactZiqoT6aOXDHwJxpVWU6Hmt1suknQNLUnGKdFOY8AbSfc1QE88tZBFgcmLkVZWwttsIq2DTkloGcZ8PGpC8p5Ls6MPfwNx8D85ZBF1C+GpP2SfarObJH4+iyZv6cr5oppNk2OEEBZlNKAE8etu8pW2BGdHT4jPjZ1QGe1pb0WeeWnQWYC6jGeVNx6n4ru6JeYMZlUW4WraR+vgL0Wvp1uDI1ZmDWelwXjL34rr/+K7zriitMuaOU1Crprok53wDBGecA3ZkJjcki9AfaPfRdcdR9yQNeSMBNHtyurzk4U/j3UxYPD0By1qdSYLocozw/AmYgAbkCs+hRwGkIq7Sh2qMC8Rawy88EMEvRGwKQU0TaKYjDiKCae5cAYxRgVq90RXC2MZ2malkzcc5+P0AiM7QoUBxbjrlOa2U0mdxEoThVma3zsOVYZ4EVALj4kkvxEy+8HALgYV96b/Qr343cpELDqxFbAsf3SQz1iNdzLI9MqTRpa9n/mCDrII1GQN5B2x5YyvPFQJp1sSNDVBt0CL7vEx+ET7rlXfBNv/rD+M03/Xer193gqVOcpwB3RDPZP5yVeJW6MczHSmAeDHEvCeLq/WRyTeWq3ml7lsC8tVUkKJ8SagWITwGRqI9reZ2KXl34ihIoQEE6bNK1JQXx4pOpi4FzbDfp4CwH5HZkZVHG7mgLZhO3IvabDp9zYc561TE4T+z5tL21qqIVzLbqzQwP+X6J2dow+5V9lUszSwmSGWcs43Ag5ft8bANguwOun38F6MmPTaVAfXkQ9HMdo2CiAXO52qJfaPOvLwJHnYAkeAMZ9IdS+4DAfAGAnlyPVUniD1ZQ/j/gfLUP9cpq1CArSE/bJ1PJcwpmuwJ5+oMDMxkz96SNgCMeC43XBYZFoVWY1OeiblHVI0CuRdmzPBXm++0fPWLTWvrtmq2ycgP0+fNMhyggLTMwLyoRAGYAXY6HoDU1QB6a5nFeZpwLWZQ/9WsJEgMNmTllm41ZJAVzbilXE5ilXHReeuAj5XkZv295zJPx0Z/wSQCAB/3zJ+GHvutRKYxE5lQNvn40/AWUN6xQo6+NAL0kg3amrG0HXfbAsod6CUldjDXDe5rDBxpUBXe46Jb4J3f6TADAMz/zwbjrzzwmtk8NGeOma7Jl5U5efVjZxG6bikTwE9sgOPdsR3m4fqPjHmAzBhyTWeOcwXr7qJPYf0NTqMdxnePVXVQwyBRaanE6a3Jk3AwqW5opJQRnWbxn2yoQDs7qrFk34MztUAeZ8/ljYMZ5hGViSqmqrNajlzcLvSaqyTwYRSnl0QWCWCNqiqCb1yqFHUsjiDbf6xq2UUtl1I3fZXNGmSIRiY8ejFitOWXZFNx1C6cbJuKK1V9XC/xs6umJ6lkQmtOGID9yykaBGCqnAdAyA/lQv6cE51YAugrnDYu6Rn8z/N5e98f1GpzHOUXbV/0wTbVUnNKiokAXu8FdbE00gaz0CyYohJUKZd0BVvQCZHZlsonG5AMqQCNAWsmOpz0KC0hvI5A42SpVqw/F0UP4v45kzQ1TOnWADtzPzFORkuijmmUtvUV+8PAmiiZiUZUAYr/icoJa1g2QcnLa9XICZcS21WbxSAVJtbDm6fIrepoGIKASZD+mIbCBX3/l5fiqr/tmAMBvvvJypPluGpyizdTnJ+5DPQ+XOubrlWDNmd1pwDwIzGKMWdseSnDeOTh77Whj0GTPFuP6Jvw13tPP41zb49ff9ocYFzWffx6dHSVSCc5W3CXruncvuNGBZUC7A7OcaBS2NXJ4AgW/dN0OUgo0PTILndI4a6u2RkFK0QQdA2udARqbtzF1oIIz3Vk8PYJ0gHNzdliAOU51wOorr+A2kemD5iR2CwTBOUDZARoE6G3NbCpCp9gyQRYIEHblSGL8fN4X4ZHAXMa1mpp9m00pWqiIlH3M1dmzgbMwjymsffV7qkk7KhLknASBlnjmypqwopzEEE4zQMXy9R0j1a1D2lz593ijiKngh4uRwIS5eD88wv4Ee3ZB87h//jA8+QmPxl++469w69t9ItbBeAO6NrZz+JoA+oYIzl6XPDXJ9KFyy+RebpZ2YBmKsVpKkNXllpzKCnzOl3wd3vrmN+PVv/yLKC66NLWOBGVjcVuQtvPhtpBaBH8cV8Z8qvJFkUEXBOZTrT4mFpH4QyxrAdCIzdLtFHxvGqVZ25j0UmtTk3BJUQJY93hUMYIwVU+n7XJSpQAwlSM+98WaC3UWWVulVQpDsl2P7IfVf5j9q17xS7jnx90GOwB/85dvw85BPHe7qW0GZi3gzTiFAGO/npkxkzULuOPZoFlbFgz3L6cp+8yAebcHdm7aXhbf8zlLwbxHgdv/ysNx63YT/M93vQ3jXENsVl+qWOk6bLOVQ48euwF1UJ7zerfsmYzIgVnGBISTcgSUyZve+jkefss6LjSheZd7DnpdDzL8NQdc4Q2us86/JiZn0eoEJgjshsETad3HLDmp672PDzsARU56K6et9r0BzquBMMEZtRVg3kTD16psHHMpSgjBmAAtXAyubKcs3I6pm61BMOU1tjz2vawlKjC53zhM/lIMCv6e4ntWB/7J5acuK9XkM4GNx1wzA83ckPCgUJQ6+sMBummsy1ivZQ7pRvNXJ2TBsAKgYQprpn6gmrO/6svvDxHBzS+7GT7yH3wIfud3/tuJ+ZvK+DU/xjW/5cTjeg3OGuCMsog4aOpsTidwVrfmtKbAwcCcUa0P/uan4gH/5OFQVXzL134efvNVv+oArXlvJYFa4f69mCjVp+IijPdya8qucuvqwPnqmHNpkrMUsQaHXSvfH/KGaxGURW7WFub+eqatislwVU8BFbTuIC2uOLsMTbGADKLjqRMcy0XUv0/7APPYYwAUrMQlGXhbldf4Qo0+zLpiP64eQEJX0l++8+3Yq21OZO4MLaU3tWjoeT+oCGz5Y7L5Y2A21lyCwlz14c63ip2zaGPPcBM3WbTuyJ6bnR9FrgLvGYo/Wd8JPVtS4XHfsqXkKnSvwH5A9x04WP1yY8s9gFkJzlM5Nfb1akfeyLjZlUFsQfmC1covPJmn3Ft3LsqWdejm8/Wctlqqa31h/tQ8d968JtnXgIPKmiMMeA8zRbN8I7W4FOwW+c4qYMW3rAWYpQaDJXOWyUoxB3RFYOcEvjxNJvARvCU/P8W8EExlAlWCMit8iO87L00hizprNuZcd+YUgnOYtkcANByYB5QZk7ZviQdKSlnEZmHyQkPq/bAaB0M9fXIwd59NihKQtz6yN2iGowl1SJpAwyQKZLQpHKQbHv2478Szf/SZ+K+/99/wO7/zX2ZhcJ1ZM3CDBOdxBsgZTRt8EAls0dR6ICQFbU3zd7xPgUtvejMAgIjg0pvd1DZd0HRRdGG+bQVoeE4p0rRNBs2FXWVSAWa9kAzz0y9K7/zQE60+qrzUzVSS42ZWPqYVSTFnq/UOzEtXi53pNkatU4PPH47FMjglJU45xptgiyqCZAZmMPJYfO9j5MYSDtL59QnM4otTfV9XK6GpWeikyNJUsOw9Fh3ufmcftEilFQCxoUQGqPEcszogz52soO54m+w5gLm2toeKm7nJqCs4N4Izr2X49PXnXQycD2qBkjRhLwO6rAHKuqwzY2bx8SkC12c3k8Sp/EzAzL4C8nGhldM116oGOqtqGcnDkLvtvdb8DlpJaOZGOddpMUiuJV4DI5JY14Cnx72jK6DFOZXq65yE2whfrf5k7llKgCZjnoPApoqD4nYivyb6nkmMaR2sV5cA7etMuN44LgRltgTmYM0T8MKBWa3ue2uQJd8nTjKk+fwopU75j8A8PKsjtq3VVjRc8feOBGZF7kInDtKgnM2A21F+y1i6xvRgymAAtB8rWXTogf6e8DMrXvLzL8XNb/0LBZTrxPGR13oHrulxAwTn7luScjOw1CcBOjcqo2h0J6EMM983gKc87cF4z1XvwZv//I34pcv/XbolWpq3gzkX5SwDxDABczWVEpin4jJbf/OC6f77Jc3Pt7KMa8//JoIMxhybr7kQMJe2wAFZzbS9U7omDZiX7vnNkpHN6Clo87Rc4MEsE82HusbX0OcUIFxby92VAph8t6cIhs6bGPc8c551A8pe0tLz3c2EVuDAmcBo8Ch+u1c1YDdcjIJStyaj/EPhIEAftXlr+i2LVuygvoF0BIu1Zj7nRfIc1ICZrhgsBOMOLLDtZnfqJuxxApS7mXEDmE+wZYLyRvsjb5vbKTDenXitmrfrHOeMIQgSIcrkn4B51lpzShlIMno3X/aJF6cs2RPnGxAm9C0wBzivyCpv1bSyAWeyYSE4O4uWra/5dIlUKYoG60dTyYZgCpHY3o0AcZIPfk8AKNecm78I0N5kcSbtl9kWB+lFIYugNbG9yp1dp2nbfivvEP3IBsziNaxprTevhAGnpVC2Y+YMLYWHnDFjxHGCMmMtsoEBZMPM3Z/wUR+PX/y3P4+/uuKv8NH3uCve/a53F2D2odeRizwyA3iMcr+3AvqaHjdAcB47QPZ2bBNCQ6ekeWMZcJ8FPIjJ2KFA86YMmOAfHd/9fd9ksRwNWWMgmDNyovhHyZjLhkwB1nXVVN/zEThvW2LdPBcUmUI1yrGWv5X3StssYoKyy702u5uyEIfCgsLUGfPiBGwBltW3bGNUJ39MEdGWAhsjOEAn12E5wNQOwndbQHlqS+kXyc1jCjiLjznUZ0AUnMlmRfSHRYePokwDYSbrhRHQzB0suuzbTDDumxSvzMMugFzYM2AmPLJMVv4CgRm76djAmtHaBZwrMDd1Zj2Q21XyGhQsSanVpxzR2KtFbFdzNs3XoflxMrkQm5isYNY2KyjvNsdVC81ZKaEAFGCW+T2TkhDnRrPQsXBMc7DJgDz3IiQVft3ABNJTI+McDrQ7TPSyjsUUiUTAZa74asoQc5sH/2bjPW/Tmec+A7DPKM05bzX/+b4sJhRjIOxPNPqmRHyOOEgvArSOWshOdoq2KNrSHJjFy2ciQXrCLAZE+nwftuZ0CNpwoO7NCuHAfczub7b4rQLSmiBtYWbN4Fl8jTPWQp1Hu5KkrqAzYO+Jj/oOXHazm+Gym90MX/cVD8Qz/+9/nYyZ7wtQ9tGvzKoKdM3rvHYPvea3nHhc/8F5Z5eeujgXpYQym9uMeT6umz8N4MQCaBbE1p5V2PbSB0Crm1gUZVkhA8Jke68LMNfWNsenwLmw4gBjyrlRZMWyGZz6WYKof3fNEqE1oYLztK3iUOyGMeZdXb+uoYfZUQ0gB2ruL2gpirHK6kNzUymm27Y5XsSKzTQEQG8tpEJwZvM6vdr9eKjv5OkauI6M6IeDRDBmyWL7xdwX95SKm7jy1sRN27lTVZq1S+OJezERRO3s5tphbnZR62qr/zgDYPh9AM18qWGZVcGB2YWw1h2W3LesUoKRApTTNDnlxQkcfE5N4DoBK2veYwboZM+SN61M1JHngzXnCCfxBOLNz5PfIzHlUY+CdfoYBQMqa6w+r6BMpsnzkh0m5lxZfXxJsTxEBDbLcxYfc2MtbdvRjoy7lraNzXaAYM+RPEBxIji6I9Go11wDMOvS/HlD7sxl7Bg7Z8mLoO3InsmmkQAttk746zHfR7N178Mhnikj3e6f9hbsdwDoDtJd1bbGLgA9MDJgLP5ZHQurBGm9AXMVOsaGf+hZP4L73PNeeM9V78HP/PufTbN3JTcRVCplvqOMKkq/Pb66xw0RnDlBgCK4eF88MEikZE5oukdC6GpGyLvQraV4twA9UAG6gDLm+5yPGbCP7vcWpLfv2bo7LiQbqyylTKvPCcr+OVm4qJJBnwZnU6p3TbE0wbIBchMkEmtB/Lm4EsHgsAFGi3o1rQhAoXZgJzKB81KAeWmOX6Yd8J5JiZBnVIiBsWnmw3OypQ8IwXkM9NFcAPq+UhTKzfzPzQE6/Wt+PfQ7SwL0EXOOYLYKpHUS+CSrmzFwu8iTzZizWWoJPHBGbsKn/ineIKW07ATMHagtclNHfC6+IyYi+/oj24lYGTPbHpVRyxGw+SgJ/bnr/PcCylZxyrRSPfLbZEFV+39ZEPwaAVTHfBkTULuwruAcv0lzuy8c5XXw81QciqJR9zA92sPZTeABIik9TvmUJ2AWTAUFJxEiOdtsfUhcj0hR2jzaWidg9n7XgEUhOwV2GszZeoHsHKAbzdvMjW5+3gQ48dTVhrEMtD6grSHTaNJvPNRZc7DkZNDc55l+aQNqpmlJAWaYqdz3iNZ4rnjpL/4Czm5+4wLIW2BGeZ1K3KZ/r1hzzsnr+rhegzNlGzXIaXxhShPzd1nNqoWw1SOhW9lueIAodJFBf1NqVQD09j7rhW/JqXt8SiE7RVZKCxnWyg/zK4p2DSDZcm1F821tFrHFImprtsH3ZZU0TmrKpQBnsHSmOMm3xcOyn8maPb+ytcKaHaCXbNgJdFdB2rUC+mBZwo9CUc0HNYZCOnN9zX/duhgwd0Caoo+6+SPi+wjMTLcLn7MPELeAdetc9pVdB4PgDa2Ty5QT9R4uwKzOu/dtUwzDJw3rk0PVabt4SoiUiNVyQ6pnXcNwuGmc3RVg6gTUMsm2sOGDIsb8Z4BO9ixk0LHoXIynCQsM/Wdd59Q4i4Lh5iI5Wgh2Tnp0VFxM8KApyt96eSclNceObLmY5ZkGQfCDL4gpkmFsAHpMwCxlO1kRA+jpcuMKa+16pQ4J1oc/BujSB6ojF62nSumioYlrBJh4v1Oz4pfW2C+CtkP6n8XWk/iAig8wFWTm2o+qGEiCshFc7tuONGezDVq6yJYHVLtxZ3UOrR1h3o5bOADfW+HqAdnvf5Wh8VrR5AKk+bi2AH0DBGcKySOMcgBtDoKWKcEAJmp5mMEOM/utpSLH1bQQZ1pvwfHRdHv0xPH2tQvd91PnXl6TOhDYvEbFvwJzbQCr88W+x42BdM3wcBFWE0PU1EYhAKL2GzaOtnHGGMmWxUWKhEZQ2+JmNtcGdg26a67JC7ATY82bbaPEFzqZiLrQG21ARrcI7G6MlimefbiQZ73Agp0GzHCrgiAj7O19BGFj0IVJA7OyJsgbWcwn4oxCys3LQhC1Ve1RQrgqhQbNOLFnrTeW7IzKRzT3DWDbCMwni4zUybidlHUCVhPOsXlbCNaxE9cGgIMVJxsNX3QAsrPXKaR4WsBHZ0j1mH7c5KPDryg0SmQ0+gmlBj1/v8LgkV15o0jU3aU24GzAbAtGnM2FPuLuqiDvQOJqAWVjz1k6t8FOiX3KBM3FWvZLZbaIATMsiHDB5JGQPcFZILuGtmtoO7HWxIC6IWIzaI4X9f3aozKdWglNj7aGZjlkq6Xv6apj42MuzLkPMubudeZ7ADMAsMZ+4HAAdCqu9r4K0kVwR+8zScuLFaSnNXBtHjdEcMasz2t53lBAGsjsiKJpToMr5X5hA7w4BuM45n2WE/e73vRJSysy4KQWN39OTn1PeUg9kM2LvmorW46dCjfsOVyXXMej4KYU8cu1XsiM+fftTVGGT4s2rwWYyTwckCXQf8l+5z1Z9F6CSc97OtpiF94Z9zdjdGgbGF3A7e1ifDonA03CXsTDFbKl8fRSoQvy65KvxiZEBLdktHbcL5+YIb994jDFhH/hdpOjSnsPqrGT4g3Q+BuGRLxRVoHU7EdtDhbsT4F0bG9aTx55EdOMOwXONe2AZmw/lvp8C8JmBq6AHdHFwai9zKR/Nlax1HPkw2BZNI/tHTwmaEt55gtLlxlkI7CjBKuFS2YLzv6jNaAOm/FlIMzgJCjDK9jsJ2+ut0gnjtHm3uqny7xMdVTqMFHPc9OYLlqi++FWKr91ezGf814g+wbZNche0HbNQdqAeWkyx60QnDnvWMlpdVBGpj0FOA+3PA2PzBYPDlNF14FfftVP4Y4fegf8+I/9FB732O+xrVM1ATpM29pz6k5A7NaxCsqb98UHt0Bd5tSpeXbtHjdEcK5ghw1Aa64TLtRYN9FXDSrjJLcgewqoaz+9Xzf3eQvCBdmj6NLIRTRdDK7uxxBCH+VjId94vJWdJZhjAui6oMtYkWnG4lcJUG5h97fnYzEQJvA0FQ8Qa150IIFZZIniBgbCHmniW/exOhbInHdk0uLsGQHOwZwpAL0Yt7bu7opu0fTOOmycNCeMuu9KzMLColEiZt6mLkFMZF9dIIrCmn0uVGBm0HDjZ1w2Vwt0vmY7qMHHeDCmipSI034UYD4AOKhn6Whpw9MNHKDZTgJ0mayxtgpynGQO7URvTeqEw6485zxgnrwhlAjvZ2HLQj91y5sQn59V7bIKYtErNJRbuwr1tT7ivYJIhvRWIi+D0ZdWcoOTpqodx9zaLNoyzvzKXPcWwcxIa3vuc5XMuSVA21LmbnEO1uDpyBE4TwHmFaAXA2OlR2IHW1/72pqB875BdgvafkkG7alVS8v0SlPsDZxlKKQrZOV4oARscqlya1iNWhL0PQ8M7PY73PFD7wARwT/6ovvh2x7z/RjaLQpcm/ubJQhBlcM27gRmCRmfc7uCcZnb8ab6fPukzrlretwAwZnBeFV8xDHBxSfBhdI3k8GqyyaZQLYKzqNjlDaBsJtRojA0ju3hHv/CClsnWS8u8Fm/rukE6oMK/Slys7U+FsJDIgDk2MVrCs9XRGlSrqcWJ5grALFUnzAYinSdflXuBOT1pKPt2FeAlpk5t2TOCmPMUFPFbR/lSh0EghWTVqMmMBbn3i0EDdxUNxclATAF/c5zQKOvwAxNS45PD4g4RjYckVf1ecNqkK2bCT2uFyn7LRBYgYNCzgN6Xh2kdQbpAOjSis8zGB0XVp1/1yhbjidZAKpPNBaIlRLtTCUp0n8icMmZdI3Giw0a7Lc07idPU2LtH19DjlkVrXacioH6+Vibf3sOXKzgLDN1jbaZHVuBEYqtuGwSW0PwdQXAnUITQNd9chZ1QKQ9gqdSTq9eQpizCcx+TEDWnUAdkHXfgDMDZQPoBbI3cG67BbI4OC8tUivtJ9QVd2fPa1kEoIzVmOfD5zYBujLngYHDecXlL/+P+JRP/Vj8i6c9B0PPoKNDdUWka2E2WxNcVVMhQGjWunnf8VyZHhec+0Sca/O4AYJzbEGLY4A+AueSLVLqs0+gx/B6VZkCKU+5KOJY8viIJQdII4G6ADMqMMM/0+bXphiTbQwPFY6NsmEfzL6C9LYKUAAzX0dZSzyHZSYDufVmgrEu/lqzPEiCMT1iUhKUhXS9JRDLUsF5B1kWyLJzn/MSPugEaF6HXbiK+/G0Q4edWORPIxfwUI20M4X6/baUjybDhEwVbiB4kOXl/FMAu7bDv/mGn8O5s4vx4J/8YvzNemUqTyGkEezMz9YUCjfJa1OMbqkqo2tk3ujOhNtYFG1xgA4FSovZEF4hUoHzCrlKrebFeYVOLJrvd1DudYKXxouLhxwLrRmJpiZlQkkFbKl9ZcoE5ubKkE/UU8c+AFom9bz+CxC7kI4FWjR31cgMjptq96MV4aFpU75Q7mGkLyD1k7qmJ3AuKZwqLpMaMAak25aM0pmiaE6OhmbMeIwjx8F8XNizz2FmYUCkrHtJX/NO5raXAGXrDZCxXyBnC2S/C/bcliXB2eN4uLNd1m3RULg47ykLa+pq1sxGrBLGYg8deOBXfTd67+ijQ/XMgZnMeZ1usSnI6hoI5zEng9+YOi/qbTrJluubtmB8bUH3BgjOuropFScAuoCzu7S4L/hUa76C3ZHrbQvQZRJME4Lno/m54+gxKcWP1PyCm3stW3DmF28Yt1wDSMfXSh6fDIIrhEfL707zlNfNRd24oExeaVHX1QWWOjhbwY36A0W8VMbcLDdD2g6y7BykdxNwawVo1/wttihvMpmzsMCGX1BmqTAPGmFeo+mTBUOGpC8vyjKXWyWbdfb193o0PuXO9wIAPPqzn4InvORb3ZVtgsluo+b8CIAGohShKMRzk2UxQJVlYCzN89ngkbXGKjyByoTcAL7lH3wm/q+7/kO87E/+C77y3/9LqxJ5lQE1TjHpaUcXnc1CMcHLHLi2wkVQuGwJeENJo5OM2M85KQHKDIwzLMwbIPStIF9TlPmat9jG3J8YW1a/9wnaInxvCRRzK8kM0KNQVjE/w9JmYI54AIL0ZtLUE63lJBvvg0+sLoA7gmTqHXhH7G22yRzPLIpMdXTA9HMSnueCTEckQO8Fg8DsrFnPFmPMZwtwtjNg9tZ2i/mel8UzGxpVcNdl7JrEMyki8G7AvRxalGsUF1FWAzO/tPNnHRgMEdPVfc1kzil3c5GRNXtwqMugZNAVLU5M7yNFNP5wtdP/wo8bKDijOSBLAeii+JLFRDrnpmpeTUdkrtSRmdG1XVr+bEIEf8m+ThQXnMF4J7MyF3HGj0LBQFZbTPV1Ld+z6ae9CQowB2mbTrD8Eci8a4Kyt/hpcSBmoJdgTjmrdrRS1QvNA5loxoYX3QjK7n7IMGWXdgTQOwfo5mAtIVzggBV0XkuBDfh7PMp5uFLUmpXxNMeyC23X0k3zN3EYuooLcMvdzlQcMqDX/tGrw3z22j9+FXz7nYxTct5epUho99CoF2y+bgfpZWTJxOZAXebMiO80pvW4T/hs3OTcxfiSD787vvI9muz5vPpGSFo2nN+A8wTSKCAtpS+TuwL2RohteUW8ntgH4XNibG1keq0ok+W1I6USOV8JzHmqOgvu+gZ1SFYDZhPTI05KBMbMmyYwN0Xs/7zwmM8J0kpzS7lQHxlFjukQiI+7NIV0Ac35djYzQDcMTwMlg27I4q9zfPwilgJoMZbpakqztsdrOFvG2YKfu/w/4uY3/0D86x/5l3jOv3su9Izs2YGZrDnA2Rn00gyYXaliuipZM4WxyU3FKNauKUCtyB5alWb+3KHKZoo+Tdq5tBLQJ0GsLSfAJPD4/BqA+sIvXofHDRGcDziSCBxq3h8GXVW2WUvezuVtJdMSCc4BzHIcM8P7y98miHJxE0gFiBQGCh1BnrxrlUIQp/DiBfF7K9hvmHkAMT/X8lxSOJW2GTPdHCfeSwQ9NfF9s/36htA0aayT4DyapNkJ5vu1BWWgrEi2TMZswLw3YG47SNsbk247aPiknXF71SKl0IyQcSuwIWipHNBS4ayTAWQcMBWrLsRoaQXNnZq54qHspc+dY/6bf/gKfMYTPhT7s3P48yveZAFu/A1ysgCGbFbVyJgQ2fNoA0MGBkGZ1WDqZinuX2+wsocyFD/3B/8FX/0xn4TX/+83Ae+h7xnAVTDT9gEG2AeauTnnKzD7udUiDXXyXBCUY5aU5wDDK2Mc/LyFFoUAZb/W6DHllucx1w9vhgnywD0/Rzt1dWtJGfOpGpSmfFAuG3VTeXO2LKlEE3jDktEKMA8/9ucEwQjWSC1iclGRNQtg2QQKoOEf3vOeuHh/Di/++Z+3majDgiybGDALmXKauTM2XrGIOLGX8DkLXU1kzl4vQHeCD/6wO+EDP/BWAIB/9Hn3x/N/7vkGyvsFerYz03Yw5/0Mzm1Ba+aKaCLz+uDEH7B69i7bRq0vsSUHsPub/xycNVkzrXF5a8s9djbFtMqIZfeAz80PpcDczm+cOv67f1y/wfl8OcaM05MJi0yYTLnu1hZNzM9XAJD7fU5ArZg0Nv5WgCGKglZ9zV0SlEv4qC1YiQUbdWr9IUAi5UlzOULoSPmQwLVld5edBOitolF+xvSF460cKxibb9akrDFqB+ZmwDwcmK2MHz1jJVy8sOQwabc9ZNk7eBOgaf5mAJkUszrP2G/uWKHNBKHSXFhMKEO8Oq/YuRkHCcO2gbPfY4s6BWSIpYiEv53swMb6f7/jzV7msMV456124BrG1Gh+MWYXnjU7L/FdeNqAeEvmBlf67HqGapzfN/70c/HgFzwLup63zY8O6iZtAFfhaAvhZNDbuVSA+RRzvpaNO28zTSqqjctA1hnI4hVNeL3+Ht/tKF5rA1Oe7gag85fTbSHE41EvR0PBrvN/EtMeBSlNTKmM/VFbmrSjitbYuFl0BvTqR1IXDJw3CyyKuSmY1PyAz/lc/OTTfwAign/+hCfgR37sx5yNjtTvm2AJ/7PGlinWFyLvzLnRRZDUOgv67AR/+qf/A7//e/8Zd/yQO+PHn/tD2O0b9MzN2t7kbAeQNe93kN3efM4Bzg0NCc7oCPmmQ21Z+hxmYbWwjCB7V7G8Z61srxem3VXS2ZQd0d8YJmNCgFdfnQvCYFLXxJTfNx7Xf3D2wY1oS+RrlTmTmUaZW/YHmRn0Cq+6hAmYUZkzF7hPlADilr8FgWvGMq1RAwqZGFVMaJYUjSCicj2nALq+Xt9fCI8Ayd7LZyOzI8xJZumNr1WJ9Fged6BoHiaGA5zFQHkMwWgNw8F5oGHIgrrhw1RyiG3ZO1uujQBtwKwlKVv8vC2NitpUln5Uzonq2/CLHwQMpafMPiOeamFVzdRAucE20hgmm2OnvcnC4Xxb4cVuQoxYU08rCQanofGrlhKGMtCdRXUy52BxSHCmMqFI/x6DyNwqJA7Ieh7JpCtATzEXugFm9pJSMFqdlATjVOuozklshbg4KHcw013c9Erm3ByIW+sFlAfaYoOeAD0mcA7zp1BAu1LJ8R0EZLMyhG83TtcWygTQklNcuJnItrwlGfQOXklLCkATGZ22BjgLIjG+BIOG1QCK2936tmDk+u0+6IMgyw6iA00HmnZIYc+p6o5kzpLJDGaBNyWj1Zq7BZjVUxO/5WFfDj3bY5ydYXdunz5n9zdbQJiz590ebbdDazu0ZTFglgbR5in4Kdu418Cg3KuypojE+VGQNzSZDsWKo2IiVSBGPtgIICcwp995S9ULSJ86j2v12v93j+s3OF8FE0xyYtiqPCmAVGrrWwDGxsSttdoSzdzDjwsYqoPz9JOjPOEC79M7QJ9lgPIQ12qLH0akmAmT+B0BcmUBm9+FBsa7ooBcHGVu8msaUh6HiFWg01QVCb02DpZP6aAmxjICoLWho9nexQ7MQ4uOX5izsWcDYyz7OGaD7CBi1aWE4EzwBaBq1aXShJUDoKoQZ6dTeGjRqodalTAdEtq/CkulOCjzPrq8Za7yVnmq9SnCcqcw1u0AXc3HqfXnVnji7FnEyhkmY0QQMARmGtCMonjSZaN1d8ICzHPBEpxgz2UiVNPQ5MBNjVeONEafPWIAPYOyg7FHZVt1UgNnA+YVbVm975DWIexZS1YMoNVzIqe9fZX33IZZYrMTw/UAaMoD0VhbsYSq/A4/rWa/oJS3FAfogooBhKlIxrxk6lRPZStPQPGM5z8XH3Sr2+CSs3P49qd9H5a2t2vXbqZt7W6uFo+PYGCYAzRPoSWDjip3dAX5OQ7PadadBYONfUM7s6Cw4cFgFiBG5rw4a96hLWblarKgiQO0ShRQIfIyyCss/AVO0+smJchS/T9jQOqbWKjvq6zxLZyTZBgdLB2rtJ9vo1wnUMZ78fi7BWbgeg7OuArzwkIxWGwVfi7ICASTBGk3a2sIrARojVxemUzbgWyUYVs1UMiPtTz3w4nMkTmLMyVbzze65Mb4gEs/AH/2F3+aQLsF5Cov6wAUM7YAs/urKo1SvkqR5Sh9GNKHxGu3IIxF7XhoKxG1Xh9bK2teDKDrLkviJYiaga64n1lo2m57iOzRmu1rPAjO2KE5E8+Vb4OoaiFcdDdYG77AF8hY3OSVAK0qkNGMHXv1EIvlMnM9BUfrxsvbqTFDurzFg81YjGGBoqk6MPN96vebzM5M21Ez2FkowXlO54EpPy7gqEwxACeCHldAVzE3jW8hPAH1EXOugEXFATmpYzF5r1W0zsAshY4LVhiErCUSW92yIJnuI2bWbm1AlhWNwLz06KUNyELmbE194NXHq9EC4eMsqr4bko+zm34qizPXRy5g8zsX9uz4qkwuXjSzBIiGO/G9PcRN3M0CF5nHX4GCzJnaWzxsXEUVj/m+70dbOxqBudFczOMOBq7PTa32vWiyZwfmCAjz89YFaF6AZOwFshO0vWDsDJCbR26b7zkLkLA1X6sE5wZjzgTaD7rFLfBn//ttYcXn/KF+13yqTR6nOC5CjUA7FQ9x4D4OhUvFe1LST4HyRlBfI/D+3QMzcD0H58mszdeQB1Lu86Tcb2sRO4NWMmlnzcGYCc5aeoVpcor5Xg+eD8+ksGD14yJUaZIUjwYVAT7kgz4Y/+Wn/hCtNTzuXz0Kz3zB9yc4b4BZyryZfN20INcBm56Uue7ALE0i40sgZpUPP5L4WBhAt+RD9mPOEkbzcBVnzZb2UL1ix5X0DZgdkNsO6gAtskcT7nG8YOiC5sAa6VG+H134immL7wuOdnaqW42VXSrGEGcmNkBD+FzTqoAp6SYVJgJjsGaNzBrui91UoyiDVOZc2LPtymO/0ieJhdBFlo1iwN2/RE3ZjC35IoZCDKgP9poeJF4PpZTz/KTyp0URPZ6AcgTMzXrxNAqPmhdfD83N202ap+DAt+Y0cF5aN+a8HNCWFW23Gjgv1ts+w8P3oDaANn99ugfG0KKwaMRdjG73hscQX3+icX3mptFcR2EC0dkcEjTV+1okhwV0mI3gHxAt844R3TGXFFKrt43FrtdL1cloAcyRvzxmcF4w5rTrxvhJiW0fyexrbrN4G16qc+zd3L1vUSEMO8t3ll0zUzb9zbKgwdYkJcIPfv1DcOubXYY/ectb8Oh//WNFbimnfRSCElemq2wTZWwG6XdPYRUTlIp2Q2y/GqyEmtXGpTABNcrx/3+A99o8rtfgjPMIMKxDLP5CalsIYA4WuGHIeSzz32KDXqRpO4Jk/NcI0MSpkWckfnZTT4G+pGDP9BHFJ374J2FZLIn+3ne7H/7Nc55RBOXc6nVrOQedJnx90+YrfB2MxTRsKzstEdMhNGW74F8coNuQWJBZQcmjs93PbOBsRjeatKvP2ZgzgXkHXXbOmlmLeReAPnSHpg3DtyEzwFSEX0/hfuLhtbUXA+huoCwOyspKTH49seejA34QGh9DgaQ/k3e1gJiVKNzUFya5UvVNfwyU2yB7BmJzCuVh8VF7C5buPlqFM3ifSaZYibscBLFn7upzdwLiBGQzgTsob03bnBQxocoiCkYzabqYYWKd1LaIyBYD8+Y+yhgnWhxax+Js2YD54OBsTBq7HgBtzNn2qVZRdwjkXsChBA2gRkUPQZSjBftqxodHbAvZsyvMtJAG+5SZOZM1V3BunOcO0NwWtPt6KcNqk6CCswFzlLdtbsFicFcvYQg+Z208x1wL348l2LNEdbDhUdu8hgBoN3NzNzjsGsSvsS3NKoM1a4Lm/xawdv4H3vQDAAAfdPObo+ni8kWjSiONH1NgJQlAyLgRinMKqTa3sBdsTNgB1EAC8/Xzcf0G56uQkYHlofWgambBghHCbGbSFNaYmGKatUNa+g8c3/iaRhDvcqEWubJNXbAT19QXnvU/+5IX4ss++yvxQbe6Hb71iQ9GO+9a5gZZeZ3RU1GkGYsAU99YjgOYXaHg9pudl+YLRAnOw1jmouIBIAbQgEVsajPppWLR2aMtG9a8QEE/MpnxHuopU2TOFbwHvCq/m8Ztb2NkqgyGn6tdjI5mm7n35uBrAlFX8dcrQCMxhkqI3zUZLgcUxjrq2FfhssBN2lKA2XNQNQHahBLjDDRMyDq4846zhjKrQg90YLbMMMlgGgIz/X2j2W5XvSgeqz9f8/mklE7Xv23lmictl2exZc3u5nB0y1A7RmozgMjM2pbyo1iaYlmGA/SKtusBzm1ZITtvSze/c+sFnI05D80I9jEUnSbtsHIqB83M20BmHlQzvr9eLaQTY97k9qeD14F557n7EzjvEPt2szpaAR7pajEnY0C6+dgNgVegVE3LMqczD0wlCOE64JanseuoKxTiec5tR6D203ND1vAdp4xVI5QRWTy4zJuIQ7MyUtvq5//bX/0V3OfjPwEvftVvoA0xi0XUjrByndVVlgDtr6lit+zwE8/+EogAX/llz8eVK2d8m6/aFYKkQVUubwjU1G8fgvLm95nH9RuczyOCsI6GfQNC4QBxkJ4BuvaSQFyZczBo3nTvmQewYc+GHkDke8LNbQ7OwgIE1Gwj99MA+sse9Pkh2BYQYCUEZlVAYp0XcKZwqab9aj6aqqA1W0TG3iWEVmieBaCbCsawRSlqCxQudIEGtOJf9iCwZM6+t6/sjTWDvqvKonfxt+Fb5oguEF0wxuIjIoA4sAkHwS96OAD3AkoOSBYwleCkVRnj3EDqJbFBATFpo/FLV8iSAjB8zcLYIQfoYWbt6neuQYrBnIt8qBg5JKAvcGI4QBKgxU3z0iUVlGodCGDGPNevDqDrQgrWzMEQZBpAbQhQhhCUh5k/ZXHWnD7npTk4t45lGc6eVwdpN207g5ZdBxygCc5Wj3kka1bb/7cCc7VsMpCPU1xh661eM62ilTFLMyXpCJjrxi21Ne616OjX3L3SW8qRIeB+yuiklQTm7sC8TsMbmR+cq349NtbNxxsMA4kc52nzi7S2m3JJIJ4AuTQCfFj3NjCp2V722tfhZb/+Oisf28UtS/BAXAljizhI05qZ8TeCb33Up+Mz7vmhAIBvf8J98Lhve2lRZigHs2eWxWxG5Ep+X4Xea35c78H5lFkbwIYtlhtLkN4y4sKWp3YEzHWlI1c7ioIwEOkRdi56sjUCtGjUwQ0tGISh6rP2X3Gz45YQx+kVoXLCVTiBjbomPVzoBDBn8iFUgcUBuqlryyoQ+psY/EJVvOQ0E5TVzdnim8WK7NFQGDIjstviDMsKEgosoIyFpUWb6T0iGLBa2KNqJwPOHuFsGZFiJFO6HI7ZY51EVQgq0l1BgdJNsLkMPTJpNzhAe6vMmYKIaT5CYNa4teHrdruEsRORIqfJVhyyY662olzO5vvZlI95/td5MbHmOggE5VHOghEKCc6IuctWWTMjtcX9ogTnYW0x8/birDkBugc4q5u3hwO07WBUgJnmbI90V1H81s/+EW5zq9vhu575OPzAj3/frE4MNWsKFT1Mi3BGpLjRG9vxUTlab4yzUEc9rXZn3mDFlKcnPlkDZbfnUzRtN41JmOLq+3V+vvWbB/hqBrzViRuKiYJut6rhh384dqDCBL6xKcuarwnLJ/N9Uc4059zrXvsm6DfafXjtb7wRWR8gFcWlNdz+DrfAH//xm8r8zCVr/fURkvNx/QbnAwKct4/UpKhdIUG6BnedaiXtQbUIPgdlqWo4/DfKLwvPYLiQEjJni8hs9EG2EWmsXDu2ljwPFACThiQm5tQdA7Mgdzty1jcFxrmMrW7D4Xm7RjxT2eDmAszaJSjbVnWLR08bgEps7xdZl4A4WyZ7gIOz7NCwg5m491A4W/b3JzBbII3Qv60WsGbOQ43RAeBuOzJS9UqeWRGLIH1cFa60spaF/3PHXqRY02fmvj8JWetmRFD2aZCiAGfKTypGavdhK2sVpgyNwpYNG7bgLNmr+9WdRWudz1ulc3qecyInk+YxTTNhrhmFj7ARoBMHsAVmeFQvWrJmKjMOzrtlOIMuAL3rkN2Ktl8BN23r0qGLM+c20GD7/obiO5mzgTvf4cNxu9v8PQDA13zxg/CDz/k+W1U6C/O4RF+HxwG/XKCt9GE3TlM2gVmcPWNvduPYja1oc5V2kmKWeptalGSDm42WLf5qMbtkzXa4i0tK0R7k2PC5A7ROFek0Jqx6vIDC0+RqEYggNpisM1noSeesmADt8hlfh4wT+JXL/xCf8cn/Cr0P/NH/eFv8XshQDLzxz/8lLrvsRnjpz/82vugfPSHmm4aGW4FZrwGs3zdB/PoNzisuCM5bE8dRCtSWFU/A3OZeiynKy8dJtZGpBDyLRREhyhGOAs7ilabUqkE1RfqIZBQh7J9HAnT4nGG/Ny1TyX64zGCgUSicZT1V1qQdrtBL7HqkLCpCcJbKg7J4YIOzISwQZC6y1IhsBoCBKVHOnB2cBTsoAdrZtsDMn8MBqsMDYoI9akjToVnKsrm/MdJnfC9Z9c3eWVda+txHcBdBEggBHWRkpFydQHkja12kBgFpDArzKOLGdCoH5lFAUSkTkT2BeGLOWqCQNtjiew6F8kjhRLEY4RiYC3s5qQXGAd8cQzUdTKxZvOCLbwEZ/uZi1m6VPS/dQHrpYeImQMvOAsOwDOjipU6bF5UJFocAGnU3w5+8+Q34nT/4Ldz5g/8+nvHs77aa5Qrzo/p4cttfU8rEgVkcpIW0Mdt2O8nYID0VUVsDe0CLidsDxKySOwJcDfy8GlaNEOWoU3tAKbwC5skvsJQyt5TLmJV191fHVJmaf1eM2XBgrw7hjC0wV1WPtEr1dDztWtwnyII4q0L9mO0oU4bgXpTr//XHb0Nfh6WOae44B1hU+s1udikA4G6f+GGuMLAYUYL0Rkpifpx67X3rcf0G5wOQ4bUnHmS2hUFPNHPI5rhlrxWYN8d1kZ6IBqSfmcl8NVJVZBj7rL14MXsHaV9DYHhSmrYFadIuU6/oG+JvGW4XZVDT8F4KQKubZrVLpFIdmbYJ1OD+yB6h6eUvDVxpik4GLC1N1nAfcoA00twXAWNKNs086WTLosy91mBlUGdlaqyp6cAYI1NSOptmXzZ9CICmSc61mBqUlQE2KPEB/hojYF1OT3FCILh6MJiqM2eNNJJQlIrs4EZFCcC89xfoNZXE2D/b56po8xze0wAtykAoTh6uE66d8lzrH7agnP+nIgnYnEcF5hIwFjsmeVskwXnnKVW78D93A+elF3A29my1yOtGID6IneBFhUfxBQ/7JPQDsK7lPo68fwwAPF7PoXb7KqwgfcKJS6sRXBHVPaiQ5t/4uTrYQT9LalD+NUB5+udx6qJW7MffNSCTZ2qrW9hU4ecMlAePHZg1ERPidHdoQ1Pb7W1wLnVF6w1jbZBVIAdEzQg9AGNV6AFHAB17GExxD1wfnloWBUaMigusIMvQA37wGS/F5/+ju+Ix//xZ/LDNO4wJkKXw5Rms3/cf7x/gvF1PBON4LtlfsNGuWwG52n5qL5h5jR26pdWBY+NzGx4YE8EwYmX5hOY9RXMAL6U2AqRBgNacWsFhfJ1Q4A2aXV1WDXWz9UBWuLMoIzOrlksz5i3JoFuy6CEJytqc5YoVFhFZ0CLq2hjDt3/jY3HvT/5M/NjPPg//9hdejGTPO4gmODMSW31zjBEAjQiW6oAH2mqMLxev6sAYpmG30TF6N1t9H9DeIQ7U2ocfF2DuFAYJiFl6s7gcwsWos7tRZrfE5EZkT1Y+sieQNM//nAoyINlxmWHliEqh/7W6WbbaWiifKEoo8n0bBWGaWCeEmOlGozzZvo+xFqwzZ8AcKVSE6QrOG7/zbvI/DytGsrMcZ1k6dOfM2TcK6bwIJTCTQGtaaIe5PdqAK6JOUHmtvn6rp0riyqqAmRCuyI6lNPcxj1RIoXsw68BavV9WjEYIRJBkporCkKMWGrKm3LR3E7hNqbgSFQFw8b+8YwTjMX1fjxag6C6TsOO5wpMKcIOsDeL59DiIA7JiHIDhQE1Qjr4XWcTFruxHMGYraNMheoDgANEVj3/Mc/G4Rz8LQ8+jFr9RzRKyWyYNaLmnp+bu+9bj+g3OHVc/thWkK4veMugLAXEsOr5Grdc/w4XKaE9UtjsSmA1ubKKRKUsP894i4sDsxQQgwcJSUKf+hzLVaMypLsRJ6DiDHrwE9UsYMCWejGGDMsPTJeAbAKhvDYfWfGMLK8PZPKqEdbCZr4y2x/3v/QUQEfyzBzwQL3z5yzJCG4uBcwgyB+exQIexZlVBV6/p7WbgHr5QAjPBeTUwHivG6EcAjd4nkJYxCmseoa03LaAMB2mCyJgBWZiqUkAmlbEN+53AuZhfHU/EryveF3N3O5fz/ueDc6+CBTbHOA3E21bXB1/QzYlME2irFyss5kCR+3yxXI330sJ/nhXCrFmFq5HR2w7SrXWvIDacNRs4tzayYIsDGDPtl8XS09ogUy6MmRZjz4xgzJQSoOuVHY3nVpk/0aqJW1IJlb4Hi+KctT1uduOL8Rdve1eZz76Tm/9eboNY4dj/6Q7c5bhhuITRYl2CQzbnpb34Iz/9Otz8A2+DZ/3Yd+Illz8nvtcK4bBkpq0d1Q4Z5iC2Iig2FM0VS3XlV1cH51UgB4lKdGTOY0W0Y4CWTeyHK9/KGJ2eDStEV+8PUD/OPX8rKI8qHacJnmB9bR/HkP538bj+g/NJn/MsMibBFoFdW7N1BWUC8jIfO0Dnbr/hpA32HDRIE5jFgblJd1bc3QgmURGwwc17YGr/CBZWFxdiuWWd2upK9K1hN0zeGkvmkeJZJUY5ChIxU5+4mduqE0HFQNl9zVvfGvOVddlbMZG2xx//2RvxIR90B/zG7/0O2t78y83N2uIMQtSElY4sYKJdgvl0Z5sR7BXOdAfm0aFc9S4BxlghAc7eiqmbpm8DZgNo1r8mKIffuIBvEw2QXuprgikYLO6Zsq9mcxTfLtv8PLGxImaZzBcC7i3AngRproPN++rnTgKzpj8evuO1DmeYqSoSmAngIlk9ynzm/m87rlN+7jCQFoLziM0xogBJG7bTEc0RmlXCGuyl5oAcxTjkuMWjyF8qRwzGyoBKasC1ubmpE/VTTqSPuTDpvuAWl9wYb/pX347d0vDE51+Opz7vV4DhOfrMOFCg7rg03HWj3hKgFT2IgN9AVb8Lza1Adk0f9uEfjVve+nYAgM/53K/Gi17+7Pw+3ytZB1sHOiu80YXCqaoYY6D1BdqbgfOhQQ4wcC4+5+Eg3dcC1J7WWNlzYqivG1e+A6DRE5hxgGBFw4pxFOGZQK0B0Fv/c6U41/ZRJ8s1fW6DP+8lsF//wXk7DtNDsq+hlyXyegZrsuPjtKBkzUu+F6XoApz1iAtjl8JmlukWGKPNgZkRzz1Sb1hRyoCaMdAm+LgJQ73HIeMhlkriCqiIATRXUgTaUo5tLfTFUWrDMElNY9Ce09nUS+3LZqwYad32UBYSWfb4ksc/FK1ZCc62nFmPxQBaFzOVaQbIQGk+zxIXooqHftV98a53XYUfe+GvevlL9ys7W8bogB6gY4WMFdJXtGHPta/Q0SHdgFxGAnTdLaoND3cLgPazEgfqMiwzYKc5e0qBc2Degh9TpyZsrgxJkwVOb9QcawABAABJREFU//j6NAPgf0PeZB7yLVUBiNdw/Byln471+G8A744fS1mGCdRCs40rsmGml61662Merh0PkJQEavHduphypJ5DjZYBUmHdYJyA0Bikk981+nIFyCVD/XdWcKZAOn/eefNDo/W1sSBSq2pB67EAfYePv8Pfw363AAA++xPugqf85Ct9ToqXx63gXABZjSt3ZjIUxd82G2ll3pgcqTts/sEf/C7++L//Pm57+w/B81/4g1hVvXqXxWvoGKbs9ga0NQSJqERQ64CijY42dtDeMPqCtoqDs8TGK2TOWvRm6svaEYYvlB6UUcGeU342tZ2pxFvDAcNBOsLBI9os0f7CAF0juOsiuDaPqwWdv7XH9Rucq3yIx/YF2QidAspHKLUF410+n45PUM38AQCai4a786jVFL7koovxkz/9TFz5N3+Dh3zVP4OMmnKopY/aWyZENK+sTjWKP9+dEp2CpTYudkkWYAEwkpcxOU0drBevN63J4xv9zWUjC8XOWDPTSHx3KW4D2bzQyOIpVFbAxCKyMSxXF8hCJ7krluIhX/MP8VUP+CwAwBXvfBd++sWv8fKcZM3GnNXBmE6u0YstzVmADJcODtLmoy7pbdUsitjgElH1awPMUTBKqhI1C/3I0YybsGFFqkfgbGbG9C3amfixkh9ldCrcLJkAXXsk4gQIb8Aa9T0b1K5M+nhlYV6EZM2umMILpSQsF/ac4zRtr4m8B74jOMQBW7KUFLg5SHNgHlqyIoDwvVIIA5v7svn/nG5Y1jPznxUbUEZFf0QZWRTAblVOEJwX/NJ/+mO85LV/gA+/7S3w4B94CawOPKu7AdrVa8TvHDDJnDuG2jaSw1vH8HEZcQFU2LjpijW7l9/wtZ8FnAn0XLPm22nqcBO1T2ilq04RQZBMZWq6oPWO1hdIbw7O2aZd/laY77no0WxaKzYG27C51sr8b76ncwt7uDFmwSFA+hRzngF6bAD6wvM6Z8h7x3j/th7vh+DMh/9BeVxB+QIAfQTKu+NjHAO0MOoCMI2PrBkVmG2Xnu/+vsfjnvf+NADANz78IfjR7/9Xzpi9VIcq6Mklg65+zCpvc/pJsLWYU3550ZS9RGRqRA3zUlwwhQlPgbGYiLWobYvWtoL8ZpLWauJ2v7O1M2PNi5XlXJw1L767VBstTZ7+W+rpHgpExafDe87HHT285z1Y+mpCZHQsncC8TgAt4wAZhwDqrVQQmrTdVGg9WbP1YSeRNG8v7AnSUI8XKLI67lMyXYIxHISNNmgI2IExHYfZ0j2K9hzIXaLTqUEQT6FcnNkX7NlVMOZaKQcFmAWnjufiIzR8Jvxq/D3eGWmHNY8fZY5vAil57EyK5yya72OAYEbaayizqSTlpYWbOi43gWhqpPZMgxC43wgFlDfyRAswT+BcfNK94Quf9FPA2rzeyBL5wKxBrd038XBgFjc9k0127RDsQHRTmHl/qMmQEeA8MgixNPVUQwNlsbZ21BRKChkrlESW3tHGgjYIzOZvToDG0Ta8wzF1BuZYBvk7fm+aK6mi9KRbj8qSvWnpx8nqQrk2GLmdjPmaIPhvkyFfd6B/PwPnE6yZjwrKEMyO1gK4E1POvNxjcE5um4IGDswULO4rcWBuWPGff+v1+Cdfazfq93/n9WbmlWTMrESd9bEYToNJZhrDyvUWV0pgVgOQyH1moybsGIGWi5BM2grkZxQwQ6RUvBA/d4NxZUZhrFmimMg+Ire525Qx5wWLVxULgG4S9cgLxIAVn573/Jfhir/6a/z1u67EL/3ibxggl9boY3ZQbgWQh/fi4I3hgSUjhVyjWRvD6mCDOcoepKTIkpxgXAAskA/F2AAzp4bftQKdbkzP4UfUCZx7mC3dB4gFgx5FZVQtf6GkuzizCF+bDnzP93w1vvmbPx+ve90f4lPu8Q3HIE0tr5zj9ChPBVcvWGyWDMxgnel/Nebc/JfzSg2QdnDd2PzT+qBq7oyoTW/SXEh7QxPCieNyTaeAOJpPRF7HFNNSAXp7BcjFVoMrWc3Eo6+F/unegLUVa+wom5JobOAyhm15OoYFUYrvXSy68yj1BGi4gmkADbcIAXCAnsrGkqGv6j58ikhJncxz+6TV+BkH5tHQApwFsgoazdp117Oukxl7DD8NmrM55igKmqYFZbZ9c44nSBOcB1Y0dIyT1YXshypzrqD8gbe4Bd7+l2/HGJSk1x1IrxnIb/DgzMfx0p+Opy3GNszZ6zlHnmLkK1ovUVSjsmf+BoFZ4bXpEPvaiu1r+8Ln/Dx+/z+/Hv383+CNf/jfsZPFTaZkzFn0shGgtRTe0Lx0Gmu6Xxu1wSqTuNvdBNIO4CxWYtq+xEIp8cYhYETcHzaaRVWXQDlW88IWoKNZetUS/3xnG6UP0q4p/avw3YVsNb/4Rb+Gde1Y+oD2FWPtZlYbK1pf0Tbs2Zhz8TsrTdprBJo07R4INgpbLj1YH9tN2Jqm7YlJo/icp9lWWGoAtGlBacZO02QAs/cDDV3XNPFjocoSytmU9uJFLCnEHvjAe2FZFtztbncJihL+tQmgJwqJBO06l7crK03Fhr9bEC7HijBlJ+jZ50qg9QZcZ7DV2GXKmtrG26CvOSxDVDKrH7NafGfr7wlQliRbPNUL6fuyeUMNFqvipbLqEkhmW3uKlZhd1YC6wyra9QbtCyxIbGf5+54uaNkNNl/ImE1aeLS6m52H2pg1v2ZbSwh8U4KmKwXqri1LocIMziVnvXmsSPP67a03tC7hbzagxlzCswPcmUqV03G2VgRrpgzLk+AFZPwOuF94L2x5xZDVTP8bk7bN1wTo+sM/8AP/Ag/75m/ClVdeiZvd7BY4f/58ucl6YgJc0+Nvj21fv8F5khtXw5onsSmYWfSWPW/r4e43bcugHeX8ZwxEWXjBqv0IGyx95A9+74+xkwP2souAo0XGBM5sVqiEEZMAxP1JIpH/y7EIQD7RhoN0smg3X4c524+nsU2AVhFw28WTuZ0E6ZouJeZrbrIzc7YUcFZJchE/aNc2HJi7WoAKhrHk0Vf3dTkoB0AfCnteA5wzXNQZtIeHivYwZy+aAG3MGfP4w9mzM+ambtJWjwtwdp3xAWR/HEYH5uoTVBMaZM1dOzq69ys6GjokKqRRBI94DfGKgfPqQpVMouOZz3wxHvOYL8GrXvVf3NQ9UZXTCBXraavl67SiyHO2JTnsVY1X5MQn4ufylk8AbYJbU5h3hS4OyN1ugHa6CzQLaig/R0Ag+BwDNSKoC9XyOR/HZaTSCsBY4anz53d1zDo7Nu8NgJQTFbWaF8hZLK7Ce+WmL7oDxggFM83ZPheKe0bGYtHq6haGmktM0FzVQVmhts+tTwsf78VYs1knOlhONwC6C1pvtmVqAWYDZ7FCPxsFKQCa00BjZiBtdPYHgZvT1Zl7Lcod6VOVSRtzTgZt5nDmg/M7+bMC4L73uy9EBJdccgnueMc74g1veEO5aVeHKdvH3x4o8/F+BM58XB1rLq8d7Qm3ic6eAPkMx+BsAC0MBImvZ+BKtwntBf8jn1JMO2SAi0WncteeEX7mRZ01i3hBC9LmZE6yscDU9d+ArDa1aVBnqw3m34oh24wdT5hmvFKgRY7aEo0R2bYRex4v4N9oEaDGnExJixlTR8cyOrSvaKNj8UAvgrOwjTXM2y3Yc4aJSql6wHKA7QiU6e+vjfaReuxlOSXHOGcR/a3pC53ZagpR8y0bKI8Kyh58RyA2EcN//s06g7OxZsv7hDPpJz/pufiuJz0LqtwdZnI4ltlSgXlGzqszZ5/6m5Wurb7k4l92gJsYd/15+kEDkOd+NI3cZM7/4cBiOw1qCv8aFVxbsGop7LocB0AnuweQVqVg/yeugaDr+vrVgnO10DpQ2yYtw1izA7MxZ8v/H2NXL2ACZ3W7iqLU7RcD6Ih+7oCFs8MUnFVd6VYH9zRnq2nIpih4dLyRCy8o40GcrVvd+9YNlFuX2G0qd5zajBM7jqOLFogNMzj87q4IYC7NHD092nZAmfXNSA0pJ5Agba88+Bv+GZ79kz+O3/iN38QfvuEPNzftaIZfy9f+dh7vJ+B8TQO0AeaTrJkAXcG3AvMpgLbPZe6mow21PFkNvAswi4OyFSPZQQKcWR2MOc5mzja2VgK+qHWK/xTMpqeyBYoiI7RwFwIzCjDzOThtywsCoLmvzE1z4s3KQPpCDYDmrlXNgXnBoi2AeUEzxUMJzgRjCmdFpklZwBfN17IB5gBoB+OpqYeHlqoHtaCBpZkMLHD2jHQnHEfPlw17JlDOCO3ZrD2DXbLnZM0P/oHH4lPvfz8897t+FC/+kZfMrFmz5tEA/dIdDIshzNt30axdAmRi14GCABN9rKi4kZxAzAIeg9eEeaWlIrJdYeqBXw7WyklXKJMX2UhgngF6dLXYiFVdgGf0tSp8JzWdN9gqU0e7WOnITcGLTb2KAOjpOJiycFGkhWnxv0XkYmkNyZwdYKZx1g2TDNOvs0zuw+0M2vL/ze9s5WlZtMdONhU0Y4Z0z0SKoCDK0xrYyiQQNHqe4ki3gW+AIa0VcM4AzqYFmCeARgK0Zss547OqDC9fV5eR6vdb4QAtzH7JWJ6IUld3HzJhWmyuD6RDqIJzzmo7fvWrX40P/ZA74/RjS/Qu9LdTz+vjwkru1T2u3+B8wccWjMsxI7SPWslJnAB6BwPmM4jvogTfsCEKDtRoKyhid5mWwIzItRybtoC1h+d/CdC2mbkHaJEhaMoMygUzfRdTo5YrlwrSJ6bdENz85rfAX7zjL/21ZM7iQS4y5sYFKqO5H0pMq3afVBstFQ5pHtns1zTkeAvFCZwHRnffcu/GjvsK6YfIZa7HDPyyoC8/LpJZXCpHdLazjWO2XIPyNgANDSvGkZ9ZGZmc/ZTaghHAPDDwOQ/6MogI/umTH4oX/fCLMMKU3YIPdMCB2erGKbKkqYeUuWA2UDbmfMjnpXqSngqS0SqwUoAdi50ZmKsSIpx3KFYD1xw5B2PucXkY9U3MCpMngRlR0QsNUGfNYZL09/rW3el1V4uryqhgSf2s6mkVqCeAljS/BrMTB68C1AsSmJcypDQFhUmI45rXC7JSstli5jawFlhUtzqLXoDBjV2GFePJkw5gNkuCWmogRrLOoQb8Eb4+QF8Sd7LKmAgq4ATnAStC5NLFAbqpWXVMBhgwjwG0IRGvJ/UnS6tPwnrn4y2aeo+IxRM0eN1vVS/Vmky6e3yFbOd1aQPpbw5FuczjslrLa/Udtb/Qa6ee18cNEZzJHONxdccXaltgruC89TcX9hw7Li2okZtWGMHAmaw5tVX1v5FZ0+S9IPzT/KelrxpoRL8YozYz8GYh8LgCsuZpTqDtw/jyl/8a7n73T8YfvOG/4RPvcbcQoky3kqkRoO24Xaj1AsYNCN1bJbavbWUTCu2K0QekW9EQGd0BlwBs6VE0Zddja91ZM5lzRL8YY8YI1rw4QAdIF1DOrQsKMDOlCgYSlTFD6xJPYK7BJ1HpCRaJ/ed/9Ebc9kPvgP/0q681fzPWjaGORuslwHmuA8WYdmfPSubsFSCcQevEoCe6iC2LTlP1MVBnz9fKnFcFdwub2bSzZ53eXr/egLkZYI7mjFngwKxBUGk5Mu+AZrVMMfHcVVkyPYvCufGkZtPpKrOZ2/2+s1veECKuPqrLFMZs4fkzQHNCbLXjCtDcKi78v5IsevBckjkHkOvAGDuPxh4xA1pR/kRthtG0TRebyOKFEKgpefCoCwYFp6zagC4SvhshQHtQqO2v7hkkKhiDa1liW9S6gUukGPLJQGSLQBGZGo3cyS0UtlMWTCkRzQ1OGKfh2pGIg7TQmkCtKXMbpNwFAXDZZZfhfp99X/zUT/8MDuuK+XE846++3x6feu2GCM7X6nF1oHwiUrvsRXwE0FIBmlvCFZ+zwLRN7irO4tgtfTdp93F/tSzgHoQ12hUB0EiAHgRmFyYO0h7LcTxtClZIfc7jMoE+5mM+DgBwpw+7cyyYedceA+O6J3HrYnvL+2W15iDcZC5nOS1Wje8gMEtsSuGg7PWwxaVsMONeQLqvXhPQj92MLSNN2JTA3FWHNc6bzqAcTWKvrABmmw2Z95wuA276Z8CUY+oiQSpADxDWFLYP8QM/8rPQzi7FVecHBvah/3eBB/o5kMuCoQnOCan81z3gK9NKcCHT9mTe1qnNwFznUQXo7XFNnGKz19v2PaFESrDOqAc0zG/cOiJgkROGioggT1s7Mm1YeGWSzHlizziu61yYcxTC6JaNMJmsOQrhFOVw+XsGMspym7gxMWebCxLsGahpTaim9d48jcrZ81gmUB/8HhgjrAAtw+QM32MA7ZXVpCVA1zutQKT6DQA7P68uUXFH2rA57oGppBBDxQkCXHGy4+ZDRMCNIaLS5WPQ1MQficCsG6p70RRawVkUGX0xrN5+cfZQILLOOn+seNXxR2/8H7j00kvxyMc8Eh//MXfFzJ55A7HpL3SME8fb126o4Hx03acGsT4vwHxB0/bW77yHBHM+Q26izvKVCcKGOmTMUl7r3pxttwVTFX7aeOp5+oQPgdDKghbknOQ4jM24SOlPjpWPjAJP+I7H4Vse/kj8xHN+PF4Lsj9gNY95KdHUQZmNOzZlvnBTz5NsLKGBiCAlMKMPyGoAbbRn3bQD0A9eZOSQoFylblAjY8nKADBYABiQTNl8/HrEmnfifbn7kdeMTfKczrPLJBTlikOymx3UzbyRPoUBlY7zh3djYD+VK7XAWnLiYcAsXjPL2ZwZT5I5mzCyiO3JpH1UdzhNoZU5HwNzvnYamOeVRFA29wsmi028LhTABaCcRKoD9XC9tg4upzktOBiALuIbyGkB5zRrR6um7cqiI9hXsq/banK9VRmSztANMNdJIfPg+AUI58c2TeykJdaYM683lfC5EWyMA9ca/g7SVOWE9ziBC2ChEY25S4tEWAKWvEbxTXAkzOGZLMeKdaIy3drGm+dgXJNCJv1FXRSWuRXzwhX5AGc1cObOdAnGHn8htFDlv7mojf3+xRdfDAC4zW1uc3yzAFwoD+G9B+lx4rVrflz/wTkeFxqgCw1wBekLmbXL/sOS7FmcOQuZczVdN7fbRDivIZm2DrTVZiJ3duL7xCs/CcUZJ7r3DFJxQRDBM+I9cr2jrOEjmVuGRfwPoibsf/iH/jV++If/DeCFRio4yxEoV2DWqRmYMThloC1qGxfEgpb4vtiMYu3AupZmz7XPjWA9l+qs1ChDc2WTQ1OjPQOYpbJmB2lBAWh7PoEzQUfsTkU0jaRwGuL+O3BfIGpTbGGUM2CeSFTdfWgJFYJnH3NCGGjmZm0ZyNrCls+Spu4ZoJmclSA8twrI21XD5xs1EtxJ7Vj1JXOmQJZkST4szFUe3X9DOHb0X0rRXBAmcKvDfgzOq7qOtwHoiOAuAWJw9oyoay3pe61XWAtzE6RJB0n3C0DLtN50Xou+YCW2SJRgzgnaLRlpNXT4dx0DjzfbiguiI5iz2ZIXv5/Gs+OcQknSDZvXMEEj9i43gLbL90KtXrSkqV9wFa1+yD9t51KdKxWsq0Abza51eHQ+a+GznChiDdhx/BMNgN/+5jd87Tfga/7p1+Bxj/m/AITz5cTZXVPD1fT1cYMH51OPUwN6WoQcg3QB5qkgiQO1FLN2aMwKCwSzharLcDBegKUBbTFQ9n0HCdDayIiyrnTzfFYZJrxrekJY3qKJBdMg3FMnRG6ubUjKihAksPVAhZpR1GaS9n7YBhHLUCzdwbj7Prwy3C9L0zHL/HU0at6wpRAnOihFu5UOXFfoavnMo6/2vB8CnMdUbMTAJ3el6sdtAmZjD8Gaye6FeeYaTHkHOIvexuXPzJkzLGN9NFjEkCJExXxlDLIzgCVIS5I1daECBo9lIFiW7uS9NA1MPccV6rRTGbntrpUpPLkCdKBAnR2TmMoVlICdoFyj1D3yXhykFenW0ALcMit8CdB5XQPq89M+M3wuhul3Y9KO3diA9DkPmrdlLhlZ+q1Ze2bOze8PbT10XbmlS3lcAJqBk0TlUxXEUK5bganoSSjgktq1Kwvha9eyTqeZoDG/AQKza9FjQdplihwMJaR86RS0BmI60OC71Nm9ag7UKoHBMY9jkmjqMVtdJ1NKj9dUwJ6fToOB7GhqlhUpwKwJyYuz5vTB21xqOAbo5//k8/C8n3y+i8LjsMbTeHFdgHp73/8POGMenFMDdWrAT7NnqQxaEpRlAukNOLMcV4MHVCzAYoCMpUEXt/8uzpy9wPxgj8rxkAxzAmfxursudMT9lJQtw9d7BemyBk8OlysW9J1OozQBtAFzG1b2cullaz8ZWKRjQcei3dKoRkcbTCNTC35LJILtCUtwXjHWFWM9QNeDPe8HA+qxYowDtB8wxqGAtAVCWeveRgDzNKJMx/CFPe0jDG5q4T0I0OmDrmbtiAUAXEBYYJ5SoSqDXTe1yBKXKNoRgRbBhs1Ex0CvYtIWwbzxhRZgdkAXj10mi65lmmjmnPx02RKYZx7hKkgA8byKcoOWVHsJzBnVHqBd5nUohZLzdAiM+AcgaTDnCB5r+d4Kzpaam77nYM9cKw7IkW41GLFdLVQtAPpIZpA5Il1Rwlrzx5tFR8sxrMOdF51++DYvWI8vCYIYcybRWl3x05JOZMDcIYOztmOGwRNgURkro7WpRPGymEcIA2fWXoLrJwqzZLh+ZafPnyPYE5g5L6SuK/96NaUg5rmfkm12gpgcNjS5vuz7/P2wkru27ib1yGfzJPymGc1ZPSlmR5hxCpgvhD83aHDeDsqpgT+lEW0NcFvz9pZFe6CYJGBLmLAVaBZhKExDWBYDZAdmXQS6GBiPRaBNCgOQqWhRL3LTZK8l+AdzHg7MHdPnNlapWSGGuoDfDJvUEXTwArzX3BRiOFveALNt72eVeYwxW8GQtkiYvg0UfeydOVvaVAecLSdAG0jH8QTSxpSHOpMuwExQnnyqbm6IXXWEBWAqQCP6YMwEZsnobZq1Gxww4PenjPOARQ0DBuIUHGas3gC7fz66WvXJa2sHSDj9uOWtb45Hfts34PnPewl+67d+L4BWE6KQCbT+2gUBegvMqTHIdFzM08AEwqfBONmz8PWy0owhSQZIjToUVvkuFJhI7fHL8fWirc57mdjzGA7SBOWRgDwGjDUT7BkQ5mivAcwNc6EiAXO7ZAJi/3sWMgDg/tmtzPEo50kbidbieDbtmmOE842sWWPy1V2XevQYO0jrwBFAb8+pTgOfxIu6UuTg5kBJxWzALrupK1PF1y5y/HXUByLQVPIjU236Mj+qQsLo766k1uqnnqZrhQcVau7UN1CBOefvNqfgGHQ39/3o+LoCdMd783g/AedTj1OAfXwzZGLNfiwFlIU+5xLJjcX9zQzqEqRjVpMdLxK97hyYF4twtiIKMKBuXh9AUsjEDHfB0oarlb7GyJoJ0B7XAicCYCldZm5Ui9U0NMgFJR7NQ39qTlHPB1bFMkbssbuMgaV37GBtUbbV06mQO9pwZbpA0KiVzE0szJQ91hV9PaD3Fb0fvNnfegA0zdrdN4n3RsGE4eUIna26HVVKo8JAYF6ap0tJxsNU0/YMzgDzmsnuBkGFkfUwYULQVTTQDz8ZGF3YmpnO7YH+fgPUZuzZBfrLX/kc3P72t8EDv+6L8AE3/liQPaV/3a/fzdwaAD3Ke04BNFfKaU4xi6+ZLc/9vNVpBez4fMhYmRk0IUdpXbBJqx54NbHmlpbuAGh1cFYDZ4Y0EJyn6mCd2OfPg7YL1H9EJyHtP869zIVyImilK++UIfPI2LwvihZoRdq2xsFAMGdIGROOk/rMHHlvxdYBSYYOi2+RcQR/8b3l1h8BtCIVAeEdEkQlrwFE3f5qzagAXUg+PFvUA8wQ+4M0RM2TyJGu4NyciJiN2oGZPmVJ83Xsxe763OlsgqOs/JitR/f7atsW0OuKQemB/wPOJzWW06AsFxzwrVl702SxnMGpuZYc5bkMnLU1yCJWfnBHcIYV+FnEUhgDoGmeLiulsObmWn+cpgOzCr2IOoPzKIJrbAA6Fs6M0uL/mxjlxJy9opYO7IaDc+9e94vm7NUqfw1zsdMvLVFrPAWP+klx+8fR6Ws2xtz7AX1dHaRX9JHA3IfVoR5sSGDWAswsU8SqbBDNvWmbA/Om537NufvUlGBnu/2AeO/iS4HhZu2u6oIBRUJRy8/wsAB5OCCqwmoXm7dViEQUpOG4I4AB2g6FnhzZTkpzFh0A7Sfm5kGy5hq1fSFVNnnEDMS0O7EW/MSedWbe0YZjWFj9tJyBTVa6Z9CAwbznJpOL1q5QIoxhuGk769lIsmfFxJrjSxQZCLbd470q7VoAucqE8pqgJXCfBOgW4CiBbHmvtVhlqE2HpaYICHpWRamU2vmocsc8EzLaXMgc3QGAjmL6cMsP+xzhZPdLIJPFZmqemK78ppz0PtZunp78ziE+s64DBuc5AVvj+8PaFetIceoKM3PgFCbkjNZyr7KiQcWFawLpzbj+H3AGjkF5OzjZn9KjjhfQDNLGkk+AdGjMLUDNPj5Q6Ze6fVR9W2jdAWNnpiIDaEV3wKgSnTI30qYXWEF5N52Hzw0E9g2DJjBXgAaCQeejsCYGbQlbbnpvIGzgvOjAMjoWaf76ikUbduo1wYdkapUMNOZ0OziTbVrlowTnypCTNR8KQHf04YA8yJqz8lZuo2iBUtxNh+q4kLZ59SmpvcDTwJJB8zbSxB0bXBSZRZk2m9+QJtsY8wFVq/jrqZ0YWkK9HCRFWSIxmZUdA1DBfe9zf3zrIx6C5z3/30PaAarlBFhqawvOFZg34b8i84S40ArJALATgBzHUeDx6H02XvMKBFCEdmgxiLKequln9r5UkfX5X+tDzQAd4KwJzqrZkzEHc1ZnUmTNR7vVEXQNpIVg7VY1yondzmJT1p6jMwO9oVm8HuzYR5oadAxIXapazmkgsvBDcTiR+DeaTe4TAC31q4EEYpcBOmyO0KgjOr+/ArPWIdtcAgFaegIzz4BgzKBTW7a2+KrfmqDfyvoMgFfnvjJdwgTKVENmppwYMCliFzy+LgDN39sWOrl2j/cDcL66x+kbcxqQt6+laQquCYuU1xyYJVIoAPEZo2WtsNdFoXsH5h0gixowRw3bPN3ALjdnt0U9/xPTxJ981LXJMUATPIKRnBgpA2PXQoNBDy+7OaxGdmHPZs52gNbVdm8awBKpVSxPmjtT8+RN8PomEKOj9+79ipWAPA7Bmqc2seb6z028bsrW5gBdrBpZFlL9tmrmaUth0uKsWTbqmm7AeRhjJnseKh7pLilMQ5LRIDncPy3heoi6yPDIbgfnLNtqaPTWt70Zj37st2MMhG9wNo1U5CEIb4B5G/4rOgWxTXMCW7Z8DMbL5nhmz2ZZsmhuCTI2PQagnsMfJSXVA3vEjiPYMYZCilmb41j6GBqZrUdj0xf/75RCdVScyI8JynBtW3YQgqLs8Bn3+Ehc/kuPAwDc57N/EK969RtNhdEC1BFLQGD2UQ2lwEe/WGbyEapdfC5YvmSvNTwarsmwRn65AwnKtTO0VLHULG2aU2ZS5mdw5mXF0G3ucd1OM8HZ1spU3MicxyFmh1hP83YtnRtgLAXo/dzEx1Gm/9OcfQpkN6QMc/HeC4N0EcwFc7K/QYLz0TLfvH5hr8PMCWYQDtPUCS10Zsw2y2r9EJnutxoo76wZMGffd+o6gKIXZ0tEH/p+rNLz57ieQ17DwVlKooxsWpXfQCx2mra3I9ScUU2pRlBnzmJ+ZThL7oUxOzgz37k1AvPiATItsErV6gWrDmPDvTszXmdAjuM+m7ORpTCDNYubtOljbp6a1JCo6o5j8XGf3Yau1ROoCdIoS5dYn7fLFQ0Tol3VTXPOAKr/1NkzATrABIqhzXxn/vkW/msTqMEmXIhB/DuHKVUaaERfO4tTaFgTwF59fKop84hxbFePlJVSAbnFcX1eAVocoIUADYSMp3E2gFn8VQdliwfTmTEDmwBKT5ajwlN6GxKZrBthKtccDgNDQbLnrcAuQaHckY6gy7gU3eH+X3h3tGbIdP8v/Hj8+iv/rHyumMUrqPK3qcBSeQ43hiOd1qSgUKNT6ARAS/TT6labGelGKBKUt8WB03PYMEeW8r4dTZS8FF7mrAPE1EMvnyF4ch5HSWBNMPdLoQtEIvsDmfZZvhKbnz02Z2/Z8inGvNv02+MtSG/BeXsmB7w3j+s5OPMhJ44rWz4WNbEQJk5wyk+0aVKSRop9Js3amGJGsJwA6H0CtCwGzEogcZ3OwBlRcAyx6XnAt5tGN95FyQjuSLE6Ac4zT9KjkarZtQbQI4TtosN8zEOwiIsrhaVZeTR3kwHbz7k6y0sRDTUFZJA5j5HgPDrWsWKdGDOB2WrpskXRDtf0dbKRIVnyoomutS/3qQbgstRgQwJ0fITgXEmos7M2skpi+qUBOuHUg73y3o1ijpUAahkEaWN+AdJ+oynExEEsBKmUmz0KAhVQLojk992DwELYbRW2rbk62zKBc4s+3+PFHgnMBEJJJuaOCMcMM2Uj7qfPV9HZlL0BZh5rGUsb4xPAXIYgjnmPNOXDhDYE4zgudRDUCxJhhyd/10vwWZ/1kQAET3nS5ZCRnxOcAuYZpNVB1NidKc/BoMudmXJzY0x9fEuhFC0oKWSuVAYI0uLCgxYUB0sTRCkwZnubnsa4cona+HH/3QjG4Fj7d7sJu+6cNekb4nOHgMxzpowPoN8+/M1S7+ss87Mw7xaIayjo9nhzoROD3gI08N7C7PsJOAN1QGR6jUenQDqBtoLxBNRT+oTf2JIyEfYT/pnAsJhZFYtClmEAvQwH6AE4OJsd2MAZLoyaBxWx6EeYYqnd+jUNmv5AQV8SagjOzX1sqACt09hUU2Nd+i18or7HNIaDcXegcqE8wsVu5ywE5zGNK+OA0wSsvmHBCGa8OghXkO7K1xygYSAd/8SLcRCc3XxNy4UpSEh03elmnWm4ErcAfZTqoYU9Ty5cDYbWRrLn5uwnYv1UEMUX3YypBGkVb+rmWDcLe+T7CGbBmxw3HtzFx3y3JxCIPt26MjzAJqzbwIaN1MjrCsgzEO/ieYvXG5qz54BnBwwEGLIZNth5jgzljvWgomnCdkz50q/5Sjzi2x6Bn/2ZF+FJT3jqhkF7scoAZj7nsGRMB4eBSgN9zhVx5uDQHUTJnBOgefyOt1+Fj//op0C87G/DfgPOKdhF67qQZO0cFzWATqDO9V/xKI4DmMuLUj5Ue2eiYVARpEVG+DcbpJgrWgIF40CPMEpjX9U8Yyqw2ikDNBQE26JSwJg27f4D/kPmlhfMP57nejwgksdHgDnf2wrMMlXUr1sDb9spBs3vPQXON2jmnI+EZx5dEyhfCKTL8eR7rqBcfmoDCiID3HZNGwF6QHfDwZnNQcTbFCG9CaAAEBIlXIyYmXMIsVFauzBrNtOmlOMcIdFyLhg2DbUIaO1p6gWioIc405bCmsObHeehAdDGnocD8ChAnIw5WDOs2D19zLUwPmjCDgSF+fyL0qtbZdiD86YdQH2tTcXf/EqWLThPbl0DVdudh740G18y6GASYfkw5rxzYO7OlnNbTYmt+JjrniY+nx8D0F4KNNDM7YBHv2GAdMkKkI1go+zL4K0ZmMmGkzVn25Xj5r04QId50QE6ZLMrlfARybQydbJTik1ImrSf8N1PwI1ufCM89Ju/EU/89qe79YF1sjjPaNqWmPtw5bQeBzBrkR1hZt6atTeA7CZt0Z2viu17jpnzHL2dsirwM9ZotZG5qyI0CX+H30vh+0LhqoqXFvmB+C5+jcS8QBhW6iYdudFGnTR+eArzmk4udfr1lVeknrniQX7axKu+0UXoWjHBWQycFbWPq8A8ItOZoqgT25PETPeL8oU91AHaAJtAzb5q9hcyb6P0N3jmPOsq9lzKkVygPyqlYM+lTe+btKEy9mFGLYJR6vZNbQAOzFgUY7F607o4SJNVO4hHQr37nBk1DZSgjNJn4ItjhGDKgdY2m7SBXLfTQ91oFpdSKoMRoDVZNN23BOYlQJziMVnzlORQlIQKzsaeaa6embIB8saMjXQDDBfgVHIyGE+LXFUD5hPVWPWEQhybjXkj5jf4LS3gHGkf3jpvP5mzsmgJ854dOKDplnDQ3/m97CO/3ywogtbV6k93MQWi+0l1n3sDZeehOlGQJkwH9ToBIqAmAHpeN/O/BF72CcxLHAc4o6Fpm4pyEJhVUaLFc+5PtZMVcWIldgu//Zv/Gfe896fhjW/8M4y+T5M2ey0uFFRg5pBoBjiVtVHNn9u4Eym+ZgIvtHrcCyDLbnqfpcmRiR+bQfNU5nSyTMGbi+uw8EgUrpGEKi1Bf3V8E8543/09MV306LU6lUw22PfNBFbLpUjgHlO2IZoKEhBBY0wjtfLkYsFf0yYbrshBwDrq6dI4AcyS48gzy/5CrPmUKTs3PJrbNTHoC5m2w4RwnR7vB+As5f/1+bbns5kPzABdmfTMqE1Sz7+kfObSWeGA7E3KThEa+yra8ViGsWyPoiJzVnDf0qxkFT9RqDKDWhjVSvN2ADTBQtOiWdyMoLksroTsWRnIxOblOhVzw4ljX/yWGjRHk6YZtyoTG9O2jgLUW1C2rfBoxg5x5eRD40QQ/n5LXVMD4FB+LWpet8rwUbWRDUD7vSZjjr3oyZ4DnA1IiZHNQVGme+BcKKKLkUCt7ulwq0eAdGcTY8srigne3B66upD0tEpLhclVocPna7PzzelsqHf/L/li/P273AVP/a7v9gCuLWue/y0FkBOY7egj7vrR+Kwv/Vy88Lt/FO/+q3eZcuL1HoPRCsqk5NwvYtd95PQ5B9CK4Es//xtw08tuhrf/5Tuh2MNtNQjuTXAuPxEKqmr0VWHKRzLnNG2n6TMBd+cgvJteb7AI7k0Me5E3RXjz3GIMCDbGklMibBurGzhQq29+wvGb0ueGK98FoOUYgI/7vA/igxQxe0hOWtdIangSlzeBspI4SOklAgWV0tjBWUXwYR97V3zKZ38RfuoZ/wLvfPs7Y4ZUsK7yrzJqQMqZbpnzNjL7NDgbkz7DNQqMiT3H4irPr9vj/QCcJxLgz2fAngG5wvT8L71rFagv9KO+qAUAjMWx0IVFDNP+WI4JzK1D2kBbBoYz5rbY54ZvzCADVksWMJ9otWEvFjSjCwACneYiKPX7J/P31Y1dgD8k2KBFCHuglPu/o4wnRqQUBUvEUtKBHJQp5JSsiYE6WkDJTdsFpAnMYcoGS4xsrjH8koj1JpMyLNC9lrUmwJkeKcV6ikE7nky6sBaA3oAza32MkYqLDB9TdaOtKj74Lp+Kz/nyJ+GXX/Z/4zWv+fdOeEu0u1pwXXd9Trr43tcEZrHr5I6QRYnQmrUx2zLtXg/SHVctHbk+6ZM/CS944QsgIviwO30YHvTVX1fM25U3yxE8NwdnAvMOC/7Nb/w02rLgUz7/s/Dgu3yxrSVtwYQErjRG6pQpXVZ+keJ15Pm7uYdKjULwl2//GyjONoDc8jnSVG2f428VCAxkriiZ8qCatuVU09kDL1gsrx81XK7krhezp8Sv5v9pck9YTkAe3HFsu0f3tmxrPE9gjuh8jm2sU4KvJiBPvZ2Yi7kE5vJ6AjbnHa9mBuiIopcC0BD0AsRsIYPbgu/9d5ejLQs+4TPvi6//1E+F79AegYCcKVtg5nNEz7GvrHlrpt6as22rYAPoUyz6VHDYljlfDY5czeN6D86nYLi+XoE629YTfRq08xvL4NKnBwoLmxpZmWoLyj2O1Stlqf99OLuW5oXrm02tAQ8CG4h+S1U1em9L0bovAMzsU+M1c5PMlxY28mIEAKtssdyiveZTsSzS/FHatay4QmXOjKBNtug8QM2fHMAc/mUNM3Yc8zr9WqO+ObNVdoDsBCAwnxlIq2/JjTMYg/b+SCGuYQZAVhoq4FyMIRGkZeDs+c5FyQGSwT34cT+Hiy/9AHzY3/9UvPZ3/j1YdrJrGFKCMXMbcOmCtgKyiuXJHxDsXlapAbrZ93rH+XCK4TUOeff3u328Y392drQW0tN8zJvJnZM3L/GbbVmww1mAEjfwcFXNcNfvbXO3Re7iVUCU4xfCvrLjtunnfOGAXo1vAjR9uQH+04PSgcz5Qu14XEQjoSz+RsVmezcSmFNxGAWazZfc3aLQMZD7do9pz24Hbe3QAtBTiRbPHwubgiRAi0/QyDCowBzrOv/G1zcevSOPSgXmFpaijK+okpj3bYT8tXGkktl2e69FKF5FHAWo5zYDdf3+GZyZGsdAMAPlXTmuDPoMCJDesuetLzvn0Hv7uN6Dcz62wFyH5hRPnspinADt+l2zLqZHfZqaINXklH0W2rQoZgI0n9et0GJKSQ3ywZTnHD4dgnNdDA1hzgyTnl+MAFFar45VdQSy5jEmA4DaMejZyyGJ8So+K4uIdV+T95F7ilLJCbZRhAE1TdeajBoZoWumUB8hUYvgjO05FVgkS6C7CZvAjDMNUMYZgHM8dgA/wzF7roowEpjFFZc2gIVGkUJWWvf4GvqjN4LqXe/6C1x86Qfgqqvejd0lDsqorBnuY7YmXcyM3QVy8OPFAfqEuyvvMbnZFngQEbp816t//dX4Z9/wz/ARH3EXfMe3PT5XgqP9FqDnsLDKmc37/Lh7PxT3/LL74YVP/AksOJtO0kiwgNYn9XsvcAVQZy5Ur+GUsJ3BOaOfq2k710Jdu84qeey/MKvztRbacQ00Wg4SnOd3SOlnWZMqs2GfnQcT7RhZIdF3Z84JzA0rFAdo7NntrTBoia1EmT2Rpu9wYQniONaz1vXssoDD5Lcm3j/muW4xDeLKEBUprokCzN5bARiP7o/iOz6hu+AxX/nF+IzPuz9+/HuejhU7Hw3ffYyyZD61CaDzrtr9zAIk22CwYxN3gvXWzL1lz/y+ytApXTm3rtvj/Qact/rJFmDz1myPZy/zMThvBYTd+hmq+9SkHFdQno+tOlZEplKz3QI0V0sVsH6CLNpAcAYCXw2wfHHc5EY3wSf+g0/GL//WL02fn/gUyUMsQM2NbHgZKOehjlR0ZJaXmV5koNzcd+YpLmzlJwKEY5FpiJAB+hxp8tJyjEyxiGRkcL+S4jrSBOJzCpwT6DkH5HMIVl1N3FvQiznhQmhizmkciaCwthFY1Svxr77vY/H3P+7L8J/+689juSQD64w1lyhtB+e2WpMVZg04yMScczJvaMwpUFbACudomQCmmD3nOc9xAQmvie2wIi2PCyjVeG3BDq201//af8Uf/Np/87+fwYQemZGfsiKsIaH0kd0xDD6qhSBrcsTKmEEZG4BWSGiiFdp1nujleB6zatqugVw1g7uqKcelS2vERfbgXJoUhWrGpu+dLYGZ7BkOyjyuDFqcXcu0f7f3VIJAC0VpFbDJlOuwlPlc0XDOvUfKJ59rlGRMBeyhcYtvPNJ8znvwoDeykNf9xmvxW6/6LYy1weoSGjivcYVpH6BFbpbYddRP+5wTlK8OoBOkuXXwZs86HJu1Be9tbe3r5Kl+6lOfirvd7W648Y1vjFve8pb4wi/8QrzhDW+Y3qOqeOITn4jb3va2uPjii3HPe94Tv//7vz+956qrrsLDHvYw3OIWt8Cll16KL/iCL8Cb3vSm9+L0j81Esnm1AnHD8e3JuD0tt0b91mzbwI61pbnZQ22+I5Mop0+HaC6qjBribkFevhKFMWoGSZkvMo+Dn0sWGOkl6rE35IYaCzCcCf7R//MW/D/f9zK89F/+Spp1adI9q6ZeAyj1oKmt9SbKkEYNS2uxD7GLlYgu1WxjaDZ/3pXPgT40TLujgLgx7g0zYhkvEdgOYALxjUaMPQuwE8hegL1AzgQ4E8g5AOcEuAjARQK9GMDFsP4SQC8F9BIAl/rxpXZcm9wIkEvn1i4F2iXWL5dYa5fk8XIJsMTfBHp2Hv/595+L8+2vsFwiaKXJJYDE8aZd3CAXWQP7cw1yrgFnDbJfgH0Ddt6WBvEtS7NGacNU/qykBm6dPfNxrphMCcoAqeYpKBK5vdY3nEFwLnrBGRrOoeGcPVdv/nf4e6BnEPodYsJaUz2Davol7PgMqudM21LXuvQc1L8T8OcaJpPSZlaUJpRjplxN1GlPIGRvk3JQxHrKkT2Gtx7NSuGu2GPFDoejtnhrOO9te2xNHJybrgFfTQ2+mg5YSqS1RTVknSmIpVcvB6D2fMfnJdaCyqn07Bm0SL3AdnIV2z+7A6NLtD4EfTSso2EdC1b1fiw46ILD2OGg1jgyq+6jcfQ4kkP3GD7CbNhI8GOmvLWMVLBu5fjUZkhzjvtxtHd9ft0f1+lTr3jFK/DQhz4Ud7vb3bCuKx7/+Mfjvve9L17/+tfj0ksvBQA87WlPw/d///fj2c9+Nu585zvjyU9+Mu5zn/vgDW94A2584xsDAB7+8IfjJS95CV74whfi5je/OR75yEfi8z7v8/C6170Oy7JcpwvYAnM9vhBbnkF6Ln8+e66SvyWn6zAt19M0VDHC1ES2nPsMD/qBbGYmMOuADp/hg99t2mzkK440Nc2h1skDAGfQrfxJ829n+zNcdHYRAODDbncnA93KnAsbCSsf/afu246AKx9ZVQdp1RwDSR01rAH+tx6FNZwtq6sqzpTNrF1HuXAaaTO3ELgdbjhzVC/kNAyMdiO3294D4vJX3JQtF6kDtAIXkUkDStN3Zc4LcpvdGHscm/yLcDK/c7oF1Jno4taCI+OoZi9u1mtDIL15AJhA1gYcXOGIXThkmshZd6FwhsoQi7shzBvROAkKwyDDVkJPsuYE5iq0KKj2m56RzXPADOeJ9WnKFqlrLQYxrk3LxE3GPPdW2EXqbIxPTzQwrFmuNBcmLWW+U0E55RY7VvJTuW/Rj7jq4iWBxMz2AjpRWCfL0/bCgCWOkzkDBwwcAG8SJu5KCtJLyxbqbmXOCn/u85wGmBgaTdkQqXybVtYJmpRCYMacg1F0gfYG7Q2tN2PNvUFGs6pqowG6QAe3TLXWtbnlTVyOzLIk0xPzbs8PuwtaAFkLSGu5q1oAWjfgnZXFqu+6msyr/fW6YRof1wmcX/ayl03Pf+InfgK3vOUt8brXvQ6f/umfDlXFD/zAD+Dxj3887n//+wMAnvOc5+BWt7oVXvCCF+DBD34w3vnOd+JZz3oWnvvc5+Le9743AOB5z3sebn/72+OXf/mXcb/73e9an48UgXJswp4D6GlW2izh0jhpRxxnYUBKXXG5xbw99xFpx9AVogeorhBdMbw13+YQw3xBOhykRzdwHtVWZCyUM0qGZs3kanlDwWq/cKZnVn8yBLgK5/H4H38M7v9p/xiP/JFvnsA5Fg6K3Ca5pz978x5ujTgUUX3MBJmtZPKswPsAZDYpi+vYZ6Qukmc2TqGsBZgF0sQ2t2hwxjwsinmnkP2A7GHtDJBzcOaMBOYTAK17jdznKINcx5T+Np8WsmkEbepdtP6bFTmFcy7fGZjN398CnLE2YBXIvkHOO0Av4nVxZHN+szEvb6qUm0vQHgHAGbnNaeNMuuT8Rk3aCZJmBnGchlILd1SfXB1Qql1pSQrAFM4Ivodzv67u3OLveDODU79VQDjS/ew3Qz2MvcATllNBKfJEUn4sZKNT60Vku9hXnpHO4AwLEDWA7g7Pdk7djbg9zNTGikeYsw9I37MBdPU9011gPmdusOKyzk3bTWeTtqimmXqcGLYOPOSrHouv+EcPwr/+6e/B8y//YXc72DySxZUoCSN6AWcBVoGuAnWQHr2hjQXi5j+h+U8bdBhIW/15bw7M3B40g8JKwCj/TQgdqy7my9YJgbhbnF9S3iMbAJ8/J+U9+XvXyUAdj/+ffM7vfOc7AQCXXXYZAOBP/uRP8Ja3vAX3ve994z3nzp3DZ3zGZ+A1r3kNHvzgB+N1r3sdDofD9J7b3va2+MiP/Ei85jWvOQnOV111Fa666qp4fsUVV0x/PwbmbTulY6cpu7kmWU0+YZbG6gNuOSp2u7l5AbzCk5mvDZQPgK7WBgHadlyCb4+IniG+KmXGs3gAknlW5X6SvUVYBUDXOUCgFuD7f+7p+P6XPN0EuoMz6+NHwESV2c6aB98jG+V5zKZ0DMQi5JgbaWMQmGu52rJH8T1XgA7lJwE60dCtGRlCDm4flcAswH6g7QHZK9rZQDubAVouAuRidfM2aAHNKO4CzlrGYKvAHGWzOEBrnKK4sJNkIUXE1zCh2L9ZJQe2N2PNqwCHBuwEON+SNbOiUsyBDTuOk/WTH2IWBgI2tQfxv3Me+eRRB+kszFFX0Gzi2/rkEpz3zkAyP21Odwl1DJm3u0Dh24FWpZVKGgAKzRmYj9lLzu8LseaG3I2hI837ybumOyY5CtXDTYBm2zkwp8tsmLgXimoN/3qmSg0MMVhuXnyHcqgHY+4JvsXfrAWgsWkpy7qZtgnSDtQB0ABYfCgDwupwCWLL2gY84uuehGVZ8B0P+n7821/4YUQlMH6mUQ2xNS70MxOQ14a2Lmhrg6yLtQrM3lTZHKC1hVyp0dqcPdt/k6yMxbIp03xSqast14ZMx3mN9fsrZdTy+evyeK/BWVXxiEc8Ave4xz3wkR/5kQCAt7zlLQCAW93qVtN7b3WrW+F//a//Fe85OzvDzW52s6P38PPbx1Of+lR853d+59WeT2XRwMyWZx27arrV/FT9Me6nkTQjCWgey52FYuOCqPd8QNcDZBycKTtAjxUyVmhfIYvRKu0lzQoDsS8vbGXE88n2W54XOrsF6QrMQXhqYQ3HALobkzmLA7MkTnARsMXG9YIuKJV8xCv7zNpnaLsBzg7QaMUsVUzaSoBGWVyFrnrNbjq9otDLMmxsi1m77dWZ85jB2Rm0XISJPZvr0lOuaNZeMFsPiG0M/qJfbSUwy2QpzXimCnIV7Hxm1g1xCzjr2ow97wjKLX3FrIgE2I8cmUCoSXlbZAZlBY5M21omUYBb+vpV897W1ZRRGjVag2UQ00+QTqO8vxGrgBZApc5ogwdpNUrneVWDsiLZ81SVro7RBMzlXsTbKFZrYCbCOiTlb7EhDDrq7lzVs7mDIhOrEEV7APUCQxmfkebsji4OzFrN2ZRFBOotONeo7TkYbLYKbqyG6kYYAvOI6WWGhJbzGV28YBLwxj/7I9zxDnfGH/zR76KtEtOvbg1JIaOw18dokCHQ1axDuhpIS1+ioe+sHztoAehRAJqxKBFUStnB+aTVsF1j9ut9PgXE9jc58Yn6UL8q3Xx//X/+ztV904Uf7zU4f9M3fRN+93d/F69+9auP/iYi03NVPXpt+7i69zz2sY/FIx7xiHh+xRVX4Pa3v739ln0a8OFMXeZItMSkTGBO81ND99e7txXcX4fmbMCjj6WFidea1YEWXQE9ZHOQ1rFCRoc4a9YI73X2rAosw0zY1ZSnWmddtd3QFXf8mElOmKdjL/aiIE6gA1t8o5n/VCU3CwjTdAdaE3Q3KRMkllI4gN64yWGgS4xqNAfoqgGnfwpRM5igLMxfcmAWcevD0j1CpUN2Alm830uYttseaBWgL1ID5ggOUzs+px5zJLZBCZlzuwA4b9oofucxxN/rPa8LCS6WFtYS8LSZj83NeNobsC7AoUEXb62Z8jQVXEf+QJg2vO/DarizpivvG/0RwZ7NXcGvDPDTkpoUfQXo7WraYZRAMYTvOVntNoojd+NusLgNi9/OAhypptVJPisHlQXxtwowxB3kLxdhTKvDNJi0YqWYNqxhKqGBXuxbDSaWpVfSRoLlTK3ITJSM9is0pWNAnTFb0Z3iIxafXAWcmU5F87Z41HaCc2HZ2iOFSpw1WwGhEapSEw1gJmsO9rzRZbTBmK8An/vFH4Fb3vZ2ePNfvgnLzqacct6XORpR8yoej5EumxGs2QF63QEOzGy2Hna5NiaAzrRMA+VU9pLFVDaT6heKrOJdTiasDqvV/VAHpLZcG/berWI48N483itwftjDHoYXv/jFeOUrX4nb3e528fqtb31rAMaOb3Ob28Trb33rW4NN3/rWt8b58+fxjne8Y2LPb33rW/Epn/IpJ3/v3LlzOHfu3NHrsunzdUUVJVvWvAXmPF6RhQhrpiJcgNHkJqDO22HgLLqi62qA7MCsBZzRV2hboa1DmhcKoEl7cYD28p1wv7OGwMXcaPKujQNxipzNwYlm/hVfQPEVvqhGbsfXKmPugrEIeq/A7GAhzTY3kBrhWJ0GDs7a0HVxs/YGoAnSE2tGKCtAYczSgbZAWncm2c0PuwwPmnKA3hkwyxnQzgyg2zlAzsSBWksEt0Y+tDJgd0nzfQw/cS9DBwKQLYALDs6lFT+7XWONaPD0IvWZOZYCzgt0XRyYF2hz00eYPCTmiVKJ6wRlTQsNWfNwkG4CbWJm1Yk9a7J8zgkqETqruXHeJ+xOA3PgTANjl+vnj8E5M3u7f38vovFCzLkC8oXyTVEWCpGGa4bfuHjvwC0pbCEJpiSDNoONiGxBOW0IA9wMZIfq2XQJolTGDZQVA118RSgDuOg3JkjP4FvN1+opVNXPUgPBkin7futcoarmHdoAMxm07aus4cqpe2u/7c/fhGUxJVQ43zuVwLQ1AO5zVgtyxHCXjbtuZF2ANZkz+t76sYPqDmqpIoVBc91U+K3A7K+WQL+UduSzvMfpkuO3SPS1pnn3uWXHGp9F+WyLV/KXatm+a/+4TuCsqnjYwx6GF73oRfi1X/s13PGOd5z+fsc73hG3vvWtcfnll+PjPu7jAADnz5/HK17xCnzv934vAOATPuETsN/vcfnll+MBD3gAAODNb34zfu/3fg9Pe9rT3quLACoepf5TgTn17CpCqn9odVhekWX9PUCHKqQuzppbVLYSj7AU+pn1AIzzgBo46zigjYOx5+7A3EybzWhUAx31PQhDDIXfudDXOu8qMJ8aDLJmZ39SZJly8YgLO0XmDiNBuQ8DY1k8griJAaI0oBkoq1CZWdysndGNMcpKkE4WPQt0luLbMh1N1ozuJVK7M2cbTywrZGlm1vZUKtn1CAibAHo/IGcNcm6kebvkPEeGzk6gi07g3GFEtCtK5S5EykijvByWOjKGxPurCX82MpaxcMEzhjUD5gXarEHcagOPRqapgdMoou4GsB9m6liaWxfETR/iJy9BIFU4xpq+9aNV5SJeJBSJOWwyV1WGQU2JOtiCe5ZkzdDLLd9hrnvyZ4rYWdXexkhfGJyLKi+ai6SAcviYnVELtNRXH3OtdalOHJcvMtCwYKcLmAG+QMwrodUb7pCiFnsynNF2kO0yFdPBQMx/ogWcpfiVM1skTWy8M7MqVewMalMjdpar4KxiUfTDBkN7EOCZL6irO6HVi8er0OIoOV89rzlcN86YZ2BO1oyxh5JBh+958ehtSdmlCc1M5eS4TVXSQNW/Muit3YTvyQ1GbKY2WDT8lg7y/Yz4TtC3x3pSTF/T4zqB80Mf+lC84AUvwM/93M/hxje+cfiIb3rTm+Liiy+GiODhD384nvKUp+BOd7oT7nSnO+EpT3kKLrnkEnzFV3xFvPfrvu7r8MhHPhI3v/nNcdlll+FRj3oUPuqjPiqit6/L47SvWY/ahVlzth1WLGqAs6DG6vHmuklF+IqBcw/nY5q1dZzHMgjQK6SvaM39zmTOXEQM0hk18MWFySiBYdWqQlaNDT4Xc0IlWCXYNv3PSb4iRmjAonRlSWDuzXzJEzCLKSrNBXKTxZlzDRJK4161UXQYe06HQk3uQFxTKEVQA+MJmFeLCWgr0BqEAO2MmYVIZA+04oNuZ+Ig7ex5SnnV8DmPHTAWwWgG0CEiCzhPwNwFjbFFHRbLMuC5nC5CC0B7NipWoRXBx0cXjLHD6AtGWzD6DkMWqNjYhRncWYhGTqkCq4GzrgNYO7BbDJC7KVIB0MWyoiKhKMYqqgLVWfO8mij2w7iLTC5KzbCqwzOEySTy0kOa+fx5DBeSqbhtV/TsY56fpyCtmqxugFnmBRNjwPexN6YsrjDGiAijn2kn8pktC2IrDHXDvgN0DYubAsI4qgRlYWBcRhxqsOhsA1WNSWAWl1HNa/aTNS/1WBHnFiUMhpESGdREXHHricEMr5CI0LYXtfk4tWK/DGWyzeDcF2vrkscB0Htvxp4rQIcbSMud1WrOpr+9oazeEKIJyTk/Mr6lVHxEgzogV3ssp0hG23dUEzmm9/4d7Of8Qz/0QwCAe97zntPrP/ETP4EHPvCBAIBHP/rRuPLKK/GQhzwE73jHO3D3u98dL3/5yyPHGQCe8YxnYLfb4QEPeACuvPJK3Ote98Kzn/3s9zrHuQ5FsuZjoN5ytcrldlhR6x3RQJsarpk0Qrgo0D0lQQo4W37zAU3PW+/gzKAwGd0YtORiCttkrdvt/4/5QtNlTas6NRjlQQtlrbecAtnBmhV8PNhLGqLMnjTxLdwaem6BFAxuYMEiLPRfwmGEoTC2mIYfB/hg52yRjLphSA0UyiuQks9hAO2gLCukrZC2WAGS1hyo7eeNPfuxg7TsFG0HtN0wn/QOVlkh6ltIFGDRnQNsQxR9WV1wrQPTFt9aY7Too+4SLt91CFY1QD54++CbfjrecMVv+5aY9MUv6LpDHwtG23krgVZkDe6P1i52rq4XYqe2NeluQHfdAJoBZItY0Npmr9wZqA1obIoRmF1h8/WQYh9gqNHME3LFzY6huhrbJEKrRWGbkZsm9KKTnljhuNq2WROQzat82xaMNdKPDIB9yMSEvkhLuSJkqXUzkFKFnOCsBaDFrWMed8KQsImXKt1fBshReZA7ThU1iT76eaQ2wV9goRFnzCitnFsFaIxkwbElrf+KuFWINyiCSZtbIMLn7PEL7nfWIQDjKipIT6x5w57VQdqZswFnva917BqgdXbSlVGBeTsvqrLUfW5RLs3qVCpB1Z2Syt4c/XTV5teu3eM6m7Wv6SEieOITn4gnPvGJF3zPRRddhGc+85l45jOfeV1+/lo90tKv09A216Jmk3b3pbTO5ifUkBIG66fPbGjRoLUsIgdnS586YOgBTQ8Y44A2ViiDwphOVRMJmUZFgCYya43cRqqJ3gjA8VCOw/ySAFHAI7JjwKQRCZM2t28bbt7rKKAcrCR9iQNZvjGCgHRTE0l3GNhhRL+U3o1tatHAcR8F+LhPvCPuce9/gB/+gRfj0M8bIKND2sGO5WCKAcHZpY14jW1Z1Bm0Qha1fge0naI5w5adlHJOFqU9FsFY1OWFoEsaC1cNAh9jO1DzV1PBGGI77nQBDipWJkIFD//41+CDbvRRuOL82/DQ3/wHXiXZZuGqC7rsrKGMm+7SH90bdNegO7H0qsXPfacW/LUMYOnQxUz+9DHDg3RYr90UtjphjKEys2piq+JKGxJUCX08rvONvHQLkTE25XtOtXGizQB9xIU3it3xI/4mm3cFMLP3X4r1yZvO95q1wcA5+3BSuJunaam3ra7wK6O21ePNMoipqiOUCSql2l55b5wfFXv/rG5Gx2TfDB1p00pQXkDztpjupnaOIHMeSJO25H2KAVQEKKubtFXK3af1xfOVCcxaMhMwDKB1Amlqzjuo7sE0Co00ClcM6ONTmrJt9s1JTXWeziBdA75s1BjvIJsRTb/2CHCeR7j6ou0Xz1/NrLzw43pfW7uaJ2TzWhrBTPfP/U7o6cvS9ccF2hgo0Q1w0E3zi2AeM8MB9HE4/9EVi+c7G0BbFLdoYc7DHZZjFN8zBcCsC27TM/P51YghzT/z60wOSPlbjhJ/h5NxKCf2cQ2kdAzYZgdtKt+4KV2nVkKPJfXIoIc3OhjS9OlatihufJOL8LO/+h1oTfBp9/pofPnnfA9EOpocINhb33aQdh6tmcndGpw9a/jbsTg4R2veE8g1GLAu7mv2NEsvZpQ7M5bbM2DEu6tb+ykfqEupf7YJVjWz9nkIbn7RBwMAbrS/DAdpOBCYacdpDsy6NyZNFr3sMJYlI7eX5iVVXWaVtDLzK6+YynQ6LUofs19KgFJz5sxI1VkwuVc2+grK1SHRkN7hdvQtWSQizdc1lEmn19kf10ue/1WYnixPdVFg5E1iC/DdAvJIq02k8PkMPZE6aGmXdavIshmG+pECjNrOvHeEAs761lV9OQLmqCBY2J6z+vS75squJCUjAcoGiSpu5vYtS6F2vlLOkXPaAboqZkJgXgzkddDa5tDI4u+M1iZzVrP8YBCgTfEMFs36wx6pbSBdqwMtZBvT/WVA36msneoUQYHPnDsDx+pNzrUR/x9OSjoyzqG6VrYqadbouC6P6zk4JyhXqIlJg9R9Zt8zTVA9NVv4wsGckWmw3W1CSGpFTNKPVAjtGOoeVDUu1HCwGrd68IAx9xXpgBCYSyV5bc6SA1G5KgjKes0UYTOz4utOPY/OFs3QXESI4vOBWkAJyFjUgFZ0h6ZertFrH9e9T6PObQC15b4SnLPV4B1gf3ZxpPVcesklaHIjG085OGPeuZ+bkeIuLAnIQrKv0aT00hpa62nmZXCcqBcxEksxEasBEnNMc4h2MPBdHPtqGpJCkjkrJpP2j73hwfiCv/d4/PJbnluqIhf27I6WLjsM2WPIDqPt3fe883SqxVmKeCyBev5pt8DCtsZJaZix9aip+04JTlVc1RVUgZmMifxiC5cNzFTehnpJ/Eb17NGcOzdulDhCZHqBWyTEo5xJFYa1p2QgEJdW67BiBuI0j3RMu5hMsrdsDCLN5ITLi2krSQdnqwLnsSwqm3XJtZ3seDkCCuVbDO9Cv7LvtEwHibVNOWjR5VkR3QBZrIa2wO1eWSomzNqSAWHh4nADQo+5bvLSWLF7UYbNfWyZM83a2mLDC/Ygi67FR8aSYKw8tueiS3yvicu0YlI+H8ceuaWjADdnT4aIVdN1cmRaNkaYvE1uDTCIR1BtRVoQ6AYKzkAVI5iGPI0L6bnKfxaGhCNumEZbgjeTIOwGDG1FCJuQMBAnc06AvnAzgA5z9lRWMb95YsnH6tw0AnzErjCUgA1esUoyMCyCPHIBaeQhNmQdXAfmUqWn6c6AWR2YfbMAUdvvVHxzcgNmi7RSP9YJrGn2rnVq0wT1jrcpvuWBL8Jn3u9D8dTH/QIWXIomKxrOownbEsCcdTmcSdRNl2WUQDb/u6hr9T0GbIpCVWfESgGXbKWmnZupktiXVogIrh/GmOl3PkDw2re9DL/+tstxXritQYutDay4v7XujdskDFhw2MDiQC3hC1TmwHikmno0fUTMVhpUQdlBy5QjjfFXz3sesZZQjtPwVyGWpj6uHQmgmoEz85jJjrOidA943v6rQEU1e14KFKrwdWlzKn4WeXctIJNpSgHQF2xlHvmlSKvrJ10/4kFEbBImGUHs7KUyVY9DKN91vdv6X7S8xOA890uxtgA05ZoCEyhWGReJjsJq0KyKfpxtSYCuwi6sQVwo5ZSbAq1J1LMJZRl23an9tpQzm4bSowK1VpAupftQ85NtLkrI9ZT7DblNCcO1YkoUdS+ISqiWBs2cqZzPo9A39mMDzjMW3UDN2sePFDCFFwInAVpCeMweA97UXQiZ2dmfk3KAccYUSLVlmsNctYdhvnPwBmmtTqt1Bt9469Ef/M8EZcqNAWNPw55rL4E7NdUBAqvgI4AXox/F3JSFAMz303SHpnuMsYfoWTSUXj03SfXMgbqCdN2zhzp9TmjBwC/8zJ/iF3/2f2JZFrRmzHmRPbh/cLV6ZKEymmxnhpTC2geHEaYQF4QyFdXqTSPXk2stzNUDUTt7KXKbP0d9a3RGa1sQGcHZzNvOmCX3FaLv2XLBd1jHDn3s0MfeIrh1b75nppIUozHASNUFaYTHBMjZ+1gwuA+Zm8lvQnwv3N+c8zHDs0b53XTtjLBIrQHM+c15zmTEPWA9a0r38qyG3wxQnA5k9DcDSZPH5b2uy6QyZQsujP4UKE9bLg2UIunQkMMS4xhAvfVD1tKsrJ/exIpxKAfYlDyozR3Oa7uSFpHUz/6vP4w7fPjt8AvPvRzf+U+fiq4NkAFRZk6UOV7kXO69dKE9mDC9FlBTRJMWZYKvhWFq2K+lkjwHAtIEnWbtDAzL5gA9WexotWvOltPFJl4dyHTPNF1b7fCG9PjX4MQKnzkTE5w5v8iYl1APJRROG0VmIQxw7GdgJnu+QYJzinITJlXA2N+1DFPC6azH1xvlNxfVJMepbNO1iZSpDzfhzYklUdmn1LWNFKAjf5YeN57YhMApYk6+THmUl2lMuTsAZ/QGaPoSChcg0hwQoOwAHZGUrNazjxbAPM5gW/9ZsrBM2/XZdlCKsrUfzpC+6aqvC+qikYhjNnP2gvNYsIsI8cXvR+7/UCPrM6wotud0jRg6wlIgUVFBA1BJqAWCSCERsYhaNUDu1a1b5DxWKRXDxDKZhjHnrhYQVk3cB4j7nYt5Wz0wzMF59B16N4DWvrOeKSkqYJ6nXVcvM7nOGAqhDhZSUFdW5xXANZQctIJpzF3N7zPrx1xdr26pmIoyGTozfAnQ8z5MFabJx2dfYDqpOOnVBWn+RmExUsag7liC1YG5Nr+pUm7sZIHR/GoPfIKI5Z8z48AtEVSgcAQ2zgybunXKl6EX8miuTDe1OddUg0Hf4cNvBxHBp33+J2NBg5X+8yh7WBBaXj/ll8FHhnE655Pqzsts8eSkKSe1zKeJLWtajsKCBHh9iGT2qaQIIg0wTNttAunKsKMhXw8mfnSGJFdjUkiy1VuXhK0SpJxflOocw7QETYpXAPRGGQFK/3eQSnV9eVSxZA8Kkhm6t8YHeyQFkhBkHTSQh0Yq/jsl5SKDSTzHrmjhwvSHaiqbWgXnZCnby1Apf9r2YzsQbsqOyOLi55pKQEouGjdnj6lizwLtBgxt7KB9jzHO0EYFZgNk4U4SZUcJBXeWOAed9tDlrkVL3I1UpphBa757M/peZeDsvDn1aCpTZYs8ZUEG92mPjiyP2aBjeDqHwLavE6BbTjOcJXO8a62PZXjKScdUiERKSWPutsOg/O5gvqpE4867B4noBKyldV0spWp4atW6g647jL63ymGdKVVwtk560/KEI4pnsT4UIRcwvg2fuIqZK2K22BD6GOhVvcYZ1rX6XUhgbn43k51U21R+b8a+ztslVpN2CZucwJke7mTKVWhuJUH1NZMxsx0ciBOYtVlNAnipWF08MKsQYvr0lQCNtgFnFsxobvFQqO82J+rJ8MNZ93DGOQzYrLKqWhkEXyW/+lOvxCf+w7viOU9+ARZZHNi5F/yIc0izL1mkl8gQcsoE7PgbjmEnlHcQ/nJq1U3RyLKTrwMTaybAcgtIsudNQ/SYQFk0/bj2Wn5/+pftHNJCsLVj1OydjI6fwZnBikkPMkKpI9WZGep5LlktoFLHGzw4V41/C7lVzFQWsX1PpZ/Dp6wLsm2AA3TSyKf0hgDh0rfyPLRwauI6q51xSpoEBQWYK0BjcxyXVSZHMUdpM+1c/ZJUNguopDZw15ix7iBeUk/7HuLArMNAWcY5YFwE0Yusx0WA+pZPOAdV63PTewPnjO6mWZtnzuXBUh3cVJ7AXEolqqaf30HZisHsYKVTHYzVrAAapnvxbevs502WmTkLCje7aeoscM7J2zZghUcm1ozYqW+syCph3Fi+gHNWRXagFklw1lLudDQrSNIdoA8LdN1B12atS5Tu1D4ylCGCCR2c0cNcKEWYbNsMZvZsKC1E1Fiqn7kjbU0rashN8nEqBsfgbHf6uIjn/Nock01wrjBifK9Dp9dkXk9h0q/m6wLQlTG3NcwiWv0XvlYToDfgTIBmU/WdlBYbRy8qZCxxwLZH9NNinIcI2rAxas6YF21QHXja1/6g5cZrxyK7WC+iRhAi1UoGKjgL6rYgBFZj3K2MpvBvUsiL5Irk+4aQoMRIT82Ge/MqfQEFdEvMa849f43HVextp2fOse1s2O6pPcdVZ9RCBixyhtF1YhbSdFhapFLl3tlXV2mlgXbefwflO9/XHsc3bEauY+6ZSFeFA5AGjRprGlpoaOHpva56lpbIVyti735OB2BtPY7ZdOFCH2CkbWXOmidpD5ICHjNQY5SrpDY5ymcVFgES1M8AWSLn1TVV12pp2mZKw1h3EG9Y95D1DNLPoN1AWfpFkGFgLONi69V6sEcCNdzUzYju9H61uIyZNa8wD+1VCcxqKUxT5W5lEN4BkYKhO+hYY79Y6YKxGiiz11XCimB7aZvAkGECmHtFdNCEpwWcEZZQrBIArQTm1f3XljWHdbCQV+51Fk3adMW5gxfB2a5hrAvGoTlIN2PpK6CrerUU2I/0ZGVKM2opBFEFJyP4T+l9nFgMkaFTSDyQjmIuDajb4j0D6dlMMZ7Ts0bEbkF5lL/P4Fx/e64SVhjNVPHLP12sWwq6mjYATV9Fs1xxad1Y86LQNtwFqlPBDQNoK6YzlThSoLk7hAGCMhoYVdg60mLVG+CR31ybvnU5dCgWHfYF5RoFiDvRVDEiZqXaGcictQAzEpg9K0EqKBN8I6BQ4jUO7RFfIXUtOhED4KY3RaGFcn+o903TLmeIBIpTkNVg31T5tiCc+SBlow9kweCaTZB2nLSdmso3hxDneedM53Ucx4IDfye1td83HwnRFawJzxWj5m3pEmRrqgZNd/ls1g0HMFmA1UF5EJzdRK0ybCEXhqytArR69n9lzorpvuY8RFmF2RSgOexoOPh3TvoGSxsasQpdI/ZwOBfaob3XsnrrAqw7Z9B7SD/z5qzZgdlA2ZodXwIzbxOsDZwlTNvMjQ4jWlx0Frk0xmwFHRh16qCszCs/oOkeMnaQuptNPxgwD9uernfrZRUIgfkgk+k6LJ+OZ9KyWm7s2EPDxwnWDCfuwxl07/DAMJQ627bgiadTyKBI1uFWyw4YQwKcdRXooUEPzfZ2PojvGqhmBehqVZdoAWHka/H10XQYwT1Ik2GsoSh2wcdwQ+goAijdPc3Xk/h6qsE2dS/nXEupHKdXeQbomsZSxHRZu9WsOLc5tcofwZyLdQumXYUJu9kGNbaZSkfseub+jABnZvw0YHglveFyYMD6rnY2XWHpRdrQY3MSDYVbhkAcmLn2ItqZAA1LsTKzSAdTiLrPyYyoGBa8VzeM0SWA+BRzpp7PGJTsicD2AdYREH6B2ZAjFo7fZe6+Ko8k5p+Z3Mv3boG9hq3H87FpNTadDH+uVD/vrZ3Hpyr6H4Oz0r5SrEApiI+rhuWZHEOz4AYMzttH1f9zhpwG6DkwxRbVcNNFA8VMTgXxdJtyO6WAuxgDHs1zlgnQTU3zZu+gHMcMMmk8f+95CaNcWr1E2bzG41BbC2NuEqlUEK6Pyp4s5WFKZegJzOjma5Z+Bln3Acwy3JQ9LoaMSxyIL4HoJQAcrHExAJq7GSR2BvFo7TSzJuOiwdeAeTFgVthm8dqx6IqmByy6xzL2aA7MMrLuZjDmtaGvgkYwXsSsCRwLDt8Q3zwCcT+qfGL0dquyfQPQWlrduaqPLOfJnyAIG+nOfa3jWLNppx9boIfSzkvsUBqWgFVSUeiSJtOQcwRoFIDWwl40ptExQE98J4RRTskqstLPLRvQzGk7c+N5m8hR/n7KrJ0AfWzOrkytLBDexHAxzSZu7hr3Zf/4frjqcCVe/PJf8nU6oDs19rxoKf7imzy0luAsrMpsClZTs4SIWzKEO0V0W5dWKteq3KEvgNj8lW4+4ph8g+DcIENCV682DNr+WLxEsABiHuvg2+L3jSmFqMMl2Vpt2BwTpLkwYHIM/pxCiYduggoWPeJENjrUFow9W0ZMKalhVwAjsCsjnorhljYDdnqSZ+BPFbGK3pzZ1o/NTE+iN4Mzj0o07nV4vF+AsxYNSsvzXND1mD4u3haKgxZ9ChaZ/tWY7w5aEdVrL+u0OIc4GDtj1kZAVqAANKK6k84TlT8Ur5UZrGXSY/P+mPj+el0EmeeAZM3ee3GAAOhNEXpd95C+B9Y90M+AcQb0c9BBc/bFUALzuASKS+wYBOxq2q7MeVuAhAalA6QEi6V27MZfr1/eIq3LChNIKaqv4Ts3YNaDREyULAiFRR0I1SO2tSP3wSarANLrwFCCCs7OlMOsvQVoB2bu5tg1vJ8ZWy5TjDm6IiLEB8+LLvWybTjOw9gzWz2f6QfKPGFxGxc5eZyv58qpD2qKdYVUAsTPVcZc89gvBM4VjOce5f8ZNTwbNCdzdjzHfAND8BOgaxxIAvW3PuQr8fQnPRqqigc+/JH46Zf+PwbIO2fNXuaV9deb78Jk7NnkAv2PVnikQXTY3GTCRggQY82tNVgFj8VaN/M2ugROUrGQ4bnjzp5lkCjk1pMXCqEz/HUmWDNDAphN0RBJtxdPYCp6wzgNgbvkgMgFm6qrYCYZWu5RlW+8NroDCcayJCj7vRTlNc2SOdnzVG8PXtJnAuqrY848MsUn1dDZnZLWovTFS1xSmXTQGyo452AoMpqvyCDMizp9CpkANRfvJ7B7+H3k6wERGCEpSLvAwRgzODe2gREgbSw5mTPMeerMWVsVhIIoZkxywwuLIiInBqMyaH5PXXgkFfwCFjSAaeOqLQBOC0CLM+cA527gjG7BYAHSw0DZ2qXOnC+B4CKoXgTZgLNO/ma7Mxklv/hdKWxaD1bwxIugfO6XfTw+96s+Gi969n/Aq/7DK51xEJglTNhyEKulfRDbBKIAM+OmPuZmn4bHfPwP4tff+ot4xh8+umLJJHNq3YopEKz0BOYA6KEJ0ARnrbsvqSl4QIjVAfW8ajNpjq5QtlWhBwUOgJ4HcFDoeQUOmiZuN3MbMLs2MG096kDMOs8KrzpVV4onWLEsVaw2PlsnwZ8cIovcbqsI1OmawFuBeMuYK0Aj1mft0/9HjerEApkyIjIuRCKP2QD6lre6zN4uglvc4gOgy4BE7XLrR2yqIm5kGsZ+hT5c9Y1x1Jgy9YLQysTjFBqa1Xi1TVx8dzf7ci+wY1ZsGAMeAVQygD7UKt7psDWBGZwZyW5KbtX1jTlTRJi12bUAaRY42sT2EPf1YtYmb5tqJXZ+oywSn0w14ktgsqvcG+Gd9bFSZZpph1VMWu1a9RQQMwiLEQfbdL5TID2CVWeGxylwntXIqt40H9EaY5HMOa+MYlhuqOC8fRwDcvazsSSXtB1nKokZgYpWNBXrKEYQZ8yr98Gg29zMnA2MMIlxocOBelYoeSG6Nfvw4hpQZs/8t8qO4pHnP0V0+DWGqYmBQ6NBh7PQqHlbI7YdnIeZtnWcgwxjzlIZNC6x13AJ1M3amfvMYDCZTtGedeR+RhTwBxc+O2PIMKb8dY+9J5Zdw4Mee3+8+uWvBothSzcTr7FaMaA6SG6bKUkgiVdPuOuzcJtL74APvtFd8COvfwreOd5hYyQ5plMFyAgGOwZmVmul75nseQwD5eGM2HC+gLIkZxxeGnbo8NSv4eA83HwN95vDgXkAhwE9DK96Qjt6petFYI58PqmvmgE482Y3VFzrtKuRuhWUqWRtgrQKhBNwqyJwzJi1vAull+mXZ3M2A8K2E6uAc6QvGkh/6zd9JZ74bQ/F5a/4dTzgQd+Eiy89w7vf824883k/DtmZSVv2tm6jiuQu2bNZop29NturWuBR1GoALVX4dEAXweLAjGZ1BdA8hbEtYFU7FhNq3aUY060AS6MalkbVdaDpgqEDQxm5vkz3NkhI3chDEphVDJClNXP/OKO3mvOu1C7wXqN07F0/5e74jqc9DW9+85/jy7/8H9v9p794uPLnSqG4NYBKn1lr3Azfhh1LN8sBgVnghUZojm4J2mJjHHtpq4HzNz/5S/Hl3/K5+A8/9Uo8/eufPoF09U/ngja3CjGhzvoUrzXtTMHo7NmCJLEu7DHw3jyu1+A8C4lZbOSiJzBnNidNFlwnNJFwwdO3HKap+EWZ04HBdZbAvDVxW/VLB+kFG5+VFrM2whKn/F+dJRcCZf5tnkHICCd+YQJzWhim1RlBQjrIng2YpS/AqH7nvZu1PZ1qnAOG5zJHlDZN2fQ7m1nbmPMeZMvTpcTB4scDkWrFQSqlAEUFb//f78ItP+gmePOfvn3WvCgACWKH+StKoaOo+vX6v/hPuM2ld8B7+rvxzr+5Al3mYQzFhybija/5CJwrgw72bAxanTknv8mgqOEVzcJE6YLLwLnHb+uqmQ52cHA+3x2ku20ZWQF6jMKct8ymNGzAOqBUMOW4HKnCaehDcIoatDUz75y+WyA+1WP63AzMxww6J1NZKMEUN+DcFI9/5INw4xtdii/6nPtAW8fDv/MJkL1CdiPYsu7UN0iyfuzEdzwzcO6LWtDUtlZB1ehdcYyi7GsCIFarEx8A7ZHbaAJZ1QNO7fMW16lWox8jcqYHWDJ1sZgXHajFWiSGROrSd2BuXre9QRc/p8V+3zZZkQLScPZs5OPrv/lbcOOb3AQ3vslN8Kmf/hn4tf/4KkDJ6B2ghxohFh+HOhsi7c8tGJqkKIA5LAeuvKtMQJnAbeD8Tx7x+Th38Tl87tfeB//i678HWbk+gblhnseGCzk7TezOYEwbTXEKlhmYx/P8vu6P6zU480FI1hPPuS7EgVmgEWNK9ly/qYayZJUcKe8o7DnAuABz89ebOglVL2yjnnahkYoRmBPgLPVUZoWL4HxMQo4/E4pgBej65lmwTRV8Rumjvq3Tg7rXaudG6O5/1rMC0CxK4kFgOGc50Btgnk5ne2pTxEk1Veb1qAIP/sxn404fcyn+53//H5AzhMlZM+rKTMALoAfdFimaLL2P/KUvw4d84N/Hn/z1G3DAyOBmH9spcLSYtA2YHSgPBpqR4uS/P7qCmTBhpnZmujWoGTh3r/blva6Wex3XB6Aw6DBnHzpwWB2YvdVKKATpqOfOXpPFTICb4Eg+QPX22DZlXrebXXYZvvbrvwzPe/aL8Na3/uVmwta1lEenQbkCNzafOwHMUxAY++PpDhQG3QZUFP/uxS/DN3z1l+L1f/jfMzKbFWd8u1Fjyophe7pA9rYUYt9wC3HIjVdQiboc+ZqtyDW3OhUHwoa2OijLYsBMkOo+0gJIXzBkuBm82/pEh6hvycjCJ8y7VgdnJx2lYggQhVQSmEdbfPc2A+gjcGZAnJu1X/rzP4873eXD8a53vQu//bu/A+z3iACOIQaufVhkd9cSCuDzjVteMRK9IQR5RILDLAOE5AY37ztwt2DPllr56pf+Fj7riz8Vv/ea33czdw0W2/qccx5XwjeXG8nQ1YoNFSO2IvlCr12bh+i12aT5fexxxRVX4KY3venRkq+D1aaWW1dkAQsWfS/Phd4ZRL5fK9pbKY9rZuqGaX/wdacWP7VXc8myPwP6mRrZ3APjjJo3wizG7wbBYMBSm4IBwoUwwkRbg38m/2JEFVV6WJiESplyrFFrJ2P+3D2gZx6N7QVGPBrb2qXAuBQyLoWMG0HGjYBxI4hag94I8v+S9+fxtmVVfTf8G3Oufe6tKhppBCQhhCAKiAr2hUlsEDtsIkSiRoMGDUoUCRgTRF8xtBKjoFF8EnnEFmKHiEYaUckbkdiiYpQIEtBIgUaaoqh7zl5zjOeP0c6197nVJE/et6x9P/OudfbZZ++115prfkc/5CpAroqobYXzCTKIwyY5lUBQ6Bq1ENCbYKFTLO16G9dh167D0t+LpV+LZXkv+nKtjt21aLv3gnbvBU6u03HhOvDJ9eAL14MvnGJcuIT1whnGyRnWkz3WCyvGbmA9WbEujLEbGF3AnXVrrRUDFQFnPcfimrNrrr6/NyivlHnI5gPXtC6rU+49mq2xhcgOQl57/ARsNci93KlIaTg/FkSj+sivlmLOXg3QK7DfA+sZsO6Bcab74wwYe2Dscc973AX/+qn/HC980Yvx4pf8XKj55FoMRFkWWmBdjlJTrX7lt77tdbjb3d4f73rXe3DXOzwQdQlLsPqjGq0PoTyDeTYW3igwbwHdAE8BqumM5AGai4IYOwbtoNqzjxOgGZRbDEJfCL0Tem/ozQZpLbsFCzovWGTBMnZYeIdl7NDXEyzriW31577foa87tP2Ctna0tYPWFinYmiSv1hPhARl7MK/gcQbmPVjOwHyGIWdg2UPkDAztMQ9ryumBYJpaBU0VJEJrzUbXFqzd4dwTzkuzXuek61wTrF2wNsG+MdbGWImxx8CKgVUYq+h2jIHBgjEYPCSK9MiqGQiwojpajbCZG03z1TQLo+sQ65Mt2u0r42q1IJE3pN1hYJGBBavux9hqzhXO+r8vn57MqcvuXHY3n0O8Zlp6UT2MA9fiD/Dud78bt7vd7XBjH38lNGcABzf9rDXP+ylvq28o5X83/pT7OJYDM8BUjYtgeY3FkrrRpms+NFfA+/6BNkypJTNtTNk0r2sHX5bmmTHNEKd+9THbm9nPVGvZFg1abwq9ObxTDLGBnHcF6Ee2KNsNmIsrX89wrKvF/FjMAeIaJepWzb8w8xmZbxbDTMhDwCuHa2HKFINdH4+IXkQVy2GvoXL6qoB/oDUjTOcKSQe0adCuvZtGLxvNOUzXrkOTaczQgBjVfCg+X+uA99TABszELaolr0PBvK7AWE1ztm11fgvjF1/6g/hb97oHHvG5n44Lt70nVl6x1ZpDczYTwmxSrneNXqurrroCAHDx4gVo6cJqdt7ep7PB+hDK2//r31YY+/tuRp1o05CSBiRWB0AM2Ah4h2VrIbV0WUl4iUFm3ibTfvV4iLRdqB+2as6EqjWTjdGp9CP3QCyK7Ios/iH2dS3uoFqUyBYaoqhPzVYbgN0yhnpfIaVj62AGb0XaOzANBbMspj0vqTnDsk+o5Bd6j2sV8kijyxvUBE8AkRbHbNB7rwk06M4EYIqSYRb7QAIijdxuki0s4h+pT7uRmtEj0Mv8z3MzIi9w5K+bxT2ACgPmfzjYz7lM5e/nPUEVL2/K4xYN52q+ps0p9lsc8HJq+lrevEqDv/zWd7+03bflnvYJLWXMgWGzmdvN3uGfLtwLKG8p1WzB8QOdqvOgXOLyXesBicxm1wpn16JRDgSbbTlAMp8uVTO3zKDObWrcE5SjyMiymdDTV4vtvHgajGmUsUJogGkFu1yrlTcgoqU7SZ27EGbw8CEYQ0E9Vnc5SF43hAVc4dwqnCVOradawXzIE5wj1xhm2rbnVtEc5dX+3uHMxZfsUI564A1aq1pPhvp6ESU5teyjSRDDTN1+8CsboCucHdAOZ8/JYrzn2msBAMyMdX+GMHM7oEs3Kp9/NaNBr2l6pQHCpz3k4XjSk5+A53z790Kwlou6mbsH73wI5Yrv+W/8vTZgnkpYlc+rN/PWFT5p04A09SNLJ9OoyQBtcF4MyjsAOwJ2Dmc1UVNrBmb9AEJZBMznTAtZFgEU1M1g7YA2UzMRZXxblTlI/c5t2HczH52w5UaLA5rw8Z/1SXj8v30y/vsfvBFf9+n/WH3ihKwQGOZsDUSTvoC6QXoxQC8dWJoKKQvhs//Bw/BFj/4C/OZvvg7/6unPBrrC0CuuRXtMZ3aDZqyRhDDl3nC1TKU1QyxYkcztQKJvQDS0RSy8IBGFnOXRQo1Ugg1zNRmQJaOy68KYAmidU3Vu+SSZQ77muXc4r+fH5X53/uMWDWcA8OCmY7JJJnckTP1B8Zrcbh3+bfPa+l4HgAZKWkwBNDbco/I+lpoldqPohxlEt4vL9D3rm9SDkWMHlc9ZXmQFMm20Zir7AWQbjX2/wPnIALbbDKub8oYroDeLj9c5lrZCaA+mvUKZ9iBaMchISCvE0ibgcBaFNfMAM4OZMQzQYwjYAK1WDslrJWa1dg0bJtOIwxmpOR/xNWOvWvME6NCgFcxgh7MB2rRmiNeoriUlZjirX5gRPW6ZsshIlB7jWVNe97rPPmrY+MDVn/hwPO6r/hFe8jM/P0+mAuj5TvKf5iBKlOd+7dd/A5/39/4hji9k24VqNlvPz8n0uvy/vFfcI2V/W4Ck3lt14m0ALQ3q/7WIZAd0lIBfYHBSl1RbyALECLxTOLvfGC1jJcjqwJIYmLUsnPmpyWuOhL+6tRTgIwhsI3uIldxkQgRZKfwALxCm0CI86pu/Erd5v9viAVc/CPd+4H3xx7/3hjgPQhaZ3bppzQ7mxUzaC7B0yNIhBc7/4EsfiSuvuhJ/++9cDTo5AVnxFqLSolEQrVVrKinKnBLrH6AyoeWMidgfsa4/xBYcR7ot1QJjSylI1q5pAeSpp+tsnaHtnIp5XSdI/flwTh/nz3a+3rTHLR7OAMoJnqXqCl625+a/K6+xNa7B6sz60lPu8a18v+XgPGTzM6UG5scim60fCJzk+vOdb3NnfMnHfiG+/xd/GO9697u362eBL5D5rMCc31rAXEBctehq1qbNaBXSvs+WPykF2v5z3Dq5qsTZ36yRFc4qLQ+A9kA7A+gM0vaQtgfTGbidgegMRHsQnQG0h2APDs+P+ddkQERN3sMAvTJjDPUpj5Ea9GhqRPbIexZgsGRRrQpnjwHwOAAr/CFVe96LbRH+Z5Qc5QpoFO0ZYcrOhSCMbl5O06PKZGRXrbjWXIK+RmrN7NtDzfnS+96HZ3/bd9uBzgvXtIjJ9o6isrT53eJL7rFxeP/ND4evTD/nb1Nvj0c1Z2/BfHRyHZl0NeChBj54kIo9J649d4QmLYuatNVIRKpZmuZMLQMavTyulumkMGu3VQOfPJhMq3dqlofnSst0GiUGkcZERJUvD7KylC3yBUuAV73oP+JR3/hVePf/fBf++x++KUzvOhTMmrq1AAHmBVgWyLKAFtecu1oKFsKv/sqv46Gf/on4kz/9M2C30xzttoLI2uraoTaxeR/9AzjmC0u5D7pOPz3folt2jVm/UAX0HJClZm1PqSJkZLfHTUzpeSWWJNfemkFNmJqXBJjnnlZyo+b1jfn9OX91Sw4I84sDpPRzuCzUsJU5QGyyblH5eXP/Tm9YpVpzwXpRAl6gAczmj/JAZg1mpghqlh2Fv8pvevcxxeJmi64Mwl885y2441V3wDXvejvu/uj7KhC2VaH20KIUx4pPDMDrLkxw9rZyVu5Ic4itR7OcgKCdpppcAZIr0eRKkFyFJh78dVvdx21BclsQ7HlcBcJVgFwJIk+j6rF++gWr5zcL7w9QO0On69Ha9ejtfeh0HXq7Dr2/F73paP1a9P5etH4daNEtluuA5X3A7nrI7nrI7hJ4dwm8O8PYaTDY2K1YT1bd7gbGjrEuA2MRjBIMFi4JeDCYpkB5cJ4MFChTgtnKaXpwGPZkcG7WlrJFu0dIh9i5F61IAzGnphR1TSZ7qrYgnOplhwRoqop32gggu9a8L/u1lNnIEQtaLmyIRWyrB9TFad4vDgzc5S53wXc855n4mZf8PP7Df/ip6V4+T0P2/XMXpzqZaiT/LOnlzZwTLItpuI/Y/cUGWdoRcEJqrj4h4ASgEwJdsP0LpMFhJ2TBYfo3bSE0Cwxr1NCbtzZd0KVj4QWdLShs3WE3dLvs7ef9Dst+sdHRzxr6vqHvgbYHaC+glUF7dVvIukLWPXjY4DPw2GPwHix7DNmDZYBlDQuNTKdJo8KpdbS2oPUF5Ntlh9YXYOdwXiA7Cwpb1KQ/usR9s7aBta1YSceQPVY7hjFWjLEHr6uO/QpeB+RMc/JlzynQ+v20Qk0Jqwk0Vs7ULRDNlA3vJ60BYdEgFovYFh4kVn8/BwsHnE0onkuZ9OgWp21dqWypBIPpNj2KGT3BWPFe/OdbV0CYoErss3Z7TEv213F5TrANZ9nCvSwPhHgPVWxl+jsu+6HEutYV2heZQmILa0tYTtVzTCsiJlx5ogE2t7l4G5MINh8alhvXksu2as8F0LTRnt0EppV4YBqzTn6C1gdWDZqm53zfcw4jYMIKByDOoaA8ESMUnWY+JtqD2qlpzaeQpoPbqT1/CvRTSDuDtDO0doZGZ+DmK1iaugXeG3hggDFEMKxYwypawWlE5a4SHwBYjrPEaZxM2q41RxS9RDGQuh8VvFbS561ntJRcY7E31oAvRk3wi5nnYBTWpUUsvP9YPhhLMV27plwgHJpzhW+F8BGzzJTbPONzvvso9hPjhJe/8sX4sA97AP7BFzwCL3v5K/Gud70Lh48bCeX80LKzAXNMrvIcteO+5iqVt1bgrVqwWNCWmDbtZm8V0vW13IFW0ozYcoOpJQYI2v6TWNuHUjMDkcV0taYBpKoxM4aZsmcBtphna+c7H1y208JTz5ddQ1fVWwORBX21HqZs6gpk6kuYtvW5BtqRpo8tGuVOfYA6xenz5kHNc/Pd6eyCm60t0vNeEG3fNbkYwAzaCFpaetTOTVGyyKegzVexfW+hqUq5WzspNGb9M1vpyRKsxFtnzFsHt3dhi5oYmPlyOIsbbs7jFg1nIJeF82DsDy+JwOWV/ndCCehaCN5/76d9OvFS4koLhLcFmHTfgBx2UvUVSiOlgMHMy/VJwFoX4If96y/AEz79n+KZP/EcSy+gTOeZtCaUBfrYvh5wgHnjZ47URwN0c0AD2ZHJoQxrRIF8DfnrpitgU9e/pp94XyDJftdEzdUB4UsAXQLaJUi7BGnXg7v+jHYJ0g3c/RTcz0DtTOGsKgaEVjApoEcFNAzKm6ElNTWCepRT5kJWwLkqla5sFliHL3ovJc1K0j89YNHkOi90TgzdxyiLRpm/1aQNkxBq2H+VBr2iigO6NpcWf87fw/cFk0m7BIFtJIT6hN0TFPu0ubN8+95r3xv3zNnZ9XaiDh9yZO/yD79JC4irSWaK0jZAEA7N2I3SV9wpKmTp731LWcbyoBmEgvqFX/jt+Nt/4yPwDb/0HLzw938WUeHL6lLBXUGsXaxGcwALWtuC2QqNlHsHhgmtnlUDJYe2pR0WROkZC0Ur8H/TeQuhxYWRBjQPAlvMlL2AliXN2osFvS1A80YgC6FZzW09TQrFLl3nnUsgts6I+6E7IkgyOvURsla3ux3YwWzPScK5iGLGZl+AzOJFqsUSKpT1fRzMZNHs3oCWSdtjDJlbZdSq3GnexgRosbtivltulXCOSwIgl4ctsF2Kr7e8F+v0eVpl/+li1wk9aQ6ZflXHUU2Zy3aUG3wEoQLOIQ9G60bCq1//X/DLr/s1NfeMJaLNsqiBfrBMQN4O/V0WL5oB7cdAqFp0gjm2Kdwe7JdvY0qyTdeMTkEtSRoZHk0AOgNawpkcwu16G5cKnE+Bfkk16n4K6megfgb0PdD3kL5Cui5Y3AaYhnYbs+GJWDkymM9rXldLiDefuGK5Ene66s5461+8deJkFDvxfspu9q5pVgFnCr8zmCdAA0hI56TOWSbdPrQnmCM2AUUi5IRwQNlh7NvNRD2YycdGOajNPYGDvfzdJ33yp+EJT3gcXvGKV+G6970XN/y4DJyp7ERKkN+tsgGzwwdlwlaoOnwdzL7fIT0BrbCu2/r3un+bi7fBZ97n74KI8I1/+yvxI3/wMtNKbVgsxmjme/b2i3YIo2kgUyMPgFJopwBiyz5ZVDRWiLVD4wJpbiNLvUZGwKEnv/Zp9u9PrWXhkcVznbuatSNyu6GZG0C6oC0M6YRmBUlUOx3o0AY6Em3w9Ny1Du2s5tpxQwaKVUCHpkBHt9Wdadg/mIHTugxgCPnCpKxwyyG5P1ndTN5oclDH6i0z5FjTSfdPe6b0DOcct2I4b2Hsv8slZIZ0/fPJjO3SmN30s795vlF0TdQJ4evi4aAE9MBG6q5g9gCSDDzIXJ6mRfFXmvJaI7+1mK/pAMh8CGgzc03BXz5RzSGlJur82hXEXUojc3F5s1oMZRoJZl84NfpUTGvWHtca/CWuNRcNWSGsA/0SuGjO1AzM7Qw4gLNGenMb1nzEwByQljBfB5hRvQSSp0uAO11xZ7zx6/8MS1vwrF94Or7lpd80WS6kCkoOatOUp5SrIebaLdfILSuT9lxEwcnEbPafbdWaerCuCU+trDII7GDUz6ghKAeM3D5xGYiWu/Ls7BKe9axnY74/b+z7lMd0e9f7EWV+YZYSQ4IkTBM1NGayKGurZW15vTOgW+nU1Ex5I1RgvPvsDH/ynrfjHre7K376j14NaTtII7BZwzx5mqRhRGATmRs875cGLl+jrlhmKrZ8XZ9YYpBm0555eJbCsBrbCeg40yV6PazNxToAAzQtNvz8WGESdhhbmpl0oHctF9rJqpJJQ/eAOFHXAJvFIKPRJdYGOah5jhTgp32/5ls4z+t8hXJVtfT3FrAWkCdA1Gytpm0tEFRLlwwqlbll29OK7LNqYlYViG7FcK4/6y1bfQlbKNO08d/XG8KlsONLiUTak5dqiH0B7vU37o1v/LpvwQ+8+AX4pd941aQ5R+qLJf6TmUdCcqeM7IzcYmt7qM0bWlaEsvxW8hxXU/tk8BE4l+cktWeyoLDUlqf74kAzdg9aj32J7RTb6DVwp+YCmu+hYPa0CtZUKfMfo6tP2cGLfilALT1hze2Satb+uuZgPgPamnBeBrjbcEB7hDZ5F6jc1j4+W2/sh9ztw7HrOwDAJ9/nIXiKHIEzCzKQz35XorszmRrpZ3MztJC9kadObSao70i3rYmVk/a8gfM0yu9Q91G29XP8Cam/2B7QDTwS0Dft7468vizI21t5s0KXCUwJbZ/ItVSmba+8zW3wnd/4TXjt638P3/ezP53FN1qBtgPamkO45inlmD7ou78YbSGtutm16A7iteZ3FtWkh0E+5AgyzdlxIcVNYMFNIt5LzwG9Wu6/C6ImjHoKYcDZfa92qGQrl0WDS6M8X6U4So4sMSpdq4mpn93v4QZpDmbrf0V6H6DZOmNehUYK5TTWVSjneiFlMYr00/ib7cqcDhVdug2WVP4IGWVdvN+53pJrzlZjjBYM7DAmSJv2TG7iPlBFykhhSGR7vDfu8VcIzse3OcVplhrtIZunxHzO4QuN0203OqpkpBB3LRkAXv4ffgkfcNe74xGf8fm4zQOvMI2KUjJ1U5vNOuI0pUUt6Qj4aQB3hbJ3r1kpuywNzNoaizV0dyDrEG6ayF+c4frVUjR1E0+TkCU3cPYeNxkR6fsttiXRgHy6loAVGnYje2rFgPQ9uO0hXbVf6QpnGHx1VDirr5m6msFjdPU5S98r8M20zX2AFwZ3GwXQnkZVC8XUqmCMFLp+8U2vwk/93o/jfu9/f3zFCx89Zx0VX3TAmMXUcpmuk7jVw/tGFlO0MrKuRnU+o2i1pjlXOPvvBQXGLjkIJkBXDfkAzJv9gyfPB+zd7nZX/ORP/jj++I//GF/yJY8693U37nETtGkC3CqTUEaSr2rKRzTmn/me78VDPu5q/OPPewRe+9/+EK9/y5uBtqj23NrUIUo8LiRWFZrkmHo6dahmBXgwk4EZqlV77y5NB9IKVynUkGq8AogwWql+Ff4SSkCzmbWZtbwni0I6inz4CbM1Lqy8pQCLL0HazMPhjAiEC7O+n3NvvUq67ZMQRS6fRKD8lMZUUsMC0hHdamBGBXmd7jWxj8ryrMeRgPY/bvrZ5rKqbSjD/ifqbxYsYNGin0y6XSUBfV5H6PPM2rOAeuMffyXgfDwQZd5XCOdzvu4pXhHgBVKF9OfJJxBgs/nQh+OL+KXTSwCAMYatjaRaswGaqDSHt3wsNWk7nGs0bingHWBuCecAtLizNLRkiRKNVifZq2kwm+ZsgW9hzk7tOUzUcc8aiCWhrL2iCqBJwa1KigfV+bnT5gIqZYt9NQti6Su4G1T7HryoBi0GaiynBdIK5tiG1qy50GhWtKStauLrIwHtcO6CYVp0pkzZMK3Zo7QnSViAL/iRR2aZTl+ID7RnJKTPfV5KFL0tnFzecKsq+DwOXrUEdzVtA4cAPtCQBWXVmCfxTX7Mf/j93/98PPjBV+PBD74aL3nJz+AnfuIn/1fePB+xtkk5Hb4aUz4f5i/BlC+7TZ3yYiFmwr72fe+Lj7p+vwf6TgOiuub+ikc0B7mUNl5SNeM4/BJKJl+Y9E+wOBci8z1T+p7hhy0F0nq/ehpfdziXQjuR01+1Z14nOKvWnH2WyGKpG9iEDclpZNI4uZnMao5TgbaP5gsE3MUnxYgjNuUSTQ1erlafP4zWqYK87vv6Kw51FwKaLW325iIuIJX1XbIJsAaG6bnlXN6VBxH4kioHSweTVeiWnfmfdxOch9Tq3C6E+fevw4M5b/q0v4XDuTZ0dFDnfoU0lVxIQab52L0Dn2S5AEiAWSafSJnMdU207YMf9nF43D/5WrzwZ1+IuENL6T64KcXhzCaZe985gzN5EjV3M2u32IqZtsn8mrr4swGayximfZuv0c2n4guAiTbud479AmmRGdDQzFuVLzeA9kGwMn0OZxiYzaTdBdxYwbms4L6ClxXS96BlD1lUk5blFLKchkYN16pNa5bmW43S1mIl6WsW8zdLSzBHY4uOqLXtWUlRZhXlxnK+YWaeryV13/2+UquXRB6yTIBWN4eguhsSpMXMHZONc56L7zukpQC9gnkzOWM183sEZUHbvPYGH4cvfM1rfhWf9mmfChHB7/zO79yUN7tpDwrq+SqLedL6oNSWK5gX3zZg6XjEv/g6fN2jvgy/8YY34E3XvEM7KnkKUWjQ2sIR1uXp9heuwpu+5bm47YUr8MU/9m/xU3/42ry+liPvqTsCvQ19ffJ7zaOyo0Rnh17brtdYPRICWTS4qy1WhlIGqBR197K2DmdhDQpzOCNgmaeJiQzQUtKxVID2yE9yOEftbDJN2MGXfnLXzhNGaakhM6s3//1GeMyymhXSue5WOPutRU3jNBiY5nUWB9H7RtA0bcuftY9wMBMsaM07eIlpzh4UFm003MRtPmk6z+98DpxvxuMWDWeKu9F/SiDHbVC0ZZtZKYjHTQ4z8fiVQ5EK3cQiMWFiHwXU9k7ves+78S3f8a8QxfIrmGs0tmvGXp3HwEzev5itMMiYAS3DgsM8TWdAW8kNyaYPkUbTEGk6oUXrjU/F/raFcqZGzcFeDdWcjaJBIwon1ddTfUMCattM7gxeRm4XBXTbrWADtG7PIIv6lHXrmnJWDkPbp+ZAqjV75KpCmsPnnA0wckhozxuZXjDtVzBvoTxp0XW/+KIPU98KoM/Vco9oGAFUBzDNzx+Fsr3uGKCrtBlDyu/9cblFRvDUp/4rvOQlP413vOMduOaaa8rvtu9z/nscPKj8PZXXhRmbYn5N2nP4mIGojT0BOuHMjfDsF/4IsOyAZTHNeadgdkBTN5O2vvFnf+jH4o5X3gYA8NUf9+n4yf/6Oj0Og7NrfFwuAtlSEKuTmEnbvmPkNDc22d0tTSpcNh7aRGIDZwW0w9k6VlmFPIk5NastDRrcJqatSg3GahYv0nRQ/Ew2ddIYLFBTvDacsM/0G4K1EY2uSwbvbGYe4E6Iu5lJ4LYr18ijeVCDVR/ToC4ApiWnm9GhrHKrfvcI7BfAg2CrnVwBrT5lMQCLdAxaMkCMHNbHTNsuGMxrCOznm8PnWzSc8w5MmTSnfgttuYI6dOu4ISR/dj9p1ZJdOm9l8vpENmk4gG4Pgi/WKrmT5el56pRODLUNuUmbyFFnTSytPWDCWQEtoUEji1oMMUCzVYfqRWv2CWhRwJE+ZZ4wn7wToO0Mit/IM5Bd7ljs+YUqoKm412dae1U16WJarKg/eMcYywDvVvBuBS0reLcH7faqUS9m7l48Glu3MFM2h1kv00p0q9HZTGnGlgnMeXoOwXwYhR/acjVlH4C4/O7Y8xPUBQ0d3/aMZ+J//Nnb8G+e8906gSqk/eftowI3YIsCWdNeXHgV/6/Z+7XNz1s4U/2QG3jk6373d3/3sr+/eY9yf4WwXe7NLZDdJ1r9zFENbAbzPBYDtA0HtGnPaLpwEwg/9lu/i2/+zD/H+9/mtnjKK34OGBf0MoyiM4kA3aAkAJvUG/KGSX/hUQth3zTGJiZQDjQeAefmuetS/M5tQIZpzaJNVGAmbX9U9UV/GhpNDgMrdYW8bTNQ1daxet5F7xFiLn9vW4+ItHKyNCytK4JVC7xNw6ZJCDUw+3mAROKKlyaNzlXw7uLmn98A8pgrJ90QBmbvf42MNNdCJKlB16GAzpSqLPu5FaPFztjxvP4betyi4Ux2o8xQzty1gHRozL5FaNSZVVCBnL5S9ctwzApqLmUioW2LAZU10m8AkQJn8uPRyUCmPXtjdc2FtDKNvOg+LwbmAmhLqYoqVUMlUpVQVXIma7Y+RVEUSCuMGRmpXU3bVcJOrbmufd6sx4tMqs5fitFXk50HjhSDgZY8FYydArrtGOOEwbuR42QYqFdgWSGmXcPSpNAt17OZ5mBFR9haLjJpdKsCWrVjcT9zm3/epgsLcBhXVbTi88A7RW0frDdSXksAA9/9Hd+Br/zHXw4A+JO3/hl+7CdeMrNs4hod/uwagNMrIOw/H4N82U6gPgbo7UHcFGj/Lz7o2JMFxlReV8d5GvPi4xiglxyuOVdAk2rPauFqOFsJ93nq04Ewel0ExqwJSretCYPaCSJjWPRwtQhOuiEyYErA6CZcNmI0by7RVlB3OFukoQPatGZE+pQPj032z3XTtNZz5wBss/czc68FfJEdk65dOg+JHUvqAyfSYpYka5jf2xjaf3p4K1cGWYMWT/2kDaTrGRCDNJufebhw46fLjirEyeCwC9f2qpmaBczbrQNXo7JlKkSyHTegOcftsz+v7s5lH7doOAfotoCmFlNx0qAd2GSvtD+LqGyqUPati2oqpWsbNw31JzOJRsBYRHj7xHEtlQzEadauYNZgE69tbRqz7BTQPANaLLXKC154MwUPABOxG5RXzMQp+4BFhWJSSny/rnGHkC4pVSYedRAWIvQyWsnldFVarNuPN2xnqzLEO2CcCNoJY+wYfDLw1Y99ID71k/4mfvhnfw0/8PO/CNoZmM1HTV0XI+1eZYtTKSvC8c9L3ttN7lI4uTnbT03RlFF8zVsteFuZrZajnhOlZ/N1KgTT/rXvuVZPvQje977r8zpNIN5CeGOO2JIqViID6bFUjoC4j/MAXUBfZvaNe/zvgDgd3T0qR8Sp8Tln+72OVgC91ZwN0n1JMPcd0BzQGV3hnaYmTb4AOUy3naPIhpupOeDskp5MkmAFDBsGtF0iZ/enNoBeo7Y1xgIOZySc/Qgb1NzbkA9djeZkSMZqZm8PpIUFVHEK/JxihII5c68JK4hXNNG8awXyyHampk1TmL1NqGGJ8xhwNqGaAPUKSs4s/3Y1dt4fAgFboFgEodk6KEVw9iJAYmDeblM79lKeffNcKeW5kcfzDPWbMuHjcYuG89z5yMDnucL2vPuIPI3B8w4JsH0UKPtgAzCn/8V+rn1WhdgAzbkQVLWzCgwF0sR+TFY5iAJxBuedac27AucF4CNwZpjJSEJrFll1cnFGlOpDpo0eqhQoH/47sBKiKCaboQZ57UrTya6Fh3oSAa2pablrNx8fYweQNQqhEwFfEDz8YR+M1gj/+OFX44df/UpgN4Alh3TTIHxRKkSMHsnR8Uk05xMlaCVuJJluqDBnu8naYXyQr4wZ1EfBjNkHfSC9A1//5G/En/zJn+Ft17wdP/tzL8dcXGRDHqlXoef+9LpyrcPm7r8b9j7nifEV6tv33IKWjjxX3+d/10PKveSHZMd42WAwIFIIJpN20Zx3R7TnXjTnvgP6Cdpygru93x3wZ++5LgEdAncRg1zzawlmsJqmm5mowz3WNsEJQjpXWdC9NoKoxYrhaYq6FhEZnKVMSNL9uBekTD5TRhxkRXUAyQBDC4WwKRMNFFHNbJZEDfoyixyHKh21s6XAGaLas/CqPvKxQsYA1qGNO8ZQOJsWTayjmrcdzK7wEKSGCJm+QSbA2Fzw58u3jHAO5DlFgwHa1keLvBezaLE4rC3qW1RQYdg+snMV0ybPedKB9IBvlXnOCrTUngPE/pyBmmJrryEPvjAteoos9htoBJC1Qr1NQIOz5whmHViZTdweERXmbNeYDdacx9WqDuodongH4h0gCzB25ndeANagMO/jq64dL9fXIbwGlFnURO0+r8l5Kh696FmYQPjjNxo0+VfBvO65+bpq0Ko5NzSDtFdYikIO4W+m6G5DO6CdCMaJgC4onN/01r/EB97zjnjdf3sr+hUM7Bi0GwrpPiBdFzhx4amqsEVziVQS22cpgC4aSo3IPtCYzwNz/fk8MB/zNW9E7O/6nu9F2PwjkZMQ9Q0rkKWKQ1sn61YQk/kgxAFdH0ckhnj+PO0Z5XX/Lz0O1rPNMRRDQcrmG1BX07Z3njpm2t5Z0REvUxlFSBa05QTv/LffittevIAf/NXfxpf+wE8jilZI0xK6QuZ/1fWAvMAO65aaa88cwYlhlQvJzqrEWRpkM0A3Bsgincn0NFceQBZFDVubotC7v7ehKlhKRW9WkzaJlrWkWC8SzGQap95TeocHzHwKk+JRaEC8bq03M2fVoGUMA7JqzwpoRrMg1kl7LmuUC9HUJPzyPqMbYK01XdEqM4UQHqQJ0GVpmEoAkO0TldfQZACJ9yEUOOfPKSwA4Wv2A7uZt8otHs5Ns2sPwEyWM5xg7gHnWjoPdvEDzn7jtA41FbnfeZj/ZSDLT5JJjVCzlZu3J0u7CwRpanezNokdl+j3IFGfM0kPjZm8B6WZtsUit6MkqEmdHgTCRdprBuZ5RiqcCIIv+uLPwUd9zAPw5Cd+K/ZnZ3pOa9R2HRslJcPugGZm7Eb+7Voxbdt3b81SqUi1iDBtE9oOGDuyNnzAuCB43DNeinHxWowL12K5gkFm8saOgYXVpGeLnYRhiZE1pT1yXbDtZJEWRHE5xYaksrkF8xwcW8pxnjM2vmW9u92CAsSdjbI/gblQRmZnQgypgD6m6crmi5yjYU+v97E1c9fX/v/gcUyZ3z631ZonQJMFSBiYrS9xas82ugZ+eZT2nW9/O9z24gUQET7hg+8FkOUnuDDlZm2TfdzVpRa3BLLXjlYtOoMVtcQfQTBCgBZpZg0jU7INzuKR0Xpdyf++bX0tNrxGNxRietdHqFRcahIyQOvSN/we8JsFi2rNnDE+OY2r88itdjqiRelYFcxjgFbVmptBulkwq2vPnkWSM1Hidmh2WI3co0BlLpBxcK7UxSZsHAC6GBfi1jOpJCLLy5isbvCIAAnt3RnsLjKfn3pJb959c4uGs2ucoZW6Jk11m37d2qybCFoAwMBKofn6hHeN2apaeVATkaXqmKTk66ibt+u6GnA2nIVJ3RGWkG7SDM4GaFZAz2btReHMCmflkKCxaLk+LpKvwLTEYuY1Uy+h4UM/9D74dy94BogI9/pb98AjP/MxoTkfUVuOAxsO6RoI1gqszToQmrPnOTe03tK0vSPri6tgpgsCugjQRd0fFwQ4YR0BZwNz23w3N5E5lK1CV/rmbXGyQhFegakqmQfVvopr7wDMxyB9Q2btycRNOA5mh3IBsnji2pTAhqNwls2XOtCyt49jkK6ArvNCjuz/vwTuY4fqz5834rRRMW2jaM4o2jPNmnQ0v2hA63jHddfj+b/y63jIfe+Dx/zIzyHOvei6I24J82MadvOFu6sK/GyAVsGfmglMlF9ShNG4aec3JtDwbcJLrV0J4AB1PDcACLx8ri5drt15ilEOknwrMi0SEBN0FxV+Jdcq1/IDU7a+sIwENOuIdqVjVThXDTp8z7qGhVnblAeXawl6GQWYjJFqBE2NIcoqE1RcdzDD1krxNZMSzqNEhRNsXZBDQJfvqZaCEvxl3c4meTsuqQs4N/1xi4ZzaM6uHYemnH7cZmlKDudmsCCi7GQWpijRG6ax+m5IA47EtT7yrZu2K6SzHqxv/car0eKOZvX3mPnXjl1h3QuYU4P24XBmds0YYMszJIEBWs23gPb/Zbd/i9fzblj3a5zH00tn8FUwTNvTed6e91l7jn0q8fEmiExR2w3R89b75LaFMBZKn/MOoBMooC8ImgGaLgjoREA7UTgvppWY60GEwWIL2MiB1Ybb6leEtuwP16KlgFVuCMx1jLJlwLuGHTVrT1rzgSSXQK7a8mTKXsoocJZj0PUPHrhhMG+BfOxn2mwv/ziPqzf4l+f94bHfH4CZUms+pjnX4LCAdAF07U5lBPiKH30JgBMVjmiB5QPGORdJsVbPjvtKzZxdwOzCPzddi9hIE2c7GlX4PU7addHh6QBjywsOwhqwSzArWUwMUQLL2znqTQAFoRGQDE4QO2YomJt0VR64uF1cExUvQGLBqD481YtXS+9UKIv7my1yG36fhuY8z5TiFcxjLLXAJX6282gvDtOzA5qtaEl0BzTtmVyLFmBwgBneelPcIuABcyq16y3smjPDTf0O6ZCRSWOBbs7jFg3nhgXNUhtmTbmjYdEtdRAtpsV1NG/j1rQHqVrD009ETU2mHgksrdlWO6oIIXzOtd999cEkmIGtful+5warYy2mQwvpDTBp1KVSmC0Iwt2iCVtozswNLEOFdiisfQaydI2arJqTEN7wB/8dn//ZX40HfeT98G1P+147o4dgnh+bZfUIwdOPT/MwUyOZX14sBUU0UF0jth3MJ4J2ImimNdNFDkCr5myANhOi/3MLAq0G5xUZ6OfH75W67OfDmti5v9WOA8z7Ms7TnCcNmjaQ9jsXG83Z4HkA6CNglgroqhXXh39oL1/EV7p6TW9o+N8cA7MHGd34x02G9jFJkY7sT5DejMn/jA2UaU7Wr13jLP3xwJpRm9OYf1IDP81PWgE9ucvYwD/A4VojeAEktWwN82ebe8osYnDuOlSLdYQM0D6oOZh1bWPSVVIbUzhZgXAw+7UW/QDXEBsczB3tSBm9iOkQQWSKeKAaD/M7K6zbGOpusrQqsoqGYj7n9C/pZf28r34SHv64b8D/eNMb8M8++6PLdTVBP7JAkAoTtGZ55B67m8/KKEeL8wbNSXct2TRojBT2QS5seCJp8SmTKKyrULCRtd3cjVsnnBsaFjicM7BqQSMdCmiFeLMSfK3NcKZuWrMFGak/c4X0ZnBu4OIzdUhzM3NLna9+kwUQ7MZyjdmBXAcXM7DBevJNG83EAS3NfCmk2iLYblrRrjdw85NOKIaCX0yS9Nnziv/4n/GKn3s1KKaePnKRDMNNOeuSE3Tzytg6qBEC7SQBWzwNyOQO6qJppJb3TDsLDjsR0AUGLghwgXV/Z4DuoqZth7MonNsAuAtoX6AsMFO3nxJ9Ptc2mQEd+eM41JIdzseer6A+0JoLhIF5/5jmPFMFCmQnyw5HteeJWLlwp+a8BXN9nb/WP5cxHdcG0DT9/f+ex1ZkOPjlMapvgXwMzNvTOZm6t4OOn8p6YH7talvXeN5f5qbZBi0B7FozT5oemp1pUg1UW0J2iAwT0M1NVcEMie2UkhVFlLIjHFmPZXKAJTngKUZ62QuYyczUYHQZaNIt6pq0ZkN0hxHz4VraVi2AwqYt235jTatqvOk3bVD2+I/6eMgXfTl6X/A3PuhDcLs7vT/e+e6/MIOFrsPoFdBm0fSBlpHVHiA7kIUTWS8bGlRYINEiKZS1IjToT1NS/Szr2q43tpjpNV2eOW+iFgagvveb8biFw3kxIKfW3GhRrRmL/V4h3Q3Q1Bpa6wrmrr1FqQvQJbRmHR3StaauQppUgW2U92O5Pxt08rOZliK70GhFFnChsWcFylxjzhWiYQrGnCamk6TB8/DM22Q9LwTDJHqqGpgt9jytYnaTiuv0kodqe9vFsWqoUbXH9jmq+Ai6LTJhbiYLjCFgKqxvo3W2vrAMWlRAGosYqBPGdCLAiZjfWa+XF3dopjUrnAVtFcOMgFn0+jJScfRvW9l1zI9cfpZjcL6c9jwwa8yX8zNXf7Nf763WLBvNOQBdyXI5OJ+nNdcD3JLsENB0oDn7Q58/xs/LPc5DO9l/R39fD2n6g4PDPQfQguh7Ou0j5iWijFQ5yvpjnDrS0ytNg6QD0GJijGvQrl05/F3TUu222YLPsRKkIA8P0qxKLiy1qOZMS+5nBgpH3Jret3b/k6CzflcRgVCHC+IaAMXowmBuVplMNXlyl413VpP0z8LMwFnL38qNWv2F5nQMSgrAorVZ7NSLnRoB4We+7zn4h1/3VLz5D34H73rP/wQXl5h00jW4m7K0ATTD18imlkW2ANRBXtW4+Jo9Xoi1YAo1aLcvX3NNmDHBR8yvL+H6MGHBb916sQjAODtnll/+cYuGc/fcYHKtWWHdaGfa8s6gvKC3Ba0tBuZmA9YSTaFAnS3YaIVYOoVYc3GfBGyWLB2lJjPl8haBRsAGzgbkAuY2KAR5hTP09zXdC/oegJtVPOdOoaw1eqsm5q+P+xhAseZe5iFlBTr/H8fWIzXrtkX0pgdPDESlMFswat1esS03Pf+0MIZtaWHQTkAeqb0TyE4gBnU2YYAdzr44mS/Nmwnpx0v9opr6UmF6OW34hjToagbfmrarclqjtct1nbRmN6GGG+KYv/kc3/ME5wrd88C9YAZ0fX0CuurKqUEfV2ZvyuOy2vLmiM99g/PAfABoFwr9eTnyOxumlUZZuJKCGPk1EXRIAWph53refwRPvXQtCwbmDk/fZOrQu3iubFib0sDhTL61Y3SBt5i6yS1qdqfGuuTriJB9vyqI9Liru3SwsCoLTKDR0KwyIZngKSULQqGcgCYDtFb/GlH3X03fBvPaHMOFGZ9aDfi5H/we/OwPf4+uu30zFluTu1kzfX0mitxjNWlbQREmyLC/WalkLrqVs0B3qGlPzCzqFgaHM8gB3kJrx/bWrfPv1ghnQjdAd4OygRkOZh2uOfdi3m69oXXSjKkFCmdP0bF8R1laTABvEKWNExTMg7I+M8PbDvrS5zcyVPKtcHY2DbOisW2HCvEuuHsjmGn9BuBF3n3tr/pwfWxl/5ormMurbP4i0y1mTZkv829MY5A2gyfSoDrrf6PLDQm8oheRVfdqK9AGWltB1qwCfaiwFJYM1u48PixfupMVaTCtmaCSeBt6jchMegETT4CMITOYb8hkfUPm7GMm7e22BoMdaM3ngfkYoLfa8w3Buc4K90VXn3Qrrz0GZj8+2WjQW635PO36+KO+y/a5+R0FNbL54AWXBbXM+36Tef7QdmwFFguoTJsoIRraeDe40QqgKb6IQqchihhRK59tizz0+azLoICp1lGK/zy7RH/OOtM23y1dw4PHyPzgLRaBNG8LMEUkszR0aWBmdG5orjFzU7P2gDbeMeFTamc1y9EmS2X0bTNIR+aI+alRPpdgbn6Qac4AyK2UFIAepYBR7Dug3eUI8zuH649Uex5NNWdyMGNa3xLMI66jn1fxe4aaWhlaBXPCmdJYmfNtPb3c9D/3cYuGc0dHL1HZbsbutENHwjlGW9Cbwrk3h7NpzouAogLVom0LlwZZWpSaZDOlaIlrQXdAk21RFSWXDhFa2hS0OTIotDukIehiZloxf5FL6Z5DHUKAGsAGLL83PzWk0frPEiigBne/IVxPToxLeZ8MC6l6seN4QDuaruonoxXNS/dhj0F7wOIBQDCzHdlxDAB7EO0B2hukdSukhfwR4M60tkidagzp1syCvLCeRqg3q11MVCI9fSmq1+KYT/kcc/XR1Klz06noMilVRWvW1cdmcgF09TlP/ufzAL0NDDsG5y2Y6++4vO8M6GMZ7+THCyk/J0pvqibtgmL9ub5PhfTBp53zYXe8wx3xl9e96/BdK6RRweza4/aClZD9GgDm7oqwkIiCOVwZRYO2j9IgMdWcXYP23GOUnx2Yc9OelEmoCBnhHqoas13fvAcMziLl6lNok53FtEuZ0jI7qzm4DTIoG5xXpPY8xDIcCqDNvE2e1igMNkCzaF/qTE0q9frtlFIxDQgKdA3MY2kYluHBsTYThoPZtWe3G7jWzFSybqjIxe5jb4hCU5bhJg1pMYH7mB3MDRE46HEKdgt6kHEkUKy3Qs25U0M3rZnQQzN2LXmhJcC8NAd019G7wnkhtMXhzFYmcoXsmsGZavVMjC46mo5GtoWYdctkLOGwgpGZvMi1ZmNOH4K+KuQ76Xto5V7WPsqeItVUAlUfbvE1e5QnMTzsuJqTvaWb/3MzV8QcutQdkiHNejPNeNYmEkPB7FusaNgHlOdQZveDyrSv5rs9gDMQzmy7h9j7NPJ6wUo87VerjdqE0nTevCGASHwv1fkcxsW87YLvMW35GJjP06C3UdzHzNmT1uxALmAGCifPVfWwcZTi8oA+D841UnSrTR8bFQq0+RkxR+qDztm/qY8K6stD+ny9/I3/6fW49z3/Fn7hNb+Eh37lw498gm9teNWZqdVY8XWIRQhWMFe3xQqF8yoJaQe0uAadgq/7oM/T9BXMxbpFYltESpQLGeT+c+u9XNCbPmd46U9JIEECWipIiAFM0JjRhmrObVQ4E2g1KPvWAB0WqAB0gtnvwSZ6n3pf52ykI6F46tdyibr4jxuBW8NohNGbQrobpA3YYdY2OKtr0UzbAedN0FjckgZfEHS9sesbhZtMgKWGWu0Qlg56YNwqWrTD+bz5ernHLRvOaszWSGczcTcsWAzUC9TnvLQdFgd0W9C7Abo17wSncN4N0G5ArGoQ7wiycynNNOZF4bw2xmiM0QSrac6NBAMdbBYn960knBPMbQB9hYJ5VTh7WfWP+dgH4uoHPxg/9F0/huv+clU4t2ETDGCWSMPQpXcDZgtaaJJgLQXn5kH156p/z2AmN1kbkIfBuAWUFbQKW40sDh1dBnr5uRmcm5wBcgrIKUj0b0XOADkDyR5N9hBZNcJTVrAFleiNzuFjdkuDKhJiCpHMQB52HSYfsxwC+nJwPg/IB4FgmAFdonhnM3Z5DtPKi/PhuR3HipH4lTwGa9eQtylY+bmHYM4HbbbzczM2zwP1jQVtfe32dS7mbY/iXvf4mwCAj3vgR+NAGhKEVSnAHGmHNthuzgpmbtB8XRSlWixPl4G1w/utJ5xbAXR+G3FwGqSJzHo1mXZ0X1+L+JtI02wWfW2RVNQRVrrw3cI0ZoM2iQeQ+WlIQLdB6EN9yG2QBlUOQhu8AbNpzis0MMwK/FQ4R43sWjDFgbyFMlJrblYQKuaemf+F1ETNrYEbYbSGtTfVoIsm7b7oMWnOBmgGeJDFBnk0N2Xmls8LWK2KYdfCBTczeQecvYGKpeaRp+FNHibJ22q9FUZrB5wDzBa/TR0LOhbqWEyDdjgvbcHigO4N3XzOzTXnZQC7DtlVOANjJwZmxroIWmOFNGmUdyM2E7MhTWBBEohSt1TA3FxjNq25k4L5NldexDOf81QQER7w4ffF4z//G0CcQQfCAqaG4Xea3+jQVolNVjM362AMxFQl08RDU2bEghHPub5doW5wJge0ma9pXzTfMxBOoYULzIcGlzxXiEUHeD5kk9WgfAqSS4BcAvgU4FMQnwG8h4w9iG0MhTR7X9th/WDIpPNN8RGy6mBufqswpi10t1C+HJwvN87zNc/yT6HMBtIVigegPgbsLWB7eb96AO5bPl9TPg7lit0Z1A7iY7D+jM/8TDzpm74R3/kd34Gf/LEfw/ZxTBv2588DdWiSRb0mKa+38/ut3/Nv8CV//4vwr77nWw/PfV2Np77CgvQ3V39HasGTtjwE2mFJEtJrTziPhLMHFE2ALlW9xO9LC2wsiczTViwtyuHsna6op/uMzHTtAVY+2FxkHrHdjNBqyrZAqUFoq40haAbjVjRmMpcNDSopg3aPeTpiQLkAugrPWyi71mxWBqoRVda2klsLQKvmbIA27ZkN1FNQmM1OdvmLyhAHM8X5gvB8W7qJHk2/qFc6rGCOfHnM5QcmWVmAUvDppjxu8XBeYFnBpA0XlgnMHTuD864ZpAPQDmdKzXnh0JxlR5ATsuIYmn+7LoKxMHrXse+W7E+sUcKUNwPD733Wa8sIybMNQe8Vzhxw7gvH9xNh9DZADua4Se3Gt0VKzLzbZUDbva1Q07GORkOriNmCANt3CCegAdXA3ThmgCYF/MAwKBei0ZkOXIIa5TUPW49fhQaRBU20aH6PYgUrRM7Q+BTEl0BDB/gUGKeQcQqMPWjsgXUFratumwaakfj3MHO9wTkqgqkbe7OPQ/ieB+YtnC8H5O12Dj6YoXxs/wDS9bGxe06Q3gK7vqZ+EG9efwh+2nzWFsP5W5qOdnt0APAjP/5juPLKK/F//9AP4cVH4OxHRZvtjXmNH0Nq1IQUEYBvePY34xu+/Vu0Zvau29eX+bpUE+wwMPsFJC2tqZqz5rhG4NeKnF+DFdBrtzFSgy6m7QroPHLX0kYIzTOkXVDwsQF0GV5b35u8ZPMIVwoU4A7nLHaimSFgCTjLqpHMGp9pUC4as/4M05wx3QM0JM51as0ocN6AGbAyv9CaEwXMHq2uRT4amDqkNYymPZZHa6ZB9zBxR7BYMWtHXROXdWErXWjLCGOSXh9be91VWO8V9zGX5im0kMZkelzmQXajac9nt0I4N1jvYNOgrS4YFmrYGah31LCjrsO05l1bsPRu2jOhLUCzoDDVnBXOvCPwicJ53QmWHWO/MNrCaJ1BfQSco0sMGAM9TKsiFH4ZWqGftQKtqfbdmmqAHQrXs7Nr8Y1PfCI+5mM+Hv/h370Qva/pUra2c8QNNU+yWVCUg5ikBmfpHeSgniT2ScWrC6Ri2RcscihjxXAw0xnonGIYEu8wILKHyIJureZEgG4Vg2ScQfgUbVwCjfeBxvWg9ZJGN66nwP4Usj8D+l59AM0jtDKaW4UN04KGVQfbQ4uQ7EXlhjMU6MrlgbwF93km7BuC8bFxox8Vnjiyf+x15/3NDY36/6wdn/fJnht/3tH9+dvfjnve615451/+5YFhHZv9rawygbpoyQfx4a41mzKpiy0dnvOa51jdGha0M0Vni/md0KDzzP+WiuVFNlD20WY4V0BPxUkUWO5jEQxo5oIeWLRepIFoW1ujSX3bWY+fDdAeBGr7E7Q9SLI5nE3LFgtcG7Da8wpj7VlBAeO6DTD71mUaF4AixiPh3OxlzQPAzCXX6mWQap0xwzeZsA8FNFMvgO4B6dGOaM7kRhFJP3u3SdNE6yQwFKAChPQENpmVVAGAq/eURWqs3DB2Bc4nuiWHtOfOEyC7WyGcFQdkBj0KMHsJkh0IJwbqHB271tW03Vpqz2HWboA1YxDXmk8EfSdYdwbmZVjald4o1Fzi9pu8pDAwtDuSv2SFRmG3hGqAVRqarHj97/8G/uC3fwftbIfWF715vIB+G2BrLsFhFhLT3rUij2q6HqRlVXpoYO5ckyuYTPTIZTYrBYWTFgrmBepnPkV1tkiA2bRjWSE4A2Mp+YaA8EDjFZ33kHEKGZcU0Ov1oP31wP6Sgnk5g5ydQdoZpCkxvUSgl1h1E6FrQbIKZC+QMz08OQNwJsAxSPvP24Cwuq1wros7X2ZsNeSb9bjZf3gzHnSwd55mfEPoB4CPuu/98Jmf89l4+c/+LPqRT7ucIaF+63NBLQCICpSPALoWgHEXe916q1d/8+jP6LC2CO2IzJY0Z6+LbTk15huEcwW0CsQUZFshxd/iKYZiqYg+yGrJe59oWKAoRREQSXUxwGwQDdux2sbIfnStV8znTCuBV6hZu0K5HMoUEBZmbXuvgHLum16hW7K4ENOaW8s002ysoSt6WOJIo3GEOoZDOrbNBmFQy9QrQIsjia9Homlc7hLwXFWTDqjZxJK4SDoHQ4ogYMGsLe9IoRxD8nfV93xagzJv/OOWDWfSnlSNKGraLwB2RGU07GgLadWke+tYrBhJizKSA7IQZAHYzNljJ+g7RjsZaAuDAs4KiWgt6eao0pfMfToYonDuYjX13SekfuDGbNV0zM/TyQpomFlqMKRpypjn1zUm62nq7+UmXyUKIW1QAehzaCJlWdRIb/U0x4pGI9/PAsDEG8+biJioZzBWCPZg2UFE4cxMGszGjM4rZOzR1jO09RLa/hLacj1ouR44ux60XIK0U0g7A9MejD3Yu92MAemWWkUlf9LN2nsBzgRyJsCpGKQT0HIAahyAWbZgPk9bvhyQ/1fATCjS/Hm0P089p8v8bt7StK+vuxyYb8xYz87w0p/4CQA4gPN5GvN5I15kmhDBLEZ2ZHqaFH5RM8Qj5GupyUGhEE+SBExzsmpZsyY9yt+jwLlqzq1s2wbO6Xeeo/WVit5EgUIVNQG0pBNSwNma8RiQVXtW7Vg2QI7v40JFVxhJk/lamfLQCqBpdUBLgXNqzw5pvyeoLHthjQ8feBqGWZRvunXDtWrMYdIW05o9/Fl0bWEssWV0MOlWAd0Myi0LkEwGFEuVspQpv77aChgIE7aXJxML2HM4e2CXB34tAE4AciBf8K2E9owTmL6ifyu7WyOckX73aDqDmmhC5gqgBHQjGw1La6o9R7UwgXesEYvO5kV9zW1nUN4xsDM4LItqb1Y4QyU8LXsHCLS1o0ulegNknWkHs5lPZEQ8Cjo2YBatouV5eESAtSnzCeZmdfugBDStBma3jStdqq85AlGQC6IGgxFyZVoBapBIkbLUAjRE+7RIvRpg7CFyApYFwos150BYEmSskHVFW87Q96eQ5RJ4fwltuQT0S6B+CUKXIHSm2rfswbwHryt4P8CLLlZRrUxETXOrDYfxaR0K6kMtGsfLcN4QmG+YfZd/OENrpaYDIB8b9QB8vxLncn+XP9PB/nxovt2OSFU7eP7w7449bgjIIsq0w6PJ0wU/VaXYB5hALVOEwhwdkUc2MgF+BlkUJnEBeyBM4gFnKf7mAewNxFNA2GFQ2CGc/XoU03YNjjAqSs33t4YWUSyBNd8/I80LrGtp0uH+av/scjKN9b726Mc5mMUOxaAd5mzawFkSzjIPKXOBRa2cbvHjphksREVr9s554trzosI9FoOzATq2HaPYH0szTV8ZINMz1RZPLk3YGqpzINpWlsh4BYoElMnBfFF0a4OOaM+y3Arh7AEGPbYOZtXlvNnMbhquRasJvFOBcwkh5Ab0rtHZWj1sAMsOWBTKvOzAfWDpCubeNJK5U2kvxg3sErkHZAAAPM1H9M4oUI52dhGMaykUkSBtB5pvhhBTQ3Mv4q2YecwB7TAuW8A+w98LDX7nckxkVzs6lGwWkR1gBlxnVpP2HiJnCmfp4OiiBfBg8FjBY0Vf9+CugKZ2Ca1dArVLQDsF6BSCU30f3uvfrCt4WcF9aBES+xdwHoDsbZwBciYQg7NUM/ceE6ClFhvZ+pjPg3GFMjb7tPm5Pvxcy/YN6hv56uYpcLOqLpufczK08h7H1Hvdz/ecv0zNg9dFVTbwlQnEx8PL8hTU7Q2JHccMEP58fSf3PzugSSi051z5K6C3ULZhQNfXSIGzfaoQtA40UgtdWaX2lVNbXglTKtUmnWrrd56jkfz+qqZtL9CzzqOtqT27Bl18y+5fDkgPmTPsmtj5S7N21GGZLejhU9aPFsCDwkxImUzZk9acUzc+A4DqxKLFVmwGqmehaM1Rga3HcDCLLGDZ2XqygGUBSy+jNgPy1a2Ys70hh0dfm1XQZxQgUeCFoCeFSLLvwiLATszXDO2QdwGA9Z7HRViDHqTmvOj5V6vqTX/8FYBzLd7h+cJAJ4Fd1qlkQ4Qwmdm7NwV03LvegqwBo6tvmCwqW/qAdIUy9wFeFoy2oPcVnczcYhGYWiFHC4/Em9vdSaEecNybYsnsYrlzElD2RUOd1uL5fyhQNDBmqzOfiAnm8M1uSCMG5jRr23GSL/juc/YzvUfqT3rvZ1MMhrg5Gzsw3KTdzaStfi1uDF4HuK3gtqK3M3A7Q6NTUDsF0SUQLgFyCuEzHWOPsd9j7FaMZWD0gVHgzMLgIeDqdzbfcwU0PLX6TAGOfW7PhfJ55uvtY0uhKjzVc+uFKeL1JrlP2vMM6C1sw18Zi41/0hZts7OcDr5M5r9vNekEs4S2vI0Rvxyob6zm7EdCZd9fx0JRPaqeRu+uRh7URAlocldSWJhMmPUjjJumpXbd/fXApJoXAXpOnXIYU27HZhvdcVxrdkAfgXNYp1R7Fmj1vKygtyLyMMncaa49G6QD1MOCn8LqJpYn7d8tT7DHpimgJeHs2rNryK45R21t5NYu2gRnzGAmEwnyZ722Cufia54AbVqzLBDZmYtsB2YDNC9g7jYsJ3oSOw3K3ieytPjM8g4Sf0E2t7yIi/fDRuesIrkT05xFYXwRBmeZAV0it2/1cFbDRu53+7kHsBPcC8kcY0y10YROYq3L3NWMRGq+XtpiWnI20uh9wdoWNE/xQUfDAIvWyA3IKcXgEZVZEZBzPjZA2gouUPZJojl/wxLz26bCzRaQXojE+pFSaluy+VdXUHF1xH820zaFlJnLbjWEZpvMEXAWBzNcsvVKPaKac+PUhNserZ2hkQHac6blFMKnEN5DVgUz71YFc9ca3oO0tOgQbX7BQ8CrqCYc2rMBuvqbq2m7aMyyhXOlyHx69HFAIMFc/1mOvch+JZHaMpm1Dwog2OIygdXB3OobgibN2eF8fgTbFsxbKCuYUxzb7tdxDND1FG3FhgplKX/jSxnb+zEsoMhXzy2kq9Zs2jFRiwYGWb+6DF+oPW915N9mcWcDc8g4DmcyDZpMa6YNlCm3UrYxj7aiSXXietClmbiradsLpDRLJXQNWlKLFrPUkVXB8/asAeZ6j29kBA8e85xmKbCWkb+LCG+fmi7Ll+mrH0HTdZ2Hp05lQJj24HWNObfCCmVhHcw7c5XpEO7goeKjluz0pdaUFRmQMYCxYtspzguloETZhNuxifXFdjizmrZ3W0gj4Exb7bnDlJub/rhFwzkCqtBi3z0PCWwHNRugOeIAa1tXz67TR4OGminstA2lFfagVRO2yNtVapAW+XA7EtnNT80kXEoTNcGiBu3ebTz5onMGJ5zF2ivx9C1hQRBm5LSgBxYpgLYhqSWXE1jgrk9JngTknasJYsfhnEKBltdcIbRD2C2k5fA1hFkBvQ4wGZxpjwYFNOEM5CTlM8g4A+/24N0KXgZGN0AT64B+5+FwNkDzXkdAeg8LFMOsNR/TmLfqXTlnN/hwr0Bd/OJ8evlLqU9hUmOkpIgdANlHIrGKU9UIfPzvEtR0sJXNONSULz/mvzmmPR/TmP0op78RAFZMotnR5XvZ0QmZQUoFPyLzN2cbMgVmBbIFGmVrOYuwLu3/piOJgxQ7dSNhvAJZS50OwcwocLZ9SAG0v/kWztWc7Rq0/SwrwMPM26o9k5gw7xp0k0i9pGKBi2pjKIewVeLdkldM1+klU+H6IK50e0FRvuskevm18+XNBCm3YhStWWQBWONVhBfIWCB9Bxkn4L7Tn9sO3BaL9THVzMHs1kDP7uBRLBtUfOUMkq6WTtmU4bG1tzVzbXYzc0enPADWdz6Cwi4ifc+mAbLcCjXnXFD4yMjKWCQlXEByEYq8O/iCQnHvNAMKS9f0JAMxyQLCCrL+uhSlYdYinZcmAl4qLirXAzCYAq45pdYOuJAtEK2pBfPWACF2kKUPbPWg0mPZgCVkfpeQmnOd0OOqcJYZzv6cCz4y3PhjvzKNGaalY6C71mwiUPiD2DrMMBTMpHW6dWh9bh8ke4Uz74FxBln3kP3etGb1N4/GWkKVGEMM0OzaM8CrDvU/myZdoIy1gHkb+HVDJuztOdqCfLvoGazTnVF1SYXycQ3a1JnQnitop1lr75WatEwHsAXzoXl79kGn+JUm7UNNuZ+zXwFdT5efygplR9MxkPuDRZnZhEL08GV0Nm+bZ9NM2BTRKH6EGQWsgO7qP44avh7kaEcTN4rYqTKt2UF9cFr9htxst/nX9QdXPy8L6DJcey4lRyW0aCmgFpNHJMt2kqRRwBe6Y3D2w9lWRgsBZZo6RWumEk7hgmi99g7mcu0MzO5vliI0qdbsgN5Bxs4AvTMw7yCk1jkRLX4U3aYsbkCrNNp5s+8TZnvmMppGjttaHK1nyVybrkUXSGtdjNSiFdTIyG2H83psEbnhxy0czqnZhQYQWocCuswsg6z9bqqp21BLyZBNtJw0diMfGa7RotmE8gjm2ke0lIvzRTr0nbhurBoAkFou/HUOwQbvR8Wmy8YtHetBNV4XM3ZRAqK2bF0RCQlmKoflxwbXXoZ+BwCQ8jnikZALhPYB5zadC5NoSSBDNXstCapFU6KJhuxBvAJjDww1acuygvcWCNa1rvlqmvMKNWsPNu2ZzbQ9RO9LD/hySG+Cv2QL5mkhzXMS26oQYPP6aRhVuJj6Kqy5/LH7nX3B9oOpUKahc3ED57wb/AP82S2cGdvVtUL5UHM+DAbLGI+SKbHZbrXn+tgqWQ5mP7I8dsrzbM/ona5Hla+pC32YohDWq2Ng5g7wklB2MLdi9fKbo944DDVr1zSl86AVc4kO50Q9EwHncp0iIqtCuvibxYeZogzMXjEMPSON0RLK/nXC5lXkQJ+Psyyo32uagiZ0hPmaN99NyrWLWWkpb4SI4I6DsWvm1y/M2dwONee2g6w7CJ1AaAfeWui4AR4z5BcsfM2rfq8K5rEYmIe2xkQzC6qmd3moUAtIc4H0BtCLWJS2RLQ27UTN2ie3ajjraucRrNPWA6PEhz6n+11ByGzpF6rVxNz3snaDIEN9WNIauCmUNTCrpeRmvT5duxWviuXBUDaxKVIPJL6CWOs2bamGTLss9YAV2mTfrBboLJY1EftZigDvxTotmIy8RZokLKmYvI+qMH6gtkjaHU1+N3s9YtHa2lrdR6u2CYqAwn5lvLuURrk3aL1tkhXEK4j36iNaV2C/KpwXC8RrA6O5WVt19lXc76zxOm7JEvc/D8xg9p+L6e6otnxgSSino+7XvyvvU+Lq4vdUL7BA/YMOaFQt+shqT7bYHIC5Ggz9o7Zw3oI5AZ0dy4AK5QTyrCXX0Tb79eguB2e/c/3ILneaxUzYKtj6kfmrTZBmPVoK8cG156oxL0BbCpyXWWumPHq9DAaabS7xyMjoCdhRKcv/Zjs/JLf+wrjOHmHlcC6aNNmEpZF+5ur0nYYBOYptICxnBCmzZANoEyIroFF8yzmvZQr+gp2nCHT3q1KXEysa41KCTJYJ05qr9kwdMjqk9QSzb5sBGuaLlg5hLfGJ6l+f4ExxfWiYtjwYjTtIOpqo266BtO5FyjZRmrmRgrltAI3YQiO0Fxi0ddqN5VYK5ykIahoKYMYAy7yvg3VrzcTBLYMoyuI+htab9bZl7Anv7sWWpmZb+51rpQwL7Tcw8yDc4cKd8cEfcD+89o9+Cd4LVYYUCxVDuFmrSJ0ckLwJ9L6wJVUIt3m/98N9H/jh+P++/D/n0kuHy6/+eSsQJmRifgEzWazvMUiLn2+247KC+n5Xe/AGrbqNJT1NjwpnfdZbP3azATTRkXAeCedF88q5D4hpzdwkfM63u92dcP97Pwi/9JsvS83ZzdsmaPk2wHxEkZRynqfvf569dTo3caIjiol8FRRbGNneLCANuPmxatFZ3tFWzcmk7Zpdyw8KtB1DtP5eDmZFastV0pjN2VUTPg/QchTUW9N2PVUM4EOuvhp/+Y534C1velMRBObXSTnCZvtR9buUe/QVWdyvzPNRkvswu3ZLUyDbMI2ZwqS9ESviQAQRtW0Apojkzm1U6nJTuGuTB2AuRKxWEgdKjcKq0Vj+s5u2K6gdzm7SZvtKLDMt60zZCA/i83Z7WCGkxNSJtUmHpM+2mLTjGkm9vj47XXtORQam4Egz4I5FTde0aCwL7RTK2EFwgojoHh3SW1y+tCKtFmwGi0qv5uwB4m6VGRsatPKi9mrYADrmfwG1B+t6LrSZv/NGUWC3diuEs/tSxQOgIGBLI2LhCcZDtKPRkBWDu3Y24gbiDmFGGyODHlZNaxqruqRG01ZkKxVtVWxwAw9vaWbVatzDbXAeDJzQRbz8y1+LpS941R/+PJ74I4+GrAqQtnqLNqBZIEYbYhMpJWJhhjdGR2v46df9Ak5OTvDaX/5VPObzHjvrRxSVtFVc8Sj0gHHLMnYmBkdLOl39yiTHtLhwCA9ikNaVgFxKDXiklCwAuqjc3llFqoYENDmc2cYYwBiaMrJa0RfTmrmpz3qQoO06Xv39b8JuOcEv/pf/iEc96XNVkTEBS2IrYb4utVhywamLFHBcYz4P1hs4k/uVy2KWcUaiwiDs2pp/kNxP6GfLFm530Uw2R1gZRxmbg3Esh14UUKYjX/YwQtt/rlduNlXPEM40xS2gK+LyaHR86Td9Ex79Ld8CAPiHH/ER+IPXvW5zKlO0CG8TzNBAUP8y6cIfR2vCCnGDtK73dal8QH6kvNvA2QC99TcHnKUM2MQieNGP7G7FgC361dI1/W1Nkav7IR0WGtaSu9suExiIyiGT9O7CXG7dsxJfh+rZLYewPZwNiN3ap0sEhfJQz5bzvywfeTXjP7JlhKb0N4RZWzVnMZehAronoLEknEWjtsELpGtgnzT/gn7w/t6Ia0WsRZpaBbNo6+FO1kipEbqQl+GeGnfUOIztfRMzuMT4jBqEexMet2g4u45MKJ2HxU2dFigkjGFwXq0f8CpDfZrcIGOgR89SwPt1chMMGyuVjBuD8sqEMazZt/URHVY+bpCCeYAwTHO+7VV3QG8dAHCvO34gRsmW0Fq2Ei6lNsz0bYD++I//JHzhFz0aL3je9+LX/9N/AYvg4hUXsdvtAAD3uNff0CrahMnMHUu5zc8Ac4PeuM1BzQHqAHS56VX5s0knYusKaw6qlf3SfbUWVDCn706vmb6joLEW5BMRsLBpzWxC09D6wQ7nbtXAuqZgCel2kOD9Lt4eS9fz8Lf+2geBL1lXMIZp0EWxODYqkG0bQTN26IT8GgcqHsrfllN3COUNoO1NiIFIffFtueG3i21A2xZxseL8HgMeDu04qCp5bKWQ4/7lY+NYMJiGSB4C+jzTtn/qB3/ER2jNYgD3vt/98N8O4GwwPnKU5OZt6MKeJm4/B6Y5WwzIZM4Wg7EUSAec7VtR6OY5Odwf4wv8BDD9XeTSck4sKtqsVCDLfA0Oabi1JxdI10YYtfqHB4LF1k+gxJzLebuBRTmUuP0L90sRLbOSS0C61m05ADTqR+aNJHaO06KmsT3iVg9qGllNDRhWJYx6gbMB2q6j+qQ7onMUIc9NxPno9dDobF3/NUq7o4k1HiaDMho6EzobnHmGtPanzi3MghgBnybMuN9mlc35vpGPWzicEZGcavBT/2OTAmYMrMLa51gWkKzwYC4eA0tbMaJvKdQcZHDmZv5MCPYi2tCIdayDsC6EtRHWTlaHgGwAw83PrDD/vI/5fLz39L1453V/ia/5wX+C9QyRJdFWBzSi1kAUA2DgGc/+t9jtTnC/B3wY/s4DPhIihPdcez2e+7Tn4pM+45Px1K9/FlaUGHWak2Q8RsbBLA7mloDWNC+e70a7QyP9okxEmHYoDfAqSEys9b6rNAzENi189o/1WjVh08Ytp9CkWwy2BhdqvuOmQgTbMTMJ3nHNX+DbnvfN+OS/85n450/7KozTtDTGmuoQduVkszZOt845dHKlahtEF392ZK2NINyyxtag/fg4E/DJ3qhqtAeLeaRY2Zm0DxbR13tuun6nijqZvucx+eLY199CuQZ+6T4dmLaPac95FMC3fdmX4crb3hZvf8tb8IsvfGEsQvUUmh4c/Iv6IDBRRIrmVcHsg7vmOnstXAc0LYBY+yDeAdRBtCBM2lrj0g7Izz9bug9MG3bt2V7DDmId4sFaBc5kgigOrunGonE0Qn8D7Qpytnu1RGirwujzBRtaHgHFPE3gLpntWzTk89WaElvJ6+NzqW7FAB1Q9mEWxuxGZbNslJlFaQWJxsnsuc8eP9AAIguAEwDDvq6EsKRaswFZepqzYZqzWIIsl+GAZnivIwUzIy0K7ECWAJPf823cKuFcUys0LoNITQ4r2Hy3JinJUAJyh/AK4Y4+GkYj1ZxXWISjBn3ppZVI01E4C/Ys2A8bq2DfvVgQYSWvSUBa6Q9aSm4w8FV/96vRWsPSFvzRn75RO7tYa0PeA7QnA3V2giHLyXvvtdfiDne8E97z7ndjzwRh9XP/+3/7A/je7/whrVuNblqz9bgiOz+kJu5IMfD86qkvLEfXqywO73ep5lEKuGjNPgHZFgK96YihaSwW/Cbl+qiPUHIBoNTaWSSvlYGYLApVhm19UILZx3Of9yx8x/OeieijLUjt2RZUlycmAtSHabYO3wjYnR2vWWjKJ118v5iUM5ibZJN6MoELuTQhNFbTmglws3aYySKK25BbQmw9ZSogjfQ5z4A+PFZfQvMfyvZw/3JBYedpz8fgfOld78K//JRPwUA2xtjKNtWjHm5TmsE8AzqPjsIAaeZtKhpz0y2RAZpssbdgsPzGZcK4+yAEU3PohqCnr/VgU3I4w4tg6AtJUtjN96+m6So9bqG8fa6CvRyru0p8Lk4qrb18K5lVhm/2Hbp1W4G8hfR25A3lAjpltojFCWjN7bS6EesMkhqkN7Leo1cdFI+6HwpniVx1P582w+O6jdCWSaxGhXSFMqzPAtS0vXBqz0uAmQzOqsw1y/mOEX2BJGU8EbT9rRDOA15+pFwLsYVO1FnvcIZHafOq5d7GqhdjEPpa8oypW7CSyalmFl95YD8Y+x0rlBcHs2DfBStJVvND8RAZnN/6P/8Ef/P974nXv/X3sJ7mhXQoUwCaNk3OCZ/26Z+CT/2Uz8TLXvpy7Nny+TwQzQd0DCthx+Yf1/6msIC2AuduWnOX0EyltswLs5mHMyvkyBelKTpV9z3ISi+DRaejLLji+2LrkUKlEZf3lizuT35cqd1zwBmR5TItWQXQx1x+dQsgoVx+9lVnirvq8+8O1QJMayxY/z60ZQPzpDHDF0OJfQWxr2UGaD+4gDKcFfBXiT1ZIRfXYbtkFlv7VhutR5eAJvvKZKeg4q+OWYs+D84+q+pXSyDPQkAzAa8KC/GHJk2RSVKTaduDw8iDvVyDdlP2AtBOtebQzOxbhmRTTKNYodq3IH2k+aVkCo5M7dlTNyMgr1g45jc4pkEf2Z4XKDFp5fXM1ofEdzs+D+exhXCjGdBb90UDcOHkBB//kIfiV17xSoz9qB9doGzz0ooqkegW0jRA12YXUYm2LyU9NR1OA/yENcBPmqe0+oRjzB/OAeQwZ8c/BXQT1ZwXEDoRlmZwHqZBDx1R/8WtnN6vxGU9F+JNiaH1yKW4EY+/AnA2XwVtFpvwA5g0yireMA3wWDHIwExUigPpTaApUgZWM48rnAfWwdh3xn6xbWOsTXSQDjWFG6CNXZ/8zQ/FnW5zB/z5O99uWUdUAO2jGaAbaNWB0fHuS5fw4z/+EmBtJjHqli0v0MHM1NScXtqnMSmgY277NuBsAOwViO7bUo1BPGc8wKwQzdxHsdVW7/CqucXaggQjbGlyIcolXbJQUdWa9bnqC4/KP2RWRfIwwCP6hOT26FpFR/Yd1AXIvmbLjcgTmsBstAlrKZWBI0OQjcaMRlv+Q1KSEAAoi50j/jBExc3cFNu6/FL5QmS+wH/+DV+N3/+d38cv/OzLDhbrNuPvqMn7huBcH/5cx6wxz5qY/RPEMVZNX+y86H7Vnrcx5Law02KmbOtdR+V1VIq6iOvuA641R0R4BbTDMfzLVkcBlroJjafImWo2JSlaNG1ha9ar2B55zRbObrL2G86FuzjT5UF1XiFu0LjW9vsmsJ7xZV8O3RsuwL36jX+Mu3zAB+Ctb3wjPv2D758fZtcpih+BorY2++zyWBVLqXJQk6WqRrcqsZx0LnnqDufQnHPmafGpAua6JYM0dTNpp+a8cEMfdcsK57UMV64WifAFvUcFYNJ0q1PcrMctG86ipTOj4m8NRDLJRWywsEZr08CgFSsXOPuCSQyNQXU/iMGZGesYOtYV6zKw31c4M/ZNsBJPgB4iAWcR4Jrr/sI0TFJql36pauY2MBucvXk7DTfh6HBAc/Q7zcrikerlgLbez9wBaaRQNjibM0XB7HCuxfWdKjLmtWDYxBvQKOOBACwGQHUhsBvflEL7TSWmpWRRmmZBdtJMTN+CWYAENGYdYlq+ZD5sALEiOYRDiLC1NoBqbsoDl9eWHvWxMWlH2mzMrwJiYA6m8TFBnGYX4eZgA8SRb1/jSLff3fc2X0Bm1P3Ai56Lhz/yMyEi+KQHPRR/+Du/u4FhArOW6zxvXA7OsnndIZAPhZhyCVNY8d+akE6S+c5wSIv6oMP/TA5l1ZyJPC+6Hq0VDRUTH8R/zvOfX8rh7BqyVSPwOgvuhJOqNWtu+RQsVqOxtsGADu16Jmm+yofbPD0R71CF0XJut9fBteUGC4byfUqxbntL3PHOdwYA3OXud8eu+ol8rrryEK4JB3BKxRJQVjAHoGt1t7YFc/qc9Tz6/NmIjQb56mdu6GjNtgbn7kDuDctQ03ZfG/oQ9CEawLtXOLczAXUq97qkeagTcGkrkt64xy0azowFQxY1lwghqnO5lAbMcBbG4GFa86qXPeBsN4UMXeCEwnc5xsAYA+tYsXYDdFux7wOrw9nAPDZwZogHdII5PgJekzeLAanWjNW15p4N3YcNTj+LWF5xas99grNQw0Me+iD8m2f9E/zCq1+Hxz35+TGvvRG4LGyAtujopulKoAFqFh3ny6SlT4D1b9Wfyvo9jCB+C+oaY9GL5nuJYhxOTcAWqtjVZdHIFbFk9ne6Hmqwh8DB7JJ4NRL6cucfZkdGnsONmRYuxxGm3gjiQPbOMu5QrSbuzXttTdpxswZsZyC35vs16tUWLZo1xTgJDmYqMBaHckI64pV8UYSeJ5JuZ8tV+roQNly4cCHur5MLF+EaKRWIVx38wPQZI+F9DM5+qo6BeYZ0Pc3FrF1QrXK4nxs78W5Nk2odcEirCck1ZnJgFzin5x62oAtgrWAdOFtFNQK+puhDh3Satr0kUGrRGz/0BNzLDDp2VpH3Y5w8SddKAXT8mopg6HNTTFZvtjTYtgNoRGmTEBg+9ex985c/Gl/8tY/H85/xLOziOqXFJuo/WEaLu9/IrRE2h8EqVBEayEx+2r1K9zWy2+Hc8oYjc0v4jR1CkDtBHfipORO1jNhGQ+OOzh2dBzo3LNzRB2MZgr4y+qqgbnsFNHXS4nLOEVHFxVtG4lLO2pvyuEXDeWAHwgK2U61QnhcpEWhKDTTVatBQrZlMax4h04EsREX9pRTpOKOzAnodWPseo69YuwG6rfqebWC1LkkrrFMSLK3HA5IYUTFsrtRHIOsH6xqzbpcE87D9AHMCWrXnaJqpWjQ1POfbvgr3+Gt3wqO/5KH4pm97Md553fWQxTTnRYDFtOZF22FqGzpvTdegUkNqCjCtkEIrFFBzc2gxmErZii8IxZd6oM7qQxUQMjBrsRR9KiFc9xlxWDOYafMRZUEKbZni6VkB24LZM3D856IuxN8hP6xqzW54mMDsWylbhnVFy5KBOo6EaYlFs1Ygm/Uo5wCFaBKV4eDnT6BaSERV2AKoYPrSL3gCnvFtX4ff+63fxet+/XXocfL0v9k3mSA7ZjTfyi/+OO8129ceX9LmTyZBpOb4RZUIFEv0V0+263wkagqlAPOsOVNcWPU7hwkdFHNXALMIudk7txXQNblRqsZ8FNA4B9AoN1UB8nTT6aD86gcSzzEwNxQoi0M3t91e0xnoBdSdvNWPntVfeOEL8aoffRFICCf+YcXKE90PxGpCmPA0pgAPvT7CG9+zdJApI2QVwSKv3So2xhfyc1Wvt8PYAU1qeW1kmjN3NCiYE9CMzoxldIXzaOiroO8FrTe0M5cNOGemiEYG27oh1x+dyDf4uMXDGdhZcQKth1ordHkkIMPKWoqe6I4R0l8aAhletzhrYiecubNCua0Yfa/btmJtZib3cpLwLVv0sMNZIrvCo5kVzgRvN+c+ZjJtmcZimrOVG7Q6s2ratso46Dmog72sKDX8ymv/CF/wiDvh2vdewjvfK5DlYgGzac4Lmwa9mgbdFdBVCnVN2IqiUCuD/BymGbKJqKbVJDVCe6+4b+wa1jUmNgR4HXHdL74qMuBQMd0GjG15CwnAVQH9fIGmN0grn1upMK8NYdqmDq2XW03drhmXR6SddkRaHlEufAFkhtbuZaC1LBeov9d5HNozPFDLV9w01WYXcwVzQ5aOVV+eLonZGDLPE8FroWtjF9eg9/s9/sXjnoqGvQoMqFozdE6ExOMA8/N9+NgCVza/w+b3x/5m+/r68+GnOjz1/Pm+m7uroKP/0mOa+0CatPM1DmUpX0T3LTVwCvaqYHYgVy3arkGBcAIawHTFcGTftlS2VQKM+SyRYeBCX0Aa+vOdbn9H3Pfe98Ov/cavJJhFzdid1TKrMLZSLgFo0t+hArpYV7YpUyiBq9AArBnK2zmtwBS37nhqnFlHSCyi2/LaKUxVAs+jJ0rNGdE1ULXl6CRIHQ0LGlYFtXR0S7VyOHfW4kl9CJZVl8u2d8VdTIDQxYWGRBlPNGC5NZq1h3W1dvmzw6bwgaRmlliRAmczgNs2LqCbCaVo3SPhPJqPPda2x2h7DFpzgK3HsP0zrdn9ziiAjvZywzTnUaBs2rLu7wqYVZUT9oLvS4A5Ia2T9su+5kfwpGf+HK5553WQfkXxNWMG8zKAZQGWVSd59ztZz7Pe/5LR2UMi9UxvuWZg4dAE3crkMKoapDMzllfRZQlbsyA1aEONrAcu/jz4XA05F60Q3GdtYvMg5GvgbkkDtGfgRJ5QNW9v4OyBYBZHN/uYXSPxmDsGuoO5pfYcxfbDtO2QTlOt2OKU2nIvW13U/LMVAqMAWuycsi1UntCkc5/cLIxWhIJyEv2kBqWOns3pmZu3NJ3z1thcwupAPXoEBtsSNBaQdtcBivABZ5f9L+XTNl8ko+XNMoZZc5YK6q2ZGyU9cQI0XMTMD91KsJOW7GpvPl/dM1P69gbSBOCqK6/Em3/9GuyWHX78Z34Ej/lnXxx9NDolmEuNNQO0gblRgls2cHYLj83Z7Bmo/t4R802l3qzFr1pyszKeBNWUiVRzJuttALN8oPm9EU5fgGzGxwkw47tB2d0b5O8vHYQFBE2F01zoReswMKOx4HZX3h5/7/O/FK/51Z/ANX/xBvQuaHuoEgJtXQxmM2nriaIG8K3TrH0RwA4MMe3ZtzW9xozVAnTWziLdtBadq45wC4DyDkoC03RFy0Wymra5wHkGs0aCD9WZ7Z9FE5fANHFbLEPB7C3SDM7kWrKDma1Ygifb807hLDvA8/7KNmrTmvb8Z3++hywX/KsZmEUDwRYGdqxQXoaJwzYa5bq30ZyzrmxPq1lohYLW7XWNFFatApoKO8VYbItS5O66o9nDltle6pqxeyt5BjJQ6K/Cg2qRvooS4L7w/IvgT5yjXC9mIFdI+wJYzhFMEIkFEKoJO4wdzN28Bs1PddPKRI1hAYpu4k4wp/ZW3TZbMKvlJBdBda3oUjkQPcq8z7d/QWumkZ5Dg9JG8/RzGKgggleOk8uM+rgxrzv2d5XI58I+BJJDGWwG78QypH6X1h/4c1KPJgWSyC+X2IMUKE/5A5HfnHXN3dmQoC7fPLThjYbsB42Dg0cpAr2J0qKo91zcsjE/73bXu2LpioEH3PfD0RbTksWgzLB0ImAxWGejXAOzpRx1OqY553z1fgTD4Ox+X0yA7ujwjnYW+Eqa6iRUzNL2ZcTcEpoTXTUAP0duwk7NmaSDWrb+JVIoNwOzNuExMVcWaCUwwb/+zp/GXe761/BZn/sV+PIvvXe4uyOgGGJuLdZEgK5aSDvdSvE37nGT/up5z3sePuzDPgy3u93tcLvb3Q5XX301fv7nfz5+LyJ4ylOegrvf/e644oor8Imf+In4/d///ek9Tk9P8TVf8zW4853vjKuuugqf8zmfgz/90z+9WQc/cLGMC1hxAStOsMcOqyzYy4K9NOyl4UxgQ3DKjFMeOOVVx9jjEu9xaZzh0jjF6TjF6VrHGU73pzjbn8XYn+1jrGcrxtmK9VS342xgnDHGGYNPGXwq4FPoOCPwKYHPCGNP4D2Bzxp438Frx1g7eF3AY8EYO4xxEoP5AlguYMgFPOYrH4bf/Z1/gy9/9KeCcRGMKyC2ZboIpisg7QoIXdTRLkK6btEuQpaLwHIR6BeA5QKwnAC7C6DdCbDbgZadbnfLPJYO2nXQ0tGWpqPn6L2htYbeuuaRt4ZOXQe63XL6f5PFZOXFAjKyck8WC2gRpU5s9ORmlgffkudWaRS5a+tswoEFs0XAFUKJUAuKDfJ91/p9a6btSI+93CivbX3znN/MvYDZFzwCFqIYu6OjxTihXn7uWJoN0qHnf8HSFtvXn1vrOqihNTfvadSq7pvG49uQXMzwasJPeGTp8sA9N5L+BgbK1hfbCcpB0QKreCTY0g9+WA+5nTdE0IXRpTiN4metBd9FNj9vbRfWL164oKl+vqsOrjHXkMZypiat2YEsZQJjAnOka09xEwRa6HCu7oC3XPNmPPf7n43f+r1fw1d8/RegL0DfQbcL0Dth6WZY68CuEXa+bcBJI5zQkYGGE5+rsHmKjh10u9jQf4uakdHRZV4LyH729WDbvpe4p4JT96U8l/mjKXFHZGyKGppWtwDYGbA1pqlhAcmC3aIhbq01NHM/ksUH0b6DzhrotKGdNtClBrpEMW7O4yZpzn/9r/91POtZz8IHfuAHAgB+4Ad+AJ/7uZ+L3/7t38aHfMiH4NnPfja+/du/HS94wQvwQR/0QXja056Ghz70oXjDG96A2972tgCAxz/+8XjpS1+KF73oRbjTne6EJz7xifisz/os/OZv/iZ67zfp4AVXWlCYSaKiFa7Etg1WtxmabDXIbhiwRchqTu0UDeuLjvgQKxnpDRdW3SfVnplWMPZg2ltv4hyqnRSJmpG1AgwuUidR8S2TacuqKZ/YdgeRE0B2ePpT/wF2u45nPfPv43nf91sApXkb8OAIKwRvec5omFKoVDRe9a5bmonGKCmfZTGxov6taTOGWHxYQivUyjnqi25NNiZa05pjnqbxcat5sHjHatWOvc6YINcqhYT5eGBquZS3tYW7rt/nPooGUlMtYfc0yr09adRVzbLDiWhYuIBgMC7aciMqRgo1DzaiMCM2C1YM7Rnu98wRwX8UeABTxzA8kBtnAk4+zKYjHdq5zb+gDjdFTn7WgjgP2Is8cpBWapOMQ561z9yvkN6Oc0Fd4D9dr7Kfl9wD3vyhcMt2mHUb7Wls37nngW32OkltV+dbasZxf8c/Rvj5JX8+X1w5YtK2n306H2jN88WcIH0AZjOrhibd7T50bc/O1bd897/UX4uC2athLWzLwtCxc4wRQe12ZOZuNWn3RmiskdfkPuGw8DSbmyVSOhYbtfqxaA1tFgMiVHjXv1lS67UIawlTQCs/b84NBOm2qSfGtwumXtlkzWZqQXF7q//PE78Mj/xHX4n/9Is/pmu0/8m+XB6fKtGhSkBnN7QAHX/cJDh/9md/9vTz05/+dDzvec/Da1/7Wtz//vfHc57zHDz5yU/Gwx/+cAAK77ve9a740R/9UTzmMY/Bu9/9bjz/+c/HD/3QD+FTPuVTAAA//MM/jHvc4x74hV/4BXzap33aTTr4gSvQcILscKyGvOwPzGg04kb0ziJkIG8MNfuYRqUMoOL6dHM0W560NmBgXhXEtBqUVzBWiG0VzCN8eyIOaX/fqumlZhiVb3gBhQn7pMBZe5hCTvCmN/057nvfu+ENf/TnEFyEmL3VawkHnIupx6ts/fxzPg8P/eh74jX/9X/g7/7LH7BgMJWu9c8lbbAeNGRSKg2OetiNLcKRHT6C3jgh1GY4AxlU5A8B4twI2NpQ+qKWaFGPjvpOAQtKckDHCsVH54kWOjGi+LUOjcuOg+Z9z3kWAzUlv+bKYZU8bt7qcIvapIW7lpz7DuS6dVirgbmFWduNrq3kNWfxGd2qxjHIA8IAIob3rlITrZqv2RfOSA8yKHsgVRTYSMyK2NMbQPME6HpKNJ2qPs4D8wGkNxp5XJeqQdpv7nGPu+M2t7s9fv+/vhmpbW76VZODeECrJw80i1DPwipiP9eIFU2r8EpfVtQX8Pu6OLDYPpMN6A7mhLSbtyuQpTyH+m03oDkC5mK6niqDbNwxnt4d1TAd0KCpwEiYsgWRXanmbMKOVHbfwcAspAO6VdN2s3s9U/PC9WLa8Aike7zMDkILGDZkh0aqqTZSYBcRYAL6YT06vyGlrDEdEZFErCfFqZpaBdL3JFYxcT7fQsA73vYOPO/bvwnLsqLvFr0fBorXh7JWjPUtAAnk/wSc62OMgR//8R/Hddddh6uvvhpvfvObcc011+BTP/VT4zUXLlzAJ3zCJ+A1r3kNHvOYx+A3f/M3sd/vp9fc/e53xwMe8AC85jWvORfOp6enOD3NMivvec97AACMqwCcwD3LZLW51L+2omE134a1I8SA9+MkcUjbgu1uTKWF1YZOiVhEy1uyDIhXGqMCZFpDMJDQmkdK1vY54kKAr/qTGSYBLaYp5zjJgR0+/KOeg3vf+65405vfA6EL8LrBXlQxajgRBWh07jI+4UH3ABHh4+57d6DtjBSwO1Q1amoMopE3haUcaMCE5QWa1qw+VEInVt+pw8XAPGvOlpLiIEQuTW7l8EVOy/plmzxd+PUPW7LWlrP623IzkMFYqkZ1zsOh7Gw65+cAtJ9X/8itf93BTC6kJKC9+I1ry+7P6/D0FEpAxzfLVVk1VkWKtykd5EUV9JwP+zuCizk6CRiq1SigLcCsfEE3/U9g9q0BOnNVS/YuadGdvK55Jaj87CLfMVDXkIwtmKsE5ClzH/nRD8Srf+WVAIAn/LNvxvO+50eQlbQSyBRCuvsVy7kCNAAIrHNVULRq7/PmhZMdzqMoAgpmtdR5hHx+2wxlnIEMSlATEFq/FG0toH0MymWfYvIAUZF0cqlIwrn4nf2tOkxjdkC388GsW0rMCml1LaJ0j5i5qcZFNFrUh1vbPhqQBy1o2EFdXAlo8q2bnimre3ketAqsacrSXGMX0sROQDFjhbasWoW0kZZEsyzOlRRTj2pFbs24JGgBStKPFCEtQWyat+yPKw039LjJcP693/s9XH311bh06RJuc5vb4MUvfjHuf//74zWveQ0A4K53vev0+rve9a54y1veAgC45pprcHJygjvc4Q4Hr7nmmmvO/cxnPvOZ+Bbr/1ofjKsgpjkTVhBWg/PeggQaGHu92aqJ1iRbsqYOrtJGYwcrHq8BXAZnD6IhDjgrmK1vFY3cl8hyDu0b+TGApWpNgHZfipjW7C3uKpxxomZtnAC0wxvf9F6ALkC8qKu4JOlas/sM7YSRSnPP/tHX4Wse8QB8/yv/q8EZ8FBiiqo7JdXAqisRDMqNbTR0EtOYqZhoJVLV0ixbY2J1SFzHEIFC6yAvGaoOiaQkDfgl8qVblWJBaM9FM1cN283bc3BYHsGkr8Q2NLjtsN+l6TG+km5s4YtvOgkrqewcizfTgJs0b9fsW08NiiWedOZ3IgOzFXRw3zE8t1wr0A/PKYWVThTdenZChXPdximzz2VJ4YgJoTGXSsoHcK7PO4QHjoA6wGwhUzRfC710eZU+8qMeFGkzVz/4o/C87/1hP0rA73G46dqEdVo1Zc2W9i5a3z2yDgjq8oIJqOJwzq3IQGrNFgQq+VlpCtejD3hvQO1nKKvj1fl0RFveArqOqi0fZBjQBGe33qSTpPCJ1e2ytPR27YgSzmL7kmBepOk5teAtD/JyrZkLZBPMOzB2GNihywkGnZgldAeSHRrplsiM6A7pKNdXRkRr+73J03nM/gEd0haDstZ5kM7ZZ6DbshuVFFNnkpbhLZOgb3IAjSIPNL9+Av4/VVv7gz/4g/G6170O73rXu/CTP/mTeNSjHoVXv/rV8Xui6bA1Enfz3PZxQ6950pOehCc84Qnx83ve8x7c4x73AOMqNFyAYBic9wD2IHQ02sOLMRAUAF7FNZe4LEzv+XAucXmjdCH3K/EGuiOBTH6z5k3rJi9M5mzEYpdwptScbSaIzRAqgFZztsqtOhTQMOmz9gTKysdJidqn+Zu//7fxzT/yG6CTAZyoVEkhVWYOIFrNXGwgS/pvJiHrENP+uJhnUTS/VoyyNRu66hBeJKb05DYNXU2KBeuSplPXstQPaCpr5LLaJ5jK5r5Ev5Fy8tV5mE9NQ873i1J5i2ldzSuw8d4eWh8jAtbOW2jRRbOpqT5ikK71091MvjrQyQWj/FvysynaxjQBXebmJoKL7DqlUIAQjtg0BSaExuwnpGrJ9c7ewrmC+SC4zH8uSeni/gybz//u//o+fMInfwLufOc742u/9km2KKuWVDXfhtXm34pmAo27uTpxaR2YwCJRTRs0QGJF8CWFcREXzm2+mvmbzpkt7o+PeXlkEipYJGVRSrl0gnLs08SqWjznaKBiV/cTTXAmTKEow8JQVg9SNDiLgdlHa2be1nKXrWnucosmIwZn0kqOrv06mIeGihmQT9AMxP4zHNQG66iFvlnvZgllewOKRnS3boDWcHRpOwOwGKQFsgi4l7FQeBxHOYfDXAjuZtF4p5iS0KBUgvutR5Vab8LjJsP55OQkAsI+6qM+Cr/+67+O5z73ufgX/+JfAFDt+AM+4APi9e94xztCm77b3e6Gs7MzvPOd75y053e84x148IMffO5nXrhwYSor6A/BVWBcgC45exDtAZyBDFAVxHmj6l2REZO6PNSgj0yFkAguqz4m1aALiI/4mLHRmuHaSblvZQLzbNomqwIWJarg6VM7hXIFtTUh307UQ0OuBzoggO25f5E2E/ZYz1U0qLqm4WCGF4l34bx6gNJDZPr2BPkJzjLDWXUQzTMctqAO/1sx0JAv+hlEBoO0fw8ydE4VysSxLSHh2oEkUORwMPSmu8vt7oZXPe23sPQFD/3Wq/HH//NNAei6DtcbtVYDq9ku28yXTnruFsorWeHcgGlB985cTAJu+tpBrqVLuhJwOEY5ThadEuyyaUg95XvxccEkeqnbthZ28Wmfolie6qPmbMq7j5EaM6hq0PWDXKsUfNEXPgritty26P1MtVzjarNwjWe0iYNHYqsfOuaraLpgmLZFhX/vUiOiFjp3YbFBmUmb5FB8y3q28gwwbXzNfqIdxvWWrYD2SVAgXYPA/GYMrdkhvUNmGzTRcpMTnIvP2cE8PINAwbxIaswnBuSdbRfWrAwHc3YBW8DQiGtYCJnQTv3K2KHjxADtGvMFkFwAkcJZgawBsKAIR0PUQ5/cdx3bCS+k31cLK4lBmSF9MTC75iwR7jMFgy+EYYbEgHS4/2Ad/lSQCvFV5vkOEaw3z6r9v57nLCI4PT3Fve51L9ztbnfDK1/5SjzoQQ8CAJydneHVr341vvVbvxUA8JEf+ZHY7XZ45StfiUc+8pEAgLe97W14/etfj2c/+9k3+bMZtwHRBag5ew/CGQA3wcK0YdEb1fyn2mU5f+c3ctbTtCXC/VbFnK0dqxLQwLCfE8yw6j+heRcVou6n1mzbCmhx7bkjK2AYpGlJaIc522bVpDkfWxZRCOR5iP6c5yYWuJA9L0i0ChWTYLN0Es9MlChWoOEfBG/M5sXm/Z3EPju8g6IV3JqkFqKFClbV9Mo38ngBjU63BU5EhQoxKLsYRkWqBSFqfgMIisRcPgJmUdcUM/DYT38C7vZ+Knj+8894Mv7pD/7javUN0myDPSdYcwGzFFe/bDRpQqTy1Mhacj+WgVlIJXk29wJRRslT/F116eQYtmU7XmkWa2GADjj7+eVZGzY2BqDLLIuAsToL/Xfng3mrMTugy5v4BwbQdBCpXkpWBUZn6NA0sQpmP+ewVChhTfOTYUU0TCgSCxATXzsGYFCGuc+YBlgczipWEtiiI7bCvkeSZzS7IAVH/34O61ljLtAJmlKJwoZpzTSZtSmVzUmDjiBFKu4VsfiRbsFgbY7Krlrzwg07Ns3ZRudu/mbNG9agVPUxD/KaDDv1J5vGTKYhk4PZtsAF+1mfS2thAjpUgW2kW0i+TbXbLqAukNYgvas/2bTk0JwXmLYcraFtP10B1XrubXdVwBH7aK/94CuLX0DBOklbN/5xk+D8Dd/wDfiMz/gM3OMe98C1116LF73oRfjlX/5lvOxlLwMR4fGPfzye8Yxn4D73uQ/uc5/74BnPeAauvPJKfNEXfREA4Pa3vz0e/ehH44lPfCLudKc74Y53vCO+7uu+Dh/6oR8a0ds35SF0JYCLAFRjFuqpM1kKhZq31B/tIfcgk3JsFSXvlE3ZKlE8eo/You4OAe3dZsQ+R8wMnukWSA1ZD7ho0tisRhstGh6RsDGCRuGInC3isyde33JlCxhjK8BvhpNI993KTxVuAZwCaWmR87kI0N0PBcIiXX+fKAfFCuO4QJQ5zcAajbZ3MPs/t3N4ZK0WeGmo6SgOZthM0OjjCvWEdP3+3uzHT4M3KmlDb1Ri4EWvej4e/alfjdYavv8Xn4c2MMFZOGQ7nTo2nbwD59T0gj0PdqNBAyHoqCKk+wTV5iLIhCxAsTEaMUbzID5Cay0hDY9U9iBItusrIDZAs4DZ4ivIBxR6bPYXtqlZtOiAtLPFiTNdjUMR0f929jHb8xOYBVFLPW+hdNFshrd8DV8x5kj3yrYAM7RUY5em6UAmKNV4+IzYXlVrphUiGnTqgA4oEyOLjpR/pO8nZeaTSYn+3arWN0HZYCquObuyWAMXXGsuZu2A8q7CmUBdMpMCybPIrjQ/swZ7la1rzIOw69ZW0eFstalrK06xCGyYGTv8yROU04QNA3Pun5RRXXpecMnXQrf++flRjVZ/LQZoA/PCkN5ta6ZsN2cvrjGrhjwH0km8r49mQmHEM5VAvtzRRkg353GT4Pz2t78dX/IlX4K3ve1tuP3tb48P+7APw8te9jI89KEPBQB8/dd/Pa6//no89rGPxTvf+U587Md+LF7xildEjjMAfMd3fAeWZcEjH/lIXH/99XjIQx6CF7zgBTc5xxkAhK6CBkTtTaJKn4PEDTogtDdTi5lrbdJTEKfmuXknbV1VHdISr61w9q2av9VXbTYMkZT6xSJiIWUl9wM9ZwRgt55Lb3wQdyginNDv6stBmAt9jEDERiIbUY+2al1TPjPQ2KoCCWUQCVOmWEjTRQ8tCotowE2sMglnAAzN1h1gNDEfoeSiSvC4gTSBN1/4PH9B7Vj6rqLXWd1OEgAprvc0bZtVw0+Jg5kdzNbI4s1/+gb8rUddGSauVmUgf7/S0CQGl2nGCubaicq1tFoxu1PdtwIWJQdTWg6OAL1RpHlPX/OgKAOMaLDdyvpFibUlKrGAR4EzjiwoDm+bRqZgz2CmIgtSAfdmSm41Zv/5qMa8CYwiUt+ztxklYnjKoN7brj27W0YFshSErDiILKYx94w4djibwOnnKyO2RwCaDdDV36wSrZ6/7hpz/NPPTjMoYr9qya41p/ZcNedKVIrtXHAkYYwKZu85HGVjpQgr6W9OBVyFlUUs55kVzEtvWJgUzJRFhpr3yTapgEnN0SIVyDuD8QWoybqCeYay+D4lnKWYAMQi22RrBpjM/AQsTc3XS4MsXbXmJX3MbRHPYDUwy+SjJzNv6TKrYGaqrg+JtVInrq9sur//PwHn5z//+Zf9PRHhKU95Cp7ylKec+5qLFy/iu77ru/Bd3/VdN+Wjjz4EFwFcBJGnENn6QAxPfRDthB1wpppaRKIh767mREcmHRK/c0Dbwmg3YMDZNWX3MbsGyqY1+wJjdm3J65bb6fqVVWoCbrljqfxt7PsxlPcsNlrigYj73wwvMkKjLOKUAS7R9CLlFis6QgZqGKjdD+UaSRaR17xSu3tMCHGtyYueell813hqP6EBy4Emzxx1RPsr9EtHPWoLAlNIuwUgtWYKEsgMZq1mqaatgShENsqlJMnnp2u4BfMQq51eIF3M3qE9byDtgUoO6mZgJmKQpX+ItfjkRrHgquuNA85uQfLAKK0bPAAZIB4K5mGAJtOgR2p7aVqQlBE5Ae6gxREIA5h90eVUZUvLAuLYygykCubmmrPfvwloc7jr9yQq2nNm3dbKXVr1K03anZtZf6ClfuG5zw5eBbRggEXTJ1mGnm+ZxAybm/rPNWbZgNm/ooM4bvUAMWYAN1hRIZTUqe123g9f807hHO2Pm1j8iJgwQtrYgTDFkSiUtZ/xMghLt22YtBPMrUgFrikLdupDlqIl0wWDssJXjmjKYlAW15rJwIwdJOz2bp+3eg7F4EhdIFFvlEBLU215aZDdDGneCWhJzTmDv0JSM21ZGcDk0f2lkI1df08h04mu4uu+/R+A8/+/PYQuguiiLs5+U4OhLYH2EMrQewkwUwGzJICDOBXSqplEgnoxbeutlrZQKRAUPxQAAOkqblJ+rOwRwl2/EIoqRvkcNq+h8neE8rmu/rkGbq+bNOMC5bHm96XM44S4JcHM/q49sICGgFYpBgbSPGeG9T61RuXSsUhH58U06G51aovWD4qAq9mk7WAuBnAzyTYsGNYMgymXT1/hvCZ0rm8K4ybuT08zfVXbAs4O4wawdcz0Dp+AAx1+0ClH+SX1Ndw9JT5KWEP6pcUg7d8vRyODSLNFgAZaG6AiPKJrrXc1VRK4qbBJranJ031hSM2PRIcKZAM0BkYbwDDf6sjK8G5SEDv/gBiYEYFLOSQgHVo0CoTkyBT3l52rMdsJL/esQ4uI1N1kfnZ3PUU3LxoKc9RaZ2LxE645MxoP1Zi5YSGKIhxu+m5cU6Pm/GYW7UAH0XtFjpmz4XK6GIwlz4lvK5Crhlxf6Ndzm48X2qJHbRcwz/FTaqINv7PAm//kd6X8cxdSOgLMmi7pJXl1aMZGtl50SYDpBEInINeO6QQiFyC4ADGteN5XEIsBWQzsNR/a85yrn1mmPEWUxj4EWsTt8/rzrimQdw2yE/DSrBSxwXlnWvMipj1v4Ewa9KeWLMubl6GMsTXSXUZ1bV9vjXBGO4HQBeRqoP5lsQCEmIlm/pWWJm2YYz9aBfnoZfEL8/asOafWXLSK0JrtcBhAGDdc83D1olysALU/NtrKpLnY6u9mXAxEk3kAHugVq1yYsAVghthijOZg3hcwaxoaZAX1FWgriNbUuLx8JzPaKmirgFaXYwjdRmMNDlm4Y3Ewy4LOpUYu0hTvh9lFI109fKeJigperUml1G4A162ms1XNWU+++pRNY7JAqrq2Txr0BszSTHZp2ouETGOul6uCGWSX2i+dreFUUmNd7qEhpk0TIhepWjYmSKem3Gjo4mdwJuu7Lb1Fo3fu2tqUegs4a+D9VnNeAV5BvCqcuwKZmnZTy/ld8VKEQYNvNeeXVx2MODWuJW5mejUKAZg0yKotk5nqQ3u2dCC45qxtvUKDnnLN/ZZ3y0QFc+sqTFrzBge0RnGr0EhudSpxJl6il0xzRikdfFCrmyQBDUyBQ36AaqLPtYnIteQtiKumrCOgbIBWRlJqzh1p0nZIWytJFQLNjO+wDusBDMgwKFOBssK4B5izLrVERnRqxQFjulggfQFscGacxFAYnyiQXWMm67wXUG7l/JD5lpHWg2iLK+GqtqBvYEeQHRmkTYPeqe+ZFsFI80lqzE0zdBoU0F7UimQx5aUrnJltbbuVw1ks0kGl2h1AKyTFRBCyjGXcreG6lRz9CJz7EThHScsEZWrMQKiBDMhwdcHt25SAbQW2kw2aj+wbOeqWtDiHTCpM8T0HQBLMoTU7nFdX6QzKAec9wHvQVps2TUtboqn2rJCuskwzSLcC6UXh7AXtLQo9iiSKa10GYPHYboeyTn5L3MIwzbr2644VPbRnFH9z0Z7JwTxD1k8rG6C9WdhkWbW/We01Ra0HYD5YqZdIQIMSzKtoA/YBDW0OQNuckZwL6btMHzO1AWoNzcBMZrLz/twauMIY2uZKbwFyEAhc6yNxMK/AUECnaq9zy810GnCXA7KZu0D4oKfhMmJQVw7AnL8p59hhHMdNUcwhLAHm+8uwCwdzg7eaC4h7OiDWtEqYAKSA7tYOsJnWqKmC2SrR4MqsAUGcNQzC1B1gtvNEPpcn+S2UX4YeF1yTDs3ZfM1hFYCZsnM/67pWKFVop9Z8kP9swoyCGVH/PqwJJrhojWzMXdPivLimnCMKFaEjHNymASPAezHAzHIRjAs2LoLpBCwXJq2ZzbfsAWVzK9ziY7aTqkoWZcpDgBkgDTMHdgJrSwA5cTgTeKcaNe06yMzb1Bm0MKJFFy0KZwwVlKFKhisbYIulKdsahLsuIb7fpMctGs5eNCOqYpmG7Lm7gjL7N/mBsBs7atapXTZBHftb7dlWdbdvVjizWPldo8BwFdoI4Dkq0mZK+KpeV/dqHy3+rrSluioi+Z7S5lUyFn8jz/CAtzU1Ztrr+8oekDMQ71Wjpj1Apj27n9J80xispu1VQCuZ6ZYC0OqDVkA3UUin33kxKVNXIhNxEs5wU9usMQ90rGoct4KJc5+hXAKBjMx1f6MvQOWUVwsHIV3xttaFf9nf1S/3QASdSLkMzizIkUtWtubuTc25gFmKmBLSg0ejkWrEKGZsrYeOaAFKSwd6M+05ZdKpIAevgCiY0VfQ8CyFMtdkxDxk79ZS53m695Ow0+Poky7H5G+qZltuT5e3Qp62qd2aqPXLAn7II5mKFUw1Qk55HAZ6ICCkcG4FzDZGqXEeq4rOMg2UzLTKMHUbkLP71Hb+FsED9Zj8B5nonRozDgEcEG4J4wnM5e/SYBgDLcFMkXYn1gBIQqPXj5IoZDOPAuaoZjBHoAntDLKuHSuIB65QIEMBPWzLdIKBC2CrGKZjAdOC2v7WL2rEvxYPWTb0UW2ZFtF2uDsBTiS2WgFZEtInBdJLAy1NE71j/VcnvVC2sXQ4E1t/6eiQVXxiHnsEwrr6zL9pj1s4nMlmXRG5fbEOMTx3dUGtGnPRnLfDteiqVbvmXAJlJs3ZF+QmuboDyJWsAt004RohJBXIdTiUfSba94J7+kbRminBTDZBhi/yJRo9tGI1ZYNNax4G51bBrYPEzNvF7+w+VX1LsrenGdLS0KVEbU/pYj6P2cIpBBkYNbBG5aaokg6rgmyApmLapwwGg+dn+7rnvue8fKWgmPqayYwLR8Dsl6t3hPm7pvi49yDkrOlSCmQlhbIN5Z/kKBrqVOiGGryllZgmRW7KXAAsAloYtCxg68lNvWWGiUkjFNAd6kzvBugQ0qogWGz97m+zoDmXbshpdwzQ/nOwxxMc85Zwgw+Xc+11ix3QNfVfgeJ5p5JpQw0aAGT3MbmMXuDun6uHLBYt3yPIsQ2DNJmASVQgiwCtm1fY8+Xs/tP5ikipmXom1LlEmXuf6xLF8WaqVIWsSScB4HYI6PgZaeqelBCE1QHkEM4I44A0mVBB9bu7z35uvlKiz0yMmat/uYl6bMA8cAW8zS9bq99hZu3hYKaqMZuoY/FCnuKn+okpVa5oWaoUFoYsqv3KjhXSJwxcYNAJK5xjYNairfIKVfNB82PQevRNmkFZB3w7WglYMWuOQK1ZN+Nxy4Zztwtkj2BhrL7lIvoICbLC2QdbSxaHtAScpduK27aaM2xlhporG3kybnnoyh11vB2cxX+dzkq3m3rwyYoQg6vuEdGBVnTEo0qEEHkubtImN2lzWYjXHA5nXoHumrNqzZPKZ2ZtNcv6ITbQSoDDepAOhraPY43mbuyAbhm1bWSLMyCYQFzLR9RMaY8hryFU9RH3L+XaFKAWwBth+AeLpebwyJCBY2AOXhmY2QGAmGpTrvNk/HBIB5gBGTRDOcBsPY2IIBi6PfA5GpwWhjbbZTQrhkzTAl3hzAnnCmZk6Vm91m7j17nKbhZoEvKla1mh/FUIFSDnuTQwIf2tfucei1Q+yC40CLcmQCewpbskIwRe0YV8wU75vFg/7F5k0cV1mI9+lGCykUFkXmePRDVyMYjB7ByOqrDOoJ4LPwc0+ZnJTNgghIafGZPlOh9oy+2cfTKzf5s07hRUXBjYgnl7F3k+PKZr59/ERZbavjS7QimcucB5GJyHackrrjA4X2E/Xyy/V3O2Alo1VW2DajXkSVWRSPUzq6c00rXZKn5l/VGDsoPZhpwI6AKbFl2G+aTZel9znH83pasdhEQ7uVEBMnkqh5vcote8AEIYy7w+3djHLRzOo6goWRjEV8eDvpwhadmFPA/M5wA6zOAO/o1JGx2lliEAiE7kGsorpO9Ro5DIk2mHgpK6buG1qE3yEl0SEuiqwpE54MReM2nOfg6Gn5uijYuDuQwPFKsQF9OowndtbzFI39e0ZgW02McomB3OJAZpsXKekhnMmm6S7QkCzJIFGGvlYtfvxM6wrrm64P21+9wb73r7Nbj+2ncGKHKhzVNSH9VN73JVgNmHfXXvy+zmb//biPXjvNRgUQAXpTX2GWC2NoucTT+0u5MHHJF1PzNoRDoNDEgM6gpmWjqwa2hLgxyBMyY4e5BACSf36ywMYTaN3ua/FSnJ+wizZkp6EgNEsbArlObueymQeRcmvxyEPPkTlGOI+dkFtFBUctIwE4ezR6uLFWXJ6xyR+iY4EZs2OQTRLMS125idBiqJmaazjss199eXsOuwFph/eVbhXXKUnJhbU/bloLy02KetJt0c1BTXKSwduTioomDxMxllTOGT12VG4aKyiNVqkAaRDm01mlqzWLlhMUAPq509cAErLmItgNbhWnTCeYTWbH3JyUQGvz9JI6a9+ZDHHMzWz2G1RxnYjQJoMe1ZgAsCucCgE0lI72xYShV1ZDeqElJPopY6BzI1ishRGmp6F6+ja38z2q0Rzs1Agk3wkkFIpqRTzpxmB21pEWbZ9ohEx7jhJaXz6rScTNT2sd6uJ24G2rzONHaHs2u14VesgE4TtpT3cQ1IaIUl9E0LQsaXudYcB6dYqzk9sqYmVbWppmCW6bVVm/KnmwGaIENMo5Yp0CkXwvT7Tr7fODUqj+ufVdncZJ74FvBQnK2zAF/y9CfhEf/ya8Bj4MvveX+8+5q3ZUYKEs5AXsIAL4pMZY8JzN2mTQuBejLJ6h+UUbRnZaJAmBLKPgVE2y4ON+cTm0BiZUwJERhFhABuczNuZ7W1Lz18ZmzgmswG1VQ98r6IZi08DMp12Byy6h1eISzgHOfVouK3rBH/HdSvCUwnWEAb/3KhuMOqAtruQ7GYT14EbamAzvs0gsTcdLu52CHTu4ZJSElDKBjqkIpb3l9X7vHA+DZh2TG/ta2HlEh5jc41Zbd5OJiXnm2j/HdV467Br2VyOoh9cpKdE400ppz05m5RKCMkJfGBDs6+ioBV7RJZMEThvOKkjIubcUXsVzgPmMZsbqssTONQ9gA5LufMUmIDzGVs4WxAxolCOvbdP+3BZNYqMoRwkOk7pnQYgCP7Z3PdpcyJWyecd3voKqTlO6eoY5RAF1+IPF85IrRFJawpyg+WH1iec/O3lxiaVnAUrdkWGMy/Jwelm5ybaGCVF212OLtv2SQuf6eia4R1gMRSCkrOMKhAxzsZTIFFDKwlKingbID20OtwJqdVAmLlSQ26ChoBhkmKoxmAxMy3BdSxuPl+ZCdvvluWbmARfNwXPxgf8rAH4IVf+3149zv+3JJY0kbC8Vf6Dh/6d68GEaEvC+59//vh9df82RRvU0EasXf2Ps2+qbtRIQZkQQQCuwvqQGu0vyP7ihXOYtXA0iyukHbvQBOxMAXBoApopO+cFNJpAtA52TqDO6NFaSddrFsn8AI0J2ROCkTKjwlfLAZnYbCnyg1Bb547jChVyPU7k5tqbStQX61YcQuBO1ziu7jnjSDhq69yzJhs4wgw942kJnGv2vdcJMrQe8lGN+dSK2aScm0y4r7Z98xjipcamCTcIEoKIeDjP/+z8TGf9an4vn/5NLz9T//H5qBNHDAoyxbOFdIVzgcBXhXMPaFct/V3DvUQbMrk3JqBXFgLi9hQU+zwnwVVnmMmsPUA59Cgy/ojGV09oIBeN4De4wL2oUm7mfuCadUJ50HdwEx6r5PEfFU9hMMVJW4FjXtgnSEd2rMcB/MFFDiz+qu9GYbn0PsqU2TccEtQubC+drigZluu5pub8Lhlw3m5ZBbfMwCnNgzSniJEG0hHypTBNjRlCW1Zdg5mTBJ5Sti24NVAMDeRhRQlYRpVHxd00ncKcYyieLOpRNT0eKMigT8SzF5MQqB2F7KDkpgQksciHJCOIgoedBbBQUMnMyuYhazQBaWrIDpt2ffVe5og3NJ3ygwZZg61G9w1MN93CZ3MVKaBFT6j9f2bfd6Vd7ktHvWDXwEiwt0++APw9I/4GvQ8mhhSzs7/9ajH4Wt/6vvwP37/D/CHr/pl7MpajwLpOKV6aUAsIQjBLre7WL1JwDYjL8bmSoWhxFR7KooKG6i98IjJMbZOq1UkeEqmk20FgWqqblqkhD2/2RfoxaO5dZ2G++lETdXd4MxgdFY48xjoncFDS4E6kMWKVVQzvj88Et49kVo8JVsxlnpwqJHLIZKRXjd//6qEhDDia7+bGbtALIXM83e90MRUbCPOU5VYJa06XQVIWe3cQD3IU2C6JKBjYW7Ahauuwj/7/ueCiHDPB9wXX/HAh5h2lwyP6UAq+mmNhDgZYVpQzhEimKsRJjP24vDtm/3tc649tzBpu8BewSzVYgcOwUyY7P4lu59V0HYLjwiBuYG5YVi6kEjRntG0b7MBesVicN5hjxPsA9IOaB+uOe8waJdaM1Hc15pX7jXWrVRrXF9XuMxV0y3Y8UB7FmAnmlp1IprvfCJWkEzs96wBljUIOOILfJ2XDCT1SdwsKLVMZAkOpJB2Ux+3bDifXK8XSSqcC6QD0AXScRFdc0aasWPUm50S0JEoa5O+grcEgXlt54SyqFZdip7UGsCzGFakbFfhQgJIMPuyJ2b6znhY+xtbiGorzJSWiwO0VR+kadfN8jk99xV+Y0ssWBwmWqgmOBzGQ29i/1kc7MNW1xFfKRtRII4zdOJL1xs5CafvuQ4n8IKdXMBciyQK3vmmN+MpH/6JAK3YwbT1csn8QfY9AJOCm30P5PrtJvhw27cERr1MsZXc+mI+adEGbPbvLRQpznpFPLhIEN3UZm/sLBjGwtTRilrv/kYq/SaJFIx6TT3CmNEbg/tQbdlA38xkriUKi5xo60416Wbd6o0SOM1Q16CLD9eAoUAjPPc//yr+2gd+IJ72ZV+MX/2Fl1XrMqpZGwFoHGjPapJEQm5yQ1EKTXYdZGBKbshrb32uufhuG9TH2PQ1Z3ud29Q73nftdWDX9PK2n8uT2gTSQhYoPnSarQEH0ditQLgfgnm7f2Da8TlZpA0Ds5CtAWgAD4PygAwCDwIPiTEYaIM0CMpsvWL+VwotWv3QLA1DusJZFNJ77KYxm7t1qOa8qOaMlqsBCZiGzVsT8wglMMzW0FZccgXQtAzLZmBLrzIwW0ESsp/Jwb2oFq51BdI+R2K57sNvcj11Ybhknct+7mNfbq1w3l2vYJUzpPZ8CYeQLoEvk8/ZB46AmXKEmalK4vqIyFxnK2Aak96hCm6LLLW0Jgofk2rNVAAdi6Eo5KUs3zo2S575uUSocELCfB6Neg8g7X5ktyYUMFsep9YRNwQKJjgLU6TXKKgNyqYlM7M2BjBpmy2Qwhcssv+1T7QFoYDhgUnrey7hOz/yybj3Q+6L//zclxicvQK3Y7rCuXx3gzKAADTc5wmEgcGPBSYJB3uQDAwwl+0BmPOyH4BZ/EmhADNb4I2b0SdrbgT7bd7e5tycedBMk7BG9wo+4REAAQAASURBVGHStMkYcEZ4wRoYLL7YaEerRqotZ0oNZm3WQNziPJP9L5l2RAivj3fa9VumgpvKtQeAB3zCJ+C+H/0xAIDHPPVZ+PVXvTyCmJz620Zt2I5FwJNALYicX3svgVsOdM7WYB+PU3YwM1sELuv59KInfp+P/cDj/vYj8KCHfDx+6rt/UOFs5kuWcRDIlDABvKJZOVlFoLBR/coHgF5s37b+c0vt2VPuQFmhUL9/0ZZNsNd4AzIBW4VsHgM8GGMI+hCtW2TBnaoxl3SiyQ/dDK7dAN2xl0W3WLCXLaR1jNguBuYCZ4y0aoTAVm/OCmbLNOlWRMmLSZnZO6qkxXY7tAlG697hzUNUzTfPJVjO5kIaOXNRyHukpHrejMctG84n79OT7z5nOYPC+RIgW+25mLeraXvKBKDjozd7ra/SvjghTdrksJEMOGFo9LIFY4Ok5Bra+1gNYF+h8zLqTewF1SMSPVYoXzEoIpXFqKP/V0AX1a2O8HuPqH4WXY/IjcaOvyJ8G2iZ3RdlWx5gIQyrr83S7Pc0VRJVLdw1fl+H7ZaMNLIVf/G6N+LPX/cH6DgDwcsmOpxlgnQ1cldjd6q0SENE+Y2zlpCXNu41k46DJfXFQL1Y+XDol48Xg3Kz84D4zqYxF2EiXCXgw7cnlO+o//cIUFTpwSOOD+3u/jk69w7TahTMNUUqKlohI5jro5qyNY4gEvtiv5f9hHO+1R/96q/ive98J666/e3xih96ARYXcicpCQegru3OaYEGhk21pCUqhU1SGZNpzZlI5EBmbhgld1Wss4kLJx6xyAT88R/8Mf7o9W8EC0dkcQDaIu0FCn9NB+KAdDZSkFL9CwrWhSAB55aBXwHkJYHcF0hfQK0noIv27AKnFJOBeNlfCwRkWe27O5yHFRIktMFYvf47w86JWs08A8OJqedRhXDtKZdjj45Vum5jqFY9oPB2qGcrCaiv2e9tN3OT3+EWsBpjC2gtQ6zlbj1wUko5U5RypmT7EqNZ2VxvahLDFZ4pVD9UDd3a+og6bsbjlg3nC9ep+SJKT5r2LKdl6z5oh7P5ESbNmWYNeWklchvmh2jmg2gKUeJYtDPuQjUkb2iAIVHjGISoXuQLRui6R6+da80L3NfsSfmx1LnY5mY7JXRopgcaNG0g7YVPSIq5S39WzTlNxsoM1fqaFOCyGwQYXQYGa+u9IWT7M5xZNGWobSLr/JZspj1TaWovBmuGNx3gsk08T0ZuuzYKZEltmQycVQd0ODoAilQccUB11Gvm2hEKV10A2MgHHPv+gROVLVRBpjfU75SCUWpCgKLTDcna4dqbhlA5wBBPSrRbzWsFyhxGpkKhvJMerbXjjL+XBDTc/0yTKbuXffdPk393AmS/x6M+4C5Wv0GwxP3iUKYjKVUFziZcc1dAi41aGkDINRgVIpsBs0HnaRaU6IDlPmugWCn8kpIKvEQnk2CI1iQfGBhgDBkGFssosONnu12zVjPC/O4mbVl87ckhVWsOzbmMpkNaV0i3DhDhkx7wQDz6Ez8NT33xD+OP3/5nqLEjCuYVLC1cVNELJzxclvo4OBSNALOtASSzdhh16EQLpg4Q9tD9PVps92hYqWEVhfdAVv0b5C0l/BwXSJOD2tdxD1zdT4PorMBalTFtCCMRO6IyDFkBMMpSpRZroV27NIEzNGfydLp8+LxKIPsEdW3ETP8343HLhvPF64Beq1iZeVsKmMWjuGtgGBezkkut5cYo3UgiEMxNUMQWhAVAuIDZX+dANg0knktlBqahwECdCykCiNHlhlj9ObB61NLLEpcdmYRs7fVtLLBqygszEGy/lAvNlnv5mrgR4JKqA0KKCdDhrOa8IYTGthW9ST0iuYsEmHVxaHFT+4KvJRA9o7kUSTkC6FmL5orl3LcbKo6dJPyBCNDNjwnMoVInlCPKuEAZmN8r+Fp/aVDkjCTR604uJLiAVd/J7a+cbyRiIAaAFtekQyx4yTpw1YMGpVBiByUi88GnWuIUUU0hTAebPN8YEfmw2SaYpwgJSj3DZ6nPVYYrzBKas/oV83qwLaIV1CiAnszE1ZYu0PNjYCa4b7mBuWP0DhqueWrJyKwfXVNmDM4xFMgKmYFBnpM/rB6FmbeJDNAeBJZbzd125aBAOdKlfL+asncGZt+6SqgL1kv/+VOwtI6/c98H4N6P/3KbNxaVjxVNGoTXvIcP4JyeLgxzBZgVzLVmKjdBOsy8c7iL2A5nlG0OfS1pRma8h5hLoP6rrj0vzqSuSqEVRHuAzmzsQbQH0WqZDubCaYhKcwFnIguQpwx0D/eOacthYynSt90nElsK94CYC0CLlcDcCTf9ccuH82LlJ8XrQ5sGLQZpb+YQLYIcQkA4yyIlQezmlIRxqze5+3LMJyhQ33LjNIkGfEukLRALmcKcQxuJRzWTWGQtAjVscNr2u6n0QC5CBdBA0aLhGnQZUsDtUa0eoRias0MZ5iN2LZgt4til6aGVSwPOni4EDNE0oY5hUZ3ui9GD9paQqj0Pk7PdKpK3srfrmwF9aNxOXTpvcjb4uRADQT0zMSKwh2CS+xF21a1dto3SG/cx4J8VsSP5MA4N5B/PGrdqxxpY51t7HcPiADRqvgtFZC1xLYqh4PaFWMuFIoKjHFx58C4QmAYgen22Z0qnuuc3R7jOBtQO6HwuFjqfmXaPeN643wfqp83X+PWQ5rcthVk4/MKmMUvcu7N255WeuGvUMXHH4AYM1TqljGNwTgtKzjvV9jg0wOiCTl5Exo6bADat2c3a3rwkrHdVe95VMB/RnB3M1gAo4IyGMRhL63jf6RmAE50nntMuTTVn82xF6f0oZypp/fM5xjoV9D7PpQIeR2JLi69UHroag2wr+dyIrd/H1jiWUO7psRn619EWeEqfVSinO7PAGe66sZAMWIEjKg1PAHjOvpcRplhpi8QdFxMTkMVcIWLVwWTY8sq3Ss35vcDuBJmza8U0AtC+9SpXA7G4EPLmdUA3Md8NmdiI6IYz57QEEs3UAfPj5fOhOZc/vcud3h+/9VO/hysuXIF/9NgvxCte/oojX0qX8ESMmis94MKnC4d0EUT34ObjgBaUYCJ9QkKDTxin5lZz/Cp4ZC7bDdV4HcJNgNVu4AFgNShrO0jGEGtdIWlUlfjeh3BuAeaEdAV0BonNEdwRpycS/SXIvkcVYqRs/W/EttHV0f7e+TVF4paBupXN1j6WRdJSktFqCg2PIi9D2cjmo7d5wByLpRc28ZS21swkSU0/RXQCSgX0oFKNNdNm5jrfFPsToG2bkfamQRdAH2rRuu1lv54xtrlWY+3U4lHOTQDOQa3PdZdN7T5ld5YXoTqOtPhGwdpRadT+wM1bEy6mOXdo5bCGat0KIZAEg1TYVE3Z3DkgDNOYo5qjCRVhkfFa0Kbpy6Las0xgPgLojTkbzcOOvba1SigP+qZvxBd87Mfhu1/5Cmj7RbPAyQiNmQLMgjFES5gamDPPWcJ1FeUeDs5GnhN3OA2w2bl0W4c+N7CaM0D/uVDDcGuK2CsT5zOMxWKNCB4QfBY/q0F9lOHCZH4Hte5oJcJuQ/dTDSJ4y1ATVsoiUGF8MMzaoAr/rRHOV1ynhUhqzm6Uo6wNHbI0YegtQU01Y6WPysHsILYlg9xgU4NjyMweroimRqzSpdhk0NSZz/vkv4fbXnVbAMCXf/Fj8KqXv8zeKVdjD95QzdmjIFWqnHrdSBoWPTI0NGh7FA7FETus9ZcGajio/YUSr/S/Z5vcbGZoivtXwUw+4SU15RX63Vex7lIyMNDjpnAzmBStzIt0Hgd0qQMdsvX8b5SzEt9c7PvBv64cgpliPSrmNfvZXhewDkHlMoCW+bl6XRRIBdBhc3bqJ6Rz69quvbGV19TFwMEKtOER1KKBLvG25nMVCvOlBgAB7DW/j0DawTy1jSzn1fdj8UMxdUvC2VsY9Lg+adFpsaincKjRuVKsE77vvtzNgAJ7TsPyeziOCBwJ6wreGh0k0NHQwdanWFsikr0231s1Z4bWfza4SEuzNtk8KmCObdGctYgGNiZt1aDlGKAjbWqZtWbsEJGt0vDG//lOPP3nXmZdNHcmnI0Q0Dw9mFlMY66BT36QapVRC1kK5V7OIa8Mm6nf7kHiBDQNM/sPDKxYDcsrVgxaMWRvYHZt2e1njvoVgjPIVGTqDBIuTI812iukfV/2IG/WIwxveqPDLX3amaxLs2GA5mLelmJo5HJBq7Y8dPDw/V7qP5DWeLgZj78icDYRMNQBK6pRt25j8PWETPNUqqSJO3Jl2DBs8aqiwCZxQI85oj8mLucEtsWJRCsn/dhLfwhf/cWPx+1v+374N899mi1U7uREWexcDk0TtofdeKtEXwZdHNCeBGSmQQoye4rVBOhKXZr3fakNaAfS7Uj9FJqZe7jGFNqxa896StfQmIdFZA500y46LDcULgo4rlUQSkCrD3obJFYNYhXMY4NM/5op5edgsQqksi0ROkN6bAB+nva8Bbd9bN3EhfDIbQe0BNELpO3DpGgyUWlskC7uQxd5JkpXq89NT6syzTHhTAZoYAwJSKv/UW4Q1FRMA1SkkWrmriZuNw9WEbNgF1XU9OeAcp1iuKvCDf40nzI7ubXCN6b90mGo5GMJFnQsEFrQaEEzSHt1dz2rKMekwZNMmjI4sIJdc96AWYO+zUcdvuYMCouc5whKnYPCcni6lEdme0k015q1HWs641XA8TTFMO3bpWSHMatFi6LiSLXUOCzNSgZEdL9dcFutTFi24DimgUErVhkFwnus2GPQGYZYTjN5hQNPlWzmVjIzvGnMwCnE0mMl0mbL1iylJGcgc296q9vGZqL2UCPrltdZbOvZVmTtQtMX7TAnN4FYNUQ4hAeDuUOY0VhS0B0IczfGdOff6MctHM7XA7sV4TzzyIax2YZjpS5+drNVCTsaZTRk2tLIyc4GaIzUli2X2SVR3bIVl5HslyHA6fXvw9Wffj8LKiQs4kXlgdDQQ4ukMukNzqJbtsWHy8KTkE4tmkwImVOtnMVpmAphZSI44hgodBy7xcWWP5OgtTY0F2FEF2DVmJsBupk52xtbOKAR5ugZ0GmSSk9ehpA4mNsEZr29Ud4ttWWkDATXgmUyXzuEHdbHtOgK4frzeQ8555cCb/ZRHnHeXUv2gBNJE/YQ7cRjWhc3UgMR5TGGduCV6Ly3ucPZ0mbG0HLqvKomHZC2RhdiW5YZzhqqIOXL2fO2n7My9+doiRJgY7M8A27yjFRXioLFX5lw1tNDOfz+sPs82okKwRs3RPlJ84ZrwwYFdJMdmixosiD7FSucq5A7BSTSioGmaUkFzGMKHJM0a0cwm/udYZCmczJHygjNuZjjaxlDWVw1zyWFBGKRjmzXQ3PdO8iKEpHoXeamiGqR8zgJl/N0yTQw2+LHUXUuwTywYtAeLHustMfAGQZ2YAdzgb7euW5f0fkl3mdA9gpkOYV4sG8MBTPJGcAGaPZhLW6ZM4M2otDVtx69MhrQScUxDz3q8EqGsGh+mMWq21atV2zlir1khBdmEivEdCuF8yXgZEXm6RiABxuYy76vtmETs4kI16BN/VX1RE07Vq2A2LRlDwyxhS60ZvbIRrFexmYaYd9KNLRKrdogZ2oslZvCl24WX8B9a1gWNfw6ethg56bSKEzix0mETISng/8B6PpqWrceUi5DElvzW/qia3D2XF0CW6Sw+poJgiuvuBL//tdeiNvc7ip846c8Fn/xhrcGdmuFrAT0ZFDewDmjNf13bgjzpdr/tXi3qqEhPsEB7VrOuIH9gDg208jPUoDkyEM2u7bKM1nuc70Atp18z6HQSGrRg3KRdw3N54Joi87WtB2ipxuIAWqGM2GsDmnRbakOVbXnSFTfAFqkfsmqv+r+xgGDFrM1Nbqa1qXCiV09mc/9Yp8bh8OpCbqMrrWP7R7wcooIIiqguVvqVEd0VLLBskMzLZQsXysTyvwbRjiYiRsFzEhN+RDQkuZ6b3logWERtd1su7QEdc19jlxmM8ub48BzywRmliZCuqjcgqYZE9papcOVkBHriVsWNHiOQVFxWE+pxPA102u1a/DbqgN7MO1VYzZNOepum3im58o15p2dR49I2GjOcgbXnCGXAs4kpwDrIDkD8RnAK4hXhbP50Vtdm0ez+iSEbnXko/ItkL5nmNYsYs0uAIylVD82KNucc91Qiy6yljH2soA343ELh/P1wMlS7l4p9knbX+vPSNNErKYNuaDUlbDrmUYHZICiU1TJInVz9oBOgFVKGgKj2cWP0q8O6gJpiHPQVTvXANyU7Dl/NP0LsdhuqgroSKNBc2Vcj9v3I4o3F5wJ1PDj0W1iDeEfPh/Qrjmr3/NzH/v5uOf97gUA+JJnPBb/+hFPhKfZeKdqPcse0FXjrLNJ5NwwUm9rslu7Qrke2xaV9SoPCP7pT70YD/qcz8FvvvSleObD/55OFTLP9hbQyOmTGtsRIJ9zH0o5wyK5z2Y6i/QuQqRzPfPbvhtf+I8ejd/+jdfiCx/+kBL4hUgrkgJlr3DVuKGxgrlR5gIKLFhFHM62NTivq2rPYxUzPKX2LOxQNiDDtPlyBkTK2ZAEs5+lCK6hWmoizadUUsYiCFJU6/Pzrb5PCmOYCKwoBrT0ZFPNyItWUCsmbUkfoffjFe5o3CG8QHgBywIS1aDJqpyQgz1mlRiUBpjcFlAtMJlmpUMMxC0BHR1VBChR51PjC3+ub4a3RaMUvNK6V553OIfvXnQekPne7bxoSp/ZOMw14r781vQ8U1PA6VuzXtJG0AJGXmlsgNsKlj2YFoUznWp2BmnVME+WVBeRg3mFNs3IiITIya5R2ZPGfEkHp/YMPgN4r2Aeq4GZMx3a4bwS+mLrdRc1ZROZI8P8z2biji56zKgtcoUJtzu5Dc7kEt576Vo1qobmrCml2Xr11gjni5eAC7uEc8bw57YhV9xGwEpOk2AxgBS9bRHRqlrDfM0azeFRm2HSlTRne3tczXsXdJsInSlLeRuYs6Z60Z5NDXNjLBcTXQ2UGAFnj5n0ZV91Ek0RaLM2Rv4VXYu2G5PceoAwaws0Rzu1oRyTJipVG9JzURO+9BwJXvWTL8dj/tXXoO8WvPwFP4kVewNzBXRGeta0KDd4zaZuL8iiz3mjjFbQniZTxHH7N6im6gc+7GForeEjHvawYjCfB29HAXIoujiXyfGLSfRxjdsg7e/DqAYLwec+4gv0+D76aowCZddqvLgG1yEK5jYaqHlAUwnJEgV0as8ELtpzgHmjPbvwK+a/YzNje6CYg9qFN4kvzwBSaz42gBmgKoEAsNmmleZUQ1mKFcGDbrjD/O9qtnQLkHYDoxCqxaOyis+QuENMi2Ze0FjhzLYFFrWiIe+VnE2u6VFE9CuY3R/dy75CMdse+j6sK5aZtbejgrqmh3nwqgvaZOptI1xcTvBlH/MxePFvvR7veNd74XE0Xu853GAlA0Usyt2FoAaK+kWtG6C6rVnNX6QLWbQcbauBeIW0PVjOtMMUaYMMJhfJZAPmHRjmWhAKQULAgKyQSJMtNSxcY5ZTEJ+C+ExN2WMPGuqnCa15IKBMa0froiW4G6F38zOTgnlBR29NByjjN1ij2b0O+d+910fi6x/6DyEAHveCZ+IP/+SNViWRTOjzrAoNprs5j1s4nM+AC2wWUFdzSCfxWib4CqSWaJoz7PXha3WJ3+1ipj2T+TqjoghiUY1AsCEx2sro+4a2CvpKOmyC1GYnVYPOnEHJgA1IaEIsCWaIw1ml4Mk0DwaohaEwvpXdvOG3Jm+Y0UJiToiTaXYmcW/gDHCYHB2Evvh68wZ1AmhO4Vve/Gb87SsfYM1fCCdAFKVYSdMztpmMHenRc/huMUm5FNp+gmAWKOw3VP9ahYhf/L+fj0/4R4/CL/3QD8bUubGQrppzffiV8TnijwPt2gUmF6DK7xj6If/ued+Jxz7uCfjlV70CX/YVj8MH/PW/jmc//cna9bNqzAZlFi0/2UZH6xZt3KbKHAXOpWTjuvU/O5gdghwmbe+m1UoEdz3T+t1zvugCa1Ls5vqReA7qcHFOT0vKf/H51XStoLZI8w79Dg1R59sj06WZMGrz2s0Nwg2yaiUw3WoBEgc0GZhJtCZoBFlVzRkWsGkaugcxqQ/aoayR3EKprWrVMQe0mU3IteQyqGwJBaQIMEcguk067xv9uid9HT7w/e+MZ/y9h+FOX/tN8Ro5sp1TcKXMawlLRRPRspZl68sPukaAS1vhNbZ9Lvp39hKmOk9r8Jhq2YIdxNLAUrT2c2xZGqLaM4Wf2bZcxlhBvJ/ATKuAVrLWCoS2F60Itie0RgphsmH/lt7RuVnus/md3W06OjAGPvaeHwJv/PKR9/wQ/NFb3oqsNLfaPaZrZWfcrMctG84nDmcD7qACZTftANOMdCi5RO2qi81K94O5puZmI9Wa96ElusZLJXG/DUFbt2Cm9G2Y2aMfNW2nrpG+XQeJVTOyf6PCGB4Ta34lyXtYv3l+b0nxG4crgY98iJhvKW4Ul8DZKl05GGER0lUHkukT3HDRJc3ZfjQWlmMmbj4ANG+0rjle9xDIFcqCNOlN3mwC/v1jvwrf89ivwh4bMNMRMNPhp+SJKlA+OIsTi+PneHLDZn8TFuBbn/YUPPsZ34LP+by/j3/3/T8KALjyytvgm77h8WURmxfEAPPoINK6y1QChkR6wNk1aNWekSlWq2vM0KCW4VSUnPNl4eb/h70/D7stq+p78e+Yc+33PaeKRgXpFI0NV7HBhigRUYxg8xNFJREUNWKLStQSbILAvdgS0SAo2ICxQaLYIFExIqC/gAoqgqgoGmMIFyOIDRGq6pz33WuO8ftjtHPtfaCqnvvc5zlP/XY9s9be+91nN2vNOT+jH5Ib+cF/HilsAm9vwCOf9304ueYUP/avvhrrpbfDsyCiEIqZFhTGavKOcvAWvKMWXAGvZiKlYkAXNS2qCbZEbrvLKPqPqwZNawMc0KPrfe4gXpA1QqsgbDYaGnH90m7TE8rNANVca06LR1ZAIzM7F/geHbrpRL/4Sar3Sagn7Q7XXgMAuHiyi9fUhilimw5DTdXc8n1CHCf7u/nKU9+2H+zWDYH6x72wiQl/0iqkDc5VgMFQMNM5RLZwtvcFAxYUJuQFprLIFJkZO8Dc1fwT5uxVNJ3Qex7tkWDuDa11Gws6abR+x4IuPaDt6aEkrjkzhAd+/KUvwnu9651x6ewyful3fwtdTtQvLVquky1S3N1Ct+R2dcP5dK/9OBlmqtpCGVCfscFZmoratUFvmNJQ1KHYwpH28dxBfU34RqX1Z9WU6HBWQEvp/b3RoE0aiwDxqi1IMZEZXsfBj/fCJFVryUeT/zkQmRt0aM9XALSQy69VI81sRNAIjQFgkyJFU6ssfYMg5vaSAHS33MGAM4n1H/EiFXr0MBvP8vbNAeXoW2L9/ROUDcxV9x6QGb5UPCH1PkogWBnH4OzGF5LNc76Pbl4fN5n/GK8xgVG7VxGuv/56E5QI17/9eqxDJXpPjWHReubMttkM3XCoLSBSMJOZDSF6/SucOdoEIlOqPOClmLTBrPPdQEziCX/lSohM9+vZFzA++d89Avd68CcCAD7rex+H5z3q8SWAMbMg4oTYcvTCKxF8M7QOt/WoCMuIbqbmg/bKYXCrka11yz/FWiBtmjSGVg37Fx/+gfix//BVeP0b/g6f/q+/H6E5e8obeeCkCRBks5Zs1jqQWwstWVoxLRcwT9J0mT/TSZjGPBNnyxHhQT/0I/jWT/s0/PBLX67PZZIutH6+hGag2RcGbVIYi/nJG6mQNoE58GkTXKBmbbNSiqjfP0ulmvBi788wM3gUFXEw+w5QrRMC8eJRUwXIvUK5WT6z+ZlVYx5pyVyhKewr0PZNQb1vCub9DOaGnRm1FzTp6K0rnKnA2daA8MANN674xmc/C7xfIeuCxkCYIniF97sWYfRbZfnO3aq599wQTSlii6Ocrw5vB7enIUQgRX2tE3JAozQdzJk6pGDWHMFmofoaAGaAHoy+WuDBSlhW15ztuNGe3fesm4cE9Dy+bRKey893/3Q+1qWTYM4cTSmmTSJdDNmKoAgqqG/pi1rg3mQ3QgMEkWF51SZEiPqrayGQJrrIV+imvsJK6EkWp9DWgjOcq4ErrRm66beyOdUgMH9F4IBS8z3QiK9wf6V8/RR9G5945ObXxfZYt/oRlfvv4N/G+bbXBqxFp/VLXvQifPkXfyHu+h53w48964fRum5izaKvm6gmrBHauulQ62hWXINqs3Lx6GQHNIFHm+ori6VTiQVVOqC9MlhGbOs13Zq3FcxzvTY1bw+84ZV/YdAG3vC7fwLCDu4fhs15T5qIQKYmKkgMVq15IPKHFzLHRriAzG1k4I6a2A7WUm4RgyAGaAzPZdX73/6ND8Od7ng73OmOt8P9P/6e+M3f/Eub/7ny3O0jZJHwLvBSAXI9mvlaNhpyJlKUmVLD9aUc4xpUBcKDVvXNXvmG1+PTnvFDXmUYsblRCtZoA+m+Y43gJoY0NqVBr7tGZjO8lSn5JBXY3qnXv3y96Ptgxha9753uRCO6FcypNXtMBFyICpeaw7kCegXJ3iDow9KmwpyN0JpbVzA3AzPtFcqtLWi0i9HJAC2LraMKZ2hQmMFZLFbB09YiniEyArxUqoRV9Oberm4496GpBuxgtptLMEMy4rERMvXAcwJLwn7syFANQTo8AscDwHwGKpgXeAJ/5tIVQK+sMHZAD9TWorP2HJNdNpqz6bQF0IiXam+q/C9l2vTfEbxHEHn1INJ8TjLzmx4d0DOcxSRm7e/s+pHlzGJkpPH0qfp9B+l5am4SM0g7lJtpzJH7SnZfDsFcI359u6cCa9eIvcqUgllCz08AywxjKnXHaAay//1QT5lvVI52CacwhmNBY0ePBdKxllmnMQnhl/7z8yM1qpqzRazSUWtobFBubtJeFH5RQWqBWASymGTPVuVI4WzmY0sP8QCwqjVHP1s5IhRFFPcsMtUwvD978Wvw7ff8POxOCH//ur80jcVSFCUsswVC9j2ILXdUr+1CZHnqnisfXzOMY61ZUR6iPNFiF5nVvC3hzzBQr/r3n/uV38eHf/B748ZL53jFH/xPjEi9hMn9uiLj6KmLRSsOvzJ5NLY/jwTzNBM2YA4Ym8kgzGwqRRG5wLwirYOwvYvrrDSN2eJnmoIjShqLNsSgpgqH1D3NwRw93iXmPEwo830LXNhk8oN+LUk4k3bEqlozSOelhJXP14SvPg2Fpk2ZZmrDcplNY47yhAANM2f3Zl3Fmt7fL2FVam2H1nagdoJGJyB4Ct2iriGx5ieomrMFv0kHS4f3tG7mMvHHJKvxhUsWws27Xd1wbsOK66oEl5GMtsodzF4NrJp3xf1JLaRlGigmvDFN+Cq1Zpm7bpOjRfpK5tKZ5jxIoWza81K0Zy9QUuEMmG9GxOr06sKdwBwGZ92Yqm5JpPqyVM2ZHM6lmpCZO2ElCnVjMQGnaM4SATvqESbQ9I20wIFmFTOJac+w6G1YipVCenVAO4QNyG7WVkiLXboZzMWjh6zNnNpaBpSpYDBwHMbVhB1Q3vy9pky5tWoLZregAKkh12s0gbnCGjnIrp0/qAJ2/N3DgP36VpFFLDpbWmrLBuZGZtKmBUQ7ADud8/B83o6oA2y5z56mdQhmCc25WbUwN2u75lytFodgDhEJhI6/+8u/xUIrOnYZeJw/WM+lqIskNWgpcFYwu7Gebc0MRtYW8LASHygn3kzj/ntROOXj6T/+G3j6j74UGAuy3VVctAgyc16HoOWasCtRvj2FVdwAUgCdF90nSJpQo3aDgRIO5FbhXKx/RkUyrTYlP7bXa4U9IouCtlVCWdYK0gqcLYKViv+Nyo8VV485WKRfx0HNogFwYmC2vCbBTudhaM1RP7kIq/4DXMvX7xjflQe8QLimOpn+tUJhbC0hqZGB2a1KO1Df6dHBTH7UIjQkXd+DWrjmQkiSFbAIfw8Cg6S/2ZUisfNJR5ySN+V29cM5/DZAraM7TXqU50uyvuYy9/RXD6i2zQJwnvQDc5L9O4VzR5Ohkpq1CnM4d7Me+f2t5hym7Sk/x7cz24bFI1hlg6rUJ9WYn1DW+2bONksBwWoIo9bj1SL/IMtKrnCO3WyYtcFjsKfdJDQm3bE4NCAA+MKv+Hx8/iM+F9/7+O/E7//Gy0DmQ24WaFa1aG+k0GCmtFih1XRddfeEc9XNXPmpAF7L8wHoY1Cm4mcuQJb8STmjDCZxmo7AdTpKmUrI4ae7vr+/j8C+TFMzrJt/vXesmJQurEFHrWl0bKZQmUl7grMe3bTtec/eq9etpdqJyKDskdpHipCEOftAa3ayhlPBr5DOVEvr81WpFheVVPXAZb0RopkAifrH47prRSdfU4Mtbca8WKUNc4nrEBM+oKZ7PzqkQw2vF6pcoW0WgwOa8rG4xBE5zX5ErK94DyribgGs7kHmbxjNNvk0m0YWic+0OF/6GuLyfkUD1Y5OWQqXMMK3Kx7IJA68BLObtuM9o8a0n0/RZh6Wg1XBrCZ1F5f3kFAQzJoT7rcqsUh8d3KJikYIKqHZ19idYWAO7VnXQ+sdrS8K5b6g7U9A7dTGCYhOQbQD4UStojDwOpzhwtIAeEE0WDKnOsVG4RuHS2QuAd7829UNZxd/QSmy+SKadkE7aVOxW43QxOihOecewkV1MuhY7e40W9h72Puq9uyl4eZjd0BzAnpxs7atzRoQ5gE3o2zbVVt2s7dO5+y426wSUtTjpo5mYVVkpf7cjBS+SFoU4AFo5Nogtn8z4L2jNU860SNmy0pNDtDoW+BJT/tOtNbwAz/9TNz7Lv8HCII1grvSQJ6wdrlZbM/JzZ91Odv25CKIo3vWliuMK5A9mH/SmK8A5q3m7LdiVJjuO6DrfalTkcqxTE/fP/PfeLGY/NCY2qyamoLGzWjq6yTzO5OlT1G5vulzVkiLLAZoC1phBX20j/RlZRCjAuZtXjMj74vknEjt2R0NFmZn6XtzRITzSj9LyK1SoqoQF9/u2ETdi1leRH2DnYHRRMNLSHJj9XlVT3yBikLaqjpFhRMDi1s3JmlMvycmX66UqGi2/OUC5YZY9FIWvtuigtUs+KbP/kp8/Wd+BX7ypc/DY3/2KYCtQU3mbqC2lnXqfs0CZ//Odm0mH7XDmRLQoOzcJ6JpbsKa6uYlOv3ExTk0oa6eR/BGGGE3Zys5xaK0xK04JW8jwezSjtgpz4mpzYUMlC7U+88iM18PMRnEHrcG6l3dPG1RGJvWTO0UaKcgOgHoBBphbFbFZh0K/Zp7ugCvyE4mgGcThHxkz3lUu/7Wm3+7uuGcJYIMkmzglVy9sctuwVyOqx8R/grfqdXP5ou1+KnZpH82WDNNo7G+T+Q1Dze5pUnbjwFn5Kbt2rIvsiKnh5/N95gG9W9VzdmDUwipRQFp6gSpv4fI2+RpIEvkhUZIuuGQvPlGbnZexQfgqFcM0+5YgLe/7e24/bvcHm98wxsxCFMUtweKkaQpO9K2YpOHmc1dS5KNfJ2vqfrZStlQbiVgT0V7LppzaM9+uQuUwzzpN1ujbr6OPbqcKvhz5bHv6ROMDdJs7xXbXgF0mE99o3IwuxZNrknbteGiMbO5K5DX3cEMD8AR9z+n71pis6lfVMLX7MFgVGFswlPOznoC9Kpkm5M1oOzREBlnYKlypHOqkc4p7YVrsLPKX/quuq0vQtYrXBsXeNxnIzGPlgMaqMFsYmtaLQRsudybY1R98YtMcT0TdA5mh0+afyWK7QuiYEeFMpVz5cvNJsoTHnYdLpyc4roHfTG+5T99D8jUcSpFSEJpjnXDiDyIMnkJaXfKclkF0A7pAmiwfd/4PTpL1Sed+6t4bc9RgNxSSPF/r0etBBaxL94v0612kmJa/e420eb7Ng/Beh4a2V48tGGFmrZVc1ZT9pLm7L4D9dPUnOkUoFOFMzmcF0j3QD+b32ZO14YXDVO7VsmUQn3s1q1bK5yHACvrRImoSykDmGov1lzo2JUdzP682HMw2DvQPaKUAsyhNbtWLg5noDbEiCpi2yEWtRxrVLc5rnZUW7dV8PYAGC+DqS9PODNpmwmPHPUgOG2Dt4AroGlJrdocdFp0yDcRe49ianJdlsBmDvOIxaI9C/DB9/jn+LiPuw9e+usvxtIMxLbIGpkEjqrZIOnn5lKIBWmpDzJjOu1GFQPVlE3YkwSY95SXuF5+v8+bERou5efArgEk4TzJMZVLvl+WvZft+rHBmgzQ+lYUP7+W8nQaxJliL6xh845INyHTnt0C4u0QM9Yg4w3gvj4zbfu1Ux8iijnXNFmbp6E5A5P2nFN3BnMtt0qm+TWawdyFNb3OX2/CnohmuEeNe25FMNWQxiFA76Kt/hhoTdAamdZchm/scOGCC6DNn8nmF2UPkHLAkc3CXmgosbBD61Q7KqSNuO8LXxzQ7m9uBuZiMvMoaGJVMn7nT38fn/jh98Mfv/51GuxkVpIpsYKKQIsC5mqLsIkaGrDbl6iA2YbkRgkrEJ2/A+WcuemOoTE/gwLKFdAVzvqZHaE9i2XMSE3pnDXnEICprABzf3l2GJk1j6iF8qO9DkjTWpsXmVlAq2vNJ5PWjHZBjwZnDVSzgj3NA/wsWE5Wi9UoJWRLiVtvFMPsoGbwrRfOBcbrsYHaCnhOYg3bZ92tERGbuWtjArFKbPV+ThZftyFMT8DO17V6LBKzCCzgyTZrzKFsh6OaCLPGtoDQyDVe953ogghAtzRrk0ZOwNM8KBZW7HBQo3qsSgNzRrV7zq2rnTfuL+MlL/lN9KbmRypjb1ByU2b4mUlCU/FNvwZ21bARZ5eP6plwGO/rfSKsJHrZ2wzl0TZgrgI8TXdzc5DNfd58IUZcw8o8r8FMBmgPnoO9pmbUuNbtN9W6E9CokLYBh7O7M7AZBc4K6BbXLx2o6Vcm8ahchMYs2y8Vv1R/hYcoZl1015pRHC+qIWvF5Q4tmKgZ7l7Jjsp8EqaC/EwOdBYEoImK1lxzGATpVE+ztUbfWhSxNEBWRKAeRAVX91zHRHCpey2gM5g1D3wqkvlh67oCZi7CnYCY8KDHPgx9t4CJ0HoHtaF7ToEzTRPPzgYl6GxawH3kmnlhAWBm3haymsNVm3YfdIA11EPTqOGl/eaa4LapqRWuCjCmsVsFg7kEUd3NbHV5nI2da7cqVnS7sNI8CMsVotEtMYdAo4HWbpHZi0Vm70D9BOgnQEu/M0x7FjqB9/VWOJuw7IJNqU0vQ7SaHjOYGYMHmHs8dg2aOVSJm3W7uuF8bpOHKSG9Nyj7cb3CcxO8xUBdYF67WPmYtIojj8trYm6W5yucfTFuBGg1c4p5z+2xG6hrPEn46yg97frYzdq6Mift2ercomlpR/Z87+aANpWjAUIubTuc9QtK2RrJAS2pOcP8L76OifK3j9hLcrPMjRP6/g5mP/0kYfyolcVqAz/9vW7aLgAGGZQlNeemfw+jSQWzx/9tAU3bjcGuQbl2XoUR5frCrmHE95RpMgqYy0+JGxuE8/miPfvLZQPpALMeXYs+EOnEfHxuVvQ8zRJ6nGD262LXyO3zfnNNJq4E4AUrmmvL01y1chMk6GAbAx3enlGDDwVettbmFjO4kWnJ9sowZ2vDptaMeQ5lBzM5AD1P1zbaSJe02VXBbLM9F3QKrnnROaAsba/32wbUBdgOKyr/ntxcDMm9AQon2a+alysoPS4k5GX/By50O5w188LWP4m5+TUKW4M2M7eBaFVBwr+3rbQo/uEBTd0WdJdiwo5Nx3yz/kXdrN0S8NQKpG0/ckuPh7RvNGdY/IWfkRCGqURGS1MrJFnDFxILyrU0KCvKo1qzAbpvNGc6BegChE5Na97B6wCEwYTYzkuas3kweDDGGOAxwDwM0FZT27Rn5o5bcru64Xxmi4fZTNOc0D03GPuxAro+PqplS4nadkrYLlsiVoMgshkTsDdBKA7hAuR4Dglk3QzpAAg+jX1NOKhVU7bKUQ5lUPiSFbp6n60QS2sJax0NaO7bFNPQYIutY5LQscIDkkKzsSNnuaYQvAfBhBZDjKAElugPd/z7qdLTThHspSlXHpoWW1iY9RkGXSINc3EgE2HfNoBuUEg3ZIWpNgM6wEzzuXcw14A+r4FjPQaAcjSrbAgsw/7kgA5DieRdv+aC/FsCGuGXTkgbGk3liNam/gMCykVLscePe/y/xJd86b3xjKf/Pp7y5Ffk97DrApuP+lmFzBuBwq0Z2a/ZenjbXDXvIjpx1jFGQ6cODV2sRXM0kNHryYtV5PKl3tlyEMS0Zb8Gzom4bjWvocysAHSD2Fz2JD0gwSwWFBlv6DLMFExiftwDQDuk05RGRRslT00C2/WWsMbR4LQ0xRKWWMow4Tnfc8T3FHtRRI2LWKtKsxSEvzyjtxXUYaPS79v0e4q3PZx63ub0kjABOaD9WFe0Lw77MeKrwB9P4q+tbZhVSI96PTNdqUnPc8Ytrn0buhe25jUnrOjIqppzi2Aw1Z4RkNaAMMFOc5jdlNZ83phTjlVbljEwxgoeHTwaxmh2fyBL5ALjVqk5n9lJi1ZeDmg2MDOwZz362NtYy7Gavl1rjp7QZYhFJMo7GZxRrZ/28M/Dt/zAU/EPb34z/s097xmAri+vwWB6J39iplNtYI0Ec4PObT/2UPVSq8oWcgppadZer1kdXDuSqeLSxNaMSsBEnmrl32RjCg2/O2zvM+nS+WC7vVctqgUm5qmr0eAeMKWxJhSlPzvclO+oci0HpaKXYCUyMEsAem3FpN2A0QijFUA7mAu/KE/l5Pc/GK4gOAsdzAjZI+IViZ3ddNCHvU4Bfxs5eE3+Zn9hBpHZpjadVNrcj10VAOEx33g/LEvDtzz+4/G93/27psn4BxO853jOy5QaZqHFRUKvPWclcCiLMy40DModizUbUEA7nP3K1vKz5jKBa8zmSee0pjqQmweAmdZ8+9vfHm+9/gasnNpzRii0+WKjCDyh/Sn0JD7AXj51sVnV17yBMzn8UI4oYIYCNsM4DdAWV9Ac1AxQExCpyRYkWjAk4GymYkstDatZs7Vk61g8ctoArWU08/tJfE+O76rmef8SNRp9BnRM+pj8Vbip53h7vx5N2Hcwl+dCW7bZ1dBCKFb3iPVsdkCH9uxgXiZAV99z+ppTc3Y4CxPI4wZAtmer2ZoDzB1jdPDashRuqUR36zRrX7bdzsXp4ZpzgbCPgPMA9s0GmUNSFObhk3Y4W9RiBI14sIgucu81m/czzcQB/PCveRSW3Q53vvvd8cEfc1+87mUvm8zWHlRTNefpZo9nIKc524fKpm7SBrLAPnJTCdHSwNwb2B63TlH/NwI+vauPbUwEe0/bLMk3eEGkErhiwrm+0/pAiIZgYUVQsqjmwjXULP/pSt4Eff7NunxLVDco/MjDwDwoteTV7o8msF4HGI20gULDVDDOlc0J0P7ZYt/Fj4zJlahpHQj+RSIB0tS/zXxUX7LPh82+56eqwFHmh0g1W/yUHk6iuJ8iwE8++yHoXTfxV/7+38Tc1T/b+RUq7yCAtIPvVwVF1307HMzmUY62fA0LERZq2MFa9sGCxcIdU+GsXynC2yQtKH49Jo0ZCuev+3ePx5d93WNwdnYZH/ZB98TbbjxDgmeGgkKZ4jd6mlRanlq0bpS4+HbBu5mFXWO2ozigzY/rszpN7D6KWRtQKJNqf5HNwFKED7GAP9eemwkCrVQko7K/uP5qvaVJ+0xrUQ9GmPY9cAvT4oUv7DkSf3uTAmbAdyWKxZ4gDuF+EhKb/bsUyOox8+JdiOvm5iMNqmUtA9zY5hM39GGV84bWyq6Adv9zgNm0ZrZKeprKp2lZGn2uK1Zrgy9g9y+Pbj3RrQzuaFZpz6AswLreKuFsELUIR92RXRsewL4bjG2cVzC3EhDWTJ3CDGfPabOiw5qg7zD2Se3BMgxvNp9h9YKfePJT8H/+yNPxlr/+X/ijl/02FlvXDAmNGQXW9vDoMji+IeqmJLBiaTjyDypsGgp89X4UQGqHRwfVZHXyr20CtHAeYz2bK5rLGqdR3oNInzfBRNMzKTwHznMPHxkCM9tD86L9q5hdWKPUVeOecpgbMEiwNrKsOcHopjFbijt3Mjgn/aV4A0JhImTTDillWO1IHMpL7P9Vc3bBIczf+fO1wb1srr1Mpxs1SK4mMOX/fQLphfnQe703HvnIB+Ep3/treP3r34bJr2LJ0x9//38Gz11/0Kc8JwK/AlMCTHm4AGYrztarLQlRci8yKYyvdLTXtWJ28E5GFdRuNTlIG3bZUxzO+v0+/pM+FUSECxcu4h73uAde9Yd/nBcGDHjdfDOZ6/UyLRFLan3u7nHBNSQEnwDjENB1VN+tVbsih7ObriGlsKFay5qdE8LWMqBw1tKaRXig8j0FJlSV6m32b7nlHsaxj3lapH5XcnO27211Zh4z8blkGStzKwD537IUcN3JqGwwObMAt5M5luNc+VwAowlr/AHrOupeb4IIfZhVxjtQrVY9rzaGsSGWciiyQLiDul1vYisjLuqL9i5wwxvHNOuN7vobRYMWEWCsuEW3qxvONzJwYpqzh9yOYbA9Bui1aMsw3zMDa59KRom1HNN8R6vjKgZpWUPS1Bw2q+pscJ7qC4vg1372F/CS5/4cFhnYQXvhjpCSJeb3diPebtR+c675tLckj5SODVDV9EQksZPpGhZQB9hhtAikiz6OGCEBdZcaAd85CCWX1X6jgllN1rG+m2QpPzNA6JolbE1iwhRKnxRTsL/VYmCLTZmoyNkKZpBY20ALWbOgL6ZqxpY0ZXfSXsBdUmPWDhxwN1i1ulXZxjXmznYcSPcjFSHE1GNHoiMh/NJ2QR24DQhzviEKiK3KLDJJSHg1rqobpd+E8bKX/XtcvHiKh3z2fXDXu34dIgnP098w8PVf9wI8+Xv/P/i1X/1LnJ2t+YVic8QE62PC4XRu7FN8X1ug5e/zSHokUh0l4OwA8pgJCiuLQK9jJoaZQCAEj/JXMEua5CH4jsdch3//zB/Dn732tfjjP3g1Ukr1C4QMuouIzJIT7NHPrdncoATzInnxvbpQc0CPDZgtOjrK/lqTBtG0Lu30JXkexYSeAHSWFiJiNPLsixZwJndXuSXLUhrF3jPBLPAKW2zmaraFS6V+t1sEyayD3gijSIebTcqlG0EGbUg8nh1yBcwyA3mCs5AKMKYx15oIAWYSCwzUo7s6OpNaakyD1haQGgjrpm6iHJ5iCFmsp7dec+lABNaRdZi3crcxBubObiwbONcd/Kbfrm44XxKFsMDUkmGAHakNr6tpyRXMpDk2bgJfByLX2QPBwt+scBZRQGfKRQE0HNTqy2GxduKSMLZ67PA8Pfc11o25boaTBoWqIbk86eZc17wSeGRgyvsG1gLcuY5oAy+C1gUcJbclzHdkSdlennCSoB3QDMiQyDiIIFgzGbcB04YkAT3rhYj4OgGYM0O3Jl8EMx0Ybn4gM9zZZ2gsxwzp0YDRBdxJteYutgBFK1saVcgIQyUytgpEE5z19FkaDyLHttqtfasnmwMQGIB0v+fyu9zlUfWKw5trLwblYrao4XSu4GiYhF+YdXrn5/3CH+N5v/BaAC0CbfJ60PT5NP3fDZOuObu27ClOjIVYk1LISk+QefRIx0LQ1geEDPj1OU1+fU2PI4/4rsZOOVg3CK1e8Ee//7t4wId/iHVht1d6xS+M4Ie+gRRAu6/Vop/9y00Sh02AhRPOnU1zVlBT5m0ia0LbvuKQZDNpswGYVejQwiwF0PDa8y2byZjmTN7UpwRmxlqyuR/R69ZpimvqCOl+1RzUJTBGorZ3HT7Fyv0iF6owJ5hOsBTt2DetAyAj7lNA20u9mnAiLpxrvnsTLQncfU2Kg9ksbcMgbdHbvZkWvao/mkgrtNeWqmAta4uu+dvqs9dAWu2drpkEgQjTlNkaxqgXNBW0devDuom3qxzOjOjxFwmrnP7iCugI3UVJn3ITeCt2UASchW1BsXZCEd6rBg177G3BDMgNrECGgIUNylbEUGrQR/6EbLVXNWmT6l0rLLdjmkuYM+2dPH0ExPBOLdQYo1kh+55HLAxtmQXwIiBTcyjoMzQFwwrtayMMN4HZYhUte0ilzSANiQwVNDUfT1986O4bRZgoNWiNbqZomdmFJn9zaEl2zsQ2V7caKJwlIF39yhH8ZWDmRXQRmlM7MlJclduatoEIAAvFqZniVADjAVkCNcPrb6FQZfx3ClmWCgqgD65zDQErUK4WjGJrEKtcdZ+P/lp8xSM/Hd/3lF+DNjko5gATbjyStsbAR57p9P/cQjNsK/Pr3eyvp0+B3MHoAWjGjmZgK6DttX494xra+aO0oGzjLFJMyHNE4ufJ36A6AMyXMEfLxfzJYWBuI6WtADRScz4GaDehlGCw2lQiu9i5sd6h4xqhCt5NLFUMGgA3A5rMvE3qc5am69mgHPHpZF5uXwcFzjXIS60pau72+tnebQpsa9nbSPr+eATO/lb67yyQMEBs/mfJ2TTPs/lx/mfClsiUndLFCxNbsKEIOpfGuKSA7mR9DsjgbNaGRpkdEOKlVX4Uiw6VpoI7k2gALex8mlXCSo+rphxgzoIkDmfeM27J7eqH874hwoKZivZMaaqOmo3ItKlh5uzRS0UKJJy9M5U3uLU2ZYK9ac5rRDseALpAegvlwK5tGlmG0yqFITdDRy6X+6DciFoxxflwTdlbvQ1LtXAwD/OP0dKApQWM1d3CwELgBaZFS/GleWEFG1G3LiVrCShL+u4b4tyzfulsoT0Aj47KdCjTlERTEFxzjiUkDkCx02Fbr/1+MSiLmfC4GaQNzNJg5mxAFoEsRsewuyag3bxdNWfy78AG6G6AXhGNFvx1YQGxqNvJ6GDTtVRjzAwVmueKblw+jyT+U7Rm+chadVpk4HWvez2+/rofgdYLPplmVronBsja9U1BOjHdZkxXQNcxlTkhB7TDeGChEYCuw+GcvlT9VSPgTAXMRWuW3LynxeI3KU+KCyFHNkkCIngizp9NWs9QqFqza84V0AFn921YcJVHPnusito8FZCjBoJJpoORWWYgVi9cIkI9AE15VHO2tckxocOtMrElMqJ87pjgnEKeNxrJugNlXTNAq0BWMXlDwiBQY0w0bRSTEULvO6TlYEal5pzzC7KFc7N1R3Z+vHiNmbPNtK1yk95fPEDMLp03MPRz5p7smFVCBmY9aTyoVGqmqdY+ixQDqxQ4z5XCPBZp7LeT86bdrn44L2xn8Jh52wfmYC+Hsze+qMWVA84OHi3ZpgtMO5FoP9JRjglpNmk44Iz0L5NpOXkzvUW2GlOR/DHL9C6Bukkvd6XcvIk4oEzE4DZAbQSYU92jcLVgJ8COwkHIOzOB9wEpgPZcyOhk4w5l99GvrIDudp4bIu4GjcCrbiqeYnXnO9wZ3/BvvwE/+9yfwR+/+jXoRBbdrEFCml45N0gIrUlsowGQHYE8GjVB7ZCWxmA3Y5sFS3yz3QFUtGhxDck+rMLZlY5m+28r+/dkZrXLwyaBSRmxERMsTaR8hs0X+POb65xjhjGiAlPVkv0+TV8q4+I9hKue2aKThsBo/1HenwBN5hMOMOummXBebQwsbSS4bTicUWMmYAIMinDmG3mcDsoHYlJNwNiBACR0OVylSQ8XkW0VbgKsphGaMxLMFdBhZVKBidydUHokY6TWHBqzCLaWgQiuE4OOC0JimrP/F5IeQnsO7c5GtuBMIXaywFC80IJVbaJ6167VBO+pFoT+NMppaPdNa3bFXGyt+vUQyvQ8bIGdWAa8hA2nQCikYDZFKMGsdb0UzsXt5OvSAD3lwM9LIjxFXqLcexupgO9x7NbKRVTQ8VKdCmhLsRItQhJxSLdKzfkyQAu7VcYmyEgzd5XuQuLbgtltnZNopGYcO8ne5FvMTkuuOWMNQGsd4EyPGF6NqEjH9eZzVsF8peqy9dV6yxhG24BMIvbRiE1zVr+SQlnL/1EfoLZqb9NOGKExi2rNO4LsyDpKisJq0X/nkahSqgghfGgj3QmLSdgGQHiQWUCazAemJHrxL78Ed3+Pu+OLvvARuOt73hXewCNKkbLWSm5CUWSCbLMh36UrmMH2GQppaXoedKG19CE1B7MAC9lvJf3+xf9cL0yFcwWz7+HVLz3x0/Z9aWL+dHghJTNNztpyRkPPG9ghmF2kM0B77i60sMYWtjmXtMrbne70rvip5zwSr/nDN+Kx3/x8fd1BWP7W1Fi3T4MFJaAbfEN0kzWb1uxjNTjbaGr67uEDNXCYXLDVmIGiNUfumYsvEjYBAGadst/hgZoAMlS+3qytyhT9bBdmAjMS0B0bOEuaVFpel2icwyq4TmBuFgzG/jEl2h0K5UU8tzsB7UPnY5JGkKZtdwuxlKA5cQjnGdO6AraHwK18hewMYFUwU4FySZGeIE1cwFwAne48AzW2oE7F5BDRet4siaqYsznBjKI1+2PzVUdN/viNTmId2UZUyS5dbM9QAX+YwK81/s1tafnOfszKYA5mi4i/VQaEXeawC8+t4HJEf1YHMzO0gfrA1C5yaklkkzJMt8W0LdqUkA605S2gXWvWY91YdUGkrJ6m7bqd5gSOYIk4JJB62ZIaPF1CAzuYhgY80MBoTQHbm9pgF5hZVyALQ3YM2RHaCUEczjuBOJz7ConiCqW8HxfNebD68BeG7AugzSEpBWQgRKqM/ibCWKzbCyyVxjchgZbkc6DFqSiLzGCspkhvU0cGZgpQS+PUmN2/bNaDtohZD4pW3V0Asg91EzWrwqXdb7DRev1S5yalX428kmFqyv7v7P23WvcM6O3wPl0efexgPi7i1QUi6PiZ5z4S9/+ED8IDHvhBeMEvvwq/89v/PbbDCme/PlsoNxC8O5ZH0EdQM8GgK+gBYoezatHdIN2bmim9AhWTzunqv3ctXs+trZBIIq+nRWyF5Iao8ClatACHhdD9HNsqJAIs2EqzFYqgNgG6qGmLwpnsd5CnL4jGftDgnLMO5mbBYM2YboCePgZmjYCnk7mtw2qIl2slQPE1669i2HkJHhmIgAJnKKBdaBAkrBzA2yqK3tjK9thws7OuV7LrUSzoqUnH/N7MdS+iE8O1ZreebEzZHttgYxHJozA6Zw33RmzuhFScHKBuJSVmSOcQ3tU9pvvpCJel3h+mJfsx4CwbOI9bo+Z8lnCOwANfc1WKM1O1TFHYHd7EPLodONQDzg5oC7KJEGRvTp5mbU5vqU1w06BRZ2NdIx6K40fXhnOb3W6vDiRdjqk5hr5gE9DBzK2pxuw9TVsD9TVWfGiOO4bsBuSkaVfBE1h3QVbLRB+Qvmrx/bZX7VlWEFZLNRsagBdFYEz63CuIvAiT5kun5kwE3P9zPxXf/BWPxn/6hZ8D9wUu13IxaDWmBFuclwJmX/UFypn+4GCGglnVcEjnhHMXkAeFuZl/ETtHusNJ8wvo84uCiW4emzYhK28mbuozwcSS3Gfgb5Xjg1vZzSqYRbdeiS14bMC8KR4SIS1qAn/d6/5v3P8TPgjMgje+8W8BnG1mXWov/vyVIO05ucEwM2vrYPQ2dNBAb2s8bjTQ2lBIkVhLxQRLmtExRfsmmMmCCU3gtWI2DmgRk4JqYJjnUsf5qSefMJV6c815C+gI2UexoYoFYDK85CPBFIKoJ88B5khrbBIfGfx3RZ3Mik7+cWLBTu5zBnrv+Imf/SPc6c7viad8z7/FC1/y06FrWEhHXlLx86TmX2EDc/yHCc7ke6dDeBXLdEGB9hbMOv8j3swrndnmF+btmGV5DWaREBYkJxGtrYIJWzczzW92rXmxv6l5217D1ljFAlnb5CT3hicDbP2rQ1nr+pvFCpAwMRgj/xMGSznyCHN2wll5MW6NcKYz84t62KtLhhtA6zB/j8e6e7i8BQIolCnh7ClCdqIp4Oyb4AhoxxBrczeL8valEsn5rASQ22b4c75VOhsIUKncN5MSeSlWXJ4nzVmlfx9VJJeFgWWBLAN91yC7BvFqdjuAdgzacZi2xfM4yVanuOasYBbTnKkCugto74COnTs2vTf90z/g65/0BG2MvnS06ENNcWQilcSBBDT5Qrdz7QFR9Wigzj2dLPKczVEsoHBMiQXCIQLFSrtZZ8IE501P+/AnR7637QEunEitmGFT1qhjAMEBoMV+ZwLGTPcFyAoa154TrgmeXAwaL6A/7FFf/Qy84Jd/D3/5l2/GG97wt47A6T1mKKPcb6E1ezWrqcGFa4BN4dxaAXSBc2/6t1Z6H0cP5gOtsEUELIQ0ur81K0vZMkIWBh0QZst3rr28cf5GE+b8N2aHNor5o3NBEtB2zBRFhXNt5Tg14QgwS9TLvrA7wad+zIPwX1/+X7COy9My6ZKgXhzMdlSBhvChH/rReI/3fD8AwMMe/vV4yW8+J+rF1y5W0zkwMDdK8c4LoXhq5KTceJDnZpAFiWUTLspeF/4ek/bsZmxbtnEdcuJXMOf3Upedm7XDbO1as5jmDG2ksshQMLehAWQ80LQVDtIltyqULSNHuIO89d1oUfaUrc0lY4XpzGBZMWRgiEKZRRtf+PtJ1MHQGty35HZ1w/mcdeLBJWkEryID36PmuKWpmhvAI0LnE8r+HlJG7rSZK1okL+iFqZJAAMMjDALFet3rttk3x3njUDwBMJOT/W54FOPGrAuFUWrPbJozacepEnEa5uyF0XYdsjS0nZq05QSQHdBOzNxt2jP1gak5O9YC5xFmbbHa5mSbl5qzdaOkgKWp0si2lp4cURNHDnU1hLkM8ftjJ4GnEXkHHCkbq7SiemtRXrMmaIS2ghkZLOb3m29s9omH8uA0VaQjNesuKI27Mm2sIU2LVYBwQPsMKUU1JDawY4AGcoZswVwl1fRcAh0vfOHLgcDqIZSnx5ReQASYyzUyTW6CM7n5Vs29Gfvg8Q8j/hbh6gGTFE3F1pOgpZbMSDATmwZd1pEljYewHvt/0aKv8DszWsiO9tvy5ZLHALauQyoFewCBB1rRwVA4v+KH/xTvded/hr9769/iox5ytzn+rFEGOVHEcMKXMzXBf/vzV+DNb3o97nDH98Dzf/4pWLp28OIi7UuTmHvu/Ej5wmIhqm/a0qa0boGEplzN2t7XwzVozSBLjVkH5X0AkS7qaVM1FmeCdb0yEubsWpClmfasZu4Z0noc6AZlbcDiuecrRFzB2INlATUt16mFBySi9NX6NsCk+x37kIQ0yxpg5tDE0+IqfGvUnPeiRcm9As1GhdGKNt2CG3SVCneEtuy7ZTTxrf8egJmgYMVFSBLA7tD29BWJoRF8syNMb+nl0f9vwdzLb6uQrv2dAZuslICuDh0PiiIHc6RbUGjNCh817SqgB2SncOYTCwg7ER07Bi0DtHBGbbstS4r2XH3OezGtGQbA1DIzckpFevEqR+hgUrl4YyxFaGtCKowxcuOr1yMcup72RXaE3UeaJggGBJQNDFEpbIrobghzfHg8SGHItid7zA+pUcZq8sIajFjtbiKLGoemW9h30msWe1Z1D27mQn3GfzuQ29g48vpDOKf5JC4K6lZ4ZUhXLbo8NpjFXJsucdEULb8+4OyZAw7mbsFgGrlj18xmuTRdXQyNgE03oaWvADIsCLD+cga8Wp2auP03SfmZMv1eQoYlAS4fFWyEhIgJ0rkWEfejVzk5oBFHd03d8V3uBAB4l9u+20FweECUPBpeU4SiRWYDqK145Bd+QEQY98XPO9K6Q7nVuU87ZQyJIEev9Oem6cxysWG+ZgrNuYIZmcUQhhCHNeU2ZXOT/GRKvQZ+/ursy5iaCcT1saT5umOgy9AjVjRZ0XgFYW9w3gPYg7FHkz0gPZr+qAtq0b3JNGedUyuY9hDsFcZ+lHEwxMAdcL5Vas57Vs3HWRq1YBu2K1Rs5yXmgLJMqgw2wxAqbo5KCGMLadOqOTbBgzdDSuvzFtvjvj9bIZzTNf5KRZr0SF/fFHwihfZMGLWupOcYN4UzL4K2MNrS0AzObQfwicIZDucd68bqaVW1LCGbZOhw9gCZPcLs54Fgutk2054brNIHMuQlkkV0iIeBuPBFUfpygrNw7gxed5Pc1IvYnCpjyJ4jC9xpBlKP5uauAWhchn4azTUYulYKinKfBubo7kUSgI6kgM2QOgL8eR+m2cD+XsE8b2XbW51/I86zb/leeISOwjlnoG+is9lbzzHFa5zIrmFSgqu277J8YOkm7Nl9L1ruze01t9S9hCYCi0SWYy2fKIMtSUOsMZpZkWxdibf94+KHns5RQgHl18Yz8o7OL5Dan35iwmcWsSiu1nz8iu9+GL7+cx6HH3ve94VG3ZpbzCnruRuYI3VPC5ihdT/H6orJ3s+qCMoEe/PhCopVXoWdCuXaUCugXDTnbcvqtgFzGEJci7bPJD+fBdI538p98XOUSkhqzK5BG5BjJJRVW7bBKxrtDc57aDrsHk3OVWuWplqzmxJo6El1wdngLNgroGVv2nOBdYw5tfbWC+dVwrdDcNO2O/SkDCr3OaDsvYjTJD5PjDBLm11MIj3Kt4sKbX3+yoBGHGskaX1+O1ljG/SvVV7nk9aDJfQcuI9Vo5JVi3Ewj9AEuQOtC1pXMJMPS6NqO2ie805AJ2zFScy03by0YQmQc9P2yhEYM3UnIESHqwB0JDdEVYcYIg5nBYk3VtcFbRspb0zasYs4mBMWKJeWbFeI7JOI8PZId7KjAjmhXZwWrHGETRLMXuBEbPNMwURMY/GSomIlRb3MqNYC979NmjMh0oGqeBdH0jktoUHX+VTPDduF8PNULswGzBIQRnkOeU4RJw7qkvBrmn8TF0xcczNh0Ad3VrdKZ7AHUllwlZpjDczUpjIFCmbCMCgPKxahr7XAv+Fw9qP9x36+YnkdrD+fH2IXYX5ZFeAl/4kLS/V5KSAOU7H+bXpsX+Ulf/Cr+K+/+6tYNIliikWjouU2Alqz1MJmEd5eza6rAJLZESnw1cp1UejGCoYkPPP7B6SvBOZxOLz2SnRokwJoG83On8+k6rLR/x8TknxGJqBdY3ZAe1GSJhZgKMPM2A7oPRr2IN6DcA6hHQgLWGyPsc0g08w6pPV0NYEhZAWocA7GOWQCs8NaU2s50mzN9XlrNGs3yxn0DUQtShyRnARE8AjM1CzS1DxdIj59osjBgvNJw7aYHMypTUt5zqFc5fa8HQfzIahzy8wNxlNDgjA5aakA2rXnplpzissDUsxg3ZpctKWh9abHhUCLmbSLWRsnAlpce9ZSntS8EIlFJLrmPKWWVDiT+W9UpI/e0NRBZDVto/B8OnsV0s2uWb1WQNQmjnBo94fXVKJyQqersNmfDZKZikahvXqNbkY9wup2I3Y9cS2lwRoKIHY9iVxJa7zhUG4GG39MBdIoe719x+zZ7LMmF/1W/NPRy7xsoAnMx+CMcn/7OO9roFWbHocJ2kaY7Kv1oQNsFhvugmHNI6RUZeMOjNamAn9a8oYwSk7pGEM150Ym6GQDRk13gUbN+nn06+EAKHC8IqwDxjRfDEuRy2GP4zP0SFQuolfP4nyfGijl32MCc5sFdHcTJJRJ0/ks4yAyMAqcI+q9fL3i/YELFtu/ezCYbDVoX2ZXgPI0JIWBJjiYWcckpdgNwxw6A7pGbLc6ZGhEtgwQmSkbaspuUCgTdiDeAbbnEKmphnxdacUjCC0AN3OpuOY8DM4KaIW0atEOahH1R0vRnoEB5lvWlurqhvMqEbehPFWQecqFmq9aLi4QrDehRtWaCiUmFZf5EIv3MKjLIrjtcWrS+Rq2CZSGx3nrzK0uH9eh/5YKoOMf5OtNqlZAI8xh7nf2ABRYbq9K3Nq32YOfWhcrNsIK5oXgDVo8z5m8QEmtH0za4D1M/J4qUgF94GOuv87KLDiAZYFIdoXJ0RXM3CBdF5EEmPX3SdWY0aCivQFzmi1+rvOM+tbQLIrIhSBGbpgkiBC/ASrnm8qOap/gGsoULGSas1UpGwbplfL+ZOaGRgyz5576HDCBcSvyaWh4nWfzXK0w9gC7K2nNZXYd3I94XqqAJgvGsgRCSi1WXSpkNX7IoOu1fwRrVNjCVPSFe7N+26T9t6lpCI4QVmlYhbGOoW0/B1txiDHDWUzG8zMmHL8hOiuRa2kSE8EMEZmLu4WxyzlbKEegvFNWyrRwDVWiUEf4czdbQ+wHdmliGlmU+OQJsvr3tBicvapdU2j75Z3BLBma4e6h1X4vl9cYoF3uda+RB365Vk0bKEeBNCnGsy2gA7h1XWZKm2vP1W7ha1YdMKaMQAPCVDnRDAQFs9UyJw32IiwA3KR9jrDSsUs11snLzdeyQtuF9rRCQpDR2nsIzsDigHYtejVQu4adBapUg775t6sazp2LJOz/l1xP+hcLGAsIU74IBAkNW9/TJ4/DPh/JAahzAzz2POLvjm+/1e3OHye6ZiNkKxv09haQRmrRvqIbKQw0MEzTLlq3+0Xa1gVOE5xpB60aVssT7hzO5sOOoLgC6OGr0U5kAMy/aEJB0MxsnWAm2SWkeUEUwe5qepKWQSW+mOApbi7SH6pBCJcGBKpelMvql9lSdLyjT1i4bLMfpHNowKNPK7gKmO2alXDVqZSoas86VmYFllh9nA2g9Wv55pCPsVHk5hlT5mvQ5EqacgMOZqHenzynVO6XkZmjBmMzRTuYucB5bYTegb1reyWnvHld824+/C7ar4Ya9sRqnBRRMDNj7Q3rYAwaGMQYpCWANK2F7Nrp2tZobuhcqfNRtkZU8Wl1/BRugVw9BBXMgklNDO04DDwSVQu9Dgpx2XSoHKs6W6CMnkJ0HRSas8yX1t+7/o7tUmGZp4Cfi82/q2lSB2CWIptLMZ4JZs1Ztl8tAT3dD21pzk7xnA7tWKVfhjwGRlaAuh0taBV7AOcQWVRbtiFhmvBYHbUEClmiVljQNMc5/M6mOQvOIXKezxUNWgHtKVW3Rs15AFFb2Z7TTcsusHikp5u98xKnf7maxBPwvh3FuxdQp6H50Bt4CGfA6zjlXNe/+mQ9tpX6cYv9Kyk4k3JqGhtRjZTNiFk0MjCzSd5kJSyRC30RK+spluusgxpbStIWzr4C6yr071i+XDohTWvuCmJZILwAvAOx319A3DXC3gPaPE/SE4ozYsU+p86QelYlIR1D/6Rf3aLs7aexAZg5NeZhvyFjFRBzi6UiUPI6BJg5fMwKFLGS7hJm7dCiYT5qQZrWzCqkYC4ggMubnq0qUOEnpJhyDnRr8yCu6l92zZjgOko+538PKNN8nyuUiTCoYZBpvo2wb6QpQd0sNwuplrwQ+gI0q8rmz6nmrD1t9qTb4F4YexGsg02oYazUFNBoAWaNmEUKWQ3h2tLNmEO4y3VeF1iReuy0kUPZY+qKoSZlNLsYMQnE4OzvZXMrHOjQGttcP7tcT+RyEQvNcI8PFoHsdJ1qNT+KAjoeVBexHv72RaDwVq5wZkj+LfaScjpocy4OwLwBcgyknFDFw7p1TbLQJHTaHl40p1k0FFy85gJ+8L/+Ck5OTvCYBzwcN/zjDfEDxTRnId1nsl9VFvMUSYFY4Twg2IHJNGdYhgY8E8d8yQHnswnQgmLirj7nWyOcO2/M2sh1kGtC8nJGEinZ2qR5UcTz+ST5Yp0/YXqcRph8/iB4BwC1BuG5mGe4qnAExvXrFehMwaNbEG7U8IzcNGCHf0pKdx0/Upgao5l8aM82IuLDV7sgavAedSyVJ9wJGfnlCl5iA/RQIMvYAX0H6t0gba9vBGIKs33Cea27pJ0kScHhAMoy+f5UxpA4MgMYJS0IhGGBZhXO4AR0BHoG0gzMcKm8KaCbB4Oxmn3ZQc0WpWxeAoJCHQ5G27I2QTRx38PPQ7SrKljO+3nGJXhpuo/pb+LHY1CGDs8iHdTCHL1vhMWOvTe0RqDeLM8e4IXQbChgHM5q/t4TcE6CcwDnBud9Z6yDVaMmz2B1MFsEt5DmnXpQGvv0cO1ZTFDPXwm/Zr4ovZLbpDXKpC1HUKG/hSiRfCqSQ9umKgnMtC1TswhfRne943viBT/0h1j6gi+87r544xtfV1If9ZzJLgdPwZvIsrMlODH2Q0YWOFwxF9Dx3+yCB+XKhS0XB3QN9Co1V+K+bxteOM1DPic4H5mavk9zue+Q1tKrORt9POJbvh73/KgPBwB8+b//Zjz1Kx4HcQ1XuoFZAc2iPmYRM4yLg1c/T10jQ33G1MHUEeG/5FFEh35nkbMCa4dzas5x4m/B7aqG8yK5ldS+yIdgtgsvRd/dUK8qI1VqnKGcxzlMawYxCqz9/X7rD1+ND/mwD8NvvvCF+NxP+7TD77oZVW7wnNoKa4d35d5E+RKoFJK0S9VRcpByJS00r6pppW3uh/PIhmkWxJvvEbA8AmaPEBodMjpoGJzHDlh2wFggXZ+j1uH5IxLscYfYNqDJdxOGTm+nb9dYgegZad/XtCGvIZwbG0XtbzK3CNUgKDObNvFcZwqtOY3CnKkYlDV6PSJ5hFmbMaRppaGQ5FHSgpACZwSLUTH7VVRnvaccsnmMd3g/ryzl3CuQ5mk005bNP2xw3lvv3N7E4h1EC+E0gHsDd8Lagb4QmrUvlR1BOmF0wtoJKwHnBN36xEaAeWCljlUGhqwY3CKKO7Il69wvzR5cgKHtycuNI3yybsamyYRtL05m6LQzWZGqkOovlStAmROOX/RZX4t3u/0dAQBf8rBvxhO/7xHa2rQriGNYFT9YmV2v6FcL6HjRQ/a5w/C29Hp0rR/53WUbL2hTo/zcHFIAjVlb9uGhBPGWlEaFGcwIrZlhc1987ntQlv0hZiLj5b/6QnzhY68DEeF3fumFBaArBA3sOZye/bFZoQxtYjGI4dHWTDsMSTiry0YN21odbGPaNt8zNmZuseRwdavucUtuVzecWX2rsZFgvqBRJAw+D6QAWpdnoXTcZqth/ftxUB8eE9T+Ph98r3uBiHDf+9//4N3qY92Aqbxj3SwR6RGpxZgoMOdfGAvpcIQkbvdLmUopZu0M0pFtptPGn2WBWQ1WA0PKl0Qea9TTIEQ3sIwSMjjb/b4AfQd0hXe0f/KdgUR3zJCq/bMNzNJjxyG7LyYYkIiWbh3QAJtB2oPaioVsg9io205GXhLC/ZnWNYup+NUMzOFoFKvp7WAeCec2dw7S7nwWaeyyDNucNvN2/FYDs+REtcn2jkBsgoX+qs3f6xHxOpQ5lma+Cma2aGq9v6JhTy1qa2uFMLM6NFG5yPzQvatGTV1T+aQ3yNI02Ks37Mm0ZyDgvCfGOTH2NLDK0CAxphnOA1H4T8ytEC0SqYEmKTJXYpU3Fc4FzCQbONcpJwnaau4uL/Kgq3jv4mnx40/9yg/hCz7jq9Bbw7P/81PduATz9ug4BcYJgFMAJ8hyuye5buMc28d4CQJeAdY03yjv6fB275AUrbr+Xjd1+9KrDHfT9QGYabNtOOApAT2BmUSFXXtNNW65YKrXSWfjn7zi9/DJt30v7JZTXHrbjehY1BtNDVpsRLURr0Do3bvCFQU3WGu8wqAVQ3YKZukRSyGScNYOhJZGNWnQCmXE0GAw3FrhvINe8ISybxwJXxYJQ5973Tyis3rm2FecicJVuCt/mJ65aff18Q897Wn43C/8QvzAk5/8jn9U+RqVbVWDYWiDAdWudMI1S2EhT2dpDdz0KI3AFgkrMSiOWCq0JVeV9zcO8djGMaWM/evTHDenDlTVzB3MS4KZRgPWpkFfvUHDyC1KKO5rVKUCGrlDxM7hp9mvsn/RATWdD3hFEeIGGWIuBpiZUjSX097OBR+upgcTDsRCaUXUNKZwVs1Zv1YRp0y718YbBuhGqkG3ERVlR/hKSTXoZm1UoilBmQc+YoJKAfRsAjyuOWM6JqgDUXD9hOIzCd7pqKFEY1utYzVlMzpalOzUYfKUgVlM+BmNsOuE3iyVr1vQ39LAS7OIbTWHrxXOLAZmxh4Dex5YeWD0hsEreKhJPMzZxffr80Z/m1vc7JcWknpwFpGk14TEAF0XahHdBTGXEs6Sp7pCX7C5kPlu//ffvB4f+uDbYmnA0oHFQevxkScFzBcAOQXaacJZivbs/Ru8ER+PhDOfY67TJEiT9wI41xzObrp3sG59xwFmMk2ajsj0R/5dyPF2dKFUL5VozQGokpU3JbuYueHSjdfjDJfQ0BFdn0OQ3uuVFoOzgRkwU7VpzUMYAysGdmCo5jxccxbX5gPjCJ+yw1mqqbuYtOEZLbdGONtEKEKpSTmWjwovrmnRfhIMCZ744xa5o3nzLc1hnc/WdXplKFN57bc8+tF4/KMfPVmMDm5VPrDHujF79GIORhb1mIZWKrCqVAroL/2mJ+KjP+GB+MFnfCd+61X/1cyKDmgFd9WUo3Rla9a9yd+XDq3IZKurnAJyEzqT/lsmLSjf7HEdrSFrEdom7fczrHyjOQPhP4wzpm0QHcjurCMvbM0GV9YqccJN66gUf7zuHg4irfbNBc6aNpTpFyINLKWlpdg19zQ2gzLagJjWrNdFC8Koq55Mc/bBYXAVIa86qxvSdrZN0207DyuUfXJVusyg3kLaK2TJ5lhN2gMqFKohsc1QJpT5aUFxpq0tDRa93dBagXPr4NYDzp5OtQdwLsA5Mc5JsJeBfRtY+8DKK9bhaVum2Vsd99ScYVRs9ktanhuxXyrljJhcpdPbwByncJ7rrnVGi1GzIrliLuW1AefyOK6cy4FAxh6YEckzKKiAGRcAuaCaNNmA+6KLWTva1w9g7IFxbn+n1Jq5+KNlNcDvETErAWgHJyWUw1y9AfOkNVOJ3K6z0KZoWjZt/XjeseTrMqDdhR49+QpMn9sZ1Say2jrWmv0ApbbuvxuqB2u3qRMMrFixh9cY0+EFcNTylY2OKqB1IPzN3nvAzSm3woCwE1PoKpy3UNYTK3HZeut42Z+8Bnd/r/fCI7/oS/Cff/EXJ8mszIfyuGbd1VfVrW2WCiuY698OX1f+YH/15zw6FzBAm8biDQYqnIVIS0ZSMxN2A7eGduEiPuPzHgEiwtc9+tvx0n/zCeHz86NYCgtHPWlBVPoyCTo6KlEz+5TvPjbjfeMi6OuYQBXkRzpS5Wh5n/yxw9iHqexhE/NNbeNclFa+m0nKVhOSmh4VzOKWagswy4vBlGBu0sBsmr0LCZbM0dDUDGe9a1vMFckdngakdaCPgLl48FLPTULBLDmPhfU6cgGM631im5Rv/r7puApdN7ZpzuYMzCBG2rzOZjT56wqYSQPHfG2xBYGtJoyUbTDnJ/Qkc0SnAwsRFiJ0amhNA3XILCTcFkhzOLeA816Q9ZkaY98G9rRqZHhrFmRXvScbczaapdGUxy6GiJ8JSbnPTuKcDVho6mAWXRsRcFXBTPHS/HdlmcRbOZgNVERu+tcpxzsNxYD5meVUwdwuAnQh4eytXic4w8C8KpzZPUewvdJiJt0fLXuEXVpWJKBbbDW5DMuo5UF720Rt+zZCGa5SZXq/v52JbuHQ10u8PuwfJMVS5UbqgbAwigqPHDN9oznDitrQUM1ZdhhYVGsWL2/igoyY4DyK77nkNIef2cE8yne6FWrOp9CLPoO5SIzQxBGXfgjAx9z/4/EB97wnAOCbnvAt+OXnPQ9A0aDL+20Bvb1tAVxffSUYb0074cup/6b+Q9C0yHUxJ6RB6kumZg0kWtPSc6aF7NeB69/+Ntz2drfHa//sNRi9Y3Q3H1KMLO1pmnMjM8WmdhlaJhXNw2yfR3lQVjHFjz2yqqfncheQCmfb5PPm36E4yDxauar3nIAQ66FHI3s+ozVd+HHy9d8qmHWRUreTE2X9smsWg8ykTSbkpdYM15pFzerSE8wR/DIdrXWKAxwlgBGwNogHE7Oc/HIFpufqP6CDf5ivoIC+PqKcb/ZYNyoNANO5S5mc5UC2aCoXKgLM0HzxxYPFqKFR145AtEBosfPbMVrPyG+Q6ibNUqrc59yapVN5ChdKEF06ulDPpPi8kYi6J/E8WgNBgwZv1TXpxwnMYo01FMy1l84UdrG5XNM1snHtNbfBa57/Jlxz4Vp8+zO/Hs/+L08DWRgGFqgPbwfATNlyQcHcLgJ0EemD3iEDwsjM2gNYV9Wax6LQj73STN7icN4poKd2qZsRy5ThnVdTpub55aFJCxDyfbUa2GPff/1PDnDyB65Nw867vVoBzXb19MgYiIr8YsrMNN/FIrTZYjwMzrRXOEvXLABqWTYW5ncO7dkKjBQoZ6pVMWlDgP8/nFNSjBakSEA3qEzzB7/1W/jbv3kT7nCnd8ePfv8zJhNzmrwTxxW8FdLTgoWvMV3Q7/d+74cv+uIvxg8+9an4x7//+wP4+kZWsHIIap9Q/r+N5jxpzNZMIjRO05qldYze8ZBP+1i8y93ugje//e8xLizqo+sNY2nghaLWB5vWLE2sMYHCJapr1JPheaICeC20WUihetJmbmxF5PI7U0M8du7rizOrN6NvqLywnG2fHPWcDTeR+8IGaotCoEft3SYdzB3SOxoroLXvdNctQahcN9tePJq8W95lXxWyMgf4sW00LAmULBBrr6eqPefPTY2sQPtoqlW9HYqd/lgg5dokqD1qm23Dc7/gAJsVRwUc99TrfK2/x9YmqZnateZOqmt7f2ktq6ilFRnd8qVb6CN7MR2F1EO4wuAM8mKydl4Tyjl0Ew+NWRzQDuUSy8sKn2Ya9NbsHYA2rbOGJUQgH7mvcgb0ZsPQ89uAf/7BH4trL94GAPCZ//Lz8eMvfFo6cw3OYgFg7QLABcx0EWrqPk04S08lhd2kbVozE7KBiIGZTWv2GkBHg0CrIcvOUQgzKEBlW0WyGUjNOc4hkBYI16rL6ZmmrOi1ZVMI4joboBXPZAJj1PMDVbCXOSJmqh5Yi695MXN211gQSpYwrMERuWnbIe2mbK+3kN0KFeu3QrP2BWiA/KQxIwMhzCozXeixrrj3e95dT60c+n+5vBao82Jr2q7rbJayX/nHf4yL11yDL3jEI3DP93zPWfCk2fdibs7ZHFg/oGzIHqWddbObtTprlqaivlrXmqWrBsJoePM//gPWC0tozj64UxTjcs2ZewYwqTl9TPxL1UHvR1lNhouZAe7YI8uCPAiKgZusdLOsf8wwP3vddGWQK7tsuPl8uaiYJB8DtGrnZOeWiBDNOLR1FyBWIL8tIFHTK1kOJXkUKGrss2gqTcbKQvoas2SOvq//WUtEqcNhbrPQNjP3P5f/xeblQlM+R/mazS0xbSb+eGT/J4q5r4CW2Px0rpLpKGY4dFUnwIxICRtEWJCjSUOXhuYdyODlWhXQLF03SwPvKsAQ01PE4CwNw332B+cz4Zw7RI95QmDTmCmOzUDdDNDZlnUDiqbzK6LpDc6Wih+mdSLX5BHnIoQoW/xu5PnN3/t1vPK1v4N/9h7vj2/70UfDjDwznA3Q7US1Z7qQcKaLgLjf2UsDUALY4exR3BHBPZAR3OeIoLKQlxzMWy3a/Ym+tBzKBuipHpEcjjiXVZbN5Tlp1/lSifWggWRU3iABTXBBUu2lZGsn9lIAJU4bjAWMVbXmyd/c0vxvc4qpms+tfja5Fp3mbD3LLpreCvOcT6E/YAKzjdWAtxqAvVrdBNiyb0n5e75Gpr/J5p86NLajL3paT05PJ+GggjnmOx2C27Xm0JBt9ouZsHXDU/sSmb+WTFNOs/ZiwTULRncoLxhLL2DWtJVDzZnB1n1KP88/f7PNq8pni4s3fgXSQh5R8koHeeTTpigIiUdgbv4WK9g13MRFNVdO4nd8yw2sHdLl6lGsWwWzbs0e3VPyy7qqFNwXkLgp1lwJ5LCKk6K9om3BVo1d7DVH/xOV5iet2eztYjAI6XGz2VyBv7kTxt/LTN5Km/Vt43uSywUp49RFUnfgKnYQ4EVUpnUphEWanWn16VN0B7JKcbKAZQm/34ACeBVodTBpBcwU04mLYONqLYV6a5D2NqSiKXUkUqBszgoh87jIAVwqUKZ6OpRA9GUbgEZ6V4AEcoWbNODT/+39FLymHW+nYXM4G5ibmbZRTNtyYqfRTdeScOauy5Ixg5lPCpgdzqUc6ARoX8eij6c9k+bzFAHrx+C8lakJs6lhMycjohux5ag1KSZ/BTTwEff7KDzxx56KV7/09/DtX/7YmK6+o3tylJgPeZgfeVhLDU0NpAJnlHxn154T0lo62Ne8+5v9R94KNeeLmDXnNCoUQY/MqFAu+B3udCe84DWvxsnJCR78cR+P173udQfpzryZIWUvjDc7BmYC8Gmf8An4iq/+ajz5277NBeRIJWhHHsd92kK6bISEDAqzxuDZhlE15upvlp5gPgR0U0gvZKB2OGs9bgnN2btHRfZuIYFo1xoRZGFoZPqJxkJNOzN5XeEoJl0HG+Ct05V0aIQN2QI2f6EtZi0oolE4JMPuM4oKD3+xWLWnuH4hngMy0qTtfmSytpWe9C3Qut/Uq+6n51tTNFoCzTYI7RZgXbLCj24bim0kQm7E9lYpnkdtkO4Uv1cawaNmaopuXA4XDI5JkgbYOncP57UFidW9kfKNavTxBOlYC/abYna4+CRxiYfoel0lNWftpetV4nQIm/YcvYcopsxgtpxmz2sGmAVsc0g8winy290uOwPaQv7UnC0GZgsg0nWpM76xC8vuo9ZzLKwphrIBs0daDySgc/3aY5cRkM/7iavyoxtvomGbwZkM4OTas0Vv48IMZyHTnFdEhPZAeW5VKLP7qguY/TMnQFsyxKQ1+/d1wfGYbLx9vLGkxWOU+c7AtsYDS7J7zoEur7IgsSf++FPxXu//vrj7+78Pfvjbn4Y3vfHN9hVydiZqLciLtEP0QAObu8T1DIdzrNeqQR+AurQUhuBWGa19Sg07skovSDivcB9HVhKum9MjvuZRuNNd7gIAuO5xj8NXfcEXRL7dJAliC2V/Rm/1ef83DcArX/EKvOoVrwjQ/uCzn41//flfgL/6i7/AAz7onppRhBLdCDWhzXCmAucUxyVeoBHZGhrZEsw9wSx9wei7hPPigC7a8+JBYYhgMG4MaQPecSh8sbHxS6yQ0ITNVkYrwqdAqioZpP05STivXOxrtrHysHraI3ezEJ29iYkH92RbNkLez3xnWyBWWlTYhIqJ0v6zHIxVTdhE41jQEpEBmrLAwQSraMjRgLaG4OIpPeJpVsjhv83bmGoetWieuU/Opho0yuWYron/pANAbyTP7QymzWtswdTgsAnO/s/s94TgAf9taVR2y5b2DfLgIAMhNzTLPafsKQkMFY7YaiJrvilpNafB4NEwRgMPUvmNocFybLs6s6XQsQl4iwlMw7R0BlkkPsF6A0Pye1kxjEwgkPCtxn5LMSWnkqueyk/l6NfLNWmPZXQeoWFSDtxvbYkBkA5N97dynbQzOFtqFZX0KlTNmRCR2JE+JRtTtoGZN2Cu/mbq82MHaMwaM+/H7/K/ST6ejGF+Hk2WFjJhx76vbi+UaV4oaXySsKwFTCbaE+P3X/py3P393geXL13C37zpb7AWCSH+i9zlbqU7m90vzVwAK1Prvdfz382AThVRomC6tyy9FZq1LxJhR9brFZ47LxoZ6IBDnUW6a/3Sj/8kvvi669CXBc9+xjMsRERCKqupDkf3OswAr6ZrX3vO0A7gkx/06SAivN8HfEBoydtjpiK4Sc0k9inSGapBmdZc/c6I4iIO5qI5LwvGYpBeukJ6cb8zpWm7OZhNa/bKTlVU8Q1QxFQEKcAlhbM1hInjXkB7qF1yz6C1gHllYB3AGJCxAqNBeNUa2mY+E1atWaawdVsMlqApspoG7dUUjgMa9vVpuqKqJ5HljAipH1TgSaamQdMOZI+F1Lztsywj0t180BE1v80WpznPiy3ebsKE1/q1zzZHpv9WEZsgYmD2DbBOzHrbTtJ3yGWJf+ICbAbHSTwHkEHXCpFYcNooPua6aHxbqp7eTKuxamqluhqxBuj5+YfoPBZW375W9TMtebACelUw8xCt7mYCHo1hFphhY7HHfQKzw7kJm9bctB2CadEdUHN3XYsi+Lyv/Qb85Wv/EK982W+kqZUTyg7gUTYEKffRUusDIQAV0PeX+r81o1gEeXnOs5ftdEDXNKvFPge2TC2EwsEs63FT9hbOFcpSj/59fc5cAcwuw09wtt/rlXeFDX7lPAqbNZR1v1OPWUnhE9dkrwRowmO//Gvw/d/2ZPzdm/4eY2VbZ2WJUDFtkxUXIUufKnDWz6EC5gLobHytM57KrCc3awO3ytraF0xzTq1ZLO0izVI6eyQ2HoHgb17/P/ERt3sXeDMxnVeE6B5F0CCneI/DfbDC+wDKSDA3AE954v+FRz/xW/EbL/iVSM7fas817Zc2IzZ++6M4lHtTzWoCc2rObNoyh/a8MzO3ac9TOpWbtS1dgLSzSzUtxQpjLhqzmMZMwEqgVSYwO5Rpb2DeN2DPOdaBT/6Qj8VXPOBf4zue8xz84Z+9HmL+auWsRNGQObpGzdpq3l5BsuYxNGiFNDkqOHdBXzgZ+d4gw7VgA/RQOESPQ6ujKBYcJtJN41YhSn2JrLZQT94TwPtPg21BU75vANo15iis7YIY0qQtOjldA58mZ70FlGWetAckz6cEqfn7/cyzF2SwF6wqnUJ6uB/dvpOQlu1U2WITN23TpVtVNWKgDc3PD0HU4cwW3BjCi5uwG2QMS/0p828soOEwduvLYoKb+7QVzs3mTTNAd/M7d6jm3F1rBsV6JhE88dk/g0/8Vw+FiOCLPuZD8fq/+DPdtK8A5e2Qlpct4Fs9MOWaeO6zp/GTg9m0aHJjjqdYlVrb0nPqTaZgB7OX+XRzuZvON9qyHDmiFwCX719hHCZnm/Y+XcPSW47i5VbtHDJXPy+pzNXsCP+bKmQiM6DzHOpu/cY3/jVyR87JLuYwd0uPAlrBLNZdLUp3+veyfxf58wXQAeXsAVpmvv/gm3+7uuHcOnbAZNLewyoUlWhiGJRDkkxlBh0SZosmFK/W/YdyJsYt1ZEtmAPQlFOiA/jJp/8AnvP0H8iqORXQlCbtwt+DyjzwwKyiNXsJTjYw+302SPPSE9DLDrzswrStr/HAMFiOppQobW9pnqdRCpxzU2zA2gzKYoCGPt7rEXsC7RPQOGfQnoH9APYNz/3678LSF3z0Pe6J9/7sh6rCOYCn/rsvw8d95AfjK7/lWXjF7/93FZiY8nuI+qfdvB2ALrmGGTVtC2WqBWhR2+VqCjVgWAcbUjOrtrDMI9jKi6quZeZtv/gC8prfduLEz5k1eBdKMU6iPZBrzWbGtt3KAQ3GRgszWB7VnqVO0/qHnMLTlKb5+TjaaghhIF/H9nu9bzgcyA4dH7B1Jup7bqxR15YCrp2qhmqrgKW9TFJqlkoVUWGtdlfSebcEoDEGmh2FR5jKtTWpVoxroTX7EHSxRoIOaTisASLdU25z29vGKbv25CKW4nlxE/YcLJeQDTN4y9dVX3O9VCEcUYGzjx7TaNPiFRllXWVY//wK4wLlOqaI7A7vGTGbtZfyfQkTmCcoYwazw9m1ZphlTBzMTFoshSqEZ0BzALpq0ZkFAaKyXfvCKCKilX3z7+5wFtOWxbI12GN7Cpz1WMFc4WxANjinWdtOAN/KNWc3aWcJRQDi6Rzaq9dj6LotPDdCeA4eG9Q9t5EAu+AlpxZww98E5bhPCeUK4ul4AGcU8xlUgygqdC1EX83aElqvFrjgxYC8tBnMkxbtZm4HtL+HpFmbvEiH/l6d8OoXVTB30GBgNNDaFMh7Aq029mJas9jzYjAmPZ4zaD+0q8G+4fL5GW5zccHbrr8efd1DhuA973hHfPFnPxBEhB/5ri/Hh3/i1xet0ncC99U6oA3ME6Dd41mCNCJyG3CLSgTWDdOc3cxqhUci16zmmcDsh6F9A2ha2Stz4sR2IJOAPMjOZo5rzLpZlZ3empSYHdn8elRUrzLKzv4BH/AB+O3/+ls4Oz/DR/7zj8Rb3vKW44tnArHEhv7AT3wgnvezz8PfvOlv8GEfdS+s66pWAZpfCzNkpFXHF5KDOn173pxGXyJTL+A2MsGs2TSjXnL5fSWK9t/1vKmMbehoK0PWDlo7ZCyqWUdRajVvk5u1ObXnBg7NuQsblJu5xjIwrEGLk3zHwz4HX/2Up+G/vfpV+B+vehV2lCZPl5cmTdnWtHuAwthRNwybjnG0mwOkGHaAAmiPoD7wB1NOh6q7RWZgOxwoR/8M93UfFOBzzZli+U3m63AmidmOypdwMHsGR1TWHao9e5Ga6WggHkxWyMbiD6BwFtdwq8CwEXZ0zrp6lufoELQt9j4Hc4WzCjr19TKDuTxOQdgE81twu6rhfNIWnJCGAulcFQvfNyiLhduIVSgSbWjvUvKAhwFJ7C1ZeD3lLrKLX/TICeCx1ujQtO1+ZQfzQgnoK8HZ9/tUqig3/FhktZEFWUER05wN0iNgbUDupkGbadtrbHsHR514Hgzma8ohaEE1YyCaVqzNYNxAe7b7mIdr0Hvoa/YA9gO0J9Wczwn3+YrPwmfe91Px0y/4L+jrClkFb3nLW3D57BwXL5zid//gz9D4XLXmsE7bpDfxOwDtBYKxIoPEiu3QtefYNQ0AtguSh9haHW6IBStJt8eW5xz2v5YXz0sg+WQKCHdoVI6eN+9spRezaspQa7xDmX1SwKwmEhr0pP2W+4//lsfjjnfUtoNf+zVfi8c/4fEHr5ke1yMB3/bEb8Ptbnc73O52t8NnfMaD8fxf/sVcAyX4ywe79kwSm7xqipJHh7SUwTZGng0Ryepc5Td6nmrEIYxmO7nOQVkbZLXuZcOPCmnVlhXSnrLVHM42dD8wDRp6v/uegIQ033gZz/iqR0JIVIF0WaqcP3GBdtrQ9dI99tu/F1/2lY/Gm9701/jIj3kv9bsWefHA0GEz1s9F3RtCICrgRpvB7Mfwydr3uUu/G645uRb/nf5y9ofX31A/o2obDlqHs+SoUR4M3UMH8t8wA63O8wbI8LKrVvBjJJQ1ucOORJna5GZnFO1Z/TAq5k3mCz8XdgIc0ram3P0Cm99Mma4qphh5WmDOa4NwczAb/Jubtd1UoNakW6o5t3f+kivfnvSkJ4GIcN111+WJEMETn/hE3O1ud8PFixfxCZ/wCfjTP/3T6d+dnZ3ha77ma3DHO94R1157LR784Afjr//6r2/255/2jpO+6Gg6dn3Bri3YtY6lDmrorZYNbGZOJjQvJhF+ryz5FgUmCOU5TH9zENe57D7lK4HZHy+kjQB0kDbn6UD0AvDmTGHGomnwQuBFW+3xQuBds1QphfUwSEcgWLf7Jc2K+w7cFqtr7FWadEwd3Es0bYK5jHOgneno5zbOBEsMRj9jLOeMfj6wnA8s+4G3/t1b8BO/8NM4e/vb0de9as+Xb8T7/4vPxEc+4BH42m/8D2jjDI3PQHyOxmdocgaScx3Yg0TDT0n2IHgtQkuss8hdqrsJy8xsNyN7LozvqqyQdjC7+dmbtgPeEKNFEN2xzl+yNG3PaddNohMYxSTxRiTp6Jy1lmny4chjAD/4w8/A+fk5brx0I378J3/8+OsnH8w8fvBZP4gxBv7xrf+IF/7GC/WzNwFBMRZodL8HK4X1xZtcZD1tL9ngwjKLpj/xsAjsVXLsBbIXL6htbalUwGt7itH3DX1t6GtHXzsWP44FC3cbdl/86KPpQMcCTetaYM9ZLrYeCQtrINsipN2WGPn85n6vVgEbXpzjMz7zYSAi3O1ud8e73v7dAlp1HIPcdkShpXrcDC7HOj6s/XP8+d3+Gq9+v7/Al777Vx1+hTqnNnMjTN9LHj3Fi616GdsYZawnwLoDxgnF/fWEsO4I6wKMRY+r9fheuzYxWZs3NGnRxIetapyW1myR9qQlZe0xPEi4DKKciwQMUkVN27gKRhOMxuA+tGNct/t9gJcBWRiyDMhOB+woJwycDOB0ACcMnOqQU4ZcsMcnx8Sud367xXB+5StfiWc+85m4173uNT3/5Cc/GU95ylPw9Kc/Ha985Stxl7vcBZ/0SZ+Et7/97fGa6667Ds9//vPx3Oc+F7/927+N66+/Hp/+6Z+OMW6ehLHrO5z0HXZ9p1DuO+zagqUvWMqxx+joraO1jkY6vPRlDUihIqr6ffdMuhkv5nB5vNWYJ0BvgTxBWccWzDpIA0AWgBYC7Qi0UFQCkoUgOwLvyMzZDuWGset5f2PuDr+0VxPzYb5Wt0WEPYy7aczqI0yNWcHczoF2rsd+DrQzQZ8Go58rmJezgeVsoJ8N9PMVy37Fst/ncT1HX/cYl27EX//PN6DxOTqfo/E5mpyhyblC2uEs5wplsV6qskfI35lrg5JAOe9GEWimaoNYc4xIWjVCZsWuYpY2P5WnnB3tnx2nMR+7SSX+Xv19BcwHJuxjw03NBLzi916B09uc4trbX4u/+h9/dRzI2423fPZzfu45WO6w4I7vewfceH5j9vaeonkFssgE6agyt7gMV0BNmYYyHM7MMdSPzJCVIXs2KOuRzjVWoe1hcwwGZoPzvmHZN+zWhmXt2I2OxcaOF+y2gJYFi3R0G4vlWweM4RCmhDPKffvb1NSBVYkKOEsBc7n/vd/5OLztn/43XvLiF+B//+M/HkA5Uo3qY6QXx83FXJ+TzEz0SmkVzKO+loGP6v8i9rr73e7+8+fWWxXoNnOl1IvJ4elYuwT0DOktmKFA3hH2DuaFsHbrRmY9vUfLxiYOZXYw1/sF1AroUtbVNG0XZGpk/SAUgVJBrSmlbEDWwTuG1HHCBmYGTgVyKgriCwblC2LD7t+C2y0ya19//fX4/M//fDzrWc/Cd3zHd8TzIoKnPvWpeNzjHoeHPOQhAICf/MmfxJ3vfGf89E//NB75yEfin/7pn/Af/+N/xE/91E/hgQ98IADgOc95Du5+97vjJS95CT7lUz7lJn+P3ndYWouZ5WbsITpWYfMfiZmwLHXCTGuaVuHmafdgSKZuSpqVRCLJxDTratIuJm5KU3aA+ojGbIHWtRz2ZJ5yLnJQntI3VB3WnUIjU83Zh2rSowA7zN4liIy7g8RMNmbCcVFZMMxHpINGS9/yqhslOZj3sPvQzdQ2Vdqzvm4tpu2I5IZ2wllVW5KVwSujrQxeG2h00CDtDBWBJHph2K4r17xma6wr9TnKXU+voE9YhzIS0m6itlxjiAUpbaKdJocGuenRJs0WiEDssiJI86A2FT/UUI5pykehbLf6o+rz2Dx3TOPeakr5E7UMqUmeQmbatufI50n8ZjPt2dGDxJqZ+8JPZ+krEC06I9CYAZEBMIPIBvTYIifZioCYJupCortY1JQ9gDXN2uqCMb+zWBS3dGzN2120x1i3dCqPEVcftDU2sRPsp1o9IgQPvuuiZtHwbLjAzoha1P/5Z56NX/jZZ2MtgVVX0p7l2PNh5UE5D5vh07TcBAgf7w/d+HT8y/ZA3AF3xHV/9dWzeu2fVeeNz23fn/zv5X7ItShuwfLZHmnfGLpnaYJCCLRhnoZXfKOo/qa+ZtOghUr3sdyx9au74Aw1UZcJH1kHFtCYTW8QgZxqrvY9VmYfuwslTaxjnxU2apv71rM89wA7rv8vwvlRj3oUHvSgB+GBD3zgBOfXv/71ePOb34xP/uRPjudOT09x//vfHy9/+cvxyEc+Eq961auw3++n19ztbnfDh3zIh+DlL3/5UTifnZ3h7OwsHr/tbW/TL7+coLdmEqYCWQsKcERghm+JJVIodOhipwppiU66eZSSWlIADbiJ2wPDrHgBipBJVxgt4eytjMndlwXAvNFsPEAjcg8bsrm6p0fs6PhYrEVkNLvI1pJ69PQXXXXiMzfMu6Yxu9YcJm1stBqgnYsO13j2ej/+TQGz1mQUSIXzYPAYBuaRnzsIFD5nAKJt3Cg0Yg4o+5IVcFzD+XYMzMjfXKJAMr/aQA1g+4a6KSSksrhw2V0bcuc1H62/Vuq/naAphyCu93M6Hr9dCcxb+B/RrD1aePua6pPc+qHr78h0kyNpJ7BrxUoZEjuS6ztd64NF2pOuVc2LBqwQk9kom40OGazHKSDsCKCxwJsCNlRA6/7R0eDBYNHhiPT6bcU85+WVTq03ifAX0ZGpcSXteZI5GVPVPalQjupLee3iyw0TgG3Nfc7/+izgBgBndh6PlAWYpl0BtLln83vn0piWDuLjs14Bu4PeFA73+U49wic4t4AyB5jLkKpSGex1IebydFCT/xBY/I79zb9LPVZrVrh0ZPPYzvPUcivPf6xviDneb/7tZsP5uc99Ll796lfjla985cHf3vxmLZF25zvfeXr+zne+M97whjfEa05OTvCu7/quB6/xf7+9PelJT8K3fuu3HjxPu1P1HQO6cJFacTPJPEDc2BZmfb5pgQIQcnkZoIUt19P2vzIpK5RDaya93/w+baxBx8Dcj8C5TAwqMPZcR2wBHb4/M28vxby0s30pfNNufkx/p1ttUaIT4xbgQjq3PH95de3YoaxA7uf5uJ8Dbc/xOloFzaK5EalXBubVTZtd4bw28BhaDcoKVWQOHGzBZ21kFjbhySBdhCy1BPhvsitWN5gKad9dGs3ahAE6NBrfEiZ7YH0zPtyBpTggDVjvEMh1h4z32r4GNw3M23ElM/fmvqfxxP3yHtJyz0sgw/fAORoWHMekgRKGzP1QDZQdwxpjmLWLvXhJ06IlDNWc3TY5GsAGZ9aobfDQXOdov6TqYwroJTgMbGCWAzBHaxNJoZzJLGy+/q9wmuMyXAHIR4d7YapBqAI52nQhffKWOADYff9whoZenJdh/yYFZETd46ihs52WJqj596/gTsEMU7lSQJmVUdqYwWwQdciyNE2pMo2Zm8KZxUq1mmnb4SyhPdtqNC3KV2RUqaj7WgRY2v1QhgqYtxCOXHCJnHCvd55BRaltT2uJcEtLa988OL/xjW/E133d1+FFL3oRLly4cMXXEc27hYgcPLe9vaPXPPaxj8WjH/3oePy2t70Nd7/73UG7C0BrNoncpyjIKF7O+zyMfLY5hNSuZls1mVVQIzUcB3VVEmKfFETtXfvtEY9LaeI6MG/3BHVzEFeNuATeUB0FzAFoC8yRRaLiD1cf0CI2/D3Fer5KmLTDJKk/HJPDy6qA0YAeTfP14YBWMAu6Q3qv99seaKuZuFdCWynhPBzMAlmbac0txqgNNIoZWiGp35El3RJbe6Bx1PQcyp3SKSJXGtjc95HqzdSow+dLiSN1tSbaP1DZbesOeLA7oxzLZMvVMj/cLhva3L8SlG/iCCgXbVooQe3Rrv5dSZEc22ZIOTKfG/LQHXYor2jS0TGwiMFZWpTV1OIlEhs9udA2mroM2LRnA7LwAq+5HpXjZEGW8bS0Kljus/1H0kyjpum/MIsiwey+Lz0Vaf4+uBRXgPB0f6Mlb7Vj2QLZhwdowf6dg9pBb3CmM6i2fIZDWFdAF0hfEdA4FNQyshmhEfvvIyHTmsng7EvLoCwEZnVfMXsQmB05Ia0g16Av1ZSjJ1rRnK8E5vyusQaOQDnBa8dFNIhzJxFvoVGBKPCm3JOr9kx0S9s53zw4v+pVr8Jb3vIW3Pve947nxhh42ctehqc//en4i7/4CwCqHd/1rneN17zlLW8Jbfoud7kLzs/P8da3vnXSnt/ylrfgvve979HPPT09xenp6cHzsrugxTd8oyxBP8IFwDzKcegMMzCDSaX6Wg6SAYc0iea/QQQUvkuYduCS9MYPTRSFC6bRjgyPxHY4l+IAbH/zIJup7POB5mzHnUNaB9tRFtHAhs4WYauNFUQr+9sE9jrPrhWaDblEnnixEdWCJUzWbsbu55vhf3dNezXz9lBAe41tMRhLgfLgZqZslaQnzdlAqVdAQosGDBZFoyUqi1WAUDFUvUP1JR/cD0jjCKB58/wWBJv4WS8rKpuxtSmW8Skf+4n4yod+Cf6v//Ad+OPX/tFmt6wqTPy4/G1+fEdQ7jfh/pU0AjtFVD8PDq8iuLh91n5vaq5FW5bVgrRWi6ZWOHdp6Nw0DzlKfiK159ptgnX+CFvpT1kgrHuBWDpVNktxAWGgiVY98Lxn75mFEDB87pCd4yNCnkE6XlJvNMtgkzxWL/sRTdkTDxzKsoXzWbkmYv/Gr52/p8FZzgBcBugyZkhPqY8G54H0ztRLTkVBcVi7daW4PcQEGbbzplozhUnZfcTMTauEGZjHsKhsi9D2oC8OjTkLhngKlZSjywMxFzdgTq05z9OhhowMgNxJHGF7KRaxcvsOa7aIXj4CaDvHt+B2s+D8gAc8AH/yJ38yPffFX/zF+MAP/EB88zd/M973fd8Xd7nLXfDiF78YH/ERHwEAOD8/x0tf+lJ893d/NwDg3ve+N3a7HV784hfjoQ99KADgTW96E1772tfiyU9+8s368nx6USOPzazJbEcZEGYwj2mIVQ2KETmnBnJYuZpmMAcAkAFaN+JtzE+AeQNob7jhkHYt2idygpkiTYoMsLVUn0pnAlpk0q7RMzhB8zukaM9i0YUyRRxGBGIfqTE3jzQuu4UopMk7RQ0GDQatbGBmtD1bFK1G1PZjYPbn94K+GqBXhM86Gm8PggxJrdkDzyYoWxR12e9FgCZiBg7zAkqWXPWbL1oSysUaZNnC+MgIZpYPriGwAkRRFGadP1s4e9Q4l/tTFPmRAcELfujnsSwL7nfv++Ld7/Ueh4ug8GJ6brspXQnK1QpzpcdbTZqK9ozyWdXignKe7DeGO4kHGg800WNHATN3LLJq9DTr6Ha/sZXWNNN2YwCmPWsKXI8GGK41s0NaMvBMZLFrsoCkaPDiUKbNgK1utwdI/MyQ2wqYK6DjVFCeoitq0WlsSU15C2YHsjeq8K8L+3c7u2b+XIEznQO4DOCSjcuqTdOZ/q0CuhUNunG5/JTHgLPNkS2g/bzp76PwHAaYxcuymsY8LFh1WOoUeQpV17/Da1+XDAnxI0IAr1ozAIuDmNeBuI+4asoTlGEw1iNOpBwZ2BFgeyx2MO3ajuGDNknsfCut3bTbzYLzbW97W3zIh3zI9Ny1116LO9zhDvH8ddddh+/6ru/CPe5xD9zjHvfAd33Xd+Gaa67Bwx/+cADA7W9/e3zpl34pHvOYx+AOd7gD3u3d3g3f8A3fgA/90A+N6O2beltPr0HvC1YRDGFtJ+dHh/IYYF4hQ/PXZKwGahMRx6qaMQ+7qBXQhDRxA27iRll8MR1oA2ifvEWLjs6BRdqcTNZlcni/BeqiqVMG6YgWDM3Z01oy/J8XDffn3dDjwparl/m3VuMUHqEdP1JsNcsIS0MFNALQgrYmoH04jJe9oO854bxPOLchpjlDwczN4EyWXtNMMEgww8F8BNAO5qpIFr3ZnphJEo6IGvRW6bPVlkO7qcApf3NQh3Wm2Ahr3jXneU1gb7Xp/HHn+3Msy4Lrb3z79Ktis7Fo4Wd9/zPxsH/1MDzth56GJ3znEw42o3cI5WXzOAaV4EOyzZdm7Rnle4QZU6ZzRSwh6BEzGjPaGOhsvmU7LjKwc0DzwE6G3Wd9DRM6NwvulNCeEZH8gEgzIDOYFxPWVXtmWeBt/WSqWelBYsNmhjsiGdWbLKYCp+EeFiFswZQCA4XE9IGfmiuM6ukIj0eV6wzOFcyyK9esgFnW+XkCEs57/be4rIMulfsFzmrd0u/QhoHZWYMCaEJkmITm7HMrIvztu5mvWQYFmMUEKrZiSgFkh7EfQ1Mu92F1BcRLDPu1yShtPc5qv9Qf0eU4mB3GOyiIT/wokBPR1KmTNh8N1Jofy6kw+Ym7jFt0+3+8Qtg3fdM34dKlS/jqr/5qvPWtb8V97nMfvOhFL8JtS13a7/u+78OyLHjoQx+KS5cu4QEPeAB+4id+Ar33d/DOh7dxeg32y07TppixCmPloQ3Zx8DKK8YY4LFi9BU8Vs3pHQNMXR+jQbAiCkqAIA5ostwE04J9I1QTN0970xbQKID26lHHwBybY6mRG1LxJr80gxIkQB1Q7myQLpryjiNpvoI5S/c11Go6ao50Z5eBZKgAQ+sA1qHR0+tQLXqvGnQzTToAfS7o5wrm5VzQV0Y3k3Y3bmn0NQzOopWCTFPmCmZxMKum1CXh7LV7W7k0KjeRWRkTyCFPiV8x+5dTeaVjo4Caq9bsJn+atWjW8xVA9i4gGDOYecA7KeWYNU2I4AM+9SPw8Ad9Dn74p55ZZv4hpL/kC78ErTU85msegyc86QmHYD4GX59jx+53mqE9bb6bAUzCDNm50qAtUXcIa9xCG6yDFNANA10GFlqtIIgCeicdOx5YeGAZrkUzOrO1m8RUChLS7LR1s6B1s6Z1u7+AMey+J0zVyJ+BqAU2OSW52Mb0dwqskhTCETRNhQB1nW5HNOXSJ8HOVUKZKpQtRVHONtfJBQBBgrxo0wL7HIeza92mPdMlgIr23Ir23Ex7DkDzzN5IF2uzRTCWVBGEhWwNu8bspYeZ1I3VyggI9xyW3MZWf0Ec0K49277tJztWR5HYpUrvRWv2PbV2hnUoy4kAp/bY85jjyAZoyrGTGdD+ObcQziQyhZteFbe3ve1tuP3tb49ve8CX4aTvsIrmNO95YM+M8zFwxivOxoqzMXC2rjgbe31s98/HivOxYr/usR8rVl6xjoHhQOdh5nEvCTn7y3Rq6LFDO/F0iBUYEewIWJoedx3YNWDpgqVroZFlAfoCtCWLjOiLoTnLlv40dmQVdBr2S8PaO/a9Y130uO8L1rbD2hesywnWvsO67DD6CcbuRMt17k7Au52NBbIskF2HWPWTKIChuyrISmDSWEHrCtrv0c7P0c73aGfn6JfP0c726Jd1LJf3WC6vWM5WLTByrkVGlj2j71m1aDNr91UCzBq0SypRs+ZCDlZf0mqgXoW0q6TYffHsKyszIogyf7FJoqZYtLKYremE+RCEFmiDXDu2HdBtLEsedz66jpOm18q6AKmkzSY9D6CvOprnjJ3rLivnAJ8DYw+s58C6B/Z7fMH9Ph1/+/dvxot/9/8LnK/WEGRYIY5hbTVFYR7VJnz31+X72//lt3Df+9wXz3vB8/A5X/I5ugldSUt+R2MH22Awg7pD672b6kSmHUW4lDRNR7QezY0b2mjoo6ONjr4uWNaOZd1pBa91h52PcYLdeoLdOMHJOLXjCXbjFDs+wTJ2WPgECy/ovEPnjsbdsi0czlBXlrm1mFew7DHkHEPOwTjHkDOwnIHhx3OIbCKkjIYELwFrgpXFDWQPbqupYMVV9FWClaw7HuFwNGD0yPrSVGzLrvCiHXIK8AVALgByUQeuAeQaQK7N+7gGgP/d+jhjq1G7EDAQgA8z9uWEc7ucx2aQbnubwg5nlFHccrQZUw1jX4Nu8RqkPbjXBt4TeN90nHfIuR5j7PMoawevPUq0yuhRtU+smp9YrIiEhQwJ5wY1bXcoMAuQqwkbO0BOoAA+gRUWES0icipZXMSKjWglsJGgjj1AFNCuOV9i4OFvxj/90z/hdre73U3m3P/jmvP/m7ezC9dClhPTnFVjPueB8zEUuGPFuq5Y+x7rusNY9xi0N3PJCsG+4LVBZE1TJyh8JACgKThIcxEYkGZI0Fsav0xztmO+JeVkqSM2TbGoQJi/GFb9C6W9m5qxeaM5s5WeSw15QJbVCpR4KUkUGxUD5I01qdjezLQ6VtOa96Cx18dr0aD3OkJzrmPPESzm/mYdqj234VqVqhqqNcM2d4Wyfh2DtkC1JaFiYqPsehOWjarK4cj9SHZDis7FafaOtOfaymwq2YTUfIerKabGcMk7E3sc1ggd3/65X4vHP+xREBF8yjd8Ll788t+cPyO0LZkU5umnAbjfp98vNdltYNdWO96V4/b+jubXhQZNiOI3oTVXmyHM/4sMKBr585u1DaWmc0P1Ic0v7sJYGmPHjB2GDhk4ET3uRM3crj03buhsEdPmd1ZDQzMDhGBIA0vDKlope1h09phyZVLETo25xSqus8sfpxnVYvClTI0y6iUTn5pAeQJhZajnLLRm13YXlengMSnmGnO/NrFOrQnOrrnaco73rEFkrjE7mM+OgHlFVjwTRB8ADxI75t3I6bCJ77DUJz9GyVvTfjPjvIW2zLSoORuL7dF+zDIxQJuuVWYN+NAvS/GlJffBDlCfIU0nEoCmCwKJSl8CumjVvy4anC8M0IV2HNCdUnu+cbNYb+Ltqobz+cXbQJZTDGE1a/PA3sC8HyvO1xX7vldAtz3Wdo7RFoz9AsYew80lMrW/gJdpdLu0QnYAwJxqaol7EcxfJ0SAeQZ0VOMqYN6G8MsiVu0LFm1N9pwO9zF7mTnu1uaxW7BXb5C+Kug7TWCOtpCRWO1fWsKUmv5m1Z7hGnQBdJi212FNL8z/bFHcfRX0YWMtwzahNhCAEwvu8RxHuKRtMO6SgI7c0u0RVJdomiEBTIFfxZ5FZAv8oG+e37eLxC13WMnvrakhJui0QiQ3abdi1hbz4w+DtAk5d3vXO+l8IsKdb3/H2cQ9BYcBuaPb3SkPuvy8K2nLuysM39hPaANsBzWlD7pGA8VOrCOLgpDlw+tRq8SJBkA2QWtpeerCWMTM1zSwo4ETDJyAcQKHswFa2Ezb7nMWS7Ezw5ZsCliIp0Wplo0jYJYC5jCPbmz3ufknV0uXcE1kIGSpTMqjv/7ArO1QrmNj0j5wQ7j86CvW5+DerqFf54a4RRUxT3+0wLAwZdfhYN7rdO4j4RxKsZmxo/LZNAVrjnE9Vy5XVuEmLVuWZb4xYy9HRgI6Tgh11AjF2IfjBJjW7EVBmph/XGy/VTjTDuZTBsi15gsCumga8zUCXGQF9MWhgL7Y9LnTBrkwzMw9bN20jN6+MHBLblc1nC9fvC3G7jQCwNYx1LS9rjqWPfb7vQK67bG2BSvtMXCO4dKZSWCM8zSPTCk19mFVYQgowMDcwgedSkWCWaVImV2YDZoeVTZSKilRnqfMO2DsxMzcBuguGvTV3X9jYG7DCozUxgtUerc6SNQGFf2AxBe87XLhOx2hMafmvFrVrgJoi+RuflzNt+jpViNBXf1YkWEkYu0gJbSgCmTXmEnMK2iLUEuvumBhgTx+seAMq1elaMdHm9U6pFs5tnLBUEbRboc55Xx3FbcHOpztOTFrBCuYMRiPfNpjIeuKN/39m/GcX/u5jWYuG0gjd/pDo8AhmLfm6grjg0F53zXoqklXzbkVoRWkGrMolLWCnIHZo3/PkWAmoJG1aBQ7smAZqj0vxNgRY0eqQZ8I40QYO2GFs/0bjdgW98QYmMXg3FRgt+hrB3MAWDyLOefDITQqmCtcKnAU0COODmhtI+lyXMh1W43Z3qgCGqsCkDtmQIcfFyFHk02r8JxUk7bpBJCUF1H81xOk7f4BmIcpf/41Wk4xKoCGH11ICqFEd0etvkj2fXJ/jYCucl1Eug4sGmWPBYIdpkY8NV4A3n27Cox1IxZ7egZ0DQibfc4COQXItGW5IKBrGLiGIXaka4bevzhstNSgT5oCemE9YV2Bf0tuVzWczy5ei7G7MMF5HQ7nvR7bucH5HCstCmaNEbXgkBYh/d5tqOa3Ztm9CmSF7wxompQJvVXNOQHNVWGtltXQnHVx8gKMRcHsR14EoxdId0mTdjRbKIFf9v76OTw1t4DnBvoX9tzdwZPplQqYA9YeHDZcg04wK6w9+Edy8NzLN32F0KAw28GabbQKZTEIq41CLRepMcMXv5/vo9Sq5NoQLAB9EBE1a8/b1KoAtJu0R1FTPKBO4bw04H/9yC/jjrd9F3zdj303nv4rP6XneB1Y1xVf9uTHAPs1TeNbrTmgDJc4MBUmcZOdb+L+M1wDDs24jNNyPKX5OQe1A9o7tYRZOzdC33jBZE5Vsj7dZJ3KyPyRBGo0ddTsIgrmzjoGY2mmQYOxc+0Zs/asZXlLbrsJciJkJXxVcFPBUzduFkJHlnysKVMOY94cfUYlqFFeK5MG7ebtgXl6TOZsu3ZRFI4NxCbXNdsbYHLdsZjEeK+iEYfZewPnmDdu1PE8Zg/8KlCOsc5gDoZRMq3Bvi8hY2bNBSgEtXrZlPBtRYPfstKfK0HelnUCsywF0NXvoqCefTW6ecb1Lus/92NxX1ipgw39MbFWpKwR0ehsN21fdCgz5NoBXDsM0A24ppkGTaBTUj/0CZlpW/IzbsHtqobzpYu3wXJyEezR2WNgDNWa1/1eAd1PsD8/x552WLHDSjsMLBhYMnJTLLjAbDZiDRCyyTxN3adCEJu0aYe03ULxlsgj1ibeGbVdlbja4NxrZfMiGIuCeewU1GOBpkZ1wuh69OYV3OYc5gj0MjDP1U7SvwYgNFjyCmtjaOqU+Z4n83bxPSekuYyMziUuwzVn1xRc6zEeac4yWflVss0XxVLh/3n87LQUy/9zb6pXJ2u3XSlCyh5XE7edxPd5zzviwZ/0YfihX/gtnMs+d+BR7ZMO5jGZue/zgR+IO93+3QAAj/ykf42nP/8nFOYr27DIbQezB3xVSE/20LIIrqQxVzAfA/IFP5IBGjOoK6A3cKZWZr2QEsVqrmO1TmXnTcG8kIK5z2D2fs6dzarSJTRnHQroBao1n8A1Z6uDLVowxM+Pn64ZzBZRLZHJHP8FmCWBnAMTiDdn/8Bkux0O6Po6oNzxKUMGaIObDNsD1iIH1g2mfqhrw+d5rcMrU+ZHaOTF/z9V9qvR2cXP3CtbCNGkp/dZe6ZYYuU8SfneQLgJmwV+RmW3UjxGR7qXpLS8Ei97KJ7GsgPFRPeJn8LWpCTVUrhN1PdsYA6laJFIXxXPZT5FdpW6qEOuZZDBWW6zgq4ZwLUr5GIDriHgQgNOB2hHegJtFki2hbhZt6sazpcNzoMHeDDGWLGuA+u61yCw/R572mOlncF5wYqO1aA8uEW5OGHVnr2ushcDm33MCq+2vR+wKP5nvxECzN7Mm9wHbf6bSD8wLVdbBwtGJ1j/eIvuLLAOMNuxkfYhbZjgLJOf2RsP6C6QwW8oC58hLCBP9RlugvUAsTxSANxyoIeCnVgBDd7AWaDArWa8jZmPygp3fTj8WqL/o/kMY965/JEDmbBpR4KZYhuHfwV1AJrw5y/+VpzsOr7oIf8CH/m5T0IW2CggHVVzTjj/zp++Bq/+qz/H+9/1PfH4Zz9tY5ngEnIucQ4TzNNPy58bk1KOg9nHpCFDoRyDDh8HoKv2bLtzRAQVMAvBW4nC2oji3OB8RqDeQM3aspqm3UqlrzaAtlg8Qhf0JlhIEtLIsTNH1AJriAGzoWIumKpFQtQfPFW4kq1IN5uxE6z5+B2B2TkZkBbMcYOUlzAuF+UcJ1FBVQqcqaH2XIFlIQX0ojCdGWdCCHNO+cD8Jas/2+viO6iz/oBqzG2j9E19AYriGWeyaMgiun993qc+Gu911w/A9/z0dbi07iOF39Mno1lJtGfVIdkc3MC8JJixA2WvXKREoj+airKRO0SB85RKVWpFLGJgBrCT4n+WiMpWSA/gmgG5doCubaZFN9A1K3ANQU7tRBH5jMjPvwW3qxvOF65BP7nGio0onMc6sO7VxzzaHiupOXvFglU0anNwBXMJyXcwN5tINvuioIhINLRIMANPfMqT8NH3+xh885d+Of7qT19rEmW9KB7dqajgSNKXDDB2929LQFstf4wuWAPSEkde2ATObGARcLe2Zw7nDAntgEVJ5uq3rzk1h2VIwHccgfRI/+mUr3sEWhNoCnCwOVYA4cjjozfb7UzI+LhP+Fh891O/C7/4Cy/Ad33H08vJPaZebjRn2sDZpKXWOpZFd7x3u/21mAqUOAG4ShwbHzQG7v21nwvwXkdAmY+cO57P3UEFCzsxdd4cA3PVlrdQvmhjuk8F0AbpE0o4h/pEyE4YG63ZwIzzBpzpbk6NQJS+39phrK0U5WtbF7SmcO6NLTUxNWmP7F7gHaSskxV0sWoql56uCPOSEt4ltibL1DJLq057ANH/F5ige9MBnVHcx6YzkLJUVDSlhBaTAtejsR3SQAFfkf88mtsZ5QYx/zchBBTDTtTGiSh6HOQ0h9bs08rBvIVz3eJiyRM+6l6fhH/70CeDiHDbC++Kb37Gw6NE59TVbpBWAgxQbzRo7qDQnheQ7MzMrRIJSQrRDmZyd0vRmqloz1mIREpNbUmXolUFo50WHZGTAucLA7i4hp8Z16zAtQS5hoALnl6ony8xi3xzvfm3qxrOly5cxHJyjVaVGgNjHeC+BpgH7bFiwZAFqywY3LFyxxg9ysV50BQGTZbeCHQIQGtvWorFr4/f7/3fF4941CNBRHjKs38Cn3Xvj1btuTTxqKZtLtHbBIoWwlURkZYWn9HE+pmaS6+JQVswWvE5O6QL4D/vAx+CJ3/s/4mXv/lV+OzfeJSlL5jtrASDzVHIRQt0X+rIoxQwawlUNm07AeMlFCFe89zKHfrRzorvXl56T9l9uKXFRkf6XaPRgvhfKXaJ//iffhh3uetd8MEfek88+d8/E+crEF0baoSn04w2gJ5Ip+eJmfB5X/tsfP5n3xvf8OTnl4vlX74MtgUp7oO23dT6FU9jlGPVmI8JM37zaeW745WCv7ZgvrgZ11B5THl0SIf2rGCmpaVW4HB2gXZtmsh7blrzmb6WWrPr5J2kmm3GZN3J1OwdgG5iQWM+pgQbHTIQDSrcJ1LmSUJZEVmN0v7/qO5lV8ejq4fZlLZm6ncG52nIZmoQ4vq5POXBYV5w0JcgDfvbCnfh6uwuU4IYUVyOF+CbHv4tuO4h34Sf/53n4mue9ZVzpzD7jAg6c+3ZR6mjXYuNROoUZq15aRu/s8O5TP/GwNnb3xbX5O1vfyvaniD23uw1DrZJ4AZoGh3iWkkZVAAN2RmYFzNvO5ytVQkV7TlMn5JfOCyXMvdttsqLXgIZO9HUqtMBOWXgdACnDbgwIBcJdJH0eMHeoyxSrzbnZoxjgto7u13VcD47uYj1wsXo/8t9gNuKQTsM2mNgjyGLjY4xrLC6NVbInsY0VW+sYNZSnCXwnywYxQD9d3/zFqzrit1uhz991R+ikbeYm3Ogs0+PwNuceZlPZyRcWkaax8ICRDK3riWF8vA9sjnYU2N+4n2+Ee9yent82nt/It7t5Fr8w/o2pF5RgsHEOSJm0i6AHjxBWKFsjUXYwTz034pArLqVxEDxJ9t52MzU3DR94zJfIakPWkwz9jKJ9b5kMiUAwp+99s9xl7veBTfccCPWMUwb1gsrtaVX7TRyVIN2kOvi+rlf/SP83K+/RqMwF99mN2pNtTvG1j+QHdJGgXEBcdTl3kLZwVz0sOpnOWYM2AZ+bcF8DRTM15b7Aeut9kwafeo+Z8+j8WAJ7wi1Ng0AM1O2a8xAFibxyUv7pqBf2uSPJrNY5ZrjPML7EGmfZ0IWAwKGGRcE0Ws7sYtaNMRnGW/GgEQq1IAFdwFH4Hzof8Y7uJ+zMo8OW7/EATbWU8sjhQz/fOeKT5PoVtWBb/ycx+GaC9fgSx745fjap33lNC39C7mMeJCDzgnmqKEtCeCAs4F50pwlv5f/aGHdh/7idb+Hx37ng3C3u94DP//CH9ad0FwZxEBbySrcugZdtWfd0Mial0AqmA3IAWYNDiODs++82DgvYHu4Wyur5uwDBc6RrhpNLTqwY9DJCjlpwOk6x2vU8z2der/it0x7vqrhfPn0FP3kAsTh3AaYVjCtEY09uKkJezSMxWq4rs1Sjqi6LCYTyDEok4G5UfaOPr/xMu57tw/CP3u/u+PPX/OH6NZfOlvOHawVO5rvVFymz4VdN4bYMEwWi0Em5ZOAiaMEdZrDBL/4P34Fj/qQL8Nf3/Am/MP+7yLpH3A/LELMD/96BCS5Fmz+5Ek7VtAIazcvh7Lf59gEU1Nh+1SX6knK2SD/vWQpxGL+OktJERdaaNJMXGmODVGAz/zUh+Le9/lo/NEf/TfMBNuO4mum5fB+9OdsKW3XLXh7YeuWLeUqetepaF3KBdYbk/Zkzq7viThPac6W6SccNWlvTdnXIsFc719DBmrohnOxgPmEbGc2ONdIRofzvqnWvHPt+ohmbRHc2DVg55p4A3UDfkNUHUMcjq0IP6cD80XwdKiccVM1L7LqYUfAHICe1laap6daMHFFaFq3dRb4vIRPm5jvm9faT6vv28ov9tnLDkKT76KOdgd+4/d+HZ/+8Z+F1/y3V4NuxOG8tH8XGrRD2cHMBcwOZ5tetcWtB4N5sJgHQMdlWVRgoA6ACK9+5YvwSrzYbBzp+WlWJYwigDAHuQBn3ekoTNzNIJ1xIGSw1proFdC250YFu+2aLZAmhKWyxvqQg3qxlNWFIcuALD5/oX7pHVRaoVS9UtVwEYEB9AOB7abcrmo4n+9O0HYnkKYVsgRDQ0akhz+ZR8NYrduJATmut0tNoTFLSFlVcj80r8k0Lr/tevzFH77WwCwxRQjNJP5i/gEsKpoUagAyqtT2Z7vPyMDdhDSmwWD7Rg5ogTe5/8bffRy+4fefYCUry6ZZHVNb/2mYZxPQFSAiXKBcgZxg3m5+qQ3pSRC4hmRfAannuO8v9Z4MzMn0FZhGXTZD+E8ivPL3Xw1tcrCDSVr1IsO1YnEIT5p0uR/nDakmRJi+777+t/mXJERc3eFUkd5RJyr/QZM524WYIhQc05oroGsEdtWcry3jNgCuNTBfS0V7JjXfVTDXGuRuVfAdbVdUK59bri07mM8p/dZmsULzDAm9LlIaJkiZx4ewHSb6muYcf6nzpv439Ej+2N5F/N18bc2QjisZSyStPu9ss6XNMe5vSB6Xu5i3Gcc15wpVbyH7hY9+yGF6JuXHTH7n8h6okC5/P9rgwrTnxhat7a8rJ0gYXqI8poCAoqKYhr1Q0d4pa+zb0fPkhb0sa4tBFlRDBdTaRaxby89usQ3beHw/CfPJ93ifOlpRbNhidcjZ0kpBpwgmS3HwytEGDuibf7uq4XzWdmh9ZxHIDLFm3GIg9ihmKQFTNXCqbrhXMqXFOOb/2oCaYCZv8rfVAiWApSjFarTLVfdkloQzp1W5KrIRQ1RSRxTerKZyQZHfthtbw6y/+qzEpPBRVO3SDyU3V4fmLJi1ZXt/EdXi6zZKqgGPMN/ngjCOxm2yFJBYJ0krLOFH1AjadA/oMBuHnYM5n8LNIgXQ20r9E5B7eU2Bc+PQ8urbHsJbcleUumAd1lLUJtk8V451kU/mbJk5uQVzDQarmrNryNcCuA3NgN7CeWfq0tZfb/fJfffd4Nrs7xsoa/32ooLViG/LmY5Sjl7aETWlaSvw6UxplhgFF2ZRrUuK70EDQ4ajWZ+rgw6B7BlKLhCXqxbwjNuG0FsgV6E8orQp/x7/nm1PEkQ7eRfWXTYeDlJfJOVysBkfuG2+gH92AXSAmjePHaCYp3dUBDPZKwricYWzDnYwN6BZapWeA5oFg1zoFqBGUVFOzdz2XE23ErKgP/0A77kdFeAiDiHzZgBTCuKciJ0SyVMf2yBZPLDuWQ5dJgbRKK+TFBzJZ11WmvNB8SkC9zvf3NtVDefz3tG6Jva537imEnlw1BS9bBun2IwkmzWR5Ui68APGxOiUTeE7WY7lBGibGCIxGXIBci7C2IMJkITxpKjGkIjH4qGR2rpIxbo3iQqVUgerRimwTc7/M+lNdPPLEHGK75VDTLP3+6yChSQSpR6pgDiALAHkKVLSFnmDLdRmQoBrPJQCR2n1jCFioM7XeFDNhDGpP6kIIAT4lpNduAqwD0Z5flpzCZR8Tg6H2xBhu56bsqdvu318KN1Pj7c7fuyeuGmA3gaDXYMZ0K49XyDVgrflTg+OfX68NOCkK5R3TU2AXcEsZh8VX5tkeflE1t1pKwrPqVHeN86f7QZbCmETtjodroI1AKzHeOzghsxD9OgNLLSgSNGFiuAbN59acghmRVKpT1cAPe0PfpWL5jyBWXTtkwnroVZv4joD0PVL+NS5EqBdjnSzN8r3s2ke+di+NFjlsEgAcaPQ0LUtJqsxbeRXKYAeqUFH5HhphkMFzJFu6fnR/j5ilQMLjLVyYLNuuJSfG1eNAGwM0F7ABsVSEaqM7oNs/5JFEKqYF04JW2kpBWt2D7KjHFztm3a7quG8RqGQKoG7VNMtr9cARVEJV0cRQwkjoYwK4oGGFR0LOnb6HBgdAw190p5rxqRLykCR1QycTmNmKCwNwsWVq+AdNGUpjYFMr2qqTQ6T8mpeJDP0t4a9Rr9M2Sbgq1eK5pyBHVKOErBWk96sjwupiZD8ezQDs9WvjYR/e08JhU+qIJuCCoBhi2WFQRmUGxXhOKC3R3vv3OzsYhzkxm1sgfX50O5QIIyZTXHfwcy5a/mJFXvO79ddcYLydELmiV61ZjryPa4UEFZN2xfoSGAYUmO+llRrjjzNthnbD6s+e/UFytJUU7a8G3HNu2UxH91nM5ZaV2MN+WqR0rRK5U+aENlerevYhFuoALcKsJLCeZWhRzigrwBmSMZwICO2B/y9E5p6eSiukYPMN/7pUmGWoWZY4eAmpkEzz5YkEl33buuePAy2zN0k60kMqRyU4xG5sE7DipAJ0AblALRDtiec/fv41CnJKinA2GdX7blGkGO674seIeN6USKXf6dlOS1V2ghCfvEELsxVwZ7rHiMAs1rqtD4D1Hpo2QY8mnbR81F2/yyPhJixx0Wxm3a7quG8FzMXF55A3LxpQU/iOb2+exmQZUCT2nUr0BSN1QC86pAVHTtosc9hkNajlWqH51tqfe0+LYrkm0ctG4SsOoHYRZchc4vfSCEW7ZPg1sJW7pP1lCVxwTKLnbBpJ5IDQGrNVDWAeeK4nr3V5sKc40cbbOkv/p0cyFQLzFcwh0ZtizTlFVscaq4eYl0SYRo0ijl/A+xZg9bFsP19E6BjlMeTLW9zfxqCrGtYxtTtq+x4/sOmCWH+ikml2eyS8bdyoyPf7Vgq1bF0qvA/U0mf2owAc8XKMSBvypxOoG4QjQqCdz1za06YqqfrDWtUkQ0rVmnoUrQhyWu8SN0OTc8htjlDGlsk2m9uTxxwziEG6UNzdk2lGoDVyHYhwjd4iuuS0eFlhtGsMW+nTrN/3igvdV1twpgKmZDN8ZgeBkIPZHI4O5iN3/GeQJliOJxq2P6tzjUfDl8/ih5p+3wF85ZHEw0lNefQoMtzFi6vfxdEMSOxgFzJgFzvjNCEMlAXNW67LKO6DFHmIM+WS9+DY6wEXikbzO0JvCftAnsCTcWlumPmDlqPN/d2dcOZB1qJKvZ0njzCtMMWQ/0WHqKvUX9NFjTo6LJgsWPHgkX8uW6PV3RoG7qOHpWKUmvWSzTFWYkW5KcIBIL5dAugWcBDtKvgBsapLcN8uC7Nmz/WPi8FYkn/nUdjB5iBTD/KFRTR2jaVpE4tA2qFshiQqSmg1VUr5hvTQimwgDfXPrq9z9TUaBJiEPmm2sBA76923zcsP5++yKp7AJRBO0dv5L+q7ES0HVJ2UxQo8wzkhctzrjVLUQ1stYftr/zIYu7PMV2Sww2uOgWPKbVX6j51QoeQnrRqbMA8fwCVD6KDGuQe3e4FIVQQ1pK4RUD0oKHisonN0AC9CtClWU11W6tF2HINuWrS+gygdi+F60oGZ0iMGciClWQGsgkPNSBx8jlLuR52GcRguNU6/dK5sbN66x3QTex0l7la+cus65ygx/hjgaW4cGt7TcQo+uO6hP24AZV//kGgG+V7T4D2f2NbavQeMIEhjpD8QroBJRVzIbt0NpX4rc52d6k1c6+5S7FPR0In62AHKumsuazqdhbyMQPiLkKmUIraAMYQU44E5O1Oz3U8+OK9cP/b3QNPuPRz+KflHHLR9jn7oGnvRApLN/d2VcN5jBU89uZoEs3FLU3pxapd0ZS4SADbwveG7aIRf10WLNLRRXVkw7QOWaB1xkx7tkCEZiZugBX6DmWxIvtCYGEMsTzMkktMQzVNaaImkqbfmVdSGIemLGEKzIxNlMcl/IByeASKkH4ummmU1eZ+BGT2r1Bnt5h/3nOoHcjcBGTpB2GGkpyisZZJrQNT3wRf2IVZdd2mxmwmbiEUYdogLUcCnqXsBblQXOw4DkYp2q8gg79oA2aex1LuHxQNt/ca5UyECcE/p5yH6Tv5hZDclLdK7TGL85U06G1ryNqNatm+8Tv6gGMfoo0KyDu2RDJ+g6ykwwtnuEXI3Dce5Lja6WvhV/TgH4q1pHFQKSrU+SqwYj1Qv7E2YUowr7CMHSAAPIHY15cUU7tbn5ADYq40EMiEz4Tsxs+8OYP1SDYF4jqXteJbFQHh8w1B1tc3qzwlrjHbkvZ/h3zb+c0396sgWwWQgE3ZTxxqNctFynTZRj+rpS2F6DQcScRDbkHtaZtkcRrEDOIBEitAI7r3dgsKi1kpgk66I2ff9wR0XX4e9+PCYQ8wE5r1q2l7wdgL2p4xzhl8xuATwbtfe1s8873/DYgIH3R6V3zK279Nf+epWCXG3Pl8v9lEKtzk29UN5/UctD/PHXzVIasAq9d71gIatEr6NxgWlKB+hCYNnZtd9G7dbzoWaXF/p3o1Ftjr0NFFwayac7dvJRvhUM1tTQQrC6Rpizz1NRuN7Lu7RhrtJRtFxLODeOoji9yYVJPO3EtgI8E2YFuwY3uL2CnAJhkmkIlBJQDt6QQMYJEimZfvYKCMWCrOkWpJLpoK6CmNrDyuUe3VdQADdewEZg+dxQSHH5fjZoQDiwqbGNmuZwDLsIIk9vyV223pezqg44ciAX1Me54AvRlXMLu/4AkvwEf/Hx+NR/6nR+L5//35RxhKRaM2KC/2OwlHP4AmvMxvSFNh5wVYF8i+Q9YO2SuYsTZr0EXgvVmGVglAr9GxLE+fr0sFs3aOG2hYxONyM11Ghc/c5xW6YnAmrCCsZEeYE4uqr7sMsSA1u+/m7ABzNW0EpCvUbA2gVnQ/bLcS2nNZng7JyqsQYsuY4GeXrmrO5RvCV+KkLSM/qz6uT+legjyvhAg+jahzRvigXWOO4Goq7wGzcvnnFnOXWzm96BG5uye0ZgfzKGBebf8ldCF0aC32HvZMj9u2c1+WfBivTGPWWB7Nux4r0AzOY69wbueCccagHYN3A7wbkMvncW7P1nP0Gyy1dLBWEdvZfmMfKLFb3/zbVQ1nPj8D0U7NOysCztpHliF7Ae3ZakJra8MslYhIvleLJGFhwiI6dtJ0wIbBejGtusd00OjtmAHSw7c24C3sSCcgCcANQoxWteeitcmavlyNgMa0+Tigt8jRm8lqrjmPEOgthqWIxtWfWQW7CQIymXfFfMhR4o71yPFFxPcne1sJ6d5LMns1IkgeY8GgAFrStD2BuvxdzfYK5kwdlvDxS5K6ikwWqV9hPDBHatv5aVR2U9eUxwzpbpCeGlXbqL5lf1xLMPnfKmQ5z/8Pfvsz8BUP/3K8/A9ejo//3I9/h4B+n7u+Dx507wcBAL7nX30Pnv+9zzca0BXdw/H3gwtfwZwvJhzTnq0RwdgB5wtw3oGzDpw3yHmDnJOOPWwIeFVzoff7Xq1bGZnf0SMc1SzewAXQavY2r6Ll7YtoGpauudSMVxD2lID2QLOBhkHbhEgCl+jb0JjdLF/iNWARwK49uxBFAIj0uXp5jp12N2s702GA9ikwypL0dVEz0JqdJo/QjvfCpIzn+/t7+deVfF9/SQr7GzATIr4j+jZTyrYgRGtLBXO19PnneFBprlELwAkwS2jMQxvvFCg3WVWJsv05p7R1KiMO4a3De8DTJPemvOxas1YuG6Y1jz0wFoXzeg7QTkALoy2MsTC4r3jb/z7Dw17xffiYu94DT/+7X8ZyzYCsNvasPZ13DHFLGhj8Dv1sV75d1XAeZ5dBWHI2r6J5c3tAzD+APSugDdLad3igrVz6Dad10gG9M0Cf2P0TkGnPOdSE0mw62MQjgmDYJsBYvem7l7VkAVMDD686xqgzKCLMPfgKmbw0o6YAWsqiQiA6wDyJ021atjOY/YmyD+nCE5jlXiMXO1TrX+qHFhHBNW1btAFml7Y5eeULxiHNqIBOEHsU9xS80fR7aIN3sXre5Q3INgEvAuJjqsSwAXMII61ozpJm674Cy5pHv99HAtoR4Y6tsTEP+PerjsjQliWu1xd81uejt477fdT9Dtm5GW/4hzfg79/+97jDbe6AX3jNLxxq1vGYUiULn+DhG9KG/lSgTMWxHbWOzxbgso2zDjlrwOUGOWuQM0DOAD4H+Fx0uNnQeoCvZtnyICHv+cvcMERHl1k/IjcSW+BZas8WuQ0LEINHY1s5EmJoOOcwOGsOhubrD4OzP26IsrSRhtjsrDmZUADtdQ5qck36nmugP20AbV4vg3zKzyII7Vgkodz8PmZAFxF8jr/Y3Pel61MxxNcC4zhS+r5d+Nfvrx+qaxDR0zrLoRqs3V0QwrOdUw9PF9ech8UEKZSJDcpQMHunrAWiLUSxaHMUGejUsPjMEAe0XReHs5BV0jVT9kra/W/V++seaOdAW4C1C1pnjM5oTfPmGSv+8K//HK/6x9dCLu6xjAHZD8j5gJwN4IQhuwHsRgCab6yi1k2/XdVw5rNL5jtGzAixVmjYi/Y6PRfg3DTo/TBAa39iGgrozow+GAsLFhHsWHtla9cwstEU2FBouwnc5W6f+RlYoktfIwk10lBYwcusm0Vj1rqyk5nVTdOJZMXzvLfr5KbUEhE4BuCAROwd083taUduFcow83WkbnQoAA3KHqATt9jrdYdhMsY1ZA3fmn5RRPWt33gyX09Qlkx3YNWeuc2A9sIobuPW2txpd5gr/7u2TGXH5BnOEaFtP6JvoOzadPRwZkwmbdr8SJbUoCcwY7r//T/1A3jMlzwav/6yX5/P8RGmMjPe/cvefa7+NfGWMN1CqJqlNzqils8BYQ7oDsgC8KJgvnGn41IHLi3ApQa53CCXGuQywJcBOgP4TDBMcKa9uZtWngIMZNgGyqrNssMZh3AmslavaFHJK0BMbH5oC6KkmpNfa4UxBB0iDMFiR1ZAu5bnVUL85E31AvQ5h6w2X9AYEzeItyuM+R3y8vta7AXa01VxsG8A7+93TOYOGaKAud6vJvVR31vKnkAVzjQ/hwJyOJgroCWO6YaytSnDXBl2X5ppy2RwJixi4qEAOwiilag0LNRNozbtmWB50PY97QfGvCp+5rGq1rx2bcKydkQjlrVpAxamgQYGy6pjrOB1hax7yNmq4/IK2a3AyYAsIwT6cf2tEM5y6QY74WRKEFkkCEUjctpLANq1aFoHaF3R1hV9DLQxFNDMWJixE8FOBN7S81QoQO2m7m7ac0NHVP8imL9qYEXD6uCuzSDYioySYAwzqBGriS6iPxQ6SS/MkI4xa9BAWZR1A6+rtv6dtv9o/psQDMyqLccKtlXNSKld/11qyx7JKQMaYNGhxe49faK+V5ikDwE9adEW2e5FWmoEcJbjMw0aLpkzUnOuVQ9cW15nMIfjc6tJu+Y8kF3pV6Dv7bgWONuPrJHanY+DubgNtlaOxz/l8Xj89z7+8Hq9s8cbDk+TpgpGrt7Y9ae6AxsGEtYeitUDzDRMU75kYL5xAW5cIDcsoBs7cGMDLhHkMkEuQyF9JqBzBp8Lxp41CnbPavUyQKfpMeEcwrB0eCgQkQZ0eulPlzXYNGWmgUFmwjZfcvpr879JQgSr0LGZjA4TmkBdhBoDlT4jE9i2vmc3dZNd+jBiVdDaYyFMEd6eilXzeI9Nh+nyy/yeMSXcF4z0plwJ0FVjjviR+sGEcMENVEBn5TY+Ztq2kHMStVp4EGArI8AcUBbsMLBgwQ4DO5jLkcgsmqphN4vgJrfRN+T+MbR6pMY9KKDbHhiN0BoMykAjryQ30IStPbGCmfcr5HyFnO4VzCcr5GQAy6oNM/oAmqDfEDvkzbpd3XC+fGPaYcKWQtb0HVo+cO+ABuicA9BtHWjrijb26EMhvRicF2bsWLBjwYkITiDWs97N3aSTAen/ArpNdt0Q3FBGSDCzgXmxzaN53e6RBQvTOOeRoq41u4mNcx8R+P/0fBSoTlAGyur0xyn15luUWja5P2uvWAPy1n3CQJS8A6VCUeFMzcDcEYrl5OBKJXcDZrUOhGuK56OnnwkLZJiGXNwDsBrgGiqsFX0UzgXK07kSZEeAljtQgNQ153EIZoe2w9lbRtY0qtr2J2BcBKftKBt33K60A9drG0e6ApSBDGkmbQm5mz+8mrVTcy61jfcduNxBlxbQJYUybtgBNyygGzpwQwdu7JBLpKPC+YxNe2aMvZirSSzjwi4Xk22kBmfTmc3AiUaWCmm9orMQkWlpzeHszXAa2POuKwGhoD6YgFeUFg12nAvhqHmbAK0YqD7oPKuzP3orI/vwv3sQ1oGmXEC+hfTRqSH+1SgSAGxJ1zCHmB5b2b6a1cMzAqTrCy4YITvqIQNYFc7FtG3Cc9aj8E5jw1wCGnXdDc5qzjbLJhi7AuYdGhbSGCG16bjfGeF39i/HlILfMLN2axok2JoXttI9bQX0egmjMaPx0AZLYxiYB/hshZwamHermrN3K9DN70yCcWs0a8ulGzQHQyjBbHCG1WnVbjhQM7cFiukYAWiFs0J6GQM7HtgJ40RY4SyuQXs2Ck1R22TLyQvyD/Ga20kgZt0wNCVIA8Ia5njReWmUZRsgVvFPrIdtXczTzhCPceXVGubUfGp6qUPJP6BCun4mpQ/MA0aoAbIq38SV1IiSR4C5BoSBc/HD90HXqBkm3FhKjgN6QDXlYWAd5rO3rU1ce/XzSg1KJN9dbAAJZlyhrna07jH4Rpf6PaaO9QFn+4IHYLbj5F/ePL6pNzlyfwvjUQd5jpE1o0B21ATpbkAZBa04cUCbxLV20Ln6k+lyB13qwKUOutHGDQtwo8H5hg7cQMCNBFyCAVogZwI2QOOcdW2udh39lA0PBiOwpTdWn3Nozmba9mvqJXrFNGduA0IDQnto1cAOiZrq+UsPzp8gTTeiwZtCks/5xHWptKxVcvrBSkcWQKO8moBIgaq3APP8zttdYTZp4wpTR/IvYv9G7IFPE4KCk5C7j/uX63tq/fyiwdcPJQV/ZpbM0y9hLQXOdfGTghlkcKbwJqWP2bXmboBWMJ+YFVNjgii6PGdAmAkkbMLbIPOhk2rKq8YmtEYRlrGS7iArrOiJWVZ5HeD9AJ8P8LmBeTdmOPcR6ZVCgnFpPXZl3untKofz9RqJbXVXxRq5e+F9CUBDFSXTolVztsCw4YDeY+E9Fl6xsAJ6kQ2kgQgQ28H9G6IBDFDvkhfTV9NWGqO9fu9qUO4G70bep9ZLIJh2p+SxvUGXpN5n1QKdZqkK42A10XRArEg3UTdcYUVjs4MYmOPTJO/ba7xCUS1R7VrzFszHfM5VaZkUGLcGO4w7VEvW06B1m8mec+132nb8PBpc/AtvwRtgNjgfvEbyRwSEDc4xuQzSHmjmZu1N0B9CS0dKO1c691KflHx8FCY4vjNm4q/GYexI2955ZJL9W9pRpFaR77yiawtrA60NOKcC5wa61IBLDbQBdJi1b2zAjQS5EZBLCmc+UyiH39mCwzwJOTVn6ywn1mkOCxgdjZYEtEPaNWe7dNI08EvagLQVQju7Rucgu8ZzZeZat1nXrpdvdM2RzF0S6YLbSCrUF+d6qxAjIbzLXe6Mj3jgA/Hyn/lpjVAul1jypamZliMop8Y7F+SsbGoBcr7zLIPE59mUqYKf/7zQRikFg6oTCLDJLKlQRmjR0VY2YkNMCBSCVms0W6R4DjM0ZQqMHdhSWwdO0LEjhfPOzNo7KZozDNBmVdbqiVAXh2nOK2XREhXbTXOGaPlYFs3HHwwerGDes4L5bIBPRtGY3descBarFjgu3yo15+uBvZpBvPapN3XH2tLE7dUHYh9VU5pGig60saKxadC8R+c9FllVg2Y2QEsCGpZyhWYKKEGNaQZgkkixEMkygatoqbluklhqzu6VaXbUiZoJFTQtLgnwALnQrrDJo/xDv+uANj/MlRZ5bACE1KL93YxdUzxR1ZQdyq1AuZq0N2AODXoDZkjxLQ+YCZvcUh2mbDFbnwyxa+FfyrppheBTdI8KSjCybaRJGfUcRmCX+60NzrCafj78b1uzdq23XVWfo9fr8LJNjzfn7YpQvhKYF0TfXQAq3K7QAOxOILNbkkldFK4iAvYEOiPQWQMuE+hSAfSNdt+hfKmb1kzme5aiPTfwOWsv6KhPgLy23HRI1wGHs1cbWNBoAVFHI0urai3nYbPNsaUQRW0PosVG7QHckI0SyqW2yyZR0U18SiFWHNu94q/fyswS/mmNi3jm6/8ndqen+NRHPQpPuO/HVOV2mgcyL/HD54/NmfJk+JcJITBUtxRv3mB6q/JvBbn89fRKnisHs73OA8xyOmY3Oc/4DZN2fI5+sp/ebShGgFkWA3S3FNeugbrUbE9u2JHlFYhWDQtjlEVpu3Y/hl15Uq0520yqAOJgXhnozBirgFdWMO8VxApmHViG9XzOQDAvSrKe3Qo1Z1y6QU+KKJjFm7+zadAB6GZ7p3U+8ZJsAeehgWGscF54RecViwwbrL4OEewE2Al0exD3H+mU9caMZLNYgyoECwzMrHWoGwuoWYJ9aMwO6BU0QYSMSkjxNzbmCum8zaVIkBtF2dBJkFJ/4dVM4PlroM2fE1uOf023FLby2OFsPmccYZXI4f3J4uXDInnRKpi1vrgueT0f1VwmTiv2H7P5BRXMkeRyxBsY0oK9XyTXVwJm/an5dVx+ZLkQ7wy+W22ZNjvgMThvoTyBGQlmv5aMALNX4Ay5xE+NvZ8qngScEegMoMtkgNaBS8fua1AYLgO4TMAZIGcCORfLf9a0qjx1hGwTaGCWBWLldN2w2WhBJwW0UEeztIBsCiG2SaoLQsG8BzWtjdDItHATkRs06pv5sL0hWSUcqZaPOlh0I2aPzTYA+aUiy6oA0JcFy8kJAODd7vYeB2AOyPmawnwEDp/PaXOsFhUFPKd/HFNLYTX9w7IFWGn8MLM3kqi8NX11+30lMPpgaiqUVXv2c0S+yIEUkPzyQXQI25V3MDucdZwYlLUehYUsWjCYhzR6GWPP9FBtWYPGKphj+xLzQLFgDEFfRTVnA7TsNHVKdqxAXtKcHTnODufzW6nmTMuqM8IbNQ+7b+UDaaQG7dGp2qJMcyw9nYqGatCdVzSxpheyJpzNFK2TxM0n1kHUxFEGIp2Dxeo/uBRIGVxAsDSqNgzQBmYxf6hn9PuKMijLZilWgGyBTCgrbrvp+2rxL1fBW/lVAE31Nf7pW815A2lqCejIk/bo4COaMzDD2ZkWrltTSDHETlU2/kD83839fu7KwuByPsPHXE9I1a7bfA7q68TBW8dqnzXZZlGqo2zG5hxvz3k83lzHaQeUdwBmOtCWsSDhBb8e+jraIcFMCM2oGgnoHPraM6j2fBnAZejxkh7pkj1nQKbLCnGyVCqc6Xe6Iph9/XIDWKPCRRTIIjt0shJnpEPagkaa+0Jdg/ii4YrlpVMbCud2jtZOIHQGIf134s4p8283ycvWGBrI6JqzxzYgj7EmWcpy5QClAtqr/BH264of/KqvxMc99GH48Ud/XbRWDNAeOx65H4CO+7lwxaAr5MKB/uOcWvlaFgrwbm/+/VsdUpY62YfZe9o2Fabtut04mGtmCaAadLyfHH5W7rli9hLGgjHBeQcKQHvtuu5pVLYTQqCBYAC8mWODWYX8debW8MZyDuc+vO8Bg3diGjIrmK0IkUQxIrfYJJz358fO7ju/XdVwxuUbIYubtZuFzDdsOkYYqGnTMxSgwVqVaGgkXmOFpd5fozJNl4Euao4OPwgMzhHo4ZNAjWWD1N8RKRDQ6ZvddExzbkN3AIsN1KFmkNi/JR8lK7a7+4TjvFf2k9jEl7Kp19VQIVtvUp7bcCt0SzqEdURs2+onhqZkXQHMAeV6ZOjGZ4KV8y8j01MN0H/j8GN7bF/Kd5P40vXDB0Jrrq1+JludjRoyXlvX1N53dAzMjMwNK9djOg+uzviu6ufmGKCBqX3RZMqmEvgFBXSx2PvbqUYsCmbTqN06G1bcar231EQ68wHgsoBsKIznI84AOhPgjALMOFeBQDyjYgVk1TKKxARtXm551KIFT0h20FJAJyDaAXQC0E4rBLYF0juoNZOIVSqmrgKwdIsN6OcAnUHaDmKat6Cjixpqm5s+w1ID7a5WMwFGuWiiC8iDm6SZCwaeaWG2G0KAiQn4tR99Fl70o89K87BDnRJstQymt4R1wX+amoClXZbpUoV6m/Picx8JckGCmeq/20w/B6r+2szdhmxledujJL9fnC052MHym5gk7lOzmrM1BNDcgehYhCcou0l7ZwrTQlZBjFwDzpMrUGGEuUDb/1+UIb/UWhRQNWcZAl4EsqpmLAtbupRpyrW+fqRj6gla9rdCzRmXb9RiEKE5V6m7jNEQJW48t5OB6IYyJAqse8h8kxFHLbqeLcrcXBJJ7oVqAg0w0Z6iJo3F3pqUjGKD7LtfmlS9WHxIo7CJX0ExybW+vHLRoH6cA7pqWQsmJk2APqJFx5Ly5zaK5SwYxOnIXGm38JYVS/5TNt95MnO7ktrtuAo8l0T8gzzFi/P8CHMCLMz363xSqoTiTmwUq8X0UkEtN5hwtqNfTyr3aw+6gYRovFe9JkXNqbubX/ewBJR/J+XfuuZcTdkLFIYekV0sH8RQMO8J2EmJg8tgxlgbQyyQ0oqHnPmRFcJnBugzBi4LcMagM1Iz9jnUP30OS2ekFBpMiJAV4EFoQ/vlOpi9+hjEunbQqcH5FEQnCtl2AukL0Bagd/WZd1IBNOqhr2jdSz+d6L8hA7SFZjZpaFGVzISSluV1yWzcspk7noalYLYCJ+I1us3fKtA+5wC8MAmASWb0qVyBvB0HgAYyv7ssTt0mKI+iR12kBmvxSBn9Tl4GVKfbXB6YY5+rbrw5+jz97v75h3Y+QOD1/V1R0fvWcle4bEVSzNqtaM1+383YCuSdAdrBHJpzSD76jZk1l3l2c/laS5dGY51SzFDNeRUtWWwNcBzMaAXONSODrCwzCfr+1qg5n98IrHuImNYsLc3bG0BT9FrUQW6uYmg9V5bohOKDDMyaBmEl8H2jFJe+Qt47HFWdJBTqaP6tkEWSokNYNwnxf+e3qrUFjG1zEL1fhYMAOBAbvXfDmvy9A9ne2r9yt4/eurxpKyHbrfz0GmiyBbWfhq2mOLlh7Y2rDBMuXovQ9vyN1Jar0OLvaeDs9qWaQZqAzAPbCjaba7a1Jca5YzVt1qIkfjK7zRt3VkaYuSC6dgSYgayNiASzPzdp7AXSfjL9K1ez9pV8zQtUey1wDnO1+5pLkHpcdkGCubTNaw7lc9bj2QDOhh2bgviMdJzTESjTBGYM7VpF3CCj6TqQDuEFLLoFe6UBwSmYTkE4RaNTCJ1C2gnQdkBXONPSQJ3Mf85WvW0F9z2on4PaGdAuA6SmAoGWNGlCUSemDYOtDS0StGk7I7qGyesPwHJ2ScecIClqEYelKMV0tUpiZS1VGI/N4wpohTQVJblAumiLYc42SGfqF6aj51M7oFJ7zswMrbqQKgjKMZZVYLgqFvXmj2xvym8Qu6lrzU2kaM1tArOOFi7GpZi0l2KxdP04zjeQAjv734og3vU+2xLnrg1+pFuwqcUyiLlNyFvFbkzZVOqG9vXWCOezS9DUFQNz9T0fQJrKEeUouYnW5FpmeLF2lfikwCMN1AItI+htv0v7bwi0gEKYtSjTB4Ssji+vENpDWo+FE2urkiqAPEM6jUyEB9/vwfjGz38Mvufnvwe/8qpfUoEjhfxS5hSpObtWZZqpBwsdg7R/mwnUVJ50mBcNDdi8R/058SblUFc0F0D7d6L8u0DKdYSavMOHwPPnetjmdE4dyA5ln0O+C/7/2nv3qNuK6k70N2ut/X0HDogihsPxFSRqhgqOBBOEpAPGqLFFY5unsTvc1qQ1iTZEHLlRO4H0YADDe2NMvNFkqFHUZJBO1ERjkgu2ihrjMBdkCOggtCKKAWmMAirn23utmveP+ahZtdf+ziMEzoFdZ9RZa6+9v/WoVTV/8zdrzlkIlQMwF+24XDyANel7MpY9cg3QIwWwNpA2adgAs9EZe/Csz1IxZkZt1oYAoPq41cAsnVjCoxSjemWJVHq1ra+b3HFSAXkh27Q1OkBjLuAsDFnB2VLnLjrJaz/XVaoMmEeNohgB0nSdlG2xC/PQlvnmTGLSTtgE0w6AdoBpE0hWN4DUg7oe1CUB6J5BPTs4U7dA7uZAp2BujmSQoCx7XSkzUifOPzSoX4hOVZDHXYxgXQ+eFaSZk4A5C3sm6CpXkEUgRn+D7P8zUOKUg05oosqn4KPo8t+VjGgFmAvYGFv29dwNqEn6DDXfUZZpOJsDZ9WFmQEi1qix6gpqMmZc/KY34lGPOR6//HMvwh3f/Ib+ogzwONTLEOalY9JNdd1m8QTQSij++hGcQ2XSRdYsC3yhLG7S9qvp2NG26/yFKHNOOiQTPNmRGNbYfRmo3Sfb6jEjAiRj6EDKIQ3OvLgbRK0TlQhb1jWbzdzN1rs5qSw1TRLKtmRrKTbjKiqSC3ZqmTmjm9IdxFVB9LxMHSQbaypmLoaavTIybNn3hXTBvAAnEU5uZQH7v4IStp9gxieCCPJ3n/dO7NjYgXe/+t148HOPrPydqoieyJzNtG1VTcgm0M0sXQGj3R8Dz/juZ+Atz3k7/vGrn8ZP//kLakAMIM36d5PgHH+zCpwNYFXwOHh1XIBZ778Q4VwYptNCvThvx5gpAJ/9hMOWUTUuizbtE1V2flf6UDtqRZD2lQVQ1xXt9OKf/c+44Nzfxl/83XvwXy86ezVINwDtipa17cigngTEOtZ8LMWknSpwlnVtkyXvmY+g+QjaGkDzJHVrUKZM6jjG4AVLkpEhgRcJ0LWdi4OmTTcpMHMBDWGjBtDq/EXKoGkTSDvAaQeQNkFpE9TNFJw7UE9I+myytOcA7pU5dzMg9eAk6UxsZbOkz5yy+qCkEZkUmNVhk6MDYB7FjO7gnJE5y1SWegDLo5GHVZYEPoSONP1tpUDW4BxBugZoWgLpAnn6BeB9mfXHbCfXeF+/GAhIkEQkuSgMctslo5kRFesjAPC8n3o+fuFlvwQAeMMlb8Mv/MRPTo3qiWNh7lqB3v6VnHS2YIguDQlS6VoDs6+XZiZtlHhsM/vpK6jaiVVEMGvyGhVslmvG+J1448vYJ1XQSS0qZV8icIo5W69CQDc+EJnzfAtIY+mEKmTJkjvnhEfs3oVPffQt6LsOz3n2ufina24s7CSbhqnake3rfInndIYNTwFa0YIF6FPoOgLOPQb0GLnDSB1GdPK3TEqYLOm+phXkTgFawjhcv8gWGhSYWZgjlW6bK0eG279xOx5x7CPwL3d8HWleOhoyV7HGBshkgNa7fqEmZN0mFI9rva+KNgN4wzPeiIcf+XA8/Hv/Ax5/9ONx/e3XA2iGJDV/15yjLUtW5zGcLzLKDJ+LLuCJhvFn+FJYfmfGRANI2/SDZVPx5lYwNWCOAG9/bx2lAudQW1arjLEGaBQWzc1+ofz4nde+Dg9+0IPx8v/0q/ivF54TWD2KP8UAzdxAksZW20PlhTt6IYROUWJvMgEpWb4vWT4AA+ZF5+AsWwNockcvy2OPRQYPCRg68EC6T7qwRZJ2dcRhZ/VFE0xgDXGzECq4M9gmQDuAtAPoNgED556Q1KydZpC55z6D+wHcz4GuFweyJMBc9K3gdzIOyMMIokEqBhBLZR6A3AOdgnUaIcvASs0pe0jQSAJAY0AHRsgBpEDrwty4gwGxAXNl/KOgP9ISc3ZnNJOJTEAKAE0BkK2dLYoBcr5wOzIsWMFHwTpcCTf80xf0e8J1n71OCUvUsEl/X4olcYmmcQPqMoQzbL2/wpzJgbkchx5TJ12GhFHZdRSgbXaqmghkICV9Ip3Mp4TKIazIEwNlVWIdkM0nYbnaw6ZxSkHZezm0wXmxJWZts8FG0ySkR//iWf8eRz3oCADAr/zK83H2Sy+UzputEweC49UStaMAKxJGlihkEXKiDMiy3iUKb8QMA3os0GPgDgN1ugiGrE3sK+bwiBGDAnSyGW1xMcks7vg5xOl6N7RZLA0I8FhnwhPPPBHPfdq/xwf/4f3F21b/XBaw5+KzZKDWsGcOWw4OzOYr5R7Z0gT44D99AI996uNw1/wufOFfvuBEcklhtr+Zeo9TYG3YR82xYImeXhEAhbW7zLE2shPoqGUbvbkGZgN/s0VW57MbQ91xzORN4eEZBeRb8Iwh0e6kGBSP6BwWykf/4Qr8xDOfhy/dfFNQMq1ydU73M2xCpIQ5Q+aTtf2MNScUBplGDuA8Ii0S0mIEzRPSfECaJ9CCQHNVAmyhmUUGD72DMw+jzCcPyYGZNZKCc1eUEQ5tC3sXCTIhbpqEgfMGKG2A1LRNqVePdAVmM9fPCOgJ3Hfg3pzGpCMLbmnuZHMAHUdQUlCmhQOzL0idZSUuttVcNL46Zx0cxpxZtqOhXejkDFk+0tLexkeNs3NLPq2JHLzZUpUiAnQA3ciUcyoATSUPOeX6bzhD+kMu3bfkBV9SAQBkXPPZz+GpT3gKjj3uu/CJj35MSUsc2isAWq/gSkAZ2johGAG4gPD0MSCFbZVeVIEZrK9HFadkw8sIkWsiMlbse2NpEhrKnnebki35y5prvAFnwAE65XoM72shZj6wv7wPy5133omjjjoKeOgJku1HX6/EqZm3tDh5PPoRu/EPH78Ufd/hzGf8Eq6/5othvWZdcQqy3cHADibsgG6ZsAMJO5CwyQmb6CRlnCZEsFB4YAOWjn3EBgbMsECPLfSYo8MeJOwhgoaFYg9l7MGIPRiwRQtsYY45SV3QHixoCwPtwUhbGNMWxrQHOc3BaQuc5uBuAU5l0QXqZeEF6jOoz4Bubd5NKtTMp1tlzNVWo1ciOOs6B5XgEKFQgPOw2eH49vw7ThidkNp+IJpVoXrbkMTazGshVE1uaA/NidsFKYujwlSjGTX7aCyVVFImaChO2PZWud52DI+ta5d+dBbIS8+wtB1Qm6QNaA2krXU0EPTwIw7Dd/Z8R+9D72XG0K6oa50KhumKLRIutUGCbT1JVc9my7AljlEdUk5IY480dkhDjzT06BYzpEWPtJghzWe+pcUMZNtFDyx6WXNv6MFDp+Cszl6jgJg4fmn2ryxJRiRsagbCJog3QLQDCYch0WHo6HB06XB0aSf6bif6dDj6fif67jD0s8PQ9xvoZ4RuBq/mJ2Zkm3vWFS4zxrQHY7obI30bA76NBb6FId+FRf4WhvEuLMa7MAx3YVh8C8PiWxgX38a4+Dby/NvIi7vBi7vBiz3AYg+w2AINC9A4l0yD40JXuROw9xBM2FaEeoIKeRX6hk4cak4aVZbEw3hQkB4T6cyAWuOo5BkU73Ct2RKrSL+Xdjfkr8cD2VaVPVfuzUeBbfos65aVKNg2w1fnU6pROD1c8YsgHGfTJJqPtAtL0NwmAHH/E5ksWzm+I/xmI/xtNd8ctAHxntdh6G0W5/XJjVfBcOOiIYJwMqWu2fffqDnbnv3uzPi1W/fgjjvuwIMe9CDsazm0mfO4EFYUBW1g0cwJX/7STXjUI39IF+qWFG8SZqBhE8qUszFblk4+sLDdAQkL7vQ9EcAdMszxoOh3kTkvtM4VnBfosGDCQIQBjIEzRoxi9mZdzs7ntG19WZ2TzlOTw7q0miklqpiIgmImGfLcwJRJPW9RMefIoNnM22bSDjV3tdBw7R6yvXv4joRFAQWEp2oskbiGY7617+JrraqpwnFftwgMuip5xUlRPmeEUa3nd2+e8BAV6HJt/vLfoJzT2TMKU67AGIExowblcjKc+v2n4HWvvQB//OfvxNvf947lNtY5bApMmnTe3Bbisia2VOGu7XOZb05jRhoTOmXO3WJEp8w5zRPSgpDmhLSgKmc9hgwsOvA4AkOHPHQOxnlMSJovm3OHnG2+VtpJ+JI2CHNpS7J3YYqUzrckZdRm1TGvc8uCZuy5R0hbmkDdpmToo1GYMRagPJeaNkCk8MASX21sGV0PjB04dWBbqNxWL8syjiN7thSoHuVhSiiVrmHrq1TuD0nGnOVhyR35/Cd3RUGW/qa8Vi0+Itci/Sa1UGibma1c+ando3NYz4oSmbPEeVvUCruNj8qWCSVRp1mnzAXL+nDRvONQTr5ln7Ar++q5DQrbhin7OeJaavYA0PsLfZ9Vlsf7YHK27SN49NcZgBjoAjB3QdEypcuZs+0fIHO+n4AzUASuvB5WBm3mHUbyuRiO2qXum/l6UGDukLBgXdgCBsyScMDmoKVjmCFGXBVkznkKoAlzJiyIMSBjwKjz0snno2W1lrGqwCiCAYNTWOIyku2+JOQLuhKLAjOTOhCzCC0TxiNJkoYWnMcalLkX4UAqFKIDPLSjmqAB4DsmV5fwJX6cBM+J3+31F9Tsx+2q39uNR21AQTTGQBowtzdkcsfYbZEO9TO5FAYqB7MYa7/KCYxDAzpQMf7qj/8cDzv6GJx28ql4+/veicoUHP82N9cMwt+FVBKztiT6V6coVnN2lhCQbiB0iwDQCsgSNixr4EquehaT9pB1jrkDj11hzGMni1jkBModMo8g7pEVnGVKNlkDKXCasI9ATW6WFYCm6tlcf7WkKpYZzbckTmNpQ51JN4Sp8wZoNBODVgPmXgdCp3UUUOawygvrAgpZ+01M5mL3bR3IgLlk0iNhzxGAp5TjDuI02kHN2kUZqOSfnby1i1PZsu2rXISpEUzF10PQWfuXdHoB6Zgx2zpyKaRSMuYeI33yWhUIfg4onjT2GqeBmcNvXQJWAF0NQwdoaXTX86I+H+6UbLhR+d5AOREHo5rsJ5Ipirh1UPbzPSDBeYDPJ7K9/uQs0p0jAjC72QcpMOYIzgkLM4tDHL4A0g5pnDaaTwiWy6Y4hM0coOeYYQsd5khl5UrKWGDEgBqYM2VkHlE8uTUGGjpCUwfKIWuIKiDEGiPI5KuwpEziedqLY4Ovpdzr1uacw5YHAWQH5lHIiWnxpFub3o8hk7H7VSw6bm2QxNETQY0DXm7HwCsmvgKgp9i6nzeCdHND7hzjT1N96nsZMsNiaICPghpujWLgTAUoHTADcMacr37f4UHJPmd89ZZ/xsOOPkbM2qZAVA8XtCVmdyqv/A9IRoc4TwaByVTAecxIAwk4O3MWUO4WCCtlqkf3QkKPxKStwDwoQ1ZztlQFaQVm4l4NBuYXLIhq+eYrLSas8MXqoFMBcwvScdom1o6cdRPMpB5pdl9QsevEtqxs2SslZc8FIDMEoFnVCoAqS0Xpqo4KiHoGFIARQDl3VMakpb3qDC1ifxOIkqk9ZcosAEyjMn0NZuexaxpL/taAmXQetnZ81A7E4V2wmZSMrhjc2kpbIptrFXjVPLNzeQfdrvocmXXLsqMYqa9nQ8lD1lDiuG2bGK5K2Duyx/eZLuaSfA4Czj2p5NdjPl0BrsRB6zeyr+XQBucsSyBZthsXM0ETdCaNwpojex4h+bENmBNknWYDZjmHSDgDZvMMTK5zmSHGmHPLnjtsIWEOUoDOGGhUsznJGs8GzDSCeVBgdmki1UxTmFrqTrxUxSdJhazJr9FYhAK2OQk1zJnVrM3qsZ1VQJi50C5v1jFQwbKiIwcs5rIvB8K2BWRqvo8gvIph+j4HIGwQPjpVxZupfhtALU5UleENMPADJ52Mf/iLj4CI8OP/5fm4/FMfDswtqNvxITlUB2Hd9zjntvGiZmEAnQEinPycM/BTZz4Pl/39/9S+sKy1FIHQKCqFgDdh4DJyUi7MudOaxoxuGNENhH4Y1c2B0NkS1gbOQwBnY8y583nmPOoUTk4YuQMpc4Y6HGVWRgyJcSbMlNnqxLzOybDn3tVcAZTVzIyKdRoLhfZd79/GrBMJyOoP2bROC1PQe6/N16m8Y61cfQZYw5yscYs/jPSP4sWr34cxFRULuV9a8gkpSAB15pNrO18ME9aUzfzeCUB7ppmuPCcnNYNbIifoMwFEmt/BOkyIGJGYb/J966ll9Jg0ToCrKjbnXIPqlF61+vsC0AXoC1uO4A/fkg8HnwOPAA2IUhWGTFFZPPABPSR9c0+agI5YdT1uXo2Zt1V1eWCC81hatzVRRjBu9s072lizzHQlDA7KNpcs55WVl4XP9gqZESLllXcKzlLFY1scwxboMVdwlrUDssxpk/EDjX2mEZkHZJLkC9odYKOVko7KHJa5U7bsVQE6BfacEjw/RgpgG6awHZDdlDYoOPf1/NfYKtxUW4FjCYS5Jqit6tweiycwEI5m4CmTsCfyAMq8bQ2u1Tm9GjAruILLA9l5tB+84Bk/ga7rAAA/88wX4PKPfxjFYzwI6faB3IvOAJoKKMd5gcoaEJAUDAsHy2D8j7/5K7lul+CUeKptQ/vHEqI8PK5VlDmZDjFP7S5ndCOhGzP6cYTl9u/GUoVlaxjSmGVMRnO2M2WZbx5ZrD8ja+QByzMB0DEq6zMDC1CosuLGArZEJ6cFmAatAZwNm4TsTkYguIOjgqln9jI5kdRkrJWTfk/Nvs/3lpaWWQ6qui6hTOVmQwTt98nGgKFSc8+F8VOZR7dlPRPptESJDiad9qIs1gvqknjOpzLoSRUgcOfKCdQXR6wppdsSqYk6mrJpBLNBZJn3qbufgWSuTNA1Q25Bmt2cHX9vDLqb/Bv5uzjfHLu/9iyV5QhyipwZZ+l8lbvKlBGmN2AOtEmOsy9yJACtSgivwVk/BHDmuouIDC7mJgrgLACdMMAWjuvgDhwQJ4esbloGzjZuzN3DXqOs0NxhcIDuHJwX6ApzRsYCCQMTBgutwqwCZiYdQK42KyjrurWU1cvWhiULKHcMpEToOmXPmdB1XMzcxqIDQLvwUrbsJrUeGEe416hlD7OwnBagKbyGqEVP6E3+99ycZyU4R4eqPLE1ZyoHaGCaUUfAbbbGtG0kRxbNwEW//zqc+fQfx2y2gdf+X7+ti75Sc/8RoPULj0UzYHZkKEpENDf4h8YmLSiq18yFsTtzr0GawsRaIHf6KgLbYNuy9iP2pBxdzuJMmTP6TOhHSXPZZyiAa0z0mDUNbgLy6Osxmyl7VICmLJm1iDuM6vhl95HJg7kASzGhq0+FPKBgkvUvmebg1GN2WI//dnGHO+8kvOn3ULHQuO+OVh2QEwvrRlZfj7B4RQKYeDlCgUTMs8cXIzZo6fvxtQbjjR9rdDbrN5J1Su9bqJpa20kt7uTObkKCIzibY2gCZa1dAo+ydrWHopkEU3AmVnZtc9QaoiUAXRzBWH0AgADMMa4yDNwIzgacsl+bpLsgS22/1lOmwLoG5imdtBUjNsS9r5PcAyAWm2Tv0oYLyjAzptwxMCMuwREIWz0e+U5c1GQsAma/yqENzh6vY9F0arQIXrg2D2LzzeSAK6xZoC0rWw4alv6ugHPWWeCiySW9QlECBKDHAM5DAOfCAbKatIFRPbczjcgwYI4ALV2VQjelnASYEwn4MgkgK0h7hI9a4rpMSB2LPE8qw0cCaRjQ8jyXsmSdcx7VEjbaqImAmvQNUNFC3ToURoiNYx/PEeBXgbO9iwjOK5ZNXmLQlckbtYT0d2y/mehbrm2U39z5zTtw4tOeEpgyCmNOhMr1ltoHDJLetJLolEbNxSrWHOZbUy7XTwRJuA853iXJUlTRiiBx2nlOu3X9allwlvV0JdIh+3oSfVZFMDO6nNTTW8FZTaWyDGNC5hGJE0ZOIKOt6FHMpMX6xVSmiKqJYpqBvfahdjj7NYfhh86Q9vvCjcBll5emXwLnBMnSRyNGGnxUZ8pexVwuwMQoW7lFeSdtt1G1z0Jll4E5HDdg9tjzcJ+y3KU4felKmMgesw2kjsCaaMUYflIW78w5i3WCRrW2aVt5W3IH4t7Zs5sSUio36v1F+5+tQCOxLIiD1nVStmxiFjbFMJfZDjn0K6qAt1tRW4NCOye9zJ5rURLLKgBPCHq7jQOqr2stN1PGHFwGq+Nx9sHFGtc+pftT7gfg3GpuQX0tcIti0g5aJmzmRGGdY6C8gTh7De5Z/mLjq87OnpOYyR2gjUWTYkvSfcaIXsKqlDVndJI1zCbKygQTwOYfrrM5WRcVJ+0UCsidAzSVZS4ZZdpMQdqBLYxRN1+rYBjDNFU7NxYFDRQPnZ1Nv44lYJ/cVu8Yy8w5Lu7QmruXABlFLUY8Fn7j3030MXsocH2+6NktqZ7gnj2VpLVhXouSqkGqeW6lscgoQactOI/wl15Jr6waWQHo8r5E6vhnlajOFFCAuhV6JU5XmQRIQJrFUcaYNgWaWYBZppHc3Ko3SwbMnKt+kqtOUnJCRaBmSHrcRBK+9KUbD9NpIODmr0oMq91K1JFkNoGR0wJjmiPTAiMWGPOATAtkGsAkdixRlrOza8uHL8BcFKeYQ5r001QXrkrUx4L+Jl2HqnlyaEKVuCa3zEUT2ABaY9Tj/DnlDpR6kIKyOL7NYM5vzD0o9+AsAO5z696PUfqfmrJ1MXUINA5ona8iWzZwNi/rOqlIYcU9Wga9GqRXgXHLpFMlxXWIti/E5FL1Bmt1ulEPHYg3MAXQKA5iEPO2nWvxgDRrh+xY8IFRwFiQA3D2LBCsDNogjkWj95Pa73L4Z+5ZxehWa2hhPhuWEMAAumylQmKdATVnZwFkdMgs6QrFu1zDHUzlRwPMoXYgdFlWZumY0CXI0mnMwnBSYdEpEZKlodNea2vXGnMex+KkOiQB6Yg53DSAEUDXoOFNX6mpU6yZaPl8sL8L5NEBeCqJx3YsehVI+4UCm/aL6t/EeAtQ9Sf+UzcJpKa6fbLeurgJDeDSGlhizAigTGMB5jTWDkJe7YXnYCLVkCkFaQMBYc5UzNpUqrAHboSpZrvmrDlYOIBzbsCZFKBJGbOGAFpHgywaMeFGCLNCucgO8zCWJpMVmImAP3kX8E9fmOPurRm+cFOPtDEDU2dWWm9uYcQLjDRHpi2M0EpbyDQXoFa7VtZRWiInNCYbGRz+tSBNzTdVIbhDmIda6T0meycBGcxDu8w/k016StYzdWqziWuTG6nx5MyWooMNoGfAKGlMSfOMU9V3rUsySJVCYguYH2AxYNZvIluW6suJoCwHNJWKM4AZLFtE7M4RtMn3p1TeWu/naqimqXfR9Dp/RbSCNZOCcdhuEPt+j/JqbFjafS1WXHtv5dAGZwPkKpuFhMiboVuOmF4XGbS9tlbPtd/G0KmMHsaci9ZW1AL4+au5bK0G0KOCcwmU6iBG7TJfnRWU3VFDVWpLB0hMcJc1FubckazI0tnYZaBPxYGh4yKznT1rfdaLfhEbO3bgr971//jSxGNS5hwY85SKWpxqilnIp2wjIQwgXgEy1eerXkfASbd8RgBW5nzCrhPwy8/9ZbzhT96Am//55mWP7siSTWMwkHbmHI5NI3Axc8duw4piZq+PwNzWgpT+Titw9ucOZm1nzOahbC9wDBKEaimiAE0RoP3yrI5EBgpmkgyOhUlj4wlIpKZDiosPFBZtKwAlMBKbaZsEdLmEK0Z1Um68AJ0BGzP7q8jeeWp0jY5YxoJlOccR/9+VA9LmJrrNDTBtKLPuUFigLtFKAzLmCsp7MPLdss9byNhCxlwqL7QOYA65B9i8T2zpSJUqumUzfHjnZY95dUkRFaBQY0iV5RYwgPbVw3Tu2Qe8/iHbfL3GNXNWKKQexD0S98h5BuQNYNQlNseZADRJYhWPG8+mmGrVTDbEg7zHqNChBeaMAspJpZqRCOuqBYiXotxiN0YN1MVBbJpNR7U3SnXT7a14l0ARCwh/l+KwIq6BWfc3dH8jHDeA9uGm731+YMT5EAdnNReI+Jz6vxawtrJUkbDCoUspei8rNIdcXbAFIU1PbTtAIXl1Or2xqkb0kn6fQrWYbBPe0l0iMBeAto4akr8zSSchKgBNhJ7ZQdrnnRPwjBe9GC+/+C0AgJ07jsCf/9HFnq9gkARPjgmtObsFZiOnMTGJM+W2bgfMy1pPzZwb8/bVb70aRxx+BM569ll42OkPmwbnqr9EMNadOELBBbDjy4337vZ7KgAdmUeKYiWIGgpb/71J5fjsOYBzeAFkrBlFghiDDiG6csnAoKP0CsoWBe2JsjoXaR9LOl0il6MlIeishk34MtqAlsTi22EpdT1sp3qZU4ZFS+ahnSKYY0yfyto+spzjANACTDvAtIFEMyTqkb3jAlCzdIYs0eqsGXsw4ju63SMgzQbSCzCL+2bmAZllsQtbhQqVaZ4dqGt1PTyZgTJKHGwF0FFnS1BmLACdEiF3hLEjAWdXzELfY+176qntnSELMFOeCTCnWHsHaCRN76kWCTNrUwRmt93Z/avlpJFknXLn5aUfSRU8Cl7PcT9WwjJIL7Pmqc9RxY7DN6jbSODqe9jQCs3bGCsKQLeArSw6vhq7lwcmOK8yVnDkQOxiw8BazM9ChciNHoYApgeWJJodhO2Wl1+Aue0ELY4US6uBdSSAhLLgRTS9k7OxEr+oQpNLWIIBs80BivZGZS4k6zEdw+4kpgrxYbMd3mSHb+zA5sJy9xaCNmXOdjC2fdQgnVBA2Tp9BGDLjOSGAduPI8j+blXDKkCnJMK3S10Nykvsuekz5rlT9SWq90twZM3iI/UBwQPAk4oJj+MxxOzgbraph7Nrk8YxY4G9nJY1p6H+rc85s04E2xbFdOIALd9Fy7oIX+1dPAXMscItNFOMpmN9tayAxEURLv3XZv4IEsKzbCJe0qXaV6eAYYozk6zsJuA8B9OWsuaZMEbqRAEhqFOX2cEWwp55jow9GPhuYdBeFaDzHJnnyFlAmnVVKls60gBanjl0ODYmHbt0mA6LwIxCgKtovDDmzMtcug2pYyY1f1ic8GQ6rAt9USeu0ww5aeJxUnCWZOsARW5qzS2sWSSXmL594QiXVLZ4bqegPMKM2ssLVZQVpQpAR4eqAtITqu0kQE8dnwJnp2Nkc9BitwEVIoHmnfRNdYasCUhqcC6y1vPc6DVnkbbvRzn0wZl9rxWtPqgjMAPFQUC63vLcUfLhby+x9UIsAy7+nV07h20N0LGWROzGtouurU/iAK1qBAvbEZM23NW/mhuBroFApJURrWD2d4mBK97yJhxx+BGYHXYY/up3fhsbVIOzE7uGMcdQXZMNlR8JFeyr2HME4JY1TzHn8JqXAFrB+dQXn4qzf/ZsvO6PX7c9a57qO6452G9jLwrXtp85wzZQJgVkfQjPeqF0J+aO9KrAHVY0KgJWUc6C0kmdv0iBmYYiPQj6MjlIJ+sMDFn8hFy6CTCTzj/Li5H3pSbKrFYZqzBjdEL0b3BTN2rG0llIlLaj82g22xQBOpLqURahOb4XuPAsJ9bMYCQ5AUDCgpnmYNqBTBtItAEycLa79FccwXmBEXNk3sLIe7Tejcx3y35WgOa5AHMu4IwA0LaeM6C5p22BCKBSt9uu7uCirz5YqCujDMJKVDmR6oFUqjNn8mQiQKdWigLMnGYgmiGlGbKtCkIbTd+0QW+dP8ucs88jleDRYsqObFlAWmJVBKB7JNgazGUdZjTMGZj55/p4N7FdNQ9dg3MZ/FF0mN1GQuK4DGmUdm/B2ZhxT6LztmC8BM5kZm05b/eABeclKQ6YJD3iiCNw2qmn4vLLP+THrFh7GfgafBeoLfMoJlIiKEeng3L1aBAvAC/VuILNTXODI8vGPcCEXRGkHtZKkDlnBPaMwqBnkMWJYgeqlG2Wjvih330dOAGbBsxZncACMFegHJizJboyvIjm7ShgbFrV9/Ucdm43460CZ3u1reYzAp+9/rN4yXkvCZ7a1Wuuu4RtqfkNVhxrr195VYeHKnZI1WSCKHHBp/N8SRNCdArQnQK8S22GZpBRcI7AHO6/+j0UmLsC0g7KuZrytpdVHkUFLi3XFLcRoA322Cw4RSCWFmLPWwwWQSq/sNFRwDmD0amgLAKTPWwJNpLUzMoKzJkWILLY5y0QbSDThrJmi+/V61poFI0why+ZW55jdIC+G5n3IPs2sOcKoHUtZ5bkHIgmbihz9uevX5ltI5AssT5C0HQByTpGOt7K+6nC92xrdvBqFRANpaIZ1IUJWZYvUwVyFu5CL6rzzTYRZzZGuX9hzCUuZYQZsQsoT7HlFpijHz4H7+faP387Bt0y7ALOZcLSexAFEUIFoG04GzCbstSlwpINmPvDduCof3cGFh+9TBwj7TjVleycMBm+/+UQB2cgSlT2FyID/Ku33IwjjjgCf/+Jv8fp/+4MLAM06V9FSC4gHQxxQfjE9HBcVfZrR4OdeXyncBwTBr34LBV/LgOdglxmFKcF3e+5uPcbMG9AmHTFnqkGT8vdkVlWVkwZSyEoTPDcGZ59Uq9vAG1ZkKyTTwEz1w26ehsbIL7q1iRRT18ug3OLp6bP+fEJtjx1uPVu21bsqmC0RYXD/B46qwrQXQpaE4dqntkKzEQ4+3k/hf/9ra/jTz/2NzLiLfGIZQtLjOIMxkXCKMMmXyxenkfuvnChwphDWlgUHwcRNG1CiVhLv5XmKyyyjBg7uqzIdlSPQBGoDDPzczDzC2MWcGbaAqVNkLJmWAhRmNe3c2ZkMBt7Ls5hmbeULe/BmAWgZbuFnLfA2Rj0IGs5u2l7DADNiEsqOpsGUNbLLm215GiPMnbarijmWAqzKuXtxTlnNstNSSeGaMHJNEPSxC6sYC1bM69E7VXBmYbGCUxAmRSU5V/ybV+xZirEoQLp5XnmWTg2C8drMzctHZsybUcZLUqfkaKiABpAt/H/Ds7EBXh1e+LnbkZ/9EOx9bnP4n//6JNFpup3tvWpCev2D0zm3JZovCbs3LkTAHDC95zg39USV5hsiwWtCcS2RRxbx43XbQF+yrUMqnOaSDJOHSlhURaKKJPBnJjrAHmzaEZgJjNr+7K+mIFkXofraaqimSvYcrCw6oNzLmBstTNg1s9OyKgIkmjirkDawGGKPUfwngJobmputlNseApH47xG9MJeKuHGgbAfby48UMxdnAJAGyj3yp57+9yAcwexgSUGujDXnAgXvPAsvPYnXwhmxpwW+ItP/78opm8D6gjSysZDSFWc2zZnMF9qFKkCY4lJ1oVU/JiCsukPULlmySdMeHM7f2yfDJSnwdnHaDRh69iJ4MzqAAY1aRNtAbQBSsIEJauYvQsFZ4pqc2DPvBD2rCZuqXscqHPeAw7MGTr3DAVo8jhERnQMq03aHCxeAaB5AlgC25YBo92UfdVkT9sLfTdmciqpODuUzEIS1wyNcyaeIfMM4A0wbyBbiBV6yRZWDbhc+gXDn6UOFC2uXx1q5twy5imHr5pBs8qqqd8aINd+D1Pz060IaSkUw9Y6Y5V/pGOiLAuZEiQKJnHRcRPQPfjBAIDZI79bdGw9nvQ3DsyxHmAWkvsBOC8zHxMD577yVfj5F70Q5/7aq/xXqywMUUansE9ogXnqarYt4iYasgWYqeok8fvlmei6O1UDnXWwk2rfsJRy7GnknD3DwJm9wxuoV8zZwBnFUgZCyWzUgPOIAsxjBGcUsPboogjM4ZoV2WxZ8+rGjk1dwLUtU4AcX3QE5gRMOn5NXdcxuX04A4EpYO4aQJ7Jft8DMwXnPtUvp8vyd8nmmAmH7zxcL004/IjDgR0dYhw0uXNZgs9de+YZYc0FmOVhnDG7kC+rGhkAxJo4sie7jAGzCm5zhOLohaEjg8UJqAXoGpz1n2XlUgUkq2e2mbQ5aa5tmoPNwUlZs1grCnPm0P8YmgUMg64At3CAFuevANJ5C+zbOZjngM87jxL7q+ZtH79u0g6suemKlTmbg5JtAK7trJoKqnXnuQZnN1s5MAeAtly8BtBNzeiRWNkzzJ/aHFLNCpCckJADs0Bk8ce2vWUHsBlq5lzX4rU9Zc5eZsjTwFzM5XW6Tx/CFKQzUWHPZHYdY84kAB3AttfaJTF03frrL8NDfuFluPP//m9iDEt1XZJjJnMOoNwPwBlYJVHf8IbfxRve8Ab9pg6wir81ELbafp7iS9Bz2RmWZ6wjMx6DMCL9jS15UTJokM9Kl8+lBi1cQdpYszuEVeyZHZQto02PYu004RrH+AAV3NoArQnbQNmqgzRqBh0dmo1BG0t2kLb9hjFHJl01eHy13GzR/G4KlONvTP+J+3a+eM64H9Vhah7QVG3fpmC2ttoDMwPlWQHnPgEzs51xAefOwqbkeq983zuwhTlu//Y38M6rLg/grGtWVkkkJLbW0sEVBzCd+GGD5sCSs21TfcyqgwJKpBcXEErBGcq9Krw92duSNfSqBWgfO54q0y4ijJkQwVlZc1qAzbEp9WDzPE7qfZyMNUvnkb7OyBqnnCFAGxl05oUw5azOYFlA2cza4AUQncJQ5p3J2LOZtIHSJmTKC+oV41BbwaIRxHR2VheErJXM5Ti6dVvVHKUW71zy8QogU0hEYiyaNWOYeXubU59cnFCIQV4C5fivMOfWjL0KeJfnnmMqTAulmmLMy5/rY65QkMlbKBiz+8WIwyErc2adupdx0iXVqxOhS+wzUN/6H2/F1nveilkCNmZFH1/KBRHl0AOXOcdSWHTLpyNzjgRpuRiI1/+wtF11/RIiggmALupBBGaZv2GPhC7+3S0wl9xJumX2Jcu8U3OIwwtMuodggAkFK5aOWvtoBcy2qqGBs5mzTTEwtq3yXzDRWUrNoHWsL4NxM39Aak5f6uTbFfs+Phg33xsYtwBdmzSmATpev2XOnl+7Begkpuu+UyBWgLa6YccpZDFgAWYzd7u9OOPVl70LwAI4zETQiJJeLTSoNqLpECWZRGhI9fIjcyawxRJykrzro30OAG1O5A7QkSFmF+Al6UuW1+H5CKSfMhqADnPNxpqrkCkza2NUgNaVqWgh86VpCyBJqMEGzLZ2sb4j748ofiBm3mYeJNmIs+iFMuWFe2uD52LWzoOCc2DOhqAhnEqAutAAz6ZlY8Qqh5rLrIa1s5HynAlpJIw+NRFM2sGszRZ3NYbqyfI7UO6BLCCdFbANnDN3IFbKwSK/pLeYHDLobWG5Tc8ZHVUjMBuTroG5A08AdZxbNmYcAXgq9l5+L8eKB1J587VcKlVMiWZdSknXIlCA9s9qEIt5har9VQA94IDK/QycgX0DaJoAaPLj5PtTwFx+H19+1P6BaNoeYYBftgWcKST0pCYX5RSDrjPw2MIEYtaW9UW1smqiAaSjmcifg8t8s5ufuTZhm+NXvdh4bc5uTdstubRzOwHlci0HZEYxOcctNbV+bcsA21yj2m8Ugea1lY4St/Gi5ukRH7BaiCI1tasBeiNsN3phzRtJwZnlRXWkAB2ktjvsKFNu10iEgW2025Pvew+Mc8i6SAWNEzXbdgKcHaBZlorURS8khSfpPViT5rr9UMzdBSyDN3UcO1TmmplGJAVmUlAWL2RdCCPpQjG6GAaSpfmMWcW4VDZwHiuQZmXRHGseAN2HzjcTm1OYhFJRnG925hz2qTBpD2WPwMz1604+fyQD0JXYBHfcgyXAScvM2dL80dj5GtvIPWjsAVsUI/eg3CFnXaJWQzHYrR2kz2NZGiyFcPHZT1zAOIJkMTdHkF7NmFszdcuGQ1b25jPCtePSkkCVmY1CfyN28oFAFEy3pY4dkC2oInUE6rk4wOsWcXrfANoErJ13Dc7TZRmgIzC3Ut800ALGtm+sl/x3q65WhEsEZzme/DcWO8gKzgWY688llKHKIRZqmWvxMFcKA4HZGfMs/CZiViSpNs+cWUD5lJ/+WfzgfzoLf/LaX8f/uu7aCpgNqCN7rsKqbKsYVs05B9ZKST8a2Uj6lTWXvSo0+63mVV7BNAiv2k7VeM62uKaBwJpVcymunqhcPWdWOwHjTd1u6NYz6TNKmiGT1KlWyy2eTWPbyGLcLAA9Vm8TVSV9vjIy5STCOm4HPT4oix4hjNoBmh2UibOCdMmNBzWBl5z/7oKDTm+qNO+ECYMKa+4oK/BmEA3qiT2IdEwLB+WcJA0lJ81Rr7mnfYlHMmWABfBZGTSPHiKVPdHI4GBcYptlSyHOmeKcc5WIpPQf0r4dHzdmx/TU6RkeRZd0rohG0gg9CaeKjJkVnM06YNYQs4RIqj8F6UHqOBYGLatXGUB3IM+JDrBbP8o60bY0bcxQWHL9w49Nzw1Tta0TjkSwbkGXqv14namIgTLnXHJTuFymeiolKUj7NJqaMsiZMklegL4BZPOvC9WME52B9Bqc961MM2iq9mvXDXut0u3sNROqPD/hrO3ZDaCV5Wiqk+IZYN9FIG6XWqqTflIF0JFB52LiRmHSHdhlvFlLexRAdWFhQIyCV8rT0DPwkkv+FJQSHnnik/HS4x9eMo2hALEq9xWDjvPO0TPczOex2Vw0R92lZcIIfxPr1Mu2bQTfjAMHZ44XjrtU7PkRlC2DQZtmSLLlKygTsKmseVOP+zwEh3MleBwrUgFdZb0YCa07vcxJJn2+4qQFhgM5mSl77ASgB2VTg+4PBaDTSGrqJgHpzKEGYFawsvjm8urYvcJrjcfGCoxnKqvROGhKsMxeCR0kN3aHTCOIhiItU6cA3SGTArOy5uysGQ1AqxsaW55sy509ImYCY2fIxZzNwaTtrNnM2GHOWUDalA2TKDUwV0Ct88lVytyo2EJYs/RdklSbISk3R0uKseYAzDSWOtr3iioC0AbOrODMcCdBFMdB2S9UxaTjdsBpAFvmj8viF6vmlM1UXsXWB2Ug2jOLKdtkUMlN4d7/2tiyLGjQXxuApsQgBebUC2MuDIfN8V1AeSbT+Tatb/6gFUwc4MoXDwhwNv1J9uLnZVbc5vIpLLoG6WWABrwDVGhgS2231G6Ere5c12WgjuBcM+hi4g5r+Ph+6zQmZKwseWmy0vaZa3BOAIb5HLMdO/Ct228vZjegyk625BjG8n309l4ycZeXUbUOUSXPavJa606rQboF2r0x5302bzf3He8nSiEbyD6gAzDbdtMqCjhvQOLfqoUNtLH92QycUXS86BCg1f+J1wssC5iAdzRbGyh3oKF3YE4RoAcDaGhlqQ7Oo4JzcmYFBWlWZzEGRFGo3mr06K6gPABoYc2SrrND0q2A88KBuaxWFbcGzCGbAcl9lRSiuhCH5862JCNli2DGJgVxcrYsW1Ywtm0wGyz3Ievj0QeC5H1aGnWfAkoEIhn9CXAlrDNNNwVyEX0INN2fKVwYApMeE8bcyfdZFtwpq4mxZj0rA6wAMyoJ6bfI7BIzbut5Ymx7bBncSybv1f+WRUFpjeCgSCWzhKx/rZ91moOCd550LQFo9CyZ9tR5h2cEnrGAsgGzbsdgo7eZBlqD86pCzX6ZV25fYw3Sq1YLrQ0me0eHCM7ZvyM/PoCwACsoR7AuZu0By0toFEex6CT2mx9+P55wxg/jhis+jjc/7Vml80dARRhUZrlSQHQWjLJ/weNPwOPPfC4++o63i8OKAX1gzx1KjHSnAO9OYVMArabmlimbGTSK7yr0aqrG5q/l/mqAngLlFqAxsR+7UulCRVJ1Ta089HR/o6mboZbYtzqGxK6xrPcJGA8ABvLkIi6kufR0+0yZRCCPXQ3MY+8AnRZyLA0JyQGayoqVIwSUR1Zg7mTbeHWDo7rK2kjaIahu5MBtUJzEZJtovfZTAAAzP0lEQVRVoFr+ZmHOcZnDeilJW06SKbpT6pUI4VrGnnOoNo8c82ePQLaMYMqWFdBtW7HkCpTNEYndT86VgyxKg79TA2mbCaPyOgEZx1nfYfI4RhtQccqjAWcFaAzlfYt5W5S0MTgDZvNtM7M5Q60eUzpxycHQgmLNZLkZthSOFYZdnLzK7DY5QNcwDdTgXJfyxslj0kj2dU1uF4DEoJSdQccbpZjdqRdQ5hmQNwhpxsgbcJAeQ3A22zy1ds+8tXSD+1Tuh+C8/KrawljWuawb0VJXaiXusq5XI0QrQVvkMJO3mLMZC1DDnGlpHtpM4DV7buegH//DTwUR4YQfOrUaMCX8yhVxFNsBVIja8QDmAL711X/GJ//oj8CrWoFDpjAWpb6zJzVgRo1xKYtyH7Iz+neOry3wta+jbfp2lO4jOJ/02JPwE6f/BH7nHa/Hd+7+zvLf+Y231Cdel7GUUcJNYQbMXEzWG7rdzMqiWQE6fDdjeBCs2T2Njdk8xADQwNNd0MwYAGz+NwprVKDcI40d0tAjDT1o0QtzXiQFaVI2XZhzGhlJWXPKY8Wa3WQLgNREypxklMV58LBrArMAJ6mBgNGRrG6VKIPIRPdYg5KxZBRHsAw1ayOIa1MYuK3KfuOKU7ksblEBM2ewzrezhlBxWDJSuoueV5/NxwLDj7sVPOpSI5ztWzx66c/Stu4sFubUfaCoPwKphQTRh8D8CEIdx+RTIaJcSfeyuWf4e4zVnN2iHGkB2u6o/Wz2yZgO1I7bNgLxsjE7yuzl/BHWj8z+UhImw2wPZq7QBD4S2pmLw10zjm0JbM3dAt4A8gZAuh1NoVZTt6U3sBTIwwGi7P0QnNtCzX7dhQpI10YZCgjQ6n2GDrGzlC4I1IgQ6RxQvLDNbG2gPAeWgLqYueOaVmXJjDoO+m9/5414+stegr//o7dVdxVbwcDYxr3JSMcYe0rSbXuMG5WFCluO1f6mxbkEVMvFVqgdPjpjVmLA1UWxDNCpedApkG2AuU89rvrTq9B1Hf7D01+A7//575/+uyWADhILARzN7t9bzWGbZXka29/IYQ4agT2zfGe/63LR9qGSMzMwcHkZUcPyuQXRtJw1mzl7jPPLAswG0FbToldQ7pRFJ6RBQnnSyIU55yzAnEekPIijULb5SGsvY6i2QJ+MiTLuam5dghBlBFrkv4y2LGyKyEG6jvWlAtAmuLmI5mIuN/CEgm8EaK4AuVDJrPOwBtRcgNnun8u2uk7sSpFBm66VyyvLJAqQPAdpl1ZZxfpuR8icaJK851UMvseoNw5/Q2Pmjl75OWH01WygbVDuD03GM/idhYQr4Xj9m2X9uZW6NReuXcxQ7Uc+Pg3ORbkzEsSowww0IZSb8XI4NQtzMO9rdQTjHsCMwRuEvMGgTYA2CLTJAswK2Kw5cKyaYWcNzktlCpSXjxcwngLp6J6wjApcfW7pW0QEhGMarznJmqdAeUBcBToCdNst/+zV5+GvXv2b2IGMHUEhoOr64bMKUSMz1QDi0BpUWHKFj1SOteC8CuPYzk11S8WLV57dLWOuUwZNM+jyqPVraAA6dQmk87k7DztcQHISmBluAjAQdA1HHygGq/ZN7cL+bCxJR2IidDdzs4D4bAT6EcV1dyyAMeoxi8kxaa9zwgjv07yzSc2gLpQX0VHIgHkWmLOyZzdvk5i2ByhzzkijzjcrMBvzstjnAmS6RKSHeeXq1ZilxZwabZTIr2vuRAbQyEGIm7AW1sixQkzBHJrJ2atv5V5ZKCM4Z6WPGQjPAWXLAbVEdbBzRWAO1/PxwE0+wKBrGUDHbmytVfowOYrTSJqRqoAzQQYMWVVv7+KRT2U7UPBRsHMXpTmH+7frxyQz5pkfnzDKoxagY6FmL0Jza/yOsrjEp5B628jd1EM73AdF8mLfymS+peyMTmEyptQ7XufuBKBJmbMANG8w8iZAYTqKDaR1/tljohOw6CYaYR/K/Qycp7rC1PfLuhwvdYqapvESbYvIEBEilgjOjMJ4W9Y8Bcytc9gY6r5AYbmHeCTuO6ePP58AarPYeqtQsdz6XVAQOITajGfXpfpSQG34twsvzf9oR+fgcFEl0p2aXYjPFZsoNNk8z/H833o+fub0n8H/+Ye/IQOttcWHuuvoY3HVJZ9E3/U49SXPwhe++hWo1ILHwViGLwflsdSYXMRTIjE8fad5a28oOHcj0A1A0vdvc58Wd2MOSeo5bfkfXV7b3K96b5OG1jgo2xxzAGQHaGPRAZyFOQMpM2g0k7aYs1PWJU3VAQzMQSCKs5jAqr1xNZuSAXTNd5bnJANIazw1YNqbzY9GYIZsswhbY6j+arWzCu6y7hekZJs+sPbVZ+IIzqqEGNAjAjNQ7S8n6pX7MV0qwdZ+gjtMCjCbwkP+yqHLRf7QmT+Js15zEb7yv67Hb/3n/8MHAUVLSeX8J8AM9bzHSO4kuCxS5Lkyl0FTQDkOjDK4oo2gyJtWuLQychmY4yy0bWPqpRKnUmDX2nEMntnsU38lbwQbW6ZR5QxN+LTkStBxLyBtpu1sC3ptkk9Jmbk7SbI699wmMVYcULmfgXNbWvZs27a2ZpPoO7jKy0c+p9Tjllt/C8ccczjO+62P4oILPqXXaYEypuZczZp50mt7RA3QReiVjhj/YWK/aOK2PjWaO7QD3jI0ZcxvGHQL1KQyLQK0XSd8bt+A7cj8j1zINNjKpN0CdLyxKfY8JUfC9gNXfQAfuPIDcuHNib8JN//K//gKHHfMLgDAa3/xXLz4wrMLSBrl6HKpDsgBaGvXeZQEvtSYwzPQD/I3pO/dwJlCVqpsLDrcQwyqNUY7UplvtvnHwJ7FlB0AeizsOVlI1QB1CJP55uTCvzDmZKCsjNm9m5EUmttszWX6w7z8Ywx/FSPBJsYVxJiwNGmrHcyBme0nIZzKwDQDPLIaJVqADpXLcQrAbABG2tmcjQNuzo4j1ZVXFKdLmUMuGR4p9l3dJjM3x5VmCHj+f/k17Dj8cDz2pO/Dwx9+PP75S7cEh7yEbA56AYRpNEWN3EQ+reMLMCe3LISBE3KJFwuCqSCt1FlWyOVzHKjRAbekEomEqA4WTQF23QPB3wNgUyni4U/q5kruozDIPUxCAcuqbsH7tUpJPmPx2N4Qh7DWodPM2zFz2LA3zriiHCCmH0oldoJVwLwM0JExh7xboYPI/hOesAsPe9hOEBFe9B9Paq7X0jXx0F7FnHmFaTsCc4nJrId9q7cuaekraotBVcupnI/zzkuqiuKJ4yaj5PBuWrOa2rGWUpZnAB19W2q6jioBwNLqHtH7ecoTehPAjmY7tW91k5sKvO1Dl+DurT3YWszx5g/+ce28Ncs6pzxOALOy37SQ2i3Kvtd5/b3XQbYG1HbONIJSMHu3k/hc9AbpeuTmTAHmANCLDrTovaahR1rMpA4zZdMz0NjUPEPKM6TcSzILlpWNiONqvmpiVcN04mKgXjZ6lMiD5EAfkp2YQmKJP9RJy5ZvhC7nyHkERt0fB9kfF7qVz7ZvS0DK/giMIziPYNvmUczcYR6adf6ZA0CXueWyL7jOjvGjATOHmsV9YND9cYyVZKuLYGVL7b0gYEH42J9fipwzvn7LLfjaP92ENCd0i1gT+gWhH6TOBkI/knSlkcSgE3TJLotVxNpecoEH0zAX83DUcGsZ1C6GG+EaaOeLCzBHMC6LSYqcnYGxAcYGstdNr2NTB2zUlWYYaYYBM4zUY6QZMvVaJTY+UxLnupQkeU1HYM9dUOQOu4nb2DKJg9hmqeMmMO4IdRMHVO6nzHlKVWlZ9CrmPGW+Xl2vufZ2XHHFjTjppF149as/gnqWxXTEAs4x+UgN0uUzV/slB3dcJKNeMbpsLSdZrv6yDIGoNsQ7bYG6baXKEUytsvZUPQJbRsOYjUlQmVu074wxLaX2DK/D1o3nSiPAcrhRF/62fQV7Yc9LNz2ltWTG9bddj8N/8qGQBCCdZPeCMglbhCIloZe+llxZWaogkdKlpHYvSnVDu/OKsuSk/SNpv8hKYaOjS7xpZv8opyEl36SsOQD0IgX2HOef1VFs7JDGkoxEmHPGT1/4k0gEvP+V7/Y5ZspZ6YV4b5fUorZVEyZTszLWstHDXl5cBQvKzr0TualGtmz7I0l/GaVz+Wuk0CVY8Bwjg4d6KwPImDOcUZOawSk7PQ7mbFTMWYz3JXmpSwDGkvShHKxHoct1cGIKZtJ11sl94P76D96Mv37T2wBsIGHDAc9WEMsMjMae23VfA/EtU+qSqz86xlH4EZtyZGDMLTDHqYliOYj0xADaJGMbGbMM0F0Aavk+e006FVCkGptyR6Py6xiOOlR9zu4gyh5yRhKAOQA0xbzI5smt3trmwU2ycqkz55xxQOV+BM7b2Q5WMec0sd0OqCN1K8fPOOOd4dgyOjAY9YIWBaBL+s5lxtyCtDHnjLIUZfkUOXVcUkPOUu6KHRitFVrciq0WW8Ucv8w7u6cG4zjITBTAjt+lcD1WzLL9uCDG0oV9cKDMPbevYrup/1Xg3B6fqu1DmreMTWIiFYC29E62yGsEZkJguNG4GQxYYY5vtTKnSTHM1O0sMjuokIJU6QjmzCWsyxJSVCxaPbRL7HOpaUz+eD9+zrPwI790BgBgz9e/jf/539+r99BBMoR1K4DZnpPgKa+0SbzDGdCDAxBDgTm+E+lQ7HZi0uaQOWYMKIlHDOAonM7AaQQwsDeng3O1ZZ1FkHb11Ja6tWQr8dbMSSzr89nbdGtRVDqg95IgSob2WWYZa8jQpBYC0LLCWDE5CbCTNp+cVe5BQHmMSmfoywbInJXtZ4A5qyk76yImRcLUrNlAuaYG7ZF2aNWL4sYsDVNzV2UxydZymdFh1PlpmxKQcxajtwGzLNYxlJzk9g5Crc2ErMd1P5EkJdFbtOxhJo8QkpSYUxhm8FzbvE7f2ZZWF5/a7i8w74tTWESH0iXLfHNcfapmyzTBnj2toMNuBOYalI0pD96FocDMVXpX08pbJh0HUduKsVV6FNmUEQB44jx7wz0GPGGJa7BBri+FUbXAPJt4FS0F2xvoLtUoyeNDMnxS3QGa4fOeJrTSWANz1fVMKgYAK5Ohel8ZJYRHzLWgAci6b9mqsm1H/xsyYHZsF9AiTVQisdFq3l5oDZnA4Dm1zcPXkpVYLCzwza/eKXOtRLjz5js8dMeehzmEGbp3X2mE2MesqWMJuAeAC7hGgDHtLysgd6xMmGp9wOagjcIGbZS1jXhgH4q+HwHa21TuxfbtRiOYmte2X05B2B2W7JjdR3xu/SMGAJKZUtNaOTxDSvL4krlTHkohp1gYHKCbvq4KJjMj6/PkLKuJCS7Jvsd7Q6cOYJ/LfvF5KfIoMuflFestlC2GQbUrBCzPXXEwlRlIZ/UHGvWlMsidCgswjw7MltBEwvCCXCNJVJIsIYnVxKCUkBJrMhHy1JypY12unWQxDAdpBMCGzFd3WGcI27eyikG34NzOlu6t7isqRKk5IK5KFUGZVTq0wJxhq+hE7sxLvzTYN9cKCvdjwMzN07d3GlsstkQrH/v2bxW/bNso636uauUq3Tp7JlROYZgybS/75tWGi+3Y81QFGlAOnwMQlG3WB9QtkwClaRiWb7tqZDP7KjjnhLIeJ9VMLYZQkaIr6wSkT0Tq5KSBuU9kItQCNqTAjIGARdhXoIbNSS+tUEXiTKYv9NPvvhLzr38bHTE+//6r0WVTMCT9I4GcwVktYS/FESwz1TMJ1vzu9RzMxs70UPZH7RMjy3MkAVcBe/PYZl9+NOpAdlF2HVnZs/tfGjDL+XmEmLO1M4uiYADdsOegt7UAbWMKE/veDXVwMBfdrYsDNheFlsKZDKbFtA0PiWoHqAFzx4zMWSxhTArOwpizzTVr7nHVfCDAHKfWRAqlBqSX+XUB6HZ1eiCGpZZ5KwqVvRYGLQuPxv5lZ7R1CIw1W76xSMfktwj3Lg5j1ksNyEnydPtWZJNl//Ic6ElklG/begDlfgjOrVRuj60C5imAjh5Jq4B6O9Zs29hVo+RsgbmsQlUbpqPBujZn12n7C2sud1Or5y1Q7g2gW9WlC+eYwrAlJd1qAGo7l+PgCoCeNGho558Mq9rOtG2vgpv99rPvx4cyQCY1cdo2C6hOAnS8j0D7OEOy5CeJsRhTAebBniHDTd9ZnL8qb+1xBAarOVQuYKwxydC45Ag6uhxyYNEowDxQWeTCvXubkBsmXPvXn0fHI7pcwpek/eJWXkJjndbTxLxN1l+4DsVTwDPHqgqYtWJUAEsMHgpaMcJFNXY19gnLuGntxSPCjBLXQ9QYehbWbObt+FDumdw+Ky93ResSNuiibhiNDa5INOLKF6FCGDtedTrAzseh/ykwJ47ALAw7eciWLmACXcTEATrKLWl4W3KTJix5U8xZbidmbKsHuDgQysAmZ8syoUshr20N0EXKFdYeWXMHW+LS5Q7gTNnvSF8ogUGUkMjkKKGrANrYNinLNnAmYd5R/ug2tR1gH8v9EJxXlZZOTYH0FGhPsemp4y3MWSlqepm3GVdUY8yrTdptx9eVaNFBOHe5M156YkZhuvGuw0yg/65tIXvS+P3UU7bgHFWSCO5Jt36NKHR0Gzs4TzV9a+7ezogxdeOrHiQ+UJw4r9xtbZtVXlED0HYPoWWM4eaxALMzWdJ7N6GhNDGb45eBcxZwXozAIgOLDFpkYMECKo2TP7nJVr/3fUzXVgbbywsv1IEz7od2MzwAyvHYNwSAy7pt0pwq/ql4N5fKJeTYYpMdlLXJiTQfd+iLBuIhPMBfNQdwt+et2o6b9uC6Q9szN2hsXSb2KQNj65KjHQxts3LbgHO0NBFc/wlPrd1HbzBVwKxzsRyrMmaQeMdr6BtZo3Ato5jrztFOtU2ZtEvXsfnmwpxtEMfVmhN6EGZIWgkbWg2so4NYUp4Lv7aZtDMGJCxgaWvKa+JwNzWnt7iCrqltPvA6x2QUIMvlQME57f0npZx//vlO9a3u2rXLv2dmnH/++di9ezcOO+wwnHHGGbjuuuuqc2xtbeEVr3gFjjnmGOzcuRPPe97zcPPNNx/Y3XvZ7umn9NbtQHoVCqwC6UiRKJwTmJD0cNNQAOkpj+x6JjlP/DO9tYZzM4ovB2ctB2pFWRSHXCNbtsXDVXXbCQAKrRcFDorgmdKVaNXr2W4WYir8qg3DigtPeJ5rNKFWrLmvoRm9uA6l6jMsxKmsDqEKFy9KHefAuACGBTDMpS60zreA+RzYmgNbi7KdL/TzULbzsdRFrsAaFVhz2W9ZYTSjtzUzeJQKZYvFcajsZ6swgslha718oocbIDe3Y2nDR2atptPo+Uy/UYC2aXdW5YMHBi/Cc2vlOYPnAObQLUu138zZFRhesK4Qqc8fgNnXuAgptLitNobszxhhtAeredDxhrZmeJjVmEMdZWtuBjGSrCgR3Czrybqsp8WnawIZX+IzVMRt9IMxYK7lUjvfHBk0B0lXgDGGUZUBXWBQWHNC7+Cc1Bs9YVNBugxQxg6w5kS0OmIHSljVJkZsaJ1hxAwZM2TuwSwAD8ha1vavQ0LHdieEngkzqwjRkzb025o1vFRrn3FAZb+Z8xOf+ER86EMf8s9dVwzqr3vd6/D6178e73jHO/C4xz0OF1xwAZ7xjGfg+uuvx5FHHgkAOOecc/CBD3wAl156KR760Ifi3HPPxZlnnokrr7yyOte/Tdkf5jxl6m6PtcDcgrLtF92xHqaWyrOILZowY0+bs8tykSNq1jyVU5ubmrG9Ud4U+/h56u3E87VPGatFtky1ZGTQdsGKFezNsBGpfXuBtiGmytR3zooIbmstqFKAzuJgIi0yUzgYPlOfVcqmJObolFDW4jXNQ/tNDIz1OGYziauEHhSA5xnYUnCR9OzCwhcZWKSaMS8CQLdVQUgAOZcUljlrMo+kgAwHZVIP8aw0lDiIYTaOEryYG4FdDKSN7Yg5TMFzFROcSRWFMRgqqAZEuR0JpzK/u2LF0NernZWrGwjzzkFjZdOzVHtgnXWwx63Cy3Xf5HEK+233st+7+XqqcOgagTVn3SZvY45nBdhn9kusMo++n5whq7zwrZkTGjMKL5MHNDKqBunWGazi9qjN2WZ27rT2oc7QBYA2Bk3uCWp8VnpbSW9sYB8dEGUvVepiL+2ADk/4iz/Dju85Af/8m2djz99/ED1n9EwCsAzNzkuSIc+Gfug/3pc6+OwWM9DdW+Dc933Flq0wM97whjfgta99LV7wghcAAC655BIce+yx+NM//VO89KUvxR133IG3ve1teNe73oUf+7EfAwC8+93vxiMf+Uh86EMfwrOe9awDe4ql0krkKVCe+pt9AewWjFtgBqahsJiB6rjnabCOSUZKLbCdwnZAca8odxMEUSUgpVqcshFM+35qutaevJUf8Ql7w7HwRC1jjgC9BMwBlA2YI0D7fmDR1bz0lOFj6vW0XWFqa5KQUczaRutMZiWgxMNYy4ZGMmkEBrK2HiUJYSIS4GwXuDZ0MdN5n00ilBPmQKOM8XkFMKcA0gxeZLnmIitFq+mYs+Mxg0ejpQzOWavOKWf2HNWSOWpEVm9e8+51MaioNR37Wnr2yIxM7Ay6uEJW+kJhzCTm8FGBOds2gDO0CVlBNHa4yit8Ql925zBXvuyzOYQ1f1PrIUs6eegVy4Mn9jcOn63PxI5qwMyiz5lFgsi8wsuSHlTdWDHXVgANmROwrivH7eIZVGkoEh1QnFSH0mANMCcsv+daEpLfLUDhXwTmTv/16AIwdw7MmwrMMUyDvJnkqgOKMbo0Ypk/n8FkroX+HfnkJ+CI7/s+AMCxr3gNvvqJv8GMhTX3TOh1/eyUWRZ3cYWNQ/8hV/A8pr4DZvdWKNUNN9yA3bt3Y3NzE6eccgouvPBCPOYxj8GNN96IW2+9Fc985jP9t5ubmzj99NPxyU9+Ei996Utx5ZVXYrFYVL/ZvXs3nvSkJ+GTn/zkSnDe2trC1lZZFPPOO+/chzudgpj28z1RV5UIh8sgbVpniX+uOzw1HT/6N4rftuiLtk2AhthPJ5tv1YW2GkAD9Rx0xK1tlHt/umhNNoBugXkSO3m6RVv5tbKs0qVWvbLtjk89WGZYmI4wZugXCTqxKZ/tbwgok7GsE5GNgudrLyNoNqoA+JKRStMkwFauFUF2IeZa2orgrOBvJl0DaP0bHnMw2QogG1uW7QjOCZxHOIHmVDyQmTG6R5Z479p64wievIA4HUXFMlPNqNwYQcWhMZp643bMXHJojKXZok7jIUcmMFV2c2hqe7cemrVE4blizva955rRV+Hrj3PA1NBRM6sCut3AAdfKWfWlzW2WXFojqxMSWOOny3pfhUEXUK5TbZYH8qU7wd44hTnXwGx/s5wMySbW5FqtU1j9LzZPBOdU/SvA3DcAXeaey7yUzTsXKsIqdXgJnEVBSWTm+V7N9qIQ7Ln2eiy+/i/oH/Jg3PW+P8MsEzaygPIsU5VFjTLcR5PMyNBBZq6Cb4P1r417A5xPOeUUvPOd78TjHvc4fO1rX8MFF1yA0047Dddddx1uvfVWAMCxxx5b/c2xxx6Lm266CQBw6623YmNjAw95yEOWfmN/P1Uuuugi/PZv//b+3Oq/sqyS4O33U6XS4UNt1e6aTcfPNNnFS+e3zENjpYtGUG5U+BV3NKXw2zlaE/fUNp4vsvHImt3azGWuOQLxUgvbd1Hg7W/ZV5DeDrwNYRkBmDlMlNvP9EZZqZ1hr3kFuf3UvJcySuISoLLLullDEWlpPWdFBVsy0uaUbQ51i3QeNQHzDPZwKS7zsY52ypwjMGu6ypwTOKfAlIHMGWPl0as9MMxTLvVpruciGTpvTGHihtmBuXIqVyAacsBIKqbt5VFTBGJxBJM/XPLUtv9Cm9fm7RXVADq82gjQS+eGq2+FQTel6uM6AAw4625ZwiITxzZgvUaRDWbO5qilBNO0qfFy3WhWiFpN68VSO6m273rZPgJEUC4lrkFV/KgLMBs8yz8D6eQe2wLOlpwku5SBKyZsL53gd1EUC8vDqc5nnJA4oVsscMPJP4SN2RybGwtsbBA2WIBZUt0TOgt5NL+NEPEAjX12ZmN9qwNm90ac87Of/WzfP/HEE3HqqafihBNOwCWXXIKnPvWp0vRE1d9YsoLtyt5+8+pXvxqvfOUr/fOdd96JRz7ykftz6/tY9saG91a2A+a9g3QL1nH2poCygPAYBmIcwKuegpvt1JPHv50CbKB4W7dPbMf3NU3L1LRwe60lHSMIw6WmXlVWgfGU+8AUQBujNe2iWlQCS6bRMgdtbMiYSQRpUvRAOX+c07Yk5Z0pAwER4ny0zSPbcuBzVuacK+YswJwdlCNLRpVDugPzCGYFZmXNMsdMWmUe2BgzYyimUhOAXPpxDv3XqwN0wD1mDFREqPuukc05s6/iNIYmyyQ4UjlkqQ6EFIC57WirhuPURPg2w5W5GEm8f6K+jn1eBdCVPhi6jiuxqhea5cmms9r5XUJR4lPQOKpEvhwnlrjSXPxsHJAn2DPqcKoC0u3U2xRbXgbomjdHo3aB5MKe65jnDVjMs2VzyCjgDE25xP5U1g4DzF2V0IFYr8gJHSd1/ErOmjcyabr8YMbWsMPix4FayMV3qf2I5ite/F7KvyqUaufOnTjxxBNxww034PnPfz4AYcfHHXec/+a2225zNr1r1y7M53N84xvfqNjzbbfdhtNOO23ldTY3N7G5eYDZw/epTAHy/oB02/3aUc/Vfpx3rvcLkNtAa+fsYm4dx4OqrmLQq5881oyCWYxlE3c81oJyBOe9gbFXDkLIhJMJOjRAvKpixbFVD7qvNxfP13rMmR3VHjjKPGvFmEXCncuyThxaRdma3LOVRDqGrxNtD2VU1uOZubjeb5F4Ii8AcmDOYtL2sK8Mm7cu88o1axbmHMFY2IVdlsCQXMuFORd2VgAh+u22Ijy6PNYOYM2UL4fjppvkwt1Ym8S34V25iTFUK7FfRcvvEkDHrV7QmXLT36zbtVYfY8/gFQBNZUOwNhbFRBYLse6lfiYUPOQVmpa3Qa7Yu4K5jmqCFu3YxSzM4f0NoRYwnmbOy7KqhujyoHFVsRi2ZABdXMEElg2mzXfaUnoyZsgKtBIARUGORk0si0KiabtkYZYCzMmBOaHPSczY6pltZm1bC927eRt+uMCys47JhoQDzhCW9v6T1WVrawuf//zncdxxx+H444/Hrl27cPnll/v38/kcV1xxhQPvySefjNlsVv3mlltuwbXXXrstON87ZX/BuN2PIzVPfJ4ywpUtN3833dnLNzaE4rCb6jex/0yFtNp2yTzYtMwUrrWpWfw7Xu0JPoWDQCCkBtBtk7af26ad+u1U2Q6g26xjcZktZ7OowTMCaPSsji1qTly2tQQii1HDoTQ0amuUMKk9ur/HatYaPm9Z5VJDWBB7+JQBNLvzV/HGjsCsTFhr5hGZB62yP7LEjo48YIR8HjFgtH8s2wEZAySf3YCMhW6lirhfsG7BFRBHI2oE5aJbsGc2tZDxKqRoWK5xEHAbQ7hqYEwBc8OYrZ+1lpxWOjAQk4ktSwRTOsKxMRwfHYib34dQNvZtbmoAVX234CItvLWXGquWEHXWwlwB9Gpg3m4IGnOOccXL7HnmWzN0z5RRz6r5aIuNhnty+zJSiGZsxCspMEsNIVM+34zgpQ94Jr8BsFS4S7Gp8xX1AMp+MedXvepVeO5zn4tHPepRuO2223DBBRfgzjvvxFlnnQUiwjnnnIMLL7wQj33sY/HYxz4WF154IQ4//HD8/M//PADgqKOOwkte8hKce+65eOhDH4qjjz4ar3rVq3DiiSe69/Z9V9qutKprxe9bJGjp1nZ1FVC3IB3NQ+adWfRDY86rGPSqOgWYCfUdxlIBaTi+CuNWAXNkzOBlgG5B2c3YLQDvrcbX0j5E2xDbhWCZZLUDxoA7BjqqNZFJ02mW35tLMQgeC5Ma5uzmB6NKXE/Sg8v9ZATTNoCBwHOWNJxDqueZo/PXmGGrLAkgByGuebGZNdVmAIFR03KObPdR1EKCpdiaSpozYdZGzb1aTraUgRRcQo1ZQbl53R52bNXo6pRJu3o/qIfgdrXpY2bStlOZpcctPhPdAShMupUG0YxtViy3rQWmbI510fNd5EHxmC9m7WinMIO4zdF2Erfuf8UobycCcgHmqLGY0x817DkOwOkhWEB5VRBV51v5Z/Bty/UWJm1rPavM46wWEtb7DBNs3IFIYpqjI1oHWgJoZ8ytVatlzx2F6afwoJE53xvgfPPNN+OFL3whbr/9djzsYQ/DU5/6VHzqU5/Cox/9aADAr//6r+Puu+/Gr/zKr+Ab3/gGTjnlFFx22WUe4wwAv/u7v4u+7/EzP/MzuPvuu/H0pz8d73jHO+6FGOftSqvrTn2/Svq3ULaKNdeSoB0ScT+e30Ikls3b9dkFoLcH5FWEcUpFiC0xZe2NZu9V1uHJfa7PCS6m7cmmDsfa+ebq8xR4x4eIZW8aSmtPaiXsGIDZ5qFNqiJIbHAAZtuqGCfAPeTaruImiQDO8WEMpaKQ8PhmLMcvW4x1Tg7KCCZtBJAWlpyQeax6qwCEefQaACg4cy2w69jXFqYDQHsoFdznrnhuF0B2FgkF5rQapN20TUWPiplFvRUDwDZDczUo70VBdIAO2/jaYrHTxS4m41qc7nxcUrylYl8TsI5wGKVD7S4nrdkhgrNNBcSbK3DfemZHP5h4bm7uqr6T+uGjI1gcgiXoKWbkMtO2MWkKIJv9c8kSVq48oiSG7UEeVlXn+hJHMNKaPNmIhU1R1Q9WgPRgSjqmwdm0sHvDW/vSSy/d9nsiwvnnn4/zzz9/5W927NiBN77xjXjjG9+4P5e+D8uUdI/HbXTSxLH9qwWky/nlzNMOFsVJrHT21jSWJraR4a7i7qswrd22wD+FeZEt23J58e9XXccaYClUZR+F5ZJ8WDr5Nje+dGMq6aPtPk0B9PKfBYmK4hym6JGBep1N/Z1JZ5PUfg8ofxeFRONBilHYMTVLHhodZl9NqzWD2lwyhYW3JMewpUmMWbENmAm1AK+XNW0hu0BG7KuV/5WBdfhsTeUe2anst+83NrPVqk+3Q7UF4e1AOfxdZM/xO7u07bdl6vLUfE7hVccu0koNa9eYkCTAeGlxji1Pev0odTj8Ppqta4Ceahiu9upnBOphEdlznH+Oc88FTuUz6cCzECmYkgEJpZK+yVX/rNeKVp7OCYnsyqlcl/V6bAESptWFhp/y4Lcx57KDisCyTrBeleqeKK005xXf7cv3EyP5AKu94/bo1H6U8an53JKBqcG+qrTAbPt7q2CgdcRfCcrNoy95Zh9o0049THsTU1qGnd/NBPowS85jHLSOoKQ5kgDFIQzlxAb2UYJzc83WW85fNGvmqgDMLk8J7r3lL5nR2n7ZKhgG0ibEa/dDuKlbwKL0HkId+mdMqvUkbn8R9ZDRYp8Z4sXNxhi5NJ02Zw77ng3MfqOAXWmrU+/a2rHtP62Wup3yN3Uue2VY/bk9vs9d2Z7T/sX2WfFPGqcwavjW3oIVu8P4XXxj9d/ZO1629k09SV2mFHszby+buwvXtW8FiA2YpYpDGFCcZeV4e7bI2/2MGh4obiOETqdvll7AKqtKC9Kxr9k4Hic6wD6UNTjvV+GJ/bYTtvtTv9seCttvCgkof7c9HtVDaUrObGcF3humcfM59scpvGt/u90Dx9/He1jJntubb86317KtZrG33zGq1GZo/y6I4AjU9sOVORvjdblmzsAyyzZArmimCRgOwAz4MowquKMABwSsfRsEe+FlKMe4COoGOvyvWvG9d6Po9KPJo2jfb3Se2DQwgG7LVFPHv90bEG/zqvYGwFN/ThPfrxqLst+Mey5ti+r3U4BZv5EC1iU4M/5qO2kRgd+25FffvqnKEKFJuTDBcxEZdoTy5KBM1beFly973VTAbDH7DXybrjxZJzvpihoB+YEEzrwk1PYm5Fa19JQKpOle3FZh6eFalcj+pp1wsO/M27F14dtCWYoiuvtF3+nlUIUgEgGUmOd2CBPKFMe2gLiihdpWsdaYesrWN8LyYSwtrpHVRwm1921caTGPIlQ5bjUNXr36EEpITLzpEfCsfNHzus2G0i6KMXU8Npxdwx+U61e6ZZUlCcgWa6wx6xywbmUyFT4hau/MmPikN10A5irLRXlmbl+Cdyl2h7A8ZGAkUB7BIyHnEVmXhMyabGRklLA2BmzNaWad02MJmJIpNksVGzKDBc9fVl9tWzOtzgqfMWL0T56IBDZjuByBUDI5a82QeWe9zZzgc9FuGKCmovQbju24r4J46rvw95X3NvbOnt1sjRpKjfSbg2fWFq2ZoRly4zTCgF4Ba8SIVNla4zCR9h/QY0DSWnyy1R9f39EI8bVfIGOO6G9vf0He+aQf5PCXY/jlAmUxyDmyzhyPGghl69rL9UbMMGCBHgv0mOucc4LRE8mQOEAWsuj9GeT+JbKAMQfzAkR7kCB1hi1sYAtDnmNMc41EWEj0QR4wjiNGGtGnDBqzRF4MGb5SnI3JaOKLyq+HQqISmHeqQ9gybm1fDklw/vrXv77NtxGsDp2yDwr6oVXa13CA2uPBX3jF/n1zF4d8/7mfPMiBP8ahKb8O2nIQNeddd92Fo446ap9/f0iC89FHHw0A+PKXv7xfD7su08Uyrn3lK1/Bgx70oPv6dg7psm7Le7as2/OeK+u2vGfLvrYnM+Ouu+7C7t279+v8hyQ4pySmmqOOOmrdye7B8qAHPWjdnvdQWbflPVvW7XnPlXVb3rNlX9rzQEjklOvEuqzLuqzLuqzLutyHZQ3O67Iu67Iu67IuB1k5JMF5c3MT55133r/xYhgPnLJuz3uurNvyni3r9rznyrot79nyb92exPvr370u67Iu67Iu67Iu/6blkGTO67Iu67Iu67Iu9+eyBud1WZd1WZd1WZeDrKzBeV3WZV3WZV3W5SAra3Bel3VZl3VZl3U5yMoanNdlXdZlXdZlXQ6yckiC85ve9CYcf/zx2LFjB04++WR8/OMfv69v6aArH/vYx/Dc5z4Xu3fvBhHhL//yL6vvmRnnn38+du/ejcMOOwxnnHEGrrvuuuo3W1tbeMUrXoFjjjkGO3fuxPOe9zzcfPPN9+JTHBzloosuwg/8wA/gyCOPxHd913fh+c9/Pq6//vrqN+v23Pfy5je/GSeddJJnVjr11FPxt3/7t/79ui0PvFx00UUgIpxzzjl+bN2e+17OP/98EFFVd+3a5d/fq23Jh1i59NJLeTab8Vve8hb+3Oc+x2effTbv3LmTb7rppvv61g6q8jd/8zf82te+lt/znvcwAH7f+95XfX/xxRfzkUceye95z3v4mmuu4Z/92Z/l4447ju+8807/zcte9jJ++MMfzpdffjlfddVV/LSnPY2f/OQn8zAM9/LT3LflWc96Fr/97W/na6+9lq+++mp+znOew4961KP4W9/6lv9m3Z77Xt7//vfzBz/4Qb7++uv5+uuv59e85jU8m8342muvZeZ1Wx5o+fSnP83f/d3fzSeddBKfffbZfnzdnvtezjvvPH7iE5/It9xyi9fbbrvNv7832/KQA+cf/MEf5Je97GXVse/93u/l3/iN37iP7ujgLy0455x5165dfPHFF/uxPXv28FFHHcV/+Id/yMzM3/zmN3k2m/Gll17qv/nqV7/KKSX+u7/7u3vt3g/GcttttzEAvuKKK5h53Z73RHnIQx7Cb33rW9dteYDlrrvu4sc+9rF8+eWX8+mnn+7gvG7P/SvnnXceP/nJT5787t5uy0PKrD2fz3HllVfimc98ZnX8mc98Jj75yU/eR3d16JUbb7wRt956a9WOm5ubOP30070dr7zySiwWi+o3u3fvxpOe9KQHfFvfcccdAMrqaOv2PPAyjiMuvfRSfPvb38app566bssDLL/6q7+K5zznOfixH/ux6vi6Pfe/3HDDDdi9ezeOP/54/NzP/Ry++MUvArj32/KQWpXq9ttvxziOOPbYY6vjxx57LG699db76K4OvWJtNdWON910k/9mY2MDD3nIQ5Z+80Bua2bGK1/5SvzwD/8wnvSkJwFYt+eBlGuuuQannnoq9uzZgyOOOALve9/78IQnPMEF2Lot971ceumluOqqq/CP//iPS9+t++b+lVNOOQXvfOc78bjHPQ5f+9rXcMEFF+C0007Dddddd6+35SEFzlaIqPrMzEvH1mXv5UDa8YHe1i9/+cvx2c9+Fp/4xCeWvlu3576Xxz/+8bj66qvxzW9+E+95z3tw1lln4YorrvDv1225b+UrX/kKzj77bFx22WXYsWPHyt+t23PfyrOf/WzfP/HEE3HqqafihBNOwCWXXIKnPvWpAO69tjykzNrHHHMMuq5b0kBuu+22JW1mXVYX8z7crh137dqF+XyOb3zjGyt/80Arr3jFK/D+978fH/nIR/CIRzzCj6/bc//LxsYGvud7vgdPecpTcNFFF+HJT34yfu/3fm/dlvtZrrzyStx22204+eST0fc9+r7HFVdcgd///d9H3/feHuv2PLCyc+dOnHjiibjhhhvu9b55SIHzxsYGTj75ZFx++eXV8csvvxynnXbafXRXh145/vjjsWvXrqod5/M5rrjiCm/Hk08+GbPZrPrNLbfcgmuvvfYB19bMjJe//OV473vfiw9/+MM4/vjjq+/X7fmvL8yMra2tdVvuZ3n605+Oa665BldffbXXpzzlKXjRi16Eq6++Go95zGPW7fmvKFtbW/j85z+P44477t7vm/vlPnYQFAuletvb3saf+9zn+JxzzuGdO3fyl770pfv61g6qctddd/FnPvMZ/sxnPsMA+PWvfz1/5jOf8ZCziy++mI866ih+73vfy9dccw2/8IUvnAwJeMQjHsEf+tCH+KqrruIf/dEffUCGV/zyL/8yH3XUUfzRj360CrH4zne+479Zt+e+l1e/+tX8sY99jG+88Ub+7Gc/y695zWs4pcSXXXYZM6/b8l9borc287o996ece+65/NGPfpS/+MUv8qc+9Sk+88wz+cgjj3R8uTfb8pADZ2bmP/iDP+BHP/rRvLGxwd///d/vIS3rUspHPvIRBrBUzzrrLGaWsIDzzjuPd+3axZubm/wjP/IjfM0111TnuPvuu/nlL385H3300XzYYYfxmWeeyV/+8pfvg6e5b8tUOwLgt7/97f6bdXvue3nxi1/s4/dhD3sYP/3pT3dgZl635b+2tOC8bs99Lxa3PJvNePfu3fyCF7yAr7vuOv/+3mzL9XrO67Iu67Iu67IuB1k5pOac12Vd1mVd1mVdHghlDc7rsi7rsi7rsi4HWVmD87qsy7qsy7qsy0FW1uC8LuuyLuuyLutykJU1OK/LuqzLuqzLuhxkZQ3O67Iu67Iu67IuB1lZg/O6rMu6rMu6rMtBVtbgvC7rsi7rsi7rcpCVNTivy7qsy7qsy7ocZGUNzuuyLuuyLuuyLgdZWYPzuqzLuqzLuqzLQVb+f9kH3KsI8wJ4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.ipynb b/notebooks/developers_resources/storage_format/transformation_scale.ipynb new file mode 100644 index 0000000..402ce9d --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.ipynb @@ -0,0 +1,240 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "64609fbc-a482-4d17-97cc-99dcacb7cd5e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a scale transformation (only translating the x) to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_scale\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "import numpy as np\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs()\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scale = sd.transformations.Scale(scale=[2.0], axes=(\"x\",))\n", + "sd.transformations.set_transformation(element=sdata[\"blobs_image\"], transformation=scale, to_coordinate_system=\"global\")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=scale, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_scale.zarr to \n", + " \u001b[35m/tmp/tmphz5xe90i/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3583c7fd-a779-4353-aade-834b0b6f62d2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/spatialdata-plot/src/spatialdata_plot/pl/render.py:335: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap', 'norm' will be ignored\n", + " _cax = ax.scatter(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.ipynb b/notebooks/developers_resources/storage_format/transformation_translation.ipynb new file mode 100644 index 0000000..76b1142 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.ipynb @@ -0,0 +1,255 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "64609fbc-a482-4d17-97cc-99dcacb7cd5e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a translation transformation (only translating the x) to a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_translation\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "import numpy as np\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs()\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "translation = sd.transformations.Translation(translation=[100.0], axes=(\"x\",))\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=translation, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=translation, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_translation.zarr to \n", + " \u001b[35m/tmp/tmpsujko4mw/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "8b10912d-06de-4808-aa7c-970e2456bd22", + "metadata": {}, + "source": [ + "Doesn't work, tracked here: https://github.com/scverse/spatialdata-plot/issues/146.\n", + "\n", + "```python\n", + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()\n", + "```" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b762fac6-00c0-4e19-86dd-b6dee89eea3e", + "metadata": {}, + "source": [ + "Screenshot from `napari_spatialdata`, notice the padding on the left, due to the translation." + ] + }, + { + "cell_type": "raw", + "id": "a9aa76ac-91f2-46fb-be8d-648deb9b455c", + "metadata": {}, + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + }, + { + "attachments": { + "bc71728c-cc98-4d24-88fd-cdbcf95d7553.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "c4f67c64-1923-4f1e-9b46-bf5cafd5355d", + "metadata": {}, + "source": [ + "![image.png](attachment:bc71728c-cc98-4d24-88fd-cdbcf95d7553.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0d0db06d668688f542265ce16fbe162f9d1637f7 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 17:06:24 +0200 Subject: [PATCH 06/25] added zarr --- .../storage_format/.gitignore | 1 + .../storage_format/multiple_elements.ipynb | 172 +- .../multiple_elements.zarr/.zgroup | 3 + .../multiple_elements.zarr/images/.zgroup | 3 + .../images/blobs_image/.zattrs | 93 ++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 + .../images/blobs_image/0/0/0/0 | Bin 0 -> 86417 bytes .../images/blobs_multiscale_image/.zattrs | 119 ++ .../images/blobs_multiscale_image/.zgroup | 3 + .../images/blobs_multiscale_image/0/.zarray | 25 + .../images/blobs_multiscale_image/0/0/0/0 | Bin 0 -> 86417 bytes .../images/blobs_multiscale_image/1/.zarray | 25 + .../images/blobs_multiscale_image/1/0/0/0 | Bin 0 -> 21784 bytes .../images/blobs_multiscale_image/2/.zarray | 25 + .../images/blobs_multiscale_image/2/0/0/0 | Bin 0 -> 5493 bytes .../multiple_elements.zarr/labels/.zattrs | 6 + .../multiple_elements.zarr/labels/.zgroup | 3 + .../labels/blobs_labels/.zattrs | 70 + .../labels/blobs_labels/.zgroup | 3 + .../labels/blobs_labels/0/.zarray | 23 + .../labels/blobs_labels/0/0/0 | Bin 0 -> 931 bytes .../labels/blobs_multiscale_labels/.zattrs | 94 ++ .../labels/blobs_multiscale_labels/.zgroup | 3 + .../labels/blobs_multiscale_labels/0/.zarray | 23 + .../labels/blobs_multiscale_labels/0/0/0 | Bin 0 -> 931 bytes .../labels/blobs_multiscale_labels/1/.zarray | 23 + .../labels/blobs_multiscale_labels/1/0/0 | Bin 0 -> 540 bytes .../labels/blobs_multiscale_labels/2/.zarray | 23 + .../labels/blobs_multiscale_labels/2/0/0 | Bin 0 -> 224 bytes .../multiple_elements.zarr/points/.zgroup | 3 + .../points/blobs_points/.zattrs | 44 + .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 6226 bytes .../multiple_elements.zarr/shapes/.zgroup | 3 + .../shapes/blobs_circles/.zattrs | 46 + .../shapes/blobs_circles/.zgroup | 3 + .../shapes/blobs_circles/Index/.zarray | 21 + .../shapes/blobs_circles/Index/0 | Bin 0 -> 56 bytes .../shapes/blobs_circles/coords/.zarray | 23 + .../shapes/blobs_circles/coords/0/0 | Bin 0 -> 96 bytes .../shapes/blobs_circles/radius/.zarray | 21 + .../shapes/blobs_circles/radius/0 | Bin 0 -> 56 bytes .../shapes/blobs_multipolygons/.zattrs | 46 + .../shapes/blobs_multipolygons/.zgroup | 3 + .../shapes/blobs_multipolygons/Index/.zarray | 21 + .../shapes/blobs_multipolygons/Index/0 | Bin 0 -> 56 bytes .../shapes/blobs_multipolygons/coords/.zarray | 23 + .../shapes/blobs_multipolygons/coords/0/0 | Bin 0 -> 603 bytes .../blobs_multipolygons/offset0/.zarray | 21 + .../shapes/blobs_multipolygons/offset0/0 | Bin 0 -> 104 bytes .../blobs_multipolygons/offset1/.zarray | 21 + .../shapes/blobs_multipolygons/offset1/0 | Bin 0 -> 104 bytes .../blobs_multipolygons/offset2/.zarray | 21 + .../shapes/blobs_multipolygons/offset2/0 | Bin 0 -> 64 bytes .../shapes/blobs_polygons/.zattrs | 46 + .../shapes/blobs_polygons/.zgroup | 3 + .../shapes/blobs_polygons/Index/.zarray | 21 + .../shapes/blobs_polygons/Index/0 | Bin 0 -> 56 bytes .../shapes/blobs_polygons/coords/.zarray | 23 + .../shapes/blobs_polygons/coords/0/0 | Bin 0 -> 321 bytes .../shapes/blobs_polygons/offset0/.zarray | 21 + .../shapes/blobs_polygons/offset0/0 | Bin 0 -> 64 bytes .../shapes/blobs_polygons/offset1/.zarray | 21 + .../shapes/blobs_polygons/offset1/0 | Bin 0 -> 64 bytes .../multiple_elements.zarr/table/.zgroup | 3 + .../table/table/.zattrs | 9 + .../table/table/.zgroup | 3 + .../table/table/X/.zattrs | 8 + .../table/table/X/.zgroup | 3 + .../table/table/X/indices/.zarray | 21 + .../table/table/X/indices/0 | Bin 0 -> 136 bytes .../table/table/X/indptr/.zarray | 21 + .../table/table/X/indptr/0 | Bin 0 -> 60 bytes .../table/table/layers/.zattrs | 4 + .../table/table/layers/.zgroup | 3 + .../table/table/obs/.zattrs | 9 + .../table/table/obs/.zgroup | 3 + .../table/table/obs/_index/.zarray | 25 + .../table/table/obs/_index/.zattrs | 4 + .../table/table/obs/_index/0 | Bin 0 -> 76 bytes .../table/table/obs/instance_id/.zarray | 21 + .../table/table/obs/instance_id/.zattrs | 4 + .../table/table/obs/instance_id/0 | Bin 0 -> 96 bytes .../table/table/obs/region/.zattrs | 5 + .../table/table/obs/region/.zgroup | 3 + .../table/table/obs/region/categories/.zarray | 25 + .../table/table/obs/region/categories/.zattrs | 4 + .../table/table/obs/region/categories/0 | Bin 0 -> 36 bytes .../table/table/obs/region/codes/.zarray | 21 + .../table/table/obs/region/codes/.zattrs | 4 + .../table/table/obs/region/codes/0 | Bin 0 -> 26 bytes .../table/table/obsm/.zattrs | 4 + .../table/table/obsm/.zgroup | 3 + .../table/table/obsp/.zattrs | 4 + .../table/table/obsp/.zgroup | 3 + .../table/table/uns/.zattrs | 4 + .../table/table/uns/.zgroup | 3 + .../table/table/uns/spatialdata_attrs/.zattrs | 4 + .../table/table/uns/spatialdata_attrs/.zgroup | 3 + .../spatialdata_attrs/instance_key/.zarray | 11 + .../spatialdata_attrs/instance_key/.zattrs | 4 + .../uns/spatialdata_attrs/instance_key/0 | Bin 0 -> 44 bytes .../uns/spatialdata_attrs/region/.zarray | 11 + .../uns/spatialdata_attrs/region/.zattrs | 4 + .../table/uns/spatialdata_attrs/region/0 | Bin 0 -> 48 bytes .../uns/spatialdata_attrs/region_key/.zarray | 11 + .../uns/spatialdata_attrs/region_key/.zattrs | 4 + .../table/uns/spatialdata_attrs/region_key/0 | Bin 0 -> 24 bytes .../table/table/var/.zattrs | 6 + .../table/table/var/.zgroup | 3 + .../table/table/var/_index/.zarray | 25 + .../table/table/var/_index/.zattrs | 4 + .../table/table/var/_index/0 | Bin 0 -> 71 bytes .../table/table/varm/.zattrs | 4 + .../table/table/varm/.zgroup | 3 + .../table/table/varp/.zattrs | 4 + .../table/table/varp/.zgroup | 3 + .../multiple_elements.zarr/zmetadata | 1407 +++++++++++++++++ .../transformation_affine.ipynb | 26 +- .../transformation_affine.zarr/.zgroup | 3 + .../transformation_affine.zarr/images/.zgroup | 3 + .../images/blobs_image/.zattrs | 113 ++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 + .../images/blobs_image/0/0/0/0 | Bin 0 -> 21819 bytes .../transformation_affine.zarr/points/.zgroup | 3 + .../points/blobs_points/.zattrs | 56 + .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 5936 bytes .../transformation_affine.zarr/zmetadata | 214 +++ .../transformation_identity.ipynb | 26 +- .../transformation_identity.zarr/.zgroup | 3 + .../images/.zgroup | 3 + .../images/blobs_image/.zattrs | 93 ++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 + .../images/blobs_image/0/0/0/0 | Bin 0 -> 21819 bytes .../points/.zgroup | 3 + .../points/blobs_points/.zattrs | 44 + .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 5936 bytes .../transformation_identity.zarr/zmetadata | 182 +++ .../storage_format/transformation_scale.ipynb | 32 +- .../transformation_scale.zarr/.zgroup | 3 + .../transformation_scale.zarr/images/.zgroup | 3 + .../images/blobs_image/.zattrs | 98 ++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 + .../images/blobs_image/0/0/0/0 | Bin 0 -> 21819 bytes .../transformation_scale.zarr/points/.zgroup | 3 + .../points/blobs_points/.zattrs | 48 + .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 5936 bytes .../transformation_scale.zarr/zmetadata | 191 +++ .../transformation_translation.zarr/.zgroup | 3 + .../images/.zgroup | 3 + .../images/blobs_image/.zattrs | 98 ++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 + .../images/blobs_image/0/0/0/0 | Bin 0 -> 21819 bytes .../points/.zgroup | 3 + .../points/blobs_points/.zattrs | 48 + .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 5936 bytes .../transformation_translation.zarr/zmetadata | 191 +++ 166 files changed, 4414 insertions(+), 167 deletions(-) create mode 100644 notebooks/developers_resources/storage_format/.gitignore create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/0 create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata diff --git a/notebooks/developers_resources/storage_format/.gitignore b/notebooks/developers_resources/storage_format/.gitignore new file mode 100644 index 0000000..647bfc7 --- /dev/null +++ b/notebooks/developers_resources/storage_format/.gitignore @@ -0,0 +1 @@ +!*.zarr diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index 78a3017..f68298b 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "6c3ef5f8-a334-4bb4-906c-db3d8e50e571", "metadata": {}, "outputs": [], @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "b7f6b9fe-c7dd-4177-a533-941a42984ff4", "metadata": {}, "outputs": [ @@ -64,6 +64,12 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" ] @@ -73,11 +79,11 @@ "text/plain": [ "SpatialData object with:\n", "├── Images\n", - "│ ├── 'blobs_image': SpatialImage[cyx] (3, 512, 512)\n", - "│ └── 'blobs_multiscale_image': MultiscaleSpatialImage[cyx] (3, 512, 512), (3, 256, 256), (3, 128, 128)\n", + "│ ├── 'blobs_image': SpatialImage[cyx] (3, 64, 64)\n", + "│ └── 'blobs_multiscale_image': MultiscaleSpatialImage[cyx] (3, 64, 64), (3, 32, 32), (3, 16, 16)\n", "├── Labels\n", - "│ ├── 'blobs_labels': SpatialImage[yx] (512, 512)\n", - "│ └── 'blobs_multiscale_labels': MultiscaleSpatialImage[yx] (512, 512), (256, 256), (128, 128)\n", + "│ ├── 'blobs_labels': SpatialImage[yx] (64, 64)\n", + "│ └── 'blobs_multiscale_labels': MultiscaleSpatialImage[yx] (64, 64), (32, 32), (16, 16)\n", "├── Points\n", "│ └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", "├── Shapes\n", @@ -85,15 +91,15 @@ "│ ├── 'blobs_multipolygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", "│ └── 'blobs_polygons': GeoDataFrame shape: (5, 1) (2D shapes)\n", "└── Table\n", - " └── AnnData object with n_obs × n_vars = 26 × 3\n", + " └── AnnData object with n_obs × n_vars = 10 × 3\n", " obs: 'instance_id', 'region'\n", - " uns: 'spatialdata_attrs': AnnData (26, 3)\n", + " uns: 'spatialdata_attrs': AnnData (10, 3)\n", "with coordinate systems:\n", "▸ 'global', with elements:\n", " blobs_image (Images), blobs_multiscale_image (Images), blobs_labels (Labels), blobs_multiscale_labels (Labels), blobs_points (Points), blobs_circles (Shapes), blobs_multipolygons (Shapes), blobs_polygons (Shapes)" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -105,7 +111,7 @@ "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", "\n", "delete_old_data(name=NAME)\n", - "sdata = blobs()\n", + "sdata = blobs(length=64)\n", "sdata" ] }, @@ -119,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "b2952c64-5502-4462-9be0-a32fdb61158c", "metadata": {}, "outputs": [ @@ -127,8 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] }, { @@ -136,15 +142,15 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", - " \u001b[35m/tmp/tmpgoqskqgb/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpxu474pqt/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] } ], @@ -170,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "621f1331-c83e-4635-b8a1-9a0f6011ba83", "metadata": {}, "outputs": [ @@ -186,7 +192,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -209,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "a0afa793-0cca-42a3-9f0e-dabd8775a147", "metadata": {}, "outputs": [ @@ -240,16 +246,6 @@ " \n", " \n", " \n", - " 1\n", - " 1\n", - " blobs_labels\n", - " \n", - " \n", - " 2\n", - " 2\n", - " blobs_labels\n", - " \n", - " \n", " 3\n", " 3\n", " blobs_labels\n", @@ -265,21 +261,11 @@ " blobs_labels\n", " \n", " \n", - " 6\n", - " 6\n", - " blobs_labels\n", - " \n", - " \n", " 8\n", " 8\n", " blobs_labels\n", " \n", " \n", - " 9\n", - " 9\n", - " blobs_labels\n", - " \n", - " \n", " 10\n", " 10\n", " blobs_labels\n", @@ -309,101 +295,25 @@ " 16\n", " blobs_labels\n", " \n", - " \n", - " 17\n", - " 17\n", - " blobs_labels\n", - " \n", - " \n", - " 18\n", - " 18\n", - " blobs_labels\n", - " \n", - " \n", - " 19\n", - " 19\n", - " blobs_labels\n", - " \n", - " \n", - " 20\n", - " 20\n", - " blobs_labels\n", - " \n", - " \n", - " 22\n", - " 22\n", - " blobs_labels\n", - " \n", - " \n", - " 23\n", - " 23\n", - " blobs_labels\n", - " \n", - " \n", - " 24\n", - " 24\n", - " blobs_labels\n", - " \n", - " \n", - " 25\n", - " 25\n", - " blobs_labels\n", - " \n", - " \n", - " 26\n", - " 26\n", - " blobs_labels\n", - " \n", - " \n", - " 27\n", - " 27\n", - " blobs_labels\n", - " \n", - " \n", - " 29\n", - " 29\n", - " blobs_labels\n", - " \n", - " \n", - " 30\n", - " 30\n", - " blobs_labels\n", - " \n", " \n", "\n", "" ], "text/plain": [ " instance_id region\n", - "1 1 blobs_labels\n", - "2 2 blobs_labels\n", "3 3 blobs_labels\n", "4 4 blobs_labels\n", "5 5 blobs_labels\n", - "6 6 blobs_labels\n", "8 8 blobs_labels\n", - "9 9 blobs_labels\n", "10 10 blobs_labels\n", "11 11 blobs_labels\n", "12 12 blobs_labels\n", "13 13 blobs_labels\n", "15 15 blobs_labels\n", - "16 16 blobs_labels\n", - "17 17 blobs_labels\n", - "18 18 blobs_labels\n", - "19 19 blobs_labels\n", - "20 20 blobs_labels\n", - "22 22 blobs_labels\n", - "23 23 blobs_labels\n", - "24 24 blobs_labels\n", - "25 25 blobs_labels\n", - "26 26 blobs_labels\n", - "27 27 blobs_labels\n", - "29 29 blobs_labels\n", - "30 30 blobs_labels" + "16 16 blobs_labels" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -414,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "0256ddc3-edb0-4293-b478-2bd16d20d6d6", "metadata": {}, "outputs": [ @@ -424,7 +334,7 @@ "Index(['channel_0_sum', 'channel_1_sum', 'channel_2_sum'], dtype='object')" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -435,13 +345,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "a37e947b-f9b9-462a-af04-a8c23a3293d5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -464,13 +374,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "75166a2b-00f5-4cca-9d63-108f93036dff", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -485,13 +395,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "2a14b388-ca41-4d98-8199-f18cec3473b9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -506,13 +416,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "a91e99b8-30e7-4b14-a010-b2e8ef8c255f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -524,6 +434,14 @@ "source": [ "sdata.pl.render_shapes('blobs_multipolygons').pl.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1308121b-0f6f-41a2-8a33-ceac4dc56ea2", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..75d8a18 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs @@ -0,0 +1,93 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..37dfbfc --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "Am+^ 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⁣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 #)H^G8QFH+UrYaYE)nBK0a^|DM8<>WYpI^{p}* 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
  • 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⁣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 #)H^G8QFH+UrYaYE)nBK0a^|DM8<>WYpI^{p}* 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
  • ypOVH)w9c&X*2r;5b?(^nZ=z8CGH$&{WNnV*Qv1Kd3|iBdX9>N zx*3Wkp})H&LS%wFbgVo*GB()KnX1n0m~7%lVM|9EB+@B7VUvUep(+Av6wC*xDQAZR zAv)b&aT5DF#D=U1u%MqLPP?g6SZEEF6@L}u(bp#k>zR&%5`pAooDV|G+VGWSs9m{aKu8HX4p!SQP*wq@`s&2JDA~i?(J6O}jm}Qb zQKiW|$qxSBwYLo4=B+3PpQ*uZ>d-%~khR1@0O3ClRg;58LV)UnA=1k*>r2&PoMZmR3+ov|l6@ZSJiQksSR*0$v;gV5ES|cVecKkC%s-FwCkt`Vsluh}m zk>tWf(vWz*gqAtRk!(>u1U&M+aV)YJi_d2(WnpHgFSvA>;XJ%|P@gNn_5c7b1&LMX z+`WE3#DyFmdD9iKxXP=8hmEixqqox3)tB{3Wacg?zLz2$}b4@i+@iwX&pY0K>!ItE8M09LfzStuKG& zK8p)Yd;}0pMf~Ug9kp?$aP%hRJu7`%DReAke^j_A%1OE^G2#e3!x(#k;b{byUiEe% zNJoa8Fj$l5I`_e#5lfijKmTAD7rX6<3k7H)nm5IIEYm6wt#VYL7r8E=;E8DUeOJg9trJgazl;^BYMCVMHICq{GN zTj};W%>?I3F)6Pko-GgNfCvnJVMWyJ)H!|O4NXc+Y^x;$?q!L|g_ptLb}xT?e^`I9B=}9#JQfU+jt>C4o1Lt(8YoEd0@}}@&Xj_C z#9==#l$dOPgnrYlzF?X=yv!y>H8%6*$D$6j#Rle|*r?5xY2(|)trfgEMit6xQwq(S z(jS>pRZ=H&sNqiY!f^tY)|;oY{C!j(@6<^$^0QdxKAIq-3IWGvLkjt@fXPyKVp$R3 z=rd!mcnGnq4Sap#^8sAq4EIj9<{*?HvRM`!rE2vM4l^ezSso-+WA?ehLXkNdqMiJJ zMJ7ro?KTm&Sa6k8K-K0Z5&k{+d>D?t%q|>s9%q;rd0`-Bah8XI>}+ZpqRODp=)Yi6 z>o)J#1}~|CIcOCRS?aF;%QI*FJ;}iS^8k=Z?BW+pIC*y;ze;Awr>0uj<(e_V*@iBy ztj6-jJTTIxnkG{^*070EX`sSY*0YbXRlz%^WffP%wxUbrgo|;1=ZV%_ditE%z6!-Q zLA{@wS3Yp#g?>o0N!{fH$S0H6JYqBfGUq1U zs8t-zEsW;+{*0BH21Y(qx>H1u%%eL>G?vRuiE^`J!OGm=qeg5UZXWwnSS3}^8B?B6 zYH&;r)b>*RD_Kh&=XIo#$`Ddr7|bw8`eVgyVD$QuPr%O-(H21UW;=aYQSb;mBOe~W zERAu4Ut0pf37e0`Y?Q{ zdSSz9TD0zsfH_l2JTvefJR*=j+4CJV?vd|FwxO$+u=Z{O${hI@p+nn#^&lp>PrIKF z6he_GL174F3cXDH9es+!z-C^3VHGB!+Lbm+XW3{o>@#NaUaU+Z2gV2vWU9jTlt@+8AD?xJ3`6HOdWZGv+Mqc4TLE&CTO1xN0Usf45#Yb3z zCwHD-EZzAAO&A=BLiB47`y_^U%jDG1mw(?+3i^cOYe0LNAEWrn!z9bbwvZtvCnJ)z z#I|_BAzh!lgZ=MJ2D7Xt%mKJU03Sjh=1y;dVJnF8p8kA>2d%teJVGWvPKET9 zO3Hg!)g=rsxJb3io^~yo5kb5MG{)YqL`^A<>p8*KZfA7tR58M3-4?)a6xp9$b%nuf z0keH{hdfv`2@!oZM{N9KM})1SUVE>v%X>YeiCcW;o9qXdhwZ5(QW7m9kA+}AeQdpF z#wuL2i_FU}gV$MT$BGg5c~;m`-Gzj<&(IR-pEU?4L69iaJs!-TyrzWko16SdO}N+` zkkgbP` z9FLRDO&wiKv6z5=#Y9hDwm7R;?EXGS)AJL=bI#B!9oWq^ptcg)tJ}MIF^_fPWMTV7F*=a$}Z1<88{h%OH>wyO&a%4De7IGN3-`Qt5|& zDp22J`r0-X4?ahY$cs&i#MuW8o8<6OEFEJ1Lg8Mi2b0Jd^D^dVp(F#v`CF)6S4ZC2 z2ohd{z#rwk-c|0_77NJSsAOpa^7Q2E=Vj*m@9vVB=uQsAqyp_Pu_%T^&n8pbz0|%M zOI5c#+jmwAi?<9Xb8E8kav={Y-63C&;GkpFybOZnOmj8N^VgVWK)SE z>n;%99Vzu$aI)X@f4SUe@k9$weWFanFKLI@wq=ECzHTnd*@Eheb*2h5GcV7q5i7-a zhC~!{V8D-Q%dwQCYlhy|Tc1T?+SH?|bwexSyDWmE$-xSW5u!mE*sg;#AmMZ&eTfZQ zFO8w6f)s8b;qteL!oO30Vl9mDr1(Z_P4_ZQ+1jUC2r_7)v6iF7GMh|qLQbi37c$IJ z+CUnxLDMZ%9+?+FiUX9piMsTVjDC$pxTEPTZM-iNkMUQTirQ9J@lXiOHQQO0mP_z$ zGr`0=AxG0Obw;YGtM+n{{w#G0SF6Q91&1p;q#{)<1ve=2h9W3csClb#6eDRaj7 z2;uf|qIv2PdLic|J&FjMB3PE+EUC#(L-uyY;Tb+GcBx*5!bVjHr;Q7xWXr768 zOHPJzTm@y{;F{82IC&f1dXF`u&j3xHB`~nU084{i_$ay?xo|Zs;dyMogQkPOQA%!7NeSF5BHPvNk0^q{*38B=Megj=H;FOR|xu~}*) zEJv+QZ@Y`p^LzZRYW;%1`L{adHDiS0;>(5)Q+$f0$Yf z<_9sxPl8N&`agsiU_`2gssL=*76r!kLD_$WB_cE{!j8BON5m3 z5qNnC@ubY@|3{<|D_YD;)!!*w@V;$#A$7FNX?X*>7Tlq|^JM^Fn0|wSj#K~tkL3S< z?Q|<-kFiqJPxE|QDxYrXo2bjY)`J_M(m`5_x8^PLH!pZg03ha9#C^*Jo$&oy+{94f zstfsC?c0`uwsI9AHFAgkBjK9X2JCXzs(`$|Dx>Nj7rZ3^x9Bf4WZHU)be6x%$e%N8 zx-kL7yd*y25dmMx2{fiqG>kshveS#;ERD62Uf;E7ff2h9`q#kWx$^ zq8yL=!1G%ArAMn~9*b(`uFKeSXTq2WE2=okrwi&-glEo|>rZ^WO)&ZV%qa+(H;Cl* zT-oi2v!oa&R^!_ZB0W5!bzMkZ{l0zVV%PPGt!*i4j^$-?HEYTr z%lzuo=-Dk5^TY3k5!;_1j3iDpqdER%X(S5uGX3TGW<8 znDO2W*@r`Tup#Bu3wZ=u`qp6phEd22{rARE9RyzGD$uFiSe8BUN|ivrc@CpO(nW6e z?K4VPXVp7m$UDNJZ@;jDQVoCaPS=QKB5UUw+HCCSNZa7NABnmB{y{PE8?%He6f{Ds3$Ebq zqb9xv3LiJ*j_NUa*P<{FYqtd@65I^(8R2B16hZn^DLi{!;T5Wm*NFo zBvc31|Bj{woibX@siyPlqQt37Cs^?qz;2qVmD`SGVqr>0FH+*UDXBoTLHwj>N<0%m zmPwu#FamPrXnuPMddYp0s`C7HOU%4lB;G_x>v!W|v+{366I?2<%@1jH;q$gaS1nE;AHjl4!W-*5~zIQM0% zo-NL0aI(jDD!1Eoim+-Z^agICR;^OD9gH+^ITp`m_(&(GHy;z9qau1gEZ~@kDdZlV zSSXqVZ_;SE>QpN$#FxJkSIOFcy1VlgwK!vK+X%el%GRZdAirk~Osba{hdC)-a^3el zu1#7H6KV7N{ZP*PGG5j10JjgbyNAj7TF!3#hnOe&k&`&VvwqNVM7PY)YeY(;C*_$e z-|so64;DR}D=nU1Xh3SWVq3!n7EqZgZjcA@w}HeH#8@ z4*I;JjY$i-pEO0Xn%#piNXM4`q~5A%8dcfsD+UJ#*J~dXg{gyP4PCPJHZ+!i;V7q#z47s5+sU8BY(X8WK^{szR8mq%~Xe|gv3h;_7iWhY*>7c6WAbIX- z_E8URtok=q|E>lNcTi$t+RJaH#zN$2JxQIcdi6JdfAnG2W{nZyHD7lntOQj&W670TBZTIG$)2yl# zmJ$9}Bf$p302P=<$|uQCKgrpyA7_~9Tk2_I^*`b+6^e5sh%|&$ydWIfC*?1SHgzf1 z9T*ojjAss#M=w~5;|u$ek1Z&M!&yIrZi^UPJ(bw0U$?r=|FkEC#D8$gc17CUSCW8n zk%G(6n>qOrcN360m&KbbnIyyZ_e2P2<#ZLknY>Ms@!dWsjes1wxHwitxp<*s-(je+tjVG*j94K2%f+|0sjtq6p~7|0SSnk&di~$Sc&tB? z2PJBx$|Dgze=vt*Fbne47S;Y@u5E$lqW&t?mZci-{mN6%L?b@G)S3WC*#a9ju~}U1 zh2RPDG7}XZQ9ZXoc_BRQmayMPb#xDcMxp)=Ibfo37mMld#dPQyj@3nezlKoR{m&1> zGE{jD4bBbZ2#3Z~{(Cb`xJy-;d}2X84o0M*zh@=%IKoujqW3*pd!HZjzec)WScgQV za4}6Zi%yz&+UQ+%M8;JxGT%eVY1j|vytYkGs$~q2Q8poj^vF|S|JJF)WSN&w!1p|$ z3ndCKUaVrp`0)f2(8aJeXMtxUKPi(Pv6w5P4ZqS)Nvqr@dTcamXt_wCjq<2lRL&*daVVI zk}k#fK|km1$iJ`3Y*k_N=WPGRLZL)i)Qq?c!^Nzxik&hMFqM7uyCL{kEK*-G{Zi=P zqB;EYWS`~KnF-nwj(--9Gj^SA@PCQLpcm(944nc6_^GaZPXUpc{%td2S#bBMnAd^)zl81uIsD*5t)CG z6&ox4j$c#;FhkUw)6AZJC~3RHYv|3clmx2t!qwlToFo^MS}4nwF6fIsrUM_IM3g2R z7NfJP0W96H47lM3r9zMNAY5EtTkkWNt6!F5lOJj)eAOa2(+q2hAg|1)f%=Mm ztp`uBw+mja4e(CPVU_{+oM)-sIc$CtN1`Ma`Z9eJG2Zqu0VxuusQ~*OFQsb6H``c4aNZB|DPE+yr-&aE46U(voTeIFF;!%#wCH$m{(23Sg8PE`7RkGr zy0M4Co`NQO=}sf(`#T<@y8KENAlcoFlS{X}V)O8HS}5k&#rYA zY#Gwk+uOu4B_jq|crz-@symT=Sj4Hfcn-xQk77+42~gLc5oXxWWrqi`Av}^ zkz-L?F44~4w@+||8~?Ve0kBzw1DX7cknC2Xw#CaEe40RVpg89251?9~hS6VEBLvth zkJzU_{!tWPq-AoQ?aV#&AuIRdCXZj95m zWMlmp&tmzr@zQ7TlEx762mCj*zk$1IL;WY^Cs@AriQq%2!4i>Oyj0jQC+NrWzs}GH zWHW1pjPq9=*iC6z5?jANCpLb^8!rsqI&A4ISzK+7;tv!(b04*6ey&22MO=p6&|1r! zOsHPBR7%%fOr7k$$mu(#2=F89QurBnY+FiP|40_WtU*{_(=yUl zo*o%EVMddsuxmdV!p6~{B<@;fNY zmrWcMUk6&pz3!AMgu)Rj7u6BaD%1!x8^b z{}2FoksOW`M8@IziB@;1JFz_IFk#?aXYY05V+0c8O(n zd62qlcuZcG^Ax6QMPr8wnj>kbPAi++Kh zNCj{u^d|JOCvA;?MRNt1u*ZqU`L?T(ptxTBpFL!N5~K*eupr7oA}Tb+2v^${j?sp5 zL88dYT)(oKI)J%&dBQC5J^wS>0JFCgE**gP&tL^0~Se(_rNy#**#$Kh=Nr`l01P znt(R^eqgajOx_KNlyfcp(il*7T$awUA9u8o0^JFnUIfwN?0rPh`ps#AQ1Tg=%*h`A z_e;|7QjXl2PHG(~AGu!c?Iv=;sV`?eobVUhRmC%<3NpgLKsJqa4UU;nb;%^hB#IBY zVrYB|f}&3KNoN0r!1@}`mUVqjgq-25S?VN3%rfp)zBoe3E$m?F;&Pm(;DG9?;0kq7 zJiQ580C~$@vI0)U2ym(8JX--=daSKxz1ZIB@cpGsRiLH#Xl5pIS}iTdWn6XJ5_B&w z$j&^+2|3Mm4OXjfJG04b$w@iIpzr*gYSX%fudD#Q>{rjE6s}<{2Uo^?qx9JG%^A5@ zW{oB~V$TLc?hF@8Yj`s0RXr421pF$BuUH<(9%f77JvWQ-)CU;p>w19qp?klNDp^|1 z8(Srgb5g@!gIBI0#qXb*iVFi^o&(2y0_kMOzvu;7Sj40K znNl}n78l^*1I&`VA<}2b=klz|`>lI&550NAzntPW1Y~$Tm-JZYroUxuPs&U@R-k_nbqY(ExYZ<8XTP$)j0EUu%_-SHW^C}i7(wyS>`kV4 zzG~KOq<_rTSOkaWMuf^%#wx?hYR$2d0pb1r&Kn(X*dRhql96BI5$Zu!8maaW4qn02 zY0;u@BZHXWv&WChq|Ng`QWdg$gBDNw&`I;IfvKN1zKqYgf|5M|0DnzHHEQKWHb_r4 zT*8urd3e?1IA15MRut#?RaRou^0iQyGoCD}iT#9Mr5c6&HVjT!#yQUB>k3p#i)_aL zK&pi0+??C%^dhP`bE}Oa$}Z9!CW@mTfkdq?EFF%?K|S1IfKGv2&aZ_1y73F14vLUs zR>OAwTD-@glXw3smg1`!MAS*;K1(n+doJy%UCRgXR5WKo>ix;$wrQ^+ojL)B=Zhe3 zw)koZwt1AQ#5UH2)g)0|cFUUg_<QK5a<;RqbF5% zrB}^!1_MqChp}<_aY?Wdz9l~2|8sxf-008c5TW6jcj_u;U0`&mw1sd~7)I=Gp z;#P-zMTMcxCZ(nM1lzm3l5yTZ9S~|#@=^sjb0@&l4TrFxKyO>wNY%e{vzO=kU5X~0 z6_A3A;xql~Hv1cVg?(a_pq!>uSW~n5^Y?%?JdkPc*EzXJU5eP+tFKhb=jfZxNk@nP z&aH3htf_y6KPYqgwgSSJ%v9{;zEem~YWA~Z+*$dA!0)hS!K*c#p1wKnqrxUW5Ny5{ZWhb5@VXNDp$7j7W z<;==Pe)DZwiU5HkR-m3p%qQjTFf1Jv_RIeKi%tC74Cg{D=u0_oTDTc~_D6=V{-a^I z&g*e!cpRc6-q1L^pwD-o zcn4JgffZ$SUPSGn?-UYK+Q2`k4)PdI?Kx|@Gd5ITuWDl{e7gw?OV6c4Fxk9A1C5B( z1@(xmSadh$aknYb=cpdp^=Ettm%2VuwMVan?Ur8UHO=9;|2eN>Zp@sUPyi#RJPR=4 z39nw))r<<+CgtrpH;Z!H*AF48U?~Y)*Au5uOVA05E2qv)?CoJpSQ(gwtD+#mZ{VXa z`P1hpR?DPAp`=4>HuboSFy<^WoQ=`WbP>p??C*B;l^n^Xe@j!@{rpHrHE*d_g~;Ki z)6Xe-O~@I5%tlxCf(zjddHMGKDMcUdq#w$l~G z#ao1po>4njKcj`^*TY#BycZ_3I&0J9f2hb-DenB_5*q%H@|33mi5VlKi2 zbgg1b0nGQ9PD=EfJXJAjoJWp%G`ycf8nbG%@7)M)I7f|ql}LKWYR~ForvjIq2Zp(Y zRYDgG{XwG87QvI+8!eX1i^lu8lqT25T2FrNSeD!F%HG?cPkxgNEKmgE)w%nkX75BzokHZdA9IEh_~CaQMYQdoBMRdgwo#q$37?J4KEu4qNi}4eD)or<~0h~*%5v} zU@#pzUW!H!5wUR-KO_5cp8uJe%y9eqUGH#+T2Nl{fkCnhhq~?nu92%|E#6>70Buoz zc6+R?L3{C}hNm5yN5`D2J;pYLl2Ppn!9fK0V>y1=Q!Of{buBg|t^t%$E!uDH(2#zU z9eCh)s$VN`+2nL>uGDI8mHCci8E8&x0#94Bp@!Qg&?dHGM1OLOAwB;_!h4FGXg$^6 zyb$!S@=h>%kj07X!@{g^13dmxL^BE1FNcwAlh39@0MZ^l_{2o4J6^{dz(Y34t2;bi zSwOcDc0)_gBU-O@y1-w#Vo!R8#Ke*_wH@E|@hsFf>kwsFARlo}OOMUEeoH>CD4o=- z5y8tyeY?whTsC1ueH6-wG`&fzks~(Qy4WTCoJ3{3xfIrG99Vz zm*3Ll3dU@!ac`4h8>?>dEW90m+Wdd1tqLB6mEoT?vlt|4X7k!}f#Wzm@yFPAw*aTE2xhL8G?m zqi=OBrB+9yi$Zp@8T?uCs$^2A2xeZ)vox;VGj^vE4-<{wVSpju=2IF3cqD^d|KUVk z)nu5s%J=r-1;#z?_V@)TDc36gZcwMdsKQKqyb#uLN=`vhwEn~E#;jr?e5UY^b6gKk z8^AH!g3>>nqI8Fy4;0uG0|5wYl2X6h%SH3G(~I6#<%YOh8ru@PYe_{GNmdMq$j%T#^~3+`n}?s5=PibDCO5; zBYrqBx?XECV+)}tbt5X1hAG%kLSdh4IAnjziu<}q_^kK(zolV-x^Q>AWNH&i zfVzf0frs|VZv|u!X1z?m?fO>U)6G1+tG;U9WWdZE=ZtW^nE#XYlFW>Xu)G64BupBZkch{kS%%>6yxdDvx@{7Ufs7RiZNsLrM77SJZ{)S_WTy; ziz=#Os^wRJ+?{+Sj@X{p3Kb23#MgtV{f-l()91Ofw{py(Lc}j6{bqTI_0ciH<9mK!K+PR zu7~Za!9i+oBU2Ovt@dz`op?+GN^eQ&I*qB?OO55AjvJV3y;EBN*SJIqYx#<3#qf~3 z^?$hy8;j_8pd&{V`Ze5)v($jdcUypBG zzMk`s+5=dav=*FPCu#Sg|Fsr?R(3W6NJJT?&b!5EhfuFV++aIJ7^*JV9ek;7^N1?d)0si& zsc75+eHQvHOk<*^zq6tw;g~PsIZOYE{>{YdWe9U&_df9Xy+HQzB$4H$fEie1R^HvCn+}jFA-|vjpovnUs8i9{6Fu=wuK@W!(LYMZ=4#I}+l|%@ z2x2Au7OI@u3Ncr#L&jD0VE7>FY!wN9Y(K>m-1K?0{ozCvYq+R%DH(Q1-;-0NlN&_`B#IloTo)sZ64uI(#=kTqJwXe5jWcMF%#iiK{lAUNOs!sGeDca;ySbDfdoMESflz#!=wGD zyx(?stEM?t^S7{1Ruk2={D22IkCOE&TNSaBxZsDU|;e{ z+qeIxy#J&^R-zv%tpe2&PVxaouMG*ZBoFbZ%5L@2-qdTG6lq6xva14$UnI+hT8}dn z5XvbD!yf8c1eQ)%LtRjN79!OZsYpi3t=0Xg(dgG7{ZqRsOaEa6cGp@&7P+*P3hU({ zQ=|jFvec}?D9Lv)`}}m}f0F;LZjzqRrB_`38t%$f50)}bZ&87O_1F1M8r7U;rvAt9 zd?Y26kfVF64PyK16hOlFC5IobX9NF_&Osk`zTpfTPmi z9}l}K$Kk=VZ2OP?#CP2mF{Q87H*CR0o~Biw2FwLHuBj)(F~TMUj?9yZ_sMl+a7a4v zcL9PV27u_5x0Psg|3no^rm80J?MI5M>ERA0`~vJkNUboxhtSIL^TQh>J1280w$kVc zl1;K+;Th^}s6Ylr_<)`iKrWJrqX`l|k8G8?pW&gikVJVhPMMFmKzZ0Kx{0{F^juCY zWfT*WHz&zhD+1-`t*y_L2rUg9lz<;3f*>1h0%8S%BPuO-JuLN58n%@|s{~ejG}*A@ zWUVt36~QF7qGNAuquzrCSnz$K+z78(CdmZ!X7t||@`Jf0L1yu6O6 zDdF>#t?;kuo!I={I8>C6V!k}4pj6trpD$f|zq2gyEsjajJm3`;qAVSh~}B zlRal-261Zj*gAf}5xR~=e&-Jhs9>TC39)tk%FXX1W>tIdIa*qVCBPrqcd9M)Tt3Zc zs19ueM`LSC?OJ_UVf<+=VXA%yO{IMpmc*D9n#g?BvAJ#6OPh_YDE#&fI+s9#0NLf1 z<&fxmJPGvu4n}R@7l78AHb?RvilyEoW93?T#^)!fd`nR|Pp*5!Z}qFEuKl zZr_&-slAUu^*&>F?&qZ#Iqe@U=&NFzU)`J)a9*s5tUOD}OyL9SPq*_N7NrNhIs^gS zHZr+@l%BR-TeQXtBpKm9js3l+p~nk&rq(xOSU?0(TYs0+FJnCrKM65CK^l`#i8yWT zU6JV=7291ey^%iTD?b1RB!Wy-`s?<#RkEBI$SWw7z8ttBea4%Utrs3j^4_cvGdc644IbN@ zI#4^baHO|5y@8bEyRza@aPB15G5p$#i~>DKl=$9t_nnYwjVWpu$WuC5ayr6 zhPkA|mF+gLecYr8<1os=@BndYvuC!8?CeU!8=E!o38ms`&lxP4`)B`-*~Vo#c_745 zA7h(@qtVsk9>ULzW6YgT89F8Q83tf@BG7DIPjp+E60`Sg5F#xSz(Zkl-gW!WKN!T% zHX9~=M>#ogk#kud+#IGj($osr>Xjwo%{)Ayy|(l|5p+YSo7W=Q#jW9>Gr22h>FFHT zy$0d_-$pICp=bY7j zgxE(YKe%hYH~e9&&>lhHAk>=H9J?%oe!Z?p#^-F*2R<^e@8{s!QuDE?0>Se~A&76tqQ<>Q6 zx#dGb{y?XMna0sXu9Rx&WM=p3scbS&$@Pe7d+1}%h}hE9z1eZ^^R=u8TqPBNH}?xl z9krCP%Q6}}Re*(n$U@F+54tQy1)JYpQHsUc7G)u?HZIzaeY*Sd7zaGm1_Bs7olSPx zp~3eg0sA+@hh$BVQv2oFr4jDZj9MS8OsIH2qD>eR1bwNHiunZ zN697f(&_i@aJn0dv9KT4=pKt*QaSU`9TiiUrK3!DWMWHJ7N;%Q)vGIsUmXrB`yAw* z`P#8>Y>IpTl*Qk9tV9ExNPptc8LlSkAYbBL zYrvQ8J9wkVvMj%17ukusEpvp`)+(}X=y6BZv%Tg&T&tt3{i0HAC#`&Aua+!HGeOEF z&`;m|Ock@{XeUc0!b7$#oRyN+r9b^alyjMX12?F^Q#@H$37LejmiOfD5GRCfO_#(; z`|b(lA84Sr0XTA@ddcC|MGygZyxaZbFh7h$M@?jcpRu)zI!STA}lq4N2!H62Ao^r~-eZqd zMr`9rKY@T$=1<0qM6!*Er}c&^eZu$y=gWbIE`cV!JJ*z!UM6ml5OSV zI}*3}gdaOUe85ZzeKDxtJ8IfRc;YKtT1rxEn&){q%1B>`O4%OLtxwA8fxk-8^Z(b@ zdxtfZec!_u6crl|mKhZbma+HVJJ=O_7wJW$C?cTJA+!(zNS7)JkU$y3tHzo2;MM15y;@}V zA^PG{r03@!0j!=gQ%?jt%}?>Y-EZhPE1!6La)LnSE1EIzEn|(vgAH+)apvp))9#yk z`}@_Ce`T3ANH+gtyo&zVVCudHBBeKF`a^Ks(wfJ7k&$dA$1=xS)nuA2zvOcmZbnqGT`gQZq_wI!|tTXvAU-u_3 zZ|d#?3l_I`3@)}NA=6#H*bM~z_usVbH|-wSZk_JE(ZR~?FdAs^%DuCsJQIC$H>)JlvfP7(ur-)-(BAmwd+jG z<;6)i{eIs{F32>rsD6Dj_Px>4-QKpVUM#|=dtPm7+IVnZ;B{Z`z02cjtAgF0t1bTQ zoZX_{x|#PO`ElI3uX83gjcGW%;?&wDH}m%3mUgai=kONU z<&fl$zDKFyFUQ-}Nj%?AF<9}b)a+(Qdr{5zx2fg)Rd)5~D*7CWLbsxG%Puqh$a7=8 zmP|>(Yx&l%TqfWqnRxqIPdESVNr%(2$({j^+KA6Qi6_`k9bS1EzFVT$X0oj71md)| zYiE{Q9sT<0+qtoon|WncCl`0wUz`AM zTWZIwOW5<}+vl<+w?c$(>~NYKQ%;I_ZY#I-Z=L(4r;EV;Plx`%IQ?C-u6ovo_oGeyA+)V4LL~5pHB5 za$w-Y{oT5mY{7)90rsDy52jyf*svrwY3A?zxbele-LFK79@3dFf6qG|5cgG2CQSWnRm}YR^WzSbX3fbN({c3g3n%{&?6Qfx^mP|v z>QHrZ&X1?d|3w*T1jI+5q2$}xKkb$c^scrBDMt)=w!Av^#mSl*xj~!GexIYL{Yx}8 z()DWCIo*G1*A|&&mBZ}dVYbT$l#yERgZTLUzWJ5Ou$8y@xm$X#^j$aoOy>=YL<`T8$NI(`Jo)g#%o#bz>$(PC zo#Onf8OxBcu@`>aJeqQ|ly+@n`;Pw-y9MJud1n>RTx`S)8$oo2Mh`C!D!$$L);4ta zaF5$H?Z?^iNy!VoKV=&J9ku#FpW&>qSGn(pL;F;M3F#XHb}q#9c^W!s-*46FR6sob<5 za08q9Q7^m7khr61qW8PE9iUfEcc*p_WJo!z#mGsi)d@ojSR#MfgtZCu-ZGCiTpVajl_$a&$MlzF6o z4fiiR6@UGCI`RIymRX-G4Z9Y;+4J0Nb4S-W@zvRLH}yJISEwlN5n0bZ zgwXM4%ce|ClSY3fINj!XOrNnud3C@u=dnULHM`Fz$9nmac=%wzG%eA(YD3XH661v~ z!N*b)z9S)PeEK5wm4ETO%1>FlA3QqZbviAzYub_H$(27RUOLzOW9qkYl^#V5-M;F9 z@+&td^7jN=xDV42B)tS*XezVKo5K3PNy|5dvXjf*rh4)gf(tmHAR1l5Kb>AK)P{sTVu}uB}?{=R0Pj0KIG@q*tFs6{Umoy)Tywb`!T)g&QUGek$fxR34F*w*h z^$ICwgB5pN*6Wk%b}Q0@V*|UtQ94}As<;z(|I;_ahG1wJW*W{6V%{7gl>RWQpIJ4{ z=B9D^o(prcxRDMnbHe|!*|TfX_9SC!OWD_;4{5pWjRn+qQ%<~UNUI!~xOQrh>gJm) zm-ai?^7mXyTSzZhRc=#omhwjaXq-=Tz5AAy>5HN|433hVHHWAo zo!Ooj?iMZarYwA7%l><;klGYeiCJW3#Hp~b&ZIl5ydn(`X>LW;`{adXrQGtE`?qz0 zw_(V`;1|O|v$Niu5+cQs0pfG%m4oWOpXc|tr)(5%F4)c|g4e-C>gPKpWO4w;S&V>I61EG)ixYby3XE9dT>u$wR098QZL z4DdT+?6P(I&X)lZSnBG}ne{hr)Wys#OU{-|-+#Tc<;S=9Ny8I<58FJ@ryi_KKPL{L z^u*RusiBO@?oiqN#qWnX^*7fhf1T)Pb?1zA#}Mg9@0+okS36z3;B+Q7N}8UisZqlN`lpLeOEWI%9=|M~@yR{(((C6R-k2?aw|~u77J%*ixzjR+q{K=YX9QPhu@3R4w}g`rlw9`RLEY|Z4u#L z{I6HTs;tXBGwgH9)Hj6PeFdtUpN$ojn#6SJgW$!MpOwR_C$o*U!00eqV0^epk$y6#wlgg4mX}%12TF~0T)#fEo?&-?+X>T___>m%t>67pTN?vn zk|dAPVlKEWvW&U5+f?VLora5vS~%S&D*AGz)H3O@na8=yI7W2(R-NA~8^oB;=C2j? zC;R$*xsJOT9YAW>A3No}?c`qf%}b7bc$l@#UpLu5ZX|kpch$K;|Fol$>c`%lUny%3 zZ^J$(q#SBpUR-(pobmqP@!i|T$=eIB;pW%QDA8OfAtozhiwKslhiFSNVK;n5I|!vE z!NN-9N$W@KIP#pC=Z|A6x^D!Uj%jPWcXw0r6z}(`XRjW5b^6ZdPyBP96+T~obbB`b z7ZA3lXl-uc^GKt^@8#A%JrifX+ceR5S4rW^X|$sqmS*PEZ{3e#O;WbF9m=}G7F-?rlO=i1Erq%PmwvVEJy#|HaxcVAf^VJLfy zDh4yw?U?Lpy)uw7yrc3;(n#F-`z`V~hF9vDT|v7w|0q(U|9jMQ;gLzy1XqVg+i@Ld zMvjzogv1_0$NU=&CkC#3tj+w;QXK7kG{ta9eob=jp-EVqK7&20&wdNT%MW8)U7#sefq+tR`0a0H!v$Uo+5aqFn<>jhbz-xqHE zxv;h;f#+}uyF$>BOKu7Gm>e^+xM3&R`e4XA!iovQzkt=dVhrbf=Ubn?*32{w@$aL5 zXFh9pzFrnxY4=C!J_T=EsMURTo6q>mX`C&?M$`HEUy2tztPUebhrPU!o_^zHSoG6{ zJ0$NG@fh>^zJ1W%VEU!0S8eKvO58q&bs+=Uu%|Ln&{i9hzWfNs#O z{Mvi`{~SAd*MQvp$nh0^@g}(zBxef!?)PoMmF#I;^Z9=b?J`fkWazo>@|2im^t#ha zSG!fU++`VunFn7UO7hUE=a^hB$UwZ4axkA>H+|i|vEN|Zy8}ppOUR#ttUpa>&C57L zJU{W_?aT++GhBzWPJMao9~)x#h4?_hH#XB%`sd}8wqX^f{D7F$7FCZ%yKGu;z}B)i zRv)JJEco1L-0__^T-TQSfwpGO%^%N&lkSae`+1hxzS+!Md7>%kebuZVRkw|M+WXgs zcUm6(@aeCUHC}_fxKHPQ;v5e&F@I+4-!fpk;mM8z&ccx!KaRTn_Rrk6HkhD0!vxEf zx~;oEHq?zXRQg{iiH}M47AM8Gy-S`R&inLQy@c9?CljCB9pWunP2c;n=^KS0e$=|S zsSwS`X6~{qs}n|->f4|_UxZbU6*yxCeCu!;DRVORm{pUX$OVp-(ECxfoT2O zdAj7Opk`O8g?9Cpxh0IT6PMgzk9^LH=2kqrQAUd4NBiT+D?ZeXkDe*n zlXR-~$6SvaiAnYmUVkje9}HuKn}(s$I%4wE|2SKAU;0o}@8c2Ox*l5|#Jp~meQUO+ zJfLCGcT7^L^z-n9!?C(~ADg|u9X-G5d)b5N-KLWMyIF70XzlpKsy%d9f8KK^^}YX%-GXq9-J5_JEHm!C(uv-i>oP&u-ad&4Qy1i-$vkhyLCC zm0iC0>bchrA(VS-G<2(f|LHwap63(&Ii&M!YQ|@G&ecrp8%&oJ)A5mY+4$d`!wWJh zJ$DQ2%N{M@s;h33&4|X$zn{xYWY&HCb~b9?q*<+@0Y1#YpWJ|$oYe;NmwJABRPbQV z+s7Hnt;^<3f6@1+Ny0v(;ClaztDaR3N0lcbFX(dq?WnLYN0ps*suPpE*NJ5K`-tIv ze1?Ayy~dMzO|aVPL28S7?jOAmnfrPl{P$$-k00kO9=w@owURjbGgN9#d>ZQIdNe&)T4Y=-6Qj_r|?`lkPgpY(NkbgZmqO6CuC)5YAbM+D0e zC^@5FE3M`!=r)4!71jHaRZHF{ZZo)N@9Yv3b{g9+Y~o&8Wub7gAEW8XVh1zB-n=hnj(rm6p7}2t z(|W&O%H*u!IaN7Kzy5jpw|{xtuU4SfTM~vbTJP`2&MbG{v#|5g752vW5C7aJ_3p60 z%R2Se?Y--2tcsb$Y9r#s!hwk-s)XaKGwM5!}l50RzC@5 z)22^I(}GkvvB+*K{&0Qj*1sRl#mUqbSjkT-LeM1AjjHIDp|1C7_e3{WPnu_A^&c&J z3vQgjj;E`~#f>}PpB*=s9}$nw51G~T^5LvYR*>^`T`xo%->A&{!MJ-!L#z%C1;LU15<<_G9?OVSu8b9>m_d}}q%aO_RXh{BxI-lWI zbbovaDP{)FQBCrGWz^SvgR)8a+wCXjkDTIHpReo*BxeuST93D;L#C0Hp5^GK!Gv)EU!oV{bFj&-Ge3OR%=kCV+$PtmjTG}nziKYM>N zZyh``jyX2@s<~Th;D#BD`|z35$kqzql{3TepQ=v3w&R*UJo)moPwx4cvDm3UKCaJD z>*ZEeXZ55t-6jH3_Urd`hl>9>>Ob%_e@@Bm73lcr7i{pIps;hLcN|@+y`;>7hB#0x?eq(>ow46)ebU>R-}~MZSsNHvg+3nMkldd1x@UH%@mPDzggYBM0`?*1V+L35 zb3(Ju@qOp$d#^3%JlE0}eYWP2L*p%gK4gwJ?4y zA=>k4I*r5U(9(m$QVWU;QbQa#e36htP4)fX^54ukWa}55K@(})TD6+io}N~#W9t`2@sQiHIg+eRV(vZMROopWGBq*EuNBzPU4^QOvRaB>Z=hLZZ! zDYvQSion~3ky+G+8y4qZp|LpRO>5O?l?Zc{lamyExg@905gPJSs%RQr$>Ah zqbMKtN2?N5Gm4+%qGKX_9j;pgNcOB*zx}wKZ$xZd3YbPI|2007?P>7Y#Q%D4TJO1dVvY9LnIwG5z zn@_Eks`Uo7JLMFmhbyep#y%R5r`4!6C>YX$9S+ZZgZ#N};~waeN7y+ArBeAQ%M?dD*aEIb$FCQZ0~k@@e3-Cszx^*FqEV`48l8$?!Bwc$N*Rxq z{^V{*8mU|W7y!NkVUng_Jx_#Aa}+rXc3RyTwYiK*G# z^k#%t2R)6zC1w%Hq+&|NuRGq^W@2IM8-b0_LcM`b<|fIK8ie z>x2ZOHm;@RRdM3t2>pc<3@&N{& z2|QcIhMi)vc^oFSgpe8$MISRXIm*lBDGCe@i^UNLW$I>_J%xr3+P7|K}f@t^JMihehm+}io@h6G+Ldejzfy~Jh9k(&4zVrjvxkK zRvnsay2mc$mv8D_PtGQ##f3Z)DVv~$E*7i65_ASf3ig3WjCI(DuG;#FL&$$)hL>;D zQw<7F2*MoTG-@Um8;_T1JG$GoQW46k#d+ikfu1}gY|eniV4Q1t^V`PC=_GH|JdOfK9uJ;>D!W?4+gd`3j0N=-p@U<8CzyAy}5 zcw@7Rs9@)3*mRVVVAXXp9z##5n5aw=gT)}{B;jBSQ2;UuDXn9MHj|Rm_0h}rgnd{x zRnK&p34~g(Q7(zWqywYI#6&y^0_Ws&%Si==B-laFAWBgMgNrJfqFkyN8Fu!&mWvgnI;m zqipGD)9}gZMVvZ~?wZ|QFQ1^umbTU>UxRyq zJgY+qg`S;5=SjqZQ9U&pnFG=pB29aDN3%|?;84lsBBi5;3=U(S#wx2(MVOK-b;(vQ5Fvj*m$s zi3~o^D#-(<5z1iUd`fCLH77CvUxKN49^J}B_zUSWO!yR ziBvlpp+MHgD#gs~n9N@QBt!>duu(zxJ+>Ns&b7PZmqz0$fO6QNO=|U$w1%2riYf+~ z5XdFJ~fEETd zNXrH_pwmdo^Fd+jVdHycRH@EiaP)3eJ`2K_N{s@Lnvee~7KUpb%O(A3hXQb>a{@~3!YVj^RsP8N7o!h@3;O5CAddMu#W8pmCM$FZ*7;>>s#3ngFtj0b`m5E*bA-wZ=rB3m_9L z?k6)O+Geecjq)3v20FZsTap_0oW@n?y88P22j09r=!AxCQhp%_j`k)+Wqt(Y5_=3j zgCJgbF)+8fzPYVMEvlfE5K(OcLcFRZub5r0YwsO+{rb(j59SsQPoi*fiQqk5-R&9? zBi+wxA)JwSU1J?t$Wym=v^OcUczB81e&()-u_o`_4~i)?>T?R@jk9p zsO#+RY*uoJ7;AX@JNmWJ7PwR0+TPx*;*)UR0jX3_glcsiNHZY4?w-C^Z{EJ;qZ!(M zo5(_--u8|*t&oCq*zy!Hm}K&KIT55-W23g7L%`TOgrt|$$h43JSMoJoz1^KX1MffR z-$jD_c_k>PT&!wrYlFNv-f1g(z8`&zC9G2_>x8VFplc_c!?MaGx)!aZlBezI>+R@% z{b}(13dFz=&gXA)#?vIaR-LpgCqB^m?6$@G?j@BeS~^?mYHNftxIV-$y;9ZH+o`HZ z^E!YW@Jg$MH<-U3J)ghD5l0benzhnuT48#`1KabbJd#=UZQX53F27Dy$05RhDKC>Y zw(2A_yz@3hKUQOB_pf8}>+gUI)~S_Jp@2irONx5zd_SeUp}nVF$rqudMT(EkVdyjV z+~BLrkY!hcbIXA%Mu#>(=a)tWsV8Yrp~-z=Mz~)RL*CrkQjey33N{g+LF0-<+_JoA zmm`}tZaU(O$u40qe+_NC%Pu61NUa1pqn3+BTt;>TnhXIxI9ws5aT$2DAW+9GO?-Ie zg0-FXg>y~;u?b0gp(ZeL9zouk9kzRd%>ZsusgxiIg|y^|OgdLA;tN5R)3T%ENj#NK zC8R!kbk{!uLam+EC0m!f2#)vG*nI8AwdOO|Sh)fAXo#C?rHGXm6PX51nHFMqaMPA;2yfVI*EyKZxxEK~J;|(E4u>Oc?CR7B$#LP? zU@H}bKLHiAMJAmmZ;(Smn@t6^3>nn~Hv|(?JV2h&cjPYdfUPcr5IN zR;Sa}^TC=~$@wfa9&^ZKh`V6TDBG>WJVb9cbUvY8kwmVlwXqX-ePawF__89O_BM2*&ah_SJS`e50qtftqBrF<44BZtQ3 za~MD*>gHy(h*=B;3N{th9jGB_>Hg=;@$uNC68(HA37Bk_tf{-FRZ&joq65~@h%XAE z5s^~Fg{aW1gg?VHyRC0v0jD+-}Dw(EH#i!AQkZWlgB(>xW zd}LrqCPRcyfM1dn8yguM8lS@uf(3Y_Si6l-AfS^gBr27p60}AMrGhW!vq%iM9zLkL zxuGUM{O%1GOr9Sk^~4x2w}(-gh17CzB!zx-R9jQagepygpoR;wfx@V&WKb(5YF%?@ zZ%>n`B-Z}a?T2ysWn8d-UbL52bRL5%;B(OkmgaZPycL*;Mu%NdOGR)`4ub_RtVPq3 z#fj%VPsuGQV=+h>kuiBF1b&0}IC~QTfV+&*3BZ1UU!c_xm9Pf&agkKr zsD;8%vzk{F?G*}WEzBd9abe8toHD&71k}tJNM_95qV*9Jk9=+oD4GVbK&IBIBrunH zkw7Bl(K7-A^ypxqOb=UM@@ppwV?8eIG8^X6D8w{OWIC~=xQM|KNu=@y;8WhHEvVF@ zj4&^dn`nkuA8rq>{qy zM0|YIV@Ky$JqHLN`$n@c6nZL26%qfyYROxmbZ5sqSDixBiDY6{QWgqtwWOMomzkBF zm5Rqaald}-4y1`NK8ME8LoXZnNx)&1WQN)8HiqlBZP|VSNQ(_(Gd~CA4h5HzlSiV_ z>9o@PXTeS<^v?olbFxt%!(h^j%4+z6(cSYMJN(;PYjgmV?`V*}^4YX}0+T0^$z>wo zoG|+nS!4b=f(ed{#rQkB1|^s1^9U5TXgoqTqJjmbJCTsfLXk{_jIz1473z6HMuz`| zqjr7~u@U|*jvfy@Y|fl^!;wKUgJT13D~tx0Lh6dvOwto`%Ea2v-j}_--K{Dv#JjC1 zBi*^-=#PoTJa(`GSv6Wpg>l))KWk9hhF~OD)T4C`assZ9t7`Acd#OO~&Ty zcN}vB<5>$Sj!2W^6& zO2p?f@?wMH@@SP6w46w1%VoxI1s^AFM-|>^cmY*{O{MTut=&D{Eoz0BtG_+4xIJnn zlwisWp1(jHhmjrbX>)Fu+1G`;E_=o6$wE{~g~ahWiOH2~+d5lSf^xLN3jP3W7@AR1 zE!DO(Ys6J$Rl)|aP;m+l<7a>Nu%(@UYzBo3=@5sUhKExGfK#WwD5-y9HEFuE9Z)(JjV0ThoBl8bd6e#76e=|&f6AdILtFQ z9JW(HNmbXd=9R%f~GmV~PYK zpI1UY#Ni1c0IM5>m9#SOIhBYnQ{ez*04rcXYCe%%RLlhW(?LyyQJfKKe`L#Ab7RB+ z88ensOrpU0fU#dZFSbI462$VxuF+9Zp3%DygG`592?7erU;)nd*05~T-4MC;Iu(mg z$t$6ebK)W(E9dig4Q(&=tCj%IpcDcwT%7%)gjNn@BL_VY9Sd>z@S-(VZb31)sHgW_ zePVOSRC0EdPZ&r62D`qs$0HInLK&S3l~1&g!y_j|;GRPS1L;f2ClbaF-Z)@k_c#g{ z6Ljx}LvSVp9GKV>k6?)80#$RTKQ^a?Mkz>-Papyh$k~KQH?LUq*Z)yMn%`A>{p{1i zyo3MepcuEn=O|OQcc#4n16#F2qM5ycP z>28FU-wq{d&EHuy{DyIlP*H@fu}CJ{2fStp*KTQ-t%0E{5c%t4-I~ z*a+JN@yX_b-mFg?P9C?18^wl%rV}Q7neBp7GPnhe0eq=d*2(xl^C5XP&`xMlwL;z^ zLw)h8{i3nIxqLLB0_lzF9Vh!AV}?RF<)~MwRgmMs7?F=t7*faw>flDg3Npay+GD5> z@FCj8g#J%g1YlsBot+=Yq~sN&024_hQmLMMNU;xMi@0dCk$~XK#|PM-afmJE)@z_( zke>|OgzB7VH(NXFtKfVDa#4ORszDmWJOOwajE`}BlAZ*V^a|KB1LJk=$hn88x@~KP z81tg^e>&&f&RxG$4($b6bpX$nemXaqtfkwV?t)vDx>(qkVxyF7`;<8i(|o;GJr*ge7JGC}>pCTawf{Qv2k zr+0m$(dYyMx-_547KrLw;s3{Jc?@Xxgu302NXaF@`2LR0q3NV@k*1@kyAAlX@R#6Y z6LE1_q_SG5F@QCaGKjR=hOXCdUh2epCk%tD#-|Sw)Vu4A>V4#NYMTZkDO5|Zs~iAA`YryP^0eXhFpV9%6=9b z1brUJS1RdTP0#DM1MTuM$e^8V?E*3xe3^t>3BeG?&!j6l-wdKkhzu=17{3!t%cYf; z5Yq8^==D_v=j`*k$gI2N_?I~ z-KZAP(;`wK>uypD;I?`a!`K{vgk{5p`;jR*Ac4;9S}=3nS@&P!64m;ITqvPR>l%Pa z)PhocL|#n;lmht_=z5?6BF1hbf}6C@F*27{xoyjOh&}4zB`4e>;2+jNBciOF#bA_G zgEjP(7&ajWTf|d0H#O7{i`jBhBZKb~Jk2izWV0lykO_lxA%*(Bm9_TnL&l7sIynBYb38?)ZSU-AZ&GVpS~WuG z13KQ|7}=n$+kksJrgA~uBFK8%*b-4=_a4N^5HS#%3_XQZ7wSVwg;FW4%8zigL~~Fy z;$U3PUbJzrxv+P^R{?@7yAf8vQ8wjqbT41M)Nyh`a0N^bG&cwd{x%k?mT%g&Y3a1V zy&lO-G_kHPCvh74-oEMUP;(10cQy{5d|Dvvcsuy6FMafRR(cFt574NjRYl1mcdy)X zbhW>7V9_48P?KR&v%IXJyrHxI)xb-rttEP%T729ukKZ!z{&i2(XalP>GnIk{hOQ>y z?40PQ;rK*ckjwEs_HiWwfQO(o9pX*bz?)ay%Bs95kJCpVWY%bU`g>cw;_~SgmE~oW zqB2=aZ~x1#Mx~IMmr10TQF5YOEUyG+Gx-ueGdn7oCTZ?_{i<6dV7`cRKkEYJhel}D zSltUxEk?^r73CsbS8q=jXd(fF!BaGd%X5ORTI@C$8rdJ|gCz?ad;5DknluXNt=ZfO z$t@Q`Pk7lWk9a);3oAL$w`*)}?`V|O3Lr!^ilL^m`gRuDc zWD1y3t7*|+UyuiA$iW5sKXMPkr4gV{EvwfwswG@O13Ere+SJvd;Sn*OE_PR}Tu|(k z6ckm8WY9A~p-@3$LITOmPf1S3W|L`Dw5cU;gq})0l!IXXRW*_Z1&@*(8HbMz@(Ru_ zA+dveEI$aS!!Ypj_MQJ5`lq#8px!DCQfxI59k9xK9p>?~@xdveq@bUNrY@n+v7D7~0 zlcqsbTLZwZq?Cy?Esb*4b8K$8xS1F-;3*V8Kuel9s;?G=R21znpR z>6?JMMzfN~Vxc7j0kse!l(?3Z7?MN*O$*8Z4$k15^1tF6j-!)ryGIjHNwi`)X=+^ zT%&R*;6usaL$uO@0!mq}RM*iB+$y0ZJi7lFgMXHik1pgHL*9x4t1$f5iF>hmv~m_T zFW%?MzDvG|1bP{@pa6VGP*Vc{RyB8ZceQDRr8sxURme2x_XB?Mr9w@!PR2}sc*e>L z3nz25WRIo?04IYBh8x)1EyK8#A;(@4oJkHPK3Qu)gjdp}Ccc zmfnHBHaRWcS-%&6KMtT*Km4wRgOfp7h*(has6^RAA(YfB9epC=6LAp{af{$TF^igB zzIp$qN6AdO=QujLfCXhTL2a!_As4byerr_l!SPY{P>I-3t&PAX#AAYEQFbh3%G>(i zz8mO(;hk=wbqA@ioR|-@BNVata)m?y$VR6!${vDR4xG9vCOYrW;uA$>Y1wA*+!^O!v5wP6e)~K!%RKkfMRJG;h6|$t@MsiJ)PQj@`Pqs-a z*~-?g7WDkvg*|qN!Qe}Pw8hc8cyL72U!gxiV!=F_gaQh)Mgos1o4dN2>IIMu0!e|K zM?-YH%bp#hRsBXOJ<0u`rB@<_SFdSmYj2d$q32I6$uEEn7mFl{`Z~xTx^z;$ST5z) zRIr6`7B46G+R9B3@BfFXvscj$1EgSRo=C=rK@>|tqnJj@u3!oE6Ocp5gkpmb9-tEv zeJ`$9b~Plwre3G3ulWTdu$>ZyD9a9Vbo79x0CX5y8>$PlBr+B7tAr2Tf3$gB$z*Py zaN@wi;}2WL46TE$<}gdMBk!KO=n<7yt!(c>O`F`PR>))`oSF^zt!1H<5;4E4;KJ=l7i&soOQ>5*F+1u7oO?cVfz%6G~N*m$o7L8n{{xH@9 z%21nO$y<;?4p5TQt)Nklc!3QFjl<*O^D5xLLGM66R9We-x>dELd@6dt28zA{h5kSy zbT^h>*1JBRnTzqb;}HiMj>9a#<4{-<>5`@%=vRSEQdGX|Q1KW9IEpA0^J^>64g^>g z#-Db;1*HoHDJKON|S0hmGrD>2MOCbl8%&V6j?H#RZk+eYz`&g2kkWMTIFC~^ZIpf6IyqMb;dnH`5EnR<|gBU@7dTp zJ9^=%F5`wK(=+uR$Q)fUgcu^DN}%a|`>wCm)W8F9;}KWF*G}LuX%HH*;SjFE@PUX& z3q+Ib5<^S&7@)JF9=sWDI7u34fo0!|>-R-+y+<&17PJ{*^n zng^wS2#2)fN0&DJF=MG->5qlfD5d~Jo`}t15%Jy^58C}=;Tm*&5f{BRw9~wtJRUzA z)d!qH?A-&?iY9+H8ZjE1h4<=}8h&p~sH2C0*W zoFNxvOWVg=TgDVbPvU7HXBeHtk0b}c$n}O%$qKf>;`>uAE4wx_3dp5Lc;Jj>* zUX*oq_xAO5H_5?xSI@eDuE&OikFH%VtOYKWD|Ic65RV_7-v+sx-ms`Xr=rkJ01edI z-T&s@tKLRo3D(7ZR6E7Rf$c$(PznmEa1y7jSFZ|DQ6-&9tP-o5dtbkM z+t(_i;l1_X2G+)e<5N;op5Y=Q6Y|RI+DG+><0iOX^pE+0>u7$m%4}$5A+3_bmp8&W zlWv``1Q+;AI+Z41K(1r_-R?L%O)rzTf~PAO2`<~<@+1+gz!g7YJUAY31eC$9289O^ zl$8@2i7F@Yq|Y0(bIGV=bv=G7B(J)m1zM7#(l~o`bo5KVwE!fc9>W3#g;m3@q~=6D z!jCE^Iiv8>)X#>2*PP(6x30Yd8u__FmzN?rhKrV73N;v7Qdx=is3r90DVb1B33l^H z7?n%{3N(2j=0TYBK-<>c?P^{z4!i+D4k89UhJ#B%%@apoQyTy1fw!0Q)stw`THD$v zFDEiV4mQgHQl9$kx?Ne7{q)k3;XMc+COy35v|C7gQbN+tKL;mA*c?4{VB4~da4;B- zT-8B$P~Yc<9MZGM5J6_{GeCZWy0(!CVq%EQH`s?PK(-q+>r2nP6Ivc+)W1Vd!O-u=kx1^f0RYZmO=GG_iH7=69ba(L0m z$aE9k*hTu^%uKjr*T6+?=wEV^850*7!UC|9P2wl5Foe$mIEfBtZm=IQ*#Yk$fLlaQ zUWud{!xbx$)=4I8WI1wrvdP>@E08?~@Zbd#oAHLoQ^X_?nPIX7ZnYO(@(g4JGUc$5 z!AxYzEcAYchN}>hwa82`h|x{NU^jxmFLTjnOwp;p!$=i+9>K^IeQfUN3rvg+4dE{n zlfO)0RezZ*Le2S?$wFiJ5j16;@fq~BBi$xj$1DMhn(Q?~U;VpD&-fJvd#9Of8~Z2B z#>B@6wFB~KtkH2JczPiWr!iS-IKjlg(9|T~(AdNbF^0!Co7f_&!N3#X_uotw8JNP) zamb=ECOL*HV6G;J!D@H}-f%QBBAIw|n#qfC3ydm^4aOLogiTp6X+M0Bf~kq~xH)il z#N_q3+2g*MA&-%9aA7FeBI`GkRdCk?WSq%t_}1U2*hD)9ZYI$G57awz0Ksx7&7W+qUg?Yin!Uwr$(?)^4}`dwMQ1lbPqc$jvj!n|u>c z5E5vB0RZs-z*YqS(7&eucmQAkHFWpS_cU6ZrT+}Mu}aRG<*c)7Lm{PJKunA9@51Bi zbx+bakND${+?S(}xWnOkIjj2hk7u#_pdf;brNV-S!s?qVt^Ab3rW}IQD~ON`Ba>Rt zct!m=x$&&+mnwknl(4I5b95V%458@@_CTCQ458)H^pO#Z%V9-KHhU@GS_Ax}^b`i_ zgQMi;DuucXkD#HK|BN1O;#36a(OD$WLDst1Sjct{6=alruog!oZnKdYl1UN&JM09A zCq*Q>@Y)XE?^C@2R;wH^%^U>3Cg;-nL@;#j;Qlu|d?IBKbVsmpw zU2oe3szM{pxTb8Fo)79-KRPeh;<>I*g3j$MD$Mx0gw8^QgfHp32O|*T-ND6j48dKn zj2pG^wKrvI*q~-7G)3CZ5TK3W7s@$|-n+PVOb9)sJNJ9_({D>4J7m;i9bA3{<%bGo zL748S1S76&#fm3~{3K}W=&!Ku6bRh_k1j&9>nzwVK^J<6xf!u1om75(Y;*-(fej~< zCI9nLaiUVN_5S2@?2QHE4d82FJW-at6(5!cToC4^<3QXgq>jAIA< z+j`)=Gk5vS!@xzX9$2nob-92IZmgje>cOjFPjBWGjZp^KwY4LtFS4W|tgW+z3D4aL zTY;!@#<ici z9Y8>cb~`9r;eB8}308;)Zy#A#vJ}{R%mT3%dB1nrNzp-_(o&J!ul22Y_N%+Zw?Qeh zLnU~AM61d0fho*L+hhc!gyj6hR|TRDJC%eADb(mqK@zibOI>h=)3!3uGx$YwSgCqs z99nGwmbn6oExbU*L`^3~{0h0_% z2BzQpC2ImMR4Kf*M%0QfoItg>Ru0Y!Bvn3+A56`Mjye#|T6O`~F>w$yEE83vr#*hI zDRyk9sy+54;97{ULwZ)BBMAVlJp86;m4k7R_D+VsO15&J|twPG=Xr2xDwiG#02|IS3>qg0d;@+KUs>X>%@_Wqy zqw)27B6v?(%DRa(5b=g}p*@44v&1alNCmFO|2cYD26+y8;sBT)Fcf(^p$z9dNZ9CDQrpp>!MH00=(d6LxrG?)T0gKFSXhWVy34BK|J4GI@1|*3)jt9W#c`-m(k4@x8jrhO{_pc)JMvZlf zrJj4gG$wuj-%9`>GNm!+paU}(lYJzk)nLG^4N~f}cm z3Py|-+!{ICm5~HRsnLg)07aZqu#yX*2og$S;;ACGEJzq0n8b`OQKBbe0ab5PDCgRv zEz$%}D_K7CRqG0O=!qOl-eamlgUnd{dT7G%%TQTR@wuE~_;oj_U+d>`N5F4=GzVG0n34fb*S)TD?)6 zV333nNZ2N+fLnVz^&%%GUnvW`)MKA)w=BGHSI;zOE$7izAQ`==lcJ$Z)FAlVsH#o%2Z)Z@7X^pDZiu8*H zskv;HG8zLXg}?K8&|BMKuiOb=WRi;8qF|42lgjCGu)*|+C62;=O+2vulYHWVnUf~^ zVUCFJpvRkdG%?pAtg-;EVDi4eW z3py92*9VIYuXR-cWb4}EO?xEUmC|J)w#fJ!o2I5kB85`JMyJywGm?{{uX@D7uc3nMVW8$usMN~NKK$oL466$2_(UsoNd@x zHQ?K9wDjnCACr{Ggw}wiGjPGCynG5g5Ahq}N6uyKukEKu8j40adW^TUG^W%URat;{ z>S&O5X~ z(UC!Tx&idh(8+B8Lf#GCPZ6uo7t#zXNaD106^N%N=b3d@FEMnr!RPi+Wxm*v>4o0s zFD|#KldlZXbS$j}=ozM)&4mkfDL1k3&m|6=2GJGhnKF<;y%;D<5>Qil`xvtWc|Y5S8E; zY>0#RBs-yh7;w&$;`gXUTn-2He0nB|^%n$S0{N10og?3$g+6W2i*CV6>QbU^@S$J% z`Ub-y70QPyR+aKrjItJTzaL@k%h|@~9MiV;>wb0vSKJG>0kcF*P_;gaXPt@bkk!YnOSMRm{{;En}$Cr*~8hI zSAPN#t-Ph0pl`n%IVgHxiPT_I!^^sqGMbq_NtwIWP`TCG6@)&PfPT`R^ij#5r#iJ#Ir*W_fZj7FMiuP(<$$|Ag%9CbE_tJhO5Eeceh>owTR*?~zrSm9=t|~Wv zRV&lpy^pE@zS2frK9Y%P006vfBT9c0b!la4+aZI8;O-sFUX?AJlSa=@^1^B=BTics zP+=}@Zb{L-!pq!D$YG3;pI)6WPsASLcWbn?0Pb5G&9KSceD0L{u0b^s(!nfw<&J0Y zR0$%nb-&nwPU`Jv(L$B&X&f{bb9gNP4VOo%lj)FqE4kMY-qeT+j>@LN%_CIDs5L_-QJ00*~M^ATWtGA z;vI{6OUwTmpqs6Wc=fyD4z&b$_rW~m5V_ye50I57Z&IgY1q=x1cf_myf4E5+pDS>u z^B>2lE_>6DOc^OzGb061R0Czt?X3RK6J?wIcN8`~=bwr)N9)yyg~~571-PE7D>Bx4 z<lTAjo!6e-sSZtCf+fn;+A7ys$9>-DoKrkPYYE8t+gwlz!OHK40fN#uu>TA* zc9mSEbN8m%0sfXobNXnkUO|~Vpu+D&Cz;d77GunzwZBKnQMG5L0ghVukCuso2jjpv znT&Ub0=6UF>7S)OV%b-b(EWMn03R|8r2DBpwh|e;i^PxFfL*f9AOjHgT(yg|z=C;i z0J#QdwSH9$vi|*nX_W?-Y>k)@^EO5YqJ)r7M#^F{CP;iWC*veLEl6p{g5B@5JPMg5 zB|P8NAO>x%5vz#WS1VPf%pma}c!I=TSx*g@Kh>HK&V`#PF(A>22q8%$IY?LqYtf40 z;qTye^tlDm8$l*HoI?^1lK6wdu6zS#uVuvEv&Qd?SZBgE-jj)L7A&5*F>eACHK zgga1eF{+{5;T!Rxvnj2f^Bexc`?Qhr+`@WC_U{e-X1pS(nau4Q|YKV z5p?7Hqz-z;B|!YOSyMJCH{ZIwxXkttyv`dBcAyL@9RTqKhmYe->F*UDf`JeFu0oXn(_n@_z{u_DoouH>|n;^Z1n& zFOu;njCjANxCh|4$R>7Uz}CgMd^scK&0>vOC{GS`I5e7SBY}h0g8N^wJ%ji83Rj{8n{`#BKK|A_C zC$KUL7oRzPlLqhTrQdhhQZGIxCSNOB$`ma*3U7?%?u4;Ro}M#uAZ8ZpE>-_ZJkS0y zirXoqQ)>>c-fGBly|hD!C2*Mo5}k8us#?SSKCs z7QTjI`j4JBgH~XeI0B`U4$9A=Scn>&(b`+b#5(2Gcfq2hBoCxq4P#?5ltn5|!&!lH zZc}7Bib>QGEUHW5;27VM-`cYelS*TlIx(21CFCnYZnd|dt<#ormd7;P`71L}@qUfo zAj`4y@L`!C#=SLGXx51Kf52j>Wue2R$?_RG6v2r)Ou-$U&LBVFPc$B=;^NbMcFi$T z4@z&2$UGEb*q$ZgB;>6*I4jZ%!c zCy^%mUm$sJwlFE_DeM+W#!=fP?cq}IY%L|9ZCJ~1kbfP4!M*jV@1*m@Me;BA3rHVz zEKvB&ni1hYYkq5t;aeD&1ZvjJp`V*2w;#ESAvD#zRNyZDa$<;^ET^T)#S-Jw3D5(= z^WYs({DU%MicoP2;Tg~bE993F%GWDCj*LZ61ZNl6dFQSf1&&$Pd0@MYfm$voz z{j!~(3ylpSKQPz9YvFaK4;gGf8THQ}`F+flL&p)*SMwiQt59!(_onxBZx__-2w!NX zBLO}={{5*notHmX_#w2)?oGfYMPB9Wu5Jhj#|#bCsexVjE`F~A5&j;hcPM`$YKX)< zNXqu@G@@Mal=>}$v+QSAk&VC=n;41ox6JJRs+wfKq8N`MRtiVW#m|X;3rp){q+s6!VpI+5OiJ0VO_qI`)q5PwGLmrOtgltOzw0=V_SmnHEU&T?N+bCFSCD{qpmC3?ZUvD@WuK2&@ z9JzRJ=r5yOma=B{)TD8@TqYvZGcx0h@TU?5w*iud^L8e_6j0-gzKtc8i(Dlg)#1;4yf*GLI;fyEFO!&^b+#+df z#P!y}POy;FJ@k18j#1^bl)Kb02X7Nx?l*+*TD*CU%|Wi5*8ZVsaj51HVj6&&`Ram& zLz9A;HQCGUSYHjR#aiEK!370veo{^;+&woACZwhlLoPA`+_4Vp zgiHwfos3C#H^Dav;ugvym*n8FZy+z>;XmN*mO1O&VTY94UhMRrv7gvRa6| z^VesM?AXN|?IujeHfxjyWP@UP`;+3G7W-o+!>E)r3HD;n*Mg2=LBh;;j)N#=@ z$RcHl1v3o7H_UMk$uLg(Lo#&5aZ)JT3RSB$GAKKJ~DtF1FBth|Hq@fP| ziLd972uvcZCAt7m0wcy5+Yv=}q3`&?__y)ltjqas*{YaC#3AE81aR-S>&~%rokDy- z&pk3t3in6<#FZ`33tcN`2FZSH4SF|!C7?IW1P>Btxq0}R>z};C04&-d(ba0^k<;GM zvGgxquK4U?vYZc@T@Qlwyxph_eHhqF`??rYABSxgVt0y4)Q)OmKxi>`EPfAcqy8)0t^>!eoHs>;2zuFAZ$A)XnP9EUO zgVutKtl3c;x7U{cb1LCA%4+;?7>eD!E_EL*SUId$g;ZwR7%Na?&#ZByo z-T15d4QwKaV0o6jNg-iVUAhGa{Z6`E^ozE+QL-ua?^=?Z9$>#Yg#zY&sIc4w zcoyf%?=~Z{x^2<;39&SozM1OC!f%em|06=6|0Q7nxwY*njaI_lJ}ie@k!&X{;c;AX zgHv`959CP$CY$o$@z>qjt5N4@o@sDNVxeY-LAHMx!lQ$2u^bqLhX+Vx)RZ-?8!E(G8uCyJ%MSNr6rN?}Gi63BtWO0ReRc;kaZ=(heyN(5|> zwKRoLz6 ztee17{9cCZ9IE?cUxx%GSY{P@mpSOk1DSy8XYMJsh z8%(Ee&)qv2a43WE8@`#lTY~7#3OiU7lF!z>XoVgxW3G@;nAVUchm8vTDh@p0u$Nt1 zceLfBfU`Z@(hx4&EZVLMws+g+E8_%b|0THY@FWzk(R2kp^$+asj)E;Mz{6Vf3dqTc zFx!1t$dQh{ASUkn`nHeGK+64|r@r(Qt7Cp7Q2F4|_{I*{aikt#bus5HwKn>BQ zp=b9)XQIJ1Hw|HZ6gwT#>qgU(8`mKH7@{UcL^tRXw8P+~^$>VTupIJsQI$`$EwEhR zdNbbQMPSBg1gkhHdtRAa;>Wpy!IFO)xRFUj1-i2rT9K>Jac`LgKh6ho9kQN!Dkw@S zr`7o9eXrtfl&Y;6ikdcP%!YFVTf{VpeJpEgqgr((L4<#V2V3R>mFU$DOI5o`t}y8U z!Id1=-J7oL3nEuYCH^HedPa`AcQ+eE@7-;(9}guewKyPY`Uw9g08wbYiOdZna>V&r z4NZ2Xys|9o1&*?=?TLv$@Xkoz0MkMH(o$PAQc3vTu;gl}N3~2KcvBpFPbqINXjK^; z*P#%t{&FUk5V8@mO^)c@L3dc7S&Qn z=%Wc_j`5@n#p;syHEIQlFl~<0FN!F@b;Jp<4aZA1G$pq2-;o2>huQv3Lpm_aZr=jA z{v-{Sz}f(W`SzN{IS!6oJBEs?eDRzX-xInBSYN~9jnK9}i*msccibT1P8XLw^Hz;}1W#swi2>GopVA2qZdq&`1VT`W? z2N&eFDG;QO+LG;{Df=Q~@PDo_X?plDm6a(2GQwj)EG*jiCxa(46vshCrf}nbPSe%z zTEJI<28HrRo8s&Yf{KJjw}DQ2e0$Kb5-HQQ9aKtnuizx5<;LK0BE1$I=d>_%8E6MaX25~2(*<@ zDK969lcxHS%u`O&uWZij>|U(%-ln8htW-0nE<18GWIp@;Akj5ZhmN2brmm{Nc`MB3 zxgf7#7;iA|T&Zw!LW-G;u;l+Y!P{A!q-Ce}+IjNI%H`~r!e9&>Do<}hMb+n0_F1g$ z{=6**=K@6<;u*sa)f?FMnr-JWg7#4$d+@4u#(jjKsIIC6zhNX9*r40dQD<4MFg@ww z#MFs)GCJ8A%1#@%CZN<`3Mj1z8Pb8xH z-vIb&e;mJ%)5N(Gp{IB0)I_ z<@wHd`rD3;`L{Pqy;TN`b)7 z$}p2;`r6F$$=dyF=6&koqjp!bwi{ql1)pR_f=uZD&=Ebt4kl|%x*A`x?^OVhGeBgE z4pS(yW4>q_%-okC-qLi3k2g86#S3~eler6l*`)JE{*pyws*mOc2uyDnWL?gtI)##^ z8Z6|T+lCg)iL~=8SZXugjtHM=3v+{9a*auKW{>-N`F~NRdsO=e^qdt9ZWTO#(rw#@ za=s4DBiUE^4TU1%!YqvXpvbLA_yy(mMHS?Gn+MzK&S&Ers$U`njtB-%8^xWp3Q82lA&g0hc}d5vIHD3Qd0 z%+o;p-X#(;;=7R^1PSTJ@mXmzqC5UnFi~*nQg+|)REWopoa^ft_%m=UXFR1{06KLD z=Sb{U|7_>e0MZgSOUf|8cVh@8^RTwBQj>9m{A4v26e3;2g3)mbRqEWXO20&+WWY2r zwz?Tz`YF+caq-Dx96JUON4K|i!>8HF{aEENBWb}Y>&*3DP!LOeC)|I<-v4Vaurl1$ z&0H;6^Pqh*u5U?M5p#QFZQIIGaHXf^yn8EfxEx08G}O#{bkC6sc9U#*U4zrP%t8#kwnF(P)t^6&gHVMpaWyPVyYkDi`Za#uQpW@6=s{<%&#+Uf9eqd~&X8~%%ro5IrO;}SJB#xenptV^y$}mG4&pLF z$A4(|y%&PV@o1S4BV%ILw2vVce(|&^+*i)@#u}fPZ7rIa;B+EfFB)rgmkvrK|E;Pp zlePt`s;Sdc2Tyn=PvzXTf4}*?QQ0?Vp&5)OF==YTynbRj5{wiv@j5PVNG>czOB^Uwlw%U_c z6p~eogfkYli^EtZT$Hrj4jFxX*4Myt9oG#L{)!5r@IagjuP~{(s+=6MQiI z5xXE#g!eEzL1?%)x|jVZm9GQ6mK#sAEBNM2r1Sx*<gnE%Gw9F|C%_c}WoS-T%)3 z(Zm5%-#3JS$BPtlm8#ir)S*y2Qh9pY``_y)l{bNk?)^wDuirdXZq6{?`Pnwp7^5~~ z$_u@B=d$qPj)_+T*Wmp2n`>#5q{grTfh{-4_%cir;NZnmI`d^({4e$yzbLvbqCa%u zoSEb~Stu-~so%?_lkwDG(P~g`19qyHTH1am4S+x;+ML&JR!HIh+#whz*1d$UnP{UB z0{GAC6zmSpnk$Rph=>02&V``TokI7I08Yu+W_pu2s z6$(P4hm?mH+*YMsO0%%#u!PO;4P97*Fq$mvUf!qo5v5@EJ}`p8kKVc3N7G8Ml97F# z(&kaYXu`ipfym)e>-Vk&DaD#IG;JlAPk+I`f|f#2$08IIVv2IdlLLZ(L}LDty*+Y? zXd}R)d`N zE!kCuNiWkMKFTIRC?~IQzX^3TrBi(NsDd??*qOP3T!hFgUAQcIIip`55*($13q^2C z^0?t{c1^jKWT+9D>VMB6(~f$W%+{nD{5~ir6+u`gKQ6GR_mHMO-}Wnq{!DL!O%p82 z?HXcE75?bA%*%Gg=07GD7UlNT9r3t%Q^v63_P!GpCl|05iU?|K^w>d;Y+jE)BVhKw zRRv-P5J|5|y4FzkE;;QW)5_2;CL`3$g9u`W zlG=XU+j8I?%c!AN66psqIy^_Y{{B`MKtm{}fke>Ngl zr$gyGZCOPZsn3E?`9Bw)ty_gMU(#UU$7CtGFyXEA0@s_j?Jd^hBE|imFC%J7J8_Iy z8x){izMB?iIKm5#FWH^;3G>B^L!`5{mLr{HMjAu?5(*AG^&u;5UQ;YGVdA(KqfX-a z^TZDFC9*Vk0Qf>;xASN`Dzs-{g$T{83x6N>DeXH?9|Ri>R?kig#2!z;pDwR@hVKFn$i7tV0+ZOfELEX77A zmO1s&3V)}ntDWo*xl?Fw{7QNdTv*JA7^2%!a;H;XHMA-%Uora**R9GCs((Bx)er54 zGTcpuKZF{Y@qq>Z*xE7%&5xCvvnG;fAe9ir+>(~jtOOU%fgA63P^{4;bB^W(W7=-M({`l0N6l)sAp%BL-jVxg4NP!82js2BR_pY zh+Q*|QEO#v_;o7O3)&%iI_Y0R8eqh)N-22U-4*xhg;ee^~IR4wPhVpydoh|yLG)ilCyle zA>VjEJjLug`IT%_`EGGejq zrUs?%cKtZ5Qr76Uf1N`r`gyvUY!`@ieeD|Hj(f^J7)=OayTaETv78$`cRR zXvV7Da8}uk%M|FJiU@OE#+Q2rc*Pjm^}Oluc7>06b8|x^r|cI+CRHx>T@aNAQY~B{ z8NT&{KuZru+ROY4>;oO`6aSfFCXT0%t33QD1L~9-^1q)DPn}8Y@{FL7@@uq;XFJP; z52<9W^sqLCJ;br2Ggh#px|qcK-0g33j|Rr@o*#LQT<8fa(W1-k=F7z>J9uy89z(E9 z+$JP?U}^G@)P-m2!W{;anMrXo&qhMEY}%$onI6Z|ih7FG?O?gx0CCnC6wsLF3^j#Yp5I=4qb`zt8!vuthiO2t3$RCo<4bJOUE4d-4CmUi^RT_7X{NA zMps)>UP`L}`k7ZPSlhA5vD6dz`v9`mvBlz3b@o|20eupV+f6UQItOze#Hln}kCGNt zLK140UE-^2VC5&pI|$@JpMd@1Dv~1yWWkS&sB;!aA4%|W-3W)twN-iKzt4&+`SMcDXPKT%6;jo!Gp-e_Zi5My5>NC^_34?m=#Z*G zv`VyL;VQ*CIaES_jDKEGJtF7({2qE4JQoRL>;pC|pIBPJIxa2o>7lU@WWSjqTnpTc zCif<%auH$^q*$LXSY~iAjMBx-Um-Mu$}e@Z2q{+g;NRWEwSxU|XfYzkdW#<-GShuA*-9F6*ohX-EK~Hci7L{`tV?d1JAFjjDx?44nESc1l_t8+O zDlZ`lU&-<%o?l#CKp_Ieq{p8WH*QN_3jRZw5?}z0UCEd@pMaOA`!QEQuV$>lX=({@ z&+kO|vtuu~==fQ&C6mP_9|x8)-4rtcWU~qs&8_S2SM4sK2{) z%H|=T7cg&JWAv2GgMeknYFBBP;rWBMRG;lMnq#OrvV;KN|8N1RkjFQkhde0giBW5^ z2H=)Nkp%AiQG*JYth||nk)qPhbpbXQwvJEwe$WM}1=9PAX;iHOZfCzO-&xB(P`X_B zMP1{<`84o@W?Qtouxg1KL}Hn6zy6zRB*9ZO6E(|c->^l_!_qNs_Edf}PyC+&CMElj zvc4Dw{7f7-rf9Tmb+6zPfe1H`uf8wy^lnIO~UAS$YUS*A>ZL`IGIY&Q$ zkSm6+fO83)wTVPBOAj)MwJz4=p9fu#-43P2RVt$$hT&k`3oT0N0&FFg&8_|g961I- z@(_=Dw6zm0wNcP{56-JWHy>ndOZ&U`HpHz0j5kq#n?8Dyp|aq3RH~4_z)28^&}7$# zj5hTtd-RzAP*+gfMQ4%yUpz#Fpphj)6+`g)qe|Z`q~i3_U2B2>?xCVPy|0Ie<7k~@ zL)Q-M(iQe!vYZF~rD6w_1sDP~o31;e4!-)k6D4+}O~s|rZp^AnYDI1KLdi7R6Vz<2 z_HO;kYgEU7{p}CuDT$(cx!1&E`f<_e%&tffm_5-|qeeZqU&<>HN}u11m!j{yiAG?I zL-nX9!>C|YEuGzt{i6pE_ZT)B-0J#=^>wtaYcw?rK?HD%UH)VEE*^#u}0d$MSA$XT8cLF@|)L`vQYGo+`^=3jZxzI!q<_H zZ(n_lVWq!IMG_80gMMw9yi4hEHz@ef*w$a_1LDT4i?(+iiX;n-YkuhF=E(Y$m6<&R zbTw|ab(JC3mkvIt$@OYw!z+`B^WbXrlegm{O|$ISxW;Z&TqX zHGH%ZbT};mr0i*ewD|U30V*zoLJ{kYP~F2|O)&GH4Ze2|i9a8Uty*_pnwo9O0)Wh* zzc6aMspp0*;|Z#cmBx_Zye2?y3(7ot0sNWp+ydkBO=2h^Lr2Mwu-f-Yas3LTD7Yfp zkn$Acs9g1AB;^}`yo9%&;Uo-!V2g&Q!;?iIGmmAha;EY8P@qpx%^_-RmrVMZcg1Cv zDL!xUS21XOb1}UMvuq1uaFdkrbM=Wme~=0Aw=6FKnkF5@Z>9Tv-}S_wOwH(U&WUyp z#8S*_K>)xw<4r8K0b~#VCl}^XaaQ4OH`;~H7`FJO-~g&DEuaSIQ4UHTWtS*pV} ztY7Hxe!y0Tg&#{pDjQN232606J^iyLU)izcuCXHJ{_-FL7P@tFiWi@$W1N_kFHAS5>PW zN-(|p-+ng$0P!@QTy9oRH;iY)Z*>6$bn&L$hat01B{=};WWt`{XtbOi zx_MO2^f+A-3 zY{{r`Kck?~ChRfjK18Xt;0R?V#99n;4i~HXr=w{o_>m^Lv%K8Ms|TFVKF?Z?$1B5G z>pk^~rE6N;PuE|UM}q2--D>tAFDKI@jm(0g=yHuP=f=*Qev8Zc9u^9!DM*1^SYP`I zhBOJ%O#vf}YyR&q$};JlEj`$)XG9uxTPuv+Z&=3ZLP&$$#X*#|CF7gX1&6EFix99? z`_4D__m&v_hAwr!{=}GNgx0aNKKPw;eR}GCM4$Q!x?g-yD_pF?Q05wtq(kSbkusmb zq?ChGStt=f4>%ubooHbSF=o!(yxg>VrbU{GP;?}T&fD>r*)o9G>PqL${-c9-GjZXp2&%9zLlIa8qH}=%P_ieF z4^DG>FZ&x1#+ALDvXe^oLz z-g!99w35~7Z4#IJigD_eB4<(Fq<(T+SifJTt?H?cr8;rTQ1up$Yc;4~UmV$l&=hGD z5Q<8L$c)>ODGoKRzR5Byc`}LV$6;bW%5~BdHdIU=c*>_BDp#01yLJ~JEtINGn%Z#E zl+ts-a<+$UkL-tnygE{@2b5Y*Xp1p#WY_*j#*a#gVQ|VtGJ>x^KCJNGvoh~=;8Y8? z-%v|WkLvU1BJZ|TXTMsg8PtDWA9i>tNAR9rhPak(Lb#L`Wpzaq>uT_~+V~H!VvoE| z4D2X$hx!99>gMoN1BfSdHR5pHK3igZsG=vOU!vd?HN0|VHFS6YsUP;WFt3wm+~~#| z@Ab^}vjIwvxSGNU%U6sS8E%F`L7+UrKg`j`L12P=2&#waMBY1Sy{U~ewmTKz%u}%S zlB*KT!!#|lqmY*mCT6(T(=Mg!NLRip)=D=EKI8EG8RUtRlwp{z zj5D&4^sL9AQPNOY)B#HAVPUMKPIXzESEiYy$y$O&^uuQ7!rAnV2LA87OK7(3*k#V3 zXcB{E_n0S44Iks9a-$@_wu<&W`GE_HlFEu{%L#Fe)_44F{g;po(Aq(QMXzep=tYmM z6IPG-c7lKB4~@Cq1r|-`A^9i_z%R1deR%!eUKEG;oOjE`+Uc*UDTRGnSksSG79>cr zWjQt5LBP$TEVelk^U!>N1_MDYzz#z+=(FDl`JwC#wXV`>NDW;OA zPN&I2n26a!CWf*r0_0I0PN{Nst+z#Ie-X8X(%p~`e!~%rwWdGHhSh3)qtL5YAtbv` zmI??``C=0BU9$A%WEQpgkp!xg3IFH?BNlT&$vvm>p{2Ygv+28;e=Ay{{&6laDL1@S zlQHD%l}QF&LGX1T$r>~A^=4R5Fd(<{y$wyedok~Cg^m3kWsjwf1P7DP&SFa<)e!20 zWE#;=O$#DKc-av>sqW?uxvqE7t_vNSgbIbcG@0AO8lC?R0+>xF2ZH-9n)$<*sKKSl z-o-Fol^^@Kn!X=u@@2S9df(!lO1W;lx3*C+RJBOWb64j!>4fUDFCKR;kX-E)X_OOk zcU<1mDp#pc1@b~ypT4=33bDO(SN@<@TX4#sz#k~n%3X~B&Y~>kgtX}RFfiUe|xvjSa@4U zfG8lSr;vfAPVzKMMb{42=+$9!-WNi>G97>3zP{uounWOkA#P;%0`5V9@`^q;(4r6jWM{4b1gv2ME zmFA;di0s*>>12m~j0whOZ$gOt(oS8WX3mX%;Un5r-;-lGVDCgE(srEOSNT2kkE|B} z;FtQFc60#YXXbHMr|qm3Tl>aYXNEqyL+A`rrIvY+IVjYQYE+|JVj!#xl(`o-e_{bo z^sE}{qlxH_mSK0PLE6(J!MIhS0S7_^z#a@hd(ZClB3_QL@_)cdq5fnZtQ7VdkUF93 zgW<;I83got{CK!hUN*xFi~mBNv0U&Zr_&2x*gd#281D;kocgx>7vWO#%WdzTkcq{K zs40ewJwH=4l9PGu&FFeu*EbJJZBlspWm3-6G#5F_$)m72>`Bgp@_zXpejRUsjj z=T;vq3Ujat9pNm2&3IZ@2riJ$a|c4lL~OJ^ZFgK*%I=zx?MlO25W@iwliMdCSP%lm z6VAnCvBTkM;7J|F;K9q${HO-gDT@K*K=3_|QY&U;I$Qp=5eB1CmR6T;y5++&%~s^* zyLAS9pUD4KZ|CJy26)xhac_8*AFl6ERGxuYw5|(^EM)b!8M2#zFpc-E@MC!{z>e{pCC(Ilm43MuCNIRB^BjGSVVfsf*dXq{-(N!>^Y1r+#jp>*?^dX7VI84cg<^#MJMo>pm{qcIuxvjwV`b!OF_6 zUVM7xT8pFS7JCRD`4aCrNLGAIp; z*tx@_{fA|C8G+r8gytdzuftz(ajg`8L5L}+KqRoDvVT8pM2%iBTCkVvZMEX{;=<`Z z8Ty&yJiXOm@-pip)#D1RuO4O=>|$lYo8^`$Xj}DfN|=VAG$WW^V&CpQa`{T-k%k$BJv##N~+q z0Nkr@K5XFwLmb?X2y*7bVLb#QCXs;9T)iDY`izMJ@K+)op8F zfhk3}<`%+SxL0iBK4E?iIqj7fYa0MCPuTE04#3Usy|;ykU>JFyKbM6|={7=)MY6+$ zdjkL#;wkqWBSB*7%ypLM7&I+w<8;5(1sts(;$NDd{FwQElL~EjqH(_repg{Jd{&;3 z&;6fo6{)qHQ#z4BfD5lo{aP@7$#aE))Q|pqY#{vqcK`scPTCIOq9>3fX^*1A_p8-KA4i2r)H z?yx4ZwI9$08y9;ofR$@mT-4Q7vAgRcF5Q9!6@gV?0YPa>?;Rn8704tc0R$nvL6S)$ zGYKR!=|HG9){5@Bu6I|x!+pNz`|mt&Ip=+UZ<#Y^PU3WY(fjXfpqFmj$wlRFZjD^} zw`H)?XU0DTk>gqXt@G-~aJtGpYYVHQnS_^1KAkbly}ouP=WA)mi4E`DfQn5wpZ@8& z9s8KOcf+iD^Wi!3e4Hf7-$@A#rKit*GlMdGz9q-M?zFD`EK~M!w8t}h-KKuLqPXA% z{%;$>Y4=|{f7f+XxpEWIT!rJi=DyxEwz;e~s)x%JbjH6G^8k=y#OqUYMrjQQS>A1OT&J+No(4|Bhc7+q?A?1Qn~&SfL+ zvH02Vc<#S$RlZ3OUCJtO>Mo!N1Aq%LJ6^nO<*Tu~K(7RYvsM>CVlxR|x0Hg1Pv z!*XTzqL3A(o;#N25+Ra@(|&0o5=CWrl$;S6-aU7I%YSCiTbZBa+Ohf3 zvv*M+h8AydDgUL{`bs^P@8mfzYMF9F zhi$HmnL+c`9d}t-|Ebz*%gpC>g@0}MGavqWM`YkLZsl@1BVx{$nKj-(yu$tNxqme` zPLGQdd0*CCx<6y{#G3hSZ|6b#zwx2ACD?D|s9*WyJh(bBVDJ!xPi6Skg(Te_OpY&>B_FK`|DR_uAMa{oT*Veq`iswkCjeE!kl<~NfUOs_-#NZp)g<1wy8=PzFU(R->scWrc5%o%Vz+BL_T zBo0bl_0D7Xe6}Xzr>}5}PmIe4a-i7)X#=OF=ZW$}RV8|yssP5w-*^|?srkCj+e&z~qR8RsUo> z|9R5z{n2W9O`v1}`Ny3d)kAj2zWuVlo7<`Q?0(RB<0SXv{MOI?zopI-7RO~)ELhWS zNm@vV|JW3>n$LOmAniZi19MIVnY#>Wn>B8yb}LranO&=z0zwu$W|rqTY>Ha?)$5M8 z{sV_r@#B8=&e-~Cd3<^_GF|ROEBGee^kK*5`=2~i%a78>Odjjo_a5j{7bg78ZdJT2 zk)N>cecMF)d%?k|-i?zjVHvcw4*su}iefV)TPr`-X1~ds8+z>NR_b=gF4`NyaWA)n z+aK1)`cOY_3!8bEKjU7i9;m83@-d<*5=4XTKo-w*4f5%Z=UX>>P?)M z)_U^2J7VQ|aNfLg7>mmO2Y0p+=l}j{&!vZd?2oGK^iHqNy!ia9+Xr!f;Ab!PQ9Lu0 z=FD|jaE;U|`f!l>d*8H7@>uk(`|*n&HyospjVq3o&4ySvww`&+Uh?pIXCB)x5qD&w z@ztT+C5v--rZMvVR1oTQAl)7%sZzOA@BG4(U>jHCuhG8>rXp9x>~*!zq^gS+yXiL zwKyoEF*?toOhp6MHFDHIl3@7IQFnBp-kKx;FTQ|lok#p`!r3t*WYa>g7}4_% zk5`L=Ui)JF1>4X4_>|tRcl~OY^X*WY@6Iph-cARm-T_{X%SxwyHGGb$GfS$f6gERU zna{{iVQOR~u~|obG}a3QVEmJK5C(-zxu(0Ghp32|Ttr2tLtw2Mk>aNsjazgrz1NHk z^g}GB3T#NFiaBL@M0`vSt1iZ^$!>3e@1;hK%``Av;WP> zTw+aZ4qpeU5FJY zOix(jTZoBw^5v*np`s`4j;hRHwuYGN6Gr6mK{+#TZ*0=t1R|Fs)yNqDuNRvuxE54( zCf?;Ds2-xmf8Dow7dBQgQjFfhT)!+D)tD$u|~H7tQ))XXo#CTq%~tE3Nk9I1*!&d0FeX2y{CJgHh^ z)G^YDTzXzQPmiilsH0P=VqoUb3o}RpA&iJRsQG?jcM^QAHT4(~v`-|_Abfzye86J} zP(&pr#h=?he}B-ab)M-ANZDsVQ8}NaG$0B@#n%}0{2VXufIut|(H_3J01Z?_Dn?bI z&Sq9XAnBo8MNf&v1C^LF_@p}#XKxYdbSj=M=E%h~0AI!sG06Y`!h$YDMWu6z5&0aA zhCznRX@!NkDG@}-s8*`@YAXt=zz0(<0h&RxfTBRxhhrY)*DCsLCbUb4>Q(w)7UoiF ztyCwcGSraEohd{zT6IGPxrEIYbn7iWEkG%r1dyxoVpMba_Wuwq;ArGxEG5ghmT^;C z;#7uIlDQfU|3P^Lrw`?276JFCOwSZpM^QS7ie(rB(x6b2fzu#2=ol5m+Qd9!O-wjR z3dY2ep%qD#|wVEuJv+ox~$vIM)5Xi-h#F7bT z*`C2S4;!!<7<>fcg8a5Rxy{g#lSATm=I+JCu8kqkV}bSu!mkr6PO>3KZ>G?xh&KKR{4Et!a2lrqE=YI>x57ViJ={O`s~Hm z5t$|310yK&))MTTKV4w983pA8P>0As%jn~Y7g~p{$!v7cD#=-o!!1u@X$@Ldax5S> z>%f8Wk>~$AC)|)Du^_CvMBgiI#vzrmmzC9F98wf*x!h)Ygq1dK=`98fYh>+pDecA~ zSdH@Tu~mxZ=uOAUc*-gMq)$FYgd$ocsa~N~C?#YPgmx8QPfxs*Qb4ia7kF}Kd?Qx| z4Osa_?FvNSb?;XhqM(p?^t?kGCVlb%{7r(wte5LeU6p*ju@4l|I(kuo0ENky?awFE zAt`~R8y{1NAz?iOl5^E266^KMS4`hXd*NyttMe3P<9{G zLqH%RWA!3k0**k+lo|(ydx@8CH!Ic5tW=5+YiRhB7MKoW#RPZ5%3hOc2x&^FB{vI% zWU9)frW0b;N*H*CKme=N28|LHgRG)j5E4MBKxncm>n^Od=G?wjPq|Om7*uR3jZmC& z1%Ob|ly$I*RpB>@+wc<}gt(nDi1k1u1L-Bfd2}AR4k##UlSA}GEM|cKWaxvrln3zO z=#ZXy%QrDSIwk9RD25>~-SvNsSA(GZN}=`9qY;xJeXWacAwxj9OW=#h5leLIE|Xxr zLO=$(3?uzmYq{p^Q%LVMK@5Rf)|h#1Uo3&%qhXf(Dns?=zSf*;Tb3r$HTr(DR&P@C z`Q-9iDS|4=xlO%8{V==q$C+B!yF9cH?n4YJA&g3u0Bpe^;s94Xq`+Wz)$5#a(Yxgx%r{2SEV*Uz+EP+pb--Ml9+}eJzIeG zwj~}*!Nl4jeXrRdtd7kmH5Q~?%6|Y2jhY0_3Pe^{(hQ;yl>wTc4N3Vx21OuYR51Dm zMhzgTSct+8>$y6Vw|`FsT8y!W|e;cU>KSrYW%Uqs;QXl}(hRC^|f%VHN_g zL4?PEy5{JbCBY5`FoDUX7ih@Hh!Jb@1!oGF0`f1n(ywjNt+*q!F#E^hnii#|yDs+B zdH+q9+l)2^dvM|r(sap-pnvi7Ubm7@1&7AX7?Q0(LQq4Gj?>UHHqkG*cdkS^(toCu zr|kiawn3|`$E*f|Zq`#ubHzjBHj5-Tu^AMe$P=4TrA(@~C@oLSt(QE5Z{}1=ES9k+ zeED#L zUrkD;h%x)iFrB3MmcEgJ?u=}aNhdddGD?)oN;gPIUdv(^M+ zVeisg2A>S@FhwlIvOh@IftbWad9|P!Wu$mGuU|bkFuz0AH7LhNQm_Si;x4_B zf9H6vz}OEp__ty=WJ@>-WfxWmm6dD}HRqnhg0@B6pvurev^9LD)A|sK&NieU?pI4& z^0IFnOk-=6O&Pgj%gC5TROWpnJ7X#x;cg}NNUc5T^wGbB#t?G|JpI`7r+R8qGsw9| zY;Pmwb{ZcUn?rD|j^9tY$p&Q_n+rD;Q`0l|62amkZ8eo)-bq)%tej@=ST!YOzXoTUHpQFg7>0Ag6j$PA;{IR1#94wVvh19k ztL>&a{vSC5BVi^u`{BH%mhf>-pEk!1oaP+rINkY$-IvBGV#*q?y04}zSmj)bO}}Es XY&*y4IL9e79h^5#xAVo^I&k2>;Z9}T literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray new file mode 100644 index 0000000..cdeee2a --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 16, + 16 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "d7|tP_2Hm!fl#<}OMwHRM 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 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs new file mode 100644 index 0000000..90c6a5d --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs @@ -0,0 +1,6 @@ +{ + "labels": [ + "blobs_labels", + "blobs_multiscale_labels" + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs new file mode 100644 index 0000000..1be5678 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs @@ -0,0 +1,70 @@ +{ + "image-label": { + "version": "0.4" + }, + "multiscales": [ + { + "axes": [ + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "yx" + }, + "output": { + "axes": [ + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "blobs_labels", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray new file mode 100644 index 0000000..00ce34c --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "t@j5{QXhKixBsx1V(jzp>rDJWmUDRiVGBuhaIgk z%+aX~D+rD}^l8`tno&CY+%Jma*yg)M&9ku2^Dd_>$g=Y)O;g3~%=>QV17RnGAdz{p znlK=Qno4K8T{FV*aN}rxjA2{J4=-EK4^rnWJ*2VCxG$p#`q&|p>45YqOWqGC*dVRp zm$^gIKC^hE(V=oAecXElSJhY_B`79H9d1uSOrn+K3c41H^y9oK%QB)22wpqA4<&Bs zM+IL|m5kGp-yWszJ#0Nbo$0WS{ftsB^^4!1v2lk& zn8K0p)TEc9&Dl!KXL+nbyylxpq7HEv=cqQ2+j$3^Dh~&gVNDhxJ&4}9V&z>ib!9X$ z!aH^BEtf04Q64q@#xRxLic~5Zn^bjEMR<3EsBOly!Xk6h&)gPX$);&aBdf42JAX5Y zr1w;rFj-QNiIdwTE2Q$>Z6>?8RZ!8&kt|~e@I|gehbh>CRZN`bgmp6o?o`_*7FZZ! z+KQ~U{0bVnuJSb#C|C11%Q7?s?hlOz5m{1WCs@iz zHN#k@=@m`^o{G))uOn2~h@P=a>X0b(>3*E382TDs9dCS(rj^#yNO0B`&x>Tb7W^g5 vs+sDGKQ$day<5~dx72FgV@{LRZ4LA(r0r_b#~u;aq;^*y?(F~d``r2uG{9e$ literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs new file mode 100644 index 0000000..eb666af --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs @@ -0,0 +1,94 @@ +{ + "image-label": { + "version": "0.4" + }, + "multiscales": [ + { + "axes": [ + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "yx" + }, + "output": { + "axes": [ + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + }, + { + "coordinateTransformations": [ + { + "scale": [ + 2.0, + 2.0 + ], + "type": "scale" + } + ], + "path": "1" + }, + { + "coordinateTransformations": [ + { + "scale": [ + 4.0, + 4.0 + ], + "type": "scale" + } + ], + "path": "2" + } + ], + "name": "blobs_multiscale_labels", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray new file mode 100644 index 0000000..00ce34c --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "t@j5{QXhKixBsx1V(jzp>rDJWmUDRiVGBuhaIgk z%+aX~D+rD}^l8`tno&CY+%Jma*yg)M&9ku2^Dd_>$g=Y)O;g3~%=>QV17RnGAdz{p znlK=Qno4K8T{FV*aN}rxjA2{J4=-EK4^rnWJ*2VCxG$p#`q&|p>45YqOWqGC*dVRp zm$^gIKC^hE(V=oAecXElSJhY_B`79H9d1uSOrn+K3c41H^y9oK%QB)22wpqA4<&Bs zM+IL|m5kGp-yWszJ#0Nbo$0WS{ftsB^^4!1v2lk& zn8K0p)TEc9&Dl!KXL+nbyylxpq7HEv=cqQ2+j$3^Dh~&gVNDhxJ&4}9V&z>ib!9X$ z!aH^BEtf04Q64q@#xRxLic~5Zn^bjEMR<3EsBOly!Xk6h&)gPX$);&aBdf42JAX5Y zr1w;rFj-QNiIdwTE2Q$>Z6>?8RZ!8&kt|~e@I|gehbh>CRZN`bgmp6o?o`_*7FZZ! z+KQ~U{0bVnuJSb#C|C11%Q7?s?hlOz5m{1WCs@iz zHN#k@=@m`^o{G))uOn2~h@P=a>X0b(>3*E382TDs9dCS(rj^#yNO0B`&x>Tb7W^g5 vs+sDGKQ$day<5~dx72FgV@{LRZ4LA(r0r_b#~u;aq;^*y?(F~d``r2uG{9e$ literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray new file mode 100644 index 0000000..3f12448 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "h9b3-kzPivWl>~Zi}pe$vl9`Ji@>j2nMpNA_#&%Aeah1#)7el zV65N+7z;+`M*e`XiDR|X&{TCb=hQh>Dp!>Z?H(xXdHPFQ6dsh4{5c1uPM(``Xh+PI zn+uIA#>FsHhD98fjPtw9L^)L<=UnKNYx8c#^QcVIRCe&Bb~f_K3^9UNr!X-p=fO%b z;p=9IV6r_#)&F&fJ^zIy8R%!gXC^( z$*%09%5exgaE4xNLNC}$V-1RI!H=-}0v`ejHqSW9abtIxlitPF-^8%XN4}HN8)A+w@LS zdbjeqb@38k_}Qgm|0U$MnAXnBm$hPzC39gY13s2!95SfaDlB!UgO~i~V$;MgFEs2b_^bESL%yTzYXU?~RhVW23!br*6OxTtc zlLcMgkN@uGn&b76L6TbWEVdi3(xkSyDexVST$;L&Ft-lz#WEIdQzlY4lbv{R8f_s5 JEM@ESFMnJ~4-WtU literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..50b68d4 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs @@ -0,0 +1,44 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..f8b0606b86efd179a47e754b1357ef6f0f828a8e GIT binary patch literal 6226 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 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray new file mode 100644 index 0000000..11f83d7 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 5, + 2 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "P6vuRhtww%5|(#`nsg#e0n$e(hbl;PYg2ho`N;5-g7AOq>Cn*5Y literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray new file mode 100644 index 0000000..6f767bd --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 40, + 2 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "-tSF72%%%j+VZk_ zV#;82)$68TH#DkV!|3bGl15FFt~0~vB9BGUb0ms9VDyaF1)`G*X1s>cT|I~D&mQaQ zfzj)$SoVGwU0(&GmzH@;%|E)d3`TEC-z4z&ACQF7Zwl7!F<rTw6ff7GK>!1qH=Ec$>1$8+92)1{yl#U(qQzb`*qp(wLjg5(JP9-_++kKQ4FIm z-A`N)6O&%Pr5&qO^NMmswGlFVM@2m}z?_N9caf|Tt`7`;Vc z_UFZhTLfUV-MfU;gWY!TV6?OHp+yEOot0tqA@|Lu26qp+!|1dPH+th|r)_}Ie6!Og z@8#s14WnOQ3)B;P_xc))c6D&JaI$oDfYFX#4(<*b#I YS-@y-SD*%GZ&w)Y00wLfMgd?30DBJ<5C8xG literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray new file mode 100644 index 0000000..908fd0c --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray @@ -0,0 +1,21 @@ +{ + "chunks": [ + 11 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "`N;5-g7AVaMrP-h~JCx>t(wtD53rYh3h`9ld literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray new file mode 100644 index 0000000..96d00b5 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray @@ -0,0 +1,21 @@ +{ + "chunks": [ + 6 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "} literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs new file mode 100644 index 0000000..204ea77 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs @@ -0,0 +1,46 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "encoding-type": "ngff:shapes", + "spatialdata_attrs": { + "geos": { + "name": "POLYGON", + "type": 3 + }, + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray new file mode 100644 index 0000000..ed01e15 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray @@ -0,0 +1,21 @@ +{ + "chunks": [ + 5 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "`N;5-g7AOq>Cn*5Y literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray new file mode 100644 index 0000000..a97e38f --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray @@ -0,0 +1,23 @@ +{ + "chunks": [ + 20, + 2 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "TEQ+2ZQRFe>b%E%lf*G&7dJff}J=WE;zKUhJwkds+z~6tH(%%%U+he}yO##Q*;$*3l9B17ouUcAJ?lw7ii^{p(Cxf>bq+Qs* z=dVH9r~7r;_q9LWUs3$UCv)wJ;!F1v7X*1`N;5-g7AVaMr2#V;0PX+) literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs new file mode 100644 index 0000000..6e9445e --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs @@ -0,0 +1,9 @@ +{ + "encoding-type": "anndata", + "encoding-version": "0.1.0", + "instance_key": "instance_id", + "region": "blobs_labels", + "region_key": "region", + "spatialdata-encoding-type": "ngff:regions_table", + "version": "0.1" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs new file mode 100644 index 0000000..59901f8 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs @@ -0,0 +1,8 @@ +{ + "encoding-type": "csr_matrix", + "encoding-version": "0.1.0", + "shape": [ + 10, + 3 + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray new file mode 100644 index 0000000..50f4374 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray @@ -0,0 +1,21 @@ +{ + "chunks": [ + 30 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "$)*p)@~~7J$+Kd$9qa literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs new file mode 100644 index 0000000..198a2dd --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs @@ -0,0 +1,5 @@ +{ + "encoding-type": "categorical", + "encoding-version": "0.2.0", + "ordered": false +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray new file mode 100644 index 0000000..7b6a20f --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 1 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "|O", + "fill_value": 0, + "filters": [ + { + "id": "vlen-utf8" + } + ], + "order": "C", + "shape": [ + 1 + ], + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs new file mode 100644 index 0000000..6e14470 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs @@ -0,0 +1,4 @@ +{ + "encoding-type": "string-array", + "encoding-version": "0.2.0" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/0 b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/0 new file mode 100644 index 0000000000000000000000000000000000000000..8835f2863f86126bef4067626b21c0a9591f6092 GIT binary patch literal 36 kcmZQ#G-ecGU|;}Y6(D8=Vjdt)%E?bEj?YOiE;&dR+1mb)k&I4iqBRB$u literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs new file mode 100644 index 0000000..7c9c5f9 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs @@ -0,0 +1,6 @@ +{ + "_index": "_index", + "column-order": [], + "encoding-type": "dataframe", + "encoding-version": "0.2.0" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray new file mode 100644 index 0000000..2abe5a8 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "|O", + "fill_value": 0, + "filters": [ + { + "id": "vlen-utf8" + } + ], + "order": "C", + "shape": [ + 3 + ], + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs new file mode 100644 index 0000000..6e14470 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs @@ -0,0 +1,4 @@ +{ + "encoding-type": "string-array", + "encoding-version": "0.2.0" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/0 b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/0 new file mode 100644 index 0000000000000000000000000000000000000000..e574eab92683d7fd0e8944d0e3e78f0e46bf8f68 GIT binary patch literal 71 tcmZQ#G-fnsU|;}YcOYg4VqPFl&PdG5OU;Qlh%YY9MHVnb7cc?|006NG5N-ef literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs new file mode 100644 index 0000000..a204673 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs @@ -0,0 +1,4 @@ +{ + "encoding-type": "dict", + "encoding-version": "0.1.0" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs new file mode 100644 index 0000000..a204673 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs @@ -0,0 +1,4 @@ +{ + "encoding-type": "dict", + "encoding-version": "0.1.0" +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata new file mode 100644 index 0000000..02f0faf --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata @@ -0,0 +1,1407 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", "with coordinate systems:\n", @@ -98,7 +92,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 3, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -121,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -130,7 +124,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_affine.zarr to \n", - " \u001b[35m/tmp/tmpvrsmf4sn/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmp1667komg/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" ] } ], @@ -148,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "id": "af8d7108-8b7c-461e-871e-77d82de82af6", "metadata": {}, "outputs": [ @@ -164,7 +158,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAMYAAAHrCAYAAACU3uIBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1c0lEQVR4nO3deXhTZd7G8fskTdI9tHRJSxcqslOQfREBUQq8FERcWFzAQUdQGCuigswMVZEiCqIiMjqKMC7gjOAGwyZQRMRBFimICAq00IbSLema9ff+0TEaeVQKxdrx/lzXuS5y8iR9csi3yTlJE01EBETkR9fQEyD6LWIYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBi/cc2bN8eECRPqfLkTJ05A0zQ8/fTT9TaX767ztddeq7fr/K1iGEQKDINIgWE0oPfeew8dO3aEyWTCZZddhmeffRaZmZnQNO1nL5ebm4tbb70VMTExMJlMaNu2LRYsWACv13vOWK/XiyeeeAJJSUkIDAxEt27d8NFHH/mNOXbsGO644w60bNkSwcHBaNasGYYPH46cnJx6vb2NSUBDT+D3av369Rg1ahT69euHVatWwe124+mnn8aZM2d+9nJnz55Fnz594HQ68fjjj6N58+b48MMPMX36dHzzzTdYsmSJ3/jFixcjOTkZixYtgtfrxfz58zF06FBkZ2ejd+/eAID8/Hw0bdoU8+bNQ3R0NEpKSrB8+XL07NkT+/btQ+vWrS/ZdvjNEmoQ3bt3l8TERHE4HL515eXl0rRpU/nhf0tycrKMHz/ed3rGjBkCQD777DO/65s8ebJomiZHjhwREZHjx48LAImPj5fq6mrfOLvdLpGRkXLttdf+5Nzcbrc4nU5p2bKl3H///b71313nsmXLLvRmNxp8KtUAKisr8fnnn2PkyJEwGo2+9aGhoRg+fPjPXnbLli1o164devTo4bd+woQJEBFs2bLFb/2oUaMQGBjoOx0WFobhw4dj+/bt8Hg8AAC32425c+eiXbt2MBqNCAgIgNFoxNGjR3H48OGLvbmNEp9KNYDS0lKICGJjY885T7Xuh4qLi9G8efNz1sfHx/vO/yGLxXLOWIvFAqfTiYqKCpjNZkybNg0vvPACHn74YfTv3x8RERHQ6XS48847UV1dXYdb9r+DYTSAiIgIaJqm3J+wWq0/e9mmTZuioKDgnPX5+fkAgKioqF+8PqvVCqPRiNDQUADA66+/jttvvx1z5871G1dUVIQmTZr87Hz+V/GpVAMICQlBt27d8O6778LpdPrWV1RU4MMPP/zZy15zzTX48ssvsXfvXr/1K1asgKZpuPrqq/3Wr169GjU1Nb7T5eXl+OCDD3DVVVdBr9cDADRNg8lk8rvc2rVrcfr06Qu6ff8L+IjRQB577DEMGzYMgwcPxn333QePx4OnnnoKoaGhKCkp+cnL3X///VixYgWGDRuGxx57DMnJyVi7di2WLFmCyZMno1WrVn7j9Xo9Bg0ahGnTpsHr9eLJJ5+E3W7Ho48+6huTnp6O1157DW3atEHHjh2xZ88ePPXUU0hISLhkt/83r6H3/n/P1qxZI6mpqWI0GiUpKUnmzZsnf/rTnyQiIsI35sdHpURETp48KePGjZOmTZuKwWCQ1q1by1NPPSUej8c35rsjSE8++aQ8+uijkpCQIEajUTp37iwbNmzwu77S0lKZOHGixMTESHBwsPTt21c+/vhj6d+/v/Tv3/+c6/w9HJXSRPgpIb8VLpcLV1xxBZo1a4aNGzc29HR+1/hUqgFNnDgRgwYNQlxcHKxWK5YuXYrDhw/j2Wefbeip/e4xjAZUXl6O6dOn4+zZszAYDOjSpQvWrVuHa6+9tqGn9rvHp1JECg16uHbJkiVISUlBYGAgunbtio8//rghp0Pk02BhrFq1ChkZGZg1axb27duHq666CkOHDkVubm5DTYnIp8GeSvXs2RNdunTBiy++6FvXtm1bjBw5EllZWQ0xJSKfBtn5djqd2LNnD2bMmOG3Pi0tDTt37jxnvMPhgMPh8J32er0oKSlB06ZNf/FvF4h+SERQXl6O+Ph46HQ//YSpQcIoKiqCx+M55w1zsbGxyvf2ZGVl+b1SS3Sx8vLyfvaV/QY9XPvj3/YionwEmDlzJqZNm+Y7bbPZkJSUhBEIwleIRRFCUIpgCM4CEAAhgKE7YAwHgnX4YNWtuKpLS2iaBhHB6aIzSIi2QEQwMXUA4k/n4axmQ78/3orrHv4rEKDB4azC9EdGY0fZaexddgBhweHweNzo1foy2MqbojSlFzzJIYjtZMb6P9yJpFgLNE2D0+HEP5atwMibrsdzixZh6XNvIQAWOEzt4QkqgjewELYjPMjQUOx2OxITExEWFvaz4xokjKioKOj1+nMeHQoLC5VvuzaZTOe8yQ0ATsOFyJQkpF0zGLaaUJTZ8hAdHYpXX10DuK2AFGPOX25F+tXdAABujwfr9+/BjBWL8MIfM7B7414YgiIQH1QBl6MStz+xACERkb7rn/mnLIx94XpMXzYZc25/BkufeRKVrgB4EIRgXRDcAR48NmIwUlt9/xduTqcL903PgE6nw5ysuXh7zTpcN2woXlueDVd5CVBZgfDw8PralHSBfvEpeEO9F6VHjx4yefJkv3Vt27aVGTNm/OJlbTabAJAkQ7C4XG7feq/XKyIiGzfuESBV3v9gs2+91+uVma+sF4waIrp7+ovx+YHSdfojcvOoKTI3qa/cEhQuO95+yzfW6/XI6gU3S+8ZOsk9e9z3c0ODkiTaOEBax2VK8y5T5LpZD4rH4/FdLnv7HnG7a+dUUVkhlZWVIiLy5ZeHBQgQQH/R244u3Hf3HZvN9rPjGuyp1LRp03DbbbehW7du6N27N1566SXk5uZi0qRJ530d248cgl5/7g5UXFwzQGuHZs2SfevKKquxz2pH+etrEBxoRLXTgZ2nvsC05x+G/UwRnvv3TjSNicakOwcgc85SBAdH4NMTX+LsiQiEB9Y+igQHByNzwXT88ZYJ2PrWNixcsBBHPj2D9ve9j6aFkYjJjcFXnm9x4NPat4S7PB6EhdT+zUNUVFPUHh3nwYLGoEFf+V6yZAnmz5+PgoICdOjQAc888wz69ev3i5ez2+0wm82w2WwIDw9HfsEZHPr6JKor3dBrgbhn0gZERlUjfWQHDEu/Ar06174V+0yFHbGh/k9jrnikB64PuxKzZz4DADhx4hiaN78cAFBScga3ZNyNGl1TzJw0BcWOAtzcdzD0ej28Xi/+cs/D+NfefwGpDkQWh6HpqSY4hhqk3X4dpoyeiHsWvIKWIWZkjB2FiRMn4ZMdXwAIhMiJet2OdP5+fN/5Sb/K41c9++7hsLS0zPf06ZMDuwTJ8YLIthIVM0o8ntr1H332rdgcFeL1euXJstd+8FTJK6dL8iT5VoP0T2smVVVV4vF4ZO6sheJw1Piu1+v1ij55nCx8+1O/dd/9+8GZj0hUt2BJatdU2jRrITGJA6WiskpERE4WlklVTe2HHXx99IRA6yfA2F91W5G/3/xTqfrQ/7InsL/4SQBASnIycFkJUGBHsMeI7/atooPdGJt1FZyt7TjVuhzDYrogsUkS7nv0ZhzQbULzKB2aVhSj16CrUGlPgqOsFf65dDD2FG7Bd1fitX+D5ubvj5jll5ehWXgEAODJJ+bgySfmQERQU+PEKy9/CtN/P+AgLFgPo6F2E4eHhwFaT0B6/pqbiC5Qo/7T1thw7/dHFwRAiBMIr0au/TCmPjgNH3z4ITLumAjdsULgYCmuKu6N9s1SER5ixsMTn0CICAJMeniiAtHnpmswdup1qDRrOOsU1NR8/4KiOJwYNX46dh/9CodOn0LinJfw709P+A4va5oGnU6H4OBA/HHSVZg0eSG27/gUY5++G2Mem4z3tmzEnr2H8WjmQABVDbKtqG4a9SNGhOcTnM7NQ1xCM6zY9Bo0oxcSBWjiwZs7n8O6Lc8joViPsjJBZQ6AonzINbV3ZqNHYKzUodpsROKV12DJ+HnQNA0JiZtw7y3v4Z//WofbbhuFzz//CqgxAK4S9Lj6HsDcDnfeNhZDezcHUPvayw99vOtTnMh5G3/LWIp8QwkKbS48csNkdE69AkMHC2xlb/z6G4rqrFGH8XXsYZzOz0VkdBROncqDLg6AEdDFAeEhXkTZdGh2WJBbHokqCUOI9/vXGwrLy7As82tEhsXitc/e8j3ytIiLghc2jJ84HePHPw1N6wmdri00HIW3rBDiciJS3wvAlQCAJxdk4eVFs6ElhUBaRyA2KQWGtsEI9rbBjueXwGg0+D47StM0xMSU/cpbiS5Eow7DHWJCj161d9AZY2fi2MsHcE2XIcj61xxITQ08Lj1cAUHQohKhBUXhiwod7s+ai+5tLsMXBzZjfuYrAIDr2v6f7zp1HoG4nQA0QHPBYKpGgLEaBpMDo28agsAmZsx/dTEikp2INgYiIjIMndqlQH9ZBEbeMhkebzAchW4M7jGgdr/ivzweD9av34AZM6bh4Yen/KrbiS7Ar3EkoL59d2RBH6fJV199JW63W559fr54vbUfBvCfLz6RmN46uaxPqPTtdZlcdddkuWLWXIl+9jUJHDZSTF06iKVdhJSUFonL5ZKlj84Rm71SnC6XjLxjusAYLtCZRadLkIiYXpLQspPMyLzP9/P/8vJC0d/fX2yV5SIiUmEvk+qaSuVcvV6veDweefHFlwXQSyPd5P8zzveoVKP8X/ruxsEYK3rdFXLLTdOkprradwg1Z9/n8tVXX0pNTY08Pm+e5J8tFpfbLS63W3K+OiLxSc2kdbhe2kcaZPGcLHE6nPLZzhPy1JPrxeFwyubNW0WvM4rJYJIW7cOl19BQWfLmPb6fv+Qfq6XEXq08fKvi9Xpl167PBDAKYLq0G4d+1vmG0Sj/tPW7F2mAjtBrnfH557NxRZcUAMBnH63Hoqez8Na/swEAZ6xnEGvxf//V4Cs7wnPyEDyiw+ovChARFQURgcPhQmCgESKCcL0JgQFeRF6moU3nRNx114MoPuNBUYnAZErElDtHAgBsthqYzbWfDfv1sa/xn1174XV6EBYSDK3Cjev+cKPvzYt6XTwEIRA59qttK/L3u3iBT8MNYtBWyYTbd4jD4ZICa7607hYsUQmQb785Kk6nUxbOmiUF+fnidrvF7XbLsaOH5ZpUvWT0h9zTRydrls0Tt9vt+43v8Xhk58efSIJmlPY6o7SK0UtR0RkREampqZbQJikyZ87rvrmsWJ4rFeXVYrdXSPv27SUo3ihxbUzSsUegjG4WKvaSEvF6vbJvb47o0Jcv8DWw38ULfOEAmuiArR+eRLMrF8PRJRvjptyC5295AWfO5uOq7uFoXmTE2397GUV6gTXECXOPKlj+T1DcCmjnAmJSfa/jAQDeeX8tBvXrixPOSmiahs+37wK8tS/3iOjgrWyF8rPff0HLicPfoHnY9TDpT6N7z2Ts/rwULq8b016fhhfGvwBHjQOdknrgyKlAaOgLDb1/5a1EF6JRhxGMYkRpRyCaBx59EaqMLkxNuw+GAAMS4pLRduC1KPrwKCorghHYJAzPz70XH9vfw57y1SiKdKAQGjp1uBM6nR4iguc/WIW8wydx08jvP4q/+4A+6JaShrsenginMwyzH52MxU+8h4TwRETGBqJj+2D06pSIvIO5mDz1PgQFBiMIwMPDZ/neLj9m/G1Y8MQquFAJF0obboPReWvUYYThGBLEAa9XUO3KR5mjEk9ufhIvjXkJp8vysbnqNCIieqCkJBrrVmegY2oixstN6PdWG+R5jqE8UAfXD97t+tePd0K//wSmTyxFRJMwaDoN2Rv34euTXuzfV4ClL40BAESGBWD362/g2S3PIzA4EINGvo6xkSnYtmAhrkxPh9PtwcNPvYwVj2eiproGb7y8GbEoRTUOoxIVAMY30Baj89Wo3xJSglIc0w7jG91hlBrP4sDcQ1h2yzI8/s8n0H38TUBOF8B6K3SOPyEq4vsd8KkxD+GL6514tesBWIsKAQBeETzeox8K16/Bydw8fPNNHvR6Hbpd2RpVyEN4E7fv8hPv/T/8ccV98Gq1xy2CQoKxypaLy2++GcEhoWhiNiMw34YelpE4dfQEcgrexaKlf0ayJvD/kH76zfp1dnnq13c7UOGIl2aGaGmVkCDvblzjO//46RMyZeYsWfPOdhl22bvSwfyVFJz+/iu9Su1Fvn/3nTJQDh09Ihlzn5OSstodsh8efvV6vYKAGMl6+nm/OXg8Hhm/aL6cyM/3rSsvL/f9e9/n++XqiI6+66m0V0gv0zi5XP9E/W0IqrPz3flu1I8YDl0LlAXE4sXlb+G6QSP/e8jVgddeeQPPPfE4Ro66Cove6gxL0F7otNrvoRAReHQe37+XP/QK2l3eCgsenoJFi1aiuroG69ZtgMvl+v4HmUphd571+9mapmFbSQXu3rAAJeWlKLaX4qkPl0BE4PV6sfyZp5HU5BQ+27IODkcNXn91Nc6EtUVZYN9fbfvQhWvU+xjto4bD2LIMMAT71hmNRjQLSfKdLq4oRXVMLs6WlyAmLhQCgdWRj6YhMfCKF5WVtV+l5fUK5jy2D49l/gMacmCz58ForH1NY9Ubr+OmETed82EN1o88KGySg/gPWsGUoEdw81C8//Am4KgdPZq2wStHz8DpdqNv1lh8vbcInp6x8KIAwC//MRY1rEYdRooZCGwTjVXbt6J719YICw4BANw66Ua8+LcVKC6yYdnCDxES1xL3zHwcf8joDM0MNDFEY832D/DOv97D1/vPYtroGVjzdgnE64WGcBgRDL3u+28bGp423Pci3Z9XLMM1bftgxuyP4Dp1CigtBiJrgABAZ/Bi+uCJKO9oQ3JkAvT6AATpAzAsdQyOfPkSgpoWITCqqCE3GZ2nRh1Gm8hCBF3REhl33YYQU5DvN3pQcCAm3307UkdNQEFIFcLLj6D8aBXWvWfFyqfeh6ZpCK7YjL+czASMwZj74jzoijtDrwUDEo5ghAP/fUOAiOD5557HPVOn4J3N2Zj35D/wZMkyeEv1ELFBdGcAuwMumwfzb5yDWwbVHrmaP+8pdO95JSpq3Fj8dytMYaGIaX4cUZ1/v1/f1Zg06n2MT8/sx/at62AvtyvPz1n9Gv7yyJ/QpDIQpuM65G+1+c6zVZSifLMNnj023DspHcmmYiQadEhN7oGC6gMICql9euZ0ONCxTUeEBAUhNaEDYnIvQ/NSDRHOwwhyH4PmPgvN48Yny7dj6o1/AlAbU/Heg2gXdx1S22RiUFxrnFm5BvumfY5hVW0u/Yahi9aow8h1u3GytABX3jYcb2/ciMefWQ2Xq/aw6nd/WXfz4L6Ic0Wji6Udsh6fg907P0VOzn7syN6AUFModJoOt6WPQ6KxDElhRbjltgSYAo3QNA15h77Eda3bon9af2iahiuuSMC118ThzXVPYtiQPjBpDmh6D7QQDd079YKmaXC7XHjq1gk4sToH4Z7LYZIWmHBrV+h0OhgNRiS3GtmwG43OS6N+KnVCM0FfcxKoFky4Zx6chd3hKA/B439Jg1cE5RVVWPToG2jhSMTj705GfPs439OtsfZbcfCrfYiLScBzjz6MFkFnERDqwRfbX8TJY50RFhaGZ8aMRv7pPLywcCHumjoV6zZ9hL+9ORNBwcF4+cqVaN4kFOUGDYgIwKvrX8SYq2/D56teg+OTE2ij64ZvvD1QY2qDPz8LdOnugt1rw8vyKUY39IajX9Sow/C0C0Nwi1Bk9LsZmTfPQnW1Ay0SRiLrifuhGcphEg3xAVE4WPwJTCFBfpft3qc/Ss4W4sqkGJgt8djxzUkEGIx4860pmHHHFdBOe9A8uAX21dRAp9fj5odGI7tqD66++koEBQejsroKFUkxuPeuP+CZB2o/V/eBpx/E/qX/QUD5lfB6B6JQnwRXTBW6DixEVGgUmkgEqk8FA+0bYmtRXTTqp1IIbIrACjNG97ihdoc6OBBX9YyD3l0DOEzwuIxodUULBIYGQ9M0VORbsWTESFSUlEDTNERGxyAqJBJ9Bw6BwWiCpmkYM/pZTHjg74hPHYyMD/6NAIMBOp0OtwwajUWjF2LPV0cwK2s5Og0biYHXX4cnps70PW27Nf0O5LqdOOktQi6Oo1I7BE1/FKP7NYGmaTDo9LhW17+htxqdh0b9iKFJDIJz8xHg+P61BU9ZHgwicEksvJoHZ6srfE+fqstK8Mm691E59R78cdFz2J+djariUpTbKnyX1+sDkHbdaPTq938wR4ZDRGDNO4XCE1bcfXftn6SeOGbC2cAwrHzsGQT+97UOp9uD0Y8/ilxdCTQcBlAOHYIR6W2C514rQ8dWE1BaXo61bx3Ao4N+7S1FddWow5CDO2ArK8CeXXvQqk2b2u/NyC9GUkA8Spr2QE2oE2XxZ3zjbR4PdkfqsWfnP7Fq8D+RUqhDbKgBZ4+dPOfFu2JrNcyR4XBVVMN+7BTuvnuK7xNBapwnUbnpPb/xBr0Ol/V24+TJ0/B6C6CrPIwQdxDCrB1xdm0T3PhVDYps+1BcEvHrbSC6YI36qdQHS/6MrLkP4m8vvIiqykp8e/gwgkxevL19MeYsGITA1BJY+oX57sAOTY8SczhsMaGwtQhDSVQsbGFNse/AUfS4YhS83u//zuJP3R/D6rtW4Z89JiGlV2cAtYdhr73+RuiNFdDpdNA0DV6v1/e5Uje0uRqBNU6EuWuQEOLBmrXLsWhJBsyldlR/U4yqU3ZUFVc3yLaiOro0b9W6tH78RrCK8grfefknTohI7Zv/0l69VQLeSZF1R7ZKXrFVRt49Uww9W0vgiOYSOaO5XD64jzRv100iA5MlQEuSl/72trjdHvn64DdyR9IN8kKzcfJW93Gydu5zctZ6RhY+/ZSYmhkkdUyqHCo46PdGwxN5B6XHLU0krgWkRRTkgzdX+Ob01iNvyxWGzRIX8JwY9H/4FbcU/djv4i/4APz3jYM1CAkNgYjg5PGjiEtOhheCb9sWI6Q6HANb9IFRZ8DqF59AZfVf0OTqEbAZNVQGdoZE2uEp/QKe4q8QFx8CvV6Hy9ul4JUT/8Siec9gZX4ZSg4exqlhN6HqyH7syt6JK7p0O+eD1hKbtUVii46o/Hw7YmKAkvy9ELkVADDmiZtgGbAfw4etgUdf2BCbieqo0YehaRrKy+2I/O/38W3f9g4srVtgp/M4ztiD0KWmI0x6o298SFAgDq18FS5N8M7+g7AWWLFgwjOAeBEYGOi7TgDofE03fPjKvyBVboRVhyHQE4J27VP9xhTZzyIqPBoaNAzpMQoPDfsrXK4KPLXoRmy6JQcr3thUe109WsIZ7YKEO0C/fY06jNzjJ3Gm8AxiY6N968bd9QAS4lLQHClYnLMbhz5ai41NN6JTy07Q60yIimqC1imJAID2yYnwitf3hkEAcHvcKCi1otJZiRkfzkZQaTSCzpoQVGaGyx2OVx7MxM0P3gO3TsNZ21nsLdiH26/5AwCgd7sBaJ/SCQCQU/YQ5sx9Hc+++CZuSB+CRa9sQHC7SJQ1OQP67WvUO9833rUM99/yCPZ9uhsA4PV6sKeg9t9urwdndmxBVE4uFo+5AeNbX4ZRPfvA4/l+B9vhdsHj+f5vM0QE3xZ/i5RdXdE353pUd9SjmzsQV9pjcaWtC0K0y7HyxfcxpHlLDEhOwo1XdsG+dzf4Lrtv2zbfv/du2AvtVCKe/8uXeO2ZM3g6cyyKN6xBpwl8y3lj0KgfMV5/4V5UnbweT//xIWzash6HQw8jOM6M9gk98J/CLxDXTIe/L1uLw59+jPmPTEWB51tcltoPsS06wBR/GfaHbsLXf3kDcU1ifE+NTledBsrN8NRYUG29DNazRoRVByPAFARPk1g4XOVwukvx2jtvIkCv4c9jhmDIkXZw13hRnFeInl36oaK6AjvWbYfZfjlinfkYMjDQ9yLgCLRo4K1G56NRh9GqdTTCu7fA1ytvwD+278DJeA0bZ/wNl1ta4HJLC/Rr3gMJ4Qlok9wez7/3DJoHhWLf3tPI+6YQnaMdcGsF+MOKDLw6bgHiouJqrzRABy3XDM+ZWFQdT8G3BXaEOIPQ8coEeIoK4a4ox+RJ49BzwAAAQMbMeZg58wHYPHrMefEltOxUe2h3/LgHsO6JV9ESh7F3yjzEpsxEaXkhDv3tb8CwmQ20xeh8NeowRARejxf5u4MhRfdC7O/iP9nHcEXLVIgIEsJrv8fZ6Xbinocex42db0aNswbrP9mEkVcPR1VNNcIGdsUdB57Ev1+u/aqxmopqmLcVIbRAEJ5XjkJHNN7flYG2HWJRYhuMcVOfwxdHvvEdldq3Zzucl8egqjoSGz47iTG3167fvnU7mngLcTlKkJr3Fb7s+jbCTC5kmlzqG0O/KY06jLxvT6Em34XPc0tRrIVA5zDinb//GyOGdIMloXYH2+l24J2db6N7y14AAJPBhCs71f47yBSI8MAURCa18T2VCgkMRYInFE0dgqjqs7B6q5GcYgYANAkzoMx7HJt2fopr2q1BdJAHupp8BLTtCF1pS6z8yI3PW48FKk+gJn8vesOLJnAjtlksuqx7FygtRPXUwb/+hqI6a9RhJLVIRHjncMQPPwhXoQmGk8F4duk9vihcTgeMRhPG9rsNYx6+CbP++Fds3L4Rt6Tf+v2VGKKgj43xndQHBKB7XDskBwfC882nCEQRFt73GMbOugcrd29EoesgKj1FsOafgSEyANeMSMNJXSACjB2hs3fHmS9PI8LhRiz0MEMQrunQbMliBKbWHq0KuPfOX3Ub0YVp1GGICNxuD3qOSMLSO7vC4+mMD//+Blp3uhwelws73/gH+k2YCKfTgW1vfIi31/wL0gYYO3Ks7zrsnffik+ZueOQ66KDDsWMn8dJrKwEAGx5cDPtzs3Hg389j1eEXkNsHcAa74TE6IeLB5u1HEZ+YjNvyz2DIkNfgLgaauIDLRIfWCEAKmiJIi0S1NxSm/z71OtSuBJ0aZGtRXTTqMNq1uw22sp7YuPF2AIBer8O7r7+Ff2f9Fa5CK6SmBhufmIvsM6dhDHNCFwd40gGH8fsX2UIN1Th+4FNEftMS8bZojAwZBm1A7dMqc6/WOLHIiSKHExV2gTMPcNkEYveixi2IirUAAKKaRiDxzCF4q51weU/CIzZo0KEJEqGTlvBItO+pmqWUbyJsDBp1GPn5JgBtMO6WL7DyLQe+3P8ptuzYiljUIB5ADIDwb46jiREoCwSszQDvEGB0yGi8KC/ig08/hN1+AjilQ7kLOHm2GK98cwb9465EdGwTPHTXNFSKC5UONyrKBO6TgLcKEBvgcAMP3vEHTH3wQex7+u9oVvIl7N5C5HtPwoVyuKEhDM2gQ0d8cXch+lr00JUfR+ybrwPDX27YDUe/qFF/P8YvfscB0Y+c732nUb/yTXSpMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAr1HkZmZqbvuyC+WywWi+98EUFmZibi4+MRFBSEAQMG4NChQ/U9DaKLckkeMdq3b4+CggLfkpOT4ztv/vz5WLhwIRYvXozdu3fDYrFg0KBBKC8vvxRTIboglySMgIAAWCwW3xIdXfsdeSKCRYsWYdasWRg1ahQ6dOiA5cuXo6qqCm+++ealmArRBbkkYRw9ehTx8fFISUnBmDFj8O233wIAjh8/DqvVirS0NN9Yk8mE/v37Y+fOnT95fQ6HA3a73W8hupTqPYyePXtixYoV2LBhA15++WVYrVb06dMHxcXFsFqtAIDY2Fi/y8TGxvrOU8nKyoLZbPYtiYmJ9T1tIj/1HsbQoUNxww03IDU1Fddeey3Wrl0LAFi+fLlvzHcfif8dETln3Q/NnDkTNpvNt+Tl5dX3tIn8XPLDtSEhIUhNTcXRo0d9R6d+/OhQWFh4zqPID5lMJoSHh/stRJfSJQ/D4XDg8OHDiIuLQ0pKCiwWCzZt2uQ73+l0Ijs7G3369LnUUyE6b/X+xTHTp0/H8OHDkZSUhMLCQsyZMwd2ux3jx4+HpmnIyMjA3Llz0bJlS7Rs2RJz585FcHAwxo0bV99TIbpg9R7GqVOnMHbsWBQVFSE6Ohq9evXCrl27kJycDAB46KGHUF1djXvuuQelpaXo2bMnNm7ciLCwsPqeCtEF4zcq0e8Kv1GJ6CIwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAp1DmP79u0YPnw44uPjoWka3n33Xb/zRQSZmZmIj49HUFAQBgwYgEOHDvmNcTgcmDp1KqKiohASEoIRI0bg1KlTF3VDiOpTncOorKxEp06dsHjxYuX58+fPx8KFC7F48WLs3r0bFosFgwYNQnl5uW9MRkYG1qxZg5UrV2LHjh2oqKhAeno6PB7Phd8SovokFwGArFmzxnfa6/WKxWKRefPm+dbV1NSI2WyWpUuXiohIWVmZGAwGWblypW/M6dOnRafTyfr168/r59psNgEgNpvtYqZPv0Pne9+p132M48ePw2q1Ii0tzbfOZDKhf//+2LlzJwBgz549cLlcfmPi4+PRoUMH35gfczgcsNvtfgvRpVSvYVitVgBAbGys3/rY2FjfeVarFUajERERET855seysrJgNpt9S2JiYn1Om+gcl+SolKZpfqdF5Jx1P/ZzY2bOnAmbzeZb8vLy6m2uRCr1GobFYgGAc37zFxYW+h5FLBYLnE4nSktLf3LMj5lMJoSHh/stRJdSvYaRkpICi8WCTZs2+dY5nU5kZ2ejT58+AICuXbvCYDD4jSkoKMDBgwd9Y4gaWkBdL1BRUYFjx475Th8/fhz79+9HZGQkkpKSkJGRgblz56Jly5Zo2bIl5s6di+DgYIwbNw4AYDabMXHiRDzwwANo2rQpIiMjMX36dKSmpuLaa6+tv1tGdDHqerhr69atAuCcZfz48SJSe8h29uzZYrFYxGQySb9+/SQnJ8fvOqqrq2XKlCkSGRkpQUFBkp6eLrm5uec9Bx6upQt1vvcdTUSkAbu8IHa7HWazGTabjfsbVCfne9/he6WIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpFDnMLZv347hw4cjPj4emqbh3Xff9Tt/woQJ0DTNb+nVq5ffGIfDgalTpyIqKgohISEYMWIETp06dVE3hKg+1TmMyspKdOrUCYsXL/7JMUOGDEFBQYFvWbdund/5GRkZWLNmDVauXIkdO3agoqIC6enp8Hg8db8FRJdAQF0vMHToUAwdOvRnx5hMJlgsFuV5NpsNr7zyCv7xj3/g2muvBQC8/vrrSExMxObNmzF48OBzLuNwOOBwOHyn7XZ7XadNVCeXZB9j27ZtiImJQatWrXDXXXehsLDQd96ePXvgcrmQlpbmWxcfH48OHTpg586dyuvLysqC2Wz2LYmJiZdi2kQ+9R7G0KFD8cYbb2DLli1YsGABdu/ejYEDB/p+41utVhiNRkRERPhdLjY2FlarVXmdM2fOhM1m8y15eXn1PW0iP3V+KvVLRo8e7ft3hw4d0K1bNyQnJ2Pt2rUYNWrUT15ORKBpmvI8k8kEk8lU31Ml+kmX/HBtXFwckpOTcfToUQCAxWKB0+lEaWmp37jCwkLExsZe6ukQnZdLHkZxcTHy8vIQFxcHAOjatSsMBgM2bdrkG1NQUICDBw+iT58+l3o6ROelzk+lKioqcOzYMd/p48ePY//+/YiMjERkZCQyMzNxww03IC4uDidOnMAjjzyCqKgoXH/99QAAs9mMiRMn4oEHHkDTpk0RGRmJ6dOnIzU11XeUiqjBSR1t3bpVAJyzjB8/XqqqqiQtLU2io6PFYDBIUlKSjB8/XnJzc/2uo7q6WqZMmSKRkZESFBQk6enp54z5OTabTQCIzWar6/Tpd+587zuaiEgDdnlB7HY7zGYzbDYbwsPDG3o61Iic732H75UiUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFOoURlZWFrp3746wsDDExMRg5MiROHLkiN8YEUFmZibi4+MRFBSEAQMG4NChQ35jHA4Hpk6diqioKISEhGDEiBE4derUxd8aonpSpzCys7Nx7733YteuXdi0aRPcbjfS0tJQWVnpGzN//nwsXLgQixcvxu7du2GxWDBo0CCUl5f7xmRkZGDNmjVYuXIlduzYgYqKCqSnp8Pj8dTfLSO6GHIRCgsLBYBkZ2eLiIjX6xWLxSLz5s3zjampqRGz2SxLly4VEZGysjIxGAyycuVK35jTp0+LTqeT9evXn9fPtdlsAkBsNtvFTJ9+h873vnNR+xg2mw0AEBkZCQA4fvw4rFYr0tLSfGNMJhP69++PnTt3AgD27NkDl8vlNyY+Ph4dOnTwjfkxh8MBu93utxBdShcchohg2rRp6Nu3Lzp06AAAsFqtAIDY2Fi/sbGxsb7zrFYrjEYjIiIifnLMj2VlZcFsNvuWxMTEC5020Xm54DCmTJmCAwcO4K233jrnPE3T/E6LyDnrfuznxsycORM2m8235OXlXei0ic7LBYUxdepUvP/++9i6dSsSEhJ86y0WCwCc85u/sLDQ9yhisVjgdDpRWlr6k2N+zGQyITw83G8hupTqFIaIYMqUKVi9ejW2bNmClJQUv/NTUlJgsViwadMm3zqn04ns7Gz06dMHANC1a1cYDAa/MQUFBTh48KBvDFGDq8se/eTJk8VsNsu2bdukoKDAt1RVVfnGzJs3T8xms6xevVpycnJk7NixEhcXJ3a73Tdm0qRJkpCQIJs3b5a9e/fKwIEDpVOnTuJ2u+v1yALRj53vfadOYQBQLsuWLfON8Xq9Mnv2bLFYLGIymaRfv36Sk5Pjdz3V1dUyZcoUiYyMlKCgIElPT5fc3Nx6v3FEP3a+9x1NRKShHq0ulN1uh9lshs1m4/4G1cn53nf4XikiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIoU5hZGVloXv37ggLC0NMTAxGjhyJI0eO+I2ZMGECNE3zW3r16uU3xuFwYOrUqYiKikJISAhGjBiBU6dOXfytIaondQojOzsb9957L3bt2oVNmzbB7XYjLS0NlZWVfuOGDBmCgoIC37Ju3Tq/8zMyMrBmzRqsXLkSO3bsQEVFBdLT0+HxeC7+FhHVB7kIhYWFAkCys7N968aPHy/XXXfdT16mrKxMDAaDrFy50rfu9OnTotPpZP369ef1c202mwAQm812wXOn36fzve9c1D6GzWYDAERGRvqt37ZtG2JiYtCqVSvcddddKCws9J23Z88euFwupKWl+dbFx8ejQ4cO2Llzp/LnOBwO2O12v4XoUrrgMEQE06ZNQ9++fdGhQwff+qFDh+KNN97Ali1bsGDBAuzevRsDBw6Ew+EAAFitVhiNRkRERPhdX2xsLKxWq/JnZWVlwWw2+5bExMQLnTbReQm40AtOmTIFBw4cwI4dO/zWjx492vfvDh06oFu3bkhOTsbatWsxatSon7w+EYGmacrzZs6ciWnTpvlO2+12xkGX1AU9YkydOhXvv/8+tm7dioSEhJ8dGxcXh+TkZBw9ehQAYLFY4HQ6UVpa6jeusLAQsbGxyuswmUwIDw/3W4gupTqFISKYMmUKVq9ejS1btiAlJeUXL1NcXIy8vDzExcUBALp27QqDwYBNmzb5xhQUFODgwYPo06dPHadPdInUZY9+8uTJYjabZdu2bVJQUOBbqqqqRESkvLxcHnjgAdm5c6ccP35ctm7dKr1795ZmzZqJ3W73Xc+kSZMkISFBNm/eLHv37pWBAwdKp06dxO121+uRBaIfO9/7Tp3CAKBcli1bJiIiVVVVkpaWJtHR0WIwGCQpKUnGjx8vubm5ftdTXV0tU6ZMkcjISAkKCpL09PRzxtTHjSP6sfO972giIg31aHWh7HY7zGYzbDYb9zeoTs73vsP3ShEpMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0iBYRApMAwiBYZBpMAwiBQYBpECwyBSYBhECgyDSIFhECkwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTAMIgUGAaRAsMgUmAYRAoMg0ghoKEncCFEBABgt9sbeCbU2Hx3n/nuPvRTGmUYxcXFAIDExMQGngk1VuXl5TCbzT95fqMMIzIyEgCQm5v7szeOan9DJiYmIi8vD+Hh4Q09nQYnIigvL0d8fPzPjmuUYeh0tbtGZrOZ/9nnKTw8nNvqv87nlyl3vokUGAaRQqMMw2QyYfbs2TCZTA09ld88bqsLo8kvHbci+h1qlI8YRJcawyBSYBhECgyDSIFhECk0yjCWLFmClJQUBAYGomvXrvj4448bekoNKjMzE5qm+S0Wi8V3voggMzMT8fHxCAoKwoABA3Do0KEGnPFvX6MLY9WqVcjIyMCsWbOwb98+XHXVVRg6dChyc3MbemoNqn379igoKPAtOTk5vvPmz5+PhQsXYvHixdi9ezcsFgsGDRqE8vLyBpzxb5w0Mj169JBJkyb5rWvTpo3MmDGjgWbU8GbPni2dOnVSnuf1esVisci8efN862pqasRsNsvSpUt/pRk2Po3qEcPpdGLPnj1IS0vzW5+WloadO3c20Kx+G44ePYr4+HikpKRgzJgx+PbbbwEAx48fh9Vq9dtmJpMJ/fv3/91vs5/TqMIoKiqCx+NBbGys3/rY2FhYrdYGmlXD69mzJ1asWIENGzbg5ZdfhtVqRZ8+fVBcXOzbLtxmddMo33auaZrfaRE5Z93vydChQ33/Tk1NRe/evdGiRQssX74cvXr1AsBtVleN6hEjKioKer3+nN90hYWF5/xG/D0LCQlBamoqjh496js6xW1WN40qDKPRiK5du2LTpk1+6zdt2oQ+ffo00Kx+exwOBw4fPoy4uDikpKTAYrH4bTOn04ns7Gxus5/T0Hv/dbVy5UoxGAzyyiuvyJdffikZGRkSEhIiJ06caOipNZgHHnhAtm3bJt9++63s2rVL0tPTJSwszLdN5s2bJ2azWVavXi05OTkyduxYiYuLE7vd3sAz/+1qdGGIiLzwwguSnJwsRqNRunTpItnZ2Q09pQY1evRoiYuLE4PBIPHx8TJq1Cg5dOiQ73yv1yuzZ88Wi8UiJpNJ+vXrJzk5OQ04498+/j0GkUKj2scg+rUwDCIFhkGkwDCIFBgGkQLDIFJgGEQKDINIgWEQKTAMIgWGQaTw/wTSiVCBi1GIAAAAAElFTkSuQmCC", "text/plain": [ "
    " ] @@ -194,7 +188,7 @@ }, { "cell_type": "raw", - "id": "d7c6bdc6-7766-40a1-a46c-60266b4b14cf", + "id": "9c7e086c-dc08-454e-8a49-811dcedcfafe", "metadata": {}, "source": [ "from napari_spatialdata import Interactive\n", diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..964245a --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs @@ -0,0 +1,113 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "affine": [ + [ + 1.0, + 0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 2.0, + 1.0, + 3.0 + ], + [ + 0.0, + 5.0, + 4.0, + 6.0 + ] + ], + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "affine" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..f245000 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "lhwE$$MmxH}a7eE(#2l9}`F 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 YoZMJbcI-1O=Qn~jEwkAN$b*Cb2k2WV5&!@I literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..976c318 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs @@ -0,0 +1,56 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "affine": [ + [ + 1.0, + 2.0, + 3.0 + ], + [ + 4.0, + 5.0, + 6.0 + ] + ], + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "affine" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c GIT binary patch literal 5936 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 EzoF}P2><{9 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata new file mode 100644 index 0000000..edfd783 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata @@ -0,0 +1,214 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "affine": [ + [ + 1.0, + 0.0, + 0.0, + 0.0 + ], + [ + 0.0, + 2.0, + 1.0, + 3.0 + ], + [ + 0.0, + 5.0, + 4.0, + 6.0 + ] + ], + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "affine" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", "with coordinate systems:\n", @@ -65,7 +65,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 9, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -77,7 +77,7 @@ "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", "\n", "delete_old_data(name=NAME)\n", - "sdata = blobs()\n", + "sdata = blobs(length=32)\n", "sdata = sd.SpatialData(images={'blobs_image': sdata['blobs_image']}, points={'blobs_points': sdata['blobs_points']})\n", "sdata" ] @@ -92,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -101,7 +101,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_identity.zarr to \n", - " \u001b[35m/tmp/tmpm0ue_qgu/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpoi4qpp72/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" ] } ], @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "id": "af8d7108-8b7c-461e-871e-77d82de82af6", "metadata": {}, "outputs": [ @@ -135,7 +135,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAHrCAYAAAD1z1UvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9edxtSVUejj+rap/3vd3NIDTaTRuaQVFBRGQQgSAaAUVEBQf8EYMYSBCCiogRgl8mERDUaGQSARGNCkbFIEQlEtCEODWooIhCEBBoGwHp6d73nF1r/f5YQ63a57y3uxHT3PSp+6m79xneffZQtZ71rKlIRAT7tm/7tm/7tm/79inTyrV9Avu2b/u2b/u2b/s2tj0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvu3bvu3bvn2KtT0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvu3bvu3bvn2KtT0479u+7du+7du+fYq1PTjv277t277t2759irU9OO/bvv0/2m5xi1vgYQ972DX+u7/5m78BEeFHfuRHPmnn4sd8+ctf/kk75r7t2//LbQ/O+7Zv+7Zv+7Zvn2JtD877tm/7tm/7tm+fYm0Pzvu2b2dg+/Vf/3Xc/va3x+HhIW51q1vhJ37iJ/DUpz4VRHTav3vf+96Hb/3Wb8VnfMZn4PDwELe5zW3woz/6o2Dmre8yM37oh34IF154IU6cOIE73/nO+J3f+Z3hO+9617vw7d/+7bj1rW+Ns88+G5/5mZ+JBzzgAXjb2972Sb3efdu361qbru0T2Ld927dr1n7zN38TD3rQg/ClX/qleOUrX4l5nvEjP/Ij+Lu/+7vT/t2HP/xh3P3ud8d6vcYP/uAP4ha3uAV+4zd+A49//OPx7ne/Gy94wQuG7z/vec/DzW9+c/z4j/84mBnPec5zcL/73Q9vetObcLe73Q0A8MEPfhDnnnsunv3sZ+PTP/3T8dGPfhQ/+7M/i7ve9a5461vfis/93M/9J7sP+7Zv/0832bd927czqt3lLneRm93sZnJ0dBTvXXbZZXLuuedKntI3v/nN5du+7dvi9ROe8AQBIH/wB38wHO9Rj3qUEJG8853vFBGR97znPQJALrjgAjl58mR879JLL5Ub3/jGcu973/vYc5vnWdbrtdz61reW7/me74n3/Zg/8zM/84le9r7t23Wq7c3a+7ZvZ1C74oor8Md//Mf4+q//ehwcHMT717ve9fCABzzgtH/7hje8Abe97W3xxV/8xcP7D3vYwyAieMMb3jC8/6AHPQgnTpyI19e//vXxgAc8AL/7u7+L1hoAYJ5nPPOZz8Rtb3tbHBwcYJomHBwc4K//+q/xjne84x97ufu2b9fZtjdr79u+nUHtYx/7GEQE55133tZnu97L7SMf+QhucYtbbL1/wQUXxOe5nX/++VvfPf/887Fer3H55Zfjhje8IR73uMfh+c9/Pr7/+78f97rXvXCjG90IpRQ84hGPwMmTJ6/Ble3bvu1bbntw3rd9O4PajW50IxDRTv/yxRdffNq/Pffcc/GhD31o6/0PfvCDAICb3OQmV3m8iy++GAcHB7je9a4HAPj5n/95PPShD8Uzn/nM4Xt///d/j0/7tE877fns277t2/Ftb9bet307g9o555yDO9/5znj1q1+N9Xod719++eX4jd/4jdP+7Vd8xVfgL/7iL/CWt7xleP8Vr3gFiAhf/uVfPrz/q7/6qzh16lS8vuyyy/Ca17wG97znPVFrBQAQEQ4PD4e/e+1rX4sPfOADn9D17du+7Zu2PXPet307w9rTn/503P/+98dXfuVX4ru/+7vRWsNzn/tcXO9618NHP/rRY//ue77ne/CKV7wC97///fH0pz8dN7/5zfHa174WL3jBC/CoRz0Kn/M5nzN8v9aK+9znPnjc4x4HZsYP//AP49JLL8XTnva0+M7XfM3X4OUvfzk+7/M+D7e//e1x0UUX4bnPfS7+2T/7Z/9k179v+3ZdaHtw3rd9O8PaV33VV+FXfuVX8OQnPxkPfvCDcf755+PRj340PvjBD+Lnfu7njv27T//0T8eb3/xmPPGJT8QTn/hEXHrppbjVrW6F5zznOXjc4x639f3HPOYxOHXqFL7ru74Ll1xyCT7/8z8fr33ta3GPe9wjvvMTP/ETWK1WeNaznoXLL78cd7zjHfGrv/qr+IEf+IF/kmvft327rjQSEbm2T2Lf9m3f/nFts9ngDne4Az7zMz8Tv/3bv31tn86+7du+/SPbnjnv276dge3hD3847nOf++CmN70pLr74YrzoRS/CO97xDvzET/zEtX1q+7Zv+/ZJaHtw3rd9OwPbZZddhsc//vH48Ic/jNVqhTve8Y543eteh3vf+97X9qnt277t2yeh7c3a+7Zv+7Zv+7Zvn2LtWk2lesELXoBb3vKWOHHiBO50pzvh937v967N09m3fdu3fdu3ffuUaNcaOL/yla/EYx/7WDzpSU/CW9/6VtzznvfE/e53P7zvfe+7tk5p3/Zt3/Zt3/btU6Jda2btu971rrjjHe+IF77whfHebW5zG3z91389nvWsZ10bp7Rv+7Zv+7Zv+/Yp0a6VgLD1eo2LLroIT3jCE4b373vf++LNb37z1vePjo5wdHQUr5kZH/3oR3Huuede5fq1+7Zv+7Zv+7Zv11YTEVx22WW44IILUMrVN1ZfK+D893//92itbRXqP++883bW833Ws541VCXat33bt33bt307k9r73//+a1Q571pNpVqyXhHZyYSf+MQnDhWMPv7xj+PCCy/E+3E93AAFQIW6zyfrBwBWAA6tnwXBCTScjZM4GydxDq7A2bgSZ+MKXA+X4WxcjrNxBU7gMpyFy3GAK3CAy7HClag4CeBKAKfQcBIzjrDBGmsc4SRmnMIGV2KDKzHjCjCuQMOVsRVcCcZJCE6BcQrAEQQbCNYA1hDMAFrqbF0WfbhTAPJ9orRNnUjvCxFARXux16UAtQCl6rYWYKrAqgAr6vuH9vqgAIdk+9Rv8cpvuwAkQGGA7BqEAbY+MzA3YGPbNQPrBmzE9hnYMGhm0EZAGwY1Ac0CaoLSBIWBatsCwcRAFWAl+vOT7a8W+yv0zyfo3xQARezO2e1l0TvvT2JOfWM9728W39n1FI97mvmJ7vQr0Y5e7HFWHfJUAJqsr7SXA6Ae9m09BKYTwCr1gwPg8BA4OAROTMDBCjgxEQ4L4QQRToBwIIRDLljNBatNRZ0r6lFFOZpA6xXk1Ap8tEI7OsR86hCb9SHWRyewXp/A0eYsHG1O4Gg+G6faCZzis3DEJ3BKDrHGAY7oAGtaYaYJm0LYEDBXgKug1RmtbMB1DS5rSDkFKUeQchJCpwBcCcEpACcBOQXwKYCPQHyk27YB2gbUZtA8A8ygudlYYqAB1AASAjUCuIC4ADwBMoF4BcgBIIcQnADkhMoPORvAORBcLzpwPQhuoK/pehBcH6CzIXQ2hM4CyiGkHABlBdQKqUVF1cTAqgEHG+BgDRweASdOaT/rJHD2SeDsK4BzrgTO0X263pXAWVeCzr4SdNZJ0ImToMNTKKuToNUpFDrSLmsUPkKZNyjrDep6Rj25QT05o17JKFc2lCsa6hWMciWjXCGgKxnlSgGdFOCkAEcAjgSyBmQN8AbgGeAGtKZbZqAx0ETnTbMucvpxv2t4ZwleTZysUj8ART+BEttDqjhExSFVHJQVDmiFVTlELQeY6gmUehaonA2szoGszkFb3QDt4AaYD2+AzeENsT7rBlif9Wk4OvsGWJ/9aTh1zvVx6pzrYX3OWTh1PcL6HETfnA1szgI2J4D5BNAOtPNKx6zUk+B6CkInIXQEoTWE1gAYctllwGd/Pa5//evvmunHtmsFnG9yk5ug1rrFki+55JKdy94dHh5uFdcHgBuAcIMtYCoYJJk9dkHFBhUVEwoqyIYAY4UW20PMOMAc2wkNFTMIKwhmMFaoaChoACYwGA3V/l5sOAkmiP0OYwLZORQUSJxfPkcGQJBhyJ6uLT/Pf7MA5SU4k0n3AOtqfbHvYF0LMDlgO1BDATpmkCji1V3gbDO6sikDDSgU1ww0UJq5BICEQVLsjlgnBWkiPXxhPUxloIigpFOox4BznCbZqZLqE7CfFzJBA+0Fi8+tL4HXn+JSEJ3uaRJ2gPJS3zqmk2/z4/Q+QYF76mBdDgA6AOgQKN5PAPWAUA6AaQKmibAqhKkQJhBWTJiYsJoJq4kwbQiVCEQFRASRApaKEuBWIW0C84QmE5qsMGOFigNUOkChA1Q5RMEhKh2g0oRGE6gUlEooVcCFgVpBtYJqAcWDEkPUpheFGcAESAW46u+3AuIKzA1U9BxBRZU7IR1DQn2WNAIVAol9rxDApINCig4G0fkjJkckus5v4ACCFQQHEDq07QkQnQWhs3QfBxAyDZaKTXsdwEIboGz6Q6oroE56Dyabf1MFVgSaCLRS5ZhWpM/zAKCV6LOuKkGKCAqLzg0IqgjqzKgzUFcz6iSok6Doz6BU1mdQGFSg129aq98CJgH77QHQSLvfTJ8joA7IJF2y7WrHDW+fSwRKrwkFhGqSdCLdn0jH6kQFKxSsqGBF+rraPyo6GZhWqLRCKyuQaa5SToDrWWj1bLR6FqZ6DqbpemjTOagToawQnVZ6v4spvnyor7ES0LSB1AlU7EEUUy9oBaABR03vyTV0wV4r4HxwcIA73elOeP3rX48HPvCB8f7rX/96fN3Xfd01ONIuRrnsKkIFjAZGS//0ndlgdzZG6zocxd/rQBEQGIQZhDUKNiBsUDDbe95b6hxb2Xluu1jxNW1XR6KXHT3rqkm6L9+HIUCAvKND/glJPYEzWvqbtuPU/G9gAsG/W0yASUc/sW08C1I1HQCEQCLDLaXFLd5lW3AEzeyZEmDn16cD2atSp5ZAfFWvj/2hq2o7LjIwJr9O2CNKHnsnU06KsaFkbJECFDc3kIBJVFADaCTRGb5lMGkX0jkoSK8L67kUghQxBW7RC0Mqd40sPVSSPn700kWHsECHtAioiGIiGzayjMOYTPGLuFiXGfobArb5q3Na0CCYY7ttS1GrGNn8EagCoIBV9DkLAGkgCCSPW/aHUYFW1ZwwV9A8ARvttJmAaQLVSQmGTKBmCg11ZYXmAloX0JFuy5pR1oSysT7DOqE0ATHZ1NU5J9J73BY/Vf8MfbtL6gjGsZ3fW7bFzwzv71KMl0qyP5kSQyKNEdH73ITRmMG5twZuvm3gWbtsJshGLQfi1sFqc8ZPzs1sabxKloMuiI4+MRl/rZm1H/e4x+Ff/at/hTvf+c64293uhhe/+MV43/veh+/4ju+4hkdagtzxwDwP0KyAzNiAsQlgFhRjsAKgmb42grMC8xoFaxDWIANqB2gYSGcDJ8W5SAycPng/UZDeBTlXBdAJjLHs0/i507IlQLs0zCiXgZl81Ga27hLxmNNyVbug0+KiqjoNtydNefEtAqB9bvjjz8C5BFLXD/xyQhAlQM53ededPt2TWQqpfAVIn+XfuKpRQLtOBth5kQMoLwGZAC4CLtRBuaCDrVhngEjZqz8SvzlsYDxH53jdwB2sDaDZLE1CDUwFQg1SBGJsTZxR1gapam2R6maSPrYoo0dRiwpIOkD7OChjLwHQaSgGQNtW+uARm79ic7kDsyryjA2ANRDbNdQmPKmSL1WtDPFkiwJ0oBuDRCCMBMxqBVBg7qCMzUr7egVyKicziDegaQKKgjXJDOKKMleUTUU5aihHCtLFQXpDqAbSdRaURmqVakhGL4KwQPUflX/IoIy+z+OwO3bsHwfMu5oMknIbjLtkF3syOl4L2V+JWhHI7rMIg4XRhDEzY24NzTrPs4LyZoZsZvCmgTcT5AiQybrNH78QYUBmUbfc1EKRhCmeIYSIgSuPsx+cvl1r4PzgBz8YH/nIR/D0pz8dH/rQh3C7290Or3vd63Dzm9/8Ghzl6uhYKhJmNOt9r9kEY6zBBsx9+LABbEE3sbAx5U0AczFwLtbZ2LRr2p05qyaV95d64haDOu0nu6DDXy+R7zhgntI220OXoG1/G2ZydJTYxZopeV9pXoCz9QzKJvzJHcEBzEUHvV9ZXJqkmZ9YM1NIDBL7flJg8y1f6hZC46H9+L6fwXrXU1je+eV3dj29JbNYHm/rb2j3/q6h4MCcAVlZau8DWy4OzjpyZzFjhj0nIaAWY5kEiJk6206AdmBmMLUOzmQARw1CBLHn7eejYDwDtWmfbFvaAM5dOor6IczlARPnJB2gFZCNPRdJAO0M2p1Jrs3ZsV1+UIOInbN0YBYDZLHOAcxOs/TGSRxbIJKsciIWjyH9J5s+CJor0CYF57mDMuqB0l0yAsCzfj7NoNKUHMgE4qZ+9o2x5lMF5Yi0rwnVepkJdSaUWUBzB2g0AgyY2af1gj9kKRsuHeljOg/Jq0s7lhJ8KcnzfiiQrkwaSDswCxyc1b0mxpQbMxo3NG4G0LOC9DxrX8/g1QYyTeBawTUptn6NfgIrQKamCmRtqly6huNaDglw5SdCvK7lgLBHP/rRePSjH/2POMLxj1ISMG/Qos/2T1+t0TAZMDtr9uOqV5kMnHVKKdh2k/YpA+gj7GLQo4nbtfB+rmT64fY1XFU7HSCfBpQHhrwE5l09g/mCOTtiAbYdpg16SFU1gM7gfJpTLZJOm/usGBDVjiEJpAPpXPCl9zJA8zEgK6NmHPqHP44E1ksQPg6Q059tfS7HfHYcUO88+PKHjumnNWMXtaAqOAsaEWYIipAKN3sWDuJdgZJgzo0YGwPmGaxbapipoUWfwajaaTZTNsClAIUgVVTITQ2oMzA1yDQncDaAztxJWEG2qRCM+AQByHyvVCUAuhhAEwOFyIaRKxwG8tIFq4AB2c2Ye0DnGowjFIs14Zg3Poh9+AoIE0SqmrlD0utYJSYIF1BbAvMMrA9AddZ7kIG5zaBpBtWm4EyzMufWQG1W5rxW9lxPKUjXI2XPdW1AHWZuB2goMBt7Jk7WKLsYEQ0FEHRgPo4971JAl20p9Y4D5RbbzpZVwuiTKX5yJBBhFLNMdObcMAcwzwrM84x5s0GbNmjrDXjagI824LqC1AIppEYN1wcbIDPM3C3ANAN1VktP6cAs2bV3xRnGnD95bQnMJYC5JWBeo2GDGRvM9v9kAV9rNBQwsrHZfcsdnAlizLmhYEYx1lxwCgVH6bVO3g7SI3umwZ+lQ/LqaZfH8bbT9V0AvQTg1THbDN51cawlnAgG1kweuzwDtEH3Vy/M234o92Oa0EeFCS7S6C2CqsiUvs9kYGvfY38fFuSjx3ATZgB0HjLc76IAg4k7g/KSTV/VE9oFzFcFurLjs+N+Ko6/gzEPoEydQSOz5gTQLW1bAWbqOhIJgtlyEbTSgUxI1CxOjLkoMG+iN2PQDtAzWpnQxECazJReGFIKpCo4K3NWUBYTephM6FUPCFPFzxkR2IB5AGfzPbJF9lcHZDXNa7KCjw2yv2VVwQfm3GEgM2bCGoIVCEdgmy9iSr4GgZb0IPrT1Pk/QUymiI9fM2tTM01pNjP21EC1Ww+ITJZIU2CeZ2XNdQYVA22ZQdxQ5gk0N5R1QzmqKEeMeooVoE8V1LWgrgVlo7eZzPecvXHCdnoCNFd6pTNkn64iC5B2nX0xB3aN6eVnp2PO7vlnY8wOyDWUZh2XCsQqrztzbsacFZg31ud5Rps3aJsNWt2g1TVaWel4pQLGZGyZzJQNyEYgB1Bg9nHqTvw0Rk3TgVzRjpnJp29nODiPzNP39SE6ODtAz9Y32GDCHFHXxSDTYdN9TApKhJpgqYNzNdO2AvNRADQFQM9m3t4G6BxwstQbr74ZaBd3K2m7izUvQXlXXwJ0YtCnA2c0xOgl12k3+ncO0GESX3bpiBCnLQmxzBbJ3GdqEYiDcjBlCq0fBQCTTlZX67mT8LDHcf8Z/0yWkmTJoNNnuwA5P5Hj2PFxjHr5neGgu9pVMecEyLtY8wDMJdz8xjj0BZOgkn7mJmJxX3LRuebgPNM2c55pthiPosBs5yFFFJgzc67GnOumC78yD+Ds8RtgBjGDyLqp2EWkA7NvE3MuBShM6p90UCcBEWMwaS/8zEwzRFTxVjP2CsARiDpjVoAuCaB9qCRLmSxtpViYMSZNPdxwDzYKd5HRtzZrZLrdL6I5mHNpM6hNKPOszHndfc/1FKGaibsey5yNIbIHivX5JZBheroks6l07DDcJdPyPLg6wDyG5nXbXEkyVMQURwNmMgVOSgOzseUyY24z5nmDuW4wb3Tb6hqtrsFlBS4TmIr+ttTOmjdQP/PRDFltIHWjrpgAZ3c7JIC+8joIzrPBqAOzxYKC0SOzuwF7xhobbFCxwdo8wwWeFuXA3B/5ChoMVhLccfxFMXCuWKMZOBOOkt95MwCz+7BdBXBFYtu0vWy7hvaSKvn2qgB6CcwHO/Z9m0BaEsAPUUZ2ziI6cn1ASgJmbFQQgTrVC9O2dPXbhDVVP57oKTjrZYYwdWngoCz5PWXUwUbIf0tGEPadHQBtw2mwpgsQsWe7HssSO7eJ7PjHO4VV+qPTgfbycfslwrfH9Myas8+57QBnSvdGSDCZybuUHjjl0dpsPuaZTBEmcx/RHL1R1VlIpggb4HOpkFLApvdJYs6YNtqrUbtghybwpCkwZ3CWDMzWmwQwlxTUpiw6AXQwbwNCaVBXV4PQDBEPHp2gLqwpOi9iORjFWLjnFewAaVGrXCiYTNAobfRoPA84UjOAnRcDrYHmGbRpatYuG4DMlSYbEE/GnCeUzYyyKShHY69m2v7Bp/wS7vIl98VrfumFeOmzvl99965nJ7O2iycRUgBEly7OlgkjSC+H7dUhHdugvO0wc0B2JTKCwBwHRFPISiBqg7D2xjMaKzhv5g02dY25WKc1Gh2hkabQshCYBcwr8FzAM0HWAlk1yMrGaF0DZQ2UDaTMkABn3QoacPI6aNY+gpb06I+lA3RPlHLWXBNAF+O1HS5H1qzgQqYFZ+asuvFs7HmNFubsbNpem2nbo7c9DcN1Px4GE3BNGbNvT0OXdgJzhUYxLME4dfFu3xMD9ND2swPTgbRPAgXmuf/eEASz5I8IQd9BWrpZ24BAhYTTLR5VdnYGrd8TUYCW5n4zFTLSFGiE+iEE6CCU3pN0egMo7wLo+NJuW0b/2jbcjoeW8WcWXx/GBg0b3d/WCOKWL4PCPGfVeyNgLoJSCDOlcxeNpOYANffNst1L1hkTvuam4EwzNpjUhRTgXHQW2G9qGlUFl6JDqtp7ZsZVRpIBemOsROcnIVXDIJ1PHgg2AHM1q7gBdB0A2pQRMn8lMYhsMBBDRH+Lzavp4MyoaFa/gGh0/wgpMBdTRGjH/Ix6BgKL3s4PBN0jZDnelGsHcAM1Y85uYSjOmjcgWYF4Vp/zXEFz7ex53VDX6nd23/Pd/vn9QUT46m98BF7+jO/XwizGVjj8zTrXJfRoitoC2dh1OomUFc7jWPTpWHNTdcdCdJX2lH4n4UFgDMZEGpVdQgAswLnNmMsGc9lgs9lgQ2vM5QgzHWCmSeOQpKiOz2oSl7lCZoKsRIPApgaZ1pC6hpQNpGwA0i4JnAEGTs07rviq2xkOzoJTAzhzmKg7cy6W/DSHIVp5bQ7bcsbtuYsb04o9jSpHa2e/82YAZO+e/8wLk7bnO3e2vLttA/UuPfSaAPMO5ixWQU0O+lYO0YHav2MAHfkESbp7OCer0Oga40ZZxBLMvTnjprTNAC2ixRcaMFQzEAakQITV+mhfRVgjDZhZQcVNcwrMgDQzcyPczQNLdKt5xn4n55FCQsoejn08Mj6N5cdZUOXtyK97Mt9OtM/HowTMi/1lHwB6YdYu5m92owaKPV6CmbQlgAwGzBIR2W7GNmXYAHqmqs4kKn0WkPqamSZjzpTynMWiXhPw1MSeSzIZigVBNZtbZsIkFgsSc8YsqEVQSRmWX0s11qwzZcGcQQAahJSfKWv2YLYNmlQQ1miUlF7qxY5AnT2T5XEJjfDlUSz6uO3BuOXHAVIpYp8nuajPPHeLAm1AtFJglpWmVzXNj6Z5Ajl7Xnt3s3bBn/zhm3D7O98Tb/qvr0SdyW6vzhkl6xQKcJUewV3SFWTJwzvG/+maLPYzMPu094JAfktMZ7exPkr/yZhziTGhSpxQg7hZmzZotMFMDsxrzHSEhlWw5iak1c88F3pTwRsCTwKZWOMi6mzM+UjZM61V9sFA2usGXhfB+SS0Vs82c+7seQ6AniNMS+HTSy6qzyyDs6QgKEKx/8W6gnNNsF/NcD76nK8+QG+Dsbddn5wOqI8zaS9AmYwxBzB7mVPbl8SgeQUtbagFDiJsN8zHvADnDaJMFWoCc3RTdJ6GnoJVfNbb07QZSDx+XQygvbCACo7EklvaFoE0UhNq81OwnM3l3WTTN/w0t7YUYG2kZ3g0wZEoCQ/7zINlvI9Moqtp/TP9hAjHjxF75IHFvr/UChbDYyvXmQRMymi12IhqIaqIUERkF+s5dS6KjECZc4MC8sa2MxUFZjHHDqHnPZcGoWopVWT5zgLx4C8DZ6nrDtCD+bZpyhA6OBdmlOLdgJkMmIsqGdUAupqyUU3h6DyX7cZ7Bm0JScJmOyNSCZBjMXIVMX9NVI3vWW0r6gqzfq+rZSIl0UX3NRDclEEWqKbBYGbWrhszaR/AC6AQq1mbmhYnKXMFbbQXT61yoN4wnvxvHoi6aSgbjnxnn69sCq+bstnynT1Y0AF6mWZ43H5usuPzDMwEZcz2RFRPR2bpKQs6/MwdmAuNzBmsMQNMM1rboJGasWdSxryBVrSbMWGWgsaExtLzoFcVsiHIpLERYlkFUtSsHeU6vWODMMQfbY65C6dvZzQ4nwJ2gHNmzy1gcUZPdNoYOCtASwB0r/qjEygz5xGcOQzjPe/Zu6dULdOpuvHcgTnHhwNYwAaQRfjYroo5uyQug0DoQJ39zAmg5YRtM0AboPOEqF4U5jdBzz811ixeSzAFvAzOI0ZPFrTuiZRlwaSpGrJJvx0CBWOzQ4dV3TpXATc1xbIDswchwWMUOiw6kIZs5K6tO5g7gxxZNO220ttz9FRuXnzWgbg/dT+OLD6RYUzI8Pd5JDhI58IaYxWssW8DdCdsAfJ2Jkw29lO6kT/UKCwSkdmqBOs2dfIAHgf0BqYKdnCO80mBTzQrGA9dWaKOMw+6YQVpYlCxnpQJ75UEE0kHZyi4OJQSgGKh/SQqSZAUdqaCJsXcVf6X2desRc5V4agopBHcRBVCE8heq2l+ghdTGZ0ZNghdoXXKaDmA5G6jMGcfALQG0YFSDplsnk6AgbNWGCua8zxXlE3TymEbAlkwGM2a86wBYRQ+Zy/IpvPNTdlekMkV0OXrPA+uui3H85I9E7LPOVeioCQeFZgnUcWvwNKo4p5ZrjrPavmgzTZAW/bODFMmObHmeQPZVMhUDJzNwlNnM2l3UBYDZkGy8qyvg+B8peqnAzhngFZIbAGRDpdeZE9voXqTeilPq+4T07ebtXs6VTZtjyDdgTqz5hDz6Ix5N1fu7XRD+ypAeadZexGpHSZrB+EE0Hxo/cC6T/hIiDXB4eBsBieZEbW5w89sl9oyy05oGgDdGbTAgMBMqwR0s7JT1gTSOatGWjbZOjCLad6aNhN30WotKykRi2amHQCdiP9CgQoTN6WnYUILdhdyyb84fz9O/gxqq1sCuPMrAYbzz8NkV/G1+MoONr0TnI2pICkiDAucijNg9JnQ3UEtZoQ6k3xWNFLzYEOqFgYLtiKN3laAVuDXsp5m2iZzkZQNwmTozBlWeEPaAMq7gdm4KvWZPRG6mTtGazZrE5YRLIQ5MWYv9Ws1EmhRe5smBWiaQLQCzPTca4R7qUd9QESp7r4AlAHa54YHW7bZgpCswLZVJdOFO6w3LQFKs4IyGUhj40CtW8wSi8tQ89iOGOw9Q1JE54tvfWSmsb6kFrvarm9k9eR4YNbX8/BXndywaIBihdUXdwRws3aKuFeAXqO1o2DLTSyDZ8ma2wyeV+CpgGtR71610rN1x/iEb1PE9mZ9lfdlVzujwfkklM32x8SJqBF2M+i80pBXyfV/k3ktvFqYTpbuc9bJ68lXGaBpAOlt1jwWosssyPdGMFYQ7xwG8V3fXl2Ati5du1d2m4E5g3Nm0AbObaXpHTWB84yF0NgYOBtb9woeUWghATN78Jiq6JH/XabBtO2XLQB+5nufj2/5sm/A31z8XtzhEV8EAXDnz7sL/vaD78FHP3qx+ZYt97ZIr3yV2KDBm/rOAHzhP/9y/J+3XoQrP3ZpfMrcZaILBc+tDEs+jSbuEE/OkA3McqnD+Jj600V+H92W4gKnF6SUNEKcaSclw7f5WtM2/ezQdrGUlj4VuGOnW3lcuRyBq9j8KQbMWRlOwIzuPvKKfFnZkTyenHmEq2SjrDkLPvHc366Kh0nTgRnmCaZuUM7Jgd7V0uFn4wpIS3JEQ5DIttm/HKBME9jAmGK7AlmQEJUZEhWkVPnUamt5/pb+VOPhiPqZXamOlRhsPsNjQiazbFVTpKuVAS3RadbgAorXDJpJP/di6o0jMHwYJMPg8Tj0NEnRWfTp2mgZ2v3+9piUpATk03CTtlnGRPT5u0zxcl7SwDJD2JNr1+pjxhFa1LwomLnoalssVm97Blu1MKlFAxcdnEtT5kza3d8sAzjzdROcr0yjJutRjBwcFsYv12Ns6kvqqvt39mwTLwGfC3fXrkMzg1cNc3GUt93P7ADtg1fgQ1ni+Fetdx4HzrtiJRN7llSyU3xCeyT2gj3zYd8GezZwbsaK54JeNsgdvBXgDVKirH0mHYhZfT/qx26JOZvAgvSAsEA63Xzlnb8CRIRbnH9zyEHBsx/xw/i39/+3aNxwp2/7XHz0Ix9SuZR+RoG5CxG/yyKEH3rFf8Od7nVfrE+dxDfd/PrgmVWHKN363pPgHJgzRC2eiSgoh+AwyRPPNT3cUSnbFkrj666kLUF6J0ADkQ7l26HvkJzZyeKw5P9raorXVtYe/8TmmDQ0IbDYLJCxLl6DGLNxcFZgZvR4265iZ67U1Wgatsv69XmeedQ2G4OyLn1W59yF8BJLn99+HjrTu0LR1ftiYKzSo9DGWPIGhTbmf1xBTKEg2hgwK9uXqBUuSZ829rwIHNPTYbVcOQjzdHpgzuAcdbpVqRYDZd+iFUgUUveoyALJ0ZHRzZxiWql07TSN5VHxPK7JYpsbp30fi6PiuFRoZQRmSeDsI9CAWYvFbMCk1SGbrTzYkjl7FrEyn7Mx5wlSK7hqGqBU6aU6k4VHkJXHBM7tOgnOiIGQwXlk0M6i5wTU3c/swKxFSXpUpj707uHwlgG6a+xtsd/il7ZHONAnX9cGtwcpLb6//Ow07Dl8zceYuCWz59TZ1hhkWxOt2fpoZaWsdq6dFRMSAM/6mw7M4Tt2zXWGB2Xo7zQVMMGee6a5EJtvEyGbiID/7xeejac/5An4zYt+G1hVfOFn3wEAUEvFhTf7LPz9ZX8HDubMC8ZsLfnObvbZnwcAWB2eQL3eOTi69DJAKJgzO5GwqM0mNo4IGiCDDNIdLgsoZJj95PgI40GPlpFlDH8G5hGks+gb7S95ZLh+lBwMacWexX2x81T5q3aMhMV6pSGczZUgBBHSXNBkmdIlN92UDTTxgMu+LtxS+Y3r8iC/NC5IzF3i3eM57DWJmbY9WlusEEnqMfKlg3EsLQpKsySbtbOLTM9c86ttwQ5YKU+qKJjMjWURLeQR1MqWyQS4ArOa4XVxcg2C0x8nRD35AtgakAirl3dOijbS+6LxIMIV0gqkOfDaawfkVjQtqHF/vwkkKpUBWu6ydLdRjIXtPBMfM13B6qNxCdKng+wtYo6uqh33TX1aqvg1EsswL3Cni678ZVRMKoAZLBsw61oKLGopbVKs27hlAVdlza1uwNUyCypZAooFL5LlwLv7xZS1CAYjjbLAfOo0V358O6PB+XKYIBmEWg8QYyyBekaP5u5VxFRzqqFBuVe519peGl/0iCpWsk955OmjOXvJeFyEZgOOLPpxfPp04Hwcg14CtHfXvBNA595WHZzLlMDZzlEczQh9PWfzq2U/t+zqFkAGY9HE+l1C+CB1qULCS9/4KrzsTb+omvGq4uHP/w687DE/hbf/zZ/hD979h5hWVVN0CqOVcS1oPU/bWFDLU7/rwfjup/wk3vybv45Lr7wcKBQAxVCW3ML3bE+YqJu1xczLkeOc4XH8P4YNJIF0FjI2YimHCmZ3TX5vKfhcyUsjQ0ZALvk1EkhL16/Iotcihs/yWJu4UYMQEfIiYANojt4sKltfey0NF54MBstkwOYpSpbj60rAMrrPFbqiW4ogG1X2iL2ru6SnU6WUKvZyntpjzW+fCTIuEqv+VLb7rQlRLc9tKiE5ikkMphkldbZqXZ5/jNICmJGAWbfoxfc8jrIUxKoj4SIypXu5FY30Ftae67GKVZZxsJa5gNO+NH1NrNkMw2qvrM+YpQwyk32OyO6xuR0nsS2/drHmpaQ7Hpi7RK3pN4udXxEvSKPbsJWKKVQ8g8sGwkrCGopZfDSvWYFZy3wyz+C26uBs9eCFAF2P2+MH5p7bnALBNNJFgHa0dSVXp53R4NyZcx4UHI9KX2fu6utBbadceVjLWNKzBOxmUaqNh6NngM6R2VlwZmAeB2OJ90dwBsYhm9vVBGYhk7zko0o7LTTyQTufummsaOTnsFpVBhhuOopY9HulIdaGXmr4WSlwBg8D8byKS9A8ZxOabgMi+IpG77v0Ytz3hx6AKoy6qmDWxeJbAYjcWzjeTnd9FwHe9rY/wr954JfoPKpOc9NTZYCL5ToK9bxHA2Z2YCZKtbwXQG2XkJ/YCNI+ZmX4v+diL0Ea6Zt9zPtoCsDFyJodkJfdl0guAYzUFzhwo4d5Jlwaa9qaAq7WMKa4PyzNmLMyZgdmCWB2RlaNeTu4+IU5OEv3T5Dl9RoDuuOFn4vf/J6fxRVHV+IuT/0KXHrZR3ulsMYa2BSgDAVldnDGUDyjivnUDaD13jmPd7N2qGuoJjGiSiCpz7vAFp0g32qxlABmavCFO8iXwazc6fugLWBh9PJxb2PNrQ1muZBIbdStNOpg3Ao4wLmC56rbxtY9J9ymHkMDwoTCOsJWp5pNMZN4piZLZde4RIxbpDHcR/y2VFu+Zrv8bYAej6GS3iLJrZgMJYAeHZkVgg2Yi1am4xpEjAVo1RRJ0VQ/5g2krCBt0hrwpfQKe7HAhWX4xDYFgl23wVlCgI2mFB8MvEOw+cDxAVaS4aoX51x4sXYIx+0jLgE7D7nOrMqOM8JVvAfkY3V0vAYMOkzdSQuPdCd7zW62LgrMZD4rX9eZEseIQC/r1c3a9v2SlIDQ9pdhOB6k1iCYVKmxKl5KFsgKjBHIhVQhFfIg83k2q/+r3yFSpqO3zIU9Ippbl10VUCUFpaJC3AHC1SzFI2eFMPCxMSE2JsSegZU0JQc3WmzjKfRnSeKjtQP08p8n2oyOEQnzYjwHKONzRTDyUHd1Tt1eE5tOFSNL4FXWrJJlgLWwgTOzrdTjCozpZ74PZ1nGssEKysaYx0pzCLZGLJCm0dfSnM6ZeVIa/sNXPxo3PPsGuOHZN8DD7vEt+MnX/qTm/TZny2MhkrzEuC4hON6PKmIA7SNbQslyeHYIkC7KUagHhcaCFGQpXWQFUgqDLG+bqgFzWQIzgyx3toN00qyyH8LGQChQPmZ9mDda9M6OtVfrDcwVjeNhaRU+aTqO2MHflS+rBAd3UWDou8aoEw0H6L7f2/L1kj13gO7yPf+lxHd6XEEUkxF9Dip3MjhbQixbtoDNZy5qLVK3WAOXGVIOrFiOgrOuQe4i09ZJGBa66MDsa4EDDPB1EJyvgN6GMQN0GQnLsZe4SfqXs5d7DPYYztWN1rLjSH78/MmyjYbH0wHwVYG0t6sCY0e4q/qOCUm27/uWKIU60/jTAkRFo4l0PBqIuqZ/4xse4nsedDu84nfejr/+wBEGoA4bnvfJUCINRwLEQdm0VpQCKu7z02haEQKXpmkgy3NMwS2et8kJnMjWjg4LvfidVqaiy+0aGG8BM1kald5H8q3NXrf85zS8qGokhp7+oztBedfWz1HQx7kCtBJxW+YRCZz5NL0BpZp8IcBXHyagS94Uth4V15jNjGrAG/ep62vuP2Zbrq+XxlVglpRsnU2pkgHac56FFeC44fmvfym+8gvuhaPNGr/0e6/UyOKZoZE8DDTZZtDR7bmLWxko2LXfM4o72+1vxaxxDtYRc0LLnhiyazz5hhtjDvY8MTAZSPu26kpdVAUR1d1vEDwgj1JgXoxdU5aECcxF8/w5gTIXNK6WatWBWZmyKblWTs8tG2xBf03YAvs8SM7dFV2JVLDcNnP7nEL63raERIL03pYMuh+3f+ZzxGMGen6ND1yPKOhVuT0YUZi6u6q4NUhN2lI2YJogZdJqcZH2h3g2Er7lDtIyxBzJdRecNe9t12PNjdF5S9bvst61TJJahneNxuptoO66Yf4fYSjL72U98nTA/I8EaKQ/Pe725AIfXnuPgbCRtsW55IRjrxBW7XthLxW89Xn3w4XnXQ+P/4bb4ayv/gk7XTuvzMTJTOfgUTnOS0waOJOtrwrqMfMwbZ/JqJ8rHS7LbJUqbqzk3ol97fgYOGm/K4SYtLIAZxda4taIBTBHBwVApnRWBYZ8L6mPxfx/B+TOVAabiwW3qdgzgHbAYenAfBxAG45QQ4/qdsOKj4VGFsmrwEw9+y2BNHoXMZAQM1278uH0u1tRyJWbYTETZbtCYsBs7KSaiZIa3vS238OnPexCi8ZuKM2A2TrNogtGNLFFHDowk5nmu79dAqCzOyAi09GzK3IMA1EHaB9osR60n3u6+ZSAGQHKqdfWt5U6czblJFINYdql2HuDYtcBmoVQHKCtByi7ZUFEGbL1IsWYs3NVLxnjMQTFAJpHt8WCSfcz6spjl4vbQug4iZ0bo4uGLkn70RgUtg0y9gwI+trcFsin+Z8WL2Lz28UFGTAXLVjCtILwClI0yM4L5niKqNaWFwBNTdzZlE2LO3JdBOcrkSs+7UIgZwKErn/R8FnX90ofjMiJUliA9AjU46D06Zy3iN/cPRB3AXDXQ3eDtLfTAHK+xGN/swuh7uuzK6LlFTJ6eSwHP0bU+nVpb9L/cFUBALUUYJ1PMYNu1Q5lzcIGECb6CMUmhDPmBNZQc5WAwJwsAaUNzlaxNYNLhZlLO0B7R813hjpIW3pQ+PfQA3Dg/nxbcYsMcIqBcxEyYKbwdXafZorBtmTSzEE0KtwjnIEO2EuHicQz6QUi/DdlAOaaAHkA5hm9Kpi4KCXDU9Fi/7PuuwtYO6fUm8VQCRpX0rZnTPtiDypDqQ/1iBgWoLFG7vvYLMZMHQzdT8EGygmYKQFzJzGy4zztXNGtJ8MUk8VcyXMvNDv0ymnOcgOoHaDTg5iWIJ2AeSKzQBVdoS2WifQgOEvHsjRErW9ui5A4QKMDNEnBuefeGD/zsifi0o9dikd+8+PRmFOWY0G18VyEFZh77dvOIsFg8TIsLguNSdv41NGab+3xAD2SmG3JtJtHiHFi/SzrkWTnEXNLGOREQFonBW718oDOJKNDJW4auKe5yyszf9eQPVHRDjLKSAPowZwd4HydrBA2MmdaPNpR2/JH698bH6/rYqoP5xKg2wC9NHXn7QjSDsqZPY9omb2O28Cco7l3CIg43mkAOn7IhIcsfyMoJiIXGVZiEHOiU7DvOSiJCTyX9hZVa0Ew9/w3r8NT/s3t8eJf/1NdlzaDs/umuWhhE6924Ky9GNAGyrrZyM6HZssHLWbWpv4YdwW0FlZNuRRd9tDqLoel3W8NyOawTWRnyXYuMh4UQEmgrPvFWEsJUCaVy/DEvC5AXEqK3X+H4x5WyGmbhKBk3BgBOvyqTCgs5mPXR1Pzo7KUdSLg39/3p3Hv2/5LvPbtL8FP/u53DWSXZ0BmAc9kGCHBonswEXc5JT1CuvdiQXPFWL69ZhsP/rdNOn31MS+dgXrJyygu4ZYbTU61nvYjZFyC8e/QpvVnfIb6OBhVoD7rKLmy7A8kNBs7fwNkyZFnyceswGwPZPI+o1dKsbFRGAMwiwabia/MJU1dBpwVO6MjNh6f8uSH47a3vRUA4Fv+9TfgF1/0y+g+5WLA7KloVlFLKpyd55gcX0woovKNRXP6XpYs26btJI4W26tqPr3dioGQ5m7ZcCuShELXAdotEKUDdJbV4kzYArxag1jeupdjBUoAs48Dh3Qf/NIH8nAXdBHoa97OaHA+iV7OLQNzh8H+OkOjdo69XAykA/Q2OI8lRnLpgw7M+jhKGgB5SPVBAeSBuQRoTlsH6asD0Pm1H1q6lj+AcY4otBxStpV/ZDZtzwe3S+uqAsT9zXUBzl4PmWb89f+5Et/6H14PLWtnA7i48EIHaDhztp8oZBp8UT+YpUBENiq530i3TAqEHKx8eMhaPch+qhCDF6zZwVlvG4XyIMaKY5uC2iiYYDWgKSAuKAbOlWxrl1zJrZwSaT0QjyY1nyxt5w44MIcuLu775PBGxDN2YHYwXgBybB2YLfavEPBVt/t21FLxgC94JF70O99lEdlk4CzgDWmJxxkah2DAJ43xoqe8Dnf7wn+BP/6z/4V/+e/uF4yY2JUQYzJQVqblQfWZRe6s64YkVtBpoUCyA5WxSb9/Bs7Bkg2YxdLqJc4zbmAYiHSrvkYnvXFPbRtGgAQumWkJEMDsQtuXJe3jPIM0m385AbQD81SAidQXXUj/jhhefEVkA5IN0CynVmZIURatJU8lovy757XgDW/8M9zvfneFiOD3/+efo8kKrmCKNLC7BySvAaDKsIgt/CEKvh2YU147eu0IHc3LIFyXbTTsd5m33bokH1/nPWfKS5B2gEYowKRnmJVv8W0+R4GY1qnrd/c66VoJzixnxgO6kiYI98tWd83vOrkqVa61Oj6sDMqUPqcd/5Y62W6A3i7KuW3i7ibxDtDdp738nbEdB8ynA+g+WMcrXX4nsWMPv6Ud4IwNwFHQMJ2bTUGpKo1MeITQ3AJn61E9x9AiopQMLaszY81tjqWRvDi25K7CQqPMfS099SHluzPcTdMjyCaUxrpxL3NZSANvgA7MxpqduXe2bCsMWRoY2SLEJNXAuSo4M6GUgsqEShRkqUAjg4k9FCVr2ZZ1L2amh5oQmVQI+rU5QLOHKqVHTIkxUzBmQm2yBcw1seYC4K3v/i3c6bO/Cn/017+Bg7XdKxZd0WtWgG4bQjOAbo3CZHyX290TRIQ73u5LUJghsUKIFrHwIDM1w2aLRAdnFhuWRTpIW9StiI0Z5kBQgvlbLdBL/c0CMWDOzFls+UM3y4c13A7pBek47mMfQLtmIfu4gps3gbx4hyuI4gYnA+ht5szJrO0ALTonKpnGYNYi2QCyVoWZ1hBbLpJkhrDlUBODrS6AAzOj4Bf/y//E//idt2J9+ZU4+Q+XouLAQLcqKCOFwIZJuwc2ef3EvqKAy76G0ZLo+evbAK23s0Ouy1j/dBfVuCrgdlmO2Nc9p0j+GgHQCtIZmP28xP7G49HFqiiK1G6hMwuiUL+GgT1vye10B66LzPkUNEBe2xKUnTWnVVPQjdn94WaARnySwdkBujPnYsXZyB7n+F1lNz1sfwTqpcqg57wE01ETc9Wf0AdAHvrHNR8cJv2cMXtkT1Sz8YKGBkRM6W8ZVu09AaWdQo4wsqILUQ85QNrfd/OkdGt1+Gz9lrAWTygKdrAF0olZWYI0zet0Bh1ACg2CMSGroKBbN6yx6RQKymradlOw/z6ZP7ufVwdm+CplKV+b7L4oa64oXFC5ogqhcjGCRH2pQk55mJx5hwehaP1fLYujY62imXWWeuxUVOjqj8ndnZrXuw3KdVZQdmCubiQQ4JmvuH8E0h/4CLOh0ppiQtkIyobQNmKWVmXQP/8r/xHfeP/vwK/+xstRmLtiYwDNnj8NDSwi8qyHrgg7a/XFRzoDVOYtki7SKoBFaHhb9HkE5ABmTsCcAFpJusCrvg2zUrLSvQBpfxZpu9VL6Hhp7Huec+t92litHjZwRpjxBTNI1gbOa0jb2OuNLg5SZvScW4QFiSyYgiD4uw9fgTLPqDiwsazmcF29yao6yEg5xFb9YqkJoGeThZ5q2hb3pSVicnqA9hu9S4I5cLoUGsFa38kg3WFa0vNzBbgfRNIhHFx9bPVsAstXFmPNYqzZtS0az0WyC2Zr6zL0OsqcV/Eqa1KZJS85a+8GCwNQuy6XAdpL6jucuaG1A3SvsO1rvjJq7GeQhg3ekT37ANmlq3uUaw40IPQBcFwbwb4fKwWYYBPAk9UWRTv7G5qhFb4cnE0CZOYcibJtBOgA5hyJJN3W608hGIcfq6hJz/J8tKRnMTXI7qMHh6VL5AiIggGvRgyTg7XV2UaANExOUD8H8yN3DcKXDvWiKbolODBPyp5ZuwK09UYa40O6tKmWktSCGaUwtOpVZygiujShrkKuyyxwOhPPHXZc8mUzyczZ+hgIpSlzVtmvQD3NiGj16sYPmLWY0dPR/XYywE3QGukiSH3VRtBGGTQ1wote+gN43gv/P7QNoTJFifQwaadZOFY4N3CWJMqWIN3UJOxpQ13Y+TVL8iknYDYGrXVMJOIWt4FZQrnz3+6BYWM89hgMulDGyfYjYMjHE9yCHGUfe2Uwe0Duaw5wTg+GkgLNRxA6AsGAWTY6fqLymPtN/bwLQFOSiBbsBTZgTrUQZXTg9brQWpJUR+1s1cK6K287g8WfEsfzVQDLAJ33j+HICbjjGztFnQOzjN+NoydbmiR/sf+tQAHarIpaiqahrzam81/EhQXQV6GzX3KX3yBrF2rJdRGcj6BDCPDn6SLA3+uvywKsM4POrDu/O0KlxOTMw/c4YJZFdxE7mrnzI1wCs4OxAzOlrfclQPuV7wDmMGWrVqh+KwM5WQCz/w03aGCYpTw5ODsokoF48e+2DtI0j68jklsQcW7OmkObLohAmNg2YwXFgMzA04Mz4lITe7IiGWQA7d4uQjELl2iBCFFBqJYqRSxagHIHZwXkAgfmFXz9XAfo0ioKV5Sm4DwRRRDuBF2yUFfMaShmjgSroiSu0MkGbMC8BGetUGZ6ftAzAAaKasQQlf0ZlKu6NKt3l//pFrsnI0aNGGtugjYT5g3QNoJ5Q6Z3SX/UphiQCJpFq3sJT1VFzQdKgFC/LrHbTvGEECZmYRnM3BHj2/OFEAU0LDpbjUESllmtGd2BucV5JhC2k/BRH/Jbxhk0+ljNnEsjQMsCoLupW0IpjSIk4WcoPX0qp1KlSG3BBkRHAK0BOYLUNYhVU4qSoMacVXcuOl9DstUkV5wl9gyBvsCuBZqhQWK1e2fOG/RU02xR3GHIjXHEIed624ZRbL0aJRnQRU5/OJkj+xEl/e2OOB7HynRK4lGCZOAs7mNOLq0kr+Poko49DiaMcll0MH4C7YwG5zU6XAH9oSjMbEfzbQNz70hbPUq+zTpcfTBmLXpOwNwG1jwlkO68KS9FObZd4NywfbbLB5110as43gDQCZhj5Mv4fWwAWClP8sK/1MHVpZwDNCWQppZAO5Cj+9/ijrtZW+wSJboyZquSAWPO4rnO6RYamngBCy1AkSpFSVEfpf+EUUUPRPeUnrwEApGBM00gUlAGVhCs1CdltchJJhCvQDwpOLeKWqqCIxUF5ubg7PYUXWqUuCkdZRXA4uZCcXBGAji9A1FKEa60M7yQyk5gLsBUCVMR3SfEKkxV7FFN/dHmQPzGCtBtFpSZ0Ny8PQNlJsyzaPGXlgLRXD8yZViBy9PDFJzVxUBhEi40GgQdiPt1poScsDUbc2aklCnpSQcWSe7DL7KuDPdCZzWs7/XGR6HfrWdLK1kqUpSZMzI46zgdQDr8DwbQZe5m7FJMB3atySO1bZ1gHEHKWs3aZZPWvG4g89MzCIVc1hCYHJgdqtI/q/zlRmpfSASY8RkXXB///Z3Pw8HhCv/um5+O3/q1N0C2wLkfj+EBaf6vS1/x75FL5xwMRsOrfO9dLAyvfT/mfgZ7St91oObh7+NF+ItNmEnyHVNLwNwtnf188xFtAO0Eaf/8OgrO+QIyyGZG7Lc4A3bBaGzLfw/kW0ymXy5NXMuJ6sCc2fOUemfQOZrbf62b7Tx70IOeluC8bLzjvXwVfsYu6ud+rIEFA8MSjrBFKXKxkBwwtRQ27tfOPUBb4GU0UySGjd8yXl50MTbACpIafhs2WSFKOoUdPxBFuzCDWCOpvWCDmrCL5qZa6c6uypXuq6MKMmAGrcC0QjFwhhwAsIVBRBcHKbwCtYrSFKRrKygzBVOtJJgax/IqJBa5wBN0uTlLazEhXyQM+KaW6LiNpBkvQiJk5UvF0qcQ/uapEKYm6tKkDsyTgVFlA+aGofx6kFIGZvM711kwz9RDCVoGZk3b8uFQjEGHKR6kRR7I2KZ7Rwpp/B8ZQBNQqEdbKBh3vic+flI+dI9rlIEte+oU21BsLJG+lWVoUZ1N89NtFCCGaGfUI0B383YL9lw6MDsgDSZuGfzO3c1j47/w6GvYBc6yBooGhgn1RTXgBTHMV+O/zTm6bUsy9HgMGa5Ozej3fuA9ceLsQwDANz/ia/Dffu3NWr5ScoaKgCmvV9CPCwdoGoFzCbODqXkHx0ghIYpz8dd+fP9gm433Q/LiHQdUmM9Y7GpMRkZFMTerhXa1+AV7RfmYMv4OYHL1mrczGpw3WJii0n7X23I8dmfR2czd/66bt12U+xDOHHSpSY81uSdjzRMYq9jfZeIGuiY5AqmD6RzfO33zv82vc/fjJkAOgEYHzxwoJhuESdvP2f82C5ych5Jthr7PkszY3in5nHfYMChdg4ilVCnLF5PkzhRUgHOXxFwB1mIC1GoHaKNI+gtst8CKT/iCAqSMGcWAuUwgWqHQCqADCK0AHEBEO+QAxAfKnJv12czbc9VobQdEErOlNFSZUXx5QVtZWFhr9xYYcyYFuRATFvnsayP35RWtIpkBc2miJuyZ9DeNLa/IXmMMHPZ1SpDAOTPnyQC6zgr6ZUPGnPW3PJ96ZqAw2RKR5iOnDszBnIvYlqyOscpCD9BnggbsUR7VYgy3bztqKlBrIoIgDwWvCuZDsbEJcRuugh5EWNJwDmlh38nm623mnOvwl86gKbE48lnZoT7mecRadCWVyFc8SrEh5MC8hq8TrUsU+oX6aRfzgfviiSqvEECp7xU7n5LAmcJatsEvvfQP8a/+3X1wwxudjWc/8ZfQcAIeoe7AnGG476lrqpMN/+0um5a+5rPPPgc/9cIX4W1vfxue89zn7BRvfh8HwowuLgLkJf5bNE7fTueS40s8Mhud0rnLL6PEyJEknUwWcuk8rovg3DA+BtqxHc3aS9DOkd1ZL1oGho0GYgdoj1zcNmkvWfMKMgB0Dw6D/U7X3nJQxnFseTkIsoqyHCj+WfJXyzhZAlgDoK0ISQ4Wi4Uz0P8+AzRkG7D9Eh2Qc88WgViGMgWHxTUwYKySmGIeaYlHEyzClmZVoWvaKjB7bW2vr02iokiDy0z9shBustJhRBXky2MWXS6TywEKHUBwAKFDQA4AOdTOB6B2ABg4lzopQJeKQoRCpJHaEFRpAc4VGnVLsgasApFQj98eivgPxsRiVcscnJW5EnnREfdzGzDPBs6wmCPpJZ29tnY5DpxFU4c9qFitsGridtJW3KQthFmsKhlIGbAgVhNlEgWtAGIZQTmBc/Q0fxkKyhxDXzpRMbCOVbS4f3dI8U/TJpuzSxqu8CHrchXQetKU5/w2QDuAy6L3GZlOJKxLswGL2/Hse+R5IAtwNuDU1zMEtuJVklsZSDwwrJDKKH/IYzGmPL7mOP6Vp9b48tv+EESOABxBDJz7bcz/jDNT5856HSM/19tBi/MVvPIXX4n73//+EBH84R/9Id74pjfiuCbpTwmqbPX7S0YU+m+MUnEpJ0fWoP5n93V1GdWPRPlgaWfXNiHTdRGcZwyVFwEcB9AAApCXAN0/7zC9G+JcC93uOfbR/c3OmFcBzsuUpT558684MGdz9q4zyt2/J4vvnw6g01ddslGDRiQvGbMDswN7GqTZVxynIl2dLegDfYiCzrOM0vsLhSSoEOnKOR7J5MBMDsyTplpZ5LSwpl2RrXNLrIDmVXj1Z808XkjTt0qF1AoqFVSVORcDaCkHAB1CoB1yAuBD7U0BmuYVqK707xM4uyNDTdqzgrOsUUQDySC9qD7b5TWygLblaBM286KmU/lCJVGZrEmYsLWTG+PNa57WWDBgLovHK4i4OlRjzkM97lksxo8CZ2Zj+bPd4Uowk68E2O4CYymIJYgdnBvlUSAxVNzsrYAJS7Pqw1xiK5FscCwoo29DDItJgADmbqJeplXmLYP6gijojHuU4fkk1O5ODizSwVIg8NiQDJZq2vbudQnUdt8X9ylp6wTAA5x0q4zaZA+pXz8ni4IsVctGTHfFJd+x3ZHuo82FZs0KAMtrDwV8Kcf6NP+7S/4u3vrIP3x0EVU9fLU3HxbpsJFglQBaln8HoKt9foAsR01WyiLPh3ac1HA9x2399655O6PBedcl04794wC6v87ALPGJv1rCnGvI3ZS1K31qyZ5z3xUU5gN8B0DtOIMR5JagnP9ulznHPzbK4MfcChirHZglDdQluO/SD9z8DWPEYTZydSr5mhulz9P1W66sgzMaaWqNL0ZsAscrdYmne5nUJytTmBm7wHNAJcXE2aIatYA8GbhOQJ0gdQWUA6AYa6YTCsxiAN1OAM0Aej4ANh2ciUoSk4IiDswbVJkGcPZUDxZGIwEl/79nPPsyeJrSUsycbz5nUpdlJctxNmB2U/YEYCWESQQrtkyeaulVNelPadQ0Qa/L7SZw0+EoWDMF+5zF/OMEO+MOzLtAmW1FUq8707quEWoqLD3OZSab8jeESogPZVmANBLT7u9FXRMk5jzMOlfffWaOaVXbQI0uD1yoB8Cn+WuKJkXtathr39dARnHrFZLPWbQqWGwTMHcfumlAkQo02VNY9dfUl0osMWHtbtMMkg3Egs8QUcsdmAcZFAs++N9bqqPNYyKP1lbLjof1DaQAhEc86hH4/T/6ffzlO/8Sf/b2Pxt19/RNb7TrAxMX/Uuy483xd/vRBsE1gnIc/KrAOe/L4kT34BxtF0D7/gjEWGwHOjncau1uuvIJm6MXfSmybNauxp67abtPnGwy8avZBc4ZkJd9y5m7uBOyOIZfaevv5wIlHniFBMxbAWmLOzeAtE88/55JXXdqUu3vx/kvvj+AM0zCUtJHdE1cImP2kfLQy2p2QC4BfHGvPEgmSDxZSHOxnKMKTJNu6wpSlQ1LOdBuzFnkLAifAPgsBef5ENgcgMrKfNU1xB9BbGGBhiIb7Typ6TtCltVMTVY/ujl7GsqsNrtOVmFniou6+JMJ3VK4agLm6NJN2wHOiTmD+uiqDrrZEus9Uqg8EMyiyynKqhjYUgJk9TFz7SBdbL8VfRTOmiO+NQ9do0s5gEwAc2+k0S59hFGaBsNMcfD2ESf9uxR/kqONEwDnLmb2TseOnxx+SEx5YFOqmr5mjaMgi8ITX3oSusiFsmYrp8vGmMVywyLI0s/VgFkqgBW6zWQFChnk6YEedeMHUH+zYAPCEbqFj7oG5A+DFmOSTBXzyHCyO0+WNGdBch4cRtjGupe8/CV9Xu5S/JNo2wnUWVPLf0xLgM6f+wjJwbmnkXWnbTtAWnZ9dvXbGQ3Ou+AIO947HVjDhuhxx8+/MwJ09+k4SPd1QjtQSwJqNxPlqG3/BYkJQotfZehj6kwqIQvyABv/dnklS1Um0wnXhFOw2mDKLuih0fl30h0dgNklvR+PAZ5s4jkTLv3PM6AnX882OAsQhUmqTf7uMPUFKgKkTeON6IJg8v5zZAUgioFyAVYJoFcTxNizVDVrgw4BGHvms7TPJxSc6yFQ1QzeFRGyfGurX8wbFF5rPrTV4qYC9R+bYCaxYKBwMcz9XkoBEZn/XJkz2FKvSP29y7DDAq27natHuh6SS3mmgmsx2jzIeNfSwmN4gWC23w+dhxBBX9ErwJViv5bOnmP5cJja6kM06Wr+HrOCcrzvo9pe5JrZ/v4SkLfVzm1JMIB5ujdivxG+5lSxbfSFezfWzM1uBCBNLTZuphBbF1qgzJkMnAVW956jsko6rs+ppJCGA+Mg9VXquUSv3SRj6uQ5MGSlev2eUJY/Vn7JChQRJoBmU5ibLTihhYRSpR+d7s6gY84v0Tc9aDnmK+nhyPJz07B6StwI0LI8wE4gXoLyNQXn5evrIDjvalcHrHcDctaoxr9zUDaRMYBzB+sMyp5nmMWkA7Oz522z9jYwi323pW3Z0TNAL694ub8EaunHEM+pcYBOgOZmbVd7YzJQeu3XlM+r9nNwQcKJxfoa0rBjtSRkXMAVA/OSaF6kjaT85Iis7KAMeDqLCRovXkKEAUWmAqy8V2A1gVYTZFoFOIuZtgUnIHICwmdB2lmQdgLYnIDUQ/NNeyUxU0DE0IRnEK+tmlix1FbR9X65WYnSWSNxZYUOyjWsA2p67ImA4ilAAvU5Q3pGjncD2ILOht1UXdt4S102BjgDY/rmwocL/w75k5e4pa3QAMpuyuYqaLUzaH+sUV51OQVaB0YFP+kF4kZ03Wl99OsIrJd+KT5aYe/vkgo+pjLmak7z9u0Qf94RrOfP3p4xW2BjE9NMKFF3A7+q7FhI/cuEBMzNWHMoSTSCtMe1iAPxAYBD651FgyqiWp4I+soBpliaEqjlLbt7xQuSaDDbCqCNKshULdBS0xE11TEp3NbFwFKfR3dPpJtt+9Tfy0paGnfHAbb+uaTBcDVQ/rTgjGNeL0/6uPeug+Dst1EW712VznJ1b9UIzuP+KKuWUZq9lnbyOCKLTAnNVQdpf/A1HXkXEOfud6Bg9yjedUVLYF5cjSQp7dKO0mANQF5uCQPTjqpELsEdcN2/zR2YB7f4QpMVmOSWJL1HNNkVjw97Lo4c3adKcTooMD9zgUwEmipkVYGDCqwqZGXseVqpidtM25pOdQjwCUg7AZnPgtQTypwj5cp9yYCX2yKegVZBtVhusZmxrewpyawCmVYmmLW2r6CgDsF5er8FHiRnfmcfFWTQTRhGCAF9DZJq2wSO+fYtVb2BBNrr5cQj6CMq5KArCZjJgNmMKG7OrovHmX7Xh4mQpnH575KkvykdoJeyfcmLluLZR01Wi08nfuM+kCoIHtmeI+ezGVtN2dzBuTUdaxqOD2olFedLzFQ8f9missOU3eCLfLirV2vQA2BNqYMvyJLYMxk4Ex0aoK5AqGaBgdILatDUvmqsU+8SWXqlYGNjco3iLjqawDShoIINnAtpSiBFhR90Zdi3yFrQDtA8TtguAXop6POAzYcGsIzi3v2U87nsGg27Vbfdx7o63zt9O6PBOcsT4PTQJIvt8v1dr5d/o8fvCQgvevlz8ZCHPhBvuegvcM+7fNsOkHbwKGmb06iKHTuDscRnfbsEYlp8xov3rioAIf9e1v0NKZe+4xiveXAugdnRrqjkX84eB2+piALMWEj8AaTT37lpO1MrP59QJMY52SU92WnpeUbYHynYUyFIJRWaqwJy9nyoQE2rCZgmyDRByko7NJVK+MD8zScg9QSkHEJwAK0iprnLEVm1apC2gSc+UxVQY1CZtfMGQirwSlhcKip1gO7RwHrdcYdN1lHkPKdUQelJOhCE7rcEuIE5261e/EkH5sV+AHrSnZwRd1O2gC07r1mUOC+ixXNAbAyL1gG6+PumQ+4Kh5A+HAACbvVZt8bFH/gATl525U6Qzmz5agN0PkdKZSKdLSczdi/s3TRjoJECc2HIXAy/LA1JDJyLLQdpazeTgbNISyVqVSEbrUxkVhU3W6vf2QGacAiiAxSsIiZClTm2JSMneJwESKJamILyAQRrCFZgmgycPQq8DyI2xlyIdJ11Z9AB0Hrnw9gWhVLs/AFj6+lmL/jDsW0LoAUDNXeTyU6E2HWghfZ5tcH4mn6+u53x4OxwBuxWqLD4/HTbq/tdB+ivfdBXgohwxzvdNgLFkMB7/DsH6i4i/PuI7XL/mnYH28ykT9fy5ynNajgv/yqNA5+W5+qSMjNmWXzunzklYmDJOIYJSP090xv6JKf+84vzzaZOChC3z8TfN4ArlJgzQVbFmHMBHVTIgTJosehtFC/huYLwAaQdQDYHCsxk4CwGzq2k1ZFmNZ37couFoZU8VvBKZES6hixT1RKMomkvZZfSZ5Wa/MIIpvMMLZJzQlY52nog/C5jzGCNTE9v6JRAO3/fQDaCvgyEZer7ZUKYtb0qbAbXgYCSkkg3z/vyklG3Y8GeM0D/8A/+OL7jEd+Fed7gVrf6dFz2D5cOI3bAizSCtsHZFUk7NpaA3McxWcAXSQdlBeYZ0iy+oIiOu0LG8PWiIl+/qsLWC5EoMFOsdQkLbS/GmDPoqILsi7UQrRb9AEQrFEwoVKzYjTLngh7AqKmVMxBpVSsIaXooYTKmrGyZqWKp5XGhmGNeS0DSDScfNwA8iSxutSv+S1DOcmAnWCdZEcfamhLoAWJXBbi0eH1N2i5UuWbtjAZn99zuAudkUB3aTg14sX9VWx9IP/acF+PxT3gkXvua303HkJ3HGz+5ug+OFvunA2U/bmbOefAdJ3qW50Jbuzs/z+dE6TxI4EX39WOfsMYKYtmiHWqxYAHQcozu4n+fTyW9zoLaHIoRZ+ZKE2GbOVcFaKwIOCiQAwPolQaISZ0gJeWu8wo8r8BVGTXTClo9bAVmBWdugMwMmVQBkJnNhz0rSnkVELPzqkDVsKpiaSwOzgxK//Ilp5vD/UltyTfpsj1bX4c6MlnPcnDOQE0dnAOkHVQTevvaC86Qw5Ttpdp96zqbPy/0YWBlw+O3ovCcxgRuZ955t7tyj7t9KYgIq9UBbnGrz8afvuWtMRYyIMfdI2wNo7GluSum9nh1PAdkC/oS6gubiIWj65gTSGmabkSuPFl1amFAtOa6LgfZwbkzcdEqeUxm0iZ4JHiUHLCHGAANL0WrJWgLrVDIwZliMRaNuBdQpFWpCRxRRGlCIU0XVb+yma99gIRli+LBMVGvYe83PilQHZiT3HFZsNTxMxj7fsnv75Bd+W8XrRTC8573k/jbv/0gnvnMZ+7+0ifUlse5DoKzB/vvEkT5WS6faW5LuDwOqPt+h+BnPeN5eOYzXgwx01H+DMicpVfRGV8rcrzqVd+Km93s0/DAB74UF1/8sR1ntWynA+k8Yo9rS4DddUfya4zvBUim3/YVpYbv+PsmqUO6el8iw+KOu4/Iw4aNtexUGpa6R8HwnvpIk4nX33fmVaHMeSoRHEYO0Cs1eUstkJJWG2s1ANtNfczaZa7gmZQxTsVYI0Nq1WOUCilFEWvBOnT1LDNRL/9Jr++kATs7np6YHMeuroVBmmAYOXHLXL7ZvXGwk+G5J8B2WVwW4GysWJwdT+il2tNCZ+GaL2Zboa405HLThmsaG+hxhrviIxNQ/9vvfhhe9vxfwFvf+sd465++BR57IAL0qoDbQ6dvx5lPfocj/dB8ym6Sdr+wm6Jd+7B0KV3aUrULAaV76+Cs65er4mZxCGhWeUt/Q3+O4BHfkKKpdXakPDa8KwhX7aWiyIRCE6ozZ9KsgWJ17Am2DCrltM8e7Op+ZTdhZ3bsGpuHRuiwVqDuih91HDUzN0FiLJNHvmfh7QLdH9gukOY0GXw3/93ivZ/+6RfjX//rbwcAvOtdf4VXveqXFyPgnwqsr147o8F5hW1wzlGm/kz8OfbAD9pxu2g4zukBOm/HCrM+oiSJQ1mIx55TB3zrt94J3/RNXwgA+OmffjAe8IAXpivZdUb9fEdQziPvOFXEP9/VFldHiyveYqq+tUnp5xinRCMQl7xvx+tLASGo4M5i/dI1asCRdrwvhMU+tgeHPSFa3DoZGDSivJYYixbvU4GUHuynZmtlEIICZu3SCngu4Jk0PXUy5lwJXAq4qDld3KzpgivrOj5Sj2N5frmueKTGbvLlCDEaQhHjOF1Gxi3yzBc/rucSR9XVxb3LfmYHaGfMkXLrTDkXyUuf19KP73J2AGYfIgmQKf1+Pqdcc+Zt7/gz3PletwNmA5A0qnJcUuiRIvq9xTCiYW70IpZelsQBmmLFDWXMYbOPkmcMsSIgWgPbpYbKCza/soiu0Sxu2g7ZYafAZL4CKDiH2mXnZ0VatOvY1vtJqaSsgrauI+NLmboTxf/pgwlwpr76VoB/gDJ14DVlN6cNcNFz0RXlsmaYJPVyWmdwTrdgaP5oWBDLm+UPl8Cc2kc+8hH9lgg+9rF/2HHQa7ed0eB8gNGqkZ+jD+lBmFnj9N5xlcCW7+lrSdslMx4B+nM/96b4y3d+GCMoL/OYGRdd9F5d3o6A3/u9d6En9+cReTqA9jtQ0nFPp/nt+mw5gvtnb7no1fjCL/w8vPCn/jMe85injDczJDyNk40cmAV9bWY5zRZdAhcH+TSJ/dq3QoRl8Rm6UuFaNKF/ljeuUxBl5IqALXGGNyEAGpUgFYiSjpUgs4lGAYRJXYzTontAVNGtFuPQ1xqnJmMMHnRRjzCZwgBiuH6/bgSQ5iefdaxhXQRFoai65T5eT7XK88Wrgw5VvghjXRffLszZmRm7ObsswDkXdPOy6nEOeVjZNaS4oxGY8xKiC6D26/BtBL3ZEIt7lvBCyIK60n12A3RnqGbCRspNx6yMMzHmuAAWoNXIz8/lMBleI751gC7aOdZ1TuNeSn/gKIg1sqiBLFdau1bTK6ypZ0UklgrVlDorWEOiEfs8jgFVVtJdMOzL46Etnr93qcaeC2HpkvYH68/jW776wXj5s38Gl11xOW7+5bfC5VdcrkM/i8AcErNr342GIS9iMiXZMH707//99+Ov/uqvcPHFF+P1r//t8W/+UW0pdz8xsP9/Cpxz1yHbn2tvIxgfo1TtBOYMzdug3H/9b973C7jZzT4Dv/+//xJ3v/uToIuW0+LoOorf8Y4P4KY3fSLOPfcsvOMdH0pnvATp5RllSVTSe7tA/Li2Sw3hQcLf4Q63ARHhId/ytXjMdz4FgxQbuowAexww51UGTsueTXpuKQwLkBKkzxfXPuT+LK85nzeG5a0dWJz1ySS2DogooNiiDoX7svXCAm4MmQQ8MXgicC1oVcCV0QqjVUYtul9sOUwuKkTFrQpg9GXslj1dg18WAWz5RWKXI8fctuVhc+BVQQfofm/s+IYzyxrYuRTnqOBgNFtnU/ZyFdJuzR/B2E+Bx+9sAXHp5ynpnP3eIL3vt8Ojh+N+Ad2cL1YDISt1CaCztIk1qcRKrEZkteUyE0WxLC0yUs337MtLmiKAzpwVoFmBubYYJz0qHIAtfKKPycCZZgXkooFjVBilWBS2bYuw9YYiRRc/AWlNQ2Zjz7H4ZVxzLFRKtkeqXDafx3nwuJsiKV/6nClM3GLf9YIkj/qXj8JUJ9zoBp+G+9/7q/HK1/2y3uZGXfwRRmG+tOTtYmIST7w/z4XAf8lLXjIe5xME0n+KdkaD8yG2wdkhzcdM5qp5z4d2VsJk8fkSukYw7hNV0q8LGj7zM28CALjdF9wcHZh3gbMOmks+/DFc8uGPhnDGVsnGJUDnlqXUUiJflRa4FP55FqiK81//6+/g3ve5B57zIy9OP7cLoHeBMNLETaAcwJxO3Y8Rp71DcZBj9gdAtv+iNNTwwTBhQyjn61legzFdqQq8KC4oGdLUGsLC4KmB54ZWG1olAzI2UGvg0sBlBpPvNzSaje14xSVlPn3VZod+Hsad6hue95vybe16HHCqI3jS2fRvEJWyWNISJ6TdrQpR/bQmUDaQHoA6dfF07Np7/EBeTyV+FGEWH58h+jTh3czYAbaPS3udwXgAaOr3Im+x2AdCkEelMghAXrRTfc3FylYWWzSCLLqezLRAFitBLGqebnrBDs7qMlAW7ivGs7FgFp33yp6lj1EQhsI+sJXUaDKAbqAyo8gMqjNIGkrV1yXqupP1oltiVGoopGuMlyhI0mWQgME2NlvRfbKUMNqaK0mRrQh3kbJoMVN4fzZPffHT8V+e8yr83Ucuxq+86dXAQUl+ZDsFIs1yiJYevuQHii4qKT3U5Xf8Vp429/nabWc0OJ9Af34ZnOe0dbkPjDXBXDd0oxDQAXobpCX2Ea9zkNcI0E960ovx8Ic/AE95ys9BfOlH6kcb1Yf8S3aMZe1aB2hZAvQuYM6NFtvc/Pv5mM7eXEIzvv5Bj+lKw2C+lv56h3nztJ0W+8u+lJR5Eg6YfBqgXn4er8eDxi+RmpLJBKGEsqEsRAqHqVFIKyUJZrDM4LIBlwlcq/mUBVwbWiloRcCF0cqMRhu0skYh7xswNtDVgFQY+r7+hoK/kEbyZsDusG0mdRP0fo0FEqw6LWOs+3DwVtyr1h2chyJx2fxcE4Oux4BzAnTZwaKcZUt69mEm96cSw5v6e1m/DcAdhbx/lv3Ow+f5dTp+F+CIgDEQzLTtip7gwpv/M7zsl16Cd7ztnfjef/sfUMwUrZCs63EVWNCe/xmbCZySSbvRAM663rWZotHAyTEnojEaUtydSmk+6jVQschsmUCxTrj2Ilo0pIjmzxcpZtaWAGdfZ7xgg8Ib3doKWGTlQ8VqfTMpm29mOvd4Ek0PE9QqkKkDtEfpR2BgobBQuVvpjX/2uzj3q87X+16g2RJMKeiPlvb2cR7H4HElhhIw25xwK1wkWH9qAnJuZzQ4H0IvIJuvveChA/O8ACZ9JGMx+4IO1vrpNtQd728egRko+OFnvxzPfvZ/BshTEfyXHYA9CWxUFwaA3sWcc5BWSKxdwLxDksU+0vf99zIwmy1hmUdMwMJ5iR4AYpNn2FI3ccZrRwF08+QSoJfNpXU+VQ/n3YHJ473c1eSY7/auIO33XM2KziKEtKyiYAbTBoU2Fq1dbZEHUXZMFVwITIJGjEYGznSEQmtUrNFoDaI1QLrgQCED6iiTqILaQZkDmDtAD5AdmoaOSBKrb52e9IRxFPo2wNn9gsk87eA65C6bgN0JzA7ICyYdJTwNjMOHTcsnQFuP1d8Hdj9ZgYK1DOM1g3RSJn1oU1fO8jHJhLhYPi5Ez+hFr3ge7niXO+COd7kDXv2L/xX/+41/GEFUHaB1+U71kzswMzxy29ftFiJwMwWq2Upkzda5cp+xsVWYglVgQYQxVwEULTwCj7ImB2YFZZIJBZOCMmwFMbCuLe7MGbbWOG1QyhqFj1CwhtbZ1rGpFcJmMM1ofTFvc1SzWpaqQKqg2NbjDDwTgmqXCUNuejxE1yApOIoU2i0bhkIlBsCFRoD2ub4l0NObZL97rLy49toZDc5noQsYhzFfaE3ly/bqU0gTPHtW9PnT4jlujQj7PwnyBTCrAM+I039Ne0NfYGJ5/CxGk8oh+bVr8+kclxLp2L68ll0KgTsDwrmzOIwN/sFsbVI9069Mx4Z9/75tIz8y/RZoKZXTrZFufV8CdtaGCTj77BO4wfVviDI1fPTKj+EUXzGCvf2deFUnt0549/sgc2cPIazWEGgKFcMjWQWMhkYTmhk7GwGNGvTfBg1HKDjCTEcgHJkAXAO0hhhT8TV7OXozaPZ/Iyg3ODvufkl/XAwN/mFZLJ9CGpTeSKOlqz3C4j5C97un4C1egLQcB8wueOuO9w2QfS2TeKSkXtxsbu8+cRrCB+Cv0/AYRjaN3Rmm57wDim1SoMuKQuf+OPlNKohFP0Nw0R9chC+5x5egtYa/+et3m3+2GejZ4iNwr41lpvtiF2QV4wycXSnhJgHM7IyUDXwjKkpPiiNEvUGd+H6xnm9s5u2U31zsrFwWFhE9Z5lQUexbgkkaKmxRlnKEwqdAOAXgyMb6GkIbMG3MfD7D1g2FFI2dKJVRDJwdmNniNXL6nGZGmHLk8z2uBToYBsZM8ZX+kG0AVB8IDtDSATowOD3YISgjP/Asqz812hkNzifQmXNmzTVNkt5GtuwuDd/vlZn7vyVIS/q/A3MyrFPDTv9yMF7nKTnEEON3B4DOZm4Hj1HH102iCVuO3KWikH8r/Y6Hw6L14xGZILDf8Cjspf84g7CDdHWpn18vkYA6QEdK1mKiiu1n30XWVQgLFq3358ILzsO7f+fXUYve47k1XPiAu+HiS/9ut9ZtVZ7ElnaUSInRLckMkY12A2YRXZBCibwYiM5gTCa2damAJoyG2cB5jYIjFJxCwSgAC9Yg6uDs7Nn/MVj922CLbug9e6Xz6HCA9iyTzJZ58ViGdUVyQJflKGc/8hKUnQ27uTpM2Gk/0qVo+zGy+PKLHZiZ+3vCNBbjygpcGs27dNKYFpLeKwmg7Y9TcHIiVuboEsHTvv/J+PVf+jV86P0fwsf//lJoxXOCLw6a5U4R/zvuN4wKhJ05u5KiPmkmRvPkblY26sDsp11AYM9ZG0y7Vlu9aKQ4kfuhfU1xB2YNBqtu5h5M3IyKjQH0KVA5BZJTgJwCcAqCNZhsfJYNvMSolIZSGupOgO7ArJ1SIGDPhY5690JRYGWwri1lV8xbjIDsPQen+uv8t/F8lwCNHa+vvXZGg/NZGMHZ13DZIMNRf7BjvGVnzaNZu89qX/lnu2VaZ75Y5FQpB00svpeiYLYY7eKYy+3g//KvLqRQhBvv6qcB5zBnJ5vmVuJt2wbobLbOYDwds02dMkBHtQL9LS9P2U9ROt0LrRoL6Z5uF4Av+aIvwFRrXO1qmnDHz70dXvdHf2eXnzVuNrRh5BWEtOtausITiNcQK7EpUCYkTGAWMDOYG5g3YJ7QLOimiaBB12du2GB2EA5gPgXBKVQ5guAIJGpK9KUCGbMBc4do59FN1Bxq3skA6NwKuqxjdNZaydhz6cBcDZSLR1WnhaADnCeE/3nJhgOIqQ/NAGgH5jSymwFvI3MaiL9HffGlRvFIxMB6J5s25huzKM5BOjBnXdiJVQbmNOZ0mrnw7iD99j/5UzUHBzC3EaClr09HxJpalXLGhBSAItpdFJxbca2DY74PLjSClsSMwjVZFtjiJ1JArCyaihWyIQd2ZczFVp4q4v5nO2dhVFHXSg2rzkkQTkJwBMEpEB2FGwa0sTzsGVyagbICM1UBZWBeGTAvAwItjdFpkZjGQs3yoQfWTPHcQhlnA+ao65o7p3vk93VXE9cQuvD4FGHRZzQ4n4AWIrEMQ0xQsdahT2+yg7AO+3Hrpig+hjkTXLM7BtwsYVTcDEyLB+sJpY4kOdrmWOBf9J3aXxq0AcjmzInlCrMi4JKJFsdf+rhTGN2yDBS1bsKOhEmM9GuqqSsw3/CG18erf+Tp+Mill+Obnv6fOkiX1BNzppDwCESRRskNn/ZLOvV0aa/6rdfjoW/6anzuLS4EEeHt/+edeN3/egOwShJd6ZkenxnUFJSlNVBrwDxDpo2uJDUrKJNUoFhADwPUBGUJzFxRuKAZAWrMaDJjlhlFNpjlCCRHykwMnAWnUKSbut18zhZ0loG5d1Hwp7HMTeKR8eSL3TZ9VJrb6gAdj6Pa43B2k8AZO9jzkjHnfOIAZ4z77Ldd1Ew7hD0KdYBuhObgnIBa15KgVM56UTwo/TaKfg77zT4n0eMeOU0vgWkZ9h2BmqelrzVXhLWQB0RTkDJACzRnGIjvqmm7xQ0SIbApFo0BLtJ/QzJA96vKpnmUAnZfr8eAwM+1s86uS3vhV1t1Sg5QpINzD7RuGs2NDQrU76zK40kAJwOcQUcQUhN3oRnFmLN2S+FygK6yUPIyQHtt8UQA/PwraeEYV9xjIPkgN2Xd/TV+EbHSHXcS4a4BXTQdIbO3cLdL+952yfz/e+2MBuezoOuuuJ+5A3O/qTvq+RgUUXx3BGVgm9Vi+/VWLqoz6Na/vsVMHTxdZFL6bmpbxSZyS+fhszYAOamltAugvfsxd7HmxGJ3dkOcYZFgUgdmLboW8lRBU4395z/hO/Fld/wCAMB3/uVf4Sdf9yag1h22VIORTLMMnKnZhG1k68JT0iMoBG1MXgBf8+8eA9AaoBmoMzAF7VqYydlYebM8IQPmVkFzBepGI23hJTwNEKwcI88NZd6A2wrcJnCrBi6EwoLGjFkaCs+YeQOSNUiOABwBcgoiBs4GzB2ct03bDsqzjGZtNW0Hz9oaLU5EOnsmy1c1Y0QG6ORzDnBe2fBygM5mbRq7j1rXIYeZYvJUSIHYGXQDYRYDaFbgas0Y9EydQRtAh5kbI0BnOe+MOe6IR/Gyfu6pTk7nySJ5Q5/2w1EH6WHVdune3QktZ4ehijLnAgVmkmJs3wFaTd/NFAAH5ZwJ4sVpXPkhY85US8w/vWa/ERaIFp4pB2aGpnodoshao7pFFUg9pqWGWbqVZhKooggDaMYpFDplwLw23/NG07YihYtBlTswh2uEEkjbfnF2nDUpQlQ2cXkTN8DknQOz+ztCDpn1K4DZwdYUGDHQ9sHpDzeUNkrb/KXcloL6mrRrDuxnNDgfQguRODjrxPAbqNsOyK6l+4JqFACt7Dn7njtgp8X3EDN/eEaD2p0+E8TSiVHeyKmeA+oS/P3v+m58lCXPEmydOUfljB3Fi4e/SRrkkjVTsbvp15p6IXh0ZpQZcuY8ETAVkAEyVhWw9ZD/9zvfiYfc58sBABe9772gs+w7tShIb4GzsQyWxJQpAJk21HWRTbolWwxatnUs2PuhhQO3Of+z8Mc/9DoQCHf9T9+It3/8PcBcgM3clQf4Obm8EAPnBpln8LxC2azAcwW3itYoAlobM0prmHkGyQZkAA05AuQIIkcQcXBW07ZIB2g3bY8AbSANDwpz03YSA9TBpcD8zt4LLJocw9rLAzgbMHtdbOxgzgMwp9/OYIy0r8yZQi9qMDO2ALNvmTAHOO8A6PBFe23xruSG39vJUWbMACJf2MaGCGn6XGbOAjUJh2VUpYDqgaKVtcRLXtJgqdWu1deLmGRJAaJx7Ta0I10rgzIElSyn3Z6XlkbVBVoUnDW9z1P/yI/F4k7vnnFgTj+SDSArEE8gNveSULB2kqbjUzYgWhs4K0AXnALTUZi2qaj/mSxym0pLOc/cFzSJcUTJCkM9TiWvXhLl4pJ8zIp6I5U5DQmUnSlLJw5s150B3rWtmPiLFjLWv/N/F4h3tTManN2srebszJetvGICZMsgXQRw6GcEwufc5vNw2y/6QrzqF345Halvwy+yzI2kVFN7+MjBL4FORFsugX7HQBAgTOSSB5k70Pq1ds2zYIjiCZBOjDSdd6eOiTWrE2gEtQGgE3OuksxVpOsgrwyYDxSc6aDihb/92/hf7/k/uGye8Z6PfRw4+8BM3ok972DO1Egn2qzALDMAA2ZsrK6vXbbWT7ZzzoHtfq3+TJbMuQke9S/+Fc4+OAsA8Oi7PQSPfs3TrHCC1wLuAsINEgLWRQp4Bs8zaDOB5wm8qdpnAs9Aa4K5CQorc6YA6DXAa0DWEDkCy5HmpIpFb0dUeGbOvADmHhjmAJ1FfTw6uAIqmm2CJUgDtZAu5xgALb0MZ4rYzsw52DNGcI708vS6+4dT4Bc6MIdJmwkzO3tWcGYDaZ6hOcJN/bZqBaY47pb+6pyZbAwUmNnTTspfF+p+TEJ/1vbcicliIMWisgWFJAVSaZWt7lJ1dt1rVdugCdbspL0NwOyArACtypQkYDbfci1A1TkYZV5tbGvqsRMCl4A65sBrUKopS7ZGuhcT0UU7dLlKYK1jFBoLARwB1P3OBGXNMNYcZvYkG6jImJ0xuMBoVHzhwJxe270XNuXcY2mrqLkls+ZUYW+Ij8liUpDkHR+DoUtg/kSAdhewX8eY8wGcOVPCEp2kVm0WM4AJZD5pslIBZLnQun/e+efjjW//Q5RS8JVfe3887FseHsy5R23vANIAL0lbB2np2pwDcl87DceDswOy7WdgjuTA9KDj/QVzDrqTjG05GjqEgpnbMS8+T4AcwFyUChZR4TCYPktazakCB5P2wwk4qHjbJR8AVivQ2Qdh7lZwtp4X9vWKC6Yty0zABqCZgPXistZ90YghPi4jlV9vIAW6WYwJP/LrL8D/759/PYgIz/2tFwKbljR7P7j+jZoXRSFRGqTNkLaBbCbw2sDZFr1oM1BmMYBuIG6gNhtz3gCygcgaLJr3XGRtzNkCwsTN2jkorCdXdZM20CO2ZYsXEEw+kgU/kgJIJiZS9DvVZGSplOpkS9zvZUGRzJo53d4tUBaEKbpHZXcG3LiDcwdoCvM2587aB2AmRBS04aDNQZ2XEkAstqCUDMBMxQEZQ5rs0n3pTLosTNxutau23wFaFGSI7b5kWaU3RkSZNqe/0cUoDKBDfHTmLAbOlMEZfmOzu0rtiiJrQFaQXuy9a2gD61TABW0gtFH2LJrqpwCtPmd4VgH59x2g4yaNsalWs75nb2Sl3OVT2newzqmZYXh0xuwPyHtLD8zrNQBDQnuWBf6APzlE95PeznBwJhyg+46B0afcDJC1AxuUYM2Utje5yWeolgzgZhdeaNANjEC8AFDKW4QQ0P2F3yNeOyDnbf6dxdaZco648fwPtxcGo3a6YIPbS/IEkmXTNtDFqZvb0zllrdMHd+Qkl9COI/jcwJlWpIz5oAKHFXS4MnDWLTlgG6vupu2FBu3SvgEyky5pu1GAlolAa+pgQV0AR9ClX19GC1eYAPRcHdXA33fx+/Hpj/h84EQBDgvoxGSnQZ1ws6j+UrUUI5GD8wbSVpBNhWwqeF3B6wJe64pUbRbQLCitoThAswI0eBPpWSxrFKvopBeqwo9lTny5780JmLtZezQY+ANUnJFguEhAVpNCI24OdV0viEy63wbUQzAYxlsd+0kfiiAudvygtLXgLwfpLYAmtFbQuIOz2N9x+JupTwH4NeqPq5lb+nOP/TwWkOg8glypeduinpkGXOjBVAqoyqKdILrLrMOxQ2gBrBLlyJgDoCmtLFUcoL02tfuJK7RcpgOx6M0tog77UNlmHUu8grQJqBPQdLlS9/l6dS9hhhbZsQge8qwBc7GQ5jvDcp6FltXsnD2PQWwasZ/lR+rhmE52cK9eE8Gn/rcuIroCMIKyybIcwOqDgXzwoz/g2NqTie/kGbTr9TVtToKuWTujwXll3dnt6Fcee89D9LT87l1+59v/Es/+D8/Ane9xV3zXw7/Hvgn4g+hCPwHWcjuAs6QBghHwAtT9WMccLKSodCowvIcFM3Twpi5ZA6CPA2eTQEmXj+bXs2TOVs4yfM6TCm5aFTNrG3M+rArIJwygDyfQ4aTvrwygB9N2UlrCxyQ90m9jCvwkJpTQATmZrftaP3aN7NdqNyoLZ41ESr8jdpvm4TaJ2DyfTBgWhUOSGcITpG3AmwraVNC6gNcFLZGKMjPazKCZlTm3nKKl+dPFuvr89KJzQFjPb2ZLzxoDwRqAH/u1X8PtvvguePqjvgP/47Wvsfvh45cCSP35RjRvAmgQRYxOnQqe+YP/Eze5yc3w7Od/Hd71txfBS2ZyClbKSkFOOWfDC2bSlRTNHehA7Qy4GUi3AGpC4xLArEtxOmMuI3MG9WsrxqRtiqBY1bQtCt+Bmlh7r4SiY6ZPC7PMSAZoikDp5AzqUdqwiG3SyG6KOd7vC9BhuadeGTAvABrkihKZYlxs/nUwDHAWCVsKoONMqlp3UCdbg7yqa4BKWnUsLcYCDfLS4jsK0uzZA1aIJLtcNHithTneU7/ymArL4bC+uwU45CDWrRVRCkZZ6nIps+ZqoJzN4n7jDKRdQY86EQbmx6ZYLYXh//12RoOzA69ATdce7NWBONfIoa3/86sXPPv52OAFVu6zAq7vUi5GIv05UX89kNfE5MYBRbu3xyF9JIhmCkKdNeeFxYe/dfbpAO0DtvZj+rVkW08oFzJu8/kW6sDsK8tUxPrHtCpatP6gKks+rArIJ1bAiUkZqZm56cB80znRllKOs0fMODivRdOgJoRpWfWRXtQxx9b4En+BrrLYZ04KgAs9SvcBiQqKRnpP7lNrEKyUOXNVgTdXY8/Kmou6+BJ7ZlBrKI1B6oxW4WddwdkXHJj7Z2Y+ZzS00xQgOf+Wt8SXfs39AQDf+9wfwe+87jXxbAl6af5CH6mHOFLIPk5jWUjwJXf7BnzOre8KAHjYN/8YnvQf75UCwFJtaGwDNLODs6ZCibk0JQd18biv4GwMmQkt9guaGChLMfN46eBMCaB9WsR28dzFCs1k68lWR3ddMgBO7DmYNCUmTX2qCDo4Y1SH+2k5KCPAWVe4MlWDfLtUnmgEaE9pTPEjwkpRBKzjs5oSWCZwqZBSwVT1+RXqUfvW9aKbWYdmVUCtMh6TV6yzFD+z3+iIzBXfkbauQPW7IhYy131TO5YsC7B2UF/cxcyawVDzmt3xLRlrc9oDROMwbiJJ8iEqiI1P7B8H0HLVX9nRznBwVoDWWzxGXo/LhmdDthvB/dtd/81x2r0R4uYmQO4DBLu3Jb0ORS6DNfqAG9izI32iAA7MTOilJTNoA0MwYmagzqSR9/3nllpjBmaMvRCIukkbKWBIA8IKsCKN1nbwPawKyCcm0FkK0Mqgq4F4MfZMwZz91goDtgYEZOPA7EpBD4Yh89lBxn19DX0d98auzQsWtKUiRf2Z+b0U6PcmgTg4E5tZe+rg3ApkY31NYHPLqfVawDNrDWV1ogJm3gY3A2dbSciqkWEBwV6409YHSiZt1WE+8N734h8+8hHc8MY3xut/7dfA6SLUgNeBOttKklEvdV0r6c/e/kas1yexWp3Am/7gF5HtEn3YefSxdGzLpmtGFFrznOVY93oAaWXLnAFaiu2X2FdTti1sGOBcBkW343MC5tiaW4iNZbJouUwWkOV2kSuGBamKro1PGyfEJlM8eNEBevjXFaEuUiQpR7mAsKc9Ld/T8emKQR+nbsZ1kNLrUauOyggtEjJpL7rwBlPpdeBNwfJKZQ12rBSxo+O8l6/VwMTZeqpch15Wto8jKyySgkEkFV8XD1z1tIBcim5ITMuCKMkoH/2eBUPzApBdpvnc39Wy8KQd31+Sp0+kXQfBGQGly1zlDLZlR1exlOF8iUYEGp4HUcopDGBe9C1AlsUWi7F2GnBemrMj8MskoAsb33cp6/QlZLNdR+RE50FmQO1R5e73icFf4zzJBUKs1GQfW+QlRSpVAVYKzm7GDoA+MQFnVQXnwxpm8ABn1xtEbNVMgWwYtNGVbpSxuxnP6I0XbQhBq9swW4pBSVsI6gBov+0SSo0AkZYiLKCVQGYBVTZTYoOggjArOHNR5jwTeFNAGwKtoex5BnjWtZ7brIVOiBnNKpAJN1QDaLH1fHtOmLGfJP7SWlWjr5kZ9zj/AlAlNOEYSmRiNkBYXFR0IFvmRnu79NKP4Ju//foohwVcOEkLgoiM3pXwIWtvucCaA/OsW2kGyim4y83VCsQGwKyhVh2YFZQ5wrB8XeTEoKkP+1GQu8ZnW84OcOpuDt86MBdo1gBBv5dzcKkoqzaLFkkH6y6b+pTrhGwbmPvEdZXH931E9ns/KpISIK02jMmCzxqEKoQamGaUAObUQf2S7F4JGJXG5FNXFFl0VSqtdte6u0XYlDNX0CSC/TRoz8qW+pqiUQPWV8bwRPoFQA9LmWW5Zfcrgt5aAuYY+HG7dLtQujPJEvtcBsE53vOtdk3A+joJzoAb57rAWaJgNjDVxeveHaA/+3NvhR9/6bPwxjf8b/zgU34Scdg00Yk03aFrrQYaw89KD16IRSIEO/QAjCOJEIma4cAz9ZZMoPik3AnS6e+GwYfTjJE8qO0iqMZpkUsYi8Z0k7ICtKZ4YCog6wHOBw7EE+hEBZ01AScq6EQFDo05rxTYwy1u5ysaugvZMGTNoMlWvokAmGTG411buw/FADulmwz3yydpPAfq9957E4tOd+bcANK62uR1k1uBzATZaHS5mEmbNgbOsy1uYOyZ2BZEEKWWIk3NrWgIB21wkZGZZMa8NCk3diUjjysMQOpDopuAaURuUw59eMssoBUF8dTxTnB/frhw3aecgLnnKC+AOkde+9YBeQBjBWetx2WATBYLHSs86dbdEtnFJJFBIXj59z0LF9zkM/BNT3kULrviUjNvM6QV29pYiVgE7Rool4B5AOkCX8VC2LiuBank9C6KeBS75YNCJGmr43NcXAexlUFWiI0Rt41Ue10RJWbR4PHkhK7cNIy+cP+FCgVoL17SwdkiHqRpHXBpmGWsVBfAHMF/FhfAFOAsXNTSFMFfVt8TEyArBWzp6V5baQFZwXbWnOtHODDn9Mkwaadt3Hb7nqRtvr3RlmC8B+fTtjyEdFti27047uMYt0jb7CV62X/5SdzmdrfGF9/9DnjFy/4r3vPeD9qvuSDPoMwJtGwb1bPQgTlX08qrOQUoIL1YsGab+Krdm/SL37bzYBPNDjgukJwpLAdnNBnH2BgZBKCoUHFwJnsdcReed0la0MABeqXFSMhyngegPlFBJwpwooAOSHPhJhgr9vli7Hc2cJ4apFqENJmp122lXoS5MaQpM5WmEdJSeQTowbyZAdofr3QhkIF5Eosqd3AusPXsOitotk6v5WPLhqDZUmLsmUFNwGZGbW7vFV25SKtDNZD0Ee0Vo3YvERn8IXgWI4uB/mDJEWLXoxfX9aSbZkXUn8q6zWlnyq4o2Ebsi0AYuNftH4THPeT5eOtf/R7+/X/6ZgXoGcGamwO1gzQTpBlbjghsBWYRTUxim6tMNYCZM0BbRK94ZLDNMwVpnSffdp8H4KH3fSAA4CXf/1w8+Iceg2RbNwWLEfVDkwtT56qCrpACsxBFUJXXy3bgFun+737rO9A6yPo7MfQEapHwOZDcND2eoitQ+jnlo5jcsPW/pQUokxVEUWBOJvk0UsSUAq2EZuMwxqaumuVsWQMTLTiRDZxZBpeGWNldqZ6rXNVPnn3NZnbvzHkFNAfnCWCtFx7mcUGM+p74nMzZDsx9YPcewGz3kOxYEaGd5IHLw3g5CMpj9pfN/3jpPrx67YwG54Yene3VY33fNUQOjds1yd6dTefwjb/6i7/BbW53a7TW8OEPXw7QAfxBE7mm6n5HNgZtOX4ByGR+Wd9iG6wzQAMYwZn6OOlOIRUeOdl+6MajfEUbTp9JCuMPjXA5IBeDcoiw1O8HMBtYR2qHFRTwHEyq1UC6KlA7OB8U0GEFHRbgkECHCZwnsUs3YcQMmTswS/EUD2OWnMC5NWBuCuazsexJwVBaV6QIo096CATxy3fTZDZ1OnO2NDKxqNBeA7z0KmYDQAMyi+7buXBjFLbrYzUJkpnmHZgpYLZHvw7rNgNwI+a2sPdnC3h6oX+eXmzH/nEvYJGBmfKiI8Y4yL6vMQL6nhcFecw3/yhufMPz8BV3+Ubc6Kzz8OGPXWIATQsm7X5nT43qrFmcMds8ZWeCVME0aRqQvYat0iTDWuFQS0xYtARv/+B7TTkDLnrPOzQwkYuOpea2+ALMgoOywtn1AFd8/DItfFNgwJ96M1BuBWygzWwuBAHYortZPGJeWXyoWgSIcBAMgWwFlAdYCwDuked6ryWUabFVmdTXXAAuYNZ94gbmaoqXBtaREFqP7At9tcDXjWZ4udKwUEHsfG1pS5EOzEVBuQl1XcctIn6vils6XN5WiGiAWhRLkBXAxp7bgj07SYkb43ItC9HFwB6iuncAc4i8DN75fQP88Ecst8v9Xc3v4TVvZzQ4exERjW/1JfpK6hUNfaIzpi2A7lGDOqsf8eAn4xUvfS3+9E//GldeyR2c/SZHRKODcjMm6Vq7g7H04g0FPcLZt4S+JR8R44RR6WtC383axhL1XLyASALhYqA1LLBhTey/ZeTjIOa9uSdf/56MZpG9IO+++k21lXBqDZAutYCmmti09QMCDgjk9VdXfp/YlFg2cHZgttVvYBHMPGvxj7lFx4aBVQLoqmZwKqzCyyYnwQXZAqCr3wpBWCoaqdLQkqLlzNnvjYGzWLpQLzUKaNC1mD6h1oDowiZ4dcvGD/uz6DCcAVngMoqGJyZbgoPs8hbKXtrvYJz2G1CaoBQNkKJCFm+hv8CCIbslhpAF3v2vt74OD/qK78DHL/8I/v6jl5jVwIGZApjb7Kw5+Z0dmKWX9lAQnow1W2CT6DyGC3sqQFWGplss5hrjove/C5/z2G/ATa5/A/zhu/4UOFypf98Ys3ADNcHNL7gp/uxlb0QtFY//0SfhFb/yC2rgKKZ0lcSWyYC5kflxzYfL/R57apQDgK77zV2tFnRzsOdti4wYFHEUSGMI3dcupjg5eJnz3xUeCJuipSy0BdA5MOtYKSK9EpqrdM7ek/2GpZuxXXeNeuiMDsqFFJRnu2dhoTTAjVqxXoLOTdorUJs0L9sWDyf24LIki12+JV4zAvKy+/dHOac31v52AG4/6K79vL2qdh0E57XdME9A2UQvBtYO0ArMI0DvAmp9eG94/Z+AQVD0kNB6x4eck93JgDoJhFoMnGmosNS/A0SgWACmT7CiICxQkHB/V+GRPTtIO5sMYPYa2ZS0Pvu9CK7YoW268pFEvTJmnQDBmAOY9TMFaN2WsgDnSijhj1b/Mq1I3UwrACsLuJrs3hi7EO6MmUlTOUhmcNtAmpbMxMb6qgEr224aUJsCc1VgVgtHoJNeHydToE1KylFTZq3QEocZnE1JglkVRIWGmn8Rq2cpW+6PJgccubkyTJbGVLLR03s2h7rQGNWoHm/hJmaB+xO7EOkmayzM1yNIF3ZQFpTZrUX+08aorVCJ/qKzGWVzP/rSx+BHX/JYnNrMEDdnh1kbnT0vqn0xOzD3+ajgnKKNy2TAPIVSLbaUlpTSgTkqyElyNTHe/Q+X4N3/8CEtjhP1R90tUiCNcc873gNTVbF4/y+7H372N16lz5LcbO4gXBIgF70WIvPl6lRy5pudDtk83NyBIWKmfOnmfWPHnpyhRFFM0bSpLaImY5dBAc56Pdz6vo7PxEDdT27AzKKrapFJQbKYAwdDEZWBEfjFooqIKEtW9kx9cZJCYLNosMcEhEJbIGz1DYYVVipIJqtiNhlAV7VoSEmGLicnFCOzA/Kkz1uqfq9Y0ABVm7ce8OqNx4kVPMllZ2bPuSNtr6pdB8F5AyCDs9VYGgB6NnDuAD0ZQI8g3UtcLtgmgK6pdcZKZYZQSaurQMs6OkuOAh2UUvlkh4nbfoJsZPjg08VezUztAO0mbTfnmFlOTFnAbAMx0RpK5y+WNxjpVNmGsw0MfRwmIQ+LgCfzW5Ev7l5Q0rYEWCuIF/NNl0oxF2kSW/FIIk1KCxkYOJspm6CFOpg3oHkDnjfAwQzZzODNDKwNmCfvDFjw2ADQzkoNFIdFBwTokbvobNnKeJKDc1JOfGLHOsDxt9RztL3ISUP8blSl2nXP87Mg+5vFo3LrRX9F8WzELR5i52hg3McW7SAWBswOytaJPOeWQ5EoZXuI5XsnDMytKTDbCmLBnhNz3hWprYtCpDgRSh0rBWmbu8BkZm0tqqHAXIYlLjWIT8y6ZZYmco3J5gobQBvt+8+//1o89D7fiPM/7TPwfS9+BuRgGs3Zcwmw4aL7jcx61Ow+sxliDMh04Qwb1zYOm5ACtCT2GcDngXIAV1J3iJ2qDjVT2ar+BsiTrgxwmVA8oHJWpYOb+9RJwc58wpWh3zeAjjLVDs42N9wfLTCTdYEBNOmSpY3QIj3LmLMpLmJyVRyY477r8yN3UWgJOhCrdQStKkC7UmF55YioCwPOIQ5IgzU/97NvgZf8yGPxW//j9/GM5/60zdWq47TUhJc+sWxy5eyWAaDT/jUG6HbVX9nRzmhwPoXIxgvmvDZg1l4XAD2hBUCvgkUja+LuwyDPU1SNMfuXaREdOoBtFdUIPfVnSiA9UQfuiNyW8Vn7OIkiGejgHEn3DsYF4RTD3Fm3H5DRWbHY3w4rVOXWgSF/MsJyMudGmZde6qUggzOlLUC+Ld7For1FTc/GcsSqbwk3M2XrSjnCM6htwKsNYF1WG2CawdMMTDNg/mnUBqrNzOQeGyBhns0APficPQJeTNlysA7LhT2LnLKBBIACZSju9UjgF4xcnHH24in5daTYhAZvzFV65C8kZ+Q7KGeLiJ9XBAgkxkzdImh2VR1Wxoip92LeUGVarPem6lzIY9bjD/14D/3678NDHvhYvOo3XoL/9LKnqFnT8DDnO+ccZzdpi3iwl4FymSCWbiOyUqENCyIyRg2qwZz76keefqcKWiwR5iuvuTtCioGVVnBrjXHfZ/xrlFlQNkA9XCk7NQbIhVCKA3JfdSq7gDRwTCw2VBXsAOfIW1e/bwSFOzizdwdo6aDs+hUMLLlPd3Hl3hgxN1MWZtEV1maxJVeLpig2QrUFRAqTGRe8qAqCjObpAng0RE+V0uXQKeJVW6PBsuCMuQOzjcuiAE0e0IeC//CN34B/9zVfhRe+7n/gGb/4m8quuShYO+O38ahjXqBVxszdVyzYQBp+7WVPwW1ufSHu8cW3w8v+86/jgx/8kAtqRBolXMF2+WcDegDhNK9ibYM9OF9lO0IPBOtm7ZIYtAKz9imxZwfmVdLEXXtbmn0BZ55koftiOXVkpi4loya4ikUJV1EGNyWBMZjcEGbcEZxdGBb0lVfMhBMLtSa2LAbQbqryZYcI6FGKjKGM56AFWtsaY32gpoxNjPniVhBVOjjrAu5FV+8R+6Z07zfBKyLprCd0FBOrvsXQqGyGFubgOoPrBlQ3oGkDTGugbsB1g2LAzFMD6qygbGZtlIXP2X/XTcoDg0U8CxJBXgCZzJxNAzjDFDi73yB4iWM3cYdT0R+zZABOWxqrQcUShklhi580Rkw7nosLE0mvh9xb60EyCOFnzqBM5MUwKILVXPpKY3NjpFxd6dcqTHjktz4VBweH+LcP+X78xE89NVi0M2cZgNlZc89f7mlSbuI2IBads7C56xWl3LSN7HOeYPPPYg+quXtKgVi0isgMckrK5gppAqnWCyBVWSCRgjKXgmbWos6aLRXTHpI0Cu8qsZW7FdW0+1IZFsCaWHPjqgFWrIuldPZJvVyqq5f2WLyMbQ84NvlhsQ8c8Q8WOd0wrOxVmoOzr7zV3R8+VsTdFuIKgprcI6/ARA83hA8+3AD9TnRgNjlFTEFyiAg/8C3fgINpwpO++QF4xs//tkVpG4jb2JVkcVJ3mwVouknHvvdX7/kAbnPrCzG3ho9eehmGdaN9vrObtPtbgCvedqwA5ExMri5A+0Gvg+B8Cj1C24PCjgPoJXNWYM7g3BeICEFHgAt0MXOJlolzYMbCRO2aejWAzpo8YfiZnHIdz3kUdKhsKR3UpalHKfpAdFbt+xmYA/i6ySgGW2yBPLgoDThKg7LrEAbQor2Ip2rUBTCXoWZINRahmrloZLL5jgievWtpUgbMTNqpzArMdQNY930F7RmlzuDEmJ0p6Zq3YauDm7YdpDt79suWYJYUz5YSQIuZtQHPEw2YdAbdfy5NY0lTu4OwGl/09RYpR5e1QZtNsRJTDDRFxkE5F9RZ7Cdg1uBCO5z7mD1gjlwRtZvArH/HrBaBsPYYe/Zb5/jDgj//yz/CF93+n+Od73qbrooZoAALtLc0G+9W+Suv8yQGus6glTkbg8YKIAVnoUnNlFbOUgqSaZutN4gFLEaxCnRBrs7Toq6Qxrq4iafY1h7YxKWEG8cBGgbO8CAxUzsLENYHeD41rNgMzRGl7W7h2fHUgZkEXMRA2UA6GKtY5Unpl+HjN1sxjJbzzMBcVHQ1NvZsz8NcEZ7koeOWApyRtgqJKTLCgsJCdzPFhNGB2ZXFXhnM4zj02TswCxHe8lfvwZfc9tZ467veB2oplkNgKWM60sUUY5d73RfdZ9vXP/IH8dVfdke85U//HKc2G/SFddxs1MctYMo429+73Mvlj93iSOlzZNm5C6D9qcw7Prvq9v8MOC8B2sHZmXP3O3ffs4KyJcBbxCChBiPyMSDkCf4NLiB9AQAvSEKlMz9PK5JJJ3wAsy8+HdXpZDRtJzNSpHa4IARgannfDlGXZEqhdHO2s2b/QV+M2GFiETQ0dgNloKNDmLto6IXL0Ktp4rUZKDegsKA20drSja3GtKexaKSQFCvGgVmrESWAbtiAyKp6FO1S+z4XBfFSGriYXdmkTRSMwY50Kjc5B3u22yL5es2UJtIDxIg6003adwRdBa813pDAtxTpGXcksY5Bji+MQ4Y/Ef4GhNQqIVAXAqCskwaANgWKDJh9yzDmbcMqlTIlezPnWYfU9SU0Q1GEmWmTfmN/8ojv+Beo9RCXnzw1sjXPe/UobQt+Eg9Mci5OxpwNpMFmvk5zVvK8pTEoDOYuiXrok1pTUOZ4CNk3L9nvPCtrdnnMlo3A1IGZzE/a0lKH3R4Uag0iJYlVUbz+Dc7Cw7/vIfjd3/w9/OHv/RFYSBMxgjkLGrMycha0uadasd9nu8fjsp1iI62PWZgOH272WRScZ7K0PlIvV+vAzFbtjLiDogJWn/7w8ygw9jz8ZNjDBN1GlhWhWJ+5dpB2HfJe3/VUHB5cD6fWAsKq/64zeUi4glFszBWdEz5Devwr4XVv+gOgbRJrdrkW6pPuc574pfdhAaEE0Fuychcwx4SFyt9r3s5wcFadJOc4z+jBYJ05e/R2j9p2xhyTHJMBcF5UEjHMgjYMwVYMoSmAmUpTIVIbYt1SN2uv6Bj27PTKhr7YbHXNOPx7BJ1xCZhdQ47xYqO42CyOFVuSSTvR9ec8+9twxy+6Fb71234SF1/8cQsgKqac+AA1oHFwygBkky3MYq13tS4T6mygPAvqLCgzo8wMmpv2qQHzrCyXLFWqGDjLjCYzWDYgKEDrMna63qz2GbBUKyoqichT3LLjN7xlS9YMbLNnpMhthO+NRJ8JiTNoAzqSxVT10KzEoOyYYWQpiNQVHwYl/T0AYxZmfdvBwQVq9svrrXFeDxdJGevOSVPeTDA1wEVrZFRbAQuKpNWmoFrGw2jj7rZ34GDBST4KYI56K2bO7tUzzVQqWZj3wiIiFWBLlRLNiw0GnSO/aILnnqv2A2RLlsaAaOQwuYLh9zL88EXBuYrmpheoidyijqnU2PaVk6Z+nxM4l+GVucO44fm/9hzc+vNvgW96+Nfhbrf4ahwdXRFTvbF5o5tVgiMBo2iwlY9aWURwGzDrs9Dx6+lGPv1h6X08i66H3nSryR1koSjqXigW0d1jE9KDtq2IyhlxUZSZNI3gHONOek2AntmQn1OXYUftSIE5YmU6YxEfth5DUnVSqu9Zz8sXoFKFs09pnVJLgE5z3hfNznMn5k9Ffs6gNJ+OZc7p2Ba6fE3bGQ7OulZzrwTbg8OcRY/AXBfAnB3BHaDdf9RFIcfE1wcPHQjGzoQqiBqkqOnMKxZRyr3sP0PKoLNp25kz0Jlvg80uG0jC2HLwRLAYencmRAtw9ih0i9i+x90+H9/3vV8HAHjlL3w37vUv/j/0gavfIwesYOfFmICn4EiYwjwgtqrr17oC8rQRlA2jbhhlwyibhjLNoKmBqi/WbsBcZ3Ax1iwaBNY8F0erekAHuy2rSFqQv9gxmLRYf2fMZsb2wL400eN+e6CWCZ4g0a6DmYYd07D0R+YcLAgAOWwqAC908UEWVUl5ApIrvEv8L6yAMvqOXfwvq92Z5cdee1xAMJdI/TJghBXGoF7qRMG2WXBWc0eiWjXsMGGwges2bMcUjbg2gO7VSZUtsYFBL+uIxJpTnexsEh2AOZd9NCbtiyb4CkYOvrFACnfWP6UH4fPYfZlsZh6rq+0lO11RYOqRxVq/ugeQuFJRpIROXTxKWxhaL30eLCANB5hl3cPErEa1MmdGa15EiSP/eUixSp6triihPxTuPRj0DKARaNZgMWXPxfKfNSjPc6GRxxvIEa+zZ1cGuIOzvyvxPR39kUXgg8drCqRJoZkujCFt1SOyvbmeYK4qsWqJsW8Fh4gkDIzRWwLRnOngiO9+a87A7Gle2SVYEdr7VnDYce06yJyP4NXBRvbsIN23xYqRjEEngZg0GczrpPPlJJkQATKuhpFrqaSgHKkAxSMPSQE6peB0gKYUGCYdnIsd0zdMCbDdRoVx0jU7ToN+N0C+m3Ajr2/Q+lTyvP/9HwQzo5SCv3jHewGs43skhj6oQ5Rv+InNh1a4gJpo0Qpjx8qQ3TWswFzXgrpi1FVDnRpKnVGqpqMRdbAVniHTJsC5yQbEM2ieocss6koSugZy6rZiDkFZM1mJTx8ZT3zI4/Gkf/kEvOUv34J//m33AmBpVAv2HNGpZqRw9kwJvDOL7nFhZiSN1wgDhsn4UYeiraeiIj4UQoqhoKdmbCPBfC9Hq71YqUuy124FGv5GzMzoAO0Rv4k1a3R8gQiD2aq/cVMGbwTTWZICi4KrFtKgAOgIjeBjeigIlDwI3aQNA2qwKbtWzjMWREBa1WjUdHUekZjA5cSmEZZKMwopPgdT7A9NTLsKcIYyZaKu0EcgqVQDZwuCZKS4CnfuVnzrg56Jxzz+6/A7r/sDXHZKIFhp6hQEzL6wSQs51cRLmbIVJ0nKjqVtboOzdM3JgZkRAWInDs/GyaOjAGhqFICsoGwsNwVhdRDqIsr3BNBAwIDn3LJSb/u1zykpxn5Fi/GQuIuwaUyFx/XExPQHptYdIh1gurylKePsAO3gLeP5BKPPFgGbW1wSGJvC5+NrsD7W/jfHMud8N8qOz666ndHgrMwZzm0Ns2gB1MXey8AcTl+LtKyL3s3axaYwm7ZVIODIp9OZLpRSApw15/znLk9sXieQTkUFANikyu+Z/coCchSQF2w5KFdCEFcowi/mJhrt73v/B/A5t30oPvuzPhO/9dtvQZixYYCeTb0RTKTCkmxxCWqMwgxyc7ZamFE2hLoBprWgrgTT1IG5VgNnA2YidURo5S8rMFJ07VjCxkB5BmarCtZmVAdono3l+bbXpu4jQvCor30kVtMKd73dXXHW4SFOrU+iQx8CoCOv0299BmKbzJ0td6IWpu3FYyGBV/yEV5esZl0IYCYz/wNWTYpMAXT/qwJdF3RkrLYa2HaApnDNTMMYz88dSKwVMEhWWNblKqsG1cmsjJ31JDNr7h6VtJazcGfNIhiLaDibBmIhBAMbCBAmULJ7Xiyyly0Vh80v7FYDT4Hy65IsONNEoiTQw+VTzcGfPkfT++pWJzeBWMQ4U0WBVSrDwqRurN5rrLPQyJrZVhqTDT52+QY/+ORXQXgNDUa1JU3EalazW/fsXwZmZ81lCcyqCXYIIucOFqBnD6wBb/utP8Zn3fyW+K3/8Tv4hoc+1AC5gloBuMZrBWa7v9J983788G3bPRS32A1zyr6d2aXfchMvCsysgXi+AEwtYS0Sc72QW1AC/3pMhEbc29znBmkeEGqR94M2ne6RtxhDJiN7EQYMVlUX4CHMl+w5H3dUUa6T4LyG1XaAA3QXyQ7QeSEM92v5jV0uJVm20E4FUPF9A+Nix4wqXJFS1fdHE5sNtiWZ2TJr+6CH/idOvRixsHrU8EZSBJeg7MqDUWuq6HVoe3/3u9+Dd7/7vePJmLMq6jvH2HaALuilAD24S01lZVa2XCbSOK21oE6MWhlTZdQyKziXGYU2KAbAmmuzgbQNeDJwLjPIzdgOzpsZMmvZztJmCDewrYtMttyisxWPBAcYL37NT+EJD3kC/uSdf4KjUydBWYAcB8wARvmezNoGyOFHLpIfdejUUUa9hLxQ37wDNZkbAPa3TVWkwCkyYEu0LxbagK00RFUBlSaQqPVHQqg4UDuIawoPmQmdWYGZIFbj24GkW4AoXZSbsxv1JSudPXfTq8XYRTGNJSgbaIjdVXFHA7pJ25QRsZvQFz2g9NoE6jIoMrorl/4AXfiKKtNFX4tim85yBxumAZyBEZQFmm8tVs3Klw1lVuas1lZTYKsneJu8sBxoMfbnK3Oz1MjvZmnI61eLWFEP7n5/LSMKu54kFCXdM6YBpD/r5rcEEeEeX/wlYDdnNwdkLf6h7qyStjaaBWHRST+k3S0OCaApvtPBmeJEe0lQYyOq5lGLa+yXYsAcUd0Sf+Mh5wrQKg+oNEiqoqjFh5LJa5jhNCp4Pm/YwHkZ25AyeraF8CA50m8t37/67YwH55rSF/SR9TCMEayThg5K/4qBr03I2Lq24764zpnYimuwf9dB2aSqR9sP6cRLphvS239q1DghouOA83fd980dlAPcvdvnwx9vA/N2V9MbxWx27d/HNdl479GcFL4sQamCsikolVAnQl0DtQpqZesNtTRMxaMANijizHgDtA1kNnCuGzTzIXuJKQVlqwo2NxSrqV1aC5AuzJ09J/vps/7zM/HMl/4Q5Ch5/ZLgDkGSlOvub+6v8/DwIipuLPF9orFUC7k+5dsm9jcUf1uKsWkDffLlCNuo9CkQmamVNY1NRBeDcGCGuWcgPa6CfAUnccuRzhOCRggTGI1GYeem9KgCW6x8IwRM1ZPeorOQmWFVRn/TQx6Or3ngg/G0J/97/MmfvrWbZGXR4y5Tl3PFWDUbAHmKoAWTjZPaJhmnLv5++lxM8bQnM4Ax6cwWU5Ip5r/7uPW+sq2cRLKCL28oPOkzsEwF9jAPU1ypzPBoco187rYKga8c5YVJmoI8FXMVGDAHY7ZOxp7tfkmYHKjLELtf/d4U/KeX/BQe/HUPxA/96I9DjC0LTx2cJW0DnHUAaBGcEXyy1AWL5nNzfl+Cc+gx+t9m2SRBcPx6vEsPDnRlxGUl2SpuPmY5A7RmfqTcMKQfH8dFdeXDANoD/ciXsuwBw8GgByvkLnBeMudPrF1jvv27v/u7eMADHoALLrgARIRXv/rVw+cigqc+9am44IILcNZZZ+HLvuzL8Od//ufDd46OjvCd3/mduMlNboJzzjkHX/u1X4u//du/vcYnv4Z6K717tUTful6WRTClPsAT9bIa2WMXrAZArgOUt9FNvsQETwJ92M+huXkbVMu36K93FnJ303WO+LBOdlco3aHYXw+dhruYel9aqbNYmwTUei+z+YXnGbSZUdYblCPt9WiDemqDetK3a0wn15hO2ntX6ut65Rr1yk3fnlqjnlyjnLJuxyvrWfsm/aaBNHHrjCWt9oQwM6aOfJtloapYVALt6AlQS0HU7S+e0TOJ9lXaWlpuWfYJqNbLRMPrWknfq7lbzfJYYMR6qaCiJ0GkPyZ0ANABhFYQHEBwAMYhGAdgOQSLbw/R+BCND9D4ADMfYG4HmNtK+zz1vqloc8U8l+htLmibYqtOaQcXPP2HfxJ3vds98bJX/EpPp9rpd94G7AhhdvT2RR9GspW69L/JMRleNnUJ5LKY/W7OLBUoE6ROkLrSPq0g00F0Xp2ATCfA0yHadAI8nUCrJ9B8672cwFwPMZdDzOUAMx1gplVsG1ZRd6FJRRNdpKL56lxs9brn0u/fjGFJUmx0eup0JVuilOwz0qKBG9ISnjPh8U9+Ci78gi/CT73s5yGtgrlCuIJNyWBeQWQFFt8egOUAIjp2fByJHADi2xUgB6qw8EqVRGPhxfzYmlZJPT6vAbUJKrN2adGLJOWd1mphK2vtdYNS1yjTGjStQdOm99UGWM0gq7FPq2Y193WVOk2rE2wLdrdo1EV307bnwC77gXayLQ77e8O+92verjFzvuKKK/CFX/iF+PZv/3Z8wzd8w9bnz3nOc/BjP/ZjePnLX47P+ZzPwTOe8Qzc5z73wTvf+U5c//rXBwA89rGPxWte8xr80i/9Es4991x87/d+L77ma74GF110EWq9+pFts88zdJ9L3/ZasP6OfrUnoriJhFLn8FGgs9Ph6IK+vHnfxufUfz/aUnOL9/Pn6Wfy+/46ukcq8eL8srnHhU7W7pammPRa0jFhoOamoGQRIqbI6IriFbNqzGXW4LJilbRKAWoRlMIo1FCooVJDxYwiG1SZQbwBNe0yz5CVTzZzXlsktsgMbgbAm4aytr5pKBvWtZK9Wx41WW1BcsG9oGsRiY4eCOa2ESdxwG7GjCTLabLrNXK0Zd4WaMqUmRhLhafCq1yYE4MmQkmWmKiglBaqL6yRw2Q1iEl0sQCyNKNYE5dSqcvwmfXqVDrW+pjxkqmFZj0P8dMwdsleF1rQSNfQsox0K0NZYhnBWQTroyMcnjiBD37gbzXgO26/8Srpwx3Sx5pZUNWQ4cBcVOmPg3DqXlQj71vxjZ6nJKOlyhkaEcii/sT5Z1GXjeZVV72XVVdKAh8AvALXA1BdgSZdOalME6hpEChVsoI1GthEkX6pc1WIoXnaGkAi7rOGrVstvZgJ1Yq3/cEbcdPzPwMP/67vxH95za+aG5jsWGbzWbJCoLsCLHe517N2d4Ax51TLmsxUr1tj0M4q4TkEFFaGvKRkOBKtIhoxx3cBzZYgC3QlY75uERETWb1+t+h4pAqhpib9SnHaKIJCvU55rg2bmbMGhvq5eX0DYMuq4kWcMnuOHHpnzAbSQwDRkp4tmz8X3vHZVbdrDM73u9/9cL/73W/nZyKCH//xH8eTnvQkPOhBDwIA/OzP/izOO+88/MIv/AIe+chH4uMf/zhe+tKX4ud+7udw73vfGwDw8z//87jZzW6G//7f/zu+8iu/8mqfywwHwdHc4jdFhtc+KJQV+T+KrfonSpjCbYUZB+7w5TpAqyfbfXbxa5LMOX5sFzQYMbgLSPQvYDnRaHwPsPPIppQEzh4qPIA0YSxDZ++FaUa/SxZkEWhlh4No6hTSvqZTOUCbIDIfZSijNokKFJwLVDOuslENuW1Azczas9bKppXmYUnV3OVCM4o0FFZwLhsFaFozaN1AG9Y+cz+XZsEgdo4OyhSIoPfTATpAGVhYPxIwJ10nFO0JoCrw1NcwVTtAY2HajlAAioXDOkArMFPKxZWmP6YuBCso4l20GAbMFBmgbKxHRKvf6SL2WmWrp1m5BqnPWYRRrSytKwheuSzHMvQVlTRoSQ2xJQF0N23f/fa3wV3v+aX49V/9L+FzjkeRhn7ISDGQMf9lgDGpktULOe/ojVVTr1Ag9v3Zb3zexgOHm4TVdG+ACNJ7ZUtUokyAHAB1BeEDEBsw1wNQnUBVmTbZCmy9brw9bH+ecQ8naFqVPjuPBQiXg1jEOgj/4svujlve4kIAwPd953fjl1/9q5FfHI/QB2uIjOTbzT56B2k2ABrGjSkfvu/KXAYh6VALB2ZSZO3RPQUEnaua/mdygngs1+CKGDd9JtLlpgMzBzCrTOEUsyPFg3KTmSSt8S5eRz2lUvbBhm5FCRFJXWGJyZ2AWmoCaQduV1p8QI3PYZTZ/5fA+XTtPe95Dy6++GLc9773jfcODw9xr3vdC29+85vxyEc+EhdddBE2m83wnQsuuAC3u93t8OY3v3knOB8dHeHo6CheX3rppQAsdS3uR8+uA1zYLoDZNCgPQMi9RIykp8SoCbvBY8Gb/X3XFL1+TzGw7seXAaQjE3BZ+CIPGAO+4bTtuhaXYt/LPrQM0JS2PvqS/XwB0uTgLLWDsiskfs4O1DbZ9MaosCGjgzQ7cFCKhdP70YG5gcxEXmwhi9JmBebNDBg4l8nynS1nOYK9mhUumVnB+aiB1gLasK7nvJEAZu8wgJbl4hPS/WERfZ2G01Cty4F5YflCNXO2VZDUFZ0IC7I0eibcA1GgaSyzgcPsj8eFufVCuuRfKRFVG73UMXhF1IfoQtZBWj9XH6JEjIXfDkYlhoi+X6QDM1nOKKBpg76qEhsoq9plAC2WvCaEBsElF1+CV7/ql7U8JRyYR9YcyrPYjfK5EvNElUWRHWBcmrFkSquASc9p9kyI0Iq4P4QtZdcflldYM2WGJgh5qdAVUA6sr9JWq5e5YuolX8krBfog8NWwKC+yo75LsQUhPN8b5t9945v+EO//wAdx3qffBP/xeS+ImtVh+HAM9n1Jr5Ov3X3HHuFOnpbGanGRbHGRzBR7FHzkKscPZMZcoUmrPc+lSFNyXJoql4CyZ6uT0NmqP/WKKIJDBbluBBcCVYBt+V22VdMyQPecfLZiRBGqGIxZw2kIkW7gwOylOwslgC4doAdb+K7UveOYs9+sa+w9BvBJBueLL74YAHDeeecN75933nl473vfG985ODjAjW50o63v+N8v27Oe9Sw87WlP23q/mVYfrCeBiqT9DKqEppPdAFesGD07TJFV5vGBCAQ4a/DBDOl2MwRIe+6dO9EsSMIXSSdGHyQi3X8GwBDCdhcaXvjKJAZyB15KarTNTin2+5S+V/r3d5q5y/iDqSoPoCYp/djupeV+U6sG0KptxjrPDmrw0LwOsEVmBWZOzHmeQZsN2HxGNM2gOptZMIEzNwVfY8tYexd7T0Ab0VKFCZwNIRSoDR2CEC6AObR72zrQZi8BJUWaEjinEs/dtC1ALCbABsjNt0av58SYZ+p/3Dowo9mBY6GGmrbqO4TY2scyQdgZdK+opULUUrGALgyFoYuWGDCLmSHFlC9P1yKfK97H2gLOnlkouYJlcB9nc3avLpWzZJ01K5h6oQmQCd9mZTjZgNkXZYuya8lsMWQwGEAumRRUaegKkRVwcRNvrIB1MIC0lANQWYGKBdwlxbTPCRsArtzTDAQwu6nY2a2t2NRnHXjd8Fm3uTvEKuE5CIsPTrhp2++omwPSVvpvdJD2gK8OzBTjZGTQ5OfqKVWBQRzjQ+e357tQPA6CRBU8ncP2KM2UqOZ2sXM0iW0Kkq+V7fOCXeGqAKrmSIPUkuPn4uAs/h6stppzDAZiKd4mPWY2T/ylqSxAeikvU4/I39yyAnj1XbW5/ZNEa/uCAN5EZOu9ZTvdd574xCficY97XLy+9NJLcbOb3WyxCFOf8oAnT/FWd4BW01KBV+7RKdt5NBHZc1P4dkeWeMiZ+TlkSOHJmn5nACQcIB0DI6dPAcEcRlD2vgBsWX7WJ2IH7wVoZ7AmZd2R20zFTLwFOy0OEUBl5iz2WVaVzfoiAHB7g12SWxI8tUnsvnnFr1lZMzYzsDFgXs1WC3k205Ted/KqFo2BWZkybQRYM2gtAdBaQ1ggMxScmytHCaCdRKVuls2dfQnMzqAzOC8BOpgzqBskLN90YHthwiZjCmbOnj1K1XotFmFrgNyKpfB4t8jhovtsIM1mrgwfoi2UIaL2IxWFLVUos1pdVpOdqINJ1LsOlauzZ5ZQXw2kZSuua6dhKL0TFqZe7FnHGbcOzjyborLp8jHM164Z5eEvCSA55mRK9I5UcOr+mLhf4YPFBIqa3r0LTTH+xfLdDYFsJjCi1kDqCpjGko1BSgBpVmCS3N8CZqSWXmRwDpDWZ/fKVzwPd77j7fGwh/8A/uf/eruCNPqiIrq/gkf+i7g7hOIEyBT2MGcLRUBtBFOK6JKx4gBNZq2yHm48U0ikjysxYPbejDl3i5WyZ3ebOTkK94ezaZNdYfis1FfNrdTlcPbuDSQ43ficehP7p2POwbZ2fHb12icVnM8//3wAyo5vetObxvuXXHJJsOnzzz8f6/UaH/vYxwb2fMkll+Dud7/7zuMeHh7i8PBw632xVVsi6GDY6gMrAcxqWgUaiGyhdbMlumjwYgxsxpnmkzuBswKzV6VSJtgBWkNSyZM7zQwnFrxCzTS+ouNHWpJWDtQC9EAWJILu7JmAbKKNGYt0oNOBc36dRCUpOPv9GyeQfe7Vwby4ApnvpSUTTwglZycKzl5kQIG5ae6yd89hXs2QVdO1mav5jYregP73ouA8M2RjgHwkCtDGnJVoiAptj9p1gB4AubPmPM0CqJMnwM3aAcw7AZqGwDDyeyFArKOcgFkB2XorvY6zsWRpqXPRCNumaTtcK6RVCxTzqNsKaQbMVMHmaxZfvJ57gR2BKltiwBrAHD5E40BeKtTYgwrQzpxD3ZVkX5IwKI4sehxxvRMGn6OOGzdVmkbkY8fTzOKBmTCONEPXqtKc8nGYf3V5AvYcyJPXUXqwFFvuazb/LnJfJe6ryR4AajPYlReLkDsdnPppLcE5XlN/b1pNmOdNFh7D8fSNVEBECLf7/M/DNz3oqwEAL3rek3G7O3wL3O9NHjwoK5CxZ0nrDXRVE0lGFLWGkbPl8KCjgFGlWMyJGzIkCrTkGBCxe6XMeQHKZnqO2NYKW/tdu8p/A+fw67vcMZeWxXnIsCZ7P0YQpWX3p5BFpt3X/xvtkwrOt7zlLXH++efj9a9/Pb7oi74IALBer/GmN70JP/zDPwwAuNOd7oTVaoXXv/71+OZv/mYAwIc+9CG8/e1vx3Oe85xr9HvSk3Ctd9OtB3hlUVJgPk+XuHbve2VhD3bxHGjgFp99Hk7c4BB/9if/B7D4VI8gFtlAbM1hz6+FVQSSCGIRM6HI+DqYsg2kePCS3Tmpi/lKpF+qXzYEnT2n11tanQsH8x5FQIf7n2s6aBcP2fcc+cNcAWqgLHwi3xtxjCg2IJ6PaN2qfWFuCs4GzDJZr83qOTeNyjSLhNfQlaY+ZtkIsF702cEZAdAUAO3zUro/GEl0uuzPrDntZ/ac1l3QlEiP4K7o5n0YMAvgqzsNKzV5DmdTYC5V015QOzBz6g7SAdasgC1sYF2q/o2DNXWAdooYPkADTyK7H7BAM/QeY0ZyIZ8OyrzYV5DuwBxwu8RDm3dIY2UY8DnnihsGU4ZbIOIBmtk7L34RQiLNsxDa/jN2rFRKV6zYRTBcA2h3HYT5d+gVEI9mttEvPqcWc1B0RvWbIMg6sFffCoDxmWgAcXjiBC5531/jnHPOwQ887Wl41nOf23XzzPTEnzAFSL/rr9+PK688ibPOOoH/9ltv7tYUixon96dKNWB25SNfix1VGEQU7ypT9tI4auCuKKhicQyuAErwY/TRkUeAjR+bPy22aZL6ajEW/R7uS18QQzrwdpZM4e4gUkVsy4SGtEUC7KVih/Td/HB2NjnNZ6dv1xicL7/8crzrXe+K1+95z3vwJ3/yJ7jxjW+MCy+8EI997GPxzGc+E7e+9a1x61vfGs985jNx9tln4yEPeQgA4IY3vCEe/vCH43u/93tx7rnn4sY3vjH+/+z9eeB1WVEeCj+19jm/twcGaZBJIKKCmDgL4oCKMhmnKEacomJUiCCKQEDgKogICkaMJPE6oCBDUGO4gijSRmWQKEpijBIxURNEIQgiLdL0e/Zadf+oeqpq7XPeHvi8fjSd8/bqtc/5nWHvtdeqp56a1qMe9Sh81Ed9VERvX9tHFLDhzSmiw/fo8QSF7j419wvBIxq5XrSAs3YDZxF8/KfeBT/yy08AADz5W5+Fn/zRl2KpAB0g7QA9jCEy1zaCVxYDZPXCFSx2UNTGAtbeCuOzfeVQGDNZNOYW6t0ptuy/Eb6j5kpBK5PPhUthHDmuNFH7tTUPSqo230k4aAgYA9WOoQONVb26pUeJgzP2PcB57DrGYnsxa/M0H79DOoZZHLoa8K4OyATpAyAO2hGDU/z+RrISmLechgBdY7KkvmnDojNGRGL3QgZ7Gkb4mHhBCO2WFjIiGMzSb7D6NqOrpdBgLcA8mjHmvqCTOffFwXrJ9zV/b1v8c/Y3dZ8oggl7QRmku4JbTrIwj/B9+S7wEyNmRM6MoRWo4c+TQavmbJrWsDg4SQZRhqVk0HxUb0YB5vAnh0a0mYcxref1EifZEqAXArSA5Xg5XsoiHd0UIFbT4utZS9NkiYRFK03WR+cyqScaryk1mejm47t+3MfhRje6EQDgS77o/njK9z4dF3zEYNt5vOfKq3CTy+6Kyy77QLztL/4GwBk07jXnRg16yuAnr11XZkESmCyKzK2FegKzFPV9A9DBMKgvSdGZqNaIZOCv8L77vGmmEHAsBxKYtSxu7hcNlgCN4wrMLhww5tcmH2N9jnJSlLUXugnjAn+7+sd1Buff/u3fxmd+5mfGc/qCv+ZrvgbPfvaz8ehHPxpXXnklHvKQh+Ad73gH7n73u+PlL3955DgDwDOe8Qzsdjs84AEPwJVXXol73eteePazn32dcpwBRI3c2dRCo7SLG+2ITfU0xU+mGyhYTm9gsb1UXeu8y8feLvzgH3O3D8Hyo+ehsGR523P4YExcWT7S67wOr/M6RZeOYkax84ViE5SgZQ4QmMtxzNwTIF0fERBWARoIIefgGb5moa+5juPikbq+kJT8yBcrte5RoE3ENo2CpMLj4Dx0oOnwcpvdgJng3Dv0YOBswDwwFu896ENl+HdpALSu3g4wBn1Qr0yjUY9FgjlTUdY5s4ZrWDZAvcGDCaBdHiNAWpJF+3NWCwuuwWhcMmcPchGPOFY3Z8tive7MXTBK6w7U3UG6+2vdgXoUkNZmRSxUWkT5KhyIKPgGZwXXBErv8yWYQc6MiUErqLZNDFqLaTuB3L9DZTLyxASOyB31+dYRFqGRynQynArMJ0zHlbSEDCcCNF9Xi/UBztbUgT6qZLmlwu5X+v+Fdb8DWUb+Bq+NgKv1+qi46vQ33b4HhHA7fvWrX4Nf+dVX4CM+4sPxLY/85yk7yjDGWmcrLHoMxdv+4q8APUOqo3RZZLodpt6Ov/Fh98Bn/8OPwLd+48/gz974dlfj0ozNgDCrRF6LOYl/U9n1mlYRlNzmKvJQ5mCZitwiM3ZTE6qO7gdvnkI5Xb4t4HQbCyYwPmp90xaEkjgB8macjx58Tz/xt2t+iKrqNb/tfetxxRVX4KY3vSk+9KYXYSeMECymFDQsWLDoznrssGCHpjs0WPm9VvL5VC29YWjuBmM7WgFPeu5jcKOb3Qjf+uXfhSv+5l1YW8cqHWtbsbYVffG2s37sVytB6WbasXNGuO/Q/QB2A7qzPqIOK2ADmGYpS57NOyVaBaAojSalRJpkn2poMDcTyH5cghqSLXlKlI+mwPJpGxY0WdCkYYm+YWkNu9awNMGObQF2i2K3A3bLwG5nNba5AUbbD7SdVfGR/TDWvCNrHhjLQPe2toFVhtspBlZVrEOxdkXvirUD/aAYq2IcgHEgWMN90DZGsgKtG5tuHVgKODP7hgWDWkmRYoDuUcGfcy7f9oCeSanyJ276zsj1SFHy2stWLalZ35vvge3g3N2H32m+JjDvMMaCte/Q+x5r32Hteztez/z4DH09Q+979HWP0ffQdY/Rd8b4GFDmc4PWnYiE94ET9cpxeh6299t5QK+C4jzUq8oNHKA4uJJq8RdZhnKkYgY94WsmG3evvweaEWQ1zA/MUfN842XJfvF+twC7VprY3ul7V5j2UuK3eNz8780/z7Jse2DxdCk5B+AiAOcgehEwLgLGOaCfA9Yz4HAGOeyAwwKcb8B5Aa4C5PwAzq/4nE+4DD/4qI/By171JnzTE14JHN4DHK4E1ncDvbYroePdgF4JjPcA+p4Ya2itgZh1D3O7ka3orpYDujHIgH0QdA+pE1nP+XOraiXeAAsKa+53vvWtb4o/ftO3Q0Tw337/LbjHxzwNDSwsdMBODt6fxyLW7+Q8lnbA0s5jaStaO+SOdEs3Gbgb0L1C9+p1XqzvZzbM/QxY+XwHrHu15bGoZ9KxzjvQPTtmdGBEgUOBnreG8w16fgHOL8D5HfSwA87vgMPe7+k+f5TNC89YHrjVDDBXxmyJuvpo7asAPB3vfOc7cZOb3OQEop1+/H8Srf139vCIPQCur1OHIXNmFKr1xp7TtBJRmxhQNXDu6vZI9yF9x1c/yUSQDM/bZcCMb1EYzNkaE+FlDGi3ajn0P8cuKUlNUmJFlZ/KnjdNSx+MWULDDo3ulCInfs1iKmi65UawJUjhRMGal9RKEQln4ZuMzQdCf61C2JjA8Ij1zmj2Mdy6MCDdIrB1Nwyclxmch6izZw/Y8+/TrhjDorLRvT9oKC/ix8GYfe/pypiDLLGXBOqtaTvGtK5H91HmBkkSPi6JGJrCNL0IxGA+ZZOIxB4E51HAeSQ4j76gj5ktR1sbxuqsefEyms16ks4wFIHrJSefFYpI2ATNg7yTxSl62nfs01JpZ5H59ZgLJQgqYhNQDD0lIIyfHmLalMIYLrhWFMlqNoKSwpJMuR5z38vRSuT8cL9zMaXEGpIgskJf9yqMC3XrDMIFxbX+b77t43C7W16MBz/gznjs974GV/yVF8rY1jAlT/TYjBoQl2NPBp33LB917eP4WLd/qx+X0s8tjdbW3nXFeYyhWBbBn7/pnabOM0Lb+8UL2NQdcs17naw54/2LkFP1nbmAoZYPUycaxZ3tLukM22NGTDYB3Acg0lXB4eP1tDLzBWGVcXlmGwORIVdWNE2GMv4nLDXTONd7dMB787heg7PsbDHl0BTTtvKW9DRdqk0SBgRZ5HGW0ItdWNSFh08MK78wB5Y1tTZgJm0Mz8tVBoRZzl2UkOzDWHINCquzT5AAPYFzlYZSjjkKZXFKnRCY1lsAc3wmF6G9oT7bGi+bLwL3S0a5T9+nFSb00sFAWape5GmAW+hZ9Lo16W7y78ODwAZ0pwbKy0BvirWN412Q1IG5A7oFaAaBudCUCaCR9X0LOJsQmY151byNAtCRsdaAIQnMCdLiZu+SO8tZqQ7ILMdJYB4JzDLIcEsE9qCveYfe2Ryk19oEfXFgdvxRsYhWlqpV8fFRu1PCXch8w5PqC5QADcYPII5PgzRXn5z4+8ZxQlMr52QAdF0AHHRs3HY8xwbPR8MRi9mC8haYA5xh4706QFdfR0h47yxfzIIL12zatQQfmsL56v/0Vnzp/e6Ad/71eVzx11ea0h4Fsns0DaDeAHcBaK2KUjy2z6/hdeo1Jz7Bx/Hf7BUR4N1XnsfH3uXp+NR7fDB++nmvw8KaBhx9V2ZrKMYCM2TkpqZpAq8RCuq2lhGKvIb+pT7uLB/RhsYGfeY6SWC2AidA7t3j1kEtClboO4IA5fBRrZt+y3I4EdPUP7/nQuB8/mpG/cKP6zU4x2JC8rbKoJm7WcGZeXcBFg4YgzcpbqYVZGhatb05NYvFNbJAiZkHA5QjutjpWrdgg5oyByDN2hU7T+ae1Bsu8yGBOUOEE5idwXHC8DB6wK+J4T+tjOcWpBlUR6AuGsBIQauxeDjWJmx0uA+aQXMB0IqxDOg6MBYD6N7UmoNzF6vdTNAPgPZGZVdoAXRSQlM2WfNSm1jv1ugpcYT1sSf/FfJSWeTIUj8KQJN2OzjTfwnfAlBabv04uKfuknvpsrRibkW4i+jr2d9cWPMqGAfBOKT1enAnKRlFceJFBOI4CJtjPuML/NglXRbuITAr8lsE09aP2FpQUlTx7xPDdYAOBs0JRIDmhwe/wdnOpEa1XFS6aVEVqgDzWApz7mYiX0dhz1qUXT8fV6oZkCjrcPeSg3NXYLU9hb/icf8Rj3raa/GWt7wDOrIuwimAtsm7MZPpyEyHOopaR/PaPlJGnnr99PF8/QLF//qfb8ef/s+3YykWtuY+39gYBrlJzCIOyqLY+fOJOVMm6EBz9tzp0nOGTGBm6nsbamsZrvgLwCJJ1YWc1cCAjC+goiU+7oEUSPPXmvPmaKw2wBygfnp083M3SHCG1bHlc6G5tejwSqCuzQFjLCaImJnuJlpl6H8o0D4RA/z73JdCJCjHkU7Fhb1tYZ7zEzylGF9wLfLFEyBNROHEpXpbftKAWTN6ffrn1+xj2ep4RkhdpolkgJ2YhtvgNR4yKAzOANQDxGJjip0Ddh/QRaGLg3PTGZyLb6nuZTEGMLpOAK29MOYTrDnM2khg3mr81Inr0iMwW7yPhLm4ZviMEkWmkbLBspAClk8UXSynWVvZwMJBwy050LJzkNK0vQtgHuuSjPlgrLkv4sXDrFADsxAIpblaFCisTZoP3lgTpEsgYJhci+mZDDqnayS1FDCW0AUoFzlnA6R1w6BjwF0gEoeBvOmTSbEymKL5evGNBOoKzJqsuTcLQmCLcp/eOFas792HBTG6eRureACivc78/T9/y99YgZ1h+5VjuC1ci00cZdJqh5JBV1/WxJyrmsNeMA9cvSNl3Op3TG4MKgCuqGXVHLOo+PcLg6/o4mKqKtOZCjgvcgKkMROdWvqJrq8IjhumfAcgD1Ow4xzgTJkKNDRAWTxNMZUvYBMKDou/sf2j5zmy0cS1zMMAZ6rxWwlx6nFDBee9TpXRbHjGjFG1V5o+rHKNmZzNvNg84lJFLA9UN5/xRSIym2QyqvQC5imqfZuoTLBGNdfVkVC6hkfO0HIsJ153Sjh8oUoh2fWjUzMWbVaDBGgLbMo0tS2ck/RgICyKo17zUnzQZccoXQjMiuHVf8ysDQxxgIb6OlNz7zl7noZ6G2RZgFm8QlH1N7t72MxvegzOR94mP0jPO2dbuSFeQEFLmDeP1Rc1ffVS8kxZvcvKJrYAaIuF8HxmZ9CdPui1oa8LxqGh7xq61RnJMWzDFISQMxpAGfEWMWdXK85T99HelKmdQJpfwbFBplyFPAug1jhGeb2a/O0tJwA6lAg/Zl3mAOgtGJcW+xm3TdMiuAVYm1elqyYWAvPIMaBpuq8p9NcGrGLZAqt63r7tT45+gFiUojVGKnr65cSit+M8RWyXNjHnLUCfgogtsOf3sG46wHh6u+aoqMgymOJ3TJjeNIOzeDxOc6Cux4sMB+rhQE3ro80YdUCOLV6d0OgAlq4WmtHUsx80rVmqcw176Hy7vEzuBNLlVtq9RJknQFkoMc6tCf7Dy74bl93sJrjf5zwJb3nzX+PY31xlQL0vfNxgwblqjXwQIex4qkgzFrAEpfhita357E5bgQYH52HfVk27pnXOwkqo6dY+WgVlzI10gv0WmDdy/2qbA3AFZPITqEOn+iJTmq+9V5TnG27sAG0l+Rj8MSItLVLT+P3ldhiLVpOjDg2xn/LCMXHmHJGWDtDd2F8XdZDeiC8tDHoIojxqaMlagJlsuQA0kjkToCdwlvSlbWcWgTn/FCOdIrKyZ/EKW1K1biaZGEOuO4jHxgjctWgC6JLv7L7mcWjoB8E4LwnOYc7myI8AQZM7nJvJ2kSro96Z3RFwlPz1MiYAEOUnTezOfytjpRyjCsgEV2qQ8SGf05oMLjcp4GsFnPm9V8eah2YKYxcD5u6gvDhFK6Vjk916Te/hoM4dsLo4MA8D574C/TwwDtBxPsH5CKQ9pBgbM/eR1YI3rc7CGMXN40jIHL0W7oqqDFRkE/fjMxVQFliwKO+PkxRx117tCb4MoCVYF4BuEVzq8ykIi5nyR9nxziqq6hEIW2C/zmE0FM0eF6ArgXkkWAd7ZuuYlboy71TxsG/8Itzz0z8aAPDMf/lP8SUPeBrmOttbYD51P26AAWE4gzEuf5rT1xeta+kx4AMmVHwT8EwrKQsubJTlSzl56iSXsnC2wBzavpbnm1aBmY9tQBcQ5ugA4As1Lb3SnCX5tcIgi1JWQlFFW/xE/JT/3dhy5olzg4TpOX+NAtaFt8nUGrhRxqC5kG8wc/dwYB4aPtMhQGcPTeuUiuc9c5gF9NMLAZpj4QAtCmTdKz0awoBHOR3uUUQbb1jMCCozLsLAfAGgBTgr04SYm8tflN2mzxjXQWNgAHQWIDF/szFnA+YMBLMgsBFwyqAY5XymNWc4EGl3NlfZ8wagmNlQ/KCEiNy0ofnrKawqjNTwTcAAPd9KwK7zaP6WeMMAMhgACcz1+AiYG2gytcBcsXSqTta8ZrqW9BwHLDAAbSkrBtyE3ZxBF3AO5nyVg7SnRW1BWbcKkAPzkVk7xxsnRnZ+1EG7kPefwpBmbI+bCVC2ssbiQoLBoJU5YwvOG6BOYNYJoEXSRThdU7ga1f3KauA7mbJNZsoCRM1Znk+5rGTMCjmIux+ag/Q81HWYJ1nvMvo/vOI30cdD0ETw8y/9j7C0qA1rPvJPbx83QHDWM9eAZdbUk6TaVngagUjqBQPUIy8H0FpoVhDxgg0bBWpQDG0nt/W6eZ4+CoLwFtj9Aqrkr8f1QaTkx68NOOcIeSflpwnMG/Ys4iUcCVylaEsE1sncHKCzUtDmMqh/wAQiN4UXpbbsoLw4yDYH5vCZIuN4xEOUJKFhBOD4Dw3P456sFBTYUxgSooCCJEOuAF1fi/uAxA6WF6nibxT2FuLEmfPYAnRuCA0Idz6qz0vpTc/BV4Lz8LSptVkQ2K5hLC2KVY1GP7NAQ4ERU4Tc7KBT/XdnbMPA6LR5e5tfq9NUq6Cba1E2f98AM48V89wPgC59nc/1lxmEKOW7CMpLAWc1V0GAczCo5qDcHJgdpGX1+0FwPuT3xt7SLcHZg8HS53w+gXlc5X0BaOYuZ4oBjpFjliPHQDsPhw3BdtCOAZmmaxwB84rY9tVZsoRvz6KzkzlrAWWPUwiAHtkXf3TsZic0qSOAMCOtFQy8E6nnj3iPxSBoETb8O9J6VgJEbWiHuyBGWtdOArSWfuD3/usb8AEfeB9cdO5ivO0vrsA1m7S3cxV+Atf9cb0HZ91RGFg/TV+FAbNHXw+/+aMLGn1XnX45K6moKOAsBGYYuG/+BR3bBFHMC0Lzb5HfzImlxzS13uNqO63gTJMcj/k3979XIhKBXwrIpOEVYMaGMSOD4czvTEDWAs40E0vWjq8MOn4m74lAg0nbGZTQIkUw4aGYXYSjWqJkgocEHg69wlIoOOSEgJomlgCbykgxZW9aHVAOuyJvv1BBUcSvQGsYoQHyEK99LYuBcdtFD9lBmxXd0HjOrRpbAeiGMcTzmi1CW8maF3EXmm7Gx+dx7NJlAXgW3OSsMRi0+0Mp1aRE2nGe6wactZiqoT6aOXDHwJxpVWU6Hmt1suknQNLUnGKdFOY8AbSfc1QE88tZBFgcmLkVZWwttsIq2DTkloGcZ8PGpC8p5Ls6MPfwNx8D85ZBF1C+GpP2SfarObJH4+iyZv6cr5oppNk2OEEBZlNKAE8etu8pW2BGdHT4jPjZ1QGe1pb0WeeWnQWYC6jGeVNx6n4ru6JeYMZlUW4WraR+vgL0Wvp1uDI1ZmDWelwXjL34rr/+K7zriitMuaOU1Crprok53wDBGecA3ZkJjcki9AfaPfRdcdR9yQNeSMBNHtyurzk4U/j3UxYPD0By1qdSYLocozw/AmYgAbkCs+hRwGkIq7Sh2qMC8Rawy88EMEvRGwKQU0TaKYjDiKCae5cAYxRgVq90RXC2MZ2malkzcc5+P0AiM7QoUBxbjrlOa2U0mdxEoThVma3zsOVYZ4EVALj4kkvxEy+8HALgYV96b/Qr343cpELDqxFbAsf3SQz1iNdzLI9MqTRpa9n/mCDrII1GQN5B2x5YyvPFQJp1sSNDVBt0CL7vEx+ET7rlXfBNv/rD+M03/Xer193gqVOcpwB3RDPZP5yVeJW6MczHSmAeDHEvCeLq/WRyTeWq3ml7lsC8tVUkKJ8SagWITwGRqI9reZ2KXl34ihIoQEE6bNK1JQXx4pOpi4FzbDfp4CwH5HZkZVHG7mgLZhO3IvabDp9zYc561TE4T+z5tL21qqIVzLbqzQwP+X6J2dow+5V9lUszSwmSGWcs43Ag5ft8bANguwOun38F6MmPTaVAfXkQ9HMdo2CiAXO52qJfaPOvLwJHnYAkeAMZ9IdS+4DAfAGAnlyPVUniD1ZQ/j/gfLUP9cpq1CArSE/bJ1PJcwpmuwJ5+oMDMxkz96SNgCMeC43XBYZFoVWY1OeiblHVI0CuRdmzPBXm++0fPWLTWvrtmq2ycgP0+fNMhyggLTMwLyoRAGYAXY6HoDU1QB6a5nFeZpwLWZQ/9WsJEgMNmTllm41ZJAVzbilXE5ilXHReeuAj5XkZv295zJPx0Z/wSQCAB/3zJ+GHvutRKYxE5lQNvn40/AWUN6xQo6+NAL0kg3amrG0HXfbAsod6CUldjDXDe5rDBxpUBXe46Jb4J3f6TADAMz/zwbjrzzwmtk8NGeOma7Jl5U5efVjZxG6bikTwE9sgOPdsR3m4fqPjHmAzBhyTWeOcwXr7qJPYf0NTqMdxnePVXVQwyBRaanE6a3Jk3AwqW5opJQRnWbxn2yoQDs7qrFk34MztUAeZ8/ljYMZ5hGViSqmqrNajlzcLvSaqyTwYRSnl0QWCWCNqiqCb1yqFHUsjiDbf6xq2UUtl1I3fZXNGmSIRiY8ejFitOWXZFNx1C6cbJuKK1V9XC/xs6umJ6lkQmtOGID9yykaBGCqnAdAyA/lQv6cE51YAugrnDYu6Rn8z/N5e98f1GpzHOUXbV/0wTbVUnNKiokAXu8FdbE00gaz0CyYohJUKZd0BVvQCZHZlsonG5AMqQCNAWsmOpz0KC0hvI5A42SpVqw/F0UP4v45kzQ1TOnWADtzPzFORkuijmmUtvUV+8PAmiiZiUZUAYr/icoJa1g2QcnLa9XICZcS21WbxSAVJtbDm6fIrepoGIKASZD+mIbCBX3/l5fiqr/tmAMBvvvJypPluGpyizdTnJ+5DPQ+XOubrlWDNmd1pwDwIzGKMWdseSnDeOTh77Whj0GTPFuP6Jvw13tPP41zb49ff9ocYFzWffx6dHSVSCc5W3CXruncvuNGBZUC7A7OcaBS2NXJ4AgW/dN0OUgo0PTILndI4a6u2RkFK0QQdA2udARqbtzF1oIIz3Vk8PYJ0gHNzdliAOU51wOorr+A2kemD5iR2CwTBOUDZARoE6G3NbCpCp9gyQRYIEHblSGL8fN4X4ZHAXMa1mpp9m00pWqiIlH3M1dmzgbMwjymsffV7qkk7KhLknASBlnjmypqwopzEEE4zQMXy9R0j1a1D2lz593ijiKngh4uRwIS5eD88wv4Ee3ZB87h//jA8+QmPxl++469w69t9ItbBeAO6NrZz+JoA+oYIzl6XPDXJ9KFyy+RebpZ2YBmKsVpKkNXllpzKCnzOl3wd3vrmN+PVv/yLKC66NLWOBGVjcVuQtvPhtpBaBH8cV8Z8qvJFkUEXBOZTrT4mFpH4QyxrAdCIzdLtFHxvGqVZ25j0UmtTk3BJUQJY93hUMYIwVU+n7XJSpQAwlSM+98WaC3UWWVulVQpDsl2P7IfVf5j9q17xS7jnx90GOwB/85dvw85BPHe7qW0GZi3gzTiFAGO/npkxkzULuOPZoFlbFgz3L6cp+8yAebcHdm7aXhbf8zlLwbxHgdv/ysNx63YT/M93vQ3jXENsVl+qWOk6bLOVQ48euwF1UJ7zerfsmYzIgVnGBISTcgSUyZve+jkefss6LjSheZd7DnpdDzL8NQdc4Q2us86/JiZn0eoEJgjshsETad3HLDmp672PDzsARU56K6et9r0BzquBMMEZtRVg3kTD16psHHMpSgjBmAAtXAyubKcs3I6pm61BMOU1tjz2vawlKjC53zhM/lIMCv6e4ntWB/7J5acuK9XkM4GNx1wzA83ckPCgUJQ6+sMBummsy1ivZQ7pRvNXJ2TBsAKgYQprpn6gmrO/6svvDxHBzS+7GT7yH3wIfud3/tuJ+ZvK+DU/xjW/5cTjeg3OGuCMsog4aOpsTidwVrfmtKbAwcCcUa0P/uan4gH/5OFQVXzL134efvNVv+oArXlvJYFa4f69mCjVp+IijPdya8qucuvqwPnqmHNpkrMUsQaHXSvfH/KGaxGURW7WFub+eqatislwVU8BFbTuIC2uOLsMTbGADKLjqRMcy0XUv0/7APPYYwAUrMQlGXhbldf4Qo0+zLpiP64eQEJX0l++8+3Yq21OZO4MLaU3tWjoeT+oCGz5Y7L5Y2A21lyCwlz14c63ip2zaGPPcBM3WbTuyJ6bnR9FrgLvGYo/Wd8JPVtS4XHfsqXkKnSvwH5A9x04WP1yY8s9gFkJzlM5Nfb1akfeyLjZlUFsQfmC1covPJmn3Ft3LsqWdejm8/Wctlqqa31h/tQ8d968JtnXgIPKmiMMeA8zRbN8I7W4FOwW+c4qYMW3rAWYpQaDJXOWyUoxB3RFYOcEvjxNJvARvCU/P8W8EExlAlWCMit8iO87L00hizprNuZcd+YUgnOYtkcANByYB5QZk7ZviQdKSlnEZmHyQkPq/bAaB0M9fXIwd59NihKQtz6yN2iGowl1SJpAwyQKZLQpHKQbHv2478Szf/SZ+K+/99/wO7/zX2ZhcJ1ZM3CDBOdxBsgZTRt8EAls0dR6ICQFbU3zd7xPgUtvejMAgIjg0pvd1DZd0HRRdGG+bQVoeE4p0rRNBs2FXWVSAWa9kAzz0y9K7/zQE60+qrzUzVSS42ZWPqYVSTFnq/UOzEtXi53pNkatU4PPH47FMjglJU45xptgiyqCZAZmMPJYfO9j5MYSDtL59QnM4otTfV9XK6GpWeikyNJUsOw9Fh3ufmcftEilFQCxoUQGqPEcszogz52soO54m+w5gLm2toeKm7nJqCs4N4Izr2X49PXnXQycD2qBkjRhLwO6rAHKuqwzY2bx8SkC12c3k8Sp/EzAzL4C8nGhldM116oGOqtqGcnDkLvtvdb8DlpJaOZGOddpMUiuJV4DI5JY14Cnx72jK6DFOZXq65yE2whfrf5k7llKgCZjnoPApoqD4nYivyb6nkmMaR2sV5cA7etMuN44LgRltgTmYM0T8MKBWa3ue2uQJd8nTjKk+fwopU75j8A8PKsjtq3VVjRc8feOBGZF7kInDtKgnM2A21F+y1i6xvRgymAAtB8rWXTogf6e8DMrXvLzL8XNb/0LBZTrxPGR13oHrulxAwTn7luScjOw1CcBOjcqo2h0J6EMM983gKc87cF4z1XvwZv//I34pcv/XbolWpq3gzkX5SwDxDABczWVEpin4jJbf/OC6f77Jc3Pt7KMa8//JoIMxhybr7kQMJe2wAFZzbS9U7omDZiX7vnNkpHN6Clo87Rc4MEsE82HusbX0OcUIFxby92VAph8t6cIhs6bGPc8c551A8pe0tLz3c2EVuDAmcBo8Ch+u1c1YDdcjIJStyaj/EPhIEAftXlr+i2LVuygvoF0BIu1Zj7nRfIc1ICZrhgsBOMOLLDtZnfqJuxxApS7mXEDmE+wZYLyRvsjb5vbKTDenXitmrfrHOeMIQgSIcrkn4B51lpzShlIMno3X/aJF6cs2RPnGxAm9C0wBzivyCpv1bSyAWeyYSE4O4uWra/5dIlUKYoG60dTyYZgCpHY3o0AcZIPfk8AKNecm78I0N5kcSbtl9kWB+lFIYugNbG9yp1dp2nbfivvEP3IBsziNaxprTevhAGnpVC2Y+YMLYWHnDFjxHGCMmMtsoEBZMPM3Z/wUR+PX/y3P4+/uuKv8NH3uCve/a53F2D2odeRizwyA3iMcr+3AvqaHjdAcB47QPZ2bBNCQ6ekeWMZcJ8FPIjJ2KFA86YMmOAfHd/9fd9ksRwNWWMgmDNyovhHyZjLhkwB1nXVVN/zEThvW2LdPBcUmUI1yrGWv5X3StssYoKyy702u5uyEIfCgsLUGfPiBGwBltW3bGNUJ39MEdGWAhsjOEAn12E5wNQOwndbQHlqS+kXyc1jCjiLjznUZ0AUnMlmRfSHRYePokwDYSbrhRHQzB0suuzbTDDumxSvzMMugFzYM2AmPLJMVv4CgRm76djAmtHaBZwrMDd1Zj2Q21XyGhQsSanVpxzR2KtFbFdzNs3XoflxMrkQm5isYNY2KyjvNsdVC81ZKaEAFGCW+T2TkhDnRrPQsXBMc7DJgDz3IiQVft3ABNJTI+McDrQ7TPSyjsUUiUTAZa74asoQc5sH/2bjPW/Tmec+A7DPKM05bzX/+b4sJhRjIOxPNPqmRHyOOEgvArSOWshOdoq2KNrSHJjFy2ciQXrCLAZE+nwftuZ0CNpwoO7NCuHAfczub7b4rQLSmiBtYWbN4Fl8jTPWQp1Hu5KkrqAzYO+Jj/oOXHazm+Gym90MX/cVD8Qz/+9/nYyZ7wtQ9tGvzKoKdM3rvHYPvea3nHhc/8F5Z5eeujgXpYQym9uMeT6umz8N4MQCaBbE1p5V2PbSB0Crm1gUZVkhA8Jke68LMNfWNsenwLmw4gBjyrlRZMWyGZz6WYKof3fNEqE1oYLztK3iUOyGMeZdXb+uoYfZUQ0gB2ruL2gpirHK6kNzUymm27Y5XsSKzTQEQG8tpEJwZvM6vdr9eKjv5OkauI6M6IeDRDBmyWL7xdwX95SKm7jy1sRN27lTVZq1S+OJezERRO3s5tphbnZR62qr/zgDYPh9AM18qWGZVcGB2YWw1h2W3LesUoKRApTTNDnlxQkcfE5N4DoBK2veYwboZM+SN61M1JHngzXnCCfxBOLNz5PfIzHlUY+CdfoYBQMqa6w+r6BMpsnzkh0m5lxZfXxJsTxEBDbLcxYfc2MtbdvRjoy7lraNzXaAYM+RPEBxIji6I9Go11wDMOvS/HlD7sxl7Bg7Z8mLoO3InsmmkQAttk746zHfR7N178Mhnikj3e6f9hbsdwDoDtJd1bbGLgA9MDJgLP5ZHQurBGm9AXMVOsaGf+hZP4L73PNeeM9V78HP/PufTbN3JTcRVCplvqOMKkq/Pb66xw0RnDlBgCK4eF88MEikZE5oukdC6GpGyLvQraV4twA9UAG6gDLm+5yPGbCP7vcWpLfv2bo7LiQbqyylTKvPCcr+OVm4qJJBnwZnU6p3TbE0wbIBchMkEmtB/Lm4EsHgsAFGi3o1rQhAoXZgJzKB81KAeWmOX6Yd8J5JiZBnVIiBsWnmw3OypQ8IwXkM9NFcAPq+UhTKzfzPzQE6/Wt+PfQ7SwL0EXOOYLYKpHUS+CSrmzFwu8iTzZizWWoJPHBGbsKn/ineIKW07ATMHagtclNHfC6+IyYi+/oj24lYGTPbHpVRyxGw+SgJ/bnr/PcCylZxyrRSPfLbZEFV+39ZEPwaAVTHfBkTULuwruAcv0lzuy8c5XXw81QciqJR9zA92sPZTeABIik9TvmUJ2AWTAUFJxEiOdtsfUhcj0hR2jzaWidg9n7XgEUhOwV2GszZeoHsHKAbzdvMjW5+3gQ48dTVhrEMtD6grSHTaNJvPNRZc7DkZNDc55l+aQNqpmlJAWaYqdz3iNZ4rnjpL/4Czm5+4wLIW2BGeZ1K3KZ/r1hzzsnr+rhegzNlGzXIaXxhShPzd1nNqoWw1SOhW9lueIAodJFBf1NqVQD09j7rhW/JqXt8SiE7RVZKCxnWyg/zK4p2DSDZcm1F821tFrHFImprtsH3ZZU0TmrKpQBnsHSmOMm3xcOyn8maPb+ytcKaHaCXbNgJdFdB2rUC+mBZwo9CUc0HNYZCOnN9zX/duhgwd0Caoo+6+SPi+wjMTLcLn7MPELeAdetc9pVdB4PgDa2Ty5QT9R4uwKzOu/dtUwzDJw3rk0PVabt4SoiUiNVyQ6pnXcNwuGmc3RVg6gTUMsm2sOGDIsb8Z4BO9ixk0LHoXIynCQsM/Wdd59Q4i4Lh5iI5Wgh2Tnp0VFxM8KApyt96eSclNceObLmY5ZkGQfCDL4gpkmFsAHpMwCxlO1kRA+jpcuMKa+16pQ4J1oc/BujSB6ojF62nSumioYlrBJh4v1Oz4pfW2C+CtkP6n8XWk/iAig8wFWTm2o+qGEiCshFc7tuONGezDVq6yJYHVLtxZ3UOrR1h3o5bOADfW+HqAdnvf5Wh8VrR5AKk+bi2AH0DBGcKySOMcgBtDoKWKcEAJmp5mMEOM/utpSLH1bQQZ1pvwfHRdHv0xPH2tQvd91PnXl6TOhDYvEbFvwJzbQCr88W+x42BdM3wcBFWE0PU1EYhAKL2GzaOtnHGGMmWxUWKhEZQ2+JmNtcGdg26a67JC7ATY82bbaPEFzqZiLrQG21ARrcI7G6MlimefbiQZ73Agp0GzHCrgiAj7O19BGFj0IVJA7OyJsgbWcwn4oxCys3LQhC1Ve1RQrgqhQbNOLFnrTeW7IzKRzT3DWDbCMwni4zUybidlHUCVhPOsXlbCNaxE9cGgIMVJxsNX3QAsrPXKaR4WsBHZ0j1mH7c5KPDryg0SmQ0+gmlBj1/v8LgkV15o0jU3aU24GzAbAtGnM2FPuLuqiDvQOJqAWVjz1k6t8FOiX3KBM3FWvZLZbaIATMsiHDB5JGQPcFZILuGtmtoO7HWxIC6IWIzaI4X9f3aozKdWglNj7aGZjlkq6Xv6apj42MuzLkPMubudeZ7ADMAsMZ+4HAAdCqu9r4K0kVwR+8zScuLFaSnNXBtHjdEcMasz2t53lBAGsjsiKJpToMr5X5hA7w4BuM45n2WE/e73vRJSysy4KQWN39OTn1PeUg9kM2LvmorW46dCjfsOVyXXMej4KYU8cu1XsiM+fftTVGGT4s2rwWYyTwckCXQf8l+5z1Z9F6CSc97OtpiF94Z9zdjdGgbGF3A7e1ifDonA03CXsTDFbKl8fRSoQvy65KvxiZEBLdktHbcL5+YIb994jDFhH/hdpOjSnsPqrGT4g3Q+BuGRLxRVoHU7EdtDhbsT4F0bG9aTx55EdOMOwXONe2AZmw/lvp8C8JmBq6AHdHFwai9zKR/Nlax1HPkw2BZNI/tHTwmaEt55gtLlxlkI7CjBKuFS2YLzv6jNaAOm/FlIMzgJCjDK9jsJ2+ut0gnjtHm3uqny7xMdVTqMFHPc9OYLlqi++FWKr91ezGf814g+wbZNche0HbNQdqAeWkyx60QnDnvWMlpdVBGpj0FOA+3PA2PzBYPDlNF14FfftVP4Y4fegf8+I/9FB732O+xrVM1ATpM29pz6k5A7NaxCsqb98UHt0Bd5tSpeXbtHjdEcK5ghw1Aa64TLtRYN9FXDSrjJLcgewqoaz+9Xzf3eQvCBdmj6NLIRTRdDK7uxxBCH+VjId94vJWdJZhjAui6oMtYkWnG4lcJUG5h97fnYzEQJvA0FQ8Qa150IIFZZIniBgbCHmniW/exOhbInHdk0uLsGQHOwZwpAL0Yt7bu7opu0fTOOmycNCeMuu9KzMLColEiZt6mLkFMZF9dIIrCmn0uVGBm0HDjZ1w2Vwt0vmY7qMHHeDCmipSI034UYD4AOKhn6Whpw9MNHKDZTgJ0mayxtgpynGQO7URvTeqEw6485zxgnrwhlAjvZ2HLQj91y5sQn59V7bIKYtErNJRbuwr1tT7ivYJIhvRWIi+D0ZdWcoOTpqodx9zaLNoyzvzKXPcWwcxIa3vuc5XMuSVA21LmbnEO1uDpyBE4TwHmFaAXA2OlR2IHW1/72pqB875BdgvafkkG7alVS8v0SlPsDZxlKKQrZOV4oARscqlya1iNWhL0PQ8M7PY73PFD7wARwT/6ovvh2x7z/RjaLQpcm/ubJQhBlcM27gRmCRmfc7uCcZnb8ab6fPukzrlretwAwZnBeFV8xDHBxSfBhdI3k8GqyyaZQLYKzqNjlDaBsJtRojA0ju3hHv/CClsnWS8u8Fm/rukE6oMK/Slys7U+FsJDIgDk2MVrCs9XRGlSrqcWJ5grALFUnzAYinSdflXuBOT1pKPt2FeAlpk5t2TOCmPMUFPFbR/lSh0EghWTVqMmMBbn3i0EDdxUNxclATAF/c5zQKOvwAxNS45PD4g4RjYckVf1ecNqkK2bCT2uFyn7LRBYgYNCzgN6Xh2kdQbpAOjSis8zGB0XVp1/1yhbjidZAKpPNBaIlRLtTCUp0n8icMmZdI3Giw0a7Lc07idPU2LtH19DjlkVrXacioH6+Vibf3sOXKzgLDN1jbaZHVuBEYqtuGwSW0PwdQXAnUITQNd9chZ1QKQ9gqdSTq9eQpizCcx+TEDWnUAdkHXfgDMDZQPoBbI3cG67BbI4OC8tUivtJ9QVd2fPa1kEoIzVmOfD5zYBujLngYHDecXlL/+P+JRP/Vj8i6c9B0PPoKNDdUWka2E2WxNcVVMhQGjWunnf8VyZHhec+0Sca/O4AYJzbEGLY4A+AueSLVLqs0+gx/B6VZkCKU+5KOJY8viIJQdII4G6ADMqMMM/0+bXphiTbQwPFY6NsmEfzL6C9LYKUAAzX0dZSzyHZSYDufVmgrEu/lqzPEiCMT1iUhKUhXS9JRDLUsF5B1kWyLJzn/MSPugEaF6HXbiK+/G0Q4edWORPIxfwUI20M4X6/baUjybDhEwVbiB4kOXl/FMAu7bDv/mGn8O5s4vx4J/8YvzNemUqTyGkEezMz9YUCjfJa1OMbqkqo2tk3ujOhNtYFG1xgA4FSovZEF4hUoHzCrlKrebFeYVOLJrvd1DudYKXxouLhxwLrRmJpiZlQkkFbKl9ZcoE5ubKkE/UU8c+AFom9bz+CxC7kI4FWjR31cgMjptq96MV4aFpU75Q7mGkLyD1k7qmJ3AuKZwqLpMaMAak25aM0pmiaE6OhmbMeIwjx8F8XNizz2FmYUCkrHtJX/NO5raXAGXrDZCxXyBnC2S/C/bcliXB2eN4uLNd1m3RULg47ykLa+pq1sxGrBLGYg8deOBXfTd67+ijQ/XMgZnMeZ1usSnI6hoI5zEng9+YOi/qbTrJluubtmB8bUH3BgjOuropFScAuoCzu7S4L/hUa76C3ZHrbQvQZRJME4Lno/m54+gxKcWP1PyCm3stW3DmF28Yt1wDSMfXSh6fDIIrhEfL707zlNfNRd24oExeaVHX1QWWOjhbwY36A0W8VMbcLDdD2g6y7BykdxNwawVo1/wttihvMpmzsMCGX1BmqTAPGmFeo+mTBUOGpC8vyjKXWyWbdfb193o0PuXO9wIAPPqzn4InvORb3ZVtgsluo+b8CIAGohShKMRzk2UxQJVlYCzN89ngkbXGKjyByoTcAL7lH3wm/q+7/kO87E/+C77y3/9LqxJ5lQE1TjHpaUcXnc1CMcHLHLi2wkVQuGwJeENJo5OM2M85KQHKDIwzLMwbIPStIF9TlPmat9jG3J8YW1a/9wnaInxvCRRzK8kM0KNQVjE/w9JmYI54AIL0ZtLUE63lJBvvg0+sLoA7gmTqHXhH7G22yRzPLIpMdXTA9HMSnueCTEckQO8Fg8DsrFnPFmPMZwtwtjNg9tZ2i/mel8UzGxpVcNdl7JrEMyki8G7AvRxalGsUF1FWAzO/tPNnHRgMEdPVfc1kzil3c5GRNXtwqMugZNAVLU5M7yNFNP5wtdP/wo8bKDijOSBLAeii+JLFRDrnpmpeTUdkrtSRmdG1XVr+bEIEf8m+ThQXnMF4J7MyF3HGj0LBQFZbTPV1Ld+z6ae9CQowB2mbTrD8Eci8a4Kyt/hpcSBmoJdgTjmrdrRS1QvNA5loxoYX3QjK7n7IMGWXdgTQOwfo5mAtIVzggBV0XkuBDfh7PMp5uFLUmpXxNMeyC23X0k3zN3EYuooLcMvdzlQcMqDX/tGrw3z22j9+FXz7nYxTct5epUho99CoF2y+bgfpZWTJxOZAXebMiO80pvW4T/hs3OTcxfiSD787vvI9muz5vPpGSFo2nN+A8wTSKCAtpS+TuwL2RohteUW8ntgH4XNibG1keq0ok+W1I6USOV8JzHmqOgvu+gZ1SFYDZhPTI05KBMbMmyYwN0Xs/7zwmM8J0kpzS7lQHxlFjukQiI+7NIV0Ac35djYzQDcMTwMlg27I4q9zfPwilgJoMZbpakqztsdrOFvG2YKfu/w/4uY3/0D86x/5l3jOv3su9Izs2YGZrDnA2Rn00gyYXaliuipZM4WxyU3FKNauKUCtyB5alWb+3KHKZoo+Tdq5tBLQJ0GsLSfAJPD4/BqA+sIvXofHDRGcDziSCBxq3h8GXVW2WUvezuVtJdMSCc4BzHIcM8P7y98miHJxE0gFiBQGCh1BnrxrlUIQp/DiBfF7K9hvmHkAMT/X8lxSOJW2GTPdHCfeSwQ9NfF9s/36htA0aayT4DyapNkJ5vu1BWWgrEi2TMZswLw3YG47SNsbk247aPiknXF71SKl0IyQcSuwIWipHNBS4ayTAWQcMBWrLsRoaQXNnZq54qHspc+dY/6bf/gKfMYTPhT7s3P48yveZAFu/A1ysgCGbFbVyJgQ2fNoA0MGBkGZ1WDqZinuX2+wsocyFD/3B/8FX/0xn4TX/+83Ae+h7xnAVTDT9gEG2AeauTnnKzD7udUiDXXyXBCUY5aU5wDDK2Mc/LyFFoUAZb/W6DHllucx1w9vhgnywD0/Rzt1dWtJGfOpGpSmfFAuG3VTeXO2LKlEE3jDktEKMA8/9ucEwQjWSC1iclGRNQtg2QQKoOEf3vOeuHh/Di/++Z+3majDgiybGDALmXKauTM2XrGIOLGX8DkLXU1kzl4vQHeCD/6wO+EDP/BWAIB/9Hn3x/N/7vkGyvsFerYz03Yw5/0Mzm1Ba+aKaCLz+uDEH7B69i7bRq0vsSUHsPub/xycNVkzrXF5a8s9djbFtMqIZfeAz80PpcDczm+cOv67f1y/wfl8OcaM05MJi0yYTLnu1hZNzM9XAJD7fU5ArZg0Nv5WgCGKglZ9zV0SlEv4qC1YiQUbdWr9IUAi5UlzOULoSPmQwLVld5edBOitolF+xvSF460cKxibb9akrDFqB+ZmwDwcmK2MHz1jJVy8sOQwabc9ZNk7eBOgaf5mAJkUszrP2G/uWKHNBKHSXFhMKEO8Oq/YuRkHCcO2gbPfY4s6BWSIpYiEv53swMb6f7/jzV7msMV456124BrG1Gh+MWYXnjU7L/FdeNqAeEvmBlf67HqGapzfN/70c/HgFzwLup63zY8O6iZtAFfhaAvhZNDbuVSA+RRzvpaNO28zTSqqjctA1hnI4hVNeL3+Ht/tKF5rA1Oe7gag85fTbSHE41EvR0PBrvN/EtMeBSlNTKmM/VFbmrSjitbYuFl0BvTqR1IXDJw3CyyKuSmY1PyAz/lc/OTTfwAign/+hCfgR37sx5yNjtTvm2AJ/7PGlinWFyLvzLnRRZDUOgv67AR/+qf/A7//e/8Zd/yQO+PHn/tD2O0b9MzN2t7kbAeQNe93kN3efM4Bzg0NCc7oCPmmQ21Z+hxmYbWwjCB7V7G8Z61srxem3VXS2ZQd0d8YJmNCgFdfnQvCYFLXxJTfNx7Xf3D2wY1oS+RrlTmTmUaZW/YHmRn0Cq+6hAmYUZkzF7hPlADilr8FgWvGMq1RAwqZGFVMaJYUjSCicj2nALq+Xt9fCI8Ayd7LZyOzI8xJZumNr1WJ9Fged6BoHiaGA5zFQHkMwWgNw8F5oGHIgrrhw1RyiG3ZO1uujQBtwKwlKVv8vC2NitpUln5Uzonq2/CLHwQMpafMPiOeamFVzdRAucE20hgmm2OnvcnC4Xxb4cVuQoxYU08rCQanofGrlhKGMtCdRXUy52BxSHCmMqFI/x6DyNwqJA7Ieh7JpCtATzEXugFm9pJSMFqdlATjVOuozklshbg4KHcw013c9Erm3ByIW+sFlAfaYoOeAD0mcA7zp1BAu1LJ8R0EZLMyhG83TtcWygTQklNcuJnItrwlGfQOXklLCkATGZ22BjgLIjG+BIOG1QCK2936tmDk+u0+6IMgyw6iA00HmnZIYc+p6o5kzpLJDGaBNyWj1Zq7BZjVUxO/5WFfDj3bY5ydYXdunz5n9zdbQJiz590ebbdDazu0ZTFglgbR5in4Kdu418Cg3KuypojE+VGQNzSZDsWKo2IiVSBGPtgIICcwp995S9ULSJ86j2v12v93j+s3OF8FE0xyYtiqPCmAVGrrWwDGxsSttdoSzdzDjwsYqoPz9JOjPOEC79M7QJ9lgPIQ12qLH0akmAmT+B0BcmUBm9+FBsa7ooBcHGVu8msaUh6HiFWg01QVCb02DpZP6aAmxjICoLWho9nexQ7MQ4uOX5izsWcDYyz7OGaD7CBi1aWE4EzwBaBq1aXShJUDoKoQZ6dTeGjRqodalTAdEtq/CkulOCjzPrq8Za7yVnmq9SnCcqcw1u0AXc3HqfXnVnji7FnEyhkmY0QQMARmGtCMonjSZaN1d8ICzHPBEpxgz2UiVNPQ5MBNjVeONEafPWIAPYOyg7FHZVt1UgNnA+YVbVm975DWIexZS1YMoNVzIqe9fZX33IZZYrMTw/UAaMoD0VhbsYSq/A4/rWa/oJS3FAfogooBhKlIxrxk6lRPZStPQPGM5z8XH3Sr2+CSs3P49qd9H5a2t2vXbqZt7W6uFo+PYGCYAzRPoSWDjip3dAX5OQ7PadadBYONfUM7s6Cw4cFgFiBG5rw4a96hLWblarKgiQO0ShRQIfIyyCss/AVO0+smJchS/T9jQOqbWKjvq6zxLZyTZBgdLB2rtJ9vo1wnUMZ78fi7BWbgeg7OuArzwkIxWGwVfi7ICASTBGk3a2sIrARojVxemUzbgWyUYVs1UMiPtTz3w4nMkTmLMyVbzze65Mb4gEs/AH/2F3+aQLsF5Cov6wAUM7YAs/urKo1SvkqR5Sh9GNKHxGu3IIxF7XhoKxG1Xh9bK2teDKDrLkviJYiaga64n1lo2m57iOzRmu1rPAjO2KE5E8+Vb4OoaiFcdDdYG77AF8hY3OSVAK0qkNGMHXv1EIvlMnM9BUfrxsvbqTFDurzFg81YjGGBoqk6MPN96vebzM5M21Ez2FkowXlO54EpPy7gqEwxACeCHldAVzE3jW8hPAH1EXOugEXFATmpYzF5r1W0zsAshY4LVhiErCUSW92yIJnuI2bWbm1AlhWNwLz06KUNyELmbE194NXHq9EC4eMsqr4bko+zm34qizPXRy5g8zsX9uz4qkwuXjSzBIiGO/G9PcRN3M0CF5nHX4GCzJnaWzxsXEUVj/m+70dbOxqBudFczOMOBq7PTa32vWiyZwfmCAjz89YFaF6AZOwFshO0vWDsDJCbR26b7zkLkLA1X6sE5wZjzgTaD7rFLfBn//ttYcXn/KF+13yqTR6nOC5CjUA7FQ9x4D4OhUvFe1LST4HyRlBfI/D+3QMzcD0H58mszdeQB1Lu86Tcb2sRO4NWMmlnzcGYCc5aeoVpcor5Xg+eD8+ksGD14yJUaZIUjwYVAT7kgz4Y/+Wn/hCtNTzuXz0Kz3zB9yc4b4BZyryZfN20INcBm56Uue7ALE0i40sgZpUPP5L4WBhAt+RD9mPOEkbzcBVnzZb2UL1ix5X0DZgdkNsO6gAtskcT7nG8YOiC5sAa6VG+H134immL7wuOdnaqW42VXSrGEGcmNkBD+FzTqoAp6SYVJgJjsGaNzBrui91UoyiDVOZc2LPtymO/0ieJhdBFlo1iwN2/RE3ZjC35IoZCDKgP9poeJF4PpZTz/KTyp0URPZ6AcgTMzXrxNAqPmhdfD83N202ap+DAt+Y0cF5aN+a8HNCWFW23Gjgv1ts+w8P3oDaANn99ugfG0KKwaMRdjG73hscQX3+icX3mptFcR2EC0dkcEjTV+1okhwV0mI3gHxAt844R3TGXFFKrt43FrtdL1cloAcyRvzxmcF4w5rTrxvhJiW0fyexrbrN4G16qc+zd3L1vUSEMO8t3ll0zUzb9zbKgwdYkJcIPfv1DcOubXYY/ectb8Oh//WNFbimnfRSCElemq2wTZWwG6XdPYRUTlIp2Q2y/GqyEmtXGpTABNcrx/3+A99o8rtfgjPMIMKxDLP5CalsIYA4WuGHIeSzz32KDXqRpO4Jk/NcI0MSpkWckfnZTT4G+pGDP9BHFJ374J2FZLIn+3ne7H/7Nc55RBOXc6nVrOQedJnx90+YrfB2MxTRsKzstEdMhNGW74F8coNuQWJBZQcmjs93PbOBsRjeatKvP2ZgzgXkHXXbOmlmLeReAPnSHpg3DtyEzwFSEX0/hfuLhtbUXA+huoCwOyspKTH49seejA34QGh9DgaQ/k3e1gJiVKNzUFya5UvVNfwyU2yB7BmJzCuVh8VF7C5buPlqFM3ifSaZYibscBLFn7upzdwLiBGQzgTsob03bnBQxocoiCkYzabqYYWKd1LaIyBYD8+Y+yhgnWhxax+Js2YD54OBsTBq7HgBtzNn2qVZRdwjkXsChBA2gRkUPQZSjBftqxodHbAvZsyvMtJAG+5SZOZM1V3BunOcO0NwWtPt6KcNqk6CCswFzlLdtbsFicFcvYQg+Z208x1wL348l2LNEdbDhUdu8hgBoN3NzNzjsGsSvsS3NKoM1a4Lm/xawdv4H3vQDAAAfdPObo+ni8kWjSiONH1NgJQlAyLgRinMKqTa3sBdsTNgB1EAC8/Xzcf0G56uQkYHlofWgambBghHCbGbSFNaYmGKatUNa+g8c3/iaRhDvcqEWubJNXbAT19QXnvU/+5IX4ss++yvxQbe6Hb71iQ9GO+9a5gZZeZ3RU1GkGYsAU99YjgOYXaHg9pudl+YLRAnOw1jmouIBIAbQgEVsajPppWLR2aMtG9a8QEE/MpnxHuopU2TOFbwHvCq/m8Ztb2NkqgyGn6tdjI5mm7n35uBrAlFX8dcrQCMxhkqI3zUZLgcUxjrq2FfhssBN2lKA2XNQNQHahBLjDDRMyDq4846zhjKrQg90YLbMMMlgGgIz/X2j2W5XvSgeqz9f8/mklE7Xv23lmictl2exZc3u5nB0y1A7RmozgMjM2pbyo1iaYlmGA/SKtusBzm1ZITtvSze/c+sFnI05D80I9jEUnSbtsHIqB83M20BmHlQzvr9eLaQTY97k9qeD14F557n7EzjvEPt2szpaAR7pajEnY0C6+dgNgVegVE3LMqczD0wlCOE64JanseuoKxTiec5tR6D203ND1vAdp4xVI5QRWTy4zJuIQ7MyUtvq5//bX/0V3OfjPwEvftVvoA0xi0XUjrByndVVlgDtr6lit+zwE8/+EogAX/llz8eVK2d8m6/aFYKkQVUubwjU1G8fgvLm95nH9RuczyOCsI6GfQNC4QBxkJ4BuvaSQFyZczBo3nTvmQewYc+GHkDke8LNbQ7OwgIE1Gwj99MA+sse9Pkh2BYQYCUEZlVAYp0XcKZwqab9aj6aqqA1W0TG3iWEVmieBaCbCsawRSlqCxQudIEGtOJf9iCwZM6+t6/sjTWDvqvKonfxt+Fb5oguEF0wxuIjIoA4sAkHwS96OAD3AkoOSBYwleCkVRnj3EDqJbFBATFpo/FLV8iSAjB8zcLYIQfoYWbt6neuQYrBnIt8qBg5JKAvcGI4QBKgxU3z0iUVlGodCGDGPNevDqDrQgrWzMEQZBpAbQhQhhCUh5k/ZXHWnD7npTk4t45lGc6eVwdpN207g5ZdBxygCc5Wj3kka1bb/7cCc7VsMpCPU1xh661eM62ilTFLMyXpCJjrxi21Ne616OjX3L3SW8qRIeB+yuiklQTm7sC8TsMbmR+cq349NtbNxxsMA4kc52nzi7S2m3JJIJ4AuTQCfFj3NjCp2V722tfhZb/+Oisf28UtS/BAXAljizhI05qZ8TeCb33Up+Mz7vmhAIBvf8J98Lhve2lRZigHs2eWxWxG5Ep+X4Xea35c78H5lFkbwIYtlhtLkN4y4sKWp3YEzHWlI1c7ioIwEOkRdi56sjUCtGjUwQ0tGISh6rP2X3Gz45YQx+kVoXLCVTiBjbomPVzoBDBn8iFUgcUBuqlryyoQ+psY/EJVvOQ0E5TVzdnim8WK7NFQGDIjstviDMsKEgosoIyFpUWb6T0iGLBa2KNqJwPOHuFsGZFiJFO6HI7ZY51EVQgq0l1BgdJNsLkMPTJpNzhAe6vMmYKIaT5CYNa4teHrdruEsRORIqfJVhyyY662olzO5vvZlI95/td5MbHmOggE5VHOghEKCc6IuctWWTMjtcX9ogTnYW0x8/birDkBugc4q5u3hwO07WBUgJnmbI90V1H81s/+EW5zq9vhu575OPzAj3/frE4MNWsKFT1Mi3BGpLjRG9vxUTlab4yzUEc9rXZn3mDFlKcnPlkDZbfnUzRtN41JmOLq+3V+vvWbB/hqBrzViRuKiYJut6rhh384dqDCBL6xKcuarwnLJ/N9Uc4059zrXvsm6DfafXjtb7wRWR8gFcWlNdz+DrfAH//xm8r8zCVr/fURkvNx/QbnAwKct4/UpKhdIUG6BnedaiXtQbUIPgdlqWo4/DfKLwvPYLiQEjJni8hs9EG2EWmsXDu2ljwPFACThiQm5tQdA7Mgdzty1jcFxrmMrW7D4Xm7RjxT2eDmAszaJSjbVnWLR08bgEps7xdZl4A4WyZ7gIOz7NCwg5m491A4W/b3JzBbII3Qv60WsGbOQ43RAeBuOzJS9UqeWRGLIH1cFa60spaF/3PHXqRY02fmvj8JWetmRFD2aZCiAGfKTypGavdhK2sVpgyNwpYNG7bgLNmr+9WdRWudz1ulc3qecyInk+YxTTNhrhmFj7ARoBMHsAVmeFQvWrJmKjMOzrtlOIMuAL3rkN2Ktl8BN23r0qGLM+c20GD7/obiO5mzgTvf4cNxu9v8PQDA13zxg/CDz/k+W1U6C/O4RF+HxwG/XKCt9GE3TlM2gVmcPWNvduPYja1oc5V2kmKWeptalGSDm42WLf5qMbtkzXa4i0tK0R7k2PC5A7ROFek0Jqx6vIDC0+RqEYggNpisM1noSeesmADt8hlfh4wT+JXL/xCf8cn/Cr0P/NH/eFv8XshQDLzxz/8lLrvsRnjpz/82vugfPSHmm4aGW4FZrwGs3zdB/PoNzisuCM5bE8dRCtSWFU/A3OZeiynKy8dJtZGpBDyLRREhyhGOAs7ilabUqkE1RfqIZBQh7J9HAnT4nGG/Ny1TyX64zGCgUSicZT1V1qQdrtBL7HqkLCpCcJbKg7J4YIOzISwQZC6y1IhsBoCBKVHOnB2cBTsoAdrZtsDMn8MBqsMDYoI9akjToVnKsrm/MdJnfC9Z9c3eWVda+txHcBdBEggBHWRkpFydQHkja12kBgFpDArzKOLGdCoH5lFAUSkTkT2BeGLOWqCQNtjiew6F8kjhRLEY4RiYC3s5qQXGAd8cQzUdTKxZvOCLbwEZ/uZi1m6VPS/dQHrpYeImQMvOAsOwDOjipU6bF5UJFocAGnU3w5+8+Q34nT/4Ldz5g/8+nvHs77aa5Qrzo/p4cttfU8rEgVkcpIW0Mdt2O8nYID0VUVsDe0CLidsDxKySOwJcDfy8GlaNEOWoU3tAKbwC5skvsJQyt5TLmJV191fHVJmaf1eM2XBgrw7hjC0wV1WPtEr1dDztWtwnyII4q0L9mO0oU4bgXpTr//XHb0Nfh6WOae44B1hU+s1udikA4G6f+GGuMLAYUYL0Rkpifpx67X3rcf0G5wOQ4bUnHmS2hUFPNHPI5rhlrxWYN8d1kZ6IBqSfmcl8NVJVZBj7rL14MXsHaV9DYHhSmrYFadIuU6/oG+JvGW4XZVDT8F4KQKubZrVLpFIdmbYJ1OD+yB6h6eUvDVxpik4GLC1N1nAfcoA00twXAWNKNs086WTLosy91mBlUGdlaqyp6cAYI1NSOptmXzZ9CICmSc61mBqUlQE2KPEB/hojYF1OT3FCILh6MJiqM2eNNJJQlIrs4EZFCcC89xfoNZXE2D/b56po8xze0wAtykAoTh6uE66d8lzrH7agnP+nIgnYnEcF5hIwFjsmeVskwXnnKVW78D93A+elF3A29my1yOtGID6IneBFhUfxBQ/7JPQDsK7lPo68fwwAPF7PoXb7KqwgfcKJS6sRXBHVPaiQ5t/4uTrYQT9LalD+NUB5+udx6qJW7MffNSCTZ2qrW9hU4ecMlAePHZg1ERPidHdoQ1Pb7W1wLnVF6w1jbZBVIAdEzQg9AGNV6AFHAB17GExxD1wfnloWBUaMigusIMvQA37wGS/F5/+ju+Ix//xZ/LDNO4wJkKXw5Rms3/cf7x/gvF1PBON4LtlfsNGuWwG52n5qL5h5jR26pdWBY+NzGx4YE8EwYmX5hOY9RXMAL6U2AqRBgNacWsFhfJ1Q4A2aXV1WDXWz9UBWuLMoIzOrlksz5i3JoFuy6CEJytqc5YoVFhFZ0CLq2hjDt3/jY3HvT/5M/NjPPg//9hdejGTPO4gmODMSW31zjBEAjQiW6oAH2mqMLxev6sAYpmG30TF6N1t9H9DeIQ7U2ocfF2DuFAYJiFl6s7gcwsWos7tRZrfE5EZkT1Y+sieQNM//nAoyINlxmWHliEqh/7W6WbbaWiifKEoo8n0bBWGaWCeEmOlGozzZvo+xFqwzZ8AcKVSE6QrOG7/zbvI/DytGsrMcZ1k6dOfM2TcK6bwIJTCTQGtaaIe5PdqAK6JOUHmtvn6rp0riyqqAmRCuyI6lNPcxj1RIoXsw68BavV9WjEYIRJBkporCkKMWGrKm3LR3E7hNqbgSFQFw8b+8YwTjMX1fjxag6C6TsOO5wpMKcIOsDeL59DiIA7JiHIDhQE1Qjr4XWcTFruxHMGYraNMheoDgANEVj3/Mc/G4Rz8LQ8+jFr9RzRKyWyYNaLmnp+bu+9bj+g3OHVc/thWkK4veMugLAXEsOr5Grdc/w4XKaE9UtjsSmA1ubKKRKUsP894i4sDsxQQgwcJSUKf+hzLVaMypLsRJ6DiDHrwE9UsYMCWejGGDMsPTJeAbAKhvDYfWfGMLK8PZPKqEdbCZr4y2x/3v/QUQEfyzBzwQL3z5yzJCG4uBcwgyB+exQIexZlVBV6/p7WbgHr5QAjPBeTUwHivG6EcAjd4nkJYxCmseoa03LaAMB2mCyJgBWZiqUkAmlbEN+53AuZhfHU/EryveF3N3O5fz/ueDc6+CBTbHOA3E21bXB1/QzYlME2irFyss5kCR+3yxXI330sJ/nhXCrFmFq5HR2w7SrXWvIDacNRs4tzayYIsDGDPtl8XS09ogUy6MmRZjz4xgzJQSoOuVHY3nVpk/0aqJW1IJlb4Hi+KctT1uduOL8Rdve1eZz76Tm/9eboNY4dj/6Q7c5bhhuITRYl2CQzbnpb34Iz/9Otz8A2+DZ/3Yd+Illz8nvtcK4bBkpq0d1Q4Z5iC2Iig2FM0VS3XlV1cH51UgB4lKdGTOY0W0Y4CWTeyHK9/KGJ2eDStEV+8PUD/OPX8rKI8qHacJnmB9bR/HkP538bj+g/NJn/MsMibBFoFdW7N1BWUC8jIfO0Dnbr/hpA32HDRIE5jFgblJd1bc3QgmURGwwc17YGr/CBZWFxdiuWWd2upK9K1hN0zeGkvmkeJZJUY5ChIxU5+4mduqE0HFQNl9zVvfGvOVddlbMZG2xx//2RvxIR90B/zG7/0O2t78y83N2uIMQtSElY4sYKJdgvl0Z5sR7BXOdAfm0aFc9S4BxlghAc7eiqmbpm8DZgNo1r8mKIffuIBvEw2QXuprgikYLO6Zsq9mcxTfLtv8PLGxImaZzBcC7i3AngRproPN++rnTgKzpj8evuO1DmeYqSoSmAngIlk9ynzm/m87rlN+7jCQFoLziM0xogBJG7bTEc0RmlXCGuyl5oAcxTjkuMWjyF8qRwzGyoBKasC1ubmpE/VTTqSPuTDpvuAWl9wYb/pX347d0vDE51+Opz7vV4DhOfrMOFCg7rg03HWj3hKgFT2IgN9AVb8Lza1Adk0f9uEfjVve+nYAgM/53K/Gi17+7Pw+3ytZB1sHOiu80YXCqaoYY6D1BdqbgfOhQQ4wcC4+5+Eg3dcC1J7WWNlzYqivG1e+A6DRE5hxgGBFw4pxFOGZQK0B0Fv/c6U41/ZRJ8s1fW6DP+8lsF//wXk7DtNDsq+hlyXyegZrsuPjtKBkzUu+F6XoApz1iAtjl8JmlukWGKPNgZkRzz1Sb1hRyoCaMdAm+LgJQ73HIeMhlkriCqiIATRXUgTaUo5tLfTFUWrDMElNY9Ce09nUS+3LZqwYad32UBYSWfb4ksc/FK1ZCc62nFmPxQBaFzOVaQbIQGk+zxIXooqHftV98a53XYUfe+GvevlL9ys7W8bogB6gY4WMFdJXtGHPta/Q0SHdgFxGAnTdLaoND3cLgPazEgfqMiwzYKc5e0qBc2Degh9TpyZsrgxJkwVOb9QcawABAABJREFU//j6NAPgf0PeZB7yLVUBiNdw/Byln471+G8A744fS1mGCdRCs40rsmGml61662Merh0PkJQEavHduphypJ5DjZYBUmHdYJyA0Bikk981+nIFyCVD/XdWcKZAOn/eefNDo/W1sSBSq2pB67EAfYePv8Pfw363AAA++xPugqf85Ct9ToqXx63gXABZjSt3ZjIUxd82G2ll3pgcqTts/sEf/C7++L//Pm57+w/B81/4g1hVvXqXxWvoGKbs9ga0NQSJqERQ64CijY42dtDeMPqCtoqDs8TGK2TOWvRm6svaEYYvlB6UUcGeU342tZ2pxFvDAcNBOsLBI9os0f7CAF0juOsiuDaPqwWdv7XH9Rucq3yIx/YF2QidAspHKLUF410+n45PUM38AQCai4a786jVFL7koovxkz/9TFz5N3+Dh3zVP4OMmnKopY/aWyZENK+sTjWKP9+dEp2CpTYudkkWYAEwkpcxOU0drBevN63J4xv9zWUjC8XOWDPTSHx3KW4D2bzQyOIpVFbAxCKyMSxXF8hCJ7krluIhX/MP8VUP+CwAwBXvfBd++sWv8fKcZM3GnNXBmE6u0YstzVmADJcODtLmoy7pbdUsitjgElH1awPMUTBKqhI1C/3I0YybsGFFqkfgbGbG9C3amfixkh9ldCrcLJkAXXsk4gQIb8Aa9T0b1K5M+nhlYV6EZM2umMILpSQsF/ac4zRtr4m8B74jOMQBW7KUFLg5SHNgHlqyIoDwvVIIA5v7svn/nG5Y1jPznxUbUEZFf0QZWRTAblVOEJwX/NJ/+mO85LV/gA+/7S3w4B94CawOPKu7AdrVa8TvHDDJnDuG2jaSw1vH8HEZcQFU2LjpijW7l9/wtZ8FnAn0XLPm22nqcBO1T2ilq04RQZBMZWq6oPWO1hdIbw7O2aZd/laY77no0WxaKzYG27C51sr8b76ncwt7uDFmwSFA+hRzngF6bAD6wvM6Z8h7x3j/th7vh+DMh/9BeVxB+QIAfQTKu+NjHAO0MOoCMI2PrBkVmG2Xnu/+vsfjnvf+NADANz78IfjR7/9Xzpi9VIcq6Mklg65+zCpvc/pJsLWYU3550ZS9RGRqRA3zUlwwhQlPgbGYiLWobYvWtoL8ZpLWauJ2v7O1M2PNi5XlXJw1L767VBstTZ7+W+rpHgpExafDe87HHT285z1Y+mpCZHQsncC8TgAt4wAZhwDqrVQQmrTdVGg9WbP1YSeRNG8v7AnSUI8XKLI67lMyXYIxHISNNmgI2IExHYfZ0j2K9hzIXaLTqUEQT6FcnNkX7NlVMOZaKQcFmAWnjufiIzR8Jvxq/D3eGWmHNY8fZY5vAil57EyK5yya72OAYEbaayizqSTlpYWbOi43gWhqpPZMgxC43wgFlDfyRAswT+BcfNK94Quf9FPA2rzeyBL5wKxBrd038XBgFjc9k0127RDsQHRTmHl/qMmQEeA8MgixNPVUQwNlsbZ21BRKChkrlESW3tHGgjYIzOZvToDG0Ta8wzF1BuZYBvk7fm+aK6mi9KRbj8qSvWnpx8nqQrk2GLmdjPmaIPhvkyFfd6B/PwPnE6yZjwrKEMyO1gK4E1POvNxjcE5um4IGDswULO4rcWBuWPGff+v1+Cdfazfq93/n9WbmlWTMrESd9bEYToNJZhrDyvUWV0pgVgOQyH1moybsGIGWi5BM2grkZxQwQ6RUvBA/d4NxZUZhrFmimMg+Ire525Qx5wWLVxULgG4S9cgLxIAVn573/Jfhir/6a/z1u67EL/3ibxggl9boY3ZQbgWQh/fi4I3hgSUjhVyjWRvD6mCDOcoepKTIkpxgXAAskA/F2AAzp4bftQKdbkzP4UfUCZx7mC3dB4gFgx5FZVQtf6GkuzizCF+bDnzP93w1vvmbPx+ve90f4lPu8Q3HIE0tr5zj9ChPBVcvWGyWDMxgnel/Nebc/JfzSg2QdnDd2PzT+qBq7oyoTW/SXEh7QxPCieNyTaeAOJpPRF7HFNNSAXp7BcjFVoMrWc3Eo6+F/unegLUVa+wom5JobOAyhm15OoYFUYrvXSy68yj1BGi4gmkADbcIAXCAnsrGkqGv6j58ikhJncxz+6TV+BkH5tHQApwFsgoazdp117Oukxl7DD8NmrM55igKmqYFZbZ9c44nSBOcB1Y0dIyT1YXshypzrqD8gbe4Bd7+l2/HGJSk1x1IrxnIb/DgzMfx0p+Opy3GNszZ6zlHnmLkK1ovUVSjsmf+BoFZ4bXpEPvaiu1r+8Ln/Dx+/z+/Hv383+CNf/jfsZPFTaZkzFn0shGgtRTe0Lx0Gmu6Xxu1wSqTuNvdBNIO4CxWYtq+xEIp8cYhYETcHzaaRVWXQDlW88IWoKNZetUS/3xnG6UP0q4p/avw3YVsNb/4Rb+Gde1Y+oD2FWPtZlYbK1pf0Tbs2Zhz8TsrTdprBJo07R4INgpbLj1YH9tN2Jqm7YlJo/icp9lWWGoAtGlBacZO02QAs/cDDV3XNPFjocoSytmU9uJFLCnEHvjAe2FZFtztbncJihL+tQmgJwqJBO06l7crK03Fhr9bEC7HijBlJ+jZ50qg9QZcZ7DV2GXKmtrG26CvOSxDVDKrH7NafGfr7wlQliRbPNUL6fuyeUMNFqvipbLqEkhmW3uKlZhd1YC6wyra9QbtCyxIbGf5+54uaNkNNl/ImE1aeLS6m52H2pg1v2ZbSwh8U4KmKwXqri1LocIMziVnvXmsSPP67a03tC7hbzagxlzCswPcmUqV03G2VgRrpgzLk+AFZPwOuF94L2x5xZDVTP8bk7bN1wTo+sM/8AP/Ag/75m/ClVdeiZvd7BY4f/58ucl6YgJc0+Nvj21fv8F5khtXw5onsSmYWfSWPW/r4e43bcugHeX8ZwxEWXjBqv0IGyx95A9+74+xkwP2souAo0XGBM5sVqiEEZMAxP1JIpH/y7EIQD7RhoN0smg3X4c524+nsU2AVhFw28WTuZ0E6ZouJeZrbrIzc7YUcFZJchE/aNc2HJi7WoAKhrHk0Vf3dTkoB0AfCnteA5wzXNQZtIeHivYwZy+aAG3MGfP4w9mzM+ambtJWjwtwdp3xAWR/HEYH5uoTVBMaZM1dOzq69ys6GjokKqRRBI94DfGKgfPqQpVMouOZz3wxHvOYL8GrXvVf3NQ9UZXTCBXraavl67SiyHO2JTnsVY1X5MQn4ufylk8AbYJbU5h3hS4OyN1ugHa6CzQLaig/R0Ag+BwDNSKoC9XyOR/HZaTSCsBY4anz53d1zDo7Nu8NgJQTFbWaF8hZLK7Ce+WmL7oDxggFM83ZPheKe0bGYtHq6haGmktM0FzVQVmhts+tTwsf78VYs1knOlhONwC6C1pvtmVqAWYDZ7FCPxsFKQCa00BjZiBtdPYHgZvT1Zl7Lcod6VOVSRtzTgZt5nDmg/M7+bMC4L73uy9EBJdccgnueMc74g1veEO5aVeHKdvH3x4o8/F+BM58XB1rLq8d7Qm3ic6eAPkMx+BsAC0MBImvZ+BKtwntBf8jn1JMO2SAi0WncteeEX7mRZ01i3hBC9LmZE6yscDU9d+ArDa1aVBnqw3m34oh24wdT5hmvFKgRY7aEo0R2bYRex4v4N9oEaDGnExJixlTR8cyOrSvaKNj8UAvgrOwjTXM2y3Yc4aJSql6wHKA7QiU6e+vjfaReuxlOSXHOGcR/a3pC53ZagpR8y0bKI8Kyh58RyA2EcN//s06g7OxZsv7hDPpJz/pufiuJz0LqtwdZnI4ltlSgXlGzqszZ5/6m5Wurb7k4l92gJsYd/15+kEDkOd+NI3cZM7/4cBiOw1qCv8aFVxbsGop7LocB0AnuweQVqVg/yeugaDr+vrVgnO10DpQ2yYtw1izA7MxZ8v/H2NXL2ACZ3W7iqLU7RcD6Ih+7oCFs8MUnFVd6VYH9zRnq2nIpih4dLyRCy8o40GcrVvd+9YNlFuX2G0qd5zajBM7jqOLFogNMzj87q4IYC7NHD092nZAmfXNSA0pJ5Agba88+Bv+GZ79kz+O3/iN38QfvuEPNzftaIZfy9f+dh7vJ+B8TQO0AeaTrJkAXcG3AvMpgLbPZe6mow21PFkNvAswi4OyFSPZQQKcWR2MOc5mzja2VgK+qHWK/xTMpqeyBYoiI7RwFwIzCjDzOThtywsCoLmvzE1z4s3KQPpCDYDmrlXNgXnBoi2AeUEzxUMJzgRjCmdFpklZwBfN17IB5gBoB+OpqYeHlqoHtaCBpZkMLHD2jHQnHEfPlw17JlDOCO3ZrD2DXbLnZM0P/oHH4lPvfz8897t+FC/+kZfMrFmz5tEA/dIdDIshzNt30axdAmRi14GCABN9rKi4kZxAzAIeg9eEeaWlIrJdYeqBXw7WyklXKJMX2UhgngF6dLXYiFVdgGf0tSp8JzWdN9gqU0e7WOnITcGLTb2KAOjpOJiycFGkhWnxv0XkYmkNyZwdYKZx1g2TDNOvs0zuw+0M2vL/ze9s5WlZtMdONhU0Y4Z0z0SKoCDK0xrYyiQQNHqe4ki3gW+AIa0VcM4AzqYFmCeARgK0Zss547OqDC9fV5eR6vdb4QAtzH7JWJ6IUld3HzJhWmyuD6RDqIJzzmo7fvWrX40P/ZA74/RjS/Qu9LdTz+vjwkru1T2u3+B8wccWjMsxI7SPWslJnAB6BwPmM4jvogTfsCEKDtRoKyhid5mWwIzItRybtoC1h+d/CdC2mbkHaJEhaMoMygUzfRdTo5YrlwrSJ6bdENz85rfAX7zjL/21ZM7iQS4y5sYFKqO5H0pMq3afVBstFQ5pHtns1zTkeAvFCZwHRnffcu/GjvsK6YfIZa7HDPyyoC8/LpJZXCpHdLazjWO2XIPyNgANDSvGkZ9ZGZmc/ZTaghHAPDDwOQ/6MogI/umTH4oX/fCLMMKU3YIPdMCB2erGKbKkqYeUuWA2UDbmfMjnpXqSngqS0SqwUoAdi50ZmKsSIpx3KFYD1xw5B2PucXkY9U3MCpMngRlR0QsNUGfNYZL09/rW3el1V4uryqhgSf2s6mkVqCeAljS/BrMTB68C1AsSmJcypDQFhUmI45rXC7JSstli5jawFlhUtzqLXoDBjV2GFePJkw5gNkuCWmogRrLOoQb8Eb4+QF8Sd7LKmAgq4ATnAStC5NLFAbqpWXVMBhgwjwG0IRGvJ/UnS6tPwnrn4y2aeo+IxRM0eN1vVS/Vmky6e3yFbOd1aQPpbw5FuczjslrLa/Udtb/Qa6ee18cNEZzJHONxdccXaltgruC89TcX9hw7Li2okZtWGMHAmaw5tVX1v5FZ0+S9IPzT/KelrxpoRL8YozYz8GYh8LgCsuZpTqDtw/jyl/8a7n73T8YfvOG/4RPvcbcQoky3kqkRoO24Xaj1AsYNCN1bJbavbWUTCu2K0QekW9EQGd0BlwBs6VE0Zddja91ZM5lzRL8YY8YI1rw4QAdIF1DOrQsKMDOlCgYSlTFD6xJPYK7BJ1HpCRaJ/ed/9Ebc9kPvgP/0q681fzPWjaGORuslwHmuA8WYdmfPSubsFSCcQevEoCe6iC2LTlP1MVBnz9fKnFcFdwub2bSzZ53eXr/egLkZYI7mjFngwKxBUGk5Mu+AZrVMMfHcVVkyPYvCufGkZtPpKrOZ2/2+s1veECKuPqrLFMZs4fkzQHNCbLXjCtDcKi78v5IsevBckjkHkOvAGDuPxh4xA1pR/kRthtG0TRebyOKFEKgpefCoCwYFp6zagC4SvhshQHtQqO2v7hkkKhiDa1liW9S6gUukGPLJQGSLQBGZGo3cyS0UtlMWTCkRzQ1OGKfh2pGIg7TQmkCtKXMbpNwFAXDZZZfhfp99X/zUT/8MDuuK+XE846++3x6feu2GCM7X6nF1oHwiUrvsRXwE0FIBmlvCFZ+zwLRN7irO4tgtfTdp93F/tSzgHoQ12hUB0EiAHgRmFyYO0h7LcTxtClZIfc7jMoE+5mM+DgBwpw+7cyyYedceA+O6J3HrYnvL+2W15iDcZC5nOS1Wje8gMEtsSuGg7PWwxaVsMONeQLqvXhPQj92MLSNN2JTA3FWHNc6bzqAcTWKvrABmmw2Z95wuA276Z8CUY+oiQSpADxDWFLYP8QM/8rPQzi7FVecHBvah/3eBB/o5kMuCoQnOCan81z3gK9NKcCHT9mTe1qnNwFznUQXo7XFNnGKz19v2PaFESrDOqAc0zG/cOiJgkROGioggT1s7Mm1YeGWSzHlizziu61yYcxTC6JaNMJmsOQrhFOVw+XsGMspym7gxMWebCxLsGahpTaim9d48jcrZ81gmUB/8HhgjrAAtw+QM32MA7ZXVpCVA1zutQKT6DQA7P68uUXFH2rA57oGppBBDxQkCXHGy4+ZDRMCNIaLS5WPQ1MQficCsG6p70RRawVkUGX0xrN5+cfZQILLOOn+seNXxR2/8H7j00kvxyMc8Eh//MXfFzJ55A7HpL3SME8fb126o4Hx03acGsT4vwHxB0/bW77yHBHM+Q26izvKVCcKGOmTMUl7r3pxttwVTFX7aeOp5+oQPgdDKghbknOQ4jM24SOlPjpWPjAJP+I7H4Vse/kj8xHN+PF4Lsj9gNY95KdHUQZmNOzZlvnBTz5NsLKGBiCAlMKMPyGoAbbRn3bQD0A9eZOSQoFylblAjY8nKADBYABiQTNl8/HrEmnfifbn7kdeMTfKczrPLJBTlikOymx3UzbyRPoUBlY7zh3djYD+VK7XAWnLiYcAsXjPL2ZwZT5I5mzCyiO3JpH1UdzhNoZU5HwNzvnYamOeVRFA29wsmi028LhTABaCcRKoD9XC9tg4upzktOBiALuIbyGkB5zRrR6um7cqiI9hXsq/banK9VRmSztANMNdJIfPg+AUI58c2TeykJdaYM683lfC5EWyMA9ca/g7SVOWE9ziBC2ChEY25S4tEWAKWvEbxTXAkzOGZLMeKdaIy3drGm+dgXJNCJv1FXRSWuRXzwhX5AGc1cObOdAnGHn8htFDlv7mojf3+xRdfDAC4zW1uc3yzAFwoD+G9B+lx4rVrflz/wTkeFxqgCw1wBekLmbXL/sOS7FmcOQuZczVdN7fbRDivIZm2DrTVZiJ3duL7xCs/CcUZJ7r3DFJxQRDBM+I9cr2jrOEjmVuGRfwPoibsf/iH/jV++If/DeCFRio4yxEoV2DWqRmYMThloC1qGxfEgpb4vtiMYu3AupZmz7XPjWA9l+qs1ChDc2WTQ1OjPQOYpbJmB2lBAWh7PoEzQUfsTkU0jaRwGuL+O3BfIGpTbGGUM2CeSFTdfWgJFYJnH3NCGGjmZm0ZyNrCls+Spu4ZoJmclSA8twrI21XD5xs1EtxJ7Vj1JXOmQJZkST4szFUe3X9DOHb0X0rRXBAmcKvDfgzOq7qOtwHoiOAuAWJw9oyoay3pe61XWAtzE6RJB0n3C0DLtN50Xou+YCW2SJRgzgnaLRlpNXT4dx0DjzfbiguiI5iz2ZIXv5/Gs+OcQknSDZvXMEEj9i43gLbL90KtXrSkqV9wFa1+yD9t51KdKxWsq0Abza51eHQ+a+GznChiDdhx/BMNgN/+5jd87Tfga/7p1+Bxj/m/AITz5cTZXVPD1fT1cYMH51OPUwN6WoQcg3QB5qkgiQO1FLN2aMwKCwSzharLcDBegKUBbTFQ9n0HCdDayIiyrnTzfFYZJrxrekJY3qKJBdMg3FMnRG6ubUjKihAksPVAhZpR1GaS9n7YBhHLUCzdwbj7Prwy3C9L0zHL/HU0at6wpRAnOihFu5UOXFfoavnMo6/2vB8CnMdUbMTAJ3el6sdtAmZjD8Gaye6FeeYaTHkHOIvexuXPzJkzLGN9NFjEkCJExXxlDLIzgCVIS5I1daECBo9lIFiW7uS9NA1MPccV6rRTGbntrpUpPLkCdKBAnR2TmMoVlICdoFyj1D3yXhykFenW0ALcMit8CdB5XQPq89M+M3wuhul3Y9KO3diA9DkPmrdlLhlZ+q1Ze2bOze8PbT10XbmlS3lcAJqBk0TlUxXEUK5bganoSSjgktq1Kwvha9eyTqeZoDG/AQKza9FjQdplihwMJaR86RS0BmI60OC71Nm9ag7UKoHBMY9jkmjqMVtdJ1NKj9dUwJ6fToOB7GhqlhUpwKwJyYuz5vTB21xqOAbo5//k8/C8n3y+i8LjsMbTeHFdgHp73/8POGMenFMDdWrAT7NnqQxaEpRlAukNOLMcV4MHVCzAYoCMpUEXt/8uzpy9wPxgj8rxkAxzAmfxursudMT9lJQtw9d7BemyBk8OlysW9J1OozQBtAFzG1b2cullaz8ZWKRjQcei3dKoRkcbTCNTC35LJILtCUtwXjHWFWM9QNeDPe8HA+qxYowDtB8wxqGAtAVCWeveRgDzNKJMx/CFPe0jDG5q4T0I0OmDrmbtiAUAXEBYYJ5SoSqDXTe1yBKXKNoRgRbBhs1Ex0CvYtIWwbzxhRZgdkAXj10mi65lmmjmnPx02RKYZx7hKkgA8byKcoOWVHsJzBnVHqBd5nUohZLzdAiM+AcgaTDnCB5r+d4Kzpaam77nYM9cKw7IkW41GLFdLVQtAPpIZpA5Il1Rwlrzx5tFR8sxrMOdF51++DYvWI8vCYIYcybRWl3x05JOZMDcIYOztmOGwRNgURkro7WpRPGymEcIA2fWXoLrJwqzZLh+ZafPnyPYE5g5L6SuK/96NaUg5rmfkm12gpgcNjS5vuz7/P2wkru27ib1yGfzJPymGc1ZPSlmR5hxCpgvhD83aHDeDsqpgT+lEW0NcFvz9pZFe6CYJGBLmLAVaBZhKExDWBYDZAdmXQS6GBiPRaBNCgOQqWhRL3LTZK8l+AdzHg7MHdPnNlapWSGGuoDfDJvUEXTwArzX3BRiOFveALNt72eVeYwxW8GQtkiYvg0UfeydOVvaVAecLSdAG0jH8QTSxpSHOpMuwExQnnyqbm6IXXWEBWAqQCP6YMwEZsnobZq1Gxww4PenjPOARQ0DBuIUHGas3gC7fz66WvXJa2sHSDj9uOWtb45Hfts34PnPewl+67d+L4BWE6KQCbT+2gUBegvMqTHIdFzM08AEwqfBONmz8PWy0owhSQZIjToUVvkuFJhI7fHL8fWirc57mdjzGA7SBOWRgDwGjDUT7BkQ5mivAcwNc6EiAXO7ZAJi/3sWMgDg/tmtzPEo50kbidbieDbtmmOE842sWWPy1V2XevQYO0jrwBFAb8+pTgOfxIu6UuTg5kBJxWzALrupK1PF1y5y/HXUByLQVPIjU236Mj+qQsLo766k1uqnnqZrhQcVau7UN1CBOefvNqfgGHQ39/3o+LoCdMd783g/AedTj1OAfXwzZGLNfiwFlIU+5xLJjcX9zQzqEqRjVpMdLxK97hyYF4twtiIKMKBuXh9AUsjEDHfB0oarlb7GyJoJ0B7XAicCYCldZm5Ui9U0NMgFJR7NQ39qTlHPB1bFMkbssbuMgaV37GBtUbbV06mQO9pwZbpA0KiVzE0szJQ91hV9PaD3Fb0fvNnfegA0zdrdN4n3RsGE4eUIna26HVVKo8JAYF6ap0tJxsNU0/YMzgDzmsnuBkGFkfUwYULQVTTQDz8ZGF3YmpnO7YH+fgPUZuzZBfrLX/kc3P72t8EDv+6L8AE3/liQPaV/3a/fzdwaAD3Ke04BNFfKaU4xi6+ZLc/9vNVpBez4fMhYmRk0IUdpXbBJqx54NbHmlpbuAGh1cFYDZ4Y0EJyn6mCd2OfPg7YL1H9EJyHtP869zIVyImilK++UIfPI2LwvihZoRdq2xsFAMGdIGROOk/rMHHlvxdYBSYYOi2+RcQR/8b3l1h8BtCIVAeEdEkQlrwFE3f5qzagAXUg+PFvUA8wQ+4M0RM2TyJGu4NyciJiN2oGZPmVJ83Xsxe763OlsgqOs/JitR/f7atsW0OuKQemB/wPOJzWW06AsFxzwrVl702SxnMGpuZYc5bkMnLU1yCJWfnBHcIYV+FnEUhgDoGmeLiulsObmWn+cpgOzCr2IOoPzKIJrbAA6Fs6M0uL/mxjlxJy9opYO7IaDc+9e94vm7NUqfw1zsdMvLVFrPAWP+klx+8fR6Ws2xtz7AX1dHaRX9JHA3IfVoR5sSGDWAswsU8SqbBDNvWmbA/Om537NufvUlGBnu/2AeO/iS4HhZu2u6oIBRUJRy8/wsAB5OCCqwmoXm7dViEQUpOG4I4AB2g6FnhzZTkpzFh0A7Sfm5kGy5hq1fSFVNnnEDMS0O7EW/MSedWbe0YZjWFj9tJyBTVa6Z9CAwbznJpOL1q5QIoxhuGk769lIsmfFxJrjSxQZCLbd470q7VoAucqE8pqgJXCfBOgW4CiBbHmvtVhlqE2HpaYICHpWRamU2vmocsc8EzLaXMgc3QGAjmL6cMsP+xzhZPdLIJPFZmqemK78ppz0PtZunp78ziE+s64DBuc5AVvj+8PaFetIceoKM3PgFCbkjNZyr7KiQcWFawLpzbj+H3AGjkF5OzjZn9KjjhfQDNLGkk+AdGjMLUDNPj5Q6Ze6fVR9W2jdAWNnpiIDaEV3wKgSnTI30qYXWEF5N52Hzw0E9g2DJjBXgAaCQeejsCYGbQlbbnpvIGzgvOjAMjoWaf76ikUbduo1wYdkapUMNOZ0OziTbVrlowTnypCTNR8KQHf04YA8yJqz8lZuo2iBUtxNh+q4kLZ59SmpvcDTwJJB8zbSxB0bXBSZRZk2m9+QJtsY8wFVq/jrqZ0YWkK9HCRFWSIxmZUdA1DBfe9zf3zrIx6C5z3/30PaAarlBFhqawvOFZg34b8i84S40ArJALATgBzHUeDx6H02XvMKBFCEdmgxiLKequln9r5UkfX5X+tDzQAd4KwJzqrZkzEHc1ZnUmTNR7vVEXQNpIVg7VY1yondzmJT1p6jMwO9oVm8HuzYR5oadAxIXapazmkgsvBDcTiR+DeaTe4TAC31q4EEYpcBOmyO0KgjOr+/ArPWIdtcAgFaegIzz4BgzKBTW7a2+KrfmqDfyvoMgFfnvjJdwgTKVENmppwYMCliFzy+LgDN39sWOrl2j/cDcL66x+kbcxqQt6+laQquCYuU1xyYJVIoAPEZo2WtsNdFoXsH5h0gixowRw3bPN3ALjdnt0U9/xPTxJ981LXJMUATPIKRnBgpA2PXQoNBDy+7OaxGdmHPZs52gNbVdm8awBKpVSxPmjtT8+RN8PomEKOj9+79ipWAPA7Bmqc2seb6z028bsrW5gBdrBpZFlL9tmrmaUth0uKsWTbqmm7AeRhjJnseKh7pLilMQ5LRIDncPy3heoi6yPDIbgfnLNtqaPTWt70Zj37st2MMhG9wNo1U5CEIb4B5G/4rOgWxTXMCW7Z8DMbL5nhmz2ZZsmhuCTI2PQagnsMfJSXVA3vEjiPYMYZCilmb41j6GBqZrUdj0xf/75RCdVScyI8JynBtW3YQgqLs8Bn3+Ehc/kuPAwDc57N/EK969RtNhdEC1BFLQGD2UQ2lwEe/WGbyEapdfC5YvmSvNTwarsmwRn65AwnKtTO0VLHULG2aU2ZS5mdw5mXF0G3ucd1OM8HZ1spU3MicxyFmh1hP83YtnRtgLAXo/dzEx1Gm/9OcfQpkN6QMc/HeC4N0EcwFc7K/QYLz0TLfvH5hr8PMCWYQDtPUCS10Zsw2y2r9EJnutxoo76wZMGffd+o6gKIXZ0tEH/p+rNLz57ieQ17DwVlKooxsWpXfQCx2mra3I9ScUU2pRlBnzmJ+ZThL7oUxOzgz37k1AvPiATItsErV6gWrDmPDvTszXmdAjuM+m7ORpTCDNYubtOljbp6a1JCo6o5j8XGf3Yau1ROoCdIoS5dYn7fLFQ0Tol3VTXPOAKr/1NkzATrABIqhzXxn/vkW/msTqMEmXIhB/DuHKVUaaERfO4tTaFgTwF59fKop84hxbFePlJVSAbnFcX1eAVocoIUADYSMp3E2gFn8VQdliwfTmTEDmwBKT5ajwlN6GxKZrBthKtccDgNDQbLnrcAuQaHckY6gy7gU3eH+X3h3tGbIdP8v/Hj8+iv/rHyumMUrqPK3qcBSeQ43hiOd1qSgUKNT6ARAS/TT6labGelGKBKUt8WB03PYMEeW8r4dTZS8FF7mrAPE1EMvnyF4ch5HSWBNMPdLoQtEIvsDmfZZvhKbnz02Z2/Z8inGvNv02+MtSG/BeXsmB7w3j+s5OPMhJ44rWz4WNbEQJk5wyk+0aVKSRop9Js3amGJGsJwA6H0CtCwGzEogcZ3OwBlRcAyx6XnAt5tGN95FyQjuSLE6Ac4zT9KjkarZtQbQI4TtosN8zEOwiIsrhaVZeTR3kwHbz7k6y0sRDTUFZJA5j5HgPDrWsWKdGDOB2WrpskXRDtf0dbKRIVnyoomutS/3qQbgstRgQwJ0fITgXEmos7M2skpi+qUBOuHUg73y3o1ijpUAahkEaWN+AdJ+oynExEEsBKmUmz0KAhVQLojk992DwELYbRW2rbk62zKBc4s+3+PFHgnMBEJJJuaOCMcMM2Uj7qfPV9HZlL0BZh5rGUsb4xPAXIYgjnmPNOXDhDYE4zgudRDUCxJhhyd/10vwWZ/1kQAET3nS5ZCRnxOcAuYZpNVB1NidKc/BoMudmXJzY0x9fEuhFC0oKWSuVAYI0uLCgxYUB0sTRCkwZnubnsa4cona+HH/3QjG4Fj7d7sJu+6cNekb4nOHgMxzpowPoN8+/M1S7+ss87Mw7xaIayjo9nhzoROD3gI08N7C7PsJOAN1QGR6jUenQDqBtoLxBNRT+oTf2JIyEfYT/pnAsJhZFYtClmEAvQwH6AE4OJsd2MAZLoyaBxWx6EeYYqnd+jUNmv5AQV8SagjOzX1sqACt09hUU2Nd+i18or7HNIaDcXegcqE8wsVu5ywE5zGNK+OA0wSsvmHBCGa8OghXkO7K1xygYSAd/8SLcRCc3XxNy4UpSEh03elmnWm4ErcAfZTqoYU9Ty5cDYbWRrLn5uwnYv1UEMUX3YypBGkVb+rmWDcLe+T7CGbBmxw3HtzFx3y3JxCIPt26MjzAJqzbwIaN1MjrCsgzEO/ieYvXG5qz54BnBwwEGLIZNth5jgzljvWgomnCdkz50q/5Sjzi2x6Bn/2ZF+FJT3jqhkF7scoAZj7nsGRMB4eBSgN9zhVx5uDQHUTJnBOgefyOt1+Fj//op0C87G/DfgPOKdhF67qQZO0cFzWATqDO9V/xKI4DmMuLUj5Ue2eiYVARpEVG+DcbpJgrWgIF40CPMEpjX9U8Yyqw2ikDNBQE26JSwJg27f4D/kPmlhfMP57nejwgksdHgDnf2wrMMlXUr1sDb9spBs3vPQXON2jmnI+EZx5dEyhfCKTL8eR7rqBcfmoDCiID3HZNGwF6QHfDwZnNQcTbFCG9CaAAEBIlXIyYmXMIsVFauzBrNtOmlOMcIdFyLhg2DbUIaO1p6gWioIc405bCmsObHeehAdDGnocD8ChAnIw5WDOs2D19zLUwPmjCDgSF+fyL0qtbZdiD86YdQH2tTcXf/EqWLThPbl0DVdudh740G18y6GASYfkw5rxzYO7OlnNbTYmt+JjrniY+nx8D0F4KNNDM7YBHv2GAdMkKkI1go+zL4K0ZmMmGkzVn25Xj5r04QId50QE6ZLMrlfARybQydbJTik1ImrSf8N1PwI1ufCM89Ju/EU/89qe79YF1sjjPaNqWmPtw5bQeBzBrkR1hZt6atTeA7CZt0Z2viu17jpnzHL2dsirwM9ZotZG5qyI0CX+H30vh+0LhqoqXFvmB+C5+jcS8QBhW6iYdudFGnTR+eArzmk4udfr1lVeknrniQX7axKu+0UXoWjHBWQycFbWPq8A8ItOZoqgT25PETPeL8oU91AHaAJtAzb5q9hcyb6P0N3jmPOsq9lzKkVygPyqlYM+lTe+btKEy9mFGLYJR6vZNbQAOzFgUY7F607o4SJNVO4hHQr37nBk1DZSgjNJn4ItjhGDKgdY2m7SBXLfTQ91oFpdSKoMRoDVZNN23BOYlQJziMVnzlORQlIQKzsaeaa6embIB8saMjXQDDBfgVHIyGE+LXFUD5hPVWPWEQhybjXkj5jf4LS3gHGkf3jpvP5mzsmgJ854dOKDplnDQ3/m97CO/3ywogtbV6k93MQWi+0l1n3sDZeehOlGQJkwH9ToBIqAmAHpeN/O/BF72CcxLHAc4o6Fpm4pyEJhVUaLFc+5PtZMVcWIldgu//Zv/Gfe896fhjW/8M4y+T5M2ey0uFFRg5pBoBjiVtVHNn9u4Eym+ZgIvtHrcCyDLbnqfpcmRiR+bQfNU5nSyTMGbi+uw8EgUrpGEKi1Bf3V8E8543/09MV306LU6lUw22PfNBFbLpUjgHlO2IZoKEhBBY0wjtfLkYsFf0yYbrshBwDrq6dI4AcyS48gzy/5CrPmUKTs3PJrbNTHoC5m2w4RwnR7vB+As5f/1+bbns5kPzABdmfTMqE1Sz7+kfObSWeGA7E3KThEa+yra8ViGsWyPoiJzVnDf0qxkFT9RqDKDWhjVSvN2ADTBQtOiWdyMoLksroTsWRnIxOblOhVzw4ljX/yWGjRHk6YZtyoTG9O2jgLUW1C2rfBoxg5x5eRD40QQ/n5LXVMD4FB+LWpet8rwUbWRDUD7vSZjjr3oyZ4DnA1IiZHNQVGme+BcKKKLkUCt7ulwq0eAdGcTY8srigne3B66upD0tEpLhclVocPna7PzzelsqHf/L/li/P273AVP/a7v9gCuLWue/y0FkBOY7egj7vrR+Kwv/Vy88Lt/FO/+q3eZcuL1HoPRCsqk5NwvYtd95PQ5B9CK4Es//xtw08tuhrf/5Tuh2MNtNQjuTXAuPxEKqmr0VWHKRzLnNG2n6TMBd+cgvJteb7AI7k0Me5E3RXjz3GIMCDbGklMibBurGzhQq29+wvGb0ueGK98FoOUYgI/7vA/igxQxe0hOWtdIangSlzeBspI4SOklAgWV0tjBWUXwYR97V3zKZ38RfuoZ/wLvfPs7Y4ZUsK7yrzJqQMqZbpnzNjL7NDgbkz7DNQqMiT3H4irPr9vj/QCcJxLgz2fAngG5wvT8L71rFagv9KO+qAUAjMWx0IVFDNP+WI4JzK1D2kBbBoYz5rbY54ZvzCADVksWMJ9otWEvFjSjCwACneYiKPX7J/P31Y1dgD8k2KBFCHuglPu/o4wnRqQUBUvEUtKBHJQp5JSsiYE6WkDJTdsFpAnMYcoGS4xsrjH8koj1JpMyLNC9lrUmwJkeKcV6ikE7nky6sBaA3oAza32MkYqLDB9TdaOtKj74Lp+Kz/nyJ+GXX/Z/4zWv+fdOeEu0u1pwXXd9Trr43tcEZrHr5I6QRYnQmrUx2zLtXg/SHVctHbk+6ZM/CS944QsgIviwO30YHvTVX1fM25U3yxE8NwdnAvMOC/7Nb/w02rLgUz7/s/Dgu3yxrSVtwYQErjRG6pQpXVZ+keJ15Pm7uYdKjULwl2//GyjONoDc8jnSVG2f428VCAxkriiZ8qCatuVU09kDL1gsrx81XK7krhezp8Sv5v9pck9YTkAe3HFsu0f3tmxrPE9gjuh8jm2sU4KvJiBPvZ2Yi7kE5vJ6AjbnHa9mBuiIopcC0BD0AsRsIYPbgu/9d5ejLQs+4TPvi6//1E+F79AegYCcKVtg5nNEz7GvrHlrpt6as22rYAPoUyz6VHDYljlfDY5czeN6D86nYLi+XoE629YTfRq08xvL4NKnBwoLmxpZmWoLyj2O1Stlqf99OLuW5oXrm02tAQ8CG4h+S1U1em9L0bovAMzsU+M1c5PMlxY28mIEAKtssdyiveZTsSzS/FHatay4QmXOjKBNtug8QM2fHMAc/mUNM3Yc8zr9WqO+ObNVdoDsBCAwnxlIq2/JjTMYg/b+SCGuYQZAVhoq4FyMIRGkZeDs+c5FyQGSwT34cT+Hiy/9AHzY3/9UvPZ3/j1YdrJrGFKCMXMbcOmCtgKyiuXJHxDsXlapAbrZ93rH+XCK4TUOeff3u328Y392drQW0tN8zJvJnZM3L/GbbVmww1mAEjfwcFXNcNfvbXO3Re7iVUCU4xfCvrLjtunnfOGAXo1vAjR9uQH+04PSgcz5Qu14XEQjoSz+RsVmezcSmFNxGAWazZfc3aLQMZD7do9pz24Hbe3QAtBTiRbPHwubgiRAi0/QyDCowBzrOv/G1zcevSOPSgXmFpaijK+okpj3bYT8tXGkktl2e69FKF5FHAWo5zYDdf3+GZyZGsdAMAPlXTmuDPoMCJDesuetLzvn0Hv7uN6Dcz62wFyH5hRPnspinADt+l2zLqZHfZqaINXklH0W2rQoZgI0n9et0GJKSQ3ywZTnHD4dgnNdDA1hzgyTnl+MAFFar45VdQSy5jEmA4DaMejZyyGJ8So+K4uIdV+T95F7ilLJCbZRhAE1TdeajBoZoWumUB8hUYvgjO05FVgkS6C7CZvAjDMNUMYZgHM8dgA/wzF7roowEpjFFZc2gIVGkUJWWvf4GvqjN4LqXe/6C1x86Qfgqqvejd0lDsqorBnuY7YmXcyM3QVy8OPFAfqEuyvvMbnZFngQEbp816t//dX4Z9/wz/ARH3EXfMe3PT5XgqP9FqDnsLDKmc37/Lh7PxT3/LL74YVP/AksOJtO0kiwgNYn9XsvcAVQZy5Ur+GUsJ3BOaOfq2k710Jdu84qeey/MKvztRbacQ00Wg4SnOd3SOlnWZMqs2GfnQcT7RhZIdF3Z84JzA0rFAdo7NntrTBoia1EmT2Rpu9wYQniONaz1vXssoDD5Lcm3j/muW4xDeLKEBUprokCzN5bARiP7o/iOz6hu+AxX/nF+IzPuz9+/HuejhU7Hw3ffYyyZD61CaDzrtr9zAIk22CwYxN3gvXWzL1lz/y+ytApXTm3rtvj/Qact/rJFmDz1myPZy/zMThvBYTd+hmq+9SkHFdQno+tOlZEplKz3QI0V0sVsH6CLNpAcAYCXw2wfHHc5EY3wSf+g0/GL//WL02fn/gUyUMsQM2NbHgZKOehjlR0ZJaXmV5koNzcd+YpLmzlJwKEY5FpiJAB+hxp8tJyjEyxiGRkcL+S4jrSBOJzCpwT6DkH5HMIVl1N3FvQiznhQmhizmkciaCwthFY1Svxr77vY/H3P+7L8J/+689juSQD64w1lyhtB+e2WpMVZg04yMScczJvaMwpUFbACudomQCmmD3nOc9xAQmvie2wIi2PCyjVeG3BDq201//af8Uf/Np/87+fwYQemZGfsiKsIaH0kd0xDD6qhSBrcsTKmEEZG4BWSGiiFdp1nujleB6zatqugVw1g7uqKcelS2vERfbgXJoUhWrGpu+dLYGZ7BkOyjyuDFqcXcu0f7f3VIJAC0VpFbDJlOuwlPlc0XDOvUfKJ59rlGRMBeyhcYtvPNJ8znvwoDeykNf9xmvxW6/6LYy1weoSGjivcYVpH6BFbpbYddRP+5wTlK8OoBOkuXXwZs86HJu1Be9tbe3r5Kl+6lOfirvd7W648Y1vjFve8pb4wi/8QrzhDW+Y3qOqeOITn4jb3va2uPjii3HPe94Tv//7vz+956qrrsLDHvYw3OIWt8Cll16KL/iCL8Cb3vSm9+L0j81Esnm1AnHD8e3JuD0tt0b91mzbwI61pbnZQ22+I5Mop0+HaC6qjBribkFevhKFMWoGSZkvMo+Dn0sWGOkl6rE35IYaCzCcCf7R//MW/D/f9zK89F/+Spp1adI9q6ZeAyj1oKmt9SbKkEYNS2uxD7GLlYgu1WxjaDZ/3pXPgT40TLujgLgx7g0zYhkvEdgOYALxjUaMPQuwE8hegL1AzgQ4E8g5AOcEuAjARQK9GMDFsP4SQC8F9BIAl/rxpXZcm9wIkEvn1i4F2iXWL5dYa5fk8XIJsMTfBHp2Hv/595+L8+2vsFwiaKXJJYDE8aZd3CAXWQP7cw1yrgFnDbJfgH0Ddt6WBvEtS7NGacNU/qykBm6dPfNxrphMCcoAqeYpKBK5vdY3nEFwLnrBGRrOoeGcPVdv/nf4e6BnEPodYsJaUz2Davol7PgMqudM21LXuvQc1L8T8OcaJpPSZlaUJpRjplxN1GlPIGRvk3JQxHrKkT2Gtx7NSuGu2GPFDoejtnhrOO9te2xNHJybrgFfTQ2+mg5YSqS1RTVknSmIpVcvB6D2fMfnJdaCyqn07Bm0SL3AdnIV2z+7A6NLtD4EfTSso2EdC1b1fiw46ILD2OGg1jgyq+6jcfQ4kkP3GD7CbNhI8GOmvLWMVLBu5fjUZkhzjvtxtHd9ft0f1+lTr3jFK/DQhz4Ud7vb3bCuKx7/+Mfjvve9L17/+tfj0ksvBQA87WlPw/d///fj2c9+Nu585zvjyU9+Mu5zn/vgDW94A2584xsDAB7+8IfjJS95CV74whfi5je/OR75yEfi8z7v8/C6170Oy7JcpwvYAnM9vhBbnkF6Ln8+e66SvyWn6zAt19M0VDHC1ES2nPsMD/qBbGYmMOuADp/hg99t2mzkK440Nc2h1skDAGfQrfxJ829n+zNcdHYRAODDbncnA93KnAsbCSsf/afu246AKx9ZVQdp1RwDSR01rAH+tx6FNZwtq6sqzpTNrF1HuXAaaTO3ELgdbjhzVC/kNAyMdiO3294D4vJX3JQtF6kDtAIXkUkDStN3Zc4LcpvdGHscm/yLcDK/c7oF1Jno4taCI+OoZi9u1mtDIL15AJhA1gYcXOGIXThkmshZd6FwhsoQi7shzBvROAkKwyDDVkJPsuYE5iq0KKj2m56RzXPADOeJ9WnKFqlrLQYxrk3LxE3GPPdW2EXqbIxPTzQwrFmuNBcmLWW+U0E55RY7VvJTuW/Rj7jq4iWBxMz2AjpRWCfL0/bCgCWOkzkDBwwcAG8SJu5KCtJLyxbqbmXOCn/u85wGmBgaTdkQqXybVtYJmpRCYMacg1F0gfYG7Q2tN2PNvUFGs6pqowG6QAe3TLXWtbnlTVyOzLIk0xPzbs8PuwtaAFkLSGu5q1oAWjfgnZXFqu+6msyr/fW6YRof1wmcX/ayl03Pf+InfgK3vOUt8brXvQ6f/umfDlXFD/zAD+Dxj3887n//+wMAnvOc5+BWt7oVXvCCF+DBD34w3vnOd+JZz3oWnvvc5+Le9743AOB5z3sebn/72+OXf/mXcb/73e9an48UgXJswp4D6GlW2izh0jhpRxxnYUBKXXG5xbw99xFpx9AVogeorhBdMbw13+YQw3xBOhykRzdwHtVWZCyUM0qGZs3kanlDwWq/cKZnVn8yBLgK5/H4H38M7v9p/xiP/JFvnsA5Fg6K3Ca5pz978x5ujTgUUX3MBJmtZPKswPsAZDYpi+vYZ6Qukmc2TqGsBZgF0sQ2t2hwxjwsinmnkP2A7GHtDJBzcOaMBOYTAK17jdznKINcx5T+Np8WsmkEbepdtP6bFTmFcy7fGZjN398CnLE2YBXIvkHOO0Av4nVxZHN+szEvb6qUm0vQHgHAGbnNaeNMuuT8Rk3aCZJmBnGchlILd1SfXB1Qql1pSQrAFM4Ivodzv67u3OLveDODU79VQDjS/ew3Qz2MvcATllNBKfJEUn4sZKNT60Vku9hXnpHO4AwLEDWA7g7Pdk7djbg9zNTGikeYsw9I37MBdPU9011gPmdusOKyzk3bTWeTtqimmXqcGLYOPOSrHouv+EcPwr/+6e/B8y//YXc72DySxZUoCSN6AWcBVoGuAnWQHr2hjQXi5j+h+U8bdBhIW/15bw7M3B40g8JKwCj/TQgdqy7my9YJgbhbnF9S3iMbAJ8/J+U9+XvXyUAdj/+ffM7vfOc7AQCXXXYZAOBP/uRP8Ja3vAX3ve994z3nzp3DZ3zGZ+A1r3kNHvzgB+N1r3sdDofD9J7b3va2+MiP/Ei85jWvOQnOV111Fa666qp4fsUVV0x/PwbmbTulY6cpu7kmWU0+YZbG6gNuOSp2u7l5AbzCk5mvDZQPgK7WBgHadlyCb4+IniG+KmXGs3gAknlW5X6SvUVYBUDXOUCgFuD7f+7p+P6XPN0EuoMz6+NHwESV2c6aB98jG+V5zKZ0DMQi5JgbaWMQmGu52rJH8T1XgA7lJwE60dCtGRlCDm4flcAswH6g7QHZK9rZQDubAVouAuRidfM2aAHNKO4CzlrGYKvAHGWzOEBrnKK4sJNkIUXE1zCh2L9ZJQe2N2PNqwCHBuwEON+SNbOiUsyBDTuOk/WTH2IWBgI2tQfxv3Me+eRRB+kszFFX0Gzi2/rkEpz3zkAyP21Odwl1DJm3u0Dh24FWpZVKGgAKzRmYj9lLzu8LseaG3I2hI837ybumOyY5CtXDTYBm2zkwp8tsmLgXimoN/3qmSg0MMVhuXnyHcqgHY+4JvsXfrAWgsWkpy7qZtgnSDtQB0ABYfCgDwupwCWLL2gY84uuehGVZ8B0P+n7821/4YUQlMH6mUQ2xNS70MxOQ14a2Lmhrg6yLtQrM3lTZHKC1hVyp0dqcPdt/k6yMxbIp03xSqast14ZMx3mN9fsrZdTy+evyeK/BWVXxiEc8Ave4xz3wkR/5kQCAt7zlLQCAW93qVtN7b3WrW+F//a//Fe85OzvDzW52s6P38PPbx1Of+lR853d+59WeT2XRwMyWZx27arrV/FT9Me6nkTQjCWgey52FYuOCqPd8QNcDZBycKTtAjxUyVmhfIYvRKu0lzQoDsS8vbGXE88n2W54XOrsF6QrMQXhqYQ3HALobkzmLA7MkTnARsMXG9YIuKJV8xCv7zNpnaLsBzg7QaMUsVUzaSoBGWVyFrnrNbjq9otDLMmxsi1m77dWZ85jB2Rm0XISJPZvr0lOuaNZeMFsPiG0M/qJfbSUwy2QpzXimCnIV7Hxm1g1xCzjr2ow97wjKLX3FrIgE2I8cmUCoSXlbZAZlBY5M21omUYBb+vpV897W1ZRRGjVag2UQ00+QTqO8vxGrgBZApc5ogwdpNUrneVWDsiLZ81SVro7RBMzlXsTbKFZrYCbCOiTlb7EhDDrq7lzVs7mDIhOrEEV7APUCQxmfkebsji4OzFrN2ZRFBOotONeo7TkYbLYKbqyG6kYYAvOI6WWGhJbzGV28YBLwxj/7I9zxDnfGH/zR76KtEtOvbg1JIaOw18dokCHQ1axDuhpIS1+ioe+sHztoAehRAJqxKBFUStnB+aTVsF1j9ut9PgXE9jc58Yn6UL8q3Xx//X/+ztV904Uf7zU4f9M3fRN+93d/F69+9auP/iYi03NVPXpt+7i69zz2sY/FIx7xiHh+xRVX4Pa3v739ln0a8OFMXeZItMSkTGBO81ND99e7txXcX4fmbMCjj6WFidea1YEWXQE9ZHOQ1rFCRoc4a9YI73X2rAosw0zY1ZSnWmddtd3QFXf8mElOmKdjL/aiIE6gA1t8o5n/VCU3CwjTdAdaE3Q3KRMkllI4gN64yWGgS4xqNAfoqgGnfwpRM5igLMxfcmAWcevD0j1CpUN2Alm830uYttseaBWgL1ID5ggOUzs+px5zJLZBCZlzuwA4b9oofucxxN/rPa8LCS6WFtYS8LSZj83NeNobsC7AoUEXb62Z8jQVXEf+QJg2vO/DarizpivvG/0RwZ7NXcGvDPDTkpoUfQXo7WraYZRAMYTvOVntNoojd+NusLgNi9/OAhypptVJPisHlQXxtwowxB3kLxdhTKvDNJi0YqWYNqxhKqGBXuxbDSaWpVfSRoLlTK3ITJSM9is0pWNAnTFb0Z3iIxafXAWcmU5F87Z41HaCc2HZ2iOFSpw1WwGhEapSEw1gJmsO9rzRZbTBmK8An/vFH4Fb3vZ2ePNfvgnLzqacct6XORpR8yoej5EumxGs2QF63QEOzGy2Hna5NiaAzrRMA+VU9pLFVDaT6heKrOJdTiasDqvV/VAHpLZcG/berWI48N483itwftjDHoYXv/jFeOUrX4nb3e528fqtb31rAMaOb3Ob28Trb33rW4NN3/rWt8b58+fxjne8Y2LPb33rW/Epn/IpJ3/v3LlzOHfu3NHrsunzdUUVJVvWvAXmPF6RhQhrpiJcgNHkJqDO22HgLLqi62qA7MCsBZzRV2hboa1DmhcKoEl7cYD28p1wv7OGwMXcaPKujQNxipzNwYlm/hVfQPEVvqhGbsfXKmPugrEIeq/A7GAhzTY3kBrhWJ0GDs7a0HVxs/YGoAnSE2tGKCtAYczSgbZAWncm2c0PuwwPmnKA3hkwyxnQzgyg2zlAzsSBWksEt0Y+tDJgd0nzfQw/cS9DBwKQLYALDs6lFT+7XWONaPD0IvWZOZYCzgt0XRyYF2hz00eYPCTmiVKJ6wRlTQsNWfNwkG4CbWJm1Yk9a7J8zgkqETqruXHeJ+xOA3PgTANjl+vnj8E5M3u7f38vovFCzLkC8oXyTVEWCpGGa4bfuHjvwC0pbCEJpiSDNoONiGxBOW0IA9wMZIfq2XQJolTGDZQVA118RSgDuOg3JkjP4FvN1+opVNXPUgPBkin7futcoarmHdoAMxm07aus4cqpe2u/7c/fhGUxJVQ43zuVwLQ1AO5zVgtyxHCXjbtuZF2ANZkz+t76sYPqDmqpIoVBc91U+K3A7K+WQL+UduSzvMfpkuO3SPS1pnn3uWXHGp9F+WyLV/KXatm+a/+4TuCsqnjYwx6GF73oRfi1X/s13PGOd5z+fsc73hG3vvWtcfnll+PjPu7jAADnz5/HK17xCnzv934vAOATPuETsN/vcfnll+MBD3gAAODNb34zfu/3fg9Pe9rT3quLACoepf5TgTn17CpCqn9odVhekWX9PUCHKqQuzppbVLYSj7AU+pn1AIzzgBo46zigjYOx5+7A3EybzWhUAx31PQhDDIXfudDXOu8qMJ8aDLJmZ39SZJly8YgLO0XmDiNBuQ8DY1k8griJAaI0oBkoq1CZWdysndGNMcpKkE4WPQt0luLbMh1N1ozuJVK7M2cbTywrZGlm1vZUKtn1CAibAHo/IGcNcm6kebvkPEeGzk6gi07g3GFEtCtK5S5EykijvByWOjKGxPurCX82MpaxcMEzhjUD5gXarEHcagOPRqapgdMoou4GsB9m6liaWxfETR/iJy9BIFU4xpq+9aNV5SJeJBSJOWwyV1WGQU2JOtiCe5ZkzdDLLd9hrnvyZ4rYWdXexkhfGJyLKi+ai6SAcviYnVELtNRXH3OtdalOHJcvMtCwYKcLmAG+QMwrodUb7pCiFnsynNF2kO0yFdPBQMx/ogWcpfiVM1skTWy8M7MqVewMalMjdpar4KxiUfTDBkN7EOCZL6irO6HVi8er0OIoOV89rzlcN86YZ2BO1oyxh5JBh+958ehtSdmlCc1M5eS4TVXSQNW/Muit3YTvyQ1GbKY2WDT8lg7y/Yz4TtC3x3pSTF/T4zqB80Mf+lC84AUvwM/93M/hxje+cfiIb3rTm+Liiy+GiODhD384nvKUp+BOd7oT7nSnO+EpT3kKLrnkEnzFV3xFvPfrvu7r8MhHPhI3v/nNcdlll+FRj3oUPuqjPiqit6/L47SvWY/ahVlzth1WLGqAs6DG6vHmuklF+IqBcw/nY5q1dZzHMgjQK6SvaM39zmTOXEQM0hk18MWFySiBYdWqQlaNDT4Xc0IlWCXYNv3PSb4iRmjAonRlSWDuzXzJEzCLKSrNBXKTxZlzDRJK4161UXQYe06HQk3uQFxTKEVQA+MJmFeLCWgr0BqEAO2MmYVIZA+04oNuZ+Ig7ex5SnnV8DmPHTAWwWgG0CEiCzhPwNwFjbFFHRbLMuC5nC5CC0B7NipWoRXBx0cXjLHD6AtGWzD6DkMWqNjYhRncWYhGTqkCq4GzrgNYO7BbDJC7KVIB0MWyoiKhKMYqqgLVWfO8mij2w7iLTC5KzbCqwzOEySTy0kOa+fx5DBeSqbhtV/TsY56fpyCtmqxugFnmBRNjwPexN6YsrjDGiAijn2kn8pktC2IrDHXDvgN0DYubAsI4qgRlYWBcRhxqsOhsA1WNSWAWl1HNa/aTNS/1WBHnFiUMhpESGdREXHHricEMr5CI0LYXtfk4tWK/DGWyzeDcF2vrkscB0Htvxp4rQIcbSMud1WrOpr+9oazeEKIJyTk/Mr6lVHxEgzogV3ssp0hG23dUEzmm9/4d7Of8Qz/0QwCAe97zntPrP/ETP4EHPvCBAIBHP/rRuPLKK/GQhzwE73jHO3D3u98dL3/5yyPHGQCe8YxnYLfb4QEPeACuvPJK3Ote98Kzn/3s9zrHuQ5FsuZjoN5ytcrldlhR6x3RQJsarpk0Qrgo0D0lQQo4W37zAU3PW+/gzKAwGd0YtORiCttkrdvt/4/5QtNlTas6NRjlQQtlrbecAtnBmhV8PNhLGqLMnjTxLdwaem6BFAxuYMEiLPRfwmGEoTC2mIYfB/hg52yRjLphSA0UyiuQks9hAO2gLCukrZC2WAGS1hyo7eeNPfuxg7TsFG0HtN0wn/QOVlkh6ltIFGDRnQNsQxR9WV1wrQPTFt9aY7Too+4SLt91CFY1QD54++CbfjrecMVv+5aY9MUv6LpDHwtG23krgVZkDe6P1i52rq4XYqe2NeluQHfdAJoBZItY0Npmr9wZqA1obIoRmF1h8/WQYh9gqNHME3LFzY6huhrbJEKrRWGbkZsm9KKTnljhuNq2WROQzat82xaMNdKPDIB9yMSEvkhLuSJkqXUzkFKFnOCsBaDFrWMed8KQsImXKt1fBshReZA7ThU1iT76eaQ2wV9goRFnzCitnFsFaIxkwbElrf+KuFWINyiCSZtbIMLn7PEL7nfWIQDjKipIT6x5w57VQdqZswFnva917BqgdXbSlVGBeTsvqrLUfW5RLs3qVCpB1Z2Syt4c/XTV5teu3eM6m7Wv6SEieOITn4gnPvGJF3zPRRddhGc+85l45jOfeV1+/lo90tKv09A216Jmk3b3pbTO5ifUkBIG66fPbGjRoLUsIgdnS586YOgBTQ8Y44A2ViiDwphOVRMJmUZFgCYya43cRqqJ3gjA8VCOw/ySAFHAI7JjwKQRCZM2t28bbt7rKKAcrCR9iQNZvjGCgHRTE0l3GNhhRL+U3o1tatHAcR8F+LhPvCPuce9/gB/+gRfj0M8bIKND2sGO5WCKAcHZpY14jW1Z1Bm0Qha1fge0naI5w5adlHJOFqU9FsFY1OWFoEsaC1cNAh9jO1DzV1PBGGI77nQBDipWJkIFD//41+CDbvRRuOL82/DQ3/wHXiXZZuGqC7rsrKGMm+7SH90bdNegO7H0qsXPfacW/LUMYOnQxUz+9DHDg3RYr90UtjphjKEys2piq+JKGxJUCX08rvONvHQLkTE25XtOtXGizQB9xIU3it3xI/4mm3cFMLP3X4r1yZvO95q1wcA5+3BSuJunaam3ra7wK6O21ePNMoipqiOUCSql2l55b5wfFXv/rG5Gx2TfDB1p00pQXkDztpjupnaOIHMeSJO25H2KAVQEKKubtFXK3af1xfOVCcxaMhMwDKB1Amlqzjuo7sE0Co00ClcM6ONTmrJt9s1JTXWeziBdA75s1BjvIJsRTb/2CHCeR7j6ou0Xz1/NrLzw43pfW7uaJ2TzWhrBTPfP/U7o6cvS9ccF2hgo0Q1w0E3zi2AeM8MB9HE4/9EVi+c7G0BbFLdoYc7DHZZjFN8zBcCsC27TM/P51YghzT/z60wOSPlbjhJ/h5NxKCf2cQ2kdAzYZgdtKt+4KV2nVkKPJfXIoIc3OhjS9OlatihufJOL8LO/+h1oTfBp9/pofPnnfA9EOpocINhb33aQdh6tmcndGpw9a/jbsTg4R2veE8g1GLAu7mv2NEsvZpQ7M5bbM2DEu6tb+ykfqEupf7YJVjWz9nkIbn7RBwMAbrS/DAdpOBCYacdpDsy6NyZNFr3sMJYlI7eX5iVVXWaVtDLzK6+YynQ6LUofs19KgFJz5sxI1VkwuVc2+grK1SHRkN7hdvQtWSQizdc1lEmn19kf10ue/1WYnixPdVFg5E1iC/DdAvJIq02k8PkMPZE6aGmXdavIshmG+pECjNrOvHeEAs761lV9OQLmqCBY2J6z+vS75squJCUjAcoGiSpu5vYtS6F2vlLOkXPaAboqZkJgXgzkddDa5tDI4u+M1iZzVrP8YBCgTfEMFs36wx6pbSBdqwMtZBvT/WVA36msneoUQYHPnDsDx+pNzrUR/x9OSjoyzqG6VrYqadbouC6P6zk4JyhXqIlJg9R9Zt8zTVA9NVv4wsGckWmw3W1CSGpFTNKPVAjtGOoeVDUu1HCwGrd68IAx9xXpgBCYSyV5bc6SA1G5KgjKes0UYTOz4utOPY/OFs3QXESI4vOBWkAJyFjUgFZ0h6ZertFrH9e9T6PObQC15b4SnLPV4B1gf3ZxpPVcesklaHIjG085OGPeuZ+bkeIuLAnIQrKv0aT00hpa62nmZXCcqBcxEksxEasBEnNMc4h2MPBdHPtqGpJCkjkrJpP2j73hwfiCv/d4/PJbnluqIhf27I6WLjsM2WPIDqPt3fe883SqxVmKeCyBev5pt8DCtsZJaZix9aip+04JTlVc1RVUgZmMifxiC5cNzFTehnpJ/Eb17NGcOzdulDhCZHqBWyTEo5xJFYa1p2QgEJdW67BiBuI0j3RMu5hMsrdsDCLN5ITLi2krSQdnqwLnsSwqm3XJtZ3seDkCCuVbDO9Cv7LvtEwHibVNOWjR5VkR3QBZrIa2wO1eWSomzNqSAWHh4nADQo+5bvLSWLF7UYbNfWyZM83a2mLDC/Ygi67FR8aSYKw8tueiS3yvicu0YlI+H8ceuaWjADdnT4aIVdN1cmRaNkaYvE1uDTCIR1BtRVoQ6AYKzkAVI5iGPI0L6bnKfxaGhCNumEZbgjeTIOwGDG1FCJuQMBAnc06AvnAzgA5z9lRWMb95YsnH6tw0AnzErjCUgA1esUoyMCyCPHIBaeQhNmQdXAfmUqWn6c6AWR2YfbMAUdvvVHxzcgNmi7RSP9YJrGn2rnVq0wT1jrcpvuWBL8Jn3u9D8dTH/QIWXIomKxrOownbEsCcdTmcSdRNl2WUQDb/u6hr9T0GbIpCVWfESgGXbKWmnZupktiXVogIrh/GmOl3PkDw2re9DL/+tstxXritQYutDay4v7XujdskDFhw2MDiQC3hC1TmwHikmno0fUTMVhpUQdlBy5QjjfFXz3sesZZQjtPwVyGWpj6uHQmgmoEz85jJjrOidA943v6rQEU1e14KFKrwdWlzKn4WeXctIJNpSgHQF2xlHvmlSKvrJ10/4kFEbBImGUHs7KUyVY9DKN91vdv6X7S8xOA890uxtgA05ZoCEyhWGReJjsJq0KyKfpxtSYCuwi6sQVwo5ZSbAq1J1LMJZRl23an9tpQzm4bSowK1VpAupftQ85NtLkrI9ZT7DblNCcO1YkoUdS+ISqiWBs2cqZzPo9A39mMDzjMW3UDN2sePFDCFFwInAVpCeMweA97UXQiZ2dmfk3KAccYUSLVlmsNctYdhvnPwBmmtTqt1Bt9469Ef/M8EZcqNAWNPw55rL4E7NdUBAqvgI4AXox/F3JSFAMz303SHpnuMsYfoWTSUXj03SfXMgbqCdN2zhzp9TmjBwC/8zJ/iF3/2f2JZFrRmzHmRPbh/cLV6ZKEymmxnhpTC2geHEaYQF4QyFdXqTSPXk2stzNUDUTt7KXKbP0d9a3RGa1sQGcHZzNvOmCX3FaLv2XLBd1jHDn3s0MfeIrh1b75nppIUozHASNUFaYTHBMjZ+1gwuA+Zm8lvQnwv3N+c8zHDs0b53XTtjLBIrQHM+c15zmTEPWA9a0r38qyG3wxQnA5k9DcDSZPH5b2uy6QyZQsujP4UKE9bLg2UIunQkMMS4xhAvfVD1tKsrJ/exIpxKAfYlDyozR3Oa7uSFpHUz/6vP4w7fPjt8AvPvRzf+U+fiq4NkAFRZk6UOV7kXO69dKE9mDC9FlBTRJMWZYKvhWFq2K+lkjwHAtIEnWbtDAzL5gA9WexotWvOltPFJl4dyHTPNF1b7fCG9PjX4MQKnzkTE5w5v8iYl1APJRROG0VmIQxw7GdgJnu+QYJzinITJlXA2N+1DFPC6azH1xvlNxfVJMepbNO1iZSpDzfhzYklUdmn1LWNFKAjf5YeN57YhMApYk6+THmUl2lMuTsAZ/QGaPoSChcg0hwQoOwAHZGUrNazjxbAPM5gW/9ZsrBM2/XZdlCKsrUfzpC+6aqvC+qikYhjNnP2gvNYsIsI8cXvR+7/UCPrM6wotud0jRg6wlIgUVFBA1BJqAWCSCERsYhaNUDu1a1b5DxWKRXDxDKZhjHnrhYQVk3cB4j7nYt5Wz0wzMF59B16N4DWvrOeKSkqYJ6nXVcvM7nOGAqhDhZSUFdW5xXANZQctIJpzF3N7zPrx1xdr26pmIoyGTozfAnQ8z5MFabJx2dfYDqpOOnVBWn+RmExUsag7liC1YG5Nr+pUm7sZIHR/GoPfIKI5Z8z48AtEVSgcAQ2zgybunXKl6EX8miuTDe1OddUg0Hf4cNvBxHBp33+J2NBg5X+8yh7WBBaXj/ll8FHhnE655Pqzsts8eSkKSe1zKeJLWtajsKCBHh9iGT2qaQIIg0wTNttAunKsKMhXw8mfnSGJFdjUkiy1VuXhK0SpJxflOocw7QETYpXAPRGGQFK/3eQSnV9eVSxZA8Kkhm6t8YHeyQFkhBkHTSQh0Yq/jsl5SKDSTzHrmjhwvSHaiqbWgXnZCnby1Apf9r2YzsQbsqOyOLi55pKQEouGjdnj6lizwLtBgxt7KB9jzHO0EYFZgNk4U4SZUcJBXeWOAed9tDlrkVL3I1UpphBa757M/peZeDsvDn1aCpTZYs8ZUEG92mPjiyP2aBjeDqHwLavE6BbTjOcJXO8a62PZXjKScdUiERKSWPutsOg/O5gvqpE4867B4noBKyldV0spWp4atW6g647jL63ymGdKVVwtk560/KEI4pnsT4UIRcwvg2fuIqZK2K22BD6GOhVvcYZ1rX6XUhgbn43k51U21R+b8a+ztslVpN2CZucwJke7mTKVWhuJUH1NZMxsx0ciBOYtVlNAnipWF08MKsQYvr0lQCNtgFnFsxobvFQqO82J+rJ8MNZ93DGOQzYrLKqWhkEXyW/+lOvxCf+w7viOU9+ARZZHNi5F/yIc0izL1mkl8gQcsoE7PgbjmEnlHcQ/nJq1U3RyLKTrwMTaybAcgtIsudNQ/SYQFk0/bj2Wn5/+pftHNJCsLVj1OydjI6fwZnBikkPMkKpI9WZGep5LlktoFLHGzw4V41/C7lVzFQWsX1PpZ/Dp6wLsm2AA3TSyKf0hgDh0rfyPLRwauI6q51xSpoEBQWYK0BjcxyXVSZHMUdpM+1c/ZJUNguopDZw15ix7iBeUk/7HuLArMNAWcY5YFwE0Yusx0WA+pZPOAdV63PTewPnjO6mWZtnzuXBUh3cVJ7AXEolqqaf30HZisHsYKVTHYzVrAAapnvxbevs502WmTkLCje7aeoscM7J2zZghUcm1ozYqW+syCph3Fi+gHNWRXagFklw1lLudDQrSNIdoA8LdN1B12atS5Tu1D4ylCGCCR2c0cNcKEWYbNsMZvZsKC1E1Fiqn7kjbU0rashN8nEqBsfgbHf6uIjn/Nock01wrjBifK9Dp9dkXk9h0q/m6wLQlTG3NcwiWv0XvlYToDfgTIBmU/WdlBYbRy8qZCxxwLZH9NNinIcI2rAxas6YF21QHXja1/6g5cZrxyK7WC+iRhAi1UoGKjgL6rYgBFZj3K2MpvBvUsiL5Irk+4aQoMRIT82Ge/MqfQEFdEvMa849f43HVextp2fOse1s2O6pPcdVZ9RCBixyhtF1YhbSdFhapFLl3tlXV2mlgXbefwflO9/XHsc3bEauY+6ZSFeFA5AGjRprGlpoaOHpva56lpbIVyti735OB2BtPY7ZdOFCH2CkbWXOmidpD5ICHjNQY5SrpDY5ymcVFgES1M8AWSLn1TVV12pp2mZKw1h3EG9Y95D1DNLPoN1AWfpFkGFgLONi69V6sEcCNdzUzYju9H61uIyZNa8wD+1VCcxqKUxT5W5lEN4BkYKhO+hYY79Y6YKxGiiz11XCimB7aZvAkGECmHtFdNCEpwWcEZZQrBIArQTm1f3XljWHdbCQV+51Fk3adMW5gxfB2a5hrAvGoTlIN2PpK6CrerUU2I/0ZGVKM2opBFEFJyP4T+l9nFgMkaFTSDyQjmIuDajb4j0D6dlMMZ7Ts0bEbkF5lL/P4Fx/e64SVhjNVPHLP12sWwq6mjYATV9Fs1xxad1Y86LQNtwFqlPBDQNoK6YzlThSoLk7hAGCMhoYVdg60mLVG+CR31ybvnU5dCgWHfYF5RoFiDvRVDEiZqXaGcictQAzEpg9K0EqKBN8I6BQ4jUO7RFfIXUtOhED4KY3RaGFcn+o903TLmeIBIpTkNVg31T5tiCc+SBlow9kweCaTZB2nLSdmso3hxDneedM53Ucx4IDfye1td83HwnRFawJzxWj5m3pEmRrqgZNd/ls1g0HMFmA1UF5EJzdRK0ybCEXhqytArR69n9lzorpvuY8RFmF2RSgOexoOPh3TvoGSxsasQpdI/ZwOBfaob3XsnrrAqw7Z9B7SD/z5qzZgdlA2ZodXwIzbxOsDZwlTNvMjQ4jWlx0Frk0xmwFHRh16qCszCs/oOkeMnaQuptNPxgwD9uernfrZRUIgfkgk+k6LJ+OZ9KyWm7s2EPDxwnWDCfuwxl07/DAMJQ627bgiadTyKBI1uFWyw4YQwKcdRXooUEPzfZ2PojvGqhmBehqVZdoAWHka/H10XQYwT1Ik2GsoSh2wcdwQ+goAijdPc3Xk/h6qsE2dS/nXEupHKdXeQbomsZSxHRZu9WsOLc5tcofwZyLdQumXYUJu9kGNbaZSkfseub+jABnZvw0YHglveFyYMD6rnY2XWHpRdrQY3MSDYVbhkAcmLn2ItqZAA1LsTKzSAdTiLrPyYyoGBa8VzeM0SWA+BRzpp7PGJTsicD2AdYREH6B2ZAjFo7fZe6+Ko8k5p+Z3Mv3boG9hq3H87FpNTadDH+uVD/vrZ3Hpyr6H4Oz0r5SrEApiI+rhuWZHEOz4AYMzttH1f9zhpwG6DkwxRbVcNNFA8VMTgXxdJtyO6WAuxgDHs1zlgnQTU3zZu+gHMcMMmk8f+95CaNcWr1E2bzG41BbC2NuEqlUEK6Pyp4s5WFKZegJzOjma5Z+Bln3Acwy3JQ9LoaMSxyIL4HoJQAcrHExAJq7GSR2BvFo7TSzJuOiwdeAeTFgVthm8dqx6IqmByy6xzL2aA7MMrLuZjDmtaGvgkYwXsSsCRwLDt8Q3zwCcT+qfGL0dquyfQPQWlrduaqPLOfJnyAIG+nOfa3jWLNppx9boIfSzkvsUBqWgFVSUeiSJtOQcwRoFIDWwl40ptExQE98J4RRTskqstLPLRvQzGk7c+N5m8hR/n7KrJ0AfWzOrkytLBDexHAxzSZu7hr3Zf/4frjqcCVe/PJf8nU6oDs19rxoKf7imzy0luAsrMpsClZTs4SIWzKEO0V0W5dWKteq3KEvgNj8lW4+4ph8g+DcIENCV682DNr+WLxEsABiHuvg2+L3jSmFqMMl2Vpt2BwTpLkwYHIM/pxCiYduggoWPeJENjrUFow9W0ZMKalhVwAjsCsjnorhljYDdnqSZ+BPFbGK3pzZ1o/NTE+iN4Mzj0o07nV4vF+AsxYNSsvzXND1mD4u3haKgxZ9ChaZ/tWY7w5aEdVrL+u0OIc4GDtj1kZAVqAANKK6k84TlT8Ur5UZrGXSY/P+mPj+el0EmeeAZM3ee3GAAOhNEXpd95C+B9Y90M+AcQb0c9BBc/bFUALzuASKS+wYBOxq2q7MeVuAhAalA6QEi6V27MZfr1/eIq3LChNIKaqv4Ts3YNaDREyULAiFRR0I1SO2tSP3wSarANLrwFCCCs7OlMOsvQVoB2bu5tg1vJ8ZWy5TjDm6IiLEB8+LLvWybTjOw9gzWz2f6QfKPGFxGxc5eZyv58qpD2qKdYVUAsTPVcZc89gvBM4VjOce5f8ZNTwbNCdzdjzHfAND8BOgaxxIAvW3PuQr8fQnPRqqigc+/JH46Zf+PwbIO2fNXuaV9deb78Jk7NnkAv2PVnikQXTY3GTCRggQY82tNVgFj8VaN/M2ugROUrGQ4bnjzp5lkCjk1pMXCqEz/HUmWDNDAphN0RBJtxdPYCp6wzgNgbvkgMgFm6qrYCYZWu5RlW+8NroDCcayJCj7vRTlNc2SOdnzVG8PXtJnAuqrY848MsUn1dDZnZLWovTFS1xSmXTQGyo452AoMpqvyCDMizp9CpkANRfvJ7B7+H3k6wERGCEpSLvAwRgzODe2gREgbSw5mTPMeerMWVsVhIIoZkxywwuLIiInBqMyaH5PXXgkFfwCFjSAaeOqLQBOC0CLM+cA527gjG7BYAHSw0DZ2qXOnC+B4CKoXgTZgLNO/ma7Mxklv/hdKWxaD1bwxIugfO6XfTw+96s+Gi969n/Aq/7DK51xEJglTNhyEKulfRDbBKIAM+OmPuZmn4bHfPwP4tff+ot4xh8+umLJJHNq3YopEKz0BOYA6KEJ0ARnrbsvqSl4QIjVAfW8ajNpjq5QtlWhBwUOgJ4HcFDoeQUOmiZuN3MbMLs2MG096kDMOs8KrzpVV4onWLEsVaw2PlsnwZ8cIovcbqsI1OmawFuBeMuYK0Aj1mft0/9HjerEApkyIjIuRCKP2QD6lre6zN4uglvc4gOgy4BE7XLrR2yqIm5kGsZ+hT5c9Y1x1Jgy9YLQysTjFBqa1Xi1TVx8dzf7ci+wY1ZsGAMeAVQygD7UKt7psDWBGZwZyW5KbtX1jTlTRJi12bUAaRY42sT2EPf1YtYmb5tqJXZ+oywSn0w14ktgsqvcG+Gd9bFSZZpph1VMWu1a9RQQMwiLEQfbdL5TID2CVWeGxylwntXIqt40H9EaY5HMOa+MYlhuqOC8fRwDcvazsSSXtB1nKokZgYpWNBXrKEYQZ8yr98Gg29zMnA2MMIlxocOBelYoeSG6Nfvw4hpQZs/8t8qO4pHnP0V0+DWGqYmBQ6NBh7PQqHlbI7YdnIeZtnWcgwxjzlIZNC6x13AJ1M3amfvMYDCZTtGedeR+RhTwBxc+O2PIMKb8dY+9J5Zdw4Mee3+8+uWvBothSzcTr7FaMaA6SG6bKUkgiVdPuOuzcJtL74APvtFd8COvfwreOd5hYyQ5plMFyAgGOwZmVmul75nseQwD5eGM2HC+gLIkZxxeGnbo8NSv4eA83HwN95vDgXkAhwE9DK96Qjt6petFYI58PqmvmgE482Y3VFzrtKuRuhWUqWRtgrQKhBNwqyJwzJi1vAull+mXZ3M2A8K2E6uAc6QvGkh/6zd9JZ74bQ/F5a/4dTzgQd+Eiy89w7vf824883k/DtmZSVv2tm6jiuQu2bNZop29NturWuBR1GoALVX4dEAXweLAjGZ1BdA8hbEtYFU7FhNq3aUY060AS6MalkbVdaDpgqEDQxm5vkz3NkhI3chDEphVDJClNXP/OKO3mvOu1C7wXqN07F0/5e74jqc9DW9+85/jy7/8H9v9p794uPLnSqG4NYBKn1lr3Azfhh1LN8sBgVnghUZojm4J2mJjHHtpq4HzNz/5S/Hl3/K5+A8/9Uo8/eufPoF09U/ngja3CjGhzvoUrzXtTMHo7NmCJLEu7DHw3jyu1+A8C4lZbOSiJzBnNidNFlwnNJFwwdO3HKap+EWZ04HBdZbAvDVxW/VLB+kFG5+VFrM2whKn/F+dJRcCZf5tnkHICCd+YQJzWhim1RlBQjrIng2YpS/AqH7nvZu1PZ1qnAOG5zJHlDZN2fQ7m1nbmPMeZMvTpcTB4scDkWrFQSqlAEUFb//f78ItP+gmePOfvn3WvCgACWKH+StKoaOo+vX6v/hPuM2ld8B7+rvxzr+5Al3mYQzFhybija/5CJwrgw72bAxanTknv8mgqOEVzcJE6YLLwLnHb+uqmQ52cHA+3x2ku20ZWQF6jMKct8ymNGzAOqBUMOW4HKnCaehDcIoatDUz75y+WyA+1WP63AzMxww6J1NZKMEUN+DcFI9/5INw4xtdii/6nPtAW8fDv/MJkL1CdiPYsu7UN0iyfuzEdzwzcO6LWtDUtlZB1ehdcYyi7GsCIFarEx8A7ZHbaAJZ1QNO7fMW16lWox8jcqYHWDJ1sZgXHajFWiSGROrSd2BuXre9QRc/p8V+3zZZkQLScPZs5OPrv/lbcOOb3AQ3vslN8Kmf/hn4tf/4KkDJ6B2ghxohFh+HOhsi7c8tGJqkKIA5LAeuvKtMQJnAbeD8Tx7x+Th38Tl87tfeB//i678HWbk+gblhnseGCzk7TezOYEwbTXEKlhmYx/P8vu6P6zU480FI1hPPuS7EgVmgEWNK9ly/qYayZJUcKe8o7DnAuABz89ebOglVL2yjnnahkYoRmBPgLPVUZoWL4HxMQo4/E4pgBej65lmwTRV8Rumjvq3Tg7rXaudG6O5/1rMC0CxK4kFgOGc50Btgnk5ne2pTxEk1Veb1qAIP/sxn404fcyn+53//H5AzhMlZM+rKTMALoAfdFimaLL2P/KUvw4d84N/Hn/z1G3DAyOBmH9spcLSYtA2YHSgPBpqR4uS/P7qCmTBhpnZmujWoGTh3r/blva6Wex3XB6Aw6DBnHzpwWB2YvdVKKATpqOfOXpPFTICb4Eg+QPX22DZlXrebXXYZvvbrvwzPe/aL8Na3/uVmwta1lEenQbkCNzafOwHMUxAY++PpDhQG3QZUFP/uxS/DN3z1l+L1f/jfMzKbFWd8u1Fjyophe7pA9rYUYt9wC3HIjVdQiboc+ZqtyDW3OhUHwoa2OijLYsBMkOo+0gJIXzBkuBm82/pEh6hvycjCJ8y7VgdnJx2lYggQhVQSmEdbfPc2A+gjcGZAnJu1X/rzP4873eXD8a53vQu//bu/A+z3iACOIQaufVhkd9cSCuDzjVteMRK9IQR5RILDLAOE5AY37ztwt2DPllr56pf+Fj7riz8Vv/ea33czdw0W2/qccx5XwjeXG8nQ1YoNFSO2IvlCr12bh+i12aT5fexxxRVX4KY3venRkq+D1aaWW1dkAQsWfS/Phd4ZRL5fK9pbKY9rZuqGaX/wdacWP7VXc8myPwP6mRrZ3APjjJo3wizG7wbBYMBSm4IBwoUwwkRbg38m/2JEFVV6WJiESplyrFFrJ2P+3D2gZx6N7QVGPBrb2qXAuBQyLoWMG0HGjYBxI4hag94I8v+S9+fxtmVVfTf8G3Oufe6tKhppBCQhhCAKiAr2hUlsEDtsIkSiRoMGDUoUCRgTRF8xtBKjoFF8EnnEFmKHiEYaUckbkdiiYpQIEtBIgUaaoqh7zl5zjOeP0c6197nVJE/et6x9P/OudfbZZ++115prfkc/5CpAroqobYXzCTKIwyY5lUBQ6Bq1ENCbYKFTLO16G9dh167D0t+LpV+LZXkv+nKtjt21aLv3gnbvBU6u03HhOvDJ9eAL14MvnGJcuIT1whnGyRnWkz3WCyvGbmA9WbEujLEbGF3AnXVrrRUDFQFnPcfimrNrrr6/NyivlHnI5gPXtC6rU+49mq2xhcgOQl57/ARsNci93KlIaTg/FkSj+sivlmLOXg3QK7DfA+sZsO6Bcab74wwYe2Dscc973AX/+qn/HC980Yvx4pf8XKj55FoMRFkWWmBdjlJTrX7lt77tdbjb3d4f73rXe3DXOzwQdQlLsPqjGq0PoTyDeTYW3igwbwHdAE8BqumM5AGai4IYOwbtoNqzjxOgGZRbDEJfCL0Tem/ozQZpLbsFCzovWGTBMnZYeIdl7NDXEyzriW31577foa87tP2Ctna0tYPWFinYmiSv1hPhARl7MK/gcQbmPVjOwHyGIWdg2UPkDAztMQ9ryumBYJpaBU0VJEJrzUbXFqzd4dwTzkuzXuek61wTrF2wNsG+MdbGWImxx8CKgVUYq+h2jIHBgjEYPCSK9MiqGQiwojpajbCZG03z1TQLo+sQ65Mt2u0r42q1IJE3pN1hYJGBBavux9hqzhXO+r8vn57MqcvuXHY3n0O8Zlp6UT2MA9fiD/Dud78bt7vd7XBjH38lNGcABzf9rDXP+ylvq28o5X83/pT7OJYDM8BUjYtgeY3FkrrRpms+NFfA+/6BNkypJTNtTNk0r2sHX5bmmTHNEKd+9THbm9nPVGvZFg1abwq9ObxTDLGBnHcF6Ee2KNsNmIsrX89wrKvF/FjMAeIaJepWzb8w8xmZbxbDTMhDwCuHa2HKFINdH4+IXkQVy2GvoXL6qoB/oDUjTOcKSQe0adCuvZtGLxvNOUzXrkOTaczQgBjVfCg+X+uA99TABszELaolr0PBvK7AWE1ztm11fgvjF1/6g/hb97oHHvG5n44Lt70nVl6x1ZpDczYTwmxSrneNXqurrroCAHDx4gVo6cJqdt7ep7PB+hDK2//r31YY+/tuRp1o05CSBiRWB0AM2Ah4h2VrIbV0WUl4iUFm3ibTfvV4iLRdqB+2as6EqjWTjdGp9CP3QCyK7Ios/iH2dS3uoFqUyBYaoqhPzVYbgN0yhnpfIaVj62AGb0XaOzANBbMspj0vqTnDsk+o5Bd6j2sV8kijyxvUBE8AkRbHbNB7rwk06M4EYIqSYRb7QAIijdxuki0s4h+pT7uRmtEj0Mv8z3MzIi9w5K+bxT2ACgPmfzjYz7lM5e/nPUEVL2/K4xYN52q+ps0p9lsc8HJq+lrevEqDv/zWd7+03bflnvYJLWXMgWGzmdvN3uGfLtwLKG8p1WzB8QOdqvOgXOLyXesBicxm1wpn16JRDgSbbTlAMp8uVTO3zKDObWrcE5SjyMiymdDTV4vtvHgajGmUsUJogGkFu1yrlTcgoqU7SZ27EGbw8CEYQ0E9Vnc5SF43hAVc4dwqnCVOradawXzIE5wj1xhm2rbnVtEc5dX+3uHMxZfsUI564A1aq1pPhvp6ESU5teyjSRDDTN1+8CsboCucHdAOZ8/JYrzn2msBAMyMdX+GMHM7oEs3Kp9/NaNBr2l6pQHCpz3k4XjSk5+A53z790Kwlou6mbsH73wI5Yrv+W/8vTZgnkpYlc+rN/PWFT5p04A09SNLJ9OoyQBtcF4MyjsAOwJ2Dmc1UVNrBmb9AEJZBMznTAtZFgEU1M1g7YA2UzMRZXxblTlI/c5t2HczH52w5UaLA5rw8Z/1SXj8v30y/vsfvBFf9+n/WH3ihKwQGOZsDUSTvoC6QXoxQC8dWJoKKQvhs//Bw/BFj/4C/OZvvg7/6unPBrrC0CuuRXtMZ3aDZqyRhDDl3nC1TKU1QyxYkcztQKJvQDS0RSy8IBGFnOXRQo1Ugg1zNRmQJaOy68KYAmidU3Vu+SSZQ77muXc4r+fH5X53/uMWDWcA8OCmY7JJJnckTP1B8Zrcbh3+bfPa+l4HgAZKWkwBNDbco/I+lpoldqPohxlEt4vL9D3rm9SDkWMHlc9ZXmQFMm20Zir7AWQbjX2/wPnIALbbDKub8oYroDeLj9c5lrZCaA+mvUKZ9iBaMchISCvE0ibgcBaFNfMAM4OZMQzQYwjYAK1WDslrJWa1dg0bJtOIwxmpOR/xNWOvWvME6NCgFcxgh7MB2rRmiNeoriUlZjirX5gRPW6ZsshIlB7jWVNe97rPPmrY+MDVn/hwPO6r/hFe8jM/P0+mAuj5TvKf5iBKlOd+7dd/A5/39/4hji9k24VqNlvPz8n0uvy/vFfcI2V/W4Ck3lt14m0ALQ3q/7WIZAd0lIBfYHBSl1RbyALECLxTOLvfGC1jJcjqwJIYmLUsnPmpyWuOhL+6tRTgIwhsI3uIldxkQgRZKfwALxCm0CI86pu/Erd5v9viAVc/CPd+4H3xx7/3hjgPQhaZ3bppzQ7mxUzaC7B0yNIhBc7/4EsfiSuvuhJ/++9cDTo5AVnxFqLSolEQrVVrKinKnBLrH6AyoeWMidgfsa4/xBYcR7ot1QJjSylI1q5pAeSpp+tsnaHtnIp5XSdI/flwTh/nz3a+3rTHLR7OAMoJnqXqCl625+a/K6+xNa7B6sz60lPu8a18v+XgPGTzM6UG5scim60fCJzk+vOdb3NnfMnHfiG+/xd/GO9697u362eBL5D5rMCc31rAXEBctehq1qbNaBXSvs+WPykF2v5z3Dq5qsTZ36yRFc4qLQ+A9kA7A+gM0vaQtgfTGbidgegMRHsQnQG0h2APDs+P+ddkQERN3sMAvTJjDPUpj5Ea9GhqRPbIexZgsGRRrQpnjwHwOAAr/CFVe96LbRH+Z5Qc5QpoFO0ZYcrOhSCMbl5O06PKZGRXrbjWXIK+RmrN7NtDzfnS+96HZ3/bd9uBzgvXtIjJ9o6isrT53eJL7rFxeP/ND4evTD/nb1Nvj0c1Z2/BfHRyHZl0NeChBj54kIo9J649d4QmLYuatNVIRKpZmuZMLQMavTyulumkMGu3VQOfPJhMq3dqlofnSst0GiUGkcZERJUvD7KylC3yBUuAV73oP+JR3/hVePf/fBf++x++KUzvOhTMmrq1AAHmBVgWyLKAFtecu1oKFsKv/sqv46Gf/on4kz/9M2C30xzttoLI2uraoTaxeR/9AzjmC0u5D7pOPz3folt2jVm/UAX0HJClZm1PqSJkZLfHTUzpeSWWJNfemkFNmJqXBJjnnlZyo+b1jfn9OX91Sw4I84sDpPRzuCzUsJU5QGyyblH5eXP/Tm9YpVpzwXpRAl6gAczmj/JAZg1mpghqlh2Fv8pvevcxxeJmi64Mwl885y2441V3wDXvejvu/uj7KhC2VaH20KIUx4pPDMDrLkxw9rZyVu5Ic4itR7OcgKCdpppcAZIr0eRKkFyFJh78dVvdx21BclsQ7HlcBcJVgFwJIk+j6rF++gWr5zcL7w9QO0On69Ha9ejtfeh0HXq7Dr2/F73paP1a9P5etH4daNEtluuA5X3A7nrI7nrI7hJ4dwm8O8PYaTDY2K1YT1bd7gbGjrEuA2MRjBIMFi4JeDCYpkB5cJ4MFChTgtnKaXpwGPZkcG7WlrJFu0dIh9i5F61IAzGnphR1TSZ7qrYgnOplhwRoqop32gggu9a8L/u1lNnIEQtaLmyIRWyrB9TFad4vDgzc5S53wXc855n4mZf8PP7Df/ip6V4+T0P2/XMXpzqZaiT/LOnlzZwTLItpuI/Y/cUGWdoRcEJqrj4h4ASgEwJdsP0LpMFhJ2TBYfo3bSE0Cwxr1NCbtzZd0KVj4QWdLShs3WE3dLvs7ef9Dst+sdHRzxr6vqHvgbYHaC+glUF7dVvIukLWPXjY4DPw2GPwHix7DNmDZYBlDQuNTKdJo8KpdbS2oPUF5Ntlh9YXYOdwXiA7Cwpb1KQ/usR9s7aBta1YSceQPVY7hjFWjLEHr6uO/QpeB+RMc/JlzynQ+v20Qk0Jqwk0Vs7ULRDNlA3vJ60BYdEgFovYFh4kVn8/BwsHnE0onkuZ9OgWp21dqWypBIPpNj2KGT3BWPFe/OdbV0CYoErss3Z7TEv213F5TrANZ9nCvSwPhHgPVWxl+jsu+6HEutYV2heZQmILa0tYTtVzTCsiJlx5ogE2t7l4G5MINh8alhvXksu2as8F0LTRnt0EppV4YBqzTn6C1gdWDZqm53zfcw4jYMIKByDOoaA8ESMUnWY+JtqD2qlpzaeQpoPbqT1/CvRTSDuDtDO0doZGZ+DmK1iaugXeG3hggDFEMKxYwypawWlE5a4SHwBYjrPEaZxM2q41RxS9RDGQuh8VvFbS561ntJRcY7E31oAvRk3wi5nnYBTWpUUsvP9YPhhLMV27plwgHJpzhW+F8BGzzJTbPONzvvso9hPjhJe/8sX4sA97AP7BFzwCL3v5K/Gud70Lh48bCeX80LKzAXNMrvIcteO+5iqVt1bgrVqwWNCWmDbtZm8V0vW13IFW0ozYcoOpJQYI2v6TWNuHUjMDkcV0taYBpKoxM4aZsmcBtphna+c7H1y208JTz5ddQ1fVWwORBX21HqZs6gpk6kuYtvW5BtqRpo8tGuVOfYA6xenz5kHNc/Pd6eyCm60t0vNeEG3fNbkYwAzaCFpaetTOTVGyyKegzVexfW+hqUq5WzspNGb9M1vpyRKsxFtnzFsHt3dhi5oYmPlyOIsbbs7jFg1nIJeF82DsDy+JwOWV/ndCCehaCN5/76d9OvFS4koLhLcFmHTfgBx2UvUVSiOlgMHMy/VJwFoX4If96y/AEz79n+KZP/EcSy+gTOeZtCaUBfrYvh5wgHnjZ47URwN0c0AD2ZHJoQxrRIF8DfnrpitgU9e/pp94XyDJftdEzdUB4UsAXQLaJUi7BGnXg7v+jHYJ0g3c/RTcz0DtTOGsKgaEVjApoEcFNAzKm6ElNTWCepRT5kJWwLkqla5sFliHL3ovJc1K0j89YNHkOi90TgzdxyiLRpm/1aQNkxBq2H+VBr2iigO6NpcWf87fw/cFk0m7BIFtJIT6hN0TFPu0ubN8+95r3xv3zNnZ9XaiDh9yZO/yD79JC4irSWaK0jZAEA7N2I3SV9wpKmTp731LWcbyoBmEgvqFX/jt+Nt/4yPwDb/0HLzw938WUeHL6lLBXUGsXaxGcwALWtuC2QqNlHsHhgmtnlUDJYe2pR0WROkZC0Ur8H/TeQuhxYWRBjQPAlvMlL2AliXN2osFvS1A80YgC6FZzW09TQrFLl3nnUsgts6I+6E7IkgyOvURsla3ux3YwWzPScK5iGLGZl+AzOJFqsUSKpT1fRzMZNHs3oCWSdtjDJlbZdSq3GnexgRosbtivltulXCOSwIgl4ctsF2Kr7e8F+v0eVpl/+li1wk9aQ6ZflXHUU2Zy3aUG3wEoQLOIQ9G60bCq1//X/DLr/s1NfeMJaLNsqiBfrBMQN4O/V0WL5oB7cdAqFp0gjm2Kdwe7JdvY0qyTdeMTkEtSRoZHk0AOgNawpkcwu16G5cKnE+Bfkk16n4K6megfgb0PdD3kL5Cui5Y3AaYhnYbs+GJWDkymM9rXldLiDefuGK5Ene66s5461+8deJkFDvxfspu9q5pVgFnCr8zmCdAA0hI56TOWSbdPrQnmCM2AUUi5IRwQNlh7NvNRD2YycdGOajNPYGDvfzdJ33yp+EJT3gcXvGKV+G6970XN/y4DJyp7ERKkN+tsgGzwwdlwlaoOnwdzL7fIT0BrbCu2/r3un+bi7fBZ97n74KI8I1/+yvxI3/wMtNKbVgsxmjme/b2i3YIo2kgUyMPgFJopwBiyz5ZVDRWiLVD4wJpbiNLvUZGwKEnv/Zp9u9PrWXhkcVznbuatSNyu6GZG0C6oC0M6YRmBUlUOx3o0AY6Em3w9Ny1Du2s5tpxQwaKVUCHpkBHt9Wdadg/mIHTugxgCPnCpKxwyyG5P1ndTN5oclDH6i0z5FjTSfdPe6b0DOcct2I4b2Hsv8slZIZ0/fPJjO3SmN30s795vlF0TdQJ4evi4aAE9MBG6q5g9gCSDDzIXJ6mRfFXmvJaI7+1mK/pAMh8CGgzc03BXz5RzSGlJur82hXEXUojc3F5s1oMZRoJZl84NfpUTGvWHtca/CWuNRcNWSGsA/0SuGjO1AzM7Qw4gLNGenMb1nzEwByQljBfB5hRvQSSp0uAO11xZ7zx6/8MS1vwrF94Or7lpd80WS6kCkoOatOUp5SrIebaLdfILSuT9lxEwcnEbPafbdWaerCuCU+trDII7GDUz6ghKAeM3D5xGYiWu/Ls7BKe9axnY74/b+z7lMd0e9f7EWV+YZYSQ4IkTBM1NGayKGurZW15vTOgW+nU1Ex5I1RgvPvsDH/ynrfjHre7K376j14NaTtII7BZwzx5mqRhRGATmRs875cGLl+jrlhmKrZ8XZ9YYpBm0555eJbCsBrbCeg40yV6PazNxToAAzQtNvz8WGESdhhbmpl0oHctF9rJqpJJQ/eAOFHXAJvFIKPRJdYGOah5jhTgp32/5ls4z+t8hXJVtfT3FrAWkCdA1Gytpm0tEFRLlwwqlbll29OK7LNqYlYViG7FcK4/6y1bfQlbKNO08d/XG8KlsONLiUTak5dqiH0B7vU37o1v/LpvwQ+8+AX4pd941aQ5R+qLJf6TmUdCcqeM7IzcYmt7qM0bWlaEsvxW8hxXU/tk8BE4l+cktWeyoLDUlqf74kAzdg9aj32J7RTb6DVwp+YCmu+hYPa0CtZUKfMfo6tP2cGLfilALT1hze2Satb+uuZgPgPamnBeBrjbcEB7hDZ5F6jc1j4+W2/sh9ztw7HrOwDAJ9/nIXiKHIEzCzKQz35XorszmRrpZ3MztJC9kadObSao70i3rYmVk/a8gfM0yu9Q91G29XP8Cam/2B7QDTwS0Dft7468vizI21t5s0KXCUwJbZ/ItVSmba+8zW3wnd/4TXjt638P3/ezP53FN1qBtgPamkO45inlmD7ou78YbSGtutm16A7iteZ3FtWkh0E+5AgyzdlxIcVNYMFNIt5LzwG9Wu6/C6ImjHoKYcDZfa92qGQrl0WDS6M8X6U4So4sMSpdq4mpn93v4QZpDmbrf0V6H6DZOmNehUYK5TTWVSjneiFlMYr00/ib7cqcDhVdug2WVP4IGWVdvN+53pJrzlZjjBYM7DAmSJv2TG7iPlBFykhhSGR7vDfu8VcIzse3OcVplhrtIZunxHzO4QuN0203OqpkpBB3LRkAXv4ffgkfcNe74xGf8fm4zQOvMI2KUjJ1U5vNOuI0pUUt6Qj4aQB3hbJ3r1kpuywNzNoaizV0dyDrEG6ayF+c4frVUjR1E0+TkCU3cPYeNxkR6fsttiXRgHy6loAVGnYje2rFgPQ9uO0hXbVf6QpnGHx1VDirr5m6msFjdPU5S98r8M20zX2AFwZ3GwXQnkZVC8XUqmCMFLp+8U2vwk/93o/jfu9/f3zFCx89Zx0VX3TAmMXUcpmuk7jVw/tGFlO0MrKuRnU+o2i1pjlXOPvvBQXGLjkIJkBXDfkAzJv9gyfPB+zd7nZX/ORP/jj++I//GF/yJY8693U37nETtGkC3CqTUEaSr2rKRzTmn/me78VDPu5q/OPPewRe+9/+EK9/y5uBtqj23NrUIUo8LiRWFZrkmHo6dahmBXgwk4EZqlV77y5NB9IKVynUkGq8AogwWql+Ff4SSkCzmbWZtbwni0I6inz4CbM1Lqy8pQCLL0HazMPhjAiEC7O+n3NvvUq67ZMQRS6fRKD8lMZUUsMC0hHdamBGBXmd7jWxj8ryrMeRgPY/bvrZ5rKqbSjD/ifqbxYsYNGin0y6XSUBfV5H6PPM2rOAeuMffyXgfDwQZd5XCOdzvu4pXhHgBVKF9OfJJxBgs/nQh+OL+KXTSwCAMYatjaRaswGaqDSHt3wsNWk7nGs0bingHWBuCecAtLizNLRkiRKNVifZq2kwm+ZsgW9hzk7tOUzUcc8aiCWhrL2iCqBJwa1KigfV+bnT5gIqZYt9NQti6Su4G1T7HryoBi0GaiynBdIK5tiG1qy50GhWtKStauLrIwHtcO6CYVp0pkzZMK3Zo7QnSViAL/iRR2aZTl+ID7RnJKTPfV5KFL0tnFzecKsq+DwOXrUEdzVtA4cAPtCQBWXVmCfxTX7Mf/j93/98PPjBV+PBD74aL3nJz+AnfuIn/1fePB+xtkk5Hb4aUz4f5i/BlC+7TZ3yYiFmwr72fe+Lj7p+vwf6TgOiuub+ikc0B7mUNl5SNeM4/BJKJl+Y9E+wOBci8z1T+p7hhy0F0nq/ehpfdziXQjuR01+1Z14nOKvWnH2WyGKpG9iEDclpZNI4uZnMao5TgbaP5gsE3MUnxYgjNuUSTQ1erlafP4zWqYK87vv6Kw51FwKaLW325iIuIJX1XbIJsAaG6bnlXN6VBxH4kioHSweTVeiWnfmfdxOch9Tq3C6E+fevw4M5b/q0v4XDuTZ0dFDnfoU0lVxIQab52L0Dn2S5AEiAWSafSJnMdU207YMf9nF43D/5WrzwZ1+IuENL6T64KcXhzCaZe985gzN5EjV3M2u32IqZtsn8mrr4swGayximfZuv0c2n4guAiTbud479AmmRGdDQzFuVLzeA9kGwMn0OZxiYzaTdBdxYwbms4L6ClxXS96BlD1lUk5blFLKchkYN16pNa5bmW43S1mIl6WsW8zdLSzBHY4uOqLXtWUlRZhXlxnK+YWaeryV13/2+UquXRB6yTIBWN4eguhsSpMXMHZONc56L7zukpQC9gnkzOWM183sEZUHbvPYGH4cvfM1rfhWf9mmfChHB7/zO79yUN7tpDwrq+SqLedL6oNSWK5gX3zZg6XjEv/g6fN2jvgy/8YY34E3XvEM7KnkKUWjQ2sIR1uXp9heuwpu+5bm47YUr8MU/9m/xU3/42ry+liPvqTsCvQ19ffJ7zaOyo0Rnh17brtdYPRICWTS4qy1WhlIGqBR197K2DmdhDQpzOCNgmaeJiQzQUtKxVID2yE9yOEftbDJN2MGXfnLXzhNGaakhM6s3//1GeMyymhXSue5WOPutRU3jNBiY5nUWB9H7RtA0bcuftY9wMBMsaM07eIlpzh4UFm003MRtPmk6z+98DpxvxuMWDWeKu9F/SiDHbVC0ZZtZKYjHTQ4z8fiVQ5EK3cQiMWFiHwXU9k7ves+78S3f8a8QxfIrmGs0tmvGXp3HwEzev5itMMiYAS3DgsM8TWdAW8kNyaYPkUbTEGk6oUXrjU/F/raFcqZGzcFeDdWcjaJBIwon1ddTfUMCattM7gxeRm4XBXTbrWADtG7PIIv6lHXrmnJWDkPbp+ZAqjV75KpCmsPnnA0wckhozxuZXjDtVzBvoTxp0XW/+KIPU98KoM/Vco9oGAFUBzDNzx+Fsr3uGKCrtBlDyu/9cblFRvDUp/4rvOQlP413vOMduOaaa8rvtu9z/nscPKj8PZXXhRmbYn5N2nP4mIGojT0BOuHMjfDsF/4IsOyAZTHNeadgdkBTN5O2vvFnf+jH4o5X3gYA8NUf9+n4yf/6Oj0Og7NrfFwuAtlSEKuTmEnbvmPkNDc22d0tTSpcNh7aRGIDZwW0w9k6VlmFPIk5NastDRrcJqatSg3GahYv0nRQ/Ew2ddIYLFBTvDacsM/0G4K1EY2uSwbvbGYe4E6Iu5lJ4LYr18ijeVCDVR/ToC4ApiWnm9GhrHKrfvcI7BfAg2CrnVwBrT5lMQCLdAxaMkCMHNbHTNsuGMxrCOznm8PnWzSc8w5MmTSnfgttuYI6dOu4ISR/dj9p1ZJdOm9l8vpENmk4gG4Pgi/WKrmT5el56pRODLUNuUmbyFFnTSytPWDCWQEtoUEji1oMMUCzVYfqRWv2CWhRwJE+ZZ4wn7wToO0Mit/IM5Bd7ljs+YUqoKm412dae1U16WJarKg/eMcYywDvVvBuBS0reLcH7faqUS9m7l48Glu3MFM2h1kv00p0q9HZTGnGlgnMeXoOwXwYhR/acjVlH4C4/O7Y8xPUBQ0d3/aMZ+J//Nnb8G+e8906gSqk/eftowI3YIsCWdNeXHgV/6/Z+7XNz1s4U/2QG3jk6373d3/3sr+/eY9yf4WwXe7NLZDdJ1r9zFENbAbzPBYDtA0HtGnPaLpwEwg/9lu/i2/+zD/H+9/mtnjKK34OGBf0MoyiM4kA3aAkAJvUG/KGSX/hUQth3zTGJiZQDjQeAefmuetS/M5tQIZpzaJNVGAmbX9U9UV/GhpNDgMrdYW8bTNQ1daxet5F7xFiLn9vW4+ItHKyNCytK4JVC7xNw6ZJCDUw+3mAROKKlyaNzlXw7uLmn98A8pgrJ90QBmbvf42MNNdCJKlB16GAzpSqLPu5FaPFztjxvP4betyi4Ux2o8xQzty1gHRozL5FaNSZVVCBnL5S9ctwzApqLmUioW2LAZU10m8AkQJn8uPRyUCmPXtjdc2FtDKNvOg+LwbmAmhLqYoqVUMlUpVQVXIma7Y+RVEUSCuMGRmpXU3bVcJOrbmufd6sx4tMqs5fitFXk50HjhSDgZY8FYydArrtGOOEwbuR42QYqFdgWSGmXcPSpNAt17OZ5mBFR9haLjJpdKsCWrVjcT9zm3/epgsLcBhXVbTi88A7RW0frDdSXksAA9/9Hd+Br/zHXw4A+JO3/hl+7CdeMrNs4hod/uwagNMrIOw/H4N82U6gPgbo7UHcFGj/Lz7o2JMFxlReV8d5GvPi4xiglxyuOVdAk2rPauFqOFsJ93nq04Ewel0ExqwJSretCYPaCSJjWPRwtQhOuiEyYErA6CZcNmI0by7RVlB3OFukoQPatGZE+pQPj032z3XTtNZz5wBss/czc68FfJEdk65dOg+JHUvqAyfSYpYka5jf2xjaf3p4K1cGWYMWT/2kDaTrGRCDNJufebhw46fLjirEyeCwC9f2qpmaBczbrQNXo7JlKkSyHTegOcftsz+v7s5lH7doOAfotoCmFlNx0qAd2GSvtD+LqGyqUPati2oqpWsbNw31JzOJRsBYRHj7xHEtlQzEadauYNZgE69tbRqz7BTQPANaLLXKC154MwUPABOxG5RXzMQp+4BFhWJSSny/rnGHkC4pVSYedRAWIvQyWsnldFVarNuPN2xnqzLEO2CcCNoJY+wYfDLw1Y99ID71k/4mfvhnfw0/8PO/CNoZmM1HTV0XI+1eZYtTKSvC8c9L3ttN7lI4uTnbT03RlFF8zVsteFuZrZajnhOlZ/N1KgTT/rXvuVZPvQje977r8zpNIN5CeGOO2JIqViID6bFUjoC4j/MAXUBfZvaNe/zvgDgd3T0qR8Sp8Tln+72OVgC91ZwN0n1JMPcd0BzQGV3hnaYmTb4AOUy3naPIhpupOeDskp5MkmAFDBsGtF0iZ/enNoBeo7Y1xgIOZySc/Qgb1NzbkA9djeZkSMZqZm8PpIUFVHEK/JxihII5c68JK4hXNNG8awXyyHampk1TmL1NqGGJ8xhwNqGaAPUKSs4s/3Y1dt4fAgFboFgEodk6KEVw9iJAYmDeblM79lKeffNcKeW5kcfzDPWbMuHjcYuG89z5yMDnucL2vPuIPI3B8w4JsH0UKPtgAzCn/8V+rn1WhdgAzbkQVLWzCgwF0sR+TFY5iAJxBuedac27AucF4CNwZpjJSEJrFll1cnFGlOpDpo0eqhQoH/47sBKiKCaboQZ57UrTya6Fh3oSAa2pablrNx8fYweQNQqhEwFfEDz8YR+M1gj/+OFX44df/UpgN4Alh3TTIHxRKkSMHsnR8Uk05xMlaCVuJJluqDBnu8naYXyQr4wZ1EfBjNkHfSC9A1//5G/En/zJn+Ft17wdP/tzL8dcXGRDHqlXoef+9LpyrcPm7r8b9j7nifEV6tv33IKWjjxX3+d/10PKveSHZMd42WAwIFIIJpN20Zx3R7TnXjTnvgP6Cdpygru93x3wZ++5LgEdAncRg1zzawlmsJqmm5mowz3WNsEJQjpXWdC9NoKoxYrhaYq6FhEZnKVMSNL9uBekTD5TRhxkRXUAyQBDC4WwKRMNFFHNbJZEDfoyixyHKh21s6XAGaLas/CqPvKxQsYA1qGNO8ZQOJsWTayjmrcdzK7wEKSGCJm+QSbA2Fzw58u3jHAO5DlFgwHa1keLvBezaLE4rC3qW1RQYdg+snMV0ybPedKB9IBvlXnOCrTUngPE/pyBmmJrryEPvjAteoos9htoBJC1Qr1NQIOz5whmHViZTdweERXmbNeYDdacx9WqDuodongH4h0gCzB25ndeANagMO/jq64dL9fXIbwGlFnURO0+r8l5Kh696FmYQPjjNxo0+VfBvO65+bpq0Ko5NzSDtFdYikIO4W+m6G5DO6CdCMaJgC4onN/01r/EB97zjnjdf3sr+hUM7Bi0GwrpPiBdFzhx4amqsEVziVQS22cpgC4aSo3IPtCYzwNz/fk8MB/zNW9E7O/6nu9F2PwjkZMQ9Q0rkKWKQ1sn61YQk/kgxAFdH0ckhnj+PO0Z5XX/Lz0O1rPNMRRDQcrmG1BX07Z3njpm2t5Z0REvUxlFSBa05QTv/LffittevIAf/NXfxpf+wE8jilZI0xK6QuZ/1fWAvMAO65aaa88cwYlhlQvJzqrEWRpkM0A3Bsgincn0NFceQBZFDVubotC7v7ehKlhKRW9WkzaJlrWkWC8SzGQap95TeocHzHwKk+JRaEC8bq03M2fVoGUMA7JqzwpoRrMg1kl7LmuUC9HUJPzyPqMbYK01XdEqM4UQHqQJ0GVpmEoAkO0TldfQZACJ9yEUOOfPKSwA4Wv2A7uZt8otHs5Ns2sPwEyWM5xg7gHnWjoPdvEDzn7jtA41FbnfeZj/ZSDLT5JJjVCzlZu3J0u7CwRpanezNokdl+j3IFGfM0kPjZm8B6WZtsUit6MkqEmdHgTCRdprBuZ5RiqcCIIv+uLPwUd9zAPw5Cd+K/ZnZ3pOa9R2HRslJcPugGZm7Eb+7Voxbdt3b81SqUi1iDBtE9oOGDuyNnzAuCB43DNeinHxWowL12K5gkFm8saOgYXVpGeLnYRhiZE1pT1yXbDtZJEWRHE5xYaksrkF8xwcW8pxnjM2vmW9u92CAsSdjbI/gblQRmZnQgypgD6m6crmi5yjYU+v97E1c9fX/v/gcUyZ3z631ZonQJMFSBiYrS9xas82ugZ+eZT2nW9/O9z24gUQET7hg+8FkOUnuDDlZm2TfdzVpRa3BLLXjlYtOoMVtcQfQTBCgBZpZg0jU7INzuKR0Xpdyf++bX0tNrxGNxRietdHqFRcahIyQOvSN/we8JsFi2rNnDE+OY2r88itdjqiRelYFcxjgFbVmptBulkwq2vPnkWSM1Hidmh2WI3co0BlLpBxcK7UxSZsHAC6GBfi1jOpJCLLy5isbvCIAAnt3RnsLjKfn3pJb959c4uGs2ucoZW6Jk11m37d2qybCFoAwMBKofn6hHeN2apaeVATkaXqmKTk66ibt+u6GnA2nIVJ3RGWkG7SDM4GaFZAz2btReHMCmflkKCxaLk+LpKvwLTEYuY1Uy+h4UM/9D74dy94BogI9/pb98AjP/MxoTkfUVuOAxsO6RoI1gqszToQmrPnOTe03tK0vSPri6tgpgsCugjQRd0fFwQ4YR0BZwNz23w3N5E5lK1CV/rmbXGyQhFegakqmQfVvopr7wDMxyB9Q2btycRNOA5mh3IBsnji2pTAhqNwls2XOtCyt49jkK6ArvNCjuz/vwTuY4fqz5834rRRMW2jaM4o2jPNmnQ0v2hA63jHddfj+b/y63jIfe+Dx/zIzyHOvei6I24J82MadvOFu6sK/GyAVsGfmglMlF9ShNG4aec3JtDwbcJLrV0J4AB1PDcACLx8ri5drt15ilEOknwrMi0SEBN0FxV+Jdcq1/IDU7a+sIwENOuIdqVjVThXDTp8z7qGhVnblAeXawl6GQWYjJFqBE2NIcoqE1RcdzDD1krxNZMSzqNEhRNsXZBDQJfvqZaCEvxl3c4meTsuqQs4N/1xi4ZzaM6uHYemnH7cZmlKDudmsCCi7GQWpijRG6ax+m5IA47EtT7yrZu2K6SzHqxv/car0eKOZvX3mPnXjl1h3QuYU4P24XBmds0YYMszJIEBWs23gPb/Zbd/i9fzblj3a5zH00tn8FUwTNvTed6e91l7jn0q8fEmiExR2w3R89b75LaFMBZKn/MOoBMooC8ImgGaLgjoREA7UTgvppWY60GEwWIL2MiB1Ybb6leEtuwP16KlgFVuCMx1jLJlwLuGHTVrT1rzgSSXQK7a8mTKXsoocJZj0PUPHrhhMG+BfOxn2mwv/ziPqzf4l+f94bHfH4CZUms+pjnX4LCAdAF07U5lBPiKH30JgBMVjmiB5QPGORdJsVbPjvtKzZxdwOzCPzddi9hIE2c7GlX4PU7addHh6QBjywsOwhqwSzArWUwMUQLL2znqTQAFoRGQDE4QO2YomJt0VR64uF1cExUvQGLBqD481YtXS+9UKIv7my1yG36fhuY8z5TiFcxjLLXAJX6282gvDtOzA5qtaEl0BzTtmVyLFmBwgBneelPcIuABcyq16y3smjPDTf0O6ZCRSWOBbs7jFg3nhgXNUhtmTbmjYdEtdRAtpsV1NG/j1rQHqVrD009ETU2mHgksrdlWO6oIIXzOtd999cEkmIGtful+5warYy2mQwvpDTBp1KVSmC0Iwt2iCVtozswNLEOFdiisfQaydI2arJqTEN7wB/8dn//ZX40HfeT98G1P+147o4dgnh+bZfUIwdOPT/MwUyOZX14sBUU0UF0jth3MJ4J2ImimNdNFDkCr5myANhOi/3MLAq0G5xUZ6OfH75W67OfDmti5v9WOA8z7Ms7TnCcNmjaQ9jsXG83Z4HkA6CNglgroqhXXh39oL1/EV7p6TW9o+N8cA7MHGd34x02G9jFJkY7sT5DejMn/jA2UaU7Wr13jLP3xwJpRm9OYf1IDP81PWgE9ucvYwD/A4VojeAEktWwN82ebe8osYnDuOlSLdYQM0D6oOZh1bWPSVVIbUzhZgXAw+7UW/QDXEBsczB3tSBm9iOkQQWSKeKAaD/M7K6zbGOpusrQqsoqGYj7n9C/pZf28r34SHv64b8D/eNMb8M8++6PLdTVBP7JAkAoTtGZ55B67m8/KKEeL8wbNSXct2TRojBT2QS5seCJp8SmTKKyrULCRtd3cjVsnnBsaFjicM7BqQSMdCmiFeLMSfK3NcKZuWrMFGak/c4X0ZnBu4OIzdUhzM3NLna9+kwUQ7MZyjdmBXAcXM7DBevJNG83EAS3NfCmk2iLYblrRrjdw85NOKIaCX0yS9Nnziv/4n/GKn3s1KKaePnKRDMNNOeuSE3Tzytg6qBEC7SQBWzwNyOQO6qJppJb3TDsLDjsR0AUGLghwgXV/Z4DuoqZth7MonNsAuAtoX6AsMFO3nxJ9Ptc2mQEd+eM41JIdzseer6A+0JoLhIF5/5jmPFMFCmQnyw5HteeJWLlwp+a8BXN9nb/WP5cxHdcG0DT9/f+ex1ZkOPjlMapvgXwMzNvTOZm6t4OOn8p6YH7talvXeN5f5qbZBi0B7FozT5oemp1pUg1UW0J2iAwT0M1NVcEMie2UkhVFlLIjHFmPZXKAJTngKUZ62QuYyczUYHQZaNIt6pq0ZkN0hxHz4VraVi2AwqYt235jTatqvOk3bVD2+I/6eMgXfTl6X/A3PuhDcLs7vT/e+e6/MIOFrsPoFdBm0fSBlpHVHiA7kIUTWS8bGlRYINEiKZS1IjToT1NS/Szr2q43tpjpNV2eOW+iFgagvveb8biFw3kxIKfW3GhRrRmL/V4h3Q3Q1Bpa6wrmrr1FqQvQJbRmHR3StaauQppUgW2U92O5Pxt08rOZliK70GhFFnChsWcFylxjzhWiYQrGnCamk6TB8/DM22Q9LwTDJHqqGpgt9jytYnaTiuv0kodqe9vFsWqoUbXH9jmq+Ai6LTJhbiYLjCFgKqxvo3W2vrAMWlRAGosYqBPGdCLAiZjfWa+XF3dopjUrnAVtFcOMgFn0+jJScfRvW9l1zI9cfpZjcL6c9jwwa8yX8zNXf7Nf763WLBvNOQBdyXI5OJ+nNdcD3JLsENB0oDn7Q58/xs/LPc5DO9l/R39fD2n6g4PDPQfQguh7Ou0j5iWijFQ5yvpjnDrS0ytNg6QD0GJijGvQrl05/F3TUu222YLPsRKkIA8P0qxKLiy1qOZMS+5nBgpH3Jret3b/k6CzflcRgVCHC+IaAMXowmBuVplMNXlyl413VpP0z8LMwFnL38qNWv2F5nQMSgrAorVZ7NSLnRoB4We+7zn4h1/3VLz5D34H73rP/wQXl5h00jW4m7K0ATTD18imlkW2ANRBXtW4+Jo9Xoi1YAo1aLcvX3NNmDHBR8yvL+H6MGHBb916sQjAODtnll/+cYuGc/fcYHKtWWHdaGfa8s6gvKC3Ba0tBuZmA9YSTaFAnS3YaIVYOoVYc3GfBGyWLB2lJjPl8haBRsAGzgbkAuY2KAR5hTP09zXdC/oegJtVPOdOoaw1eqsm5q+P+xhAseZe5iFlBTr/H8fWIzXrtkX0pgdPDESlMFswat1esS03Pf+0MIZtaWHQTkAeqb0TyE4gBnU2YYAdzr44mS/Nmwnpx0v9opr6UmF6OW34hjToagbfmrarclqjtct1nbRmN6GGG+KYv/kc3/ME5wrd88C9YAZ0fX0CuurKqUEfV2ZvyuOy2vLmiM99g/PAfABoFwr9eTnyOxumlUZZuJKCGPk1EXRIAWph53refwRPvXQtCwbmDk/fZOrQu3iubFib0sDhTL61Y3SBt5i6yS1qdqfGuuTriJB9vyqI9Liru3SwsCoLTKDR0KwyIZngKSULQqGcgCYDtFb/GlH3X03fBvPaHMOFGZ9aDfi5H/we/OwPf4+uu30zFluTu1kzfX0mitxjNWlbQREmyLC/WalkLrqVs0B3qGlPzCzqFgaHM8gB3kJrx/bWrfPv1ghnQjdAd4OygRkOZh2uOfdi3m69oXXSjKkFCmdP0bF8R1laTABvEKWNExTMg7I+M8PbDvrS5zcyVPKtcHY2DbOisW2HCvEuuHsjmGn9BuBF3n3tr/pwfWxl/5ormMurbP4i0y1mTZkv829MY5A2gyfSoDrrf6PLDQm8oheRVfdqK9AGWltB1qwCfaiwFJYM1u48PixfupMVaTCtmaCSeBt6jchMegETT4CMITOYb8hkfUPm7GMm7e22BoMdaM3ngfkYoLfa8w3Buc4K90VXn3Qrrz0GZj8+2WjQW635PO36+KO+y/a5+R0FNbL54AWXBbXM+36Tef7QdmwFFguoTJsoIRraeDe40QqgKb6IQqchihhRK59tizz0+azLoICp1lGK/zy7RH/OOtM23y1dw4PHyPzgLRaBNG8LMEUkszR0aWBmdG5orjFzU7P2gDbeMeFTamc1y9EmS2X0bTNIR+aI+alRPpdgbn6Qac4AyK2UFIAepYBR7Dug3eUI8zuH649Uex5NNWdyMGNa3xLMI66jn1fxe4aaWhlaBXPCmdJYmfNtPb3c9D/3cYuGc0dHL1HZbsbutENHwjlGW9Cbwrk3h7NpzouAogLVom0LlwZZWpSaZDOlaIlrQXdAk21RFSWXDhFa2hS0OTIotDukIehiZloxf5FL6Z5DHUKAGsAGLL83PzWk0frPEiigBne/IVxPToxLeZ8MC6l6seN4QDuaruonoxXNS/dhj0F7wOIBQDCzHdlxDAB7EO0B2hukdSukhfwR4M60tkidagzp1syCvLCeRqg3q11MVCI9fSmq1+KYT/kcc/XR1Klz06noMilVRWvW1cdmcgF09TlP/ufzAL0NDDsG5y2Y6++4vO8M6GMZ7+THCyk/J0pvqibtgmL9ub5PhfTBp53zYXe8wx3xl9e96/BdK6RRweza4/aClZD9GgDm7oqwkIiCOVwZRYO2j9IgMdWcXYP23GOUnx2Yc9OelEmoCBnhHqoas13fvAcMziLl6lNok53FtEuZ0jI7qzm4DTIoG5xXpPY8xDIcCqDNvE2e1igMNkCzaF/qTE0q9frtlFIxDQgKdA3MY2kYluHBsTYThoPZtWe3G7jWzFSybqjIxe5jb4hCU5bhJg1pMYH7mB3MDRE46HEKdgt6kHEkUKy3Qs25U0M3rZnQQzN2LXmhJcC8NAd019G7wnkhtMXhzFYmcoXsmsGZavVMjC46mo5GtoWYdctkLOGwgpGZvMi1ZmNOH4K+KuQ76Xto5V7WPsqeItVUAlUfbvE1e5QnMTzsuJqTvaWb/3MzV8QcutQdkiHNejPNeNYmEkPB7FusaNgHlOdQZveDyrSv5rs9gDMQzmy7h9j7NPJ6wUo87VerjdqE0nTevCGASHwv1fkcxsW87YLvMW35GJjP06C3UdzHzNmT1uxALmAGCifPVfWwcZTi8oA+D841UnSrTR8bFQq0+RkxR+qDztm/qY8K6stD+ny9/I3/6fW49z3/Fn7hNb+Eh37lw498gm9teNWZqdVY8XWIRQhWMFe3xQqF8yoJaQe0uAadgq/7oM/T9BXMxbpFYltESpQLGeT+c+u9XNCbPmd46U9JIEECWipIiAFM0JjRhmrObVQ4E2g1KPvWAB0WqAB0gtnvwSZ6n3pf52ykI6F46tdyibr4jxuBW8NohNGbQrobpA3YYdY2OKtr0UzbAedN0FjckgZfEHS9sesbhZtMgKWGWu0Qlg56YNwqWrTD+bz5ernHLRvOaszWSGczcTcsWAzUC9TnvLQdFgd0W9C7Abo17wSncN4N0G5ArGoQ7wiycynNNOZF4bw2xmiM0QSrac6NBAMdbBYn960knBPMbQB9hYJ5VTh7WfWP+dgH4uoHPxg/9F0/huv+clU4t2ETDGCWSMPQpXcDZgtaaJJgLQXn5kH156p/z2AmN1kbkIfBuAWUFbQKW40sDh1dBnr5uRmcm5wBcgrIKUj0b0XOADkDyR5N9hBZNcJTVrAFleiNzuFjdkuDKhJiCpHMQB52HSYfsxwC+nJwPg/IB4FgmAFdonhnM3Z5DtPKi/PhuR3HipH4lTwGa9eQtylY+bmHYM4HbbbzczM2zwP1jQVtfe32dS7mbY/iXvf4mwCAj3vgR+NAGhKEVSnAHGmHNthuzgpmbtB8XRSlWixPl4G1w/utJ5xbAXR+G3FwGqSJzHo1mXZ0X1+L+JtI02wWfW2RVNQRVrrw3cI0ZoM2iQeQ+WlIQLdB6EN9yG2QBlUOQhu8AbNpzis0MMwK/FQ4R43sWjDFgbyFMlJrblYQKuaemf+F1ETNrYEbYbSGtTfVoIsm7b7oMWnOBmgGeJDFBnk0N2Xmls8LWK2KYdfCBTczeQecvYGKpeaRp+FNHibJ22q9FUZrB5wDzBa/TR0LOhbqWEyDdjgvbcHigO4N3XzOzTXnZQC7DtlVOANjJwZmxroIWmOFNGmUdyM2E7MhTWBBEohSt1TA3FxjNq25k4L5NldexDOf81QQER7w4ffF4z//G0CcQQfCAqaG4Xea3+jQVolNVjM362AMxFQl08RDU2bEghHPub5doW5wJge0ma9pXzTfMxBOoYULzIcGlzxXiEUHeD5kk9WgfAqSS4BcAvgU4FMQnwG8h4w9iG0MhTR7X9th/WDIpPNN8RGy6mBufqswpi10t1C+HJwvN87zNc/yT6HMBtIVigegPgbsLWB7eb96AO5bPl9TPg7lit0Z1A7iY7D+jM/8TDzpm74R3/kd34Gf/LEfw/ZxTBv2588DdWiSRb0mKa+38/ut3/Nv8CV//4vwr77nWw/PfV2Np77CgvQ3V39HasGTtjwE2mFJEtJrTziPhLMHFE2ALlW9xO9LC2wsiczTViwtyuHsna6op/uMzHTtAVY+2FxkHrHdjNBqyrZAqUFoq40haAbjVjRmMpcNDSopg3aPeTpiQLkAugrPWyi71mxWBqoRVda2klsLQKvmbIA27ZkN1FNQmM1OdvmLyhAHM8X5gvB8W7qJHk2/qFc6rGCOfHnM5QcmWVmAUvDppjxu8XBeYFnBpA0XlgnMHTuD864ZpAPQDmdKzXnh0JxlR5ATsuIYmn+7LoKxMHrXse+W7E+sUcKUNwPD733Wa8sIybMNQe8Vzhxw7gvH9xNh9DZADua4Se3Gt0VKzLzbZUDbva1Q07GORkOriNmCANt3CCegAdXA3ThmgCYF/MAwKBei0ZkOXIIa5TUPW49fhQaRBU20aH6PYgUrRM7Q+BTEl0BDB/gUGKeQcQqMPWjsgXUFratumwaakfj3MHO9wTkqgqkbe7OPQ/ieB+YtnC8H5O12Dj6YoXxs/wDS9bGxe06Q3gK7vqZ+EG9efwh+2nzWFsP5W5qOdnt0APAjP/5juPLKK/F//9AP4cVH4OxHRZvtjXmNH0Nq1IQUEYBvePY34xu+/Vu0Zvau29eX+bpUE+wwMPsFJC2tqZqz5rhG4NeKnF+DFdBrtzFSgy6m7QroPHLX0kYIzTOkXVDwsQF0GV5b35u8ZPMIVwoU4A7nLHaimSFgCTjLqpHMGp9pUC4as/4M05wx3QM0JM51as0ocN6AGbAyv9CaEwXMHq2uRT4amDqkNYymPZZHa6ZB9zBxR7BYMWtHXROXdWErXWjLCGOSXh9be91VWO8V9zGX5im0kMZkelzmQXajac9nt0I4N1jvYNOgrS4YFmrYGah31LCjrsO05l1bsPRu2jOhLUCzoDDVnBXOvCPwicJ53QmWHWO/MNrCaJ1BfQSco0sMGAM9TKsiFH4ZWqGftQKtqfbdmmqAHQrXs7Nr8Y1PfCI+5mM+Hv/h370Qva/pUra2c8QNNU+yWVCUg5ikBmfpHeSgniT2ScWrC6Ri2RcscihjxXAw0xnonGIYEu8wILKHyIJureZEgG4Vg2ScQfgUbVwCjfeBxvWg9ZJGN66nwP4Usj8D+l59AM0jtDKaW4UN04KGVQfbQ4uQ7EXlhjMU6MrlgbwF93km7BuC8bFxox8Vnjiyf+x15/3NDY36/6wdn/fJnht/3tH9+dvfjnve615451/+5YFhHZv9rawygbpoyQfx4a41mzKpiy0dnvOa51jdGha0M0Vni/md0KDzzP+WiuVFNlD20WY4V0BPxUkUWO5jEQxo5oIeWLRepIFoW1ujSX3bWY+fDdAeBGr7E7Q9SLI5nE3LFgtcG7Da8wpj7VlBAeO6DTD71mUaF4AixiPh3OxlzQPAzCXX6mWQap0xwzeZsA8FNFMvgO4B6dGOaM7kRhFJP3u3SdNE6yQwFKAChPQENpmVVAGAq/eURWqs3DB2Bc4nuiWHtOfOEyC7WyGcFQdkBj0KMHsJkh0IJwbqHB271tW03Vpqz2HWboA1YxDXmk8EfSdYdwbmZVjald4o1Fzi9pu8pDAwtDuSv2SFRmG3hGqAVRqarHj97/8G/uC3fwftbIfWF715vIB+G2BrLsFhFhLT3rUij2q6HqRlVXpoYO5ckyuYTPTIZTYrBYWTFgrmBepnPkV1tkiA2bRjWSE4A2Mp+YaA8EDjFZ33kHEKGZcU0Ov1oP31wP6Sgnk5g5ydQdoZpCkxvUSgl1h1E6FrQbIKZC+QMz08OQNwJsAxSPvP24Cwuq1wros7X2ZsNeSb9bjZf3gzHnSwd55mfEPoB4CPuu/98Jmf89l4+c/+LPqRT7ucIaF+63NBLQCICpSPALoWgHEXe916q1d/8+jP6LC2CO2IzJY0Z6+LbTk15huEcwW0CsQUZFshxd/iKYZiqYg+yGrJe59oWKAoRREQSXUxwGwQDdux2sbIfnStV8znTCuBV6hZu0K5HMoUEBZmbXuvgHLum16hW7K4ENOaW8s002ysoSt6WOJIo3GEOoZDOrbNBmFQy9QrQIsjia9Homlc7hLwXFWTDqjZxJK4SDoHQ4ogYMGsLe9IoRxD8nfV93xagzJv/OOWDWfSnlSNKGraLwB2RGU07GgLadWke+tYrBhJizKSA7IQZAHYzNljJ+g7RjsZaAuDAs4KiWgt6eao0pfMfToYonDuYjX13SekfuDGbNV0zM/TyQpomFlqMKRpypjn1zUm62nq7+UmXyUKIW1QAehzaCJlWdRIb/U0x4pGI9/PAsDEG8+biJioZzBWCPZg2UFE4cxMGszGjM4rZOzR1jO09RLa/hLacj1ouR44ux60XIK0U0g7A9MejD3Yu92MAemWWkUlf9LN2nsBzgRyJsCpGKQT0HIAahyAWbZgPk9bvhyQ/1fATCjS/Hm0P089p8v8bt7StK+vuxyYb8xYz87w0p/4CQA4gPN5GvN5I15kmhDBLEZ2ZHqaFH5RM8Qj5GupyUGhEE+SBExzsmpZsyY9yt+jwLlqzq1s2wbO6Xeeo/WVit5EgUIVNQG0pBNSwNma8RiQVXtW7Vg2QI7v40JFVxhJk/lamfLQCqBpdUBLgXNqzw5pvyeoLHthjQ8feBqGWZRvunXDtWrMYdIW05o9/Fl0bWEssWV0MOlWAd0Myi0LkEwGFEuVspQpv77aChgIE7aXJxML2HM4e2CXB34tAE4AciBf8K2E9owTmL6ifyu7WyOckX73aDqDmmhC5gqgBHQjGw1La6o9R7UwgXesEYvO5kV9zW1nUN4xsDM4LItqb1Y4QyU8LXsHCLS1o0ulegNknWkHs5lPZEQ8Cjo2YBatouV5eESAtSnzCeZmdfugBDStBma3jStdqq85AlGQC6IGgxFyZVoBapBIkbLUAjRE+7RIvRpg7CFyApYFwos150BYEmSskHVFW87Q96eQ5RJ4fwltuQT0S6B+CUKXIHSm2rfswbwHryt4P8CLLlZRrUxETXOrDYfxaR0K6kMtGsfLcN4QmG+YfZd/OENrpaYDIB8b9QB8vxLncn+XP9PB/nxovt2OSFU7eP7w7449bgjIIsq0w6PJ0wU/VaXYB5hALVOEwhwdkUc2MgF+BlkUJnEBeyBM4gFnKf7mAewNxFNA2GFQ2CGc/XoU03YNjjAqSs33t4YWUSyBNd8/I80LrGtp0uH+av/scjKN9b726Mc5mMUOxaAd5mzawFkSzjIPKXOBRa2cbvHjphksREVr9s554trzosI9FoOzATq2HaPYH0szTV8ZINMz1RZPLk3YGqpzINpWlsh4BYoElMnBfFF0a4OOaM+y3Arh7AEGPbYOZtXlvNnMbhquRasJvFOBcwkh5Ab0rtHZWj1sAMsOWBTKvOzAfWDpCubeNJK5U2kvxg3sErkHZAAAPM1H9M4oUI52dhGMaykUkSBtB5pvhhBTQ3Mv4q2YecwB7TAuW8A+w98LDX7nckxkVzs6lGwWkR1gBlxnVpP2HiJnCmfp4OiiBfBg8FjBY0Vf9+CugKZ2Ca1dArVLQDsF6BSCU30f3uvfrCt4WcF9aBES+xdwHoDsbZwBciYQg7NUM/ceE6ClFhvZ+pjPg3GFMjb7tPm5Pvxcy/YN6hv56uYpcLOqLpufczK08h7H1Hvdz/ecv0zNg9dFVTbwlQnEx8PL8hTU7Q2JHccMEP58fSf3PzugSSi051z5K6C3ULZhQNfXSIGzfaoQtA40UgtdWaX2lVNbXglTKtUmnWrrd56jkfz+qqZtL9CzzqOtqT27Bl18y+5fDkgPmTPsmtj5S7N21GGZLejhU9aPFsCDwkxImUzZk9acUzc+A4DqxKLFVmwGqmehaM1Rga3HcDCLLGDZ2XqygGUBSy+jNgPy1a2Ys70hh0dfm1XQZxQgUeCFoCeFSLLvwiLATszXDO2QdwGA9Z7HRViDHqTmvOj5V6vqTX/8FYBzLd7h+cJAJ4Fd1qlkQ4Qwmdm7NwV03LvegqwBo6tvmCwqW/qAdIUy9wFeFoy2oPcVnczcYhGYWiFHC4/Em9vdSaEecNybYsnsYrlzElD2RUOd1uL5fyhQNDBmqzOfiAnm8M1uSCMG5jRr23GSL/juc/YzvUfqT3rvZ1MMhrg5Gzsw3KTdzaStfi1uDF4HuK3gtqK3M3A7Q6NTUDsF0SUQLgFyCuEzHWOPsd9j7FaMZWD0gVHgzMLgIeDqdzbfcwU0PLX6TAGOfW7PhfJ55uvtY0uhKjzVc+uFKeL1JrlP2vMM6C1sw18Zi41/0hZts7OcDr5M5r9vNekEs4S2vI0Rvxyob6zm7EdCZd9fx0JRPaqeRu+uRh7URAlocldSWJhMmPUjjJumpXbd/fXApJoXAXpOnXIYU27HZhvdcVxrdkAfgXNYp1R7Fmj1vKygtyLyMMncaa49G6QD1MOCn8LqJpYn7d8tT7DHpimgJeHs2rNryK45R21t5NYu2gRnzGAmEwnyZ722Cufia54AbVqzLBDZmYtsB2YDNC9g7jYsJ3oSOw3K3ieytPjM8g4Sf0E2t7yIi/fDRuesIrkT05xFYXwRBmeZAV0it2/1cFbDRu53+7kHsBPcC8kcY0y10YROYq3L3NWMRGq+XtpiWnI20uh9wdoWNE/xQUfDAIvWyA3IKcXgEZVZEZBzPjZA2gouUPZJojl/wxLz26bCzRaQXojE+pFSaluy+VdXUHF1xH820zaFlJnLbjWEZpvMEXAWBzNcsvVKPaKac+PUhNserZ2hkQHac6blFMKnEN5DVgUz71YFc9ca3oO0tOgQbX7BQ8CrqCYc2rMBuvqbq2m7aMyyhXOlyHx69HFAIMFc/1mOvch+JZHaMpm1Dwog2OIygdXB3OobgibN2eF8fgTbFsxbKCuYUxzb7tdxDND1FG3FhgplKX/jSxnb+zEsoMhXzy2kq9Zs2jFRiwYGWb+6DF+oPW915N9mcWcDc8g4DmcyDZpMa6YNlCm3UrYxj7aiSXXietClmbiradsLpDRLJXQNWlKLFrPUkVXB8/asAeZ6j29kBA8e85xmKbCWkb+LCG+fmi7Ll+mrH0HTdZ2Hp05lQJj24HWNObfCCmVhHcw7c5XpEO7goeKjluz0pdaUFRmQMYCxYtspzguloETZhNuxifXFdjizmrZ3W0gj4Exb7bnDlJub/rhFwzkCqtBi3z0PCWwHNRugOeIAa1tXz67TR4OGminstA2lFfagVRO2yNtVapAW+XA7EtnNT80kXEoTNcGiBu3ebTz5onMGJ5zF2ivx9C1hQRBm5LSgBxYpgLYhqSWXE1jgrk9JngTknasJYsfhnEKBltdcIbRD2C2k5fA1hFkBvQ4wGZxpjwYFNOEM5CTlM8g4A+/24N0KXgZGN0AT64B+5+FwNkDzXkdAeg8LFMOsNR/TmLfqXTlnN/hwr0Bd/OJ8evlLqU9hUmOkpIgdANlHIrGKU9UIfPzvEtR0sJXNONSULz/mvzmmPR/TmP0op78RAFZMotnR5XvZ0QmZQUoFPyLzN2cbMgVmBbIFGmVrOYuwLu3/piOJgxQ7dSNhvAJZS50OwcwocLZ9SAG0v/kWztWc7Rq0/SwrwMPM26o9k5gw7xp0k0i9pGKBi2pjKIewVeLdkldM1+klU+H6IK50e0FRvuskevm18+XNBCm3YhStWWQBWONVhBfIWCB9Bxkn4L7Tn9sO3BaL9THVzMHs1kDP7uBRLBtUfOUMkq6WTtmU4bG1tzVzbXYzc0enPADWdz6Cwi4ifc+mAbLcCjXnXFD4yMjKWCQlXEByEYq8O/iCQnHvNAMKS9f0JAMxyQLCCrL+uhSlYdYinZcmAl4qLirXAzCYAq45pdYOuJAtEK2pBfPWACF2kKUPbPWg0mPZgCVkfpeQmnOd0OOqcJYZzv6cCz4y3PhjvzKNGaalY6C71mwiUPiD2DrMMBTMpHW6dWh9bh8ke4Uz74FxBln3kP3etGb1N4/GWkKVGEMM0OzaM8CrDvU/myZdoIy1gHkb+HVDJuztOdqCfLvoGazTnVF1SYXycQ3a1JnQnitop1lr75WatEwHsAXzoXl79kGn+JUm7UNNuZ+zXwFdT5efygplR9MxkPuDRZnZhEL08GV0Nm+bZ9NM2BTRKH6EGQWsgO7qP44avh7kaEcTN4rYqTKt2UF9cFr9htxst/nX9QdXPy8L6DJcey4lRyW0aCmgFpNHJMt2kqRRwBe6Y3D2w9lWRgsBZZo6RWumEk7hgmi99g7mcu0MzO5vliI0qdbsgN5Bxs4AvTMw7yCk1jkRLX4U3aYsbkCrNNp5s+8TZnvmMppGjttaHK1nyVybrkUXSGtdjNSiFdTIyG2H83psEbnhxy0czqnZhQYQWocCuswsg6z9bqqp21BLyZBNtJw0diMfGa7RotmE8gjm2ke0lIvzRTr0nbhurBoAkFou/HUOwQbvR8Wmy8YtHetBNV4XM3ZRAqK2bF0RCQlmKoflxwbXXoZ+BwCQ8jnikZALhPYB5zadC5NoSSBDNXstCapFU6KJhuxBvAJjDww1acuygvcWCNa1rvlqmvMKNWsPNu2ZzbQ9RO9LD/hySG+Cv2QL5mkhzXMS26oQYPP6aRhVuJj6Kqy5/LH7nX3B9oOpUKahc3ED57wb/AP82S2cGdvVtUL5UHM+DAbLGI+SKbHZbrXn+tgqWQ5mP7I8dsrzbM/ona5Hla+pC32YohDWq2Ng5g7wklB2MLdi9fKbo944DDVr1zSl86AVc4kO50Q9EwHncp0iIqtCuvibxYeZogzMXjEMPSON0RLK/nXC5lXkQJ+Psyyo32uagiZ0hPmaN99NyrWLWWkpb4SI4I6DsWvm1y/M2dwONee2g6w7CJ1AaAfeWui4AR4z5BcsfM2rfq8K5rEYmIe2xkQzC6qmd3moUAtIc4H0BtCLWJS2RLQ27UTN2ie3ajjraucRrNPWA6PEhz6n+11ByGzpF6rVxNz3snaDIEN9WNIauCmUNTCrpeRmvT5duxWviuXBUDaxKVIPJL6CWOs2bamGTLss9YAV2mTfrBboLJY1EftZigDvxTotmIy8RZokLKmYvI+qMH6gtkjaHU1+N3s9YtHa2lrdR6u2CYqAwn5lvLuURrk3aL1tkhXEK4j36iNaV2C/KpwXC8RrA6O5WVt19lXc76zxOm7JEvc/D8xg9p+L6e6otnxgSSino+7XvyvvU+Lq4vdUL7BA/YMOaFQt+shqT7bYHIC5Ggz9o7Zw3oI5AZ0dy4AK5QTyrCXX0Tb79eguB2e/c/3ILneaxUzYKtj6kfmrTZBmPVoK8cG156oxL0BbCpyXWWumPHq9DAaabS7xyMjoCdhRKcv/Zjs/JLf+wrjOHmHlcC6aNNmEpZF+5ur0nYYBOYptICxnBCmzZANoEyIroFF8yzmvZQr+gp2nCHT3q1KXEysa41KCTJYJ05qr9kwdMjqk9QSzb5sBGuaLlg5hLfGJ6l+f4ExxfWiYtjwYjTtIOpqo266BtO5FyjZRmrmRgrltAI3YQiO0Fxi0ddqN5VYK5ykIahoKYMYAy7yvg3VrzcTBLYMoyuI+htab9bZl7Anv7sWWpmZb+51rpQwL7Tcw8yDc4cKd8cEfcD+89o9+Cd4LVYYUCxVDuFmrSJ0ckLwJ9L6wJVUIt3m/98N9H/jh+P++/D/n0kuHy6/+eSsQJmRifgEzWazvMUiLn2+247KC+n5Xe/AGrbqNJT1NjwpnfdZbP3azATTRkXAeCedF88q5D4hpzdwkfM63u92dcP97Pwi/9JsvS83ZzdsmaPk2wHxEkZRynqfvf569dTo3caIjiol8FRRbGNneLCANuPmxatFZ3tFWzcmk7Zpdyw8KtB1DtP5eDmZFastV0pjN2VUTPg/QchTUW9N2PVUM4EOuvhp/+Y534C1velMRBObXSTnCZvtR9buUe/QVWdyvzPNRkvswu3ZLUyDbMI2ZwqS9ESviQAQRtW0Apojkzm1U6nJTuGuTB2AuRKxWEgdKjcKq0Vj+s5u2K6gdzm7SZvtKLDMt60zZCA/i83Z7WCGkxNSJtUmHpM+2mLTjGkm9vj47XXtORQam4Egz4I5FTde0aCwL7RTK2EFwgojoHh3SW1y+tCKtFmwGi0qv5uwB4m6VGRsatPKi9mrYADrmfwG1B+t6LrSZv/NGUWC3diuEs/tSxQOgIGBLI2LhCcZDtKPRkBWDu3Y24gbiDmFGGyODHlZNaxqruqRG01ZkKxVtVWxwAw9vaWbVatzDbXAeDJzQRbz8y1+LpS941R/+PJ74I4+GrAqQtnqLNqBZIEYbYhMpJWJhhjdGR2v46df9Ak5OTvDaX/5VPObzHjvrRxSVtFVc8Sj0gHHLMnYmBkdLOl39yiTHtLhwCA9ikNaVgFxKDXiklCwAuqjc3llFqoYENDmc2cYYwBiaMrJa0RfTmrmpz3qQoO06Xv39b8JuOcEv/pf/iEc96XNVkTEBS2IrYb4utVhywamLFHBcYz4P1hs4k/uVy2KWcUaiwiDs2pp/kNxP6GfLFm530Uw2R1gZRxmbg3Esh14UUKYjX/YwQtt/rlduNlXPEM40xS2gK+LyaHR86Td9Ex79Ld8CAPiHH/ER+IPXvW5zKlO0CG8TzNBAUP8y6cIfR2vCCnGDtK73dal8QH6kvNvA2QC99TcHnKUM2MQieNGP7G7FgC361dI1/W1Nkav7IR0WGtaSu9suExiIyiGT9O7CXG7dsxJfh+rZLYewPZwNiN3ap0sEhfJQz5bzvywfeTXjP7JlhKb0N4RZWzVnMZehAronoLEknEWjtsELpGtgnzT/gn7w/t6Ia0WsRZpaBbNo6+FO1kipEbqQl+GeGnfUOIztfRMzuMT4jBqEexMet2g4u45MKJ2HxU2dFigkjGFwXq0f8CpDfZrcIGOgR89SwPt1chMMGyuVjBuD8sqEMazZt/URHVY+bpCCeYAwTHO+7VV3QG8dAHCvO34gRsmW0Fq2Ei6lNsz0bYD++I//JHzhFz0aL3je9+LX/9N/AYvg4hUXsdvtAAD3uNff0CrahMnMHUu5zc8Ac4PeuM1BzQHqAHS56VX5s0knYusKaw6qlf3SfbUWVDCn706vmb6joLEW5BMRsLBpzWxC09D6wQ7nbtXAuqZgCel2kOD9Lt4eS9fz8Lf+2geBL1lXMIZp0EWxODYqkG0bQTN26IT8GgcqHsrfllN3COUNoO1NiIFIffFtueG3i21A2xZxseL8HgMeDu04qCp5bKWQ4/7lY+NYMJiGSB4C+jzTtn/qB3/ER2jNYgD3vt/98N8O4GwwPnKU5OZt6MKeJm4/B6Y5WwzIZM4Wg7EUSAec7VtR6OY5Odwf4wv8BDD9XeTSck4sKtqsVCDLfA0Oabi1JxdI10YYtfqHB4LF1k+gxJzLebuBRTmUuP0L90sRLbOSS0C61m05ADTqR+aNJHaO06KmsT3iVg9qGllNDRhWJYx6gbMB2q6j+qQ7onMUIc9NxPno9dDobF3/NUq7o4k1HiaDMho6EzobnHmGtPanzi3MghgBnybMuN9mlc35vpGPWzicEZGcavBT/2OTAmYMrMLa51gWkKzwYC4eA0tbMaJvKdQcZHDmZv5MCPYi2tCIdayDsC6EtRHWTlaHgGwAw83PrDD/vI/5fLz39L1453V/ia/5wX+C9QyRJdFWBzSi1kAUA2DgGc/+t9jtTnC/B3wY/s4DPhIihPdcez2e+7Tn4pM+45Px1K9/FlaUGHWak2Q8RsbBLA7mloDWNC+e70a7QyP9okxEmHYoDfAqSEys9b6rNAzENi189o/1WjVh08Ytp9CkWwy2BhdqvuOmQgTbMTMJ3nHNX+DbnvfN+OS/85n450/7KozTtDTGmuoQduVkszZOt845dHKlahtEF392ZK2NINyyxtag/fg4E/DJ3qhqtAeLeaRY2Zm0DxbR13tuun6nijqZvucx+eLY199CuQZ+6T4dmLaPac95FMC3fdmX4crb3hZvf8tb8IsvfGEsQvUUmh4c/Iv6IDBRRIrmVcHsg7vmOnstXAc0LYBY+yDeAdRBtCBM2lrj0g7Izz9bug9MG3bt2V7DDmId4sFaBc5kgigOrunGonE0Qn8D7Qpytnu1RGirwujzBRtaHgHFPE3gLpntWzTk89WaElvJ6+NzqW7FAB1Q9mEWxuxGZbNslJlFaQWJxsnsuc8eP9AAIguAEwDDvq6EsKRaswFZepqzYZqzWIIsl+GAZnivIwUzIy0K7ECWAJPf823cKuFcUys0LoNITQ4r2Hy3JinJUAJyh/AK4Y4+GkYj1ZxXWISjBn3ppZVI01E4C/Ys2A8bq2DfvVgQYSWvSUBa6Q9aSm4w8FV/96vRWsPSFvzRn75RO7tYa0PeA7QnA3V2giHLyXvvtdfiDne8E97z7ndjzwRh9XP/+3/7A/je7/whrVuNblqz9bgiOz+kJu5IMfD86qkvLEfXqywO73ep5lEKuGjNPgHZFgK96YihaSwW/Cbl+qiPUHIBoNTaWSSvlYGYLApVhm19UILZx3Of9yx8x/OeieijLUjt2RZUlycmAtSHabYO3wjYnR2vWWjKJ118v5iUM5ibZJN6MoELuTQhNFbTmglws3aYySKK25BbQmw9ZSogjfQ5z4A+PFZfQvMfyvZw/3JBYedpz8fgfOld78K//JRPwUA2xtjKNtWjHm5TmsE8AzqPjsIAaeZtKhpz0y2RAZpssbdgsPzGZcK4+yAEU3PohqCnr/VgU3I4w4tg6AtJUtjN96+m6So9bqG8fa6CvRyru0p8Lk4qrb18K5lVhm/2Hbp1W4G8hfR25A3lAjpltojFCWjN7bS6EesMkhqkN7Leo1cdFI+6HwpniVx1P582w+O6jdCWSaxGhXSFMqzPAtS0vXBqz0uAmQzOqsw1y/mOEX2BJGU8EbT9rRDOA15+pFwLsYVO1FnvcIZHafOq5d7GqhdjEPpa8oypW7CSyalmFl95YD8Y+x0rlBcHs2DfBStJVvND8RAZnN/6P/8Ef/P974nXv/X3sJ7mhXQoUwCaNk3OCZ/26Z+CT/2Uz8TLXvpy7Nny+TwQzQd0DCthx+Yf1/6msIC2AuduWnOX0EyltswLs5mHMyvkyBelKTpV9z3ISi+DRaejLLji+2LrkUKlEZf3lizuT35cqd1zwBmR5TItWQXQx1x+dQsgoVx+9lVnirvq8+8O1QJMayxY/z60ZQPzpDHDF0OJfQWxr2UGaD+4gDKcFfBXiT1ZIRfXYbtkFlv7VhutR5eAJvvKZKeg4q+OWYs+D84+q+pXSyDPQkAzAa8KC/GHJk2RSVKTaduDw8iDvVyDdlP2AtBOtebQzOxbhmRTTKNYodq3IH2k+aVkCo5M7dlTNyMgr1g45jc4pkEf2Z4XKDFp5fXM1ofEdzs+D+exhXCjGdBb90UDcOHkBB//kIfiV17xSoz9qB9doGzz0ooqkegW0jRA12YXUYm2LyU9NR1OA/yENcBPmqe0+oRjzB/OAeQwZ8c/BXQT1ZwXEDoRlmZwHqZBDx1R/8WtnN6vxGU9F+JNiaH1yKW4EY+/AnA2XwVtFpvwA5g0yireMA3wWDHIwExUigPpTaApUgZWM48rnAfWwdh3xn6xbWOsTXSQDjWFG6CNXZ/8zQ/FnW5zB/z5O99uWUdUAO2jGaAbaNWB0fHuS5fw4z/+EmBtJjHqli0v0MHM1NScXtqnMSmgY277NuBsAOwViO7bUo1BPGc8wKwQzdxHsdVW7/CqucXaggQjbGlyIcolXbJQUdWa9bnqC4/KP2RWRfIwwCP6hOT26FpFR/Yd1AXIvmbLjcgTmsBstAlrKZWBI0OQjcaMRlv+Q1KSEAAoi50j/jBExc3cFNu6/FL5QmS+wH/+DV+N3/+d38cv/OzLDhbrNuPvqMn7huBcH/5cx6wxz5qY/RPEMVZNX+y86H7Vnrcx5Law02KmbOtdR+V1VIq6iOvuA641R0R4BbTDMfzLVkcBlroJjafImWo2JSlaNG1ha9ar2B55zRbObrL2G86FuzjT5UF1XiFu0LjW9vsmsJ7xZV8O3RsuwL36jX+Mu3zAB+Ctb3wjPv2D758fZtcpih+BorY2++zyWBVLqXJQk6WqRrcqsZx0LnnqDufQnHPmafGpAua6JYM0dTNpp+a8cEMfdcsK57UMV64WifAFvUcFYNJ0q1PcrMctG86ipTOj4m8NRDLJRWywsEZr08CgFSsXOPuCSQyNQXU/iMGZGesYOtYV6zKw31c4M/ZNsBJPgB4iAWcR4Jrr/sI0TFJql36pauY2MBucvXk7DTfh6HBAc/Q7zcrikerlgLbez9wBaaRQNjibM0XB7HCuxfWdKjLmtWDYxBvQKOOBACwGQHUhsBvflEL7TSWmpWRRmmZBdtJMTN+CWYAENGYdYlq+ZD5sALEiOYRDiLC1NoBqbsoDl9eWHvWxMWlH2mzMrwJiYA6m8TFBnGYX4eZgA8SRb1/jSLff3fc2X0Bm1P3Ai56Lhz/yMyEi+KQHPRR/+Du/u4FhArOW6zxvXA7OsnndIZAPhZhyCVNY8d+akE6S+c5wSIv6oMP/TA5l1ZyJPC+6Hq0VDRUTH8R/zvOfX8rh7BqyVSPwOgvuhJOqNWtu+RQsVqOxtsGADu16Jmm+yofbPD0R71CF0XJut9fBteUGC4byfUqxbntL3PHOdwYA3OXud8eu+ol8rrryEK4JB3BKxRJQVjAHoGt1t7YFc/qc9Tz6/NmIjQb56mdu6GjNtgbn7kDuDctQ03ZfG/oQ9CEawLtXOLczAXUq97qkeagTcGkrkt64xy0azowFQxY1lwghqnO5lAbMcBbG4GFa86qXPeBsN4UMXeCEwnc5xsAYA+tYsXYDdFux7wOrw9nAPDZwZogHdII5PgJekzeLAanWjNW15p4N3YcNTj+LWF5xas99grNQw0Me+iD8m2f9E/zCq1+Hxz35+TGvvRG4LGyAtujopulKoAFqFh3ny6SlT4D1b9Wfyvo9jCB+C+oaY9GL5nuJYhxOTcAWqtjVZdHIFbFk9ne6Hmqwh8DB7JJ4NRL6cucfZkdGnsONmRYuxxGm3gjiQPbOMu5QrSbuzXttTdpxswZsZyC35vs16tUWLZo1xTgJDmYqMBaHckI64pV8UYSeJ5JuZ8tV+roQNly4cCHur5MLF+EaKRWIVx38wPQZI+F9DM5+qo6BeYZ0Pc3FrF1QrXK4nxs78W5Nk2odcEirCck1ZnJgFzin5x62oAtgrWAdOFtFNQK+puhDh3Satr0kUGrRGz/0BNzLDDp2VpH3Y5w8SddKAXT8mopg6HNTTFZvtjTYtgNoRGmTEBg+9ex985c/Gl/8tY/H85/xLOziOqXFJuo/WEaLu9/IrRE2h8EqVBEayEx+2r1K9zWy2+Hc8oYjc0v4jR1CkDtBHfipORO1jNhGQ+OOzh2dBzo3LNzRB2MZgr4y+qqgbnsFNHXS4nLOEVHFxVtG4lLO2pvyuEXDeWAHwgK2U61QnhcpEWhKDTTVatBQrZlMax4h04EsREX9pRTpOKOzAnodWPseo69YuwG6rfqebWC1LkkrrFMSLK3HA5IYUTFsrtRHIOsH6xqzbpcE87D9AHMCWrXnaJqpWjQ1POfbvgr3+Gt3wqO/5KH4pm97Md553fWQxTTnRYDFtOZF22FqGzpvTdegUkNqCjCtkEIrFFBzc2gxmErZii8IxZd6oM7qQxUQMjBrsRR9KiFc9xlxWDOYafMRZUEKbZni6VkB24LZM3D856IuxN8hP6xqzW54mMDsWylbhnVFy5KBOo6EaYlFs1Ygm/Uo5wCFaBKV4eDnT6BaSERV2AKoYPrSL3gCnvFtX4ff+63fxet+/XXocfL0v9k3mSA7ZjTfyi/+OO8129ceX9LmTyZBpOb4RZUIFEv0V0+263wkagqlAPOsOVNcWPU7hwkdFHNXALMIudk7txXQNblRqsZ8FNA4B9AoN1UB8nTT6aD86gcSzzEwNxQoi0M3t91e0xnoBdSdvNWPntVfeOEL8aoffRFICCf+YcXKE90PxGpCmPA0pgAPvT7CG9+zdJApI2QVwSKv3So2xhfyc1Wvt8PYAU1qeW1kmjN3NCiYE9CMzoxldIXzaOiroO8FrTe0M5cNOGemiEYG27oh1x+dyDf4uMXDGdhZcQKth1ordHkkIMPKWoqe6I4R0l8aAhletzhrYiecubNCua0Yfa/btmJtZib3cpLwLVv0sMNZIrvCo5kVzgRvN+c+ZjJtmcZimrOVG7Q6s2ratso46Dmog72sKDX8ymv/CF/wiDvh2vdewjvfK5DlYgGzac4Lmwa9mgbdFdBVCnVN2IqiUCuD/BymGbKJqKbVJDVCe6+4b+wa1jUmNgR4HXHdL74qMuBQMd0GjG15CwnAVQH9fIGmN0grn1upMK8NYdqmDq2XW03drhmXR6SddkRaHlEufAFkhtbuZaC1LBeov9d5HNozPFDLV9w01WYXcwVzQ5aOVV+eLonZGDLPE8FroWtjF9eg9/s9/sXjnoqGvQoMqFozdE6ExOMA8/N9+NgCVza/w+b3x/5m+/r68+GnOjz1/Pm+m7uroKP/0mOa+0CatPM1DmUpX0T3LTVwCvaqYHYgVy3arkGBcAIawHTFcGTftlS2VQKM+SyRYeBCX0Aa+vOdbn9H3Pfe98Ov/cavJJhFzdid1TKrMLZSLgFo0t+hArpYV7YpUyiBq9AArBnK2zmtwBS37nhqnFlHSCyi2/LaKUxVAs+jJ0rNGdE1ULXl6CRIHQ0LGlYFtXR0S7VyOHfW4kl9CJZVl8u2d8VdTIDQxYWGRBlPNGC5NZq1h3W1dvmzw6bwgaRmlliRAmczgNs2LqCbCaVo3SPhPJqPPda2x2h7DFpzgK3HsP0zrdn9ziiAjvZywzTnUaBs2rLu7wqYVZUT9oLvS4A5Ia2T9su+5kfwpGf+HK5553WQfkXxNWMG8zKAZQGWVSd59ztZz7Pe/5LR2UMi9UxvuWZg4dAE3crkMKoapDMzllfRZQlbsyA1aEONrAcu/jz4XA05F60Q3GdtYvMg5GvgbkkDtGfgRJ5QNW9v4OyBYBZHN/uYXSPxmDsGuoO5pfYcxfbDtO2QTlOt2OKU2nIvW13U/LMVAqMAWuycsi1UntCkc5/cLIxWhIJyEv2kBqWOns3pmZu3NJ3z1thcwupAPXoEBtsSNBaQdtcBivABZ5f9L+XTNl8ko+XNMoZZc5YK6q2ZGyU9cQI0XMTMD91KsJOW7GpvPl/dM1P69gbSBOCqK6/Em3/9GuyWHX78Z34Ej/lnXxx9NDolmEuNNQO0gblRgls2cHYLj83Z7Bmo/t4R802l3qzFr1pyszKeBNWUiVRzJuttALN8oPm9EU5fgGzGxwkw47tB2d0b5O8vHYQFBE2F01zoReswMKOx4HZX3h5/7/O/FK/51Z/ANX/xBvQuaHuoEgJtXQxmM2nriaIG8K3TrH0RwA4MMe3ZtzW9xozVAnTWziLdtBadq45wC4DyDkoC03RFy0Wymra5wHkGs0aCD9WZ7Z9FE5fANHFbLEPB7C3SDM7kWrKDma1Ygifb807hLDvA8/7KNmrTmvb8Z3++hywX/KsZmEUDwRYGdqxQXoaJwzYa5bq30ZyzrmxPq1lohYLW7XWNFFatApoKO8VYbItS5O66o9nDltle6pqxeyt5BjJQ6K/Cg2qRvooS4L7w/IvgT5yjXC9mIFdI+wJYzhFMEIkFEKoJO4wdzN28Bs1PddPKRI1hAYpu4k4wp/ZW3TZbMKvlJBdBda3oUjkQPcq8z7d/QWumkZ5Dg9JG8/RzGKgggleOk8uM+rgxrzv2d5XI58I+BJJDGWwG78QypH6X1h/4c1KPJgWSyC+X2IMUKE/5A5HfnHXN3dmQoC7fPLThjYbsB42Dg0cpAr2J0qKo91zcsjE/73bXu2LpioEH3PfD0RbTksWgzLB0ImAxWGejXAOzpRx1OqY553z1fgTD4Ox+X0yA7ujwjnYW+Eqa6iRUzNL2ZcTcEpoTXTUAP0duwk7NmaSDWrb+JVIoNwOzNuExMVcWaCUwwb/+zp/GXe761/BZn/sV+PIvvXe4uyOgGGJuLdZEgK5aSDvdSvE37nGT/up5z3sePuzDPgy3u93tcLvb3Q5XX301fv7nfz5+LyJ4ylOegrvf/e644oor8Imf+In4/d///ek9Tk9P8TVf8zW4853vjKuuugqf8zmfgz/90z+9WQc/cLGMC1hxAStOsMcOqyzYy4K9NOyl4UxgQ3DKjFMeOOVVx9jjEu9xaZzh0jjF6TjF6VrHGU73pzjbn8XYn+1jrGcrxtmK9VS342xgnDHGGYNPGXwq4FPoOCPwKYHPCGNP4D2Bzxp438Frx1g7eF3AY8EYO4xxEoP5AlguYMgFPOYrH4bf/Z1/gy9/9KeCcRGMKyC2ZboIpisg7QoIXdTRLkK6btEuQpaLwHIR6BeA5QKwnAC7C6DdCbDbgZadbnfLPJYO2nXQ0tGWpqPn6L2htYbeuuaRt4ZOXQe63XL6f5PFZOXFAjKyck8WC2gRpU5s9ORmlgffkudWaRS5a+tswoEFs0XAFUKJUAuKDfJ91/p9a6btSI+93CivbX3znN/MvYDZFzwCFqIYu6OjxTihXn7uWJoN0qHnf8HSFtvXn1vrOqihNTfvadSq7pvG49uQXMzwasJPeGTp8sA9N5L+BgbK1hfbCcpB0QKreCTY0g9+WA+5nTdE0IXRpTiN4metBd9FNj9vbRfWL164oKl+vqsOrjHXkMZypiat2YEsZQJjAnOka09xEwRa6HCu7oC3XPNmPPf7n43f+r1fw1d8/RegL0DfQbcL0Dth6WZY68CuEXa+bcBJI5zQkYGGE5+rsHmKjh10u9jQf4uakdHRZV4LyH729WDbvpe4p4JT96U8l/mjKXFHZGyKGppWtwDYGbA1pqlhAcmC3aIhbq01NHM/ksUH0b6DzhrotKGdNtClBrpEMW7O4yZpzn/9r/91POtZz8IHfuAHAgB+4Ad+AJ/7uZ+L3/7t38aHfMiH4NnPfja+/du/HS94wQvwQR/0QXja056Ghz70oXjDG96A2972tgCAxz/+8XjpS1+KF73oRbjTne6EJz7xifisz/os/OZv/iZ67zfp4AVXWlCYSaKiFa7Etg1WtxmabDXIbhiwRchqTu0UDeuLjvgQKxnpDRdW3SfVnplWMPZg2ltv4hyqnRSJmpG1AgwuUidR8S2TacuqKZ/YdgeRE0B2ePpT/wF2u45nPfPv43nf91sApXkb8OAIKwRvec5omFKoVDRe9a5bmonGKCmfZTGxov6taTOGWHxYQivUyjnqi25NNiZa05pjnqbxcat5sHjHatWOvc6YINcqhYT5eGBquZS3tYW7rt/nPooGUlMtYfc0yr09adRVzbLDiWhYuIBgMC7aciMqRgo1DzaiMCM2C1YM7Rnu98wRwX8UeABTxzA8kBtnAk4+zKYjHdq5zb+gDjdFTn7WgjgP2Is8cpBWapOMQ561z9yvkN6Oc0Fd4D9dr7Kfl9wD3vyhcMt2mHUb7Wls37nngW32OkltV+dbasZxf8c/Rvj5JX8+X1w5YtK2n306H2jN88WcIH0AZjOrhibd7T50bc/O1bd897/UX4uC2athLWzLwtCxc4wRQe12ZOZuNWn3RmiskdfkPuGw8DSbmyVSOhYbtfqxaA1tFgMiVHjXv1lS67UIawlTQCs/b84NBOm2qSfGtwumXtlkzWZqQXF7q//PE78Mj/xHX4n/9Is/pmu0/8m+XB6fKtGhSkBnN7QAHX/cJDh/9md/9vTz05/+dDzvec/Da1/7Wtz//vfHc57zHDz5yU/Gwx/+cAAK77ve9a740R/9UTzmMY/Bu9/9bjz/+c/HD/3QD+FTPuVTAAA//MM/jHvc4x74hV/4BXzap33aTTr4gSvQcILscKyGvOwPzGg04kb0ziJkIG8MNfuYRqUMoOL6dHM0W560NmBgXhXEtBqUVzBWiG0VzCN8eyIOaX/fqumlZhiVb3gBhQn7pMBZe5hCTvCmN/057nvfu+ENf/TnEFyEmL3VawkHnIupx6ts/fxzPg8P/eh74jX/9X/g7/7LH7BgMJWu9c8lbbAeNGRSKg2OetiNLcKRHT6C3jgh1GY4AxlU5A8B4twI2NpQ+qKWaFGPjvpOAQtKckDHCsVH54kWOjGi+LUOjcuOg+Z9z3kWAzUlv+bKYZU8bt7qcIvapIW7lpz7DuS6dVirgbmFWduNrq3kNWfxGd2qxjHIA8IAIob3rlITrZqv2RfOSA8yKHsgVRTYSMyK2NMbQPME6HpKNJ2qPs4D8wGkNxp5XJeqQdpv7nGPu+M2t7s9fv+/vhmpbW76VZODeECrJw80i1DPwipiP9eIFU2r8EpfVtQX8Pu6OLDYPpMN6A7mhLSbtyuQpTyH+m03oDkC5mK6niqDbNwxnt4d1TAd0KCpwEiYsgWRXanmbMKOVHbfwcAspAO6VdN2s3s9U/PC9WLa8Aike7zMDkILGDZkh0aqqTZSYBcRYAL6YT06vyGlrDEdEZFErCfFqZpaBdL3JFYxcT7fQsA73vYOPO/bvwnLsqLvFr0fBorXh7JWjPUtAAnk/wSc62OMgR//8R/Hddddh6uvvhpvfvObcc011+BTP/VT4zUXLlzAJ3zCJ+A1r3kNHvOYx+A3f/M3sd/vp9fc/e53xwMe8AC85jWvORfOp6enOD3NMivvec97AACMqwCcwD3LZLW51L+2omE134a1I8SA9+MkcUjbgu1uTKWF1YZOiVhEy1uyDIhXGqMCZFpDMJDQmkdK1vY54kKAr/qTGSYBLaYp5zjJgR0+/KOeg3vf+65405vfA6EL8LrBXlQxajgRBWh07jI+4UH3ABHh4+57d6DtjBSwO1Q1amoMopE3haUcaMCE5QWa1qw+VEInVt+pw8XAPGvOlpLiIEQuTW7l8EVOy/plmzxd+PUPW7LWlrP623IzkMFYqkZ1zsOh7Gw65+cAtJ9X/8itf93BTC6kJKC9+I1ry+7P6/D0FEpAxzfLVVk1VkWKtykd5EUV9JwP+zuCizk6CRiq1SigLcCsfEE3/U9g9q0BOnNVS/YuadGdvK55Jaj87CLfMVDXkIwtmKsE5ClzH/nRD8Srf+WVAIAn/LNvxvO+50eQlbQSyBRCuvsVy7kCNAAIrHNVULRq7/PmhZMdzqMoAgpmtdR5hHx+2wxlnIEMSlATEFq/FG0toH0MymWfYvIAUZF0cqlIwrn4nf2tOkxjdkC388GsW0rMCml1LaJ0j5i5qcZFNFrUh1vbPhqQBy1o2EFdXAlo8q2bnimre3ketAqsacrSXGMX0sROQDFjhbasWoW0kZZEsyzOlRRTj2pFbs24JGgBStKPFCEtQWyat+yPKw039LjJcP693/s9XH311bh06RJuc5vb4MUvfjHuf//74zWveQ0A4K53vev0+rve9a54y1veAgC45pprcHJygjvc4Q4Hr7nmmmvO/cxnPvOZ+Bbr/1ofjKsgpjkTVhBWg/PeggQaGHu92aqJ1iRbsqYOrtJGYwcrHq8BXAZnD6IhDjgrmK1vFY3cl8hyDu0b+TGApWpNgHZfipjW7C3uKpxxomZtnAC0wxvf9F6ALkC8qKu4JOlas/sM7YSRSnPP/tHX4Wse8QB8/yv/q8EZ8FBiiqo7JdXAqisRDMqNbTR0EtOYqZhoJVLV0ixbY2J1SFzHEIFC6yAvGaoOiaQkDfgl8qVblWJBaM9FM1cN283bc3BYHsGkr8Q2NLjtsN+l6TG+km5s4YtvOgkrqewcizfTgJs0b9fsW08NiiWedOZ3IgOzFXRw3zE8t1wr0A/PKYWVThTdenZChXPdximzz2VJ4YgJoTGXSsoHcK7PO4QHjoA6wGwhUzRfC710eZU+8qMeFGkzVz/4o/C87/1hP0rA73G46dqEdVo1Zc2W9i5a3z2yDgjq8oIJqOJwzq3IQGrNFgQq+VlpCtejD3hvQO1nKKvj1fl0RFveArqOqi0fZBjQBGe33qSTpPCJ1e2ytPR27YgSzmL7kmBepOk5teAtD/JyrZkLZBPMOzB2GNihywkGnZgldAeSHRrplsiM6A7pKNdXRkRr+73J03nM/gEd0haDstZ5kM7ZZ6DbshuVFFNnkpbhLZOgb3IAjSIPNL9+Av4/VVv7gz/4g/G6170O73rXu/CTP/mTeNSjHoVXv/rV8Xui6bA1Enfz3PZxQ6950pOehCc84Qnx83ve8x7c4x73AOMqNFyAYBic9wD2IHQ02sOLMRAUAF7FNZe4LEzv+XAucXmjdCH3K/EGuiOBTH6z5k3rJi9M5mzEYpdwptScbSaIzRAqgFZztsqtOhTQMOmz9gTKysdJidqn+Zu//7fxzT/yG6CTAZyoVEkhVWYOIFrNXGwgS/pvJiHrENP+uJhnUTS/VoyyNRu66hBeJKb05DYNXU2KBeuSplPXstQPaCpr5LLaJ5jK5r5Ev5Fy8tV5mE9NQ873i1J5i2ldzSuw8d4eWh8jAtbOW2jRRbOpqT5ikK71091MvjrQyQWj/FvysynaxjQBXebmJoKL7DqlUIAQjtg0BSaExuwnpGrJ9c7ewrmC+SC4zH8uSeni/gybz//u//o+fMInfwLufOc742u/9km2KKuWVDXfhtXm34pmAo27uTpxaR2YwCJRTRs0QGJF8CWFcREXzm2+mvmbzpkt7o+PeXlkEipYJGVRSrl0gnLs08SqWjznaKBiV/cTTXAmTKEow8JQVg9SNDiLgdlHa2be1nKXrWnucosmIwZn0kqOrv06mIeGihmQT9AMxP4zHNQG66iFvlnvZgllewOKRnS3boDWcHRpOwOwGKQFsgi4l7FQeBxHOYfDXAjuZtF4p5iS0KBUgvutR5Vab8LjJsP55OQkAsI+6qM+Cr/+67+O5z73ufgX/+JfAFDt+AM+4APi9e94xztCm77b3e6Gs7MzvPOd75y053e84x148IMffO5nXrhwYSor6A/BVWBcgC45exDtAZyBDFAVxHmj6l2REZO6PNSgj0yFkAguqz4m1aALiI/4mLHRmuHaSblvZQLzbNomqwIWJarg6VM7hXIFtTUh307UQ0OuBzoggO25f5E2E/ZYz1U0qLqm4WCGF4l34bx6gNJDZPr2BPkJzjLDWXUQzTMctqAO/1sx0JAv+hlEBoO0fw8ydE4VysSxLSHh2oEkUORwMPSmu8vt7oZXPe23sPQFD/3Wq/HH//NNAei6DtcbtVYDq9ku28yXTnruFsorWeHcgGlB985cTAJu+tpBrqVLuhJwOEY5ThadEuyyaUg95XvxccEkeqnbthZ28Wmfolie6qPmbMq7j5EaM6hq0PWDXKsUfNEXPgritty26P1MtVzjarNwjWe0iYNHYqsfOuaraLpgmLZFhX/vUiOiFjp3YbFBmUmb5FB8y3q28gwwbXzNfqIdxvWWrYD2SVAgXYPA/GYMrdkhvUNmGzTRcpMTnIvP2cE8PINAwbxIaswnBuSdbRfWrAwHc3YBW8DQiGtYCJnQTv3K2KHjxADtGvMFkFwAkcJZgawBsKAIR0PUQ5/cdx3bCS+k31cLK4lBmSF9MTC75iwR7jMFgy+EYYbEgHS4/2Ad/lSQCvFV5vkOEaw3z6r9v57nLCI4PT3Fve51L9ztbnfDK1/5SjzoQQ8CAJydneHVr341vvVbvxUA8JEf+ZHY7XZ45StfiUc+8pEAgLe97W14/etfj2c/+9k3+bMZtwHRBag5ew/CGQA3wcK0YdEb1fyn2mU5f+c3ctbTtCXC/VbFnK0dqxLQwLCfE8yw6j+heRcVou6n1mzbCmhx7bkjK2AYpGlJaIc522bVpDkfWxZRCOR5iP6c5yYWuJA9L0i0ChWTYLN0Es9MlChWoOEfBG/M5sXm/Z3EPju8g6IV3JqkFqKFClbV9Mo38ngBjU63BU5EhQoxKLsYRkWqBSFqfgMIisRcPgJmUdcUM/DYT38C7vZ+Knj+8894Mv7pD/7javUN0myDPSdYcwGzFFe/bDRpQqTy1Mhacj+WgVlIJXk29wJRRslT/F116eQYtmU7XmkWa2GADjj7+eVZGzY2BqDLLIuAsToL/Xfng3mrMTugy5v4BwbQdBCpXkpWBUZn6NA0sQpmP+ewVChhTfOTYUU0TCgSCxATXzsGYFCGuc+YBlgczipWEtiiI7bCvkeSZzS7IAVH/34O61ljLtAJmlKJwoZpzTSZtSmVzUmDjiBFKu4VsfiRbsFgbY7Krlrzwg07Ns3ZRudu/mbNG9agVPUxD/KaDDv1J5vGTKYhk4PZtsAF+1mfS2thAjpUgW2kW0i+TbXbLqAukNYgvas/2bTk0JwXmLYcraFtP10B1XrubXdVwBH7aK/94CuLX0DBOklbN/5xk+D8Dd/wDfiMz/gM3OMe98C1116LF73oRfjlX/5lvOxlLwMR4fGPfzye8Yxn4D73uQ/uc5/74BnPeAauvPJKfNEXfREA4Pa3vz0e/ehH44lPfCLudKc74Y53vCO+7uu+Dh/6oR8a0ds35SF0JYCLAFRjFuqpM1kKhZq31B/tIfcgk3JsFSXvlE3ZKlE8eo/You4OAe3dZsQ+R8wMnukWSA1ZD7ho0tisRhstGh6RsDGCRuGInC3isyde33JlCxhjK8BvhpNI993KTxVuAZwCaWmR87kI0N0PBcIiXX+fKAfFCuO4QJQ5zcAajbZ3MPs/t3N4ZK0WeGmo6SgOZthM0OjjCvWEdP3+3uzHT4M3KmlDb1Ri4EWvej4e/alfjdYavv8Xn4c2MMFZOGQ7nTo2nbwD59T0gj0PdqNBAyHoqCKk+wTV5iLIhCxAsTEaMUbzID5Cay0hDY9U9iBItusrIDZAs4DZ4ivIBxR6bPYXtqlZtOiAtLPFiTNdjUMR0f929jHb8xOYBVFLPW+hdNFshrd8DV8x5kj3yrYAM7RUY5em6UAmKNV4+IzYXlVrphUiGnTqgA4oEyOLjpR/pO8nZeaTSYn+3arWN0HZYCquObuyWAMXXGsuZu2A8q7CmUBdMpMCybPIrjQ/swZ7la1rzIOw69ZW0eFstalrK06xCGyYGTv8yROU04QNA3Pun5RRXXpecMnXQrf++flRjVZ/LQZoA/PCkN5ta6ZsN2cvrjGrhjwH0km8r49mQmHEM5VAvtzRRkg353GT4Pz2t78dX/IlX4K3ve1tuP3tb48P+7APw8te9jI89KEPBQB8/dd/Pa6//no89rGPxTvf+U587Md+LF7xildEjjMAfMd3fAeWZcEjH/lIXH/99XjIQx6CF7zgBTc5xxkAhK6CBkTtTaJKn4PEDTogtDdTi5lrbdJTEKfmuXknbV1VHdISr61w9q2av9VXbTYMkZT6xSJiIWUl9wM9ZwRgt55Lb3wQdyginNDv6stBmAt9jEDERiIbUY+2al1TPjPQ2KoCCWUQCVOmWEjTRQ8tCotowE2sMglnAAzN1h1gNDEfoeSiSvC4gTSBN1/4PH9B7Vj6rqLXWd1OEgAprvc0bZtVw0+Jg5kdzNbI4s1/+gb8rUddGSauVmUgf7/S0CQGl2nGCubaicq1tFoxu1PdtwIWJQdTWg6OAL1RpHlPX/OgKAOMaLDdyvpFibUlKrGAR4EzjiwoDm+bRqZgz2CmIgtSAfdmSm41Zv/5qMa8CYwiUt+ztxklYnjKoN7brj27W0YFshSErDiILKYx94w4djibwOnnKyO2RwCaDdDV36wSrZ6/7hpz/NPPTjMoYr9qya41p/ZcNedKVIrtXHAkYYwKZu85HGVjpQgr6W9OBVyFlUUs55kVzEtvWJgUzJRFhpr3yTapgEnN0SIVyDuD8QWoybqCeYay+D4lnKWYAMQi22RrBpjM/AQsTc3XS4MsXbXmJX3MbRHPYDUwy+SjJzNv6TKrYGaqrg+JtVInrq9sur//PwHn5z//+Zf9PRHhKU95Cp7ylKec+5qLFy/iu77ru/Bd3/VdN+Wjjz4EFwFcBJGnENn6QAxPfRDthB1wpppaRKIh767mREcmHRK/c0Dbwmg3YMDZNWX3MbsGyqY1+wJjdm3J65bb6fqVVWoCbrljqfxt7PsxlPcsNlrigYj73wwvMkKjLOKUAS7R9CLlFis6QgZqGKjdD+UaSRaR17xSu3tMCHGtyYueell813hqP6EBy4Emzxx1RPsr9EtHPWoLAlNIuwUgtWYKEsgMZq1mqaatgShENsqlJMnnp2u4BfMQq51eIF3M3qE9byDtgUoO6mZgJmKQpX+ItfjkRrHgquuNA85uQfLAKK0bPAAZIB4K5mGAJtOgR2p7aVqQlBE5Ae6gxREIA5h90eVUZUvLAuLYygykCubmmrPfvwloc7jr9yQq2nNm3dbKXVr1K03anZtZf6ClfuG5zw5eBbRggEXTJ1mGnm+ZxAybm/rPNWbZgNm/ooM4bvUAMWYAN1hRIZTUqe123g9f807hHO2Pm1j8iJgwQtrYgTDFkSiUtZ/xMghLt22YtBPMrUgFrikLdupDlqIl0wWDssJXjmjKYlAW15rJwIwdJOz2bp+3eg7F4EhdIFFvlEBLU215aZDdDGneCWhJzTmDv0JSM21ZGcDk0f2lkI1df08h04mu4uu+/R+A8/+/PYQuguiiLs5+U4OhLYH2EMrQewkwUwGzJICDOBXSqplEgnoxbeutlrZQKRAUPxQAAOkqblJ+rOwRwl2/EIoqRvkcNq+h8neE8rmu/rkGbq+bNOMC5bHm96XM44S4JcHM/q49sICGgFYpBgbSPGeG9T61RuXSsUhH58U06G51aovWD4qAq9mk7WAuBnAzyTYsGNYMgymXT1/hvCZ0rm8K4ybuT08zfVXbAs4O4wawdcz0Dp+AAx1+0ClH+SX1Ndw9JT5KWEP6pcUg7d8vRyODSLNFgAZaG6AiPKJrrXc1VRK4qbBJranJ031hSM2PRIcKZAM0BkYbwDDf6sjK8G5SEDv/gBiYEYFLOSQgHVo0CoTkyBT3l52rMdsJL/esQ4uI1N1kfnZ3PUU3LxoKc9RaZ2LxE645MxoP1Zi5YSGKIhxu+m5cU6Pm/GYW7UAH0XtFjpmz4XK6GIwlz4lvK5Crhlxf6Ndzm48X2qJHbRcwz/FTaqINv7PAm//kd6X8cxdSOgLMmi7pJXl1aMZGtl50SYDpBEInINeO6QQiFyC4ADGteN5XEIsBWQzsNR/a85yrn1mmPEWUxj4EWsTt8/rzrimQdw2yE/DSrBSxwXlnWvMipj1v4Ewa9KeWLMubl6GMsTXSXUZ1bV9vjXBGO4HQBeRqoP5lsQCEmIlm/pWWJm2YYz9aBfnoZfEL8/asOafWXLSK0JrtcBhAGDdc83D1olysALU/NtrKpLnY6u9mXAxEk3kAHugVq1yYsAVghthijOZg3hcwaxoaZAX1FWgriNbUuLx8JzPaKmirgFaXYwjdRmMNDlm4Y3Ewy4LOpUYu0hTvh9lFI109fKeJigperUml1G4A162ms1XNWU+++pRNY7JAqrq2Txr0BszSTHZp2ouETGOul6uCGWSX2i+dreFUUmNd7qEhpk0TIhepWjYmSKem3Gjo4mdwJuu7Lb1Fo3fu2tqUegs4a+D9VnNeAV5BvCqcuwKZmnZTy/ld8VKEQYNvNeeXVx2MODWuJW5mejUKAZg0yKotk5nqQ3u2dCC45qxtvUKDnnLN/ZZ3y0QFc+sqTFrzBge0RnGr0EhudSpxJl6il0xzRikdfFCrmyQBDUyBQ36AaqLPtYnIteQtiKumrCOgbIBWRlJqzh1p0nZIWytJFQLNjO+wDusBDMgwKFOBssK4B5izLrVERnRqxQFjulggfQFscGacxFAYnyiQXWMm67wXUG7l/JD5lpHWg2iLK+GqtqBvYEeQHRmkTYPeqe+ZFsFI80lqzE0zdBoU0F7UimQx5aUrnJltbbuVw1ks0kGl2h1AKyTFRBCyjGXcreG6lRz9CJz7EThHScsEZWrMQKiBDMhwdcHt25SAbQW2kw2aj+wbOeqWtDiHTCpM8T0HQBLMoTU7nFdX6QzKAec9wHvQVps2TUtboqn2rJCuskwzSLcC6UXh7AXtLQo9iiSKa10GYPHYboeyTn5L3MIwzbr2644VPbRnFH9z0Z7JwTxD1k8rG6C9WdhkWbW/We01Ra0HYD5YqZdIQIMSzKtoA/YBDW0OQNuckZwL6btMHzO1AWoNzcBMZrLz/twauMIY2uZKbwFyEAhc6yNxMK/AUECnaq9zy810GnCXA7KZu0D4oKfhMmJQVw7AnL8p59hhHMdNUcwhLAHm+8uwCwdzg7eaC4h7OiDWtEqYAKSA7tYOsJnWqKmC2SrR4MqsAUGcNQzC1B1gtvNEPpcn+S2UX4YeF1yTDs3ZfM1hFYCZsnM/67pWKFVop9Z8kP9swoyCGVH/PqwJJrhojWzMXdPivLimnCMKFaEjHNymASPAezHAzHIRjAs2LoLpBCwXJq2ZzbfsAWVzK9ziY7aTqkoWZcpDgBkgDTMHdgJrSwA5cTgTeKcaNe06yMzb1Bm0MKJFFy0KZwwVlKFKhisbYIulKdsahLsuIb7fpMctGs5eNCOqYpmG7Lm7gjL7N/mBsBs7atapXTZBHftb7dlWdbdvVjizWPldo8BwFdoI4Dkq0mZK+KpeV/dqHy3+rrSluioi+Z7S5lUyFn8jz/CAtzU1Ztrr+8oekDMQ71Wjpj1Apj27n9J80xispu1VQCuZ6ZYC0OqDVkA3UUin33kxKVNXIhNxEs5wU9usMQ90rGoct4KJc5+hXAKBjMx1f6MvQOWUVwsHIV3xttaFf9nf1S/3QASdSLkMzizIkUtWtubuTc25gFmKmBLSg0ejkWrEKGZsrYeOaAFKSwd6M+05ZdKpIAevgCiY0VfQ8CyFMtdkxDxk79ZS53m695Ow0+Poky7H5G+qZltuT5e3Qp62qd2aqPXLAn7II5mKFUw1Qk55HAZ6ICCkcG4FzDZGqXEeq4rOMg2UzLTKMHUbkLP71Hb+FsED9Zj8B5nonRozDgEcEG4J4wnM5e/SYBgDLcFMkXYn1gBIQqPXj5IoZDOPAuaoZjBHoAntDLKuHSuIB65QIEMBPWzLdIKBC2CrGKZjAdOC2v7WL2rEvxYPWTb0UW2ZFtF2uDsBTiS2WgFZEtInBdJLAy1NE71j/VcnvVC2sXQ4E1t/6eiQVXxiHnsEwrr6zL9pj1s4nMlmXRG5fbEOMTx3dUGtGnPRnLfDteiqVbvmXAJlJs3ZF+QmuboDyJWsAt004RohJBXIdTiUfSba94J7+kbRminBTDZBhi/yJRo9tGI1ZYNNax4G51bBrYPEzNvF7+w+VX1LsrenGdLS0KVEbU/pYj6P2cIpBBkYNbBG5aaokg6rgmyApmLapwwGg+dn+7rnvue8fKWgmPqayYwLR8Dsl6t3hPm7pvi49yDkrOlSCmQlhbIN5Z/kKBrqVOiGGryllZgmRW7KXAAsAloYtCxg68lNvWWGiUkjFNAd6kzvBugQ0qogWGz97m+zoDmXbshpdwzQ/nOwxxMc85Zwgw+Xc+11ix3QNfVfgeJ5p5JpQw0aAGT3MbmMXuDun6uHLBYt3yPIsQ2DNJmASVQgiwCtm1fY8+Xs/tP5ikipmXom1LlEmXuf6xLF8WaqVIWsSScB4HYI6PgZaeqelBCE1QHkEM4I44A0mVBB9bu7z35uvlKiz0yMmat/uYl6bMA8cAW8zS9bq99hZu3hYKaqMZuoY/FCnuKn+okpVa5oWaoUFoYsqv3KjhXSJwxcYNAJK5xjYNairfIKVfNB82PQevRNmkFZB3w7WglYMWuOQK1ZN+Nxy4Zztwtkj2BhrL7lIvoICbLC2QdbSxaHtAScpduK27aaM2xlhporG3kybnnoyh11vB2cxX+dzkq3m3rwyYoQg6vuEdGBVnTEo0qEEHkubtImN2lzWYjXHA5nXoHumrNqzZPKZ2ZtNcv6ITbQSoDDepAOhraPY43mbuyAbhm1bWSLMyCYQFzLR9RMaY8hryFU9RH3L+XaFKAWwBth+AeLpebwyJCBY2AOXhmY2QGAmGpTrvNk/HBIB5gBGTRDOcBsPY2IIBi6PfA5GpwWhjbbZTQrhkzTAl3hzAnnCmZk6Vm91m7j17nKbhZoEvKla1mh/FUIFSDnuTQwIf2tfucei1Q+yC40CLcmQCewpbskIwRe0YV8wU75vFg/7F5k0cV1mI9+lGCykUFkXmePRDVyMYjB7ByOqrDOoJ4LPwc0+ZnJTNgghIafGZPlOh9oy+2cfTKzf5s07hRUXBjYgnl7F3k+PKZr59/ERZbavjS7QimcucB5GJyHackrrjA4X2E/Xyy/V3O2Alo1VW2DajXkSVWRSPUzq6c00rXZKn5l/VGDsoPZhpwI6AKbFl2G+aTZel9znH83pasdhEQ7uVEBMnkqh5vcote8AEIYy7w+3djHLRzOo6goWRjEV8eDvpwhadmFPA/M5wA6zOAO/o1JGx2lliEAiE7kGsorpO9Ro5DIk2mHgpK6buG1qE3yEl0SEuiqwpE54MReM2nOfg6Gn5uijYuDuQwPFKsQF9OowndtbzFI39e0ZgW02McomB3OJAZpsXKekhnMmm6S7QkCzJIFGGvlYtfvxM6wrrm64P21+9wb73r7Nbj+2ncGKHKhzVNSH9VN73JVgNmHfXXvy+zmb//biPXjvNRgUQAXpTX2GWC2NoucTT+0u5MHHJF1PzNoRDoNDEgM6gpmWjqwa2hLgxyBMyY4e5BACSf36ywMYTaN3ua/FSnJ+wizZkp6EgNEsbArlObueymQeRcmvxyEPPkTlGOI+dkFtFBUctIwE4ezR6uLFWXJ6xyR+iY4EZs2OQTRLMS125idBiqJmaazjss199eXsOuwFph/eVbhXXKUnJhbU/bloLy02KetJt0c1BTXKSwduTioomDxMxllTOGT12VG4aKyiNVqkAaRDm01mlqzWLlhMUAPq509cAErLmItgNbhWnTCeYTWbH3JyUQGvz9JI6a9+ZDHHMzWz2G1RxnYjQJoMe1ZgAsCucCgE0lI72xYShV1ZDeqElJPopY6BzI1ishRGmp6F6+ja38z2q0Rzs1Agk3wkkFIpqRTzpxmB21pEWbZ9ohEx7jhJaXz6rScTNT2sd6uJ24G2rzONHaHs2u14VesgE4TtpT3cQ1IaIUl9E0LQsaXudYcB6dYqzk9sqYmVbWppmCW6bVVm/KnmwGaIENMo5Yp0CkXwvT7Tr7fODUqj+ufVdncZJ74FvBQnK2zAF/y9CfhEf/ya8Bj4MvveX+8+5q3ZUYKEs5AXsIAL4pMZY8JzN2mTQuBejLJ6h+UUbRnZaJAmBLKPgVE2y4ON+cTm0BiZUwJERhFhABuczNuZ7W1Lz18ZmzgmswG1VQ98r6IZi08DMp12Byy6h1eISzgHOfVouK3rBH/HdSvCUwnWEAb/3KhuMOqAtruQ7GYT14EbamAzvs0gsTcdLu52CHTu4ZJSElDKBjqkIpb3l9X7vHA+DZh2TG/ta2HlEh5jc41Zbd5OJiXnm2j/HdV467Br2VyOoh9cpKdE400ppz05m5RKCMkJfGBDs6+ioBV7RJZMEThvOKkjIubcUXsVzgPmMZsbqssTONQ9gA5LufMUmIDzGVs4WxAxolCOvbdP+3BZNYqMoRwkOk7pnQYgCP7Z3PdpcyJWyecd3voKqTlO6eoY5RAF1+IPF85IrRFJawpyg+WH1iec/O3lxiaVnAUrdkWGMy/Jwelm5ybaGCVF212OLtv2SQuf6eia4R1gMRSCkrOMKhAxzsZTIFFDKwlKingbID20OtwJqdVAmLlSQ26ChoBhkmKoxmAxMy3BdSxuPl+ZCdvvluWbmARfNwXPxgf8rAH4IVf+3149zv+3JJY0kbC8Vf6Dh/6d68GEaEvC+59//vh9df82RRvU0EasXf2Ps2+qbtRIQZkQQQCuwvqQGu0vyP7ihXOYtXA0iyukHbvQBOxMAXBoApopO+cFNJpAtA52TqDO6NFaSddrFsn8AI0J2ROCkTKjwlfLAZnYbCnyg1Bb547jChVyPU7k5tqbStQX61YcQuBO1ziu7jnjSDhq69yzJhs4wgw942kJnGv2vdcJMrQe8lGN+dSK2aScm0y4r7Z98xjipcamCTcIEoKIeDjP/+z8TGf9an4vn/5NLz9T//H5qBNHDAoyxbOFdIVzgcBXhXMPaFct/V3DvUQbMrk3JqBXFgLi9hQU+zwnwVVnmMmsPUA59Cgy/ojGV09oIBeN4De4wL2oUm7mfuCadUJ50HdwEx6r5PEfFU9hMMVJW4FjXtgnSEd2rMcB/MFFDiz+qu9GYbn0PsqU2TccEtQubC+drigZluu5pub8Lhlw3m5ZBbfMwCnNgzSniJEG0hHypTBNjRlCW1Zdg5mTBJ5Sti24NVAMDeRhRQlYRpVHxd00ncKcYyieLOpRNT0eKMigT8SzF5MQqB2F7KDkpgQksciHJCOIgoedBbBQUMnMyuYhazQBaWrIDpt2ffVe5og3NJ3ygwZZg61G9w1MN93CZ3MVKaBFT6j9f2bfd6Vd7ktHvWDXwEiwt0++APw9I/4GvQ8mhhSzs7/9ajH4Wt/6vvwP37/D/CHr/pl7MpajwLpOKV6aUAsIQjBLre7WL1JwDYjL8bmSoWhxFR7KooKG6i98IjJMbZOq1UkeEqmk20FgWqqblqkhD2/2RfoxaO5dZ2G++lETdXd4MxgdFY48xjoncFDS4E6kMWKVVQzvj88Et49kVo8JVsxlnpwqJHLIZKRXjd//6qEhDDia7+bGbtALIXM83e90MRUbCPOU5VYJa06XQVIWe3cQD3IU2C6JKBjYW7Ahauuwj/7/ueCiHDPB9wXX/HAh5h2lwyP6UAq+mmNhDgZYVpQzhEimKsRJjP24vDtm/3tc649tzBpu8BewSzVYgcOwUyY7P4lu59V0HYLjwiBuYG5YVi6kEjRntG0b7MBesVicN5hjxPsA9IOaB+uOe8waJdaM1Hc15pX7jXWrVRrXF9XuMxV0y3Y8UB7FmAnmlp1IprvfCJWkEzs96wBljUIOOILfJ2XDCT1SdwsKLVMZAkOpJB2Ux+3bDifXK8XSSqcC6QD0AXScRFdc0aasWPUm50S0JEoa5O+grcEgXlt54SyqFZdip7UGsCzGFakbFfhQgJIMPuyJ2b6znhY+xtbiGorzJSWiwO0VR+kadfN8jk99xV+Y0ssWBwmWqgmOBzGQ29i/1kc7MNW1xFfKRtRII4zdOJL1xs5CafvuQ4n8IKdXMBciyQK3vmmN+MpH/6JAK3YwbT1csn8QfY9AJOCm30P5PrtJvhw27cERr1MsZXc+mI+adEGbPbvLRQpznpFPLhIEN3UZm/sLBjGwtTRilrv/kYq/SaJFIx6TT3CmNEbg/tQbdlA38xkriUKi5xo60416Wbd6o0SOM1Q16CLD9eAoUAjPPc//yr+2gd+IJ72ZV+MX/2Fl1XrMqpZGwFoHGjPapJEQm5yQ1EKTXYdZGBKbshrb32uufhuG9TH2PQ1Z3ud29Q73nftdWDX9PK2n8uT2gTSQhYoPnSarQEH0ditQLgfgnm7f2Da8TlZpA0Ds5CtAWgAD4PygAwCDwIPiTEYaIM0CMpsvWL+VwotWv3QLA1DusJZFNJ77KYxm7t1qOa8qOaMlqsBCZiGzVsT8wglMMzW0FZccgXQtAzLZmBLrzIwW0ESsp/Jwb2oFq51BdI+R2K57sNvcj11Ybhknct+7mNfbq1w3l2vYJUzpPZ8CYeQLoEvk8/ZB46AmXKEmalK4vqIyFxnK2Aak96hCm6LLLW0Jgofk2rNVAAdi6Eo5KUs3zo2S575uUSocELCfB6Neg8g7X5ktyYUMFsep9YRNwQKJjgLU6TXKKgNyqYlM7M2BjBpmy2Qwhcssv+1T7QFoYDhgUnrey7hOz/yybj3Q+6L//zclxicvQK3Y7rCuXx3gzKAADTc5wmEgcGPBSYJB3uQDAwwl+0BmPOyH4BZ/EmhADNb4I2b0SdrbgT7bd7e5tycedBMk7BG9wo+4REAAQAASURBVGHStMkYcEZ4wRoYLL7YaEerRqotZ0oNZm3WQNziPJP9L5l2RAivj3fa9VumgpvKtQeAB3zCJ+C+H/0xAIDHPPVZ+PVXvTyCmJz620Zt2I5FwJNALYicX3svgVsOdM7WYB+PU3YwM1sELuv59KInfp+P/cDj/vYj8KCHfDx+6rt/UOFs5kuWcRDIlDABvKJZOVlFoLBR/coHgF5s37b+c0vt2VPuQFmhUL9/0ZZNsNd4AzIBW4VsHgM8GGMI+hCtW2TBnaoxl3SiyQ/dDK7dAN2xl0W3WLCXLaR1jNguBuYCZ4y0aoTAVm/OCmbLNOlWRMmLSZnZO6qkxXY7tAlG697hzUNUzTfPJVjO5kIaOXNRyHukpHrejMctG84n79OT7z5nOYPC+RIgW+25mLeraXvKBKDjozd7ra/SvjghTdrksJEMOGFo9LIFY4Ok5Bra+1gNYF+h8zLqTewF1SMSPVYoXzEoIpXFqKP/V0AX1a2O8HuPqH4WXY/IjcaOvyJ8G2iZ3RdlWx5gIQyrr83S7Pc0VRJVLdw1fl+H7ZaMNLIVf/G6N+LPX/cH6DgDwcsmOpxlgnQ1cldjd6q0SENE+Y2zlpCXNu41k46DJfXFQL1Y+XDol48Xg3Kz84D4zqYxF2EiXCXgw7cnlO+o//cIUFTpwSOOD+3u/jk69w7TahTMNUUqKlohI5jro5qyNY4gEvtiv5f9hHO+1R/96q/ive98J666/e3xih96ARYXcicpCQegru3OaYEGhk21pCUqhU1SGZNpzZlI5EBmbhgld1Wss4kLJx6xyAT88R/8Mf7o9W8EC0dkcQDaIu0FCn9NB+KAdDZSkFL9CwrWhSAB55aBXwHkJYHcF0hfQK0noIv27AKnFJOBeNlfCwRkWe27O5yHFRIktMFYvf47w86JWs08A8OJqedRhXDtKZdjj45Vum5jqFY9oPB2qGcrCaiv2e9tN3OT3+EWsBpjC2gtQ6zlbj1wUko5U5RypmT7EqNZ2VxvahLDFZ4pVD9UDd3a+og6bsbjlg3nC9ep+SJKT5r2LKdl6z5oh7P5ESbNmWYNeWklchvmh2jmg2gKUeJYtDPuQjUkb2iAIVHjGISoXuQLRui6R6+da80L3NfsSfmx1LnY5mY7JXRopgcaNG0g7YVPSIq5S39WzTlNxsoM1fqaFOCyGwQYXQYGa+u9IWT7M5xZNGWobSLr/JZspj1TaWovBmuGNx3gsk08T0ZuuzYKZEltmQycVQd0ODoAilQccUB11Gvm2hEKV10A2MgHHPv+gROVLVRBpjfU75SCUWpCgKLTDcna4dqbhlA5wBBPSrRbzWsFyhxGpkKhvJMerbXjjL+XBDTc/0yTKbuXffdPk393AmS/x6M+4C5Wv0GwxP3iUKYjKVUFziZcc1dAi41aGkDINRgVIpsBs0HnaRaU6IDlPmugWCn8kpIKvEQnk2CI1iQfGBhgDBkGFssosONnu12zVjPC/O4mbVl87ckhVWsOzbmMpkNaV0i3DhDhkx7wQDz6Ez8NT33xD+OP3/5nqLEjCuYVLC1cVNELJzxclvo4OBSNALOtASSzdhh16EQLpg4Q9tD9PVps92hYqWEVhfdAVv0b5C0l/BwXSJOD2tdxD1zdT4PorMBalTFtCCMRO6IyDFkBMMpSpRZroV27NIEzNGfydLp8+LxKIPsEdW3ETP8343HLhvPF64Beq1iZeVsKmMWjuGtgGBezkkut5cYo3UgiEMxNUMQWhAVAuIDZX+dANg0knktlBqahwECdCykCiNHlhlj9ObB61NLLEpcdmYRs7fVtLLBqygszEGy/lAvNlnv5mrgR4JKqA0KKCdDhrOa8IYTGthW9ST0iuYsEmHVxaHFT+4KvJRA9o7kUSTkC6FmL5orl3LcbKo6dJPyBCNDNjwnMoVInlCPKuEAZmN8r+Fp/aVDkjCTR604uJLiAVd/J7a+cbyRiIAaAFtekQyx4yTpw1YMGpVBiByUi88GnWuIUUU0hTAebPN8YEfmw2SaYpwgJSj3DZ6nPVYYrzBKas/oV83qwLaIV1CiAnszE1ZYu0PNjYCa4b7mBuWP0DhqueWrJyKwfXVNmDM4xFMgKmYFBnpM/rB6FmbeJDNAeBJZbzd125aBAOdKlfL+asncGZt+6SqgL1kv/+VOwtI6/c98H4N6P/3KbNxaVjxVNGoTXvIcP4JyeLgxzBZgVzLVmKjdBOsy8c7iL2A5nlG0OfS1pRma8h5hLoP6rrj0vzqSuSqEVRHuAzmzsQbQH0WqZDubCaYhKcwFnIguQpwx0D/eOacthYynSt90nElsK94CYC0CLlcDcCTf9ccuH82LlJ8XrQ5sGLQZpb+YQLYIcQkA4yyIlQezmlIRxqze5+3LMJyhQ33LjNIkGfEukLRALmcKcQxuJRzWTWGQtAjVscNr2u6n0QC5CBdBA0aLhGnQZUsDtUa0eoRias0MZ5iN2LZgt4til6aGVSwPOni4EDNE0oY5hUZ3ui9GD9paQqj0Pk7PdKpK3srfrmwF9aNxOXTpvcjb4uRADQT0zMSKwh2CS+xF21a1dto3SG/cx4J8VsSP5MA4N5B/PGrdqxxpY51t7HcPiADRqvgtFZC1xLYqh4PaFWMuFIoKjHFx58C4QmAYgen22Z0qnuuc3R7jOBtQO6HwuFjqfmXaPeN643wfqp83X+PWQ5rcthVk4/MKmMUvcu7N255WeuGvUMXHH4AYM1TqljGNwTgtKzjvV9jg0wOiCTl5Exo6bADat2c3a3rwkrHdVe95VMB/RnB3M1gAo4IyGMRhL63jf6RmAE50nntMuTTVn82xF6f0oZypp/fM5xjoV9D7PpQIeR2JLi69UHroag2wr+dyIrd/H1jiWUO7psRn619EWeEqfVSinO7PAGe66sZAMWIEjKg1PAHjOvpcRplhpi8QdFxMTkMVcIWLVwWTY8sq3Ss35vcDuBJmza8U0AtC+9SpXA7G4EPLmdUA3Md8NmdiI6IYz57QEEs3UAfPj5fOhOZc/vcud3h+/9VO/hysuXIF/9NgvxCte/oojX0qX8ESMmis94MKnC4d0EUT34ObjgBaUYCJ9QkKDTxin5lZz/Cp4ZC7bDdV4HcJNgNVu4AFgNShrO0jGEGtdIWlUlfjeh3BuAeaEdAV0BonNEdwRpycS/SXIvkcVYqRs/W/EttHV0f7e+TVF4paBupXN1j6WRdJSktFqCg2PIi9D2cjmo7d5wByLpRc28ZS21swkSU0/RXQCSgX0oFKNNdNm5jrfFPsToG2bkfamQRdAH2rRuu1lv54xtrlWY+3U4lHOTQDOQa3PdZdN7T5ld5YXoTqOtPhGwdpRadT+wM1bEy6mOXdo5bCGat0KIZAEg1TYVE3Z3DkgDNOYo5qjCRVhkfFa0Kbpy6Las0xgPgLojTkbzcOOvba1SigP+qZvxBd87Mfhu1/5Cmj7RbPAyQiNmQLMgjFES5gamDPPWcJ1FeUeDs5GnhN3OA2w2bl0W4c+N7CaM0D/uVDDcGuK2CsT5zOMxWKNCB4QfBY/q0F9lOHCZH4Hte5oJcJuQ/dTDSJ4y1ATVsoiUGF8MMzaoAr/rRHOV1ynhUhqzm6Uo6wNHbI0YegtQU01Y6WPysHsILYlg9xgU4NjyMweroimRqzSpdhk0NSZz/vkv4fbXnVbAMCXf/Fj8KqXv8zeKVdjD95QzdmjIFWqnHrdSBoWPTI0NGh7FA7FETus9ZcGajio/YUSr/S/Z5vcbGZoivtXwUw+4SU15RX63Vex7lIyMNDjpnAzmBStzIt0Hgd0qQMdsvX8b5SzEt9c7PvBv64cgpliPSrmNfvZXhewDkHlMoCW+bl6XRRIBdBhc3bqJ6Rz69quvbGV19TFwMEKtOER1KKBLvG25nMVCvOlBgAB7DW/j0DawTy1jSzn1fdj8UMxdUvC2VsY9Lg+adFpsaincKjRuVKsE77vvtzNgAJ7TsPyeziOCBwJ6wreGh0k0NHQwdanWFsikr0231s1Z4bWfza4SEuzNtk8KmCObdGctYgGNiZt1aDlGKAjbWqZtWbsEJGt0vDG//lOPP3nXmZdNHcmnI0Q0Dw9mFlMY66BT36QapVRC1kK5V7OIa8Mm6nf7kHiBDQNM/sPDKxYDcsrVgxaMWRvYHZt2e1njvoVgjPIVGTqDBIuTI812iukfV/2IG/WIwxveqPDLX3amaxLs2GA5mLelmJo5HJBq7Y8dPDw/V7qP5DWeLgZj78icDYRMNQBK6pRt25j8PWETPNUqqSJO3Jl2DBs8aqiwCZxQI85oj8mLucEtsWJRCsn/dhLfwhf/cWPx+1v+374N899mi1U7uREWexcDk0TtofdeKtEXwZdHNCeBGSmQQoye4rVBOhKXZr3fakNaAfS7Uj9FJqZe7jGFNqxa896StfQmIdFZA500y46LDcULgo4rlUQSkCrD3obJFYNYhXMY4NM/5op5edgsQqksi0ROkN6bAB+nva8Bbd9bN3EhfDIbQe0BNELpO3DpGgyUWlskC7uQxd5JkpXq89NT6syzTHhTAZoYAwJSKv/UW4Q1FRMA1SkkWrmriZuNw9WEbNgF1XU9OeAcp1iuKvCDf40nzI7ubXCN6b90mGo5GMJFnQsEFrQaEEzSHt1dz2rKMekwZNMmjI4sIJdc96AWYO+zUcdvuYMCouc5whKnYPCcni6lEdme0k015q1HWs641XA8TTFMO3bpWSHMatFi6LiSLXUOCzNSgZEdL9dcFutTFi24DimgUErVhkFwnus2GPQGYZYTjN5hQNPlWzmVjIzvGnMwCnE0mMl0mbL1iylJGcgc296q9vGZqL2UCPrltdZbOvZVmTtQtMX7TAnN4FYNUQ4hAeDuUOY0VhS0B0IczfGdOff6MctHM7XA7sV4TzzyIax2YZjpS5+drNVCTsaZTRk2tLIyc4GaIzUli2X2SVR3bIVl5HslyHA6fXvw9Wffj8LKiQs4kXlgdDQQ4ukMukNzqJbtsWHy8KTkE4tmkwImVOtnMVpmAphZSI44hgodBy7xcWWP5OgtTY0F2FEF2DVmJsBupk52xtbOKAR5ugZ0GmSSk9ehpA4mNsEZr29Ud4ttWWkDATXgmUyXzuEHdbHtOgK4frzeQ8555cCb/ZRHnHeXUv2gBNJE/YQ7cRjWhc3UgMR5TGGduCV6Ly3ucPZ0mbG0HLqvKomHZC2RhdiW5YZzhqqIOXL2fO2n7My9+doiRJgY7M8A27yjFRXioLFX5lw1tNDOfz+sPs82okKwRs3RPlJ84ZrwwYFdJMdmixosiD7FSucq5A7BSTSioGmaUkFzGMKHJM0a0cwm/udYZCmczJHygjNuZjjaxlDWVw1zyWFBGKRjmzXQ3PdO8iKEpHoXeamiGqR8zgJl/N0yTQw2+LHUXUuwTywYtAeLHustMfAGQZ2YAdzgb7euW5f0fkl3mdA9gpkOYV4sG8MBTPJGcAGaPZhLW6ZM4M2otDVtx69MhrQScUxDz3q8EqGsGh+mMWq21atV2zlir1khBdmEivEdCuF8yXgZEXm6RiABxuYy76vtmETs4kI16BN/VX1RE07Vq2A2LRlDwyxhS60ZvbIRrFexmYaYd9KNLRKrdogZ2oslZvCl24WX8B9a1gWNfw6ethg56bSKEzix0mETISng/8B6PpqWrceUi5DElvzW/qia3D2XF0CW6Sw+poJgiuvuBL//tdeiNvc7ip846c8Fn/xhrcGdmuFrAT0ZFDewDmjNf13bgjzpdr/tXi3qqEhPsEB7VrOuIH9gDg208jPUoDkyEM2u7bKM1nuc70Atp18z6HQSGrRg3KRdw3N54Joi87WtB2ipxuIAWqGM2GsDmnRbakOVbXnSFTfAFqkfsmqv+r+xgGDFrM1Nbqa1qXCiV09mc/9Yp8bh8OpCbqMrrWP7R7wcooIIiqguVvqVEd0VLLBskMzLZQsXysTyvwbRjiYiRsFzEhN+RDQkuZ6b3logWERtd1su7QEdc19jlxmM8ub48BzywRmliZCuqjcgqYZE9papcOVkBHriVsWNHiOQVFxWE+pxPA102u1a/DbqgN7MO1VYzZNOepum3im58o15p2dR49I2GjOcgbXnCGXAs4kpwDrIDkD8RnAK4hXhbP50Vtdm0ez+iSEbnXko/ItkL5nmNYsYs0uAIylVD82KNucc91Qiy6yljH2soA343ELh/P1wMlS7l4p9knbX+vPSNNErKYNuaDUlbDrmUYHZICiU1TJInVz9oBOgFVKGgKj2cWP0q8O6gJpiHPQVTvXANyU7Dl/NP0LsdhuqgroSKNBc2Vcj9v3I4o3F5wJ1PDj0W1iDeEfPh/Qrjmr3/NzH/v5uOf97gUA+JJnPBb/+hFPhKfZeKdqPcse0FXjrLNJ5NwwUm9rslu7Qrke2xaV9SoPCP7pT70YD/qcz8FvvvSleObD/55OFTLP9hbQyOmTGtsRIJ9zH0o5wyK5z2Y6i/QuQqRzPfPbvhtf+I8ejd/+jdfiCx/+kBL4hUgrkgJlr3DVuKGxgrlR5gIKLFhFHM62NTivq2rPYxUzPKX2LOxQNiDDtPlyBkTK2ZAEs5+lCK6hWmoizadUUsYiCFJU6/Pzrb5PCmOYCKwoBrT0ZFPNyItWUCsmbUkfoffjFe5o3CG8QHgBywIS1aDJqpyQgz1mlRiUBpjcFlAtMJlmpUMMxC0BHR1VBChR51PjC3+ub4a3RaMUvNK6V553OIfvXnQekPne7bxoSp/ZOMw14r781vQ8U1PA6VuzXtJG0AJGXmlsgNsKlj2YFoUznWp2BmnVME+WVBeRg3mFNs3IiITIya5R2ZPGfEkHp/YMPgN4r2Aeq4GZMx3a4bwS+mLrdRc1ZROZI8P8z2biji56zKgtcoUJtzu5Dc7kEt576Vo1qobmrCml2Xr11gjni5eAC7uEc8bw57YhV9xGwEpOk2AxgBS9bRHRqlrDfM0azeFRm2HSlTRne3tczXsXdJsInSlLeRuYs6Z60Z5NDXNjLBcTXQ2UGAFnj5n0ZV91Ek0RaLM2Rv4VXYu2G5PceoAwaws0Rzu1oRyTJipVG9JzURO+9BwJXvWTL8dj/tXXoO8WvPwFP4kVewNzBXRGeta0KDd4zaZuL8iiz3mjjFbQniZTxHH7N6im6gc+7GForeEjHvawYjCfB29HAXIoujiXyfGLSfRxjdsg7e/DqAYLwec+4gv0+D76aowCZddqvLgG1yEK5jYaqHlAUwnJEgV0as8ELtpzgHmjPbvwK+a/YzNje6CYg9qFN4kvzwBSaz42gBmgKoEAsNmmleZUQ1mKFcGDbrjD/O9qtnQLkHYDoxCqxaOyis+QuENMi2Ze0FjhzLYFFrWiIe+VnE2u6VFE9CuY3R/dy75CMdse+j6sK5aZtbejgrqmh3nwqgvaZOptI1xcTvBlH/MxePFvvR7veNd74XE0Xu853GAlA0Usyt2FoAaK+kWtG6C6rVnNX6QLWbQcbauBeIW0PVjOtMMUaYMMJhfJZAPmHRjmWhAKQULAgKyQSJMtNSxcY5ZTEJ+C+ExN2WMPGuqnCa15IKBMa0froiW4G6F38zOTgnlBR29NByjjN1ij2b0O+d+910fi6x/6DyEAHveCZ+IP/+SNViWRTOjzrAoNprs5j1s4nM+AC2wWUFdzSCfxWib4CqSWaJoz7PXha3WJ3+1ipj2T+TqjoghiUY1AsCEx2sro+4a2CvpKOmyC1GYnVYPOnEHJgA1IaEIsCWaIw1ml4Mk0DwaohaEwvpXdvOG3Jm+Y0UJiToiTaXYmcW/gDHCYHB2Evvh68wZ1AmhO4Vve/Gb87SsfYM1fCCdAFKVYSdMztpmMHenRc/huMUm5FNp+gmAWKOw3VP9ahYhf/L+fj0/4R4/CL/3QD8bUubGQrppzffiV8TnijwPt2gUmF6DK7xj6If/ued+Jxz7uCfjlV70CX/YVj8MH/PW/jmc//cna9bNqzAZlFi0/2UZH6xZt3KbKHAXOpWTjuvU/O5gdghwmbe+m1UoEdz3T+t1zvugCa1Ls5vqReA7qcHFOT0vKf/H51XStoLZI8w79Dg1R59sj06WZMGrz2s0Nwg2yaiUw3WoBEgc0GZhJtCZoBFlVzRkWsGkaugcxqQ/aoayR3EKprWrVMQe0mU3IteQyqGwJBaQIMEcguk067xv9uid9HT7w/e+MZ/y9h+FOX/tN8Ro5sp1TcKXMawlLRRPRspZl68sPukaAS1vhNbZ9Lvp39hKmOk9r8Jhq2YIdxNLAUrT2c2xZGqLaM4Wf2bZcxlhBvJ/ATKuAVrLWCoS2F60Itie0RgphsmH/lt7RuVnus/md3W06OjAGPvaeHwJv/PKR9/wQ/NFb3oqsNLfaPaZrZWfcrMctG84nDmcD7qACZTftANOMdCi5RO2qi81K94O5puZmI9Wa96ElusZLJXG/DUFbt2Cm9G2Y2aMfNW2nrpG+XQeJVTOyf6PCGB4Ta34lyXtYv3l+b0nxG4crgY98iJhvKW4Ul8DZKl05GGER0lUHkukT3HDRJc3ZfjQWlmMmbj4ANG+0rjle9xDIFcqCNOlN3mwC/v1jvwrf89ivwh4bMNMRMNPhp+SJKlA+OIsTi+PneHLDZn8TFuBbn/YUPPsZ34LP+by/j3/3/T8KALjyytvgm77h8WURmxfEAPPoINK6y1QChkR6wNk1aNWekSlWq2vM0KCW4VSUnPNl4eb/h70/D7stq+p78e+Yc+33PaeKRgXpFI0NV7HBhigRUYxg8xNFJREUNWKLStQSbILAvdgS0SAo2ICxQaLYIFExIqC/gAoqgqgoGmMIFyOIDRGq6pz33WuO8ftjtHPtfaCqnvvc5zlP/XY9s9be+91nN2vNOT+jH5Ib+cF/HilsAm9vwCOf9304ueYUP/avvhrrpbfDsyCiEIqZFhTGavKOcvAWvKMWXAGvZiKlYkAXNS2qCbZEbrvLKPqPqwZNawMc0KPrfe4gXpA1QqsgbDYaGnH90m7TE8rNANVca06LR1ZAIzM7F/geHbrpRL/4Sar3Sagn7Q7XXgMAuHiyi9fUhilimw5DTdXc8n1CHCf7u/nKU9+2H+zWDYH6x72wiQl/0iqkDc5VgMFQMNM5RLZwtvcFAxYUJuQFprLIFJkZO8Dc1fwT5uxVNJ3Qex7tkWDuDa11Gws6abR+x4IuPaDt6aEkrjkzhAd+/KUvwnu9651x6ewyful3fwtdTtQvLVquky1S3N1Ct+R2dcP5dK/9OBlmqtpCGVCfscFZmoratUFvmNJQ1KHYwpH28dxBfU34RqX1Z9WU6HBWQEvp/b3RoE0aiwDxqi1IMZEZXsfBj/fCJFVryUeT/zkQmRt0aM9XALSQy69VI81sRNAIjQFgkyJFU6ssfYMg5vaSAHS33MGAM4n1H/EiFXr0MBvP8vbNAeXoW2L9/ROUDcxV9x6QGb5UPCH1PkogWBnH4OzGF5LNc76Pbl4fN5n/GK8xgVG7VxGuv/56E5QI17/9eqxDJXpPjWHReubMttkM3XCoLSBSMJOZDSF6/SucOdoEIlOqPOClmLTBrPPdQEziCX/lSohM9+vZFzA++d89Avd68CcCAD7rex+H5z3q8SWAMbMg4oTYcvTCKxF8M7QOt/WoCMuIbqbmg/bKYXCrka11yz/FWiBtmjSGVg37Fx/+gfix//BVeP0b/g6f/q+/H6E5e8obeeCkCRBks5Zs1jqQWwstWVoxLRcwT9J0mT/TSZjGPBNnyxHhQT/0I/jWT/s0/PBLX67PZZIutH6+hGag2RcGbVIYi/nJG6mQNoE58GkTXKBmbbNSiqjfP0ulmvBi788wM3gUFXEw+w5QrRMC8eJRUwXIvUK5WT6z+ZlVYx5pyVyhKewr0PZNQb1vCub9DOaGnRm1FzTp6K0rnKnA2daA8MANN674xmc/C7xfIeuCxkCYIniF97sWYfRbZfnO3aq599wQTSlii6Ocrw5vB7enIUQgRX2tE3JAozQdzJk6pGDWHMFmofoaAGaAHoy+WuDBSlhW15ztuNGe3fesm4cE9Dy+bRKey893/3Q+1qWTYM4cTSmmTSJdDNmKoAgqqG/pi1rg3mQ3QgMEkWF51SZEiPqrayGQJrrIV+imvsJK6EkWp9DWgjOcq4ErrRm66beyOdUgMH9F4IBS8z3QiK9wf6V8/RR9G5945ObXxfZYt/oRlfvv4N/G+bbXBqxFp/VLXvQifPkXfyHu+h53w48964fRum5izaKvm6gmrBHauulQ62hWXINqs3Lx6GQHNIFHm+ori6VTiQVVOqC9MlhGbOs13Zq3FcxzvTY1bw+84ZV/YdAG3vC7fwLCDu4fhs15T5qIQKYmKkgMVq15IPKHFzLHRriAzG1k4I6a2A7WUm4RgyAGaAzPZdX73/6ND8Od7ng73OmOt8P9P/6e+M3f/Eub/7ny3O0jZJHwLvBSAXI9mvlaNhpyJlKUmVLD9aUc4xpUBcKDVvXNXvmG1+PTnvFDXmUYsblRCtZoA+m+Y43gJoY0NqVBr7tGZjO8lSn5JBXY3qnXv3y96Ptgxha9753uRCO6FcypNXtMBFyICpeaw7kCegXJ3iDow9KmwpyN0JpbVzA3AzPtFcqtLWi0i9HJAC2LraMKZ2hQmMFZLFbB09YiniEyArxUqoRV9Oberm4496GpBuxgtptLMEMy4rERMvXAcwJLwn7syFANQTo8AscDwHwGKpgXeAJ/5tIVQK+sMHZAD9TWorP2HJNdNpqz6bQF0IiXam+q/C9l2vTfEbxHEHn1INJ8TjLzmx4d0DOcxSRm7e/s+pHlzGJkpPH0qfp9B+l5am4SM0g7lJtpzJH7SnZfDsFcI359u6cCa9eIvcqUgllCz08AywxjKnXHaAay//1QT5lvVI52CacwhmNBY0ePBdKxllmnMQnhl/7z8yM1qpqzRazSUWtobFBubtJeFH5RQWqBWASymGTPVuVI4WzmY0sP8QCwqjVHP1s5IhRFFPcsMtUwvD978Wvw7ff8POxOCH//ur80jcVSFCUsswVC9j2ILXdUr+1CZHnqnisfXzOMY61ZUR6iPNFiF5nVvC3hzzBQr/r3n/uV38eHf/B748ZL53jFH/xPjEi9hMn9uiLj6KmLRSsOvzJ5NLY/jwTzNBM2YA4Ym8kgzGwqRRG5wLwirYOwvYvrrDSN2eJnmoIjShqLNsSgpgqH1D3NwRw93iXmPEwo830LXNhk8oN+LUk4k3bEqlozSOelhJXP14SvPg2Fpk2ZZmrDcplNY47yhAANM2f3Zl3Fmt7fL2FVam2H1nagdoJGJyB4Ct2iriGx5ieomrMFv0kHS4f3tG7mMvHHJKvxhUsWws27Xd1wbsOK66oEl5GMtsodzF4NrJp3xf1JLaRlGigmvDFN+Cq1Zpm7bpOjRfpK5tKZ5jxIoWza81K0Zy9QUuEMmG9GxOr06sKdwBwGZ92Yqm5JpPqyVM2ZHM6lmpCZO2ElCnVjMQGnaM4SATvqESbQ9I20wIFmFTOJac+w6G1YipVCenVAO4QNyG7WVkiLXboZzMWjh6zNnNpaBpSpYDBwHMbVhB1Q3vy9pky5tWoLZregAKkh12s0gbnCGjnIrp0/qAJ2/N3DgP36VpFFLDpbWmrLBuZGZtKmBUQ7ADud8/B83o6oA2y5z56mdQhmCc25WbUwN2u75lytFodgDhEJhI6/+8u/xUIrOnYZeJw/WM+lqIskNWgpcFYwu7Gebc0MRtYW8LASHygn3kzj/ntROOXj6T/+G3j6j74UGAuy3VVctAgyc16HoOWasCtRvj2FVdwAUgCdF90nSJpQo3aDgRIO5FbhXKx/RkUyrTYlP7bXa4U9IouCtlVCWdYK0gqcLYKViv+Nyo8VV485WKRfx0HNogFwYmC2vCbBTudhaM1RP7kIq/4DXMvX7xjflQe8QLimOpn+tUJhbC0hqZGB2a1KO1Df6dHBTH7UIjQkXd+DWrjmQkiSFbAIfw8Cg6S/2ZUisfNJR5ySN+V29cM5/DZAraM7TXqU50uyvuYy9/RXD6i2zQJwnvQDc5L9O4VzR5Ohkpq1CnM4d7Me+f2t5hym7Sk/x7cz24bFI1hlg6rUJ9WYn1DW+2bONksBwWoIo9bj1SL/IMtKrnCO3WyYtcFjsKfdJDQm3bE4NCAA+MKv+Hx8/iM+F9/7+O/E7//Gy0DmQ24WaFa1aG+k0GCmtFih1XRddfeEc9XNXPmpAF7L8wHoY1Cm4mcuQJb8STmjDCZxmo7AdTpKmUrI4ae7vr+/j8C+TFMzrJt/vXesmJQurEFHrWl0bKZQmUl7grMe3bTtec/eq9etpdqJyKDskdpHipCEOftAa3ayhlPBr5DOVEvr81WpFheVVPXAZb0RopkAifrH47prRSdfU4Mtbca8WKUNc4nrEBM+oKZ7PzqkQw2vF6pcoW0WgwOa8rG4xBE5zX5ErK94DyribgGs7kHmbxjNNvk0m0YWic+0OF/6GuLyfkUD1Y5OWQqXMMK3Kx7IJA68BLObtuM9o8a0n0/RZh6Wg1XBrCZ1F5f3kFAQzJoT7rcqsUh8d3KJikYIKqHZ19idYWAO7VnXQ+sdrS8K5b6g7U9A7dTGCYhOQbQD4UStojDwOpzhwtIAeEE0WDKnOsVG4RuHS2QuAd7829UNZxd/QSmy+SKadkE7aVOxW43QxOihOecewkV1MuhY7e40W9h72Puq9uyl4eZjd0BzAnpxs7atzRoQ5gE3o2zbVVt2s7dO5+y426wSUtTjpo5mYVVkpf7cjBS+SFoU4AFo5Nogtn8z4L2jNU860SNmy0pNDtDoW+BJT/tOtNbwAz/9TNz7Lv8HCII1grvSQJ6wdrlZbM/JzZ91Odv25CKIo3vWliuMK5A9mH/SmK8A5q3m7LdiVJjuO6DrfalTkcqxTE/fP/PfeLGY/NCY2qyamoLGzWjq6yTzO5OlT1G5vulzVkiLLAZoC1phBX20j/RlZRCjAuZtXjMj74vknEjt2R0NFmZn6XtzRITzSj9LyK1SoqoQF9/u2ETdi1leRH2DnYHRRMNLSHJj9XlVT3yBikLaqjpFhRMDi1s3JmlMvycmX66UqGi2/OUC5YZY9FIWvtuigtUs+KbP/kp8/Wd+BX7ypc/DY3/2KYCtQU3mbqC2lnXqfs0CZ//Odm0mH7XDmRLQoOzcJ6JpbsKa6uYlOv3ExTk0oa6eR/BGGGE3Zys5xaK0xK04JW8jwezSjtgpz4mpzYUMlC7U+88iM18PMRnEHrcG6l3dPG1RGJvWTO0UaKcgOgHoBBphbFbFZh0K/Zp7ugCvyE4mgGcThHxkz3lUu/7Wm3+7uuGcJYIMkmzglVy9sctuwVyOqx8R/grfqdXP5ou1+KnZpH82WDNNo7G+T+Q1Dze5pUnbjwFn5Kbt2rIvsiKnh5/N95gG9W9VzdmDUwipRQFp6gSpv4fI2+RpIEvkhUZIuuGQvPlGbnZexQfgqFcM0+5YgLe/7e24/bvcHm98wxsxCFMUtweKkaQpO9K2YpOHmc1dS5KNfJ2vqfrZStlQbiVgT0V7LppzaM9+uQuUwzzpN1ujbr6OPbqcKvhz5bHv6ROMDdJs7xXbXgF0mE99o3IwuxZNrknbteGiMbO5K5DX3cEMD8AR9z+n71pis6lfVMLX7MFgVGFswlPOznoC9Kpkm5M1oOzREBlnYKlypHOqkc4p7YVrsLPKX/quuq0vQtYrXBsXeNxnIzGPlgMaqMFsYmtaLQRsudybY1R98YtMcT0TdA5mh0+afyWK7QuiYEeFMpVz5cvNJsoTHnYdLpyc4roHfTG+5T99D8jUcSpFSEJpjnXDiDyIMnkJaXfKclkF0A7pAmiwfd/4PTpL1Sed+6t4bc9RgNxSSPF/r0etBBaxL94v0612kmJa/e420eb7Ng/Beh4a2V48tGGFmrZVc1ZT9pLm7L4D9dPUnOkUoFOFMzmcF0j3QD+b32ZO14YXDVO7VsmUQn3s1q1bK5yHACvrRImoSykDmGov1lzo2JUdzP682HMw2DvQPaKUAsyhNbtWLg5noDbEiCpi2yEWtRxrVLc5rnZUW7dV8PYAGC+DqS9PODNpmwmPHPUgOG2Dt4AroGlJrdocdFp0yDcRe49ianJdlsBmDvOIxaI9C/DB9/jn+LiPuw9e+usvxtIMxLbIGpkEjqrZIOnn5lKIBWmpDzJjOu1GFQPVlE3YkwSY95SXuF5+v8+bERou5efArgEk4TzJMZVLvl+WvZft+rHBmgzQ+lYUP7+W8nQaxJliL6xh845INyHTnt0C4u0QM9Yg4w3gvj4zbfu1Ux8iijnXNFmbp6E5A5P2nFN3BnMtt0qm+TWawdyFNb3OX2/CnohmuEeNe25FMNWQxiFA76Kt/hhoTdAamdZchm/scOGCC6DNn8nmF2UPkHLAkc3CXmgosbBD61Q7KqSNuO8LXxzQ7m9uBuZiMvMoaGJVMn7nT38fn/jh98Mfv/51GuxkVpIpsYKKQIsC5mqLsIkaGrDbl6iA2YbkRgkrEJ2/A+WcuemOoTE/gwLKFdAVzvqZHaE9i2XMSE3pnDXnEICprABzf3l2GJk1j6iF8qO9DkjTWpsXmVlAq2vNJ5PWjHZBjwZnDVSzgj3NA/wsWE5Wi9UoJWRLiVtvFMPsoGbwrRfOBcbrsYHaCnhOYg3bZ92tERGbuWtjArFKbPV+ThZftyFMT8DO17V6LBKzCCzgyTZrzKFsh6OaCLPGtoDQyDVe953ogghAtzRrk0ZOwNM8KBZW7HBQo3qsSgNzRrV7zq2rnTfuL+MlL/lN9KbmRypjb1ByU2b4mUlCU/FNvwZ21bARZ5eP6plwGO/rfSKsJHrZ2wzl0TZgrgI8TXdzc5DNfd58IUZcw8o8r8FMBmgPnoO9pmbUuNbtN9W6E9CokLYBh7O7M7AZBc4K6BbXLx2o6Vcm8ahchMYs2y8Vv1R/hYcoZl1015pRHC+qIWvF5Q4tmKgZ7l7Jjsp8EqaC/EwOdBYEoImK1lxzGATpVE+ztUbfWhSxNEBWRKAeRAVX91zHRHCpey2gM5g1D3wqkvlh67oCZi7CnYCY8KDHPgx9t4CJ0HoHtaF7ToEzTRPPzgYl6GxawH3kmnlhAWBm3haymsNVm3YfdIA11EPTqOGl/eaa4LapqRWuCjCmsVsFg7kEUd3NbHV5nI2da7cqVnS7sNI8CMsVotEtMYdAo4HWbpHZi0Vm70D9BOgnQEu/M0x7FjqB9/VWOJuw7IJNqU0vQ7SaHjOYGYMHmHs8dg2aOVSJm3W7uuF8bpOHKSG9Nyj7cb3CcxO8xUBdYF67WPmYtIojj8trYm6W5yucfTFuBGg1c4p5z+2xG6hrPEn46yg97frYzdq6Mift2ercomlpR/Z87+aANpWjAUIubTuc9QtK2RrJAS2pOcP8L76OifK3j9hLcrPMjRP6/g5mP/0kYfyolcVqAz/9vW7aLgAGGZQlNeemfw+jSQWzx/9tAU3bjcGuQbl2XoUR5frCrmHE95RpMgqYy0+JGxuE8/miPfvLZQPpALMeXYs+EOnEfHxuVvQ8zRJ6nGD262LXyO3zfnNNJq4E4AUrmmvL01y1chMk6GAbAx3enlGDDwVettbmFjO4kWnJ9sowZ2vDptaMeQ5lBzM5AD1P1zbaSJe02VXBbLM9F3QKrnnROaAsba/32wbUBdgOKyr/ntxcDMm9AQon2a+alysoPS4k5GX/By50O5w188LWP4m5+TUKW4M2M7eBaFVBwr+3rbQo/uEBTd0WdJdiwo5Nx3yz/kXdrN0S8NQKpG0/ckuPh7RvNGdY/IWfkRCGqURGS1MrJFnDFxILyrU0KCvKo1qzAbpvNGc6BegChE5Na97B6wCEwYTYzkuas3kweDDGGOAxwDwM0FZT27Rn5o5bcru64Xxmi4fZTNOc0D03GPuxAro+PqplS4nadkrYLlsiVoMgshkTsDdBKA7hAuR4Dglk3QzpAAg+jX1NOKhVU7bKUQ5lUPiSFbp6n60QS2sJax0NaO7bFNPQYIutY5LQscIDkkKzsSNnuaYQvAfBhBZDjKAElugPd/z7qdLTThHspSlXHpoWW1iY9RkGXSINc3EgE2HfNoBuUEg3ZIWpNgM6wEzzuXcw14A+r4FjPQaAcjSrbAgsw/7kgA5DieRdv+aC/FsCGuGXTkgbGk3liNam/gMCykVLscePe/y/xJd86b3xjKf/Pp7y5Ffk97DrApuP+lmFzBuBwq0Z2a/ZenjbXDXvIjpx1jFGQ6cODV2sRXM0kNHryYtV5PKl3tlyEMS0Zb8Gzom4bjWvocysAHSD2Fz2JD0gwSwWFBlv6DLMFExiftwDQDuk05RGRRslT00C2/WWsMbR4LQ0xRKWWMow4Tnfc8T3FHtRRI2LWKtKsxSEvzyjtxXUYaPS79v0e4q3PZx63ub0kjABOaD9WFe0Lw77MeKrwB9P4q+tbZhVSI96PTNdqUnPc8Ytrn0buhe25jUnrOjIqppzi2Aw1Z4RkNaAMMFOc5jdlNZ83phTjlVbljEwxgoeHTwaxmh2fyBL5ALjVqk5n9lJi1ZeDmg2MDOwZz362NtYy7Gavl1rjp7QZYhFJMo7GZxRrZ/28M/Dt/zAU/EPb34z/s097xmAri+vwWB6J39iplNtYI0Ec4PObT/2UPVSq8oWcgppadZer1kdXDuSqeLSxNaMSsBEnmrl32RjCg2/O2zvM+nS+WC7vVctqgUm5qmr0eAeMKWxJhSlPzvclO+oci0HpaKXYCUyMEsAem3FpN2A0QijFUA7mAu/KE/l5Pc/GK4gOAsdzAjZI+IViZ3ddNCHvU4Bfxs5eE3+Zn9hBpHZpjadVNrcj10VAOEx33g/LEvDtzz+4/G93/27psn4BxO853jOy5QaZqHFRUKvPWclcCiLMy40DModizUbUEA7nP3K1vKz5jKBa8zmSee0pjqQmweAmdZ8+9vfHm+9/gasnNpzRii0+WKjCDyh/Sn0JD7AXj51sVnV17yBMzn8UI4oYIYCNsM4DdAWV9Ac1AxQExCpyRYkWjAk4GymYkstDatZs7Vk61g8ctoArWU08/tJfE+O76rmef8SNRp9BnRM+pj8Vbip53h7vx5N2Hcwl+dCW7bZ1dBCKFb3iPVsdkCH9uxgXiZAV99z+ppTc3Y4CxPI4wZAtmer2ZoDzB1jdPDashRuqUR36zRrX7bdzsXp4ZpzgbCPgPMA9s0GmUNSFObhk3Y4W9RiBI14sIgucu81m/czzcQB/PCveRSW3Q53vvvd8cEfc1+87mUvm8zWHlRTNefpZo9nIKc524fKpm7SBrLAPnJTCdHSwNwb2B63TlH/NwI+vauPbUwEe0/bLMk3eEGkErhiwrm+0/pAiIZgYUVQsqjmwjXULP/pSt4Eff7NunxLVDco/MjDwDwoteTV7o8msF4HGI20gULDVDDOlc0J0P7ZYt/Fj4zJlahpHQj+RSIB0tS/zXxUX7LPh82+56eqwFHmh0g1W/yUHk6iuJ8iwE8++yHoXTfxV/7+38Tc1T/b+RUq7yCAtIPvVwVF1307HMzmUY62fA0LERZq2MFa9sGCxcIdU+GsXynC2yQtKH49Jo0ZCuev+3ePx5d93WNwdnYZH/ZB98TbbjxDgmeGgkKZ4jd6mlRanlq0bpS4+HbBu5mFXWO2ozigzY/rszpN7D6KWRtQKJNqf5HNwFKED7GAP9eemwkCrVQko7K/uP5qvaVJ+0xrUQ9GmPY9cAvT4oUv7DkSf3uTAmbAdyWKxZ4gDuF+EhKb/bsUyOox8+JdiOvm5iMNqmUtA9zY5hM39GGV84bWyq6Adv9zgNm0ZrZKeprKp2lZGn2uK1Zrgy9g9y+Pbj3RrQzuaFZpz6AswLreKuFsELUIR92RXRsewL4bjG2cVzC3EhDWTJ3CDGfPabOiw5qg7zD2Se3BMgxvNp9h9YKfePJT8H/+yNPxlr/+X/ijl/02FlvXDAmNGQXW9vDoMji+IeqmJLBiaTjyDypsGgp89X4UQGqHRwfVZHXyr20CtHAeYz2bK5rLGqdR3oNInzfBRNMzKTwHznMPHxkCM9tD86L9q5hdWKPUVeOecpgbMEiwNrKsOcHopjFbijt3Mjgn/aV4A0JhImTTDillWO1IHMpL7P9Vc3bBIczf+fO1wb1srr1Mpxs1SK4mMOX/fQLphfnQe703HvnIB+Ep3/treP3r34bJr2LJ0x9//38Gz11/0Kc8JwK/AlMCTHm4AGYrztarLQlRci8yKYyvdLTXtWJ28E5GFdRuNTlIG3bZUxzO+v0+/pM+FUSECxcu4h73uAde9Yd/nBcGDHjdfDOZ6/UyLRFLan3u7nHBNSQEnwDjENB1VN+tVbsih7ObriGlsKFay5qdE8LWMqBw1tKaRXig8j0FJlSV6m32b7nlHsaxj3lapH5XcnO27211Zh4z8blkGStzKwD537IUcN3JqGwwObMAt5M5luNc+VwAowlr/AHrOupeb4IIfZhVxjtQrVY9rzaGsSGWciiyQLiDul1vYisjLuqL9i5wwxvHNOuN7vobRYMWEWCsuEW3qxvONzJwYpqzh9yOYbA9Bui1aMsw3zMDa59KRom1HNN8R6vjKgZpWUPS1Bw2q+pscJ7qC4vg1372F/CS5/4cFhnYQXvhjpCSJeb3diPebtR+c675tLckj5SODVDV9EQksZPpGhZQB9hhtAikiz6OGCEBdZcaAd85CCWX1X6jgllN1rG+m2QpPzNA6JolbE1iwhRKnxRTsL/VYmCLTZmoyNkKZpBY20ALWbOgL6ZqxpY0ZXfSXsBdUmPWDhxwN1i1ulXZxjXmznYcSPcjFSHE1GNHoiMh/NJ2QR24DQhzviEKiK3KLDJJSHg1rqobpd+E8bKX/XtcvHiKh3z2fXDXu34dIgnP098w8PVf9wI8+Xv/P/i1X/1LnJ2t+YVic8QE62PC4XRu7FN8X1ug5e/zSHokUh0l4OwA8pgJCiuLQK9jJoaZQCAEj/JXMEua5CH4jsdch3//zB/Dn732tfjjP3g1Ukr1C4QMuouIzJIT7NHPrdncoATzInnxvbpQc0CPDZgtOjrK/lqTBtG0Lu30JXkexYSeAHSWFiJiNPLsixZwJndXuSXLUhrF3jPBLPAKW2zmaraFS6V+t1sEyayD3gijSIebTcqlG0EGbUg8nh1yBcwyA3mCs5AKMKYx15oIAWYSCwzUo7s6OpNaakyD1haQGgjrpm6iHJ5iCFmsp7dec+lABNaRdZi3crcxBubObiwbONcd/Kbfrm44XxKFsMDUkmGAHakNr6tpyRXMpDk2bgJfByLX2QPBwt+scBZRQGfKRQE0HNTqy2GxduKSMLZ67PA8Pfc11o25boaTBoWqIbk86eZc17wSeGRgyvsG1gLcuY5oAy+C1gUcJbclzHdkSdlennCSoB3QDMiQyDiIIFgzGbcB04YkAT3rhYj4OgGYM0O3Jl8EMx0Ybn4gM9zZZ2gsxwzp0YDRBdxJteYutgBFK1saVcgIQyUytgpEE5z19FkaDyLHttqtfasnmwMQGIB0v+fyu9zlUfWKw5trLwblYrao4XSu4GiYhF+YdXrn5/3CH+N5v/BaAC0CbfJ60PT5NP3fDZOuObu27ClOjIVYk1LISk+QefRIx0LQ1geEDPj1OU1+fU2PI4/4rsZOOVg3CK1e8Ee//7t4wId/iHVht1d6xS+M4Ie+gRRAu6/Vop/9y00Sh02AhRPOnU1zVlBT5m0ia0LbvuKQZDNpswGYVejQwiwF0PDa8y2byZjmTN7UpwRmxlqyuR/R69ZpimvqCOl+1RzUJTBGorZ3HT7Fyv0iF6owJ5hOsBTt2DetAyAj7lNA20u9mnAiLpxrvnsTLQncfU2Kg9ksbcMgbdHbvZkWvao/mkgrtNeWqmAta4uu+dvqs9dAWu2drpkEgQjTlNkaxqgXNBW0devDuom3qxzOjOjxFwmrnP7iCugI3UVJn3ITeCt2UASchW1BsXZCEd6rBg177G3BDMgNrECGgIUNylbEUGrQR/6EbLVXNWmT6l0rLLdjmkuYM+2dPH0ExPBOLdQYo1kh+55HLAxtmQXwIiBTcyjoMzQFwwrtayMMN4HZYhUte0ilzSANiQwVNDUfT1986O4bRZgoNWiNbqZomdmFJn9zaEl2zsQ2V7caKJwlIF39yhH8ZWDmRXQRmlM7MlJclduatoEIAAvFqZniVADjAVkCNcPrb6FQZfx3ClmWCgqgD65zDQErUK4WjGJrEKtcdZ+P/lp8xSM/Hd/3lF+DNjko5gATbjyStsbAR57p9P/cQjNsK/Pr3eyvp0+B3MHoAWjGjmZgK6DttX494xra+aO0oGzjLFJMyHNE4ufJ36A6AMyXMEfLxfzJYWBuI6WtADRScz4GaDehlGCw2lQiu9i5sd6h4xqhCt5NLFUMGgA3A5rMvE3qc5am69mgHPHpZF5uXwcFzjXIS60pau72+tnebQpsa9nbSPr+eATO/lb67yyQMEBs/mfJ2TTPs/lx/mfClsiUndLFCxNbsKEIOpfGuKSA7mR9DsjgbNaGRpkdEOKlVX4Uiw6VpoI7k2gALex8mlXCSo+rphxgzoIkDmfeM27J7eqH874hwoKZivZMaaqOmo3ItKlh5uzRS0UKJJy9M5U3uLU2ZYK9ac5rRDseALpAegvlwK5tGlmG0yqFITdDRy6X+6DciFoxxflwTdlbvQ1LtXAwD/OP0dKApQWM1d3CwELgBaZFS/GleWEFG1G3LiVrCShL+u4b4tyzfulsoT0Aj47KdCjTlERTEFxzjiUkDkCx02Fbr/1+MSiLmfC4GaQNzNJg5mxAFoEsRsewuyag3bxdNWfy78AG6G6AXhGNFvx1YQGxqNvJ6GDTtVRjzAwVmueKblw+jyT+U7Rm+chadVpk4HWvez2+/rofgdYLPplmVronBsja9U1BOjHdZkxXQNcxlTkhB7TDeGChEYCuw+GcvlT9VSPgTAXMRWuW3LynxeI3KU+KCyFHNkkCIngizp9NWs9QqFqza84V0AFn921YcJVHPnusito8FZCjBoJJpoORWWYgVi9cIkI9AE15VHO2tckxocOtMrElMqJ87pjgnEKeNxrJugNlXTNAq0BWMXlDwiBQY0w0bRSTEULvO6TlYEal5pzzC7KFc7N1R3Z+vHiNmbPNtK1yk95fPEDMLp03MPRz5p7smFVCBmY9aTyoVGqmqdY+ixQDqxQ4z5XCPBZp7LeT86bdrn44L2xn8Jh52wfmYC+Hsze+qMWVA84OHi3ZpgtMO5FoP9JRjglpNmk44Iz0L5NpOXkzvUW2GlOR/DHL9C6Bukkvd6XcvIk4oEzE4DZAbQSYU92jcLVgJ8COwkHIOzOB9wEpgPZcyOhk4w5l99GvrIDudp4bIu4GjcCrbiqeYnXnO9wZ3/BvvwE/+9yfwR+/+jXoRBbdrEFCml45N0gIrUlsowGQHYE8GjVB7ZCWxmA3Y5sFS3yz3QFUtGhxDck+rMLZlY5m+28r+/dkZrXLwyaBSRmxERMsTaR8hs0X+POb65xjhjGiAlPVkv0+TV8q4+I9hKue2aKThsBo/1HenwBN5hMOMOummXBebQwsbSS4bTicUWMmYAIMinDmG3mcDsoHYlJNwNiBACR0OVylSQ8XkW0VbgKsphGaMxLMFdBhZVKBidydUHokY6TWHBqzCLaWgQiuE4OOC0JimrP/F5IeQnsO7c5GtuBMIXaywFC80IJVbaJ6167VBO+pFoT+NMppaPdNa3bFXGyt+vUQyvQ8bIGdWAa8hA2nQCikYDZFKMGsdb0UzsXt5OvSAD3lwM9LIjxFXqLcexupgO9x7NbKRVTQ8VKdCmhLsRItQhJxSLdKzfkyQAu7VcYmyEgzd5XuQuLbgtltnZNopGYcO8ne5FvMTkuuOWMNQGsd4EyPGF6NqEjH9eZzVsF8peqy9dV6yxhG24BMIvbRiE1zVr+SQlnL/1EfoLZqb9NOGKExi2rNO4LsyDpKisJq0X/nkahSqgghfGgj3QmLSdgGQHiQWUCazAemJHrxL78Ed3+Pu+OLvvARuOt73hXewCNKkbLWSm5CUWSCbLMh36UrmMH2GQppaXoedKG19CE1B7MAC9lvJf3+xf9cL0yFcwWz7+HVLz3x0/Z9aWL+dHghJTNNztpyRkPPG9ghmF2kM0B77i60sMYWtjmXtMrbne70rvip5zwSr/nDN+Kx3/x8fd1BWP7W1Fi3T4MFJaAbfEN0kzWb1uxjNTjbaGr67uEDNXCYXLDVmIGiNUfumYsvEjYBAGadst/hgZoAMlS+3qytyhT9bBdmAjMS0B0bOEuaVFpel2icwyq4TmBuFgzG/jEl2h0K5UU8tzsB7UPnY5JGkKZtdwuxlKA5cQjnGdO6AraHwK18hewMYFUwU4FySZGeIE1cwFwAne48AzW2oE7F5BDRet4siaqYsznBjKI1+2PzVUdN/viNTmId2UZUyS5dbM9QAX+YwK81/s1tafnOfszKYA5mi4i/VQaEXeawC8+t4HJEf1YHMzO0gfrA1C5yaklkkzJMt8W0LdqUkA605S2gXWvWY91YdUGkrJ6m7bqd5gSOYIk4JJB62ZIaPF1CAzuYhgY80MBoTQHbm9pgF5hZVyALQ3YM2RHaCUEczjuBOJz7ConiCqW8HxfNebD68BeG7AugzSEpBWQgRKqM/ibCWKzbCyyVxjchgZbkc6DFqSiLzGCspkhvU0cGZgpQS+PUmN2/bNaDtohZD4pW3V0Asg91EzWrwqXdb7DRev1S5yalX428kmFqyv7v7P23WvcM6O3wPl0efexgPi7i1QUi6PiZ5z4S9/+ED8IDHvhBeMEvvwq/89v/PbbDCme/PlsoNxC8O5ZH0EdQM8GgK+gBYoezatHdIN2bmim9AhWTzunqv3ctXs+trZBIIq+nRWyF5Iao8ClatACHhdD9HNsqJAIs2EqzFYqgNgG6qGmLwpnsd5CnL4jGftDgnLMO5mbBYM2YboCePgZmjYCnk7mtw2qIl2slQPE1669i2HkJHhmIgAJnKKBdaBAkrBzA2yqK3tjK9thws7OuV7LrUSzoqUnH/N7MdS+iE8O1ZreebEzZHttgYxHJozA6Zw33RmzuhFScHKBuJSVmSOcQ3tU9pvvpCJel3h+mJfsx4CwbOI9bo+Z8lnCOwANfc1WKM1O1TFHYHd7EPLodONQDzg5oC7KJEGRvTp5mbU5vqU1w06BRZ2NdIx6K40fXhnOb3W6vDiRdjqk5hr5gE9DBzK2pxuw9TVsD9TVWfGiOO4bsBuSkaVfBE1h3QVbLRB+Qvmrx/bZX7VlWEFZLNRsagBdFYEz63CuIvAiT5kun5kwE3P9zPxXf/BWPxn/6hZ8D9wUu13IxaDWmBFuclwJmX/UFypn+4GCGglnVcEjnhHMXkAeFuZl/ETtHusNJ8wvo84uCiW4emzYhK28mbuozwcSS3Gfgb5Xjg1vZzSqYRbdeiS14bMC8KR4SIS1qAn/d6/5v3P8TPgjMgje+8W8BnG1mXWov/vyVIO05ucEwM2vrYPQ2dNBAb2s8bjTQ2lBIkVhLxQRLmtExRfsmmMmCCU3gtWI2DmgRk4JqYJjnUsf5qSefMJV6c815C+gI2UexoYoFYDK85CPBFIKoJ88B5khrbBIfGfx3RZ3Mik7+cWLBTu5zBnrv+Imf/SPc6c7viad8z7/FC1/y06FrWEhHXlLx86TmX2EDc/yHCc7ke6dDeBXLdEGB9hbMOv8j3swrndnmF+btmGV5DWaREBYkJxGtrYIJWzczzW92rXmxv6l5217D1ljFAlnb5CT3hicDbP2rQ1nr+pvFCpAwMRgj/xMGSznyCHN2wll5MW6NcKYz84t62KtLhhtA6zB/j8e6e7i8BQIolCnh7ClCdqIp4Oyb4AhoxxBrczeL8valEsn5rASQ22b4c75VOhsIUKncN5MSeSlWXJ4nzVmlfx9VJJeFgWWBLAN91yC7BvFqdjuAdgzacZi2xfM4yVanuOasYBbTnKkCugto74COnTs2vTf90z/g65/0BG2MvnS06ENNcWQilcSBBDT5Qrdz7QFR9Wigzj2dLPKczVEsoHBMiQXCIQLFSrtZZ8IE501P+/AnR7637QEunEitmGFT1qhjAMEBoMV+ZwLGTPcFyAoa154TrgmeXAwaL6A/7FFf/Qy84Jd/D3/5l2/GG97wt47A6T1mKKPcb6E1ezWrqcGFa4BN4dxaAXSBc2/6t1Z6H0cP5gOtsEUELIQ0ur81K0vZMkIWBh0QZst3rr28cf5GE+b8N2aHNor5o3NBEtB2zBRFhXNt5Tg14QgwS9TLvrA7wad+zIPwX1/+X7COy9My6ZKgXhzMdlSBhvChH/rReI/3fD8AwMMe/vV4yW8+J+rF1y5W0zkwMDdK8c4LoXhq5KTceJDnZpAFiWUTLspeF/4ek/bsZmxbtnEdcuJXMOf3Upedm7XDbO1as5jmDG2ksshQMLehAWQ80LQVDtIltyqULSNHuIO89d1oUfaUrc0lY4XpzGBZMWRgiEKZRRtf+PtJ1MHQGty35HZ1w/mcdeLBJWkEryID36PmuKWpmhvAI0LnE8r+HlJG7rSZK1okL+iFqZJAAMMjDALFet3rttk3x3njUDwBMJOT/W54FOPGrAuFUWrPbJozacepEnEa5uyF0XYdsjS0nZq05QSQHdBOzNxt2jP1gak5O9YC5xFmbbHa5mSbl5qzdaOkgKWp0si2lp4cURNHDnU1hLkM8ftjJ4GnEXkHHCkbq7SiemtRXrMmaIS2ghkZLOb3m29s9omH8uA0VaQjNesuKI27Mm2sIU2LVYBwQPsMKUU1JDawY4AGcoZswVwl1fRcAh0vfOHLgcDqIZSnx5ReQASYyzUyTW6CM7n5Vs29Gfvg8Q8j/hbh6gGTFE3F1pOgpZbMSDATmwZd1pEljYewHvt/0aKv8DszWsiO9tvy5ZLHALauQyoFewCBB1rRwVA4v+KH/xTvded/hr9769/iox5ytzn+rFEGOVHEcMKXMzXBf/vzV+DNb3o97nDH98Dzf/4pWLp28OIi7UuTmHvu/Ej5wmIhqm/a0qa0boGEplzN2t7XwzVozSBLjVkH5X0AkS7qaVM1FmeCdb0yEubsWpClmfasZu4Z0noc6AZlbcDiuecrRFzB2INlATUt16mFBySi9NX6NsCk+x37kIQ0yxpg5tDE0+IqfGvUnPeiRcm9As1GhdGKNt2CG3SVCneEtuy7ZTTxrf8egJmgYMVFSBLA7tD29BWJoRF8syNMb+nl0f9vwdzLb6uQrv2dAZuslICuDh0PiiIHc6RbUGjNCh817SqgB2SncOYTCwg7ER07Bi0DtHBGbbstS4r2XH3OezGtGQbA1DIzckpFevEqR+hgUrl4YyxFaGtCKowxcuOr1yMcup72RXaE3UeaJggGBJQNDFEpbIrobghzfHg8SGHItid7zA+pUcZq8sIajFjtbiKLGoemW9h30msWe1Z1D27mQn3GfzuQ29g48vpDOKf5JC4K6lZ4ZUhXLbo8NpjFXJsucdEULb8+4OyZAw7mbsFgGrlj18xmuTRdXQyNgE03oaWvADIsCLD+cga8Wp2auP03SfmZMv1eQoYlAS4fFWyEhIgJ0rkWEfejVzk5oBFHd03d8V3uBAB4l9u+20FweECUPBpeU4SiRWYDqK145Bd+QEQY98XPO9K6Q7nVuU87ZQyJIEev9Oem6cxysWG+ZgrNuYIZmcUQhhCHNeU2ZXOT/GRKvQZ+/ursy5iaCcT1saT5umOgy9AjVjRZ0XgFYW9w3gPYg7FHkz0gPZr+qAtq0b3JNGedUyuY9hDsFcZ+lHEwxMAdcL5Vas57Vs3HWRq1YBu2K1Rs5yXmgLJMqgw2wxAqbo5KCGMLadOqOTbBgzdDSuvzFtvjvj9bIZzTNf5KRZr0SF/fFHwihfZMGLWupOcYN4UzL4K2MNrS0AzObQfwicIZDucd68bqaVW1LCGbZOhw9gCZPcLs54Fgutk2054brNIHMuQlkkV0iIeBuPBFUfpygrNw7gxed5Pc1IvYnCpjyJ4jC9xpBlKP5uauAWhchn4azTUYulYKinKfBubo7kUSgI6kgM2QOgL8eR+m2cD+XsE8b2XbW51/I86zb/leeISOwjlnoG+is9lbzzHFa5zIrmFSgqu277J8YOkm7Nl9L1ruze01t9S9hCYCi0SWYy2fKIMtSUOsMZpZkWxdibf94+KHns5RQgHl18Yz8o7OL5Dan35iwmcWsSiu1nz8iu9+GL7+cx6HH3ve94VG3ZpbzCnruRuYI3VPC5ihdT/H6orJ3s+qCMoEe/PhCopVXoWdCuXaUCugXDTnbcvqtgFzGEJci7bPJD+fBdI538p98XOUSkhqzK5BG5BjJJRVW7bBKxrtDc57aDrsHk3OVWuWplqzmxJo6El1wdngLNgroGVv2nOBdYw5tfbWC+dVwrdDcNO2O/SkDCr3OaDsvYjTJD5PjDBLm11MIj3Kt4sKbX3+yoBGHGskaX1+O1ljG/SvVV7nk9aDJfQcuI9Vo5JVi3Ewj9AEuQOtC1pXMJMPS6NqO2ie805AJ2zFScy03by0YQmQc9P2yhEYM3UnIESHqwB0JDdEVYcYIg5nBYk3VtcFbRspb0zasYs4mBMWKJeWbFeI7JOI8PZId7KjAjmhXZwWrHGETRLMXuBEbPNMwURMY/GSomIlRb3MqNYC979NmjMh0oGqeBdH0jktoUHX+VTPDduF8PNULswGzBIQRnkOeU4RJw7qkvBrmn8TF0xcczNh0Ad3VrdKZ7AHUllwlZpjDczUpjIFCmbCMCgPKxahr7XAv+Fw9qP9x36+YnkdrD+fH2IXYX5ZFeAl/4kLS/V5KSAOU7H+bXpsX+Ulf/Cr+K+/+6tYNIliikWjouU2Alqz1MJmEd5eza6rAJLZESnw1cp1UejGCoYkPPP7B6SvBOZxOLz2SnRokwJoG83On8+k6rLR/x8TknxGJqBdY3ZAe1GSJhZgKMPM2A7oPRr2IN6DcA6hHQgLWGyPsc0g08w6pPV0NYEhZAWocA7GOWQCs8NaU2s50mzN9XlrNGs3yxn0DUQtShyRnARE8AjM1CzS1DxdIj59osjBgvNJw7aYHMypTUt5zqFc5fa8HQfzIahzy8wNxlNDgjA5aakA2rXnplpzissDUsxg3ZpctKWh9abHhUCLmbSLWRsnAlpce9ZSntS8EIlFJLrmPKWWVDiT+W9UpI/e0NRBZDVto/B8OnsV0s2uWb1WQNQmjnBo94fXVKJyQqersNmfDZKZikahvXqNbkY9wup2I3Y9cS2lwRoKIHY9iVxJa7zhUG4GG39MBdIoe719x+zZ7LMmF/1W/NPRy7xsoAnMx+CMcn/7OO9roFWbHocJ2kaY7Kv1oQNsFhvugmHNI6RUZeMOjNamAn9a8oYwSk7pGEM150Ym6GQDRk13gUbN+nn06+EAKHC8IqwDxjRfDEuRy2GP4zP0SFQuolfP4nyfGijl32MCc5sFdHcTJJRJ0/ks4yAyMAqcI+q9fL3i/YELFtu/ezCYbDVoX2ZXgPI0JIWBJjiYWcckpdgNwxw6A7pGbLc6ZGhEtgwQmSkbaspuUCgTdiDeAbbnEKmphnxdacUjCC0AN3OpuOY8DM4KaIW0atEOahH1R0vRnoEB5lvWlurqhvMqEbehPFWQecqFmq9aLi4QrDehRtWaCiUmFZf5EIv3MKjLIrjtcWrS+Rq2CZSGx3nrzK0uH9eh/5YKoOMf5OtNqlZAI8xh7nf2ABRYbq9K3Nq32YOfWhcrNsIK5oXgDVo8z5m8QEmtH0za4D1M/J4qUgF94GOuv87KLDiAZYFIdoXJ0RXM3CBdF5EEmPX3SdWY0aCivQFzmi1+rvOM+tbQLIrIhSBGbpgkiBC/ASrnm8qOap/gGsoULGSas1UpGwbplfL+ZOaGRgyz5576HDCBcSvyaWh4nWfzXK0w9gC7K2nNZXYd3I94XqqAJgvGsgRCSi1WXSpkNX7IoOu1fwRrVNjCVPSFe7N+26T9t6lpCI4QVmlYhbGOoW0/B1txiDHDWUzG8zMmHL8hOiuRa2kSE8EMEZmLu4WxyzlbKEegvFNWyrRwDVWiUEf4czdbQ+wHdmliGlmU+OQJsvr3tBicvapdU2j75Z3BLBma4e6h1X4vl9cYoF3uda+RB365Vk0bKEeBNCnGsy2gA7h1XWZKm2vP1W7ha1YdMKaMQAPCVDnRDAQFs9UyJw32IiwA3KR9jrDSsUs11snLzdeyQtuF9rRCQpDR2nsIzsDigHYtejVQu4adBapUg775t6sazp2LJOz/l1xP+hcLGAsIU74IBAkNW9/TJ4/DPh/JAahzAzz2POLvjm+/1e3OHye6ZiNkKxv09haQRmrRvqIbKQw0MEzTLlq3+0Xa1gVOE5xpB60aVssT7hzO5sOOoLgC6OGr0U5kAMy/aEJB0MxsnWAm2SWkeUEUwe5qepKWQSW+mOApbi7SH6pBCJcGBKpelMvql9lSdLyjT1i4bLMfpHNowKNPK7gKmO2alXDVqZSoas86VmYFllh9nA2g9Wv55pCPsVHk5hlT5mvQ5EqacgMOZqHenzynVO6XkZmjBmMzRTuYucB5bYTegb1reyWnvHld824+/C7ar4Ya9sRqnBRRMDNj7Q3rYAwaGMQYpCWANK2F7Nrp2tZobuhcqfNRtkZU8Wl1/BRugVw9BBXMgklNDO04DDwSVQu9Dgpx2XSoHKs6W6CMnkJ0HRSas8yX1t+7/o7tUmGZp4Cfi82/q2lSB2CWIptLMZ4JZs1Ztl8tAT3dD21pzk7xnA7tWKVfhjwGRlaAuh0taBV7AOcQWVRbtiFhmvBYHbUEClmiVljQNMc5/M6mOQvOIXKezxUNWgHtKVW3Rs15AFFb2Z7TTcsusHikp5u98xKnf7maxBPwvh3FuxdQp6H50Bt4CGfA6zjlXNe/+mQ9tpX6cYv9Kyk4k3JqGhtRjZTNiFk0MjCzSd5kJSyRC30RK+spluusgxpbStIWzr4C6yr071i+XDohTWvuCmJZILwAvAOx319A3DXC3gPaPE/SE4ozYsU+p86QelYlIR1D/6Rf3aLs7aexAZg5NeZhvyFjFRBzi6UiUPI6BJg5fMwKFLGS7hJm7dCiYT5qQZrWzCqkYC4ggMubnq0qUOEnpJhyDnRr8yCu6l92zZjgOko+538PKNN8nyuUiTCoYZBpvo2wb6QpQd0sNwuplrwQ+gI0q8rmz6nmrD1t9qTb4F4YexGsg02oYazUFNBoAWaNmEUKWQ3h2tLNmEO4y3VeF1iReuy0kUPZY+qKoSZlNLsYMQnE4OzvZXMrHOjQGttcP7tcT+RyEQvNcI8PFoHsdJ1qNT+KAjoeVBexHv72RaDwVq5wZkj+LfaScjpocy4OwLwBcgyknFDFw7p1TbLQJHTaHl40p1k0FFy85gJ+8L/+Ck5OTvCYBzwcN/zjDfEDxTRnId1nsl9VFvMUSYFY4Twg2IHJNGdYhgY8E8d8yQHnswnQgmLirj7nWyOcO2/M2sh1kGtC8nJGEinZ2qR5UcTz+ST5Yp0/YXqcRph8/iB4BwC1BuG5mGe4qnAExvXrFehMwaNbEG7U8IzcNGCHf0pKdx0/Upgao5l8aM82IuLDV7sgavAedSyVJ9wJGfnlCl5iA/RQIMvYAX0H6t0gba9vBGIKs33Cea27pJ0kScHhAMoy+f5UxpA4MgMYJS0IhGGBZhXO4AR0BHoG0gzMcKm8KaCbB4Oxmn3ZQc0WpWxeAoJCHQ5G27I2QTRx38PPQ7SrKljO+3nGJXhpuo/pb+LHY1CGDs8iHdTCHL1vhMWOvTe0RqDeLM8e4IXQbChgHM5q/t4TcE6CcwDnBud9Z6yDVaMmz2B1MFsEt5DmnXpQGvv0cO1ZTFDPXwm/Zr4ovZLbpDXKpC1HUKG/hSiRfCqSQ9umKgnMtC1TswhfRne943viBT/0h1j6gi+87r544xtfV1If9ZzJLgdPwZvIsrMlODH2Q0YWOFwxF9Dx3+yCB+XKhS0XB3QN9Co1V+K+bxteOM1DPic4H5mavk9zue+Q1tKrORt9POJbvh73/KgPBwB8+b//Zjz1Kx4HcQ1XuoFZAc2iPmYRM4yLg1c/T10jQ33G1MHUEeG/5FFEh35nkbMCa4dzas5x4m/B7aqG8yK5ldS+yIdgtgsvRd/dUK8qI1VqnKGcxzlMawYxCqz9/X7rD1+ND/mwD8NvvvCF+NxP+7TD77oZVW7wnNoKa4d35d5E+RKoFJK0S9VRcpByJS00r6pppW3uh/PIhmkWxJvvEbA8AmaPEBodMjpoGJzHDlh2wFggXZ+j1uH5IxLscYfYNqDJdxOGTm+nb9dYgegZad/XtCGvIZwbG0XtbzK3CNUgKDObNvFcZwqtOY3CnKkYlDV6PSJ5hFmbMaRppaGQ5FHSgpACZwSLUTH7VVRnvaccsnmMd3g/ryzl3CuQ5mk005bNP2xw3lvv3N7E4h1EC+E0gHsDd8Lagb4QmrUvlR1BOmF0wtoJKwHnBN36xEaAeWCljlUGhqwY3CKKO7Il69wvzR5cgKHtycuNI3yybsamyYRtL05m6LQzWZGqkOovlStAmROOX/RZX4t3u/0dAQBf8rBvxhO/7xHa2rQriGNYFT9YmV2v6FcL6HjRQ/a5w/C29Hp0rR/53WUbL2hTo/zcHFIAjVlb9uGhBPGWlEaFGcwIrZlhc1987ntQlv0hZiLj5b/6QnzhY68DEeF3fumFBaArBA3sOZye/bFZoQxtYjGI4dHWTDsMSTiry0YN21odbGPaNt8zNmZuseRwdavucUtuVzecWX2rsZFgvqBRJAw+D6QAWpdnoXTcZqth/ftxUB8eE9T+Ph98r3uBiHDf+9//4N3qY92Aqbxj3SwR6RGpxZgoMOdfGAvpcIQkbvdLmUopZu0M0pFtptPGn2WBWQ1WA0PKl0Qea9TTIEQ3sIwSMjjb/b4AfQd0hXe0f/KdgUR3zJCq/bMNzNJjxyG7LyYYkIiWbh3QAJtB2oPaioVsg9io205GXhLC/ZnWNYup+NUMzOFoFKvp7WAeCec2dw7S7nwWaeyyDNucNvN2/FYDs+REtcn2jkBsgoX+qs3f6xHxOpQ5lma+Cma2aGq9v6JhTy1qa2uFMLM6NFG5yPzQvatGTV1T+aQ3yNI02Ks37Mm0ZyDgvCfGOTH2NLDK0CAxphnOA1H4T8ytEC0SqYEmKTJXYpU3Fc4FzCQbONcpJwnaau4uL/Kgq3jv4mnx40/9yg/hCz7jq9Bbw7P/81PduATz9ug4BcYJgFMAJ8hyuye5buMc28d4CQJeAdY03yjv6fB275AUrbr+Xjd1+9KrDHfT9QGYabNtOOApAT2BmUSFXXtNNW65YKrXSWfjn7zi9/DJt30v7JZTXHrbjehY1BtNDVpsRLURr0Do3bvCFQU3WGu8wqAVQ3YKZukRSyGScNYOhJZGNWnQCmXE0GAw3FrhvINe8ISybxwJXxYJQ5973Tyis3rm2FecicJVuCt/mJ65aff18Q897Wn43C/8QvzAk5/8jn9U+RqVbVWDYWiDAdWudMI1S2EhT2dpDdz0KI3AFgkrMSiOWCq0JVeV9zcO8djGMaWM/evTHDenDlTVzB3MS4KZRgPWpkFfvUHDyC1KKO5rVKUCGrlDxM7hp9mvsn/RATWdD3hFEeIGGWIuBpiZUjSX097OBR+upgcTDsRCaUXUNKZwVs1Zv1YRp0y718YbBuhGqkG3ERVlR/hKSTXoZm1UoilBmQc+YoJKAfRsAjyuOWM6JqgDUXD9hOIzCd7pqKFEY1utYzVlMzpalOzUYfKUgVlM+BmNsOuE3iyVr1vQ39LAS7OIbTWHrxXOLAZmxh4Dex5YeWD0hsEreKhJPMzZxffr80Z/m1vc7JcWknpwFpGk14TEAF0XahHdBTGXEs6Sp7pCX7C5kPlu//ffvB4f+uDbYmnA0oHFQevxkScFzBcAOQXaacJZivbs/Ru8ER+PhDOfY67TJEiT9wI41xzObrp3sG59xwFmMk2ajsj0R/5dyPF2dKFUL5VozQGokpU3JbuYueHSjdfjDJfQ0BFdn0OQ3uuVFoOzgRkwU7VpzUMYAysGdmCo5jxccxbX5gPjCJ+yw1mqqbuYtOEZLbdGONtEKEKpSTmWjwovrmnRfhIMCZ744xa5o3nzLc1hnc/WdXplKFN57bc8+tF4/KMfPVmMDm5VPrDHujF79GIORhb1mIZWKrCqVAroL/2mJ+KjP+GB+MFnfCd+61X/1cyKDmgFd9WUo3Rla9a9yd+XDq3IZKurnAJyEzqT/lsmLSjf7HEdrSFrEdom7fczrHyjOQPhP4wzpm0QHcjurCMvbM0GV9YqccJN66gUf7zuHg4irfbNBc6aNpTpFyINLKWlpdg19zQ2gzLagJjWrNdFC8Koq55Mc/bBYXAVIa86qxvSdrZN0207DyuUfXJVusyg3kLaK2TJ5lhN2gMqFKohsc1QJpT5aUFxpq0tDRa93dBagXPr4NYDzp5OtQdwLsA5Mc5JsJeBfRtY+8DKK9bhaVum2Vsd99ScYVRs9ktanhuxXyrljJhcpdPbwByncJ7rrnVGi1GzIrliLuW1AefyOK6cy4FAxh6YEckzKKiAGRcAuaCaNNmA+6KLWTva1w9g7IFxbn+n1Jq5+KNlNcDvETErAWgHJyWUw1y9AfOkNVOJ3K6z0KZoWjZt/XjeseTrMqDdhR49+QpMn9sZ1Say2jrWmv0ApbbuvxuqB2u3qRMMrFixh9cY0+EFcNTylY2OKqB1IPzN3nvAzSm3woCwE1PoKpy3UNYTK3HZeut42Z+8Bnd/r/fCI7/oS/Cff/EXJ8mszIfyuGbd1VfVrW2WCiuY698OX1f+YH/15zw6FzBAm8biDQYqnIVIS0ZSMxN2A7eGduEiPuPzHgEiwtc9+tvx0n/zCeHz86NYCgtHPWlBVPoyCTo6KlEz+5TvPjbjfeMi6OuYQBXkRzpS5Wh5n/yxw9iHqexhE/NNbeNclFa+m0nKVhOSmh4VzOKWagswy4vBlGBu0sBsmr0LCZbM0dDUDGe9a1vMFckdngakdaCPgLl48FLPTULBLDmPhfU6cgGM631im5Rv/r7puApdN7ZpzuYMzCBG2rzOZjT56wqYSQPHfG2xBYGtJoyUbTDnJ/Qkc0SnAwsRFiJ0amhNA3XILCTcFkhzOLeA816Q9ZkaY98G9rRqZHhrFmRXvScbczaapdGUxy6GiJ8JSbnPTuKcDVho6mAWXRsRcFXBTPHS/HdlmcRbOZgNVERu+tcpxzsNxYD5meVUwdwuAnQh4eytXic4w8C8KpzZPUewvdJiJt0fLXuEXVpWJKBbbDW5DMuo5UF720Rt+zZCGa5SZXq/v52JbuHQ10u8PuwfJMVS5UbqgbAwigqPHDN9oznDitrQUM1ZdhhYVGsWL2/igoyY4DyK77nkNIef2cE8yne6FWrOp9CLPoO5SIzQxBGXfgjAx9z/4/EB97wnAOCbnvAt+OXnPQ9A0aDL+20Bvb1tAVxffSUYb0074cup/6b+Q9C0yHUxJ6RB6kumZg0kWtPSc6aF7NeB69/+Ntz2drfHa//sNRi9Y3Q3H1KMLO1pmnMjM8WmdhlaJhXNw2yfR3lQVjHFjz2yqqfncheQCmfb5PPm36E4yDxauar3nIAQ66FHI3s+ozVd+HHy9d8qmHWRUreTE2X9smsWg8ykTSbkpdYM15pFzerSE8wR/DIdrXWKAxwlgBGwNogHE7Oc/HIFpufqP6CDf5ivoIC+PqKcb/ZYNyoNANO5S5mc5UC2aCoXKgLM0HzxxYPFqKFR145AtEBosfPbMVrPyG+Q6ibNUqrc59yapVN5ChdKEF06ulDPpPi8kYi6J/E8WgNBgwZv1TXpxwnMYo01FMy1l84UdrG5XNM1snHtNbfBa57/Jlxz4Vp8+zO/Hs/+L08DWRgGFqgPbwfATNlyQcHcLgJ0EemD3iEDwsjM2gNYV9Wax6LQj73STN7icN4poKd2qZsRy5ThnVdTpub55aFJCxDyfbUa2GPff/1PDnDyB65Nw867vVoBzXb19MgYiIr8YsrMNN/FIrTZYjwMzrRXOEvXLABqWTYW5ncO7dkKjBQoZ6pVMWlDgP8/nFNSjBakSEA3qEzzB7/1W/jbv3kT7nCnd8ePfv8zJhNzmrwTxxW8FdLTgoWvMV3Q7/d+74cv+uIvxg8+9an4x7//+wP4+kZWsHIIap9Q/r+N5jxpzNZMIjRO05qldYze8ZBP+1i8y93ugje//e8xLizqo+sNY2nghaLWB5vWLE2sMYHCJapr1JPheaICeC20WUihetJmbmxF5PI7U0M8du7rizOrN6NvqLywnG2fHPWcDTeR+8IGaotCoEft3SYdzB3SOxoroLXvdNctQahcN9tePJq8W95lXxWyMgf4sW00LAmULBBrr6eqPefPTY2sQPtoqlW9HYqd/lgg5dokqD1qm23Dc7/gAJsVRwUc99TrfK2/x9YmqZnateZOqmt7f2ktq6ilFRnd8qVb6CN7MR2F1EO4wuAM8mKydl4Tyjl0Ew+NWRzQDuUSy8sKn2Ya9NbsHYA2rbOGJUQgH7mvcgb0ZsPQ89uAf/7BH4trL94GAPCZ//Lz8eMvfFo6cw3OYgFg7QLABcx0EWrqPk04S08lhd2kbVozE7KBiIGZTWv2GkBHg0CrIcvOUQgzKEBlW0WyGUjNOc4hkBYI16rL6ZmmrOi1ZVMI4joboBXPZAJj1PMDVbCXOSJmqh5Yi695MXN211gQSpYwrMERuWnbIe2mbK+3kN0KFeu3QrP2BWiA/KQxIwMhzCozXeixrrj3e95dT60c+n+5vBao82Jr2q7rbJayX/nHf4yL11yDL3jEI3DP93zPWfCk2fdibs7ZHFg/oGzIHqWddbObtTprlqaivlrXmqWrBsJoePM//gPWC0tozj64UxTjcs2ZewYwqTl9TPxL1UHvR1lNhouZAe7YI8uCPAiKgZusdLOsf8wwP3vddGWQK7tsuPl8uaiYJB8DtGrnZOeWiBDNOLR1FyBWIL8tIFHTK1kOJXkUKGrss2gqTcbKQvoas2SOvq//WUtEqcNhbrPQNjP3P5f/xeblQlM+R/mazS0xbSb+eGT/J4q5r4CW2Px0rpLpKGY4dFUnwIxICRtEWJCjSUOXhuYdyODlWhXQLF03SwPvKsAQ01PE4CwNw332B+cz4Zw7RI95QmDTmCmOzUDdDNDZlnUDiqbzK6LpDc6Wih+mdSLX5BHnIoQoW/xu5PnN3/t1vPK1v4N/9h7vj2/70UfDjDwznA3Q7US1Z7qQcKaLgLjf2UsDUALY4exR3BHBPZAR3OeIoLKQlxzMWy3a/Ym+tBzKBuipHpEcjjiXVZbN5Tlp1/lSifWggWRU3iABTXBBUu2lZGsn9lIAJU4bjAWMVbXmyd/c0vxvc4qpms+tfja5Fp3mbD3LLpreCvOcT6E/YAKzjdWAtxqAvVrdBNiyb0n5e75Gpr/J5p86NLajL3paT05PJ+GggjnmOx2C27Xm0JBt9ouZsHXDU/sSmb+WTFNOs/ZiwTULRncoLxhLL2DWtJVDzZnB1n1KP88/f7PNq8pni4s3fgXSQh5R8koHeeTTpigIiUdgbv4WK9g13MRFNVdO4nd8yw2sHdLl6lGsWwWzbs0e3VPyy7qqFNwXkLgp1lwJ5LCKk6K9om3BVo1d7DVH/xOV5iet2eztYjAI6XGz2VyBv7kTxt/LTN5Km/Vt43uSywUp49RFUnfgKnYQ4EVUpnUphEWanWn16VN0B7JKcbKAZQm/34ACeBVodTBpBcwU04mLYONqLYV6a5D2NqSiKXUkUqBszgoh87jIAVwqUKZ6OpRA9GUbgEZ6V4AEcoWbNODT/+39FLymHW+nYXM4G5ibmbZRTNtyYqfRTdeScOauy5Ixg5lPCpgdzqUc6ARoX8eij6c9k+bzFAHrx+C8lakJs6lhMycjohux5ag1KSZ/BTTwEff7KDzxx56KV7/09/DtX/7YmK6+o3tylJgPeZgfeVhLDU0NpAJnlHxn154T0lo62Ne8+5v9R94KNeeLmDXnNCoUQY/MqFAu+B3udCe84DWvxsnJCR78cR+P173udQfpzryZIWUvjDc7BmYC8Gmf8An4iq/+ajz5277NBeRIJWhHHsd92kK6bISEDAqzxuDZhlE15upvlp5gPgR0U0gvZKB2OGs9bgnN2btHRfZuIYFo1xoRZGFoZPqJxkJNOzN5XeEoJl0HG+Ct05V0aIQN2QI2f6EtZi0oolE4JMPuM4oKD3+xWLWnuH4hngMy0qTtfmSytpWe9C3Qut/Uq+6n51tTNFoCzTYI7RZgXbLCj24bim0kQm7E9lYpnkdtkO4Uv1cawaNmaopuXA4XDI5JkgbYOncP57UFidW9kfKNavTxBOlYC/abYna4+CRxiYfoel0lNWftpetV4nQIm/YcvYcopsxgtpxmz2sGmAVsc0g8winy290uOwPaQv7UnC0GZgsg0nWpM76xC8vuo9ZzLKwphrIBs0daDySgc/3aY5cRkM/7iavyoxtvomGbwZkM4OTas0Vv48IMZyHTnFdEhPZAeW5VKLP7qguY/TMnQFsyxKQ1+/d1wfGYbLx9vLGkxWOU+c7AtsYDS7J7zoEur7IgsSf++FPxXu//vrj7+78Pfvjbn4Y3vfHN9hVydiZqLciLtEP0QAObu8T1DIdzrNeqQR+AurQUhuBWGa19Sg07skovSDivcB9HVhKum9MjvuZRuNNd7gIAuO5xj8NXfcEXRL7dJAliC2V/Rm/1ef83DcArX/EKvOoVrwjQ/uCzn41//flfgL/6i7/AAz7onppRhBLdCDWhzXCmAucUxyVeoBHZGhrZEsw9wSx9wei7hPPigC7a8+JBYYhgMG4MaQPecSh8sbHxS6yQ0ITNVkYrwqdAqioZpP05STivXOxrtrHysHraI3ezEJ29iYkH92RbNkLez3xnWyBWWlTYhIqJ0v6zHIxVTdhE41jQEpEBmrLAwQSraMjRgLaG4OIpPeJpVsjhv83bmGoetWieuU/Opho0yuWYron/pANAbyTP7QymzWtswdTgsAnO/s/s94TgAf9taVR2y5b2DfLgIAMhNzTLPafsKQkMFY7YaiJrvilpNafB4NEwRgMPUvmNocFybLs6s6XQsQl4iwlMw7R0BlkkPsF6A0Pye1kxjEwgkPCtxn5LMSWnkqueyk/l6NfLNWmPZXQeoWFSDtxvbYkBkA5N97dynbQzOFtqFZX0KlTNmRCR2JE+JRtTtoGZN2Cu/mbq82MHaMwaM+/H7/K/ST6ejGF+Hk2WFjJhx76vbi+UaV4oaXySsKwFTCbaE+P3X/py3P393geXL13C37zpb7AWCSH+i9zlbqU7m90vzVwAK1Prvdfz382AThVRomC6tyy9FZq1LxJhR9brFZ47LxoZ6IBDnUW6a/3Sj/8kvvi669CXBc9+xjMsRERCKqupDkf3OswAr6ZrX3vO0A7gkx/06SAivN8HfEBoydtjpiK4Sc0k9inSGapBmdZc/c6I4iIO5qI5LwvGYpBeukJ6cb8zpWm7OZhNa/bKTlVU8Q1QxFQEKcAlhbM1hInjXkB7qF1yz6C1gHllYB3AGJCxAqNBeNUa2mY+E1atWaawdVsMlqApspoG7dUUjgMa9vVpuqKqJ5HljAipH1TgSaamQdMOZI+F1Lztsywj0t180BE1v80WpznPiy3ebsKE1/q1zzZHpv9WEZsgYmD2DbBOzHrbTtJ3yGWJf+ICbAbHSTwHkEHXCpFYcNooPua6aHxbqp7eTKuxamqluhqxBuj5+YfoPBZW375W9TMtebACelUw8xCt7mYCHo1hFphhY7HHfQKzw7kJm9bctB2CadEdUHN3XYsi+Lyv/Qb85Wv/EK982W+kqZUTyg7gUTYEKffRUusDIQAV0PeX+r81o1gEeXnOs5ftdEDXNKvFPge2TC2EwsEs63FT9hbOFcpSj/59fc5cAcwuw09wtt/rlXeFDX7lPAqbNZR1v1OPWUnhE9dkrwRowmO//Gvw/d/2ZPzdm/4eY2VbZ2WJUDFtkxUXIUufKnDWz6EC5gLobHytM57KrCc3awO3ytraF0xzTq1ZLO0izVI6eyQ2HoHgb17/P/ERt3sXeDMxnVeE6B5F0CCneI/DfbDC+wDKSDA3AE954v+FRz/xW/EbL/iVSM7fas817Zc2IzZ++6M4lHtTzWoCc2rObNoyh/a8MzO3ac9TOpWbtS1dgLSzSzUtxQpjLhqzmMZMwEqgVSYwO5Rpb2DeN2DPOdaBT/6Qj8VXPOBf4zue8xz84Z+9HmL+auWsRNGQObpGzdpq3l5BsuYxNGiFNDkqOHdBXzgZ+d4gw7VgA/RQOESPQ6ujKBYcJtJN41YhSn2JrLZQT94TwPtPg21BU75vANo15iis7YIY0qQtOjldA58mZ70FlGWetAckz6cEqfn7/cyzF2SwF6wqnUJ6uB/dvpOQlu1U2WITN23TpVtVNWKgDc3PD0HU4cwW3BjCi5uwG2QMS/0p828soOEwduvLYoKb+7QVzs3mTTNAd/M7d6jm3F1rBsV6JhE88dk/g0/8Vw+FiOCLPuZD8fq/+DPdtK8A5e2Qlpct4Fs9MOWaeO6zp/GTg9m0aHJjjqdYlVrb0nPqTaZgB7OX+XRzuZvON9qyHDmiFwCX719hHCZnm/Y+XcPSW47i5VbtHDJXPy+pzNXsCP+bKmQiM6DzHOpu/cY3/jVyR87JLuYwd0uPAlrBLNZdLUp3+veyfxf58wXQAeXsAVpmvv/gm3+7uuHcOnbAZNLewyoUlWhiGJRDkkxlBh0SZosmFK/W/YdyJsYt1ZEtmAPQlFOiA/jJp/8AnvP0H8iqORXQlCbtwt+DyjzwwKyiNXsJTjYw+302SPPSE9DLDrzswrStr/HAMFiOppQobW9pnqdRCpxzU2zA2gzKYoCGPt7rEXsC7RPQOGfQnoH9APYNz/3678LSF3z0Pe6J9/7sh6rCOYCn/rsvw8d95AfjK7/lWXjF7/93FZiY8nuI+qfdvB2ALrmGGTVtC2WqBWhR2+VqCjVgWAcbUjOrtrDMI9jKi6quZeZtv/gC8prfduLEz5k1eBdKMU6iPZBrzWbGtt3KAQ3GRgszWB7VnqVO0/qHnMLTlKb5+TjaaghhIF/H9nu9bzgcyA4dH7B1Jup7bqxR15YCrp2qhmqrgKW9TFJqlkoVUWGtdlfSebcEoDEGmh2FR5jKtTWpVoxroTX7EHSxRoIOaTisASLdU25z29vGKbv25CKW4nlxE/YcLJeQDTN4y9dVX3O9VCEcUYGzjx7TaNPiFRllXWVY//wK4wLlOqaI7A7vGTGbtZfyfQkTmCcoYwazw9m1ZphlTBzMTFoshSqEZ0BzALpq0ZkFAaKyXfvCKCKilX3z7+5wFtOWxbI12GN7Cpz1WMFc4WxANjinWdtOAN/KNWc3aWcJRQDi6Rzaq9dj6LotPDdCeA4eG9Q9t5EAu+AlpxZww98E5bhPCeUK4ul4AGcU8xlUgygqdC1EX83aElqvFrjgxYC8tBnMkxbtZm4HtL+HpFmbvEiH/l6d8OoXVTB30GBgNNDaFMh7Aq029mJas9jzYjAmPZ4zaD+0q8G+4fL5GW5zccHbrr8efd1DhuA973hHfPFnPxBEhB/5ri/Hh3/i1xet0ncC99U6oA3ME6Dd41mCNCJyG3CLSgTWDdOc3cxqhUci16zmmcDsh6F9A2ha2Stz4sR2IJOAPMjOZo5rzLpZlZ3empSYHdn8elRUrzLKzv4BH/AB+O3/+ls4Oz/DR/7zj8Rb3vKW44tnArHEhv7AT3wgnvezz8PfvOlv8GEfdS+s66pWAZpfCzNkpFXHF5KDOn173pxGXyJTL+A2MsGs2TSjXnL5fSWK9t/1vKmMbehoK0PWDlo7ZCyqWUdRajVvk5u1ObXnBg7NuQsblJu5xjIwrEGLk3zHwz4HX/2Up+G/vfpV+B+vehV2lCZPl5cmTdnWtHuAwthRNwybjnG0mwOkGHaAAmiPoD7wB1NOh6q7RWZgOxwoR/8M93UfFOBzzZli+U3m63AmidmOypdwMHsGR1TWHao9e5Ga6WggHkxWyMbiD6BwFtdwq8CwEXZ0zrp6lufoELQt9j4Hc4WzCjr19TKDuTxOQdgE81twu6rhfNIWnJCGAulcFQvfNyiLhduIVSgSbWjvUvKAhwFJ7C1ZeD3lLrKLX/TICeCx1ujQtO1+ZQfzQgnoK8HZ9/tUqig3/FhktZEFWUER05wN0iNgbUDupkGbadtrbHsHR514Hgzma8ohaEE1YyCaVqzNYNxAe7b7mIdr0Hvoa/YA9gO0J9Wczwn3+YrPwmfe91Px0y/4L+jrClkFb3nLW3D57BwXL5zid//gz9D4XLXmsE7bpDfxOwDtBYKxIoPEiu3QtefYNQ0AtguSh9haHW6IBStJt8eW5xz2v5YXz0sg+WQKCHdoVI6eN+9spRezaspQa7xDmX1SwKwmEhr0pP2W+4//lsfjjnfUtoNf+zVfi8c/4fEHr5ke1yMB3/bEb8Ptbnc73O52t8NnfMaD8fxf/sVcAyX4ywe79kwSm7xqipJHh7SUwTZGng0Ryepc5Td6nmrEIYxmO7nOQVkbZLXuZcOPCmnVlhXSnrLVHM42dD8wDRp6v/uegIQ033gZz/iqR0JIVIF0WaqcP3GBdtrQ9dI99tu/F1/2lY/Gm9701/jIj3kv9bsWefHA0GEz1s9F3RtCICrgRpvB7Mfwydr3uUu/G645uRb/nf5y9ofX31A/o2obDlqHs+SoUR4M3UMH8t8wA63O8wbI8LKrVvBjJJQ1ucOORJna5GZnFO1Z/TAq5k3mCz8XdgIc0ram3P0Cm99Mma4qphh5WmDOa4NwczAb/Jubtd1UoNakW6o5t3f+kivfnvSkJ4GIcN111+WJEMETn/hE3O1ud8PFixfxCZ/wCfjTP/3T6d+dnZ3ha77ma3DHO94R1157LR784Afjr//6r2/255/2jpO+6Gg6dn3Bri3YtY6lDmrorZYNbGZOJjQvJhF+ryz5FgUmCOU5TH9zENe57D7lK4HZHy+kjQB0kDbn6UD0AvDmTGHGomnwQuBFW+3xQuBds1QphfUwSEcgWLf7Jc2K+w7cFqtr7FWadEwd3Es0bYK5jHOgneno5zbOBEsMRj9jLOeMfj6wnA8s+4G3/t1b8BO/8NM4e/vb0de9as+Xb8T7/4vPxEc+4BH42m/8D2jjDI3PQHyOxmdocgaScx3Yg0TDT0n2IHgtQkuss8hdqrsJy8xsNyN7LozvqqyQdjC7+dmbtgPeEKNFEN2xzl+yNG3PaddNohMYxSTxRiTp6Jy1lmny4chjAD/4w8/A+fk5brx0I378J3/8+OsnH8w8fvBZP4gxBv7xrf+IF/7GC/WzNwFBMRZodL8HK4X1xZtcZD1tL9ngwjKLpj/xsAjsVXLsBbIXL6htbalUwGt7itH3DX1t6GtHXzsWP44FC3cbdl/86KPpQMcCTetaYM9ZLrYeCQtrINsipN2WGPn85n6vVgEbXpzjMz7zYSAi3O1ud8e73v7dAlp1HIPcdkShpXrcDC7HOj6s/XP8+d3+Gq9+v7/Al777Vx1+hTqnNnMjTN9LHj3Fi616GdsYZawnwLoDxgnF/fWEsO4I6wKMRY+r9fheuzYxWZs3NGnRxIetapyW1myR9qQlZe0xPEi4DKKciwQMUkVN27gKRhOMxuA+tGNct/t9gJcBWRiyDMhOB+woJwycDOB0ACcMnOqQU4ZcsMcnx8Sud367xXB+5StfiWc+85m4173uNT3/5Cc/GU95ylPw9Kc/Ha985Stxl7vcBZ/0SZ+Et7/97fGa6667Ds9//vPx3Oc+F7/927+N66+/Hp/+6Z+OMW6ehLHrO5z0HXZ9p1DuO+zagqUvWMqxx+joraO1jkY6vPRlDUihIqr6ffdMuhkv5nB5vNWYJ0BvgTxBWccWzDpIA0AWgBYC7Qi0UFQCkoUgOwLvyMzZDuWGset5f2PuDr+0VxPzYb5Wt0WEPYy7aczqI0yNWcHczoF2rsd+DrQzQZ8Go58rmJezgeVsoJ8N9PMVy37Fst/ncT1HX/cYl27EX//PN6DxOTqfo/E5mpyhyblC2uEs5wplsV6qskfI35lrg5JAOe9GEWimaoNYc4xIWjVCZsWuYpY2P5WnnB3tnx2nMR+7SSX+Xv19BcwHJuxjw03NBLzi916B09uc4trbX4u/+h9/dRzI2423fPZzfu45WO6w4I7vewfceH5j9vaeonkFssgE6agyt7gMV0BNmYYyHM7MMdSPzJCVIXs2KOuRzjVWoe1hcwwGZoPzvmHZN+zWhmXt2I2OxcaOF+y2gJYFi3R0G4vlWweM4RCmhDPKffvb1NSBVYkKOEsBc7n/vd/5OLztn/43XvLiF+B//+M/HkA5Uo3qY6QXx83FXJ+TzEz0SmkVzKO+loGP6v8i9rr73e7+8+fWWxXoNnOl1IvJ4elYuwT0DOktmKFA3hH2DuaFsHbrRmY9vUfLxiYOZXYw1/sF1AroUtbVNG0XZGpk/SAUgVJBrSmlbEDWwTuG1HHCBmYGTgVyKgriCwblC2LD7t+C2y0ya19//fX4/M//fDzrWc/Cd3zHd8TzIoKnPvWpeNzjHoeHPOQhAICf/MmfxJ3vfGf89E//NB75yEfin/7pn/Af/+N/xE/91E/hgQ98IADgOc95Du5+97vjJS95CT7lUz7lJn+P3ndYWouZ5WbsITpWYfMfiZmwLHXCTGuaVuHmafdgSKZuSpqVRCLJxDTratIuJm5KU3aA+ojGbIHWtRz2ZJ5yLnJQntI3VB3WnUIjU83Zh2rSowA7zN4liIy7g8RMNmbCcVFZMMxHpINGS9/yqhslOZj3sPvQzdQ2Vdqzvm4tpu2I5IZ2wllVW5KVwSujrQxeG2h00CDtDBWBJHph2K4r17xma6wr9TnKXU+voE9YhzIS0m6itlxjiAUpbaKdJocGuenRJs0WiEDssiJI86A2FT/UUI5pykehbLf6o+rz2Dx3TOPeakr5E7UMqUmeQmbatufI50n8ZjPt2dGDxJqZ+8JPZ+krEC06I9CYAZEBMIPIBvTYIifZioCYJupCortY1JQ9gDXN2uqCMb+zWBS3dGzN2120x1i3dCqPEVcftDU2sRPsp1o9IgQPvuuiZtHwbLjAzoha1P/5Z56NX/jZZ2MtgVVX0p7l2PNh5UE5D5vh07TcBAgf7w/d+HT8y/ZA3AF3xHV/9dWzeu2fVeeNz23fn/zv5X7ItShuwfLZHmnfGLpnaYJCCLRhnoZXfKOo/qa+ZtOghUr3sdyx9au74Aw1UZcJH1kHFtCYTW8QgZxqrvY9VmYfuwslTaxjnxU2apv71rM89wA7rv8vwvlRj3oUHvSgB+GBD3zgBOfXv/71ePOb34xP/uRPjudOT09x//vfHy9/+cvxyEc+Eq961auw3++n19ztbnfDh3zIh+DlL3/5UTifnZ3h7OwsHr/tbW/TL7+coLdmEqYCWQsKcERghm+JJVIodOhipwppiU66eZSSWlIADbiJ2wPDrHgBipBJVxgt4eytjMndlwXAvNFsPEAjcg8bsrm6p0fs6PhYrEVkNLvI1pJ69PQXXXXiMzfMu6Yxu9YcJm1stBqgnYsO13j2ej/+TQGz1mQUSIXzYPAYBuaRnzsIFD5nAKJt3Cg0Yg4o+5IVcFzD+XYMzMjfXKJAMr/aQA1g+4a6KSSksrhw2V0bcuc1H62/Vuq/naAphyCu93M6Hr9dCcxb+B/RrD1aePua6pPc+qHr78h0kyNpJ7BrxUoZEjuS6ztd64NF2pOuVc2LBqwQk9kom40OGazHKSDsCKCxwJsCNlRA6/7R0eDBYNHhiPT6bcU85+WVTq03ifAX0ZGpcSXteZI5GVPVPalQjupLee3iyw0TgG3Nfc7/+izgBgBndh6PlAWYpl0BtLln83vn0piWDuLjs14Bu4PeFA73+U49wic4t4AyB5jLkKpSGex1IebydFCT/xBY/I79zb9LPVZrVrh0ZPPYzvPUcivPf6xviDneb/7tZsP5uc99Ll796lfjla985cHf3vxmLZF25zvfeXr+zne+M97whjfEa05OTvCu7/quB6/xf7+9PelJT8K3fuu3HjxPu1P1HQO6cJFacTPJPEDc2BZmfb5pgQIQcnkZoIUt19P2vzIpK5RDaya93/w+baxBx8Dcj8C5TAwqMPZcR2wBHb4/M28vxby0s30pfNNufkx/p1ttUaIT4xbgQjq3PH95de3YoaxA7uf5uJ8Dbc/xOloFzaK5EalXBubVTZtd4bw28BhaDcoKVWQOHGzBZ21kFjbhySBdhCy1BPhvsitWN5gKad9dGs3ahAE6NBrfEiZ7YH0zPtyBpTggDVjvEMh1h4z32r4GNw3M23ElM/fmvqfxxP3yHtJyz0sgw/fAORoWHMekgRKGzP1QDZQdwxpjmLWLvXhJ06IlDNWc3TY5GsAGZ9aobfDQXOdov6TqYwroJTgMbGCWAzBHaxNJoZzJLGy+/q9wmuMyXAHIR4d7YapBqAI52nQhffKWOADYff9whoZenJdh/yYFZETd46ihs52WJqj596/gTsEMU7lSQJmVUdqYwWwQdciyNE2pMo2Zm8KZxUq1mmnb4SyhPdtqNC3KV2RUqaj7WgRY2v1QhgqYtxCOXHCJnHCvd55BRaltT2uJcEtLa988OL/xjW/E133d1+FFL3oRLly4cMXXEc27hYgcPLe9vaPXPPaxj8WjH/3oePy2t70Nd7/73UG7C0BrNoncpyjIKF7O+zyMfLY5hNSuZls1mVVQIzUcB3VVEmKfFETtXfvtEY9LaeI6MG/3BHVzEFeNuATeUB0FzAFoC8yRRaLiD1cf0CI2/D3Fer5KmLTDJKk/HJPDy6qA0YAeTfP14YBWMAu6Q3qv99seaKuZuFdCWynhPBzMAlmbac0txqgNNIoZWiGp35El3RJbe6Bx1PQcyp3SKSJXGtjc95HqzdSow+dLiSN1tSbaP1DZbesOeLA7oxzLZMvVMj/cLhva3L8SlG/iCCgXbVooQe3Rrv5dSZEc22ZIOTKfG/LQHXYor2jS0TGwiMFZWpTV1OIlEhs9udA2mroM2LRnA7LwAq+5HpXjZEGW8bS0Kljus/1H0kyjpum/MIsiwey+Lz0Vaf4+uBRXgPB0f6Mlb7Vj2QLZhwdowf6dg9pBb3CmM6i2fIZDWFdAF0hfEdA4FNQyshmhEfvvIyHTmsng7EvLoCwEZnVfMXsQmB05Ia0g16Av1ZSjJ1rRnK8E5vyusQaOQDnBa8dFNIhzJxFvoVGBKPCm3JOr9kx0S9s53zw4v+pVr8Jb3vIW3Pve947nxhh42ctehqc//en4i7/4CwCqHd/1rneN17zlLW8Jbfoud7kLzs/P8da3vnXSnt/ylrfgvve979HPPT09xenp6cHzsrugxTd8oyxBP8IFwDzKcegMMzCDSaX6Wg6SAYc0iea/QQQUvkuYduCS9MYPTRSFC6bRjgyPxHY4l+IAbH/zIJup7POB5mzHnUNaB9tRFtHAhs4WYauNFUQr+9sE9jrPrhWaDblEnnixEdWCJUzWbsbu55vhf3dNezXz9lBAe41tMRhLgfLgZqZslaQnzdlAqVdAQosGDBZFoyUqi1WAUDFUvUP1JR/cD0jjCKB58/wWBJv4WS8rKpuxtSmW8Skf+4n4yod+Cf6v//Ad+OPX/tFmt6wqTPy4/G1+fEdQ7jfh/pU0AjtFVD8PDq8iuLh91n5vaq5FW5bVgrRWi6ZWOHdp6Nw0DzlKfiK159ptgnX+CFvpT1kgrHuBWDpVNktxAWGgiVY98Lxn75mFEDB87pCd4yNCnkE6XlJvNMtgkzxWL/sRTdkTDxzKsoXzWbkmYv/Gr52/p8FZzgBcBugyZkhPqY8G54H0ztRLTkVBcVi7daW4PcQEGbbzplozhUnZfcTMTauEGZjHsKhsi9D2oC8OjTkLhngKlZSjywMxFzdgTq05z9OhhowMgNxJHGF7KRaxcvsOa7aIXj4CaDvHt+B2s+D8gAc8AH/yJ38yPffFX/zF+MAP/EB88zd/M973fd8Xd7nLXfDiF78YH/ERHwEAOD8/x0tf+lJ893d/NwDg3ve+N3a7HV784hfjoQ99KADgTW96E1772tfiyU9+8s368nx6USOPzazJbEcZEGYwj2mIVQ2KETmnBnJYuZpmMAcAkAFaN+JtzE+AeQNob7jhkHYt2idygpkiTYoMsLVUn0pnAlpk0q7RMzhB8zukaM9i0YUyRRxGBGIfqTE3jzQuu4UopMk7RQ0GDQatbGBmtD1bFK1G1PZjYPbn94K+GqBXhM86Gm8PggxJrdkDzyYoWxR12e9FgCZiBg7zAkqWXPWbL1oSysUaZNnC+MgIZpYPriGwAkRRFGadP1s4e9Q4l/tTFPmRAcELfujnsSwL7nfv++Ld7/Ueh4ug8GJ6brspXQnK1QpzpcdbTZqK9ozyWdXignKe7DeGO4kHGg800WNHATN3LLJq9DTr6Ha/sZXWNNN2YwCmPWsKXI8GGK41s0NaMvBMZLFrsoCkaPDiUKbNgK1utwdI/MyQ2wqYK6DjVFCeoitq0WlsSU15C2YHsjeq8K8L+3c7u2b+XIEznQO4DOCSjcuqTdOZ/q0CuhUNunG5/JTHgLPNkS2g/bzp76PwHAaYxcuymsY8LFh1WOoUeQpV17/Da1+XDAnxI0IAr1ozAIuDmNeBuI+4asoTlGEw1iNOpBwZ2BFgeyx2MO3ajuGDNknsfCut3bTbzYLzbW97W3zIh3zI9Ny1116LO9zhDvH8ddddh+/6ru/CPe5xD9zjHvfAd33Xd+Gaa67Bwx/+cADA7W9/e3zpl34pHvOYx+AOd7gD3u3d3g3f8A3fgA/90A+N6O2beltPr0HvC1YRDGFtJ+dHh/IYYF4hQ/PXZKwGahMRx6qaMQ+7qBXQhDRxA27iRll8MR1oA2ifvEWLjs6BRdqcTNZlcni/BeqiqVMG6YgWDM3Z01oy/J8XDffn3dDjwparl/m3VuMUHqEdP1JsNcsIS0MFNALQgrYmoH04jJe9oO854bxPOLchpjlDwczN4EyWXtNMMEgww8F8BNAO5qpIFr3ZnphJEo6IGvRW6bPVlkO7qcApf3NQh3Wm2Ahr3jXneU1gb7Xp/HHn+3Msy4Lrb3z79Ktis7Fo4Wd9/zPxsH/1MDzth56GJ3znEw42o3cI5WXzOAaV4EOyzZdm7Rnle4QZU6ZzRSwh6BEzGjPaGOhsvmU7LjKwc0DzwE6G3Wd9DRM6NwvulNCeEZH8gEgzIDOYFxPWVXtmWeBt/WSqWelBYsNmhjsiGdWbLKYCp+EeFiFswZQCA4XE9IGfmiuM6ukIj0eV6wzOFcyyK9esgFnW+XkCEs57/be4rIMulfsFzmrd0u/QhoHZWYMCaEJkmITm7HMrIvztu5mvWQYFmMUEKrZiSgFkh7EfQ1Mu92F1BcRLDPu1yShtPc5qv9Qf0eU4mB3GOyiIT/wokBPR1KmTNh8N1Jofy6kw+Ym7jFt0+3+8Qtg3fdM34dKlS/jqr/5qvPWtb8V97nMfvOhFL8JtS13a7/u+78OyLHjoQx+KS5cu4QEPeAB+4id+Ar33d/DOh7dxeg32y07TppixCmPloQ3Zx8DKK8YY4LFi9BU8Vs3pHQNMXR+jQbAiCkqAIA5ostwE04J9I1QTN0970xbQKID26lHHwBybY6mRG1LxJr80gxIkQB1Q7myQLpryjiNpvoI5S/c11Go6ao50Z5eBZKgAQ+sA1qHR0+tQLXqvGnQzTToAfS7o5wrm5VzQV0Y3k3Y3bmn0NQzOopWCTFPmCmZxMKum1CXh7LV7W7k0KjeRWRkTyCFPiV8x+5dTeaVjo4Caq9bsJn+atWjW8xVA9i4gGDOYecA7KeWYNU2I4AM+9SPw8Ad9Dn74p55ZZv4hpL/kC78ErTU85msegyc86QmHYD4GX59jx+53mqE9bb6bAUzCDNm50qAtUXcIa9xCG6yDFNANA10GFlqtIIgCeicdOx5YeGAZrkUzOrO1m8RUChLS7LR1s6B1s6Z1u7+AMey+J0zVyJ+BqAU2OSW52Mb0dwqskhTCETRNhQB1nW5HNOXSJ8HOVUKZKpQtRVHONtfJBQBBgrxo0wL7HIeza92mPdMlgIr23Ir23Ex7DkDzzN5IF2uzRTCWVBGEhWwNu8bspYeZ1I3VyggI9xyW3MZWf0Ec0K49277tJztWR5HYpUrvRWv2PbV2hnUoy4kAp/bY85jjyAZoyrGTGdD+ObcQziQyhZteFbe3ve1tuP3tb49ve8CX4aTvsIrmNO95YM+M8zFwxivOxoqzMXC2rjgbe31s98/HivOxYr/usR8rVl6xjoHhQOdh5nEvCTn7y3Rq6LFDO/F0iBUYEewIWJoedx3YNWDpgqVroZFlAfoCtCWLjOiLoTnLlv40dmQVdBr2S8PaO/a9Y130uO8L1rbD2hesywnWvsO67DD6CcbuRMt17k7Au52NBbIskF2HWPWTKIChuyrISmDSWEHrCtrv0c7P0c73aGfn6JfP0c726Jd1LJf3WC6vWM5WLTByrkVGlj2j71m1aDNr91UCzBq0SypRs+ZCDlZf0mqgXoW0q6TYffHsKyszIogyf7FJoqZYtLKYremE+RCEFmiDXDu2HdBtLEsedz66jpOm18q6AKmkzSY9D6CvOprnjJ3rLivnAJ8DYw+s58C6B/Z7fMH9Ph1/+/dvxot/9/8LnK/WEGRYIY5hbTVFYR7VJnz31+X72//lt3Df+9wXz3vB8/A5X/I5ugldSUt+R2MH22Awg7pD672b6kSmHUW4lDRNR7QezY0b2mjoo6ONjr4uWNaOZd1pBa91h52PcYLdeoLdOMHJOLXjCXbjFDs+wTJ2WPgECy/ovEPnjsbdsi0czlBXlrm1mFew7DHkHEPOwTjHkDOwnIHhx3OIbCKkjIYELwFrgpXFDWQPbqupYMVV9FWClaw7HuFwNGD0yPrSVGzLrvCiHXIK8AVALgByUQeuAeQaQK7N+7gGgP/d+jhjq1G7EDAQgA8z9uWEc7ucx2aQbnubwg5nlFHccrQZUw1jX4Nu8RqkPbjXBt4TeN90nHfIuR5j7PMoawevPUq0yuhRtU+smp9YrIiEhQwJ5wY1bXcoMAuQqwkbO0BOoAA+gRUWES0icipZXMSKjWglsJGgjj1AFNCuOV9i4OFvxj/90z/hdre73U3m3P/jmvP/m7ezC9dClhPTnFVjPueB8zEUuGPFuq5Y+x7rusNY9xi0N3PJCsG+4LVBZE1TJyh8JACgKThIcxEYkGZI0Fsav0xztmO+JeVkqSM2TbGoQJi/GFb9C6W9m5qxeaM5s5WeSw15QJbVCpR4KUkUGxUD5I01qdjezLQ6VtOa96Cx18dr0aD3OkJzrmPPESzm/mYdqj234VqVqhqqNcM2d4Wyfh2DtkC1JaFiYqPsehOWjarK4cj9SHZDis7FafaOtOfaymwq2YTUfIerKabGcMk7E3sc1ggd3/65X4vHP+xREBF8yjd8Ll788t+cPyO0LZkU5umnAbjfp98vNdltYNdWO96V4/b+jubXhQZNiOI3oTVXmyHM/4sMKBr585u1DaWmc0P1Ic0v7sJYGmPHjB2GDhk4ET3uRM3crj03buhsEdPmd1ZDQzMDhGBIA0vDKlope1h09phyZVLETo25xSqus8sfpxnVYvClTI0y6iUTn5pAeQJhZajnLLRm13YXlengMSnmGnO/NrFOrQnOrrnaco73rEFkrjE7mM+OgHlFVjwTRB8ADxI75t3I6bCJ77DUJz9GyVvTfjPjvIW2zLSoORuL7dF+zDIxQJuuVWYN+NAvS/GlJffBDlCfIU0nEoCmCwKJSl8CumjVvy4anC8M0IV2HNCdUnu+cbNYb+Ltqobz+cXbQJZTDGE1a/PA3sC8HyvO1xX7vldAtz3Wdo7RFoz9AsYew80lMrW/gJdpdLu0QnYAwJxqaol7EcxfJ0SAeQZ0VOMqYN6G8MsiVu0LFm1N9pwO9zF7mTnu1uaxW7BXb5C+Kug7TWCOtpCRWO1fWsKUmv5m1Z7hGnQBdJi212FNL8z/bFHcfRX0YWMtwzahNhCAEwvu8RxHuKRtMO6SgI7c0u0RVJdomiEBTIFfxZ5FZAv8oG+e37eLxC13WMnvrakhJui0QiQ3abdi1hbz4w+DtAk5d3vXO+l8IsKdb3/H2cQ9BYcBuaPb3SkPuvy8K2nLuysM39hPaANsBzWlD7pGA8VOrCOLgpDlw+tRq8SJBkA2QWtpeerCWMTM1zSwo4ETDJyAcQKHswFa2Ezb7nMWS7Ezw5ZsCliIp0Wplo0jYJYC5jCPbmz3ufknV0uXcE1kIGSpTMqjv/7ArO1QrmNj0j5wQ7j86CvW5+DerqFf54a4RRUxT3+0wLAwZdfhYN7rdO4j4RxKsZmxo/LZNAVrjnE9Vy5XVuEmLVuWZb4xYy9HRgI6Tgh11AjF2IfjBJjW7EVBmph/XGy/VTjTDuZTBsi15gsCumga8zUCXGQF9MWhgL7Y9LnTBrkwzMw9bN20jN6+MHBLblc1nC9fvC3G7jQCwNYx1LS9rjqWPfb7vQK67bG2BSvtMXCO4dKZSWCM8zSPTCk19mFVYQgowMDcwgedSkWCWaVImV2YDZoeVTZSKilRnqfMO2DsxMzcBuguGvTV3X9jYG7DCozUxgtUerc6SNQGFf2AxBe87XLhOx2hMafmvFrVrgJoi+RuflzNt+jpViNBXf1YkWEkYu0gJbSgCmTXmEnMK2iLUEuvumBhgTx+seAMq1elaMdHm9U6pFs5tnLBUEbRboc55Xx3FbcHOpztOTFrBCuYMRiPfNpjIeuKN/39m/GcX/u5jWYuG0gjd/pDo8AhmLfm6grjg0F53zXoqklXzbkVoRWkGrMolLWCnIHZo3/PkWAmoJG1aBQ7smAZqj0vxNgRY0eqQZ8I40QYO2GFs/0bjdgW98QYmMXg3FRgt+hrB3MAWDyLOefDITQqmCtcKnAU0COODmhtI+lyXMh1W43Z3qgCGqsCkDtmQIcfFyFHk02r8JxUk7bpBJCUF1H81xOk7f4BmIcpf/41Wk4xKoCGH11ICqFEd0etvkj2fXJ/jYCucl1Eug4sGmWPBYIdpkY8NV4A3n27Cox1IxZ7egZ0DQibfc4COQXItGW5IKBrGLiGIXaka4bevzhstNSgT5oCemE9YV2Bf0tuVzWczy5ei7G7MMF5HQ7nvR7bucH5HCstCmaNEbXgkBYh/d5tqOa3Ztm9CmSF7wxompQJvVXNOQHNVWGtltXQnHVx8gKMRcHsR14EoxdId0mTdjRbKIFf9v76OTw1t4DnBvoX9tzdwZPplQqYA9YeHDZcg04wK6w9+Edy8NzLN32F0KAw28GabbQKZTEIq41CLRepMcMXv5/vo9Sq5NoQLAB9EBE1a8/b1KoAtJu0R1FTPKBO4bw04H/9yC/jjrd9F3zdj303nv4rP6XneB1Y1xVf9uTHAPs1TeNbrTmgDJc4MBUmcZOdb+L+M1wDDs24jNNyPKX5OQe1A9o7tYRZOzdC33jBZE5Vsj7dZJ3KyPyRBGo0ddTsIgrmzjoGY2mmQYOxc+0Zs/asZXlLbrsJciJkJXxVcFPBUzduFkJHlnysKVMOY94cfUYlqFFeK5MG7ebtgXl6TOZsu3ZRFI4NxCbXNdsbYHLdsZjEeK+iEYfZewPnmDdu1PE8Zg/8KlCOsc5gDoZRMq3Bvi8hY2bNBSgEtXrZlPBtRYPfstKfK0HelnUCsywF0NXvoqCefTW6ecb1Lus/92NxX1ipgw39MbFWpKwR0ehsN21fdCgz5NoBXDsM0A24ppkGTaBTUj/0CZlpW/IzbsHtqobzpYu3wXJyEezR2WNgDNWa1/1eAd1PsD8/x552WLHDSjsMLBhYMnJTLLjAbDZiDRCyyTxN3adCEJu0aYe03ULxlsgj1ibeGbVdlbja4NxrZfMiGIuCeewU1GOBpkZ1wuh69OYV3OYc5gj0MjDP1U7SvwYgNFjyCmtjaOqU+Z4n83bxPSekuYyMziUuwzVn1xRc6zEeac4yWflVss0XxVLh/3n87LQUy/9zb6pXJ2u3XSlCyh5XE7edxPd5zzviwZ/0YfihX/gtnMs+d+BR7ZMO5jGZue/zgR+IO93+3QAAj/ykf42nP/8nFOYr27DIbQezB3xVSE/20LIIrqQxVzAfA/IFP5IBGjOoK6A3cKZWZr2QEsVqrmO1TmXnTcG8kIK5z2D2fs6dzarSJTRnHQroBao1n8A1Z6uDLVowxM+Pn64ZzBZRLZHJHP8FmCWBnAMTiDdn/8Bkux0O6Po6oNzxKUMGaIObDNsD1iIH1g2mfqhrw+d5rcMrU+ZHaOTF/z9V9qvR2cXP3CtbCNGkp/dZe6ZYYuU8SfneQLgJmwV+RmW3UjxGR7qXpLS8Ei97KJ7GsgPFRPeJn8LWpCTVUrhN1PdsYA6laJFIXxXPZT5FdpW6qEOuZZDBWW6zgq4ZwLUr5GIDriHgQgNOB2hHegJtFki2hbhZt6sazpcNzoMHeDDGWLGuA+u61yCw/R572mOlncF5wYqO1aA8uEW5OGHVnr2ushcDm33MCq+2vR+wKP5nvxECzN7Mm9wHbf6bSD8wLVdbBwtGJ1j/eIvuLLAOMNuxkfYhbZjgLJOf2RsP6C6QwW8oC58hLCBP9RlugvUAsTxSANxyoIeCnVgBDd7AWaDArWa8jZmPygp3fTj8WqL/o/kMY965/JEDmbBpR4KZYhuHfwV1AJrw5y/+VpzsOr7oIf8CH/m5T0IW2CggHVVzTjj/zp++Bq/+qz/H+9/1PfH4Zz9tY5ngEnIucQ4TzNNPy58bk1KOg9nHpCFDoRyDDh8HoKv2bLtzRAQVMAvBW4nC2oji3OB8RqDeQM3aspqm3UqlrzaAtlg8Qhf0JlhIEtLIsTNH1AJriAGzoWIumKpFQtQfPFW4kq1IN5uxE6z5+B2B2TkZkBbMcYOUlzAuF+UcJ1FBVQqcqaH2XIFlIQX0ojCdGWdCCHNO+cD8Jas/2+viO6iz/oBqzG2j9E19AYriGWeyaMgiun993qc+Gu911w/A9/z0dbi07iOF39Mno1lJtGfVIdkc3MC8JJixA2WvXKREoj+airKRO0SB85RKVWpFLGJgBrCT4n+WiMpWSA/gmgG5doCubaZFN9A1K3ANQU7tRBH5jMjPvwW3qxvOF65BP7nGio0onMc6sO7VxzzaHiupOXvFglU0anNwBXMJyXcwN5tINvuioIhINLRIMANPfMqT8NH3+xh885d+Of7qT19rEmW9KB7dqajgSNKXDDB2929LQFstf4wuWAPSEkde2ATObGARcLe2Zw7nDAntgEVJ5uq3rzk1h2VIwHccgfRI/+mUr3sEWhNoCnCwOVYA4cjjozfb7UzI+LhP+Fh891O/C7/4Cy/Ad33H08vJPaZebjRn2sDZpKXWOpZFd7x3u/21mAqUOAG4ShwbHzQG7v21nwvwXkdAmY+cO57P3UEFCzsxdd4cA3PVlrdQvmhjuk8F0AbpE0o4h/pEyE4YG63ZwIzzBpzpbk6NQJS+39phrK0U5WtbF7SmcO6NLTUxNWmP7F7gHaSskxV0sWoql56uCPOSEt4ltibL1DJLq057ANH/F5ige9MBnVHcx6YzkLJUVDSlhBaTAtejsR3SQAFfkf88mtsZ5QYx/zchBBTDTtTGiSh6HOQ0h9bs08rBvIVz3eJiyRM+6l6fhH/70CeDiHDbC++Kb37Gw6NE59TVbpBWAgxQbzRo7qDQnheQ7MzMrRIJSQrRDmZyd0vRmqloz1mIREpNbUmXolUFo50WHZGTAucLA7i4hp8Z16zAtQS5hoALnl6ony8xi3xzvfm3qxrOly5cxHJyjVaVGgNjHeC+BpgH7bFiwZAFqywY3LFyxxg9ysV50BQGTZbeCHQIQGtvWorFr4/f7/3fF4941CNBRHjKs38Cn3Xvj1btuTTxqKZtLtHbBIoWwlURkZYWn9HE+pmaS6+JQVswWvE5O6QL4D/vAx+CJ3/s/4mXv/lV+OzfeJSlL5jtrASDzVHIRQt0X+rIoxQwawlUNm07AeMlFCFe89zKHfrRzorvXl56T9l9uKXFRkf6XaPRgvhfKXaJ//iffhh3uetd8MEfek88+d8/E+crEF0baoSn04w2gJ5Ip+eJmfB5X/tsfP5n3xvf8OTnl4vlX74MtgUp7oO23dT6FU9jlGPVmI8JM37zaeW745WCv7ZgvrgZ11B5THl0SIf2rGCmpaVW4HB2gXZtmsh7blrzmb6WWrPr5J2kmm3GZN3J1OwdgG5iQWM+pgQbHTIQDSrcJ1LmSUJZEVmN0v7/qO5lV8ejq4fZlLZm6ncG52nIZmoQ4vq5POXBYV5w0JcgDfvbCnfh6uwuU4IYUVyOF+CbHv4tuO4h34Sf/53n4mue9ZVzpzD7jAg6c+3ZR6mjXYuNROoUZq15aRu/s8O5TP/GwNnb3xbX5O1vfyvaniD23uw1DrZJ4AZoGh3iWkkZVAAN2RmYFzNvO5ytVQkV7TlMn5JfOCyXMvdttsqLXgIZO9HUqtMBOWXgdACnDbgwIBcJdJH0eMHeoyxSrzbnZoxjgto7u13VcD47uYj1wsXo/8t9gNuKQTsM2mNgjyGLjY4xrLC6NVbInsY0VW+sYNZSnCXwnywYxQD9d3/zFqzrit1uhz991R+ikbeYm3Ogs0+PwNuceZlPZyRcWkaax8ICRDK3riWF8vA9sjnYU2N+4n2+Ee9yent82nt/It7t5Fr8w/o2pF5RgsHEOSJm0i6AHjxBWKFsjUXYwTz034pArLqVxEDxJ9t52MzU3DR94zJfIakPWkwz9jKJ9b5kMiUAwp+99s9xl7veBTfccCPWMUwb1gsrtaVX7TRyVIN2kOvi+rlf/SP83K+/RqMwF99mN2pNtTvG1j+QHdJGgXEBcdTl3kLZwVz0sOpnOWYM2AZ+bcF8DRTM15b7Aeut9kwafeo+Z8+j8WAJ7wi1Ng0AM1O2a8xAFibxyUv7pqBf2uSPJrNY5ZrjPML7EGmfZ0IWAwKGGRcE0Ws7sYtaNMRnGW/GgEQq1IAFdwFH4Hzof8Y7uJ+zMo8OW7/EATbWU8sjhQz/fOeKT5PoVtWBb/ycx+GaC9fgSx745fjap33lNC39C7mMeJCDzgnmqKEtCeCAs4F50pwlv5f/aGHdh/7idb+Hx37ng3C3u94DP//CH9ad0FwZxEBbySrcugZdtWfd0Mial0AqmA3IAWYNDiODs++82DgvYHu4Wyur5uwDBc6RrhpNLTqwY9DJCjlpwOk6x2vU8z2der/it0x7vqrhfPn0FP3kAsTh3AaYVjCtEY09uKkJezSMxWq4rs1Sjqi6LCYTyDEok4G5UfaOPr/xMu57tw/CP3u/u+PPX/OH6NZfOlvOHawVO5rvVFymz4VdN4bYMEwWi0Em5ZOAiaMEdZrDBL/4P34Fj/qQL8Nf3/Am/MP+7yLpH3A/LELMD/96BCS5Fmz+5Ek7VtAIazcvh7Lf59gEU1Nh+1SX6knK2SD/vWQpxGL+OktJERdaaNJMXGmODVGAz/zUh+Le9/lo/NEf/TfMBNuO4mum5fB+9OdsKW3XLXh7YeuWLeUqetepaF3KBdYbk/Zkzq7viThPac6W6SccNWlvTdnXIsFc719DBmrohnOxgPmEbGc2ONdIRofzvqnWvHPt+ohmbRHc2DVg55p4A3UDfkNUHUMcjq0IP6cD80XwdKiccVM1L7LqYUfAHICe1laap6daMHFFaFq3dRb4vIRPm5jvm9faT6vv28ov9tnLDkKT76KOdgd+4/d+HZ/+8Z+F1/y3V4NuxOG8tH8XGrRD2cHMBcwOZ5tetcWtB4N5sJgHQMdlWVRgoA6ACK9+5YvwSrzYbBzp+WlWJYwigDAHuQBn3ekoTNzNIJ1xIGSw1proFdC250YFu+2aLZAmhKWyxvqQg3qxlNWFIcuALD5/oX7pHVRaoVS9UtVwEYEB9AOB7abcrmo4n+9O0HYnkKYVsgRDQ0akhz+ZR8NYrduJATmut0tNoTFLSFlVcj80r8k0Lr/tevzFH77WwCwxRQjNJP5i/gEsKpoUagAyqtT2Z7vPyMDdhDSmwWD7Rg5ogTe5/8bffRy+4fefYCUry6ZZHVNb/2mYZxPQFSAiXKBcgZxg3m5+qQ3pSRC4hmRfAannuO8v9Z4MzMn0FZhGXTZD+E8ivPL3Xw1tcrCDSVr1IsO1YnEIT5p0uR/nDakmRJi+777+t/mXJERc3eFUkd5RJyr/QZM524WYIhQc05oroGsEdtWcry3jNgCuNTBfS0V7JjXfVTDXGuRuVfAdbVdUK59bri07mM8p/dZmsULzDAm9LlIaJkiZx4ewHSb6muYcf6nzpv439Ej+2N5F/N18bc2QjisZSyStPu9ss6XNMe5vSB6Xu5i3Gcc15wpVbyH7hY9+yGF6JuXHTH7n8h6okC5/P9rgwrTnxhat7a8rJ0gYXqI8poCAoqKYhr1Q0d4pa+zb0fPkhb0sa4tBFlRDBdTaRaxby89usQ3beHw/CfPJ93ifOlpRbNhidcjZ0kpBpwgmS3HwytEGDuibf7uq4XzWdmh9ZxHIDLFm3GIg9ihmKQFTNXCqbrhXMqXFOOb/2oCaYCZv8rfVAiWApSjFarTLVfdkloQzp1W5KrIRQ1RSRxTerKZyQZHfthtbw6y/+qzEpPBRVO3SDyU3V4fmLJi1ZXt/EdXi6zZKqgGPMN/ngjCOxm2yFJBYJ0krLOFH1AjadA/oMBuHnYM5n8LNIgXQ20r9E5B7eU2Bc+PQ8urbHsJbcleUumAd1lLUJtk8V451kU/mbJk5uQVzDQarmrNryNcCuA3NgN7CeWfq0tZfb/fJfffd4Nrs7xsoa/32ooLViG/LmY5Sjl7aETWlaSvw6UxplhgFF2ZRrUuK70EDQ4ajWZ+rgw6B7BlKLhCXqxbwjNuG0FsgV6E8orQp/x7/nm1PEkQ7eRfWXTYeDlJfJOVysBkfuG2+gH92AXSAmjePHaCYp3dUBDPZKwricYWzDnYwN6BZapWeA5oFg1zoFqBGUVFOzdz2XE23ErKgP/0A77kdFeAiDiHzZgBTCuKciJ0SyVMf2yBZPLDuWQ5dJgbRKK+TFBzJZ11WmvNB8SkC9zvf3NtVDefz3tG6Jva537imEnlw1BS9bBun2IwkmzWR5Ui68APGxOiUTeE7WY7lBGibGCIxGXIBci7C2IMJkITxpKjGkIjH4qGR2rpIxbo3iQqVUgerRimwTc7/M+lNdPPLEHGK75VDTLP3+6yChSQSpR6pgDiALAHkKVLSFnmDLdRmQoBrPJQCR2n1jCFioM7XeFDNhDGpP6kIIAT4lpNduAqwD0Z5flpzCZR8Tg6H2xBhu56bsqdvu318KN1Pj7c7fuyeuGmA3gaDXYMZ0K49XyDVgrflTg+OfX68NOCkK5R3TU2AXcEsZh8VX5tkeflE1t1pKwrPqVHeN86f7QZbCmETtjodroI1AKzHeOzghsxD9OgNLLSgSNGFiuAbN59acghmRVKpT1cAPe0PfpWL5jyBWXTtkwnroVZv4joD0PVL+NS5EqBdjnSzN8r3s2ke+di+NFjlsEgAcaPQ0LUtJqsxbeRXKYAeqUFH5HhphkMFzJFu6fnR/j5ilQMLjLVyYLNuuJSfG1eNAGwM0F7ABsVSEaqM7oNs/5JFEKqYF04JW2kpBWt2D7KjHFztm3a7quG8RqGQKoG7VNMtr9cARVEJV0cRQwkjoYwK4oGGFR0LOnb6HBgdAw190p5rxqRLykCR1QycTmNmKCwNwsWVq+AdNGUpjYFMr2qqTQ6T8mpeJDP0t4a9Rr9M2Sbgq1eK5pyBHVKOErBWk96sjwupiZD8ezQDs9WvjYR/e08JhU+qIJuCCoBhi2WFQRmUGxXhOKC3R3vv3OzsYhzkxm1sgfX50O5QIIyZTXHfwcy5a/mJFXvO79ddcYLydELmiV61ZjryPa4UEFZN2xfoSGAYUmO+llRrjjzNthnbD6s+e/UFytJUU7a8G3HNu2UxH91nM5ZaV2MN+WqR0rRK5U+aENlerevYhFuoALcKsJLCeZWhRzigrwBmSMZwICO2B/y9E5p6eSiukYPMN/7pUmGWoWZY4eAmpkEzz5YkEl33buuePAy2zN0k60kMqRyU4xG5sE7DipAJ0AblALRDtiec/fv41CnJKinA2GdX7blGkGO674seIeN6USKXf6dlOS1V2ghCfvEELsxVwZ7rHiMAs1rqtD4D1Hpo2QY8mnbR81F2/yyPhJixx0Wxm3a7quG8FzMXF55A3LxpQU/iOb2+exmQZUCT2nUr0BSN1QC86pAVHTtosc9hkNajlWqH51tqfe0+LYrkm0ctG4SsOoHYRZchc4vfSCEW7ZPg1sJW7pP1lCVxwTKLnbBpJ5IDQGrNVDWAeeK4nr3V5sKc40cbbOkv/p0cyFQLzFcwh0ZtizTlFVscaq4eYl0SYRo0ijl/A+xZg9bFsP19E6BjlMeTLW9zfxqCrGtYxtTtq+x4/sOmCWH+ikml2eyS8bdyoyPf7Vgq1bF0qvA/U0mf2owAc8XKMSBvypxOoG4QjQqCdz1za06YqqfrDWtUkQ0rVmnoUrQhyWu8SN0OTc8htjlDGlsk2m9uTxxwziEG6UNzdk2lGoDVyHYhwjd4iuuS0eFlhtGsMW+nTrN/3igvdV1twpgKmZDN8ZgeBkIPZHI4O5iN3/GeQJliOJxq2P6tzjUfDl8/ih5p+3wF85ZHEw0lNefQoMtzFi6vfxdEMSOxgFzJgFzvjNCEMlAXNW67LKO6DFHmIM+WS9+DY6wEXikbzO0JvCftAnsCTcWlumPmDlqPN/d2dcOZB1qJKvZ0njzCtMMWQ/0WHqKvUX9NFjTo6LJgsWPHgkX8uW6PV3RoG7qOHpWKUmvWSzTFWYkW5KcIBIL5dAugWcBDtKvgBsapLcN8uC7Nmz/WPi8FYkn/nUdjB5iBTD/KFRTR2jaVpE4tA2qFshiQqSmg1VUr5hvTQimwgDfXPrq9z9TUaBJiEPmm2sBA76923zcsP5++yKp7AJRBO0dv5L+q7ES0HVJ2UxQo8wzkhctzrjVLUQ1stYftr/zIYu7PMV2Sww2uOgWPKbVX6j51QoeQnrRqbMA8fwCVD6KDGuQe3e4FIVQQ1pK4RUD0oKHisonN0AC9CtClWU11W6tF2HINuWrS+gygdi+F60oGZ0iMGciClWQGsgkPNSBx8jlLuR52GcRguNU6/dK5sbN66x3QTex0l7la+cus65ygx/hjgaW4cGt7TcQo+uO6hP24AZV//kGgG+V7T4D2f2NbavQeMIEhjpD8QroBJRVzIbt0NpX4rc52d6k1c6+5S7FPR0In62AHKumsuazqdhbyMQPiLkKmUIraAMYQU44E5O1Oz3U8+OK9cP/b3QNPuPRz+KflHHLR9jn7oGnvRApLN/d2VcN5jBU89uZoEs3FLU3pxapd0ZS4SADbwveG7aIRf10WLNLRRXVkw7QOWaB1xkx7tkCEZiZugBX6DmWxIvtCYGEMsTzMkktMQzVNaaImkqbfmVdSGIemLGEKzIxNlMcl/IByeASKkH4ummmU1eZ+BGT2r1Bnt5h/3nOoHcjcBGTpB2GGkpyisZZJrQNT3wRf2IVZdd2mxmwmbiEUYdogLUcCnqXsBblQXOw4DkYp2q8gg79oA2aex1LuHxQNt/ca5UyECcE/p5yH6Tv5hZDclLdK7TGL85U06G1ryNqNatm+8Tv6gGMfoo0KyDu2RDJ+g6ykwwtnuEXI3Dce5Lja6WvhV/TgH4q1pHFQKSrU+SqwYj1Qv7E2YUowr7CMHSAAPIHY15cUU7tbn5ADYq40EMiEz4Tsxs+8OYP1SDYF4jqXteJbFQHh8w1B1tc3qzwlrjHbkvZ/h3zb+c0396sgWwWQgE3ZTxxqNctFynTZRj+rpS2F6DQcScRDbkHtaZtkcRrEDOIBEitAI7r3dgsKi1kpgk66I2ff9wR0XX4e9+PCYQ8wE5r1q2l7wdgL2p4xzhl8xuATwbtfe1s8873/DYgIH3R6V3zK279Nf+epWCXG3Pl8v9lEKtzk29UN5/UctD/PHXzVIasAq9d71gIatEr6NxgWlKB+hCYNnZtd9G7dbzoWaXF/p3o1Ftjr0NFFwayac7dvJRvhUM1tTQQrC6Rpizz1NRuN7Lu7RhrtJRtFxLODeOoji9yYVJPO3EtgI8E2YFuwY3uL2CnAJhkmkIlBJQDt6QQMYJEimZfvYKCMWCrOkWpJLpoK6CmNrDyuUe3VdQADdewEZg+dxQSHH5fjZoQDiwqbGNmuZwDLsIIk9vyV223pezqg44ciAX1Me54AvRlXMLu/4AkvwEf/Hx+NR/6nR+L5//35RxhKRaM2KC/2OwlHP4AmvMxvSFNh5wVYF8i+Q9YO2SuYsTZr0EXgvVmGVglAr9GxLE+fr0sFs3aOG2hYxONyM11Ghc/c5xW6YnAmrCCsZEeYE4uqr7sMsSA1u+/m7ABzNW0EpCvUbA2gVnQ/bLcS2nNZng7JyqsQYsuY4GeXrmrO5RvCV+KkLSM/qz6uT+legjyvhAg+jahzRvigXWOO4Goq7wGzcvnnFnOXWzm96BG5uye0ZgfzKGBebf8ldCF0aC32HvZMj9u2c1+WfBivTGPWWB7Nux4r0AzOY69wbueCccagHYN3A7wbkMvncW7P1nP0Gyy1dLBWEdvZfmMfKLFb3/zbVQ1nPj8D0U7NOysCztpHliF7Ae3ZakJra8MslYhIvleLJGFhwiI6dtJ0wIbBejGtusd00OjtmAHSw7c24C3sSCcgCcANQoxWteeitcmavlyNgMa0+Tigt8jRm8lqrjmPEOgthqWIxtWfWQW7CQIymXfFfMhR4o71yPFFxPcne1sJ6d5LMns1IkgeY8GgAFrStD2BuvxdzfYK5kwdlvDxS5K6ikwWqV9hPDBHatv5aVR2U9eUxwzpbpCeGlXbqL5lf1xLMPnfKmQ5z/8Pfvsz8BUP/3K8/A9ejo//3I9/h4B+n7u+Dx507wcBAL7nX30Pnv+9zzca0BXdw/H3gwtfwZwvJhzTnq0RwdgB5wtw3oGzDpw3yHmDnJOOPWwIeFVzoff7Xq1bGZnf0SMc1SzewAXQavY2r6Ll7YtoGpauudSMVxD2lID2QLOBhkHbhEgCl+jb0JjdLF/iNWARwK49uxBFAIj0uXp5jp12N2s702GA9ikwypL0dVEz0JqdJo/QjvfCpIzn+/t7+deVfF9/SQr7GzATIr4j+jZTyrYgRGtLBXO19PnneFBprlELwAkwS2jMQxvvFCg3WVWJsv05p7R1KiMO4a3De8DTJPemvOxas1YuG6Y1jz0wFoXzeg7QTkALoy2MsTC4r3jb/z7Dw17xffiYu94DT/+7X8ZyzYCsNvasPZ13DHFLGhj8Dv1sV75d1XAeZ5dBWHI2r6J5c3tAzD+APSugDdLad3igrVz6Dad10gG9M0Cf2P0TkGnPOdSE0mw62MQjgmDYJsBYvem7l7VkAVMDD686xqgzKCLMPfgKmbw0o6YAWsqiQiA6wDyJ021atjOY/YmyD+nCE5jlXiMXO1TrX+qHFhHBNW1btAFml7Y5eeULxiHNqIBOEHsU9xS80fR7aIN3sXre5Q3INgEvAuJjqsSwAXMII61ozpJm674Cy5pHv99HAtoR4Y6tsTEP+PerjsjQliWu1xd81uejt477fdT9Dtm5GW/4hzfg79/+97jDbe6AX3jNLxxq1vGYUiULn+DhG9KG/lSgTMWxHbWOzxbgso2zDjlrwOUGOWuQM0DOAD4H+Fx0uNnQeoCvZtnyICHv+cvcMERHl1k/IjcSW+BZas8WuQ0LEINHY1s5EmJoOOcwOGsOhubrD4OzP26IsrSRhtjsrDmZUADtdQ5qck36nmugP20AbV4vg3zKzyII7Vgkodz8PmZAFxF8jr/Y3Pel61MxxNcC4zhS+r5d+Nfvrx+qaxDR0zrLoRqs3V0QwrOdUw9PF9ech8UEKZSJDcpQMHunrAWiLUSxaHMUGejUsPjMEAe0XReHs5BV0jVT9kra/W/V++seaOdAW4C1C1pnjM5oTfPmGSv+8K//HK/6x9dCLu6xjAHZD8j5gJwN4IQhuwHsRgCab6yi1k2/XdVw5rNL5jtGzAixVmjYi/Y6PRfg3DTo/TBAa39iGgrozow+GAsLFhHsWHtla9cwstEU2FBouwnc5W6f+RlYoktfIwk10lBYwcusm0Vj1rqyk5nVTdOJZMXzvLfr5KbUEhE4BuCAROwd083taUduFcow83WkbnQoAA3KHqATt9jrdYdhMsY1ZA3fmn5RRPWt33gyX09Qlkx3YNWeuc2A9sIobuPW2txpd5gr/7u2TGXH5BnOEaFtP6JvoOzadPRwZkwmbdr8SJbUoCcwY7r//T/1A3jMlzwav/6yX5/P8RGmMjPe/cvefa7+NfGWMN1CqJqlNzqils8BYQ7oDsgC8KJgvnGn41IHLi3ApQa53CCXGuQywJcBOgP4TDBMcKa9uZtWngIMZNgGyqrNssMZh3AmslavaFHJK0BMbH5oC6KkmpNfa4UxBB0iDMFiR1ZAu5bnVUL85E31AvQ5h6w2X9AYEzeItyuM+R3y8vta7AXa01VxsG8A7+93TOYOGaKAud6vJvVR31vKnkAVzjQ/hwJyOJgroCWO6YaytSnDXBl2X5ppy2RwJixi4qEAOwiilag0LNRNozbtmWB50PY97QfGvCp+5rGq1rx2bcKydkQjlrVpAxamgQYGy6pjrOB1hax7yNmq4/IK2a3AyYAsIwT6cf2tEM5y6QY74WRKEFkkCEUjctpLANq1aFoHaF3R1hV9DLQxFNDMWJixE8FOBN7S81QoQO2m7m7ac0NHVP8imL9qYEXD6uCuzSDYioySYAwzqBGriS6iPxQ6SS/MkI4xa9BAWZR1A6+rtv6dtv9o/psQDMyqLccKtlXNSKld/11qyx7JKQMaYNGhxe49faK+V5ikDwE9adEW2e5FWmoEcJbjMw0aLpkzUnOuVQ9cW15nMIfjc6tJu+Y8kF3pV6Dv7bgWONuPrJHanY+DubgNtlaOxz/l8Xj89z7+8Hq9s8cbDk+TpgpGrt7Y9ae6AxsGEtYeitUDzDRMU75kYL5xAW5cIDcsoBs7cGMDLhHkMkEuQyF9JqBzBp8Lxp41CnbPavUyQKfpMeEcwrB0eCgQkQZ0eulPlzXYNGWmgUFmwjZfcvpr879JQgSr0LGZjA4TmkBdhBoDlT4jE9i2vmc3dZNd+jBiVdDaYyFMEd6eilXzeI9Nh+nyy/yeMSXcF4z0plwJ0FVjjviR+sGEcMENVEBn5TY+Ztq2kHMStVp4EGArI8AcUBbsMLBgwQ4DO5jLkcgsmqphN4vgJrfRN+T+MbR6pMY9KKDbHhiN0BoMykAjryQ30IStPbGCmfcr5HyFnO4VzCcr5GQAy6oNM/oAmqDfEDvkzbpd3XC+fGPaYcKWQtb0HVo+cO+ABuicA9BtHWjrijb26EMhvRicF2bsWLBjwYkITiDWs97N3aSTAen/ArpNdt0Q3FBGSDCzgXmxzaN53e6RBQvTOOeRoq41u4mNcx8R+P/0fBSoTlAGyur0xyn15luUWja5P2uvWAPy1n3CQJS8A6VCUeFMzcDcEYrl5OBKJXcDZrUOhGuK56OnnwkLZJiGXNwDsBrgGiqsFX0UzgXK07kSZEeAljtQgNQ153EIZoe2w9lbRtY0qtr2J2BcBKftKBt33K60A9drG0e6ApSBDGkmbQm5mz+8mrVTcy61jfcduNxBlxbQJYUybtgBNyygGzpwQwdu7JBLpKPC+YxNe2aMvZirSSzjwi4Xk22kBmfTmc3AiUaWCmm9orMQkWlpzeHszXAa2POuKwGhoD6YgFeUFg12nAvhqHmbAK0YqD7oPKuzP3orI/vwv3sQ1oGmXEC+hfTRqSH+1SgSAGxJ1zCHmB5b2b6a1cMzAqTrCy4YITvqIQNYFc7FtG3Cc9aj8E5jw1wCGnXdDc5qzjbLJhi7AuYdGhbSGCG16bjfGeF39i/HlILfMLN2axok2JoXttI9bQX0egmjMaPx0AZLYxiYB/hshZwamHermrN3K9DN70yCcWs0a8ulGzQHQyjBbHCG1WnVbjhQM7cFiukYAWiFs0J6GQM7HtgJ40RY4SyuQXs2Ck1R22TLyQvyD/Ga20kgZt0wNCVIA8Ia5njReWmUZRsgVvFPrIdtXczTzhCPceXVGubUfGp6qUPJP6BCun4mpQ/MA0aoAbIq38SV1IiSR4C5BoSBc/HD90HXqBkm3FhKjgN6QDXlYWAd5rO3rU1ce/XzSg1KJN9dbAAJZlyhrna07jH4Rpf6PaaO9QFn+4IHYLbj5F/ePL6pNzlyfwvjUQd5jpE1o0B21ATpbkAZBa04cUCbxLV20Ln6k+lyB13qwKUOutHGDQtwo8H5hg7cQMCNBFyCAVogZwI2QOOcdW2udh39lA0PBiOwpTdWn3Nozmba9mvqJXrFNGduA0IDQnto1cAOiZrq+UsPzp8gTTeiwZtCks/5xHWptKxVcvrBSkcWQKO8moBIgaq3APP8zttdYTZp4wpTR/IvYv9G7IFPE4KCk5C7j/uX63tq/fyiwdcPJQV/ZpbM0y9hLQXOdfGTghlkcKbwJqWP2bXmboBWMJ+YFVNjgii6PGdAmAkkbMLbIPOhk2rKq8YmtEYRlrGS7iArrOiJWVZ5HeD9AJ8P8LmBeTdmOPcR6ZVCgnFpPXZl3untKofz9RqJbXVXxRq5e+F9CUBDFSXTolVztsCw4YDeY+E9Fl6xsAJ6kQ2kgQgQ28H9G6IBDFDvkhfTV9NWGqO9fu9qUO4G70bep9ZLIJh2p+SxvUGXpN5n1QKdZqkK42A10XRArEg3UTdcYUVjs4MYmOPTJO/ba7xCUS1R7VrzFszHfM5VaZkUGLcGO4w7VEvW06B1m8mec+132nb8PBpc/AtvwRtgNjgfvEbyRwSEDc4xuQzSHmjmZu1N0B9CS0dKO1c691KflHx8FCY4vjNm4q/GYexI2955ZJL9W9pRpFaR77yiawtrA60NOKcC5wa61IBLDbQBdJi1b2zAjQS5EZBLCmc+UyiH39mCwzwJOTVn6ywn1mkOCxgdjZYEtEPaNWe7dNI08EvagLQVQju7Rucgu8ZzZeZat1nXrpdvdM2RzF0S6YLbSCrUF+d6qxAjIbzLXe6Mj3jgA/Hyn/lpjVAul1jypamZliMop8Y7F+SsbGoBcr7zLIPE59mUqYKf/7zQRikFg6oTCLDJLKlQRmjR0VY2YkNMCBSCVms0W6R4DjM0ZQqMHdhSWwdO0LEjhfPOzNo7KZozDNBmVdbqiVAXh2nOK2XREhXbTXOGaPlYFs3HHwwerGDes4L5bIBPRtGY3descBarFjgu3yo15+uBvZpBvPapN3XH2tLE7dUHYh9VU5pGig60saKxadC8R+c9FllVg2Y2QEsCGpZyhWYKKEGNaQZgkkixEMkygatoqbluklhqzu6VaXbUiZoJFTQtLgnwALnQrrDJo/xDv+uANj/MlRZ5bACE1KL93YxdUzxR1ZQdyq1AuZq0N2AODXoDZkjxLQ+YCZvcUh2mbDFbnwyxa+FfyrppheBTdI8KSjCybaRJGfUcRmCX+60NzrCafj78b1uzdq23XVWfo9fr8LJNjzfn7YpQvhKYF0TfXQAq3K7QAOxOILNbkkldFK4iAvYEOiPQWQMuE+hSAfSNdt+hfKmb1kzme5aiPTfwOWsv6KhPgLy23HRI1wGHs1cbWNBoAVFHI0urai3nYbPNsaUQRW0PosVG7QHckI0SyqW2yyZR0U18SiFWHNu94q/fyswS/mmNi3jm6/8ndqen+NRHPQpPuO/HVOV2mgcyL/HD54/NmfJk+JcJITBUtxRv3mB6q/JvBbn89fRKnisHs73OA8xyOmY3Oc/4DZN2fI5+sp/ebShGgFkWA3S3FNeugbrUbE9u2JHlFYhWDQtjlEVpu3Y/hl15Uq0520yqAOJgXhnozBirgFdWMO8VxApmHViG9XzOQDAvSrKe3Qo1Z1y6QU+KKJjFm7+zadAB6GZ7p3U+8ZJsAeehgWGscF54RecViwwbrL4OEewE2Al0exD3H+mU9caMZLNYgyoECwzMrHWoGwuoWYJ9aMwO6BU0QYSMSkjxNzbmCum8zaVIkBtF2dBJkFJ/4dVM4PlroM2fE1uOf023FLby2OFsPmccYZXI4f3J4uXDInnRKpi1vrgueT0f1VwmTiv2H7P5BRXMkeRyxBsY0oK9XyTXVwJm/an5dVx+ZLkQ7wy+W22ZNjvgMThvoTyBGQlmv5aMALNX4Ay5xE+NvZ8qngScEegMoMtkgNaBS8fua1AYLgO4TMAZIGcCORfLf9a0qjx1hGwTaGCWBWLldN2w2WhBJwW0UEeztIBsCiG2SaoLQsG8BzWtjdDItHATkRs06pv5sL0hWSUcqZaPOlh0I2aPzTYA+aUiy6oA0JcFy8kJAODd7vYeB2AOyPmawnwEDp/PaXOsFhUFPKd/HFNLYTX9w7IFWGn8MLM3kqi8NX11+30lMPpgaiqUVXv2c0S+yIEUkPzyQXQI25V3MDucdZwYlLUehYUsWjCYhzR6GWPP9FBtWYPGKphj+xLzQLFgDEFfRTVnA7TsNHVKdqxAXtKcHTnODufzW6nmTMuqM8IbNQ+7b+UDaaQG7dGp2qJMcyw9nYqGatCdVzSxpheyJpzNFK2TxM0n1kHUxFEGIp2Dxeo/uBRIGVxAsDSqNgzQBmYxf6hn9PuKMijLZilWgGyBTCgrbrvp+2rxL1fBW/lVAE31Nf7pW815A2lqCejIk/bo4COaMzDD2ZkWrltTSDHETlU2/kD83839fu7KwuByPsPHXE9I1a7bfA7q68TBW8dqnzXZZlGqo2zG5hxvz3k83lzHaQeUdwBmOtCWsSDhBb8e+jraIcFMCM2oGgnoHPraM6j2fBnAZejxkh7pkj1nQKbLCnGyVCqc6Xe6Iph9/XIDWKPCRRTIIjt0shJnpEPagkaa+0Jdg/ii4YrlpVMbCud2jtZOIHQGIf134s4p8283ycvWGBrI6JqzxzYgj7EmWcpy5QClAtqr/BH264of/KqvxMc99GH48Ud/XbRWDNAeOx65H4CO+7lwxaAr5MKB/uOcWvlaFgrwbm/+/VsdUpY62YfZe9o2Fabtut04mGtmCaAadLyfHH5W7rli9hLGgjHBeQcKQHvtuu5pVLYTQqCBYAC8mWODWYX8debW8MZyDuc+vO8Bg3diGjIrmK0IkUQxIrfYJJz358fO7ju/XdVwxuUbIYubtZuFzDdsOkYYqGnTMxSgwVqVaGgkXmOFpd5fozJNl4Euao4OPwgMzhHo4ZNAjWWD1N8RKRDQ6ZvddExzbkN3AIsN1KFmkNi/JR8lK7a7+4TjvFf2k9jEl7Kp19VQIVtvUp7bcCt0SzqEdURs2+onhqZkXQHMAeV6ZOjGZ4KV8y8j01MN0H/j8GN7bF/Kd5P40vXDB0Jrrq1+JludjRoyXlvX1N53dAzMjMwNK9djOg+uzviu6ufmGKCBqX3RZMqmEvgFBXSx2PvbqUYsCmbTqN06G1bcar231EQ68wHgsoBsKIznI84AOhPgjALMOFeBQDyjYgVk1TKKxARtXm551KIFT0h20FJAJyDaAXQC0E4rBLYF0juoNZOIVSqmrgKwdIsN6OcAnUHaDmKat6Cjixpqm5s+w1ID7a5WMwFGuWiiC8iDm6SZCwaeaWG2G0KAiQn4tR99Fl70o89K87BDnRJstQymt4R1wX+amoClXZbpUoV6m/Picx8JckGCmeq/20w/B6r+2szdhmxledujJL9fnC052MHym5gk7lOzmrM1BNDcgehYhCcou0l7ZwrTQlZBjFwDzpMrUGGEuUDb/1+UIb/UWhRQNWcZAl4EsqpmLAtbupRpyrW+fqRj6gla9rdCzRmXb9RiEKE5V6m7jNEQJW48t5OB6IYyJAqse8h8kxFHLbqeLcrcXBJJ7oVqAg0w0Z6iJo3F3pqUjGKD7LtfmlS9WHxIo7CJX0ExybW+vHLRoH6cA7pqWQsmJk2APqJFx5Ly5zaK5SwYxOnIXGm38JYVS/5TNt95MnO7ktrtuAo8l0T8gzzFi/P8CHMCLMz363xSqoTiTmwUq8X0UkEtN5hwtqNfTyr3aw+6gYRovFe9JkXNqbubX/ewBJR/J+XfuuZcTdkLFIYekV0sH8RQMO8J2EmJg8tgxlgbQyyQ0oqHnPmRFcJnBugzBi4LcMagM1Iz9jnUP30OS2ekFBpMiJAV4EFoQ/vlOpi9+hjEunbQqcH5FEQnCtl2AukL0Bagd/WZd1IBNOqhr2jdSz+d6L8hA7SFZjZpaFGVzISSluV1yWzcspk7noalYLYCJ+I1us3fKtA+5wC8MAmASWb0qVyBvB0HgAYyv7ssTt0mKI+iR12kBmvxSBn9Tl4GVKfbXB6YY5+rbrw5+jz97v75h3Y+QOD1/V1R0fvWcle4bEVSzNqtaM1+383YCuSdAdrBHJpzSD76jZk1l3l2c/laS5dGY51SzFDNeRUtWWwNcBzMaAXONSODrCwzCfr+1qg5n98IrHuImNYsLc3bG0BT9FrUQW6uYmg9V5bohOKDDMyaBmEl8H2jFJe+Qt47HFWdJBTqaP6tkEWSokNYNwnxf+e3qrUFjG1zEL1fhYMAOBAbvXfDmvy9A9ne2r9yt4/eurxpKyHbrfz0GmiyBbWfhq2mOLlh7Y2rDBMuXovQ9vyN1Jar0OLvaeDs9qWaQZqAzAPbCjaba7a1Jca5YzVt1qIkfjK7zRt3VkaYuSC6dgSYgayNiASzPzdp7AXSfjL9K1ez9pV8zQtUey1wDnO1+5pLkHpcdkGCubTNaw7lc9bj2QDOhh2bgviMdJzTESjTBGYM7VpF3CCj6TqQDuEFLLoFe6UBwSmYTkE4RaNTCJ1C2gnQdkBXONPSQJ3Mf85WvW0F9z2on4PaGdAuA6SmAoGWNGlCUSemDYOtDS0StGk7I7qGyesPwHJ2ScecIClqEYelKMV0tUpiZS1VGI/N4wpohTQVJblAumiLYc42SGfqF6aj51M7oFJ7zswMrbqQKgjKMZZVYLgqFvXmj2xvym8Qu6lrzU2kaM1tArOOFi7GpZi0l2KxdP04zjeQAjv734og3vU+2xLnrg1+pFuwqcUyiLlNyFvFbkzZVOqG9vXWCOezS9DUFQNz9T0fQJrKEeUouYnW5FpmeLF2lfikwCMN1AItI+htv0v7bwi0gEKYtSjTB4Ssji+vENpDWo+FE2urkiqAPEM6jUyEB9/vwfjGz38Mvufnvwe/8qpfUoEjhfxS5hSpObtWZZqpBwsdg7R/mwnUVJ50mBcNDdi8R/058SblUFc0F0D7d6L8u0DKdYSavMOHwPPnetjmdE4dyA5ln0O+C/7/2nv3qNuK6k70N2ut/X0HDogihsPxFSRqhgqOBBOEpAPGqLFFY5unsTvc1qQ1iTZEHLlRO4H0YADDe2NMvNFkqFHUZJBO1ERjkgu2ihrjMBdkCOggtCKKAWmMAirn23utmveP+ahZtdf+ziMEzoFdZ9RZa6+9v/WoVTV/8zdrzlkIlQMwF+24XDyANel7MpY9cg3QIwWwNpA2adgAs9EZe/Csz1IxZkZt1oYAoPq41cAsnVjCoxSjemWJVHq1ra+b3HFSAXkh27Q1OkBjLuAsDFnB2VLnLjrJaz/XVaoMmEeNohgB0nSdlG2xC/PQlvnmTGLSTtgE0w6AdoBpE0hWN4DUg7oe1CUB6J5BPTs4U7dA7uZAp2BujmSQoCx7XSkzUifOPzSoX4hOVZDHXYxgXQ+eFaSZk4A5C3sm6CpXkEUgRn+D7P8zUOKUg05oosqn4KPo8t+VjGgFmAvYGFv29dwNqEn6DDXfUZZpOJsDZ9WFmQEi1qix6gpqMmZc/KY34lGPOR6//HMvwh3f/Ib+ogzwONTLEOalY9JNdd1m8QTQSij++hGcQ2XSRdYsC3yhLG7S9qvp2NG26/yFKHNOOiQTPNmRGNbYfRmo3Sfb6jEjAiRj6EDKIQ3OvLgbRK0TlQhb1jWbzdzN1rs5qSw1TRLKtmRrKTbjKiqSC3ZqmTmjm9IdxFVB9LxMHSQbaypmLoaavTIybNn3hXTBvAAnEU5uZQH7v4IStp9gxieCCPJ3n/dO7NjYgXe/+t148HOPrPydqoieyJzNtG1VTcgm0M0sXQGj3R8Dz/juZ+Atz3k7/vGrn8ZP//kLakAMIM36d5PgHH+zCpwNYFXwOHh1XIBZ778Q4VwYptNCvThvx5gpAJ/9hMOWUTUuizbtE1V2flf6UDtqRZD2lQVQ1xXt9OKf/c+44Nzfxl/83XvwXy86ezVINwDtipa17cigngTEOtZ8LMWknSpwlnVtkyXvmY+g+QjaGkDzJHVrUKZM6jjG4AVLkpEhgRcJ0LWdi4OmTTcpMHMBDWGjBtDq/EXKoGkTSDvAaQeQNkFpE9TNFJw7UE9I+myytOcA7pU5dzMg9eAk6UxsZbOkz5yy+qCkEZkUmNVhk6MDYB7FjO7gnJE5y1SWegDLo5GHVZYEPoSONP1tpUDW4BxBugZoWgLpAnn6BeB9mfXHbCfXeF+/GAhIkEQkuSgMctslo5kRFesjAPC8n3o+fuFlvwQAeMMlb8Mv/MRPTo3qiWNh7lqB3v6VnHS2YIguDQlS6VoDs6+XZiZtlHhsM/vpK6jaiVVEMGvyGhVslmvG+J1448vYJ1XQSS0qZV8icIo5W69CQDc+EJnzfAtIY+mEKmTJkjvnhEfs3oVPffQt6LsOz3n2ufina24s7CSbhqnake3rfInndIYNTwFa0YIF6FPoOgLOPQb0GLnDSB1GdPK3TEqYLOm+phXkTgFawjhcv8gWGhSYWZgjlW6bK0eG279xOx5x7CPwL3d8HWleOhoyV7HGBshkgNa7fqEmZN0mFI9rva+KNgN4wzPeiIcf+XA8/Hv/Ax5/9ONx/e3XA2iGJDV/15yjLUtW5zGcLzLKDJ+LLuCJhvFn+FJYfmfGRANI2/SDZVPx5lYwNWCOAG9/bx2lAudQW1arjLEGaBQWzc1+ofz4nde+Dg9+0IPx8v/0q/ivF54TWD2KP8UAzdxAksZW20PlhTt6IYROUWJvMgEpWb4vWT4AA+ZF5+AsWwNockcvy2OPRQYPCRg68EC6T7qwRZJ2dcRhZ/VFE0xgDXGzECq4M9gmQDuAtAPoNgED556Q1KydZpC55z6D+wHcz4GuFweyJMBc9K3gdzIOyMMIokEqBhBLZR6A3AOdgnUaIcvASs0pe0jQSAJAY0AHRsgBpEDrwty4gwGxAXNl/KOgP9ISc3ZnNJOJTEAKAE0BkK2dLYoBcr5wOzIsWMFHwTpcCTf80xf0e8J1n71OCUvUsEl/X4olcYmmcQPqMoQzbL2/wpzJgbkchx5TJ12GhFHZdRSgbXaqmghkICV9Ip3Mp4TKIazIEwNlVWIdkM0nYbnaw6ZxSkHZezm0wXmxJWZts8FG0ySkR//iWf8eRz3oCADAr/zK83H2Sy+UzputEweC49UStaMAKxJGlihkEXKiDMiy3iUKb8QMA3os0GPgDgN1ugiGrE3sK+bwiBGDAnSyGW1xMcks7vg5xOl6N7RZLA0I8FhnwhPPPBHPfdq/xwf/4f3F21b/XBaw5+KzZKDWsGcOWw4OzOYr5R7Z0gT44D99AI996uNw1/wufOFfvuBEcklhtr+Zeo9TYG3YR82xYImeXhEAhbW7zLE2shPoqGUbvbkGZgN/s0VW57MbQ91xzORN4eEZBeRb8Iwh0e6kGBSP6BwWykf/4Qr8xDOfhy/dfFNQMq1ydU73M2xCpIQ5Q+aTtf2MNScUBplGDuA8Ii0S0mIEzRPSfECaJ9CCQHNVAmyhmUUGD72DMw+jzCcPyYGZNZKCc1eUEQ5tC3sXCTIhbpqEgfMGKG2A1LRNqVePdAVmM9fPCOgJ3Hfg3pzGpCMLbmnuZHMAHUdQUlCmhQOzL0idZSUuttVcNL46Zx0cxpxZtqOhXejkDFk+0tLexkeNs3NLPq2JHLzZUpUiAnQA3ciUcyoATSUPOeX6bzhD+kMu3bfkBV9SAQBkXPPZz+GpT3gKjj3uu/CJj35MSUsc2isAWq/gSkAZ2johGAG4gPD0MSCFbZVeVIEZrK9HFadkw8sIkWsiMlbse2NpEhrKnnebki35y5prvAFnwAE65XoM72shZj6wv7wPy5133omjjjoKeOgJku1HX6/EqZm3tDh5PPoRu/EPH78Ufd/hzGf8Eq6/5othvWZdcQqy3cHADibsgG6ZsAMJO5CwyQmb6CRlnCZEsFB4YAOWjn3EBgbMsECPLfSYo8MeJOwhgoaFYg9l7MGIPRiwRQtsYY45SV3QHixoCwPtwUhbGNMWxrQHOc3BaQuc5uBuAU5l0QXqZeEF6jOoz4Bubd5NKtTMp1tlzNVWo1ciOOs6B5XgEKFQgPOw2eH49vw7ThidkNp+IJpVoXrbkMTazGshVE1uaA/NidsFKYujwlSjGTX7aCyVVFImaChO2PZWud52DI+ta5d+dBbIS8+wtB1Qm6QNaA2krXU0EPTwIw7Dd/Z8R+9D72XG0K6oa50KhumKLRIutUGCbT1JVc9my7AljlEdUk5IY480dkhDjzT06BYzpEWPtJghzWe+pcUMZNtFDyx6WXNv6MFDp+Cszl6jgJg4fmn2ryxJRiRsagbCJog3QLQDCYch0WHo6HB06XB0aSf6bif6dDj6fif67jD0s8PQ9xvoZ4RuBq/mJ2Zkm3vWFS4zxrQHY7obI30bA76NBb6FId+FRf4WhvEuLMa7MAx3YVh8C8PiWxgX38a4+Dby/NvIi7vBi7vBiz3AYg+w2AINC9A4l0yD40JXuROw9xBM2FaEeoIKeRX6hk4cak4aVZbEw3hQkB4T6cyAWuOo5BkU73Ct2RKrSL+Xdjfkr8cD2VaVPVfuzUeBbfos65aVKNg2w1fnU6pROD1c8YsgHGfTJJqPtAtL0NwmAHH/E5ksWzm+I/xmI/xtNd8ctAHxntdh6G0W5/XJjVfBcOOiIYJwMqWu2fffqDnbnv3uzPi1W/fgjjvuwIMe9CDsazm0mfO4EFYUBW1g0cwJX/7STXjUI39IF+qWFG8SZqBhE8qUszFblk4+sLDdAQkL7vQ9EcAdMszxoOh3kTkvtM4VnBfosGDCQIQBjIEzRoxi9mZdzs7ntG19WZ2TzlOTw7q0miklqpiIgmImGfLcwJRJPW9RMefIoNnM22bSDjV3tdBw7R6yvXv4joRFAQWEp2oskbiGY7617+JrraqpwnFftwgMuip5xUlRPmeEUa3nd2+e8BAV6HJt/vLfoJzT2TMKU67AGIExowblcjKc+v2n4HWvvQB//OfvxNvf947lNtY5bApMmnTe3Bbisia2VOGu7XOZb05jRhoTOmXO3WJEp8w5zRPSgpDmhLSgKmc9hgwsOvA4AkOHPHQOxnlMSJovm3OHnG2+VtpJ+JI2CHNpS7J3YYqUzrckZdRm1TGvc8uCZuy5R0hbmkDdpmToo1GYMRagPJeaNkCk8MASX21sGV0PjB04dWBbqNxWL8syjiN7thSoHuVhSiiVrmHrq1TuD0nGnOVhyR35/Cd3RUGW/qa8Vi0+Itci/Sa1UGibma1c+ando3NYz4oSmbPEeVvUCruNj8qWCSVRp1mnzAXL+nDRvONQTr5ln7Ar++q5DQrbhin7OeJaavYA0PsLfZ9Vlsf7YHK27SN49NcZgBjoAjB3QdEypcuZs+0fIHO+n4AzUASuvB5WBm3mHUbyuRiO2qXum/l6UGDukLBgXdgCBsyScMDmoKVjmCFGXBVkznkKoAlzJiyIMSBjwKjz0snno2W1lrGqwCiCAYNTWOIyku2+JOQLuhKLAjOTOhCzCC0TxiNJkoYWnMcalLkX4UAqFKIDPLSjmqAB4DsmV5fwJX6cBM+J3+31F9Tsx+2q39uNR21AQTTGQBowtzdkcsfYbZEO9TO5FAYqB7MYa7/KCYxDAzpQMf7qj/8cDzv6GJx28ql4+/veicoUHP82N9cMwt+FVBKztiT6V6coVnN2lhCQbiB0iwDQCsgSNixr4EquehaT9pB1jrkDj11hzGMni1jkBModMo8g7pEVnGVKNlkDKXCasI9ATW6WFYCm6tlcf7WkKpYZzbckTmNpQ51JN4Sp8wZoNBODVgPmXgdCp3UUUOawygvrAgpZ+01M5mL3bR3IgLlk0iNhzxGAp5TjDuI02kHN2kUZqOSfnby1i1PZsu2rXISpEUzF10PQWfuXdHoB6Zgx2zpyKaRSMuYeI33yWhUIfg4onjT2GqeBmcNvXQJWAF0NQwdoaXTX86I+H+6UbLhR+d5AOREHo5rsJ5Ipirh1UPbzPSDBeYDPJ7K9/uQs0p0jAjC72QcpMOYIzgkLM4tDHL4A0g5pnDaaTwiWy6Y4hM0coOeYYQsd5khl5UrKWGDEgBqYM2VkHlE8uTUGGjpCUwfKIWuIKiDEGiPI5KuwpEziedqLY4Ovpdzr1uacw5YHAWQH5lHIiWnxpFub3o8hk7H7VSw6bm2QxNETQY0DXm7HwCsmvgKgp9i6nzeCdHND7hzjT1N96nsZMsNiaICPghpujWLgTAUoHTADcMacr37f4UHJPmd89ZZ/xsOOPkbM2qZAVA8XtCVmdyqv/A9IRoc4TwaByVTAecxIAwk4O3MWUO4WCCtlqkf3QkKPxKStwDwoQ1ZztlQFaQVm4l4NBuYXLIhq+eYrLSas8MXqoFMBcwvScdom1o6cdRPMpB5pdl9QsevEtqxs2SslZc8FIDMEoFnVCoAqS0Xpqo4KiHoGFIARQDl3VMakpb3qDC1ifxOIkqk9ZcosAEyjMn0NZuexaxpL/taAmXQetnZ81A7E4V2wmZSMrhjc2kpbIptrFXjVPLNzeQfdrvocmXXLsqMYqa9nQ8lD1lDiuG2bGK5K2Duyx/eZLuaSfA4Czj2p5NdjPl0BrsRB6zeyr+XQBucsSyBZthsXM0ETdCaNwpojex4h+bENmBNknWYDZjmHSDgDZvMMTK5zmSHGmHPLnjtsIWEOUoDOGGhUsznJGs8GzDSCeVBgdmki1UxTmFrqTrxUxSdJhazJr9FYhAK2OQk1zJnVrM3qsZ1VQJi50C5v1jFQwbKiIwcs5rIvB8K2BWRqvo8gvIph+j4HIGwQPjpVxZupfhtALU5UleENMPADJ52Mf/iLj4CI8OP/5fm4/FMfDswtqNvxITlUB2Hd9zjntvGiZmEAnQEinPycM/BTZz4Pl/39/9S+sKy1FIHQKCqFgDdh4DJyUi7MudOaxoxuGNENhH4Y1c2B0NkS1gbOQwBnY8y583nmPOoUTk4YuQMpc4Y6HGVWRgyJcSbMlNnqxLzOybDn3tVcAZTVzIyKdRoLhfZd79/GrBMJyOoP2bROC1PQe6/N16m8Y61cfQZYw5yscYs/jPSP4sWr34cxFRULuV9a8gkpSAB15pNrO18ME9aUzfzeCUB7ppmuPCcnNYNbIifoMwFEmt/BOkyIGJGYb/J966ll9Jg0ToCrKjbnXIPqlF61+vsC0AXoC1uO4A/fkg8HnwOPAA2IUhWGTFFZPPABPSR9c0+agI5YdT1uXo2Zt1V1eWCC81hatzVRRjBu9s072lizzHQlDA7KNpcs55WVl4XP9gqZESLllXcKzlLFY1scwxboMVdwlrUDssxpk/EDjX2mEZkHZJLkC9odYKOVko7KHJa5U7bsVQE6BfacEjw/RgpgG6awHZDdlDYoOPf1/NfYKtxUW4FjCYS5Jqit6tweiycwEI5m4CmTsCfyAMq8bQ2u1Tm9GjAruILLA9l5tB+84Bk/ga7rAAA/88wX4PKPfxjFYzwI6faB3IvOAJoKKMd5gcoaEJAUDAsHy2D8j7/5K7lul+CUeKptQ/vHEqI8PK5VlDmZDjFP7S5ndCOhGzP6cYTl9u/GUoVlaxjSmGVMRnO2M2WZbx5ZrD8ja+QByzMB0DEq6zMDC1CosuLGArZEJ6cFmAatAZwNm4TsTkYguIOjgqln9jI5kdRkrJWTfk/Nvs/3lpaWWQ6qui6hTOVmQwTt98nGgKFSc8+F8VOZR7dlPRPptESJDiad9qIs1gvqknjOpzLoSRUgcOfKCdQXR6wppdsSqYk6mrJpBLNBZJn3qbufgWSuTNA1Q25Bmt2cHX9vDLqb/Bv5uzjfHLu/9iyV5QhyipwZZ+l8lbvKlBGmN2AOtEmOsy9yJACtSgivwVk/BHDmuouIDC7mJgrgLACdMMAWjuvgDhwQJ4esbloGzjZuzN3DXqOs0NxhcIDuHJwX6ApzRsYCCQMTBgutwqwCZiYdQK42KyjrurWU1cvWhiULKHcMpEToOmXPmdB1XMzcxqIDQLvwUrbsJrUeGEe416hlD7OwnBagKbyGqEVP6E3+99ycZyU4R4eqPLE1ZyoHaGCaUUfAbbbGtG0kRxbNwEW//zqc+fQfx2y2gdf+X7+ti75Sc/8RoPULj0UzYHZkKEpENDf4h8YmLSiq18yFsTtzr0GawsRaIHf6KgLbYNuy9iP2pBxdzuJMmTP6TOhHSXPZZyiAa0z0mDUNbgLy6Osxmyl7VICmLJm1iDuM6vhl95HJg7kASzGhq0+FPKBgkvUvmebg1GN2WI//dnGHO+8kvOn3ULHQuO+OVh2QEwvrRlZfj7B4RQKYeDlCgUTMs8cXIzZo6fvxtQbjjR9rdDbrN5J1Su9bqJpa20kt7uTObkKCIzibY2gCZa1dAo+ydrWHopkEU3AmVnZtc9QaoiUAXRzBWH0AgADMMa4yDNwIzgacsl+bpLsgS22/1lOmwLoG5imdtBUjNsS9r5PcAyAWm2Tv0oYLyjAzptwxMCMuwREIWz0e+U5c1GQsAma/yqENzh6vY9F0arQIXrg2D2LzzeSAK6xZoC0rWw4alv6ugHPWWeCiySW9QlECBKDHAM5DAOfCAbKatIFRPbczjcgwYI4ALV2VQjelnASYEwn4MgkgK0h7hI9a4rpMSB2LPE8qw0cCaRjQ8jyXsmSdcx7VEjbaqImAmvQNUNFC3ToURoiNYx/PEeBXgbO9iwjOK5ZNXmLQlckbtYT0d2y/mehbrm2U39z5zTtw4tOeEpgyCmNOhMr1ltoHDJLetJLolEbNxSrWHOZbUy7XTwRJuA853iXJUlTRiiBx2nlOu3X9allwlvV0JdIh+3oSfVZFMDO6nNTTW8FZTaWyDGNC5hGJE0ZOIKOt6FHMpMX6xVSmiKqJYpqBvfahdjj7NYfhh86Q9vvCjcBll5emXwLnBMnSRyNGGnxUZ8pexVwuwMQoW7lFeSdtt1G1z0Jll4E5HDdg9tjzcJ+y3KU4felKmMgesw2kjsCaaMUYflIW78w5i3WCRrW2aVt5W3IH4t7Zs5sSUio36v1F+5+tQCOxLIiD1nVStmxiFjbFMJfZDjn0K6qAt1tRW4NCOye9zJ5rURLLKgBPCHq7jQOqr2stN1PGHFwGq+Nx9sHFGtc+pftT7gfg3GpuQX0tcIti0g5aJmzmRGGdY6C8gTh7De5Z/mLjq87OnpOYyR2gjUWTYkvSfcaIXsKqlDVndJI1zCbKygQTwOYfrrM5WRcVJ+0UCsidAzSVZS4ZZdpMQdqBLYxRN1+rYBjDNFU7NxYFDRQPnZ1Nv44lYJ/cVu8Yy8w5Lu7QmruXABlFLUY8Fn7j3030MXsocH2+6NktqZ7gnj2VpLVhXouSqkGqeW6lscgoQactOI/wl15Jr6waWQHo8r5E6vhnlajOFFCAuhV6JU5XmQRIQJrFUcaYNgWaWYBZppHc3Ko3SwbMnKt+kqtOUnJCRaBmSHrcRBK+9KUbD9NpIODmr0oMq91K1JFkNoGR0wJjmiPTAiMWGPOATAtkGsAkdixRlrOza8uHL8BcFKeYQ5r001QXrkrUx4L+Jl2HqnlyaEKVuCa3zEUT2ABaY9Tj/DnlDpR6kIKyOL7NYM5vzD0o9+AsAO5z696PUfqfmrJ1MXUINA5ona8iWzZwNi/rOqlIYcU9Wga9GqRXgXHLpFMlxXWIti/E5FL1Bmt1ulEPHYg3MAXQKA5iEPO2nWvxgDRrh+xY8IFRwFiQA3D2LBCsDNogjkWj95Pa73L4Z+5ZxehWa2hhPhuWEMAAumylQmKdATVnZwFkdMgs6QrFu1zDHUzlRwPMoXYgdFlWZumY0CXI0mnMwnBSYdEpEZKlodNea2vXGnMex+KkOiQB6Yg53DSAEUDXoOFNX6mpU6yZaPl8sL8L5NEBeCqJx3YsehVI+4UCm/aL6t/EeAtQ9Sf+UzcJpKa6fbLeurgJDeDSGlhizAigTGMB5jTWDkJe7YXnYCLVkCkFaQMBYc5UzNpUqrAHboSpZrvmrDlYOIBzbsCZFKBJGbOGAFpHgywaMeFGCLNCucgO8zCWJpMVmImAP3kX8E9fmOPurRm+cFOPtDEDU2dWWm9uYcQLjDRHpi2M0EpbyDQXoFa7VtZRWiInNCYbGRz+tSBNzTdVIbhDmIda6T0meycBGcxDu8w/k016StYzdWqziWuTG6nx5MyWooMNoGfAKGlMSfOMU9V3rUsySJVCYguYH2AxYNZvIluW6suJoCwHNJWKM4AZLFtE7M4RtMn3p1TeWu/naqimqXfR9Dp/RbSCNZOCcdhuEPt+j/JqbFjafS1WXHtv5dAGZwPkKpuFhMiboVuOmF4XGbS9tlbPtd/G0KmMHsaci9ZW1AL4+au5bK0G0KOCcwmU6iBG7TJfnRWU3VFDVWpLB0hMcJc1FubckazI0tnYZaBPxYGh4yKznT1rfdaLfhEbO3bgr971//jSxGNS5hwY85SKWpxqilnIp2wjIQwgXgEy1eerXkfASbd8RgBW5nzCrhPwy8/9ZbzhT96Am//55mWP7siSTWMwkHbmHI5NI3Axc8duw4piZq+PwNzWgpT+Titw9ucOZm1nzOahbC9wDBKEaimiAE0RoP3yrI5EBgpmkgyOhUlj4wlIpKZDiosPFBZtKwAlMBKbaZsEdLmEK0Z1Um68AJ0BGzP7q8jeeWp0jY5YxoJlOccR/9+VA9LmJrrNDTBtKLPuUFigLtFKAzLmCsp7MPLdss9byNhCxlwqL7QOYA65B9i8T2zpSJUqumUzfHjnZY95dUkRFaBQY0iV5RYwgPbVw3Tu2Qe8/iHbfL3GNXNWKKQexD0S98h5BuQNYNQlNseZADRJYhWPG8+mmGrVTDbEg7zHqNChBeaMAspJpZqRCOuqBYiXotxiN0YN1MVBbJpNR7U3SnXT7a14l0ARCwh/l+KwIq6BWfc3dH8jHDeA9uGm731+YMT5EAdnNReI+Jz6vxawtrJUkbDCoUspei8rNIdcXbAFIU1PbTtAIXl1Or2xqkb0kn6fQrWYbBPe0l0iMBeAto4akr8zSSchKgBNhJ7ZQdrnnRPwjBe9GC+/+C0AgJ07jsCf/9HFnq9gkARPjgmtObsFZiOnMTGJM+W2bgfMy1pPzZwb8/bVb70aRxx+BM569ll42OkPmwbnqr9EMNadOELBBbDjy4337vZ7KgAdmUeKYiWIGgpb/71J5fjsOYBzeAFkrBlFghiDDiG6csnAoKP0CsoWBe2JsjoXaR9LOl0il6MlIeishk34MtqAlsTi22EpdT1sp3qZU4ZFS+ahnSKYY0yfyto+spzjANACTDvAtIFEMyTqkb3jAlCzdIYs0eqsGXsw4ju63SMgzQbSCzCL+2bmAZllsQtbhQqVaZ4dqGt1PTyZgTJKHGwF0FFnS1BmLACdEiF3hLEjAWdXzELfY+176qntnSELMFOeCTCnWHsHaCRN76kWCTNrUwRmt93Z/avlpJFknXLn5aUfSRU8Cl7PcT9WwjJIL7Pmqc9RxY7DN6jbSODqe9jQCs3bGCsKQLeArSw6vhq7lwcmOK8yVnDkQOxiw8BazM9ChciNHoYApgeWJJodhO2Wl1+Aue0ELY4US6uBdSSAhLLgRTS9k7OxEr+oQpNLWIIBs80BivZGZS4k6zEdw+4kpgrxYbMd3mSHb+zA5sJy9xaCNmXOdjC2fdQgnVBA2Tp9BGDLjOSGAduPI8j+blXDKkCnJMK3S10Nykvsuekz5rlT9SWq90twZM3iI/UBwQPAk4oJj+MxxOzgbraph7Nrk8YxY4G9nJY1p6H+rc85s04E2xbFdOIALd9Fy7oIX+1dPAXMscItNFOMpmN9tayAxEURLv3XZv4IEsKzbCJe0qXaV6eAYYozk6zsJuA8B9OWsuaZMEbqRAEhqFOX2cEWwp55jow9GPhuYdBeFaDzHJnnyFlAmnVVKls60gBanjl0ODYmHbt0mA6LwIxCgKtovDDmzMtcug2pYyY1f1ic8GQ6rAt9USeu0ww5aeJxUnCWZOsARW5qzS2sWSSXmL594QiXVLZ4bqegPMKM2ssLVZQVpQpAR4eqAtITqu0kQE8dnwJnp2Nkc9BitwEVIoHmnfRNdYasCUhqcC6y1vPc6DVnkbbvRzn0wZl9rxWtPqgjMAPFQUC63vLcUfLhby+x9UIsAy7+nV07h20N0LGWROzGtouurU/iAK1qBAvbEZM23NW/mhuBroFApJURrWD2d4mBK97yJhxx+BGYHXYY/up3fhsbVIOzE7uGMcdQXZMNlR8JFeyr2HME4JY1TzHn8JqXAFrB+dQXn4qzf/ZsvO6PX7c9a57qO6452G9jLwrXtp85wzZQJgVkfQjPeqF0J+aO9KrAHVY0KgJWUc6C0kmdv0iBmYYiPQj6MjlIJ+sMDFn8hFy6CTCTzj/Li5H3pSbKrFYZqzBjdEL0b3BTN2rG0llIlLaj82g22xQBOpLqURahOb4XuPAsJ9bMYCQ5AUDCgpnmYNqBTBtItAEycLa79FccwXmBEXNk3sLIe7Tejcx3y35WgOa5AHMu4IwA0LaeM6C5p22BCKBSt9uu7uCirz5YqCujDMJKVDmR6oFUqjNn8mQiQKdWigLMnGYgmiGlGbKtCkIbTd+0QW+dP8ucs88jleDRYsqObFlAWmJVBKB7JNgazGUdZjTMGZj55/p4N7FdNQ9dg3MZ/FF0mN1GQuK4DGmUdm/B2ZhxT6LztmC8BM5kZm05b/eABeclKQ6YJD3iiCNw2qmn4vLLP+THrFh7GfgafBeoLfMoJlIiKEeng3L1aBAvAC/VuILNTXODI8vGPcCEXRGkHtZKkDlnBPaMwqBnkMWJYgeqlG2Wjvih330dOAGbBsxZncACMFegHJizJboyvIjm7ShgbFrV9/Ucdm43460CZ3u1reYzAp+9/rN4yXkvCZ7a1Wuuu4RtqfkNVhxrr195VYeHKnZI1WSCKHHBp/N8SRNCdArQnQK8S22GZpBRcI7AHO6/+j0UmLsC0g7KuZrytpdVHkUFLi3XFLcRoA322Cw4RSCWFmLPWwwWQSq/sNFRwDmD0amgLAKTPWwJNpLUzMoKzJkWILLY5y0QbSDThrJmi+/V61poFI0why+ZW55jdIC+G5n3IPs2sOcKoHUtZ5bkHIgmbihz9uevX5ltI5AssT5C0HQByTpGOt7K+6nC92xrdvBqFRANpaIZ1IUJWZYvUwVyFu5CL6rzzTYRZzZGuX9hzCUuZYQZsQsoT7HlFpijHz4H7+faP387Bt0y7ALOZcLSexAFEUIFoG04GzCbstSlwpINmPvDduCof3cGFh+9TBwj7TjVleycMBm+/+UQB2cgSlT2FyID/Ku33IwjjjgCf/+Jv8fp/+4MLAM06V9FSC4gHQxxQfjE9HBcVfZrR4OdeXyncBwTBr34LBV/LgOdglxmFKcF3e+5uPcbMG9AmHTFnqkGT8vdkVlWVkwZSyEoTPDcGZ59Uq9vAG1ZkKyTTwEz1w26ehsbIL7q1iRRT18ug3OLp6bP+fEJtjx1uPVu21bsqmC0RYXD/B46qwrQXQpaE4dqntkKzEQ4+3k/hf/9ra/jTz/2NzLiLfGIZQtLjOIMxkXCKMMmXyxenkfuvnChwphDWlgUHwcRNG1CiVhLv5XmKyyyjBg7uqzIdlSPQBGoDDPzczDzC2MWcGbaAqVNkLJmWAhRmNe3c2ZkMBt7Ls5hmbeULe/BmAWgZbuFnLfA2Rj0IGs5u2l7DADNiEsqOpsGUNbLLm215GiPMnbarijmWAqzKuXtxTlnNstNSSeGaMHJNEPSxC6sYC1bM69E7VXBmYbGCUxAmRSU5V/ybV+xZirEoQLp5XnmWTg2C8drMzctHZsybUcZLUqfkaKiABpAt/H/Ds7EBXh1e+LnbkZ/9EOx9bnP4n//6JNFpup3tvWpCev2D0zm3JZovCbs3LkTAHDC95zg39USV5hsiwWtCcS2RRxbx43XbQF+yrUMqnOaSDJOHSlhURaKKJPBnJjrAHmzaEZgJjNr+7K+mIFkXofraaqimSvYcrCw6oNzLmBstTNg1s9OyKgIkmjirkDawGGKPUfwngJobmputlNseApH47xG9MJeKuHGgbAfby48UMxdnAJAGyj3yp57+9yAcwexgSUGujDXnAgXvPAsvPYnXwhmxpwW+ItP/78opm8D6gjSysZDSFWc2zZnMF9qFKkCY4lJ1oVU/JiCsukPULlmySdMeHM7f2yfDJSnwdnHaDRh69iJ4MzqAAY1aRNtAbQBSsIEJauYvQsFZ4pqc2DPvBD2rCZuqXscqHPeAw7MGTr3DAVo8jhERnQMq03aHCxeAaB5AlgC25YBo92UfdVkT9sLfTdmciqpODuUzEIS1wyNcyaeIfMM4A0wbyBbiBV6yRZWDbhc+gXDn6UOFC2uXx1q5twy5imHr5pBs8qqqd8aINd+D1Pz060IaSkUw9Y6Y5V/pGOiLAuZEiQKJnHRcRPQPfjBAIDZI79bdGw9nvQ3DsyxHmAWkvsBOC8zHxMD577yVfj5F70Q5/7aq/xXqywMUUansE9ogXnqarYt4iYasgWYqeok8fvlmei6O1UDnXWwk2rfsJRy7GnknD3DwJm9wxuoV8zZwBnFUgZCyWzUgPOIAsxjBGcUsPboogjM4ZoV2WxZ8+rGjk1dwLUtU4AcX3QE5gRMOn5NXdcxuX04A4EpYO4aQJ7Jft8DMwXnPtUvp8vyd8nmmAmH7zxcL004/IjDgR0dYhw0uXNZgs9de+YZYc0FmOVhnDG7kC+rGhkAxJo4sie7jAGzCm5zhOLohaEjg8UJqAXoGpz1n2XlUgUkq2e2mbQ5aa5tmoPNwUlZs1grCnPm0P8YmgUMg64At3CAFuevANJ5C+zbOZjngM87jxL7q+ZtH79u0g6suemKlTmbg5JtAK7trJoKqnXnuQZnN1s5MAeAtly8BtBNzeiRWNkzzJ/aHFLNCpCckJADs0Bk8ce2vWUHsBlq5lzX4rU9Zc5eZsjTwFzM5XW6Tx/CFKQzUWHPZHYdY84kAB3AttfaJTF03frrL8NDfuFluPP//m9iDEt1XZJjJnMOoNwPwBlYJVHf8IbfxRve8Ab9pg6wir81ELbafp7iS9Bz2RmWZ6wjMx6DMCL9jS15UTJokM9Kl8+lBi1cQdpYszuEVeyZHZQto02PYu004RrH+AAV3NoArQnbQNmqgzRqBh0dmo1BG0t2kLb9hjFHJl01eHy13GzR/G4KlONvTP+J+3a+eM64H9Vhah7QVG3fpmC2ttoDMwPlWQHnPgEzs51xAefOwqbkeq983zuwhTlu//Y38M6rLg/grGtWVkkkJLbW0sEVBzCd+GGD5sCSs21TfcyqgwJKpBcXEErBGcq9Krw92duSNfSqBWgfO54q0y4ijJkQwVlZc1qAzbEp9WDzPE7qfZyMNUvnkb7OyBqnnCFAGxl05oUw5azOYFlA2cza4AUQncJQ5p3J2LOZtIHSJmTKC+oV41BbwaIRxHR2VheErJXM5Ti6dVvVHKUW71zy8QogU0hEYiyaNWOYeXubU59cnFCIQV4C5fivMOfWjL0KeJfnnmMqTAulmmLMy5/rY65QkMlbKBiz+8WIwyErc2adupdx0iXVqxOhS+wzUN/6H2/F1nveilkCNmZFH1/KBRHl0AOXOcdSWHTLpyNzjgRpuRiI1/+wtF11/RIiggmALupBBGaZv2GPhC7+3S0wl9xJumX2Jcu8U3OIwwtMuodggAkFK5aOWvtoBcy2qqGBs5mzTTEwtq3yXzDRWUrNoHWsL4NxM39Aak5f6uTbFfs+Phg33xsYtwBdmzSmATpev2XOnl+7Begkpuu+UyBWgLa6YccpZDFgAWYzd7u9OOPVl70LwAI4zETQiJJeLTSoNqLpECWZRGhI9fIjcyawxRJykrzro30OAG1O5A7QkSFmF+Al6UuW1+H5CKSfMhqADnPNxpqrkCkza2NUgNaVqWgh86VpCyBJqMEGzLZ2sb4j748ofiBm3mYeJNmIs+iFMuWFe2uD52LWzoOCc2DOhqAhnEqAutAAz6ZlY8Qqh5rLrIa1s5HynAlpJIw+NRFM2sGszRZ3NYbqyfI7UO6BLCCdFbANnDN3IFbKwSK/pLeYHDLobWG5Tc8ZHVUjMBuTroG5A08AdZxbNmYcAXgq9l5+L8eKB1J587VcKlVMiWZdSknXIlCA9s9qEIt5har9VQA94IDK/QycgX0DaJoAaPLj5PtTwFx+H19+1P6BaNoeYYBftgWcKST0pCYX5RSDrjPw2MIEYtaW9UW1smqiAaSjmcifg8t8s5ufuTZhm+NXvdh4bc5uTdstubRzOwHlci0HZEYxOcctNbV+bcsA21yj2m8Ugea1lY4St/Gi5ukRH7BaiCI1tasBeiNsN3phzRtJwZnlRXWkAB2ktjvsKFNu10iEgW2025Pvew+Mc8i6SAWNEzXbdgKcHaBZlorURS8khSfpPViT5rr9UMzdBSyDN3UcO1TmmplGJAVmUlAWL2RdCCPpQjG6GAaSpfmMWcW4VDZwHiuQZmXRHGseAN2HzjcTm1OYhFJRnG925hz2qTBpD2WPwMz1604+fyQD0JXYBHfcgyXAScvM2dL80dj5GtvIPWjsAVsUI/eg3CFnXaJWQzHYrR2kz2NZGiyFcPHZT1zAOIJkMTdHkF7NmFszdcuGQ1b25jPCtePSkkCVmY1CfyN28oFAFEy3pY4dkC2oInUE6rk4wOsWcXrfANoErJ13Dc7TZRmgIzC3Ut800ALGtm+sl/x3q65WhEsEZzme/DcWO8gKzgWY688llKHKIRZqmWvxMFcKA4HZGfMs/CZiViSpNs+cWUD5lJ/+WfzgfzoLf/LaX8f/uu7aCpgNqCN7rsKqbKsYVs05B9ZKST8a2Uj6lTWXvSo0+63mVV7BNAiv2k7VeM62uKaBwJpVcymunqhcPWdWOwHjTd1u6NYz6TNKmiGT1KlWyy2eTWPbyGLcLAA9Vm8TVSV9vjIy5STCOm4HPT4oix4hjNoBmh2UibOCdMmNBzWBl5z/7oKDTm+qNO+ECYMKa+4oK/BmEA3qiT2IdEwLB+WcJA0lJ81Rr7mnfYlHMmWABfBZGTSPHiKVPdHI4GBcYptlSyHOmeKcc5WIpPQf0r4dHzdmx/TU6RkeRZd0rohG0gg9CaeKjJkVnM06YNYQs4RIqj8F6UHqOBYGLatXGUB3IM+JDrBbP8o60bY0bcxQWHL9w49Nzw1Tta0TjkSwbkGXqv14namIgTLnXHJTuFymeiolKUj7NJqaMsiZMklegL4BZPOvC9WME52B9Bqc961MM2iq9mvXDXut0u3sNROqPD/hrO3ZDaCV5Wiqk+IZYN9FIG6XWqqTflIF0JFB52LiRmHSHdhlvFlLexRAdWFhQIyCV8rT0DPwkkv+FJQSHnnik/HS4x9eMo2hALEq9xWDjvPO0TPczOex2Vw0R92lZcIIfxPr1Mu2bQTfjAMHZ44XjrtU7PkRlC2DQZtmSLLlKygTsKmseVOP+zwEh3MleBwrUgFdZb0YCa07vcxJJn2+4qQFhgM5mSl77ASgB2VTg+4PBaDTSGrqJgHpzKEGYFawsvjm8urYvcJrjcfGCoxnKqvROGhKsMxeCR0kN3aHTCOIhiItU6cA3SGTArOy5uysGQ1AqxsaW55sy509ImYCY2fIxZzNwaTtrNnM2GHOWUDalA2TKDUwV0Ct88lVytyo2EJYs/RdklSbISk3R0uKseYAzDSWOtr3iioC0AbOrODMcCdBFMdB2S9UxaTjdsBpAFvmj8viF6vmlM1UXsXWB2Ug2jOLKdtkUMlN4d7/2tiyLGjQXxuApsQgBebUC2MuDIfN8V1AeSbT+Tatb/6gFUwc4MoXDwhwNv1J9uLnZVbc5vIpLLoG6WWABrwDVGhgS2231G6Ere5c12WgjuBcM+hi4g5r+Ph+6zQmZKwseWmy0vaZa3BOAIb5HLMdO/Ct228vZjegyk625BjG8n309l4ycZeXUbUOUSXPavJa606rQboF2r0x5302bzf3He8nSiEbyD6gAzDbdtMqCjhvQOLfqoUNtLH92QycUXS86BCg1f+J1wssC5iAdzRbGyh3oKF3YE4RoAcDaGhlqQ7Oo4JzcmYFBWlWZzEGRFGo3mr06K6gPABoYc2SrrND0q2A88KBuaxWFbcGzCGbAcl9lRSiuhCH5862JCNli2DGJgVxcrYsW1Ywtm0wGyz3Ievj0QeC5H1aGnWfAkoEIhn9CXAlrDNNNwVyEX0INN2fKVwYApMeE8bcyfdZFtwpq4mxZj0rA6wAMyoJ6bfI7BIzbut5Ymx7bBncSybv1f+WRUFpjeCgSCWzhKx/rZ91moOCd550LQFo9CyZ9tR5h2cEnrGAsgGzbsdgo7eZBlqD86pCzX6ZV25fYw3Sq1YLrQ0me0eHCM7ZvyM/PoCwACsoR7AuZu0By0toFEex6CT2mx9+P55wxg/jhis+jjc/7Vml80dARRhUZrlSQHQWjLJ/weNPwOPPfC4++o63i8OKAX1gzx1KjHSnAO9OYVMArabmlimbGTSK7yr0aqrG5q/l/mqAngLlFqAxsR+7UulCRVJ1Ta089HR/o6mboZbYtzqGxK6xrPcJGA8ABvLkIi6kufR0+0yZRCCPXQ3MY+8AnRZyLA0JyQGayoqVIwSUR1Zg7mTbeHWDo7rK2kjaIahu5MBtUJzEZJtovfZTAAAzP0lEQVRVoFr+ZmHOcZnDeilJW06SKbpT6pUI4VrGnnOoNo8c82ePQLaMYMqWFdBtW7HkCpTNEYndT86VgyxKg79TA2mbCaPyOgEZx1nfYfI4RhtQccqjAWcFaAzlfYt5W5S0MTgDZvNtM7M5Q60eUzpxycHQgmLNZLkZthSOFYZdnLzK7DY5QNcwDdTgXJfyxslj0kj2dU1uF4DEoJSdQccbpZjdqRdQ5hmQNwhpxsgbcJAeQ3A22zy1ds+8tXSD+1Tuh+C8/KrawljWuawb0VJXaiXusq5XI0QrQVvkMJO3mLMZC1DDnGlpHtpM4DV7buegH//DTwUR4YQfOrUaMCX8yhVxFNsBVIja8QDmAL711X/GJ//oj8CrWoFDpjAWpb6zJzVgRo1xKYtyH7Iz+neOry3wta+jbfp2lO4jOJ/02JPwE6f/BH7nHa/Hd+7+zvLf+Y231Cdel7GUUcJNYQbMXEzWG7rdzMqiWQE6fDdjeBCs2T2Njdk8xADQwNNd0MwYAGz+NwprVKDcI40d0tAjDT1o0QtzXiQFaVI2XZhzGhlJWXPKY8Wa3WQLgNREypxklMV58LBrArMAJ6mBgNGRrG6VKIPIRPdYg5KxZBRHsAw1ayOIa1MYuK3KfuOKU7ksblEBM2ewzrezhlBxWDJSuoueV5/NxwLDj7sVPOpSI5ztWzx66c/Stu4sFubUfaCoPwKphQTRh8D8CEIdx+RTIaJcSfeyuWf4e4zVnN2iHGkB2u6o/Wz2yZgO1I7bNgLxsjE7yuzl/BHWj8z+UhImw2wPZq7QBD4S2pmLw10zjm0JbM3dAt4A8gZAuh1NoVZTt6U3sBTIwwGi7P0QnNtCzX7dhQpI10YZCgjQ6n2GDrGzlC4I1IgQ6RxQvLDNbG2gPAeWgLqYueOaVmXJjDoO+m9/5414+stegr//o7dVdxVbwcDYxr3JSMcYe0rSbXuMG5WFCluO1f6mxbkEVMvFVqgdPjpjVmLA1UWxDNCpedApkG2AuU89rvrTq9B1Hf7D01+A7//575/+uyWADhILARzN7t9bzWGbZXka29/IYQ4agT2zfGe/63LR9qGSMzMwcHkZUcPyuQXRtJw1mzl7jPPLAswG0FbToldQ7pRFJ6RBQnnSyIU55yzAnEekPIijULb5SGsvY6i2QJ+MiTLuam5dghBlBFrkv4y2LGyKyEG6jvWlAtAmuLmI5mIuN/CEgm8EaK4AuVDJrPOwBtRcgNnun8u2uk7sSpFBm66VyyvLJAqQPAdpl1ZZxfpuR8icaJK851UMvseoNw5/Q2Pmjl75OWH01WygbVDuD03GM/idhYQr4Xj9m2X9uZW6NReuXcxQ7Uc+Pg3ORbkzEsSowww0IZSb8XI4NQtzMO9rdQTjHsCMwRuEvMGgTYA2CLTJAswK2Kw5cKyaYWcNzktlCpSXjxcwngLp6J6wjApcfW7pW0QEhGMarznJmqdAeUBcBToCdNst/+zV5+GvXv2b2IGMHUEhoOr64bMKUSMz1QDi0BpUWHKFj1SOteC8CuPYzk11S8WLV57dLWOuUwZNM+jyqPVraAA6dQmk87k7DztcQHISmBluAjAQdA1HHygGq/ZN7cL+bCxJR2IidDdzs4D4bAT6EcV1dyyAMeoxi8kxaa9zwgjv07yzSc2gLpQX0VHIgHkWmLOyZzdvk5i2ByhzzkijzjcrMBvzstjnAmS6RKSHeeXq1ZilxZwabZTIr2vuRAbQyEGIm7AW1sixQkzBHJrJ2atv5V5ZKCM4Z6WPGQjPAWXLAbVEdbBzRWAO1/PxwE0+wKBrGUDHbmytVfowOYrTSJqRqoAzQQYMWVVv7+KRT2U7UPBRsHMXpTmH+7frxyQz5pkfnzDKoxagY6FmL0Jza/yOsrjEp5B628jd1EM73AdF8mLfymS+peyMTmEyptQ7XufuBKBJmbMANG8w8iZAYTqKDaR1/tljohOw6CYaYR/K/Qycp7rC1PfLuhwvdYqapvESbYvIEBEilgjOjMJ4W9Y8Bcytc9gY6r5AYbmHeCTuO6ePP58AarPYeqtQsdz6XVAQOITajGfXpfpSQG34twsvzf9oR+fgcFEl0p2aXYjPFZsoNNk8z/H833o+fub0n8H/+Ye/IQOttcWHuuvoY3HVJZ9E3/U49SXPwhe++hWo1ILHwViGLwflsdSYXMRTIjE8fad5a28oOHcj0A1A0vdvc58Wd2MOSeo5bfkfXV7b3K96b5OG1jgo2xxzAGQHaGPRAZyFOQMpM2g0k7aYs1PWJU3VAQzMQSCKs5jAqr1xNZuSAXTNd5bnJANIazw1YNqbzY9GYIZsswhbY6j+arWzCu6y7hekZJs+sPbVZ+IIzqqEGNAjAjNQ7S8n6pX7MV0qwdZ+gjtMCjCbwkP+yqHLRf7QmT+Js15zEb7yv67Hb/3n/8MHAUVLSeX8J8AM9bzHSO4kuCxS5Lkyl0FTQDkOjDK4oo2gyJtWuLQychmY4yy0bWPqpRKnUmDX2nEMntnsU38lbwQbW6ZR5QxN+LTkStBxLyBtpu1sC3ptkk9Jmbk7SbI699wmMVYcULmfgXNbWvZs27a2ZpPoO7jKy0c+p9Tjllt/C8ccczjO+62P4oILPqXXaYEypuZczZp50mt7RA3QReiVjhj/YWK/aOK2PjWaO7QD3jI0ZcxvGHQL1KQyLQK0XSd8bt+A7cj8j1zINNjKpN0CdLyxKfY8JUfC9gNXfQAfuPIDcuHNib8JN//K//gKHHfMLgDAa3/xXLz4wrMLSBrl6HKpDsgBaGvXeZQEvtSYwzPQD/I3pO/dwJlCVqpsLDrcQwyqNUY7UplvtvnHwJ7FlB0AeizsOVlI1QB1CJP55uTCvzDmZKCsjNm9m5EUmttszWX6w7z8Ywx/FSPBJsYVxJiwNGmrHcyBme0nIZzKwDQDPLIaJVqADpXLcQrAbABG2tmcjQNuzo4j1ZVXFKdLmUMuGR4p9l3dJjM3x5VmCHj+f/k17Dj8cDz2pO/Dwx9+PP75S7cEh7yEbA56AYRpNEWN3EQ+reMLMCe3LISBE3KJFwuCqSCt1FlWyOVzHKjRAbekEomEqA4WTQF23QPB3wNgUyni4U/q5kruozDIPUxCAcuqbsH7tUpJPmPx2N4Qh7DWodPM2zFz2LA3zriiHCCmH0oldoJVwLwM0JExh7xboYPI/hOesAsPe9hOEBFe9B9Paq7X0jXx0F7FnHmFaTsCc4nJrId9q7cuaekraotBVcupnI/zzkuqiuKJ4yaj5PBuWrOa2rGWUpZnAB19W2q6jioBwNLqHtH7ecoTehPAjmY7tW91k5sKvO1Dl+DurT3YWszx5g/+ce28Ncs6pzxOALOy37SQ2i3Kvtd5/b3XQbYG1HbONIJSMHu3k/hc9AbpeuTmTAHmANCLDrTovaahR1rMpA4zZdMz0NjUPEPKM6TcSzILlpWNiONqvmpiVcN04mKgXjZ6lMiD5EAfkp2YQmKJP9RJy5ZvhC7nyHkERt0fB9kfF7qVz7ZvS0DK/giMIziPYNvmUczcYR6adf6ZA0CXueWyL7jOjvGjATOHmsV9YND9cYyVZKuLYGVL7b0gYEH42J9fipwzvn7LLfjaP92ENCd0i1gT+gWhH6TOBkI/knSlkcSgE3TJLotVxNpecoEH0zAX83DUcGsZ1C6GG+EaaOeLCzBHMC6LSYqcnYGxAcYGstdNr2NTB2zUlWYYaYYBM4zUY6QZMvVaJTY+UxLnupQkeU1HYM9dUOQOu4nb2DKJg9hmqeMmMO4IdRMHVO6nzHlKVWlZ9CrmPGW+Xl2vufZ2XHHFjTjppF149as/gnqWxXTEAs4x+UgN0uUzV/slB3dcJKNeMbpsLSdZrv6yDIGoNsQ7bYG6baXKEUytsvZUPQJbRsOYjUlQmVu074wxLaX2DK/D1o3nSiPAcrhRF/62fQV7Yc9LNz2ltWTG9bddj8N/8qGQBCCdZPeCMglbhCIloZe+llxZWaogkdKlpHYvSnVDu/OKsuSk/SNpv8hKYaOjS7xpZv8opyEl36SsOQD0IgX2HOef1VFs7JDGkoxEmHPGT1/4k0gEvP+V7/Y5ZspZ6YV4b5fUorZVEyZTszLWstHDXl5cBQvKzr0TualGtmz7I0l/GaVz+Wuk0CVY8Bwjg4d6KwPImDOcUZOawSk7PQ7mbFTMWYz3JXmpSwDGkvShHKxHoct1cGIKZtJ11sl94P76D96Mv37T2wBsIGHDAc9WEMsMjMae23VfA/EtU+qSqz86xlH4EZtyZGDMLTDHqYliOYj0xADaJGMbGbMM0F0Aavk+e006FVCkGptyR6Py6xiOOlR9zu4gyh5yRhKAOQA0xbzI5smt3trmwU2ycqkz55xxQOV+BM7b2Q5WMec0sd0OqCN1K8fPOOOd4dgyOjAY9YIWBaBL+s5lxtyCtDHnjLIUZfkUOXVcUkPOUu6KHRitFVrciq0WW8Ucv8w7u6cG4zjITBTAjt+lcD1WzLL9uCDG0oV9cKDMPbevYrup/1Xg3B6fqu1DmreMTWIiFYC29E62yGsEZkJguNG4GQxYYY5vtTKnSTHM1O0sMjuokIJU6QjmzCWsyxJSVCxaPbRL7HOpaUz+eD9+zrPwI790BgBgz9e/jf/539+r99BBMoR1K4DZnpPgKa+0SbzDGdCDAxBDgTm+E+lQ7HZi0uaQOWYMKIlHDOAonM7AaQQwsDeng3O1ZZ1FkHb11Ja6tWQr8dbMSSzr89nbdGtRVDqg95IgSob2WWYZa8jQpBYC0LLCWDE5CbCTNp+cVe5BQHmMSmfoywbInJXtZ4A5qyk76yImRcLUrNlAuaYG7ZF2aNWL4sYsDVNzV2UxydZymdFh1PlpmxKQcxajtwGzLNYxlJzk9g5Crc2ErMd1P5EkJdFbtOxhJo8QkpSYUxhm8FzbvE7f2ZZWF5/a7i8w74tTWESH0iXLfHNcfapmyzTBnj2toMNuBOYalI0pD96FocDMVXpX08pbJh0HUduKsVV6FNmUEQB44jx7wz0GPGGJa7BBri+FUbXAPJt4FS0F2xvoLtUoyeNDMnxS3QGa4fOeJrTSWANz1fVMKgYAK5Ohel8ZJYRHzLWgAci6b9mqsm1H/xsyYHZsF9AiTVQisdFq3l5oDZnA4Dm1zcPXkpVYLCzwza/eKXOtRLjz5js8dMeehzmEGbp3X2mE2MesqWMJuAeAC7hGgDHtLysgd6xMmGp9wOagjcIGbZS1jXhgH4q+HwHa21TuxfbtRiOYmte2X05B2B2W7JjdR3xu/SMGAJKZUtNaOTxDSvL4krlTHkohp1gYHKCbvq4KJjMj6/PkLKuJCS7Jvsd7Q6cOYJ/LfvF5KfIoMuflFestlC2GQbUrBCzPXXEwlRlIZ/UHGvWlMsidCgswjw7MltBEwvCCXCNJVJIsIYnVxKCUkBJrMhHy1JypY12unWQxDAdpBMCGzFd3WGcI27eyikG34NzOlu6t7isqRKk5IK5KFUGZVTq0wJxhq+hE7sxLvzTYN9cKCvdjwMzN07d3GlsstkQrH/v2bxW/bNso636uauUq3Tp7JlROYZgybS/75tWGi+3Y81QFGlAOnwMQlG3WB9QtkwClaRiWb7tqZDP7KjjnhLIeJ9VMLYZQkaIr6wSkT0Tq5KSBuU9kItQCNqTAjIGARdhXoIbNSS+tUEXiTKYv9NPvvhLzr38bHTE+//6r0WVTMCT9I4GcwVktYS/FESwz1TMJ1vzu9RzMxs70UPZH7RMjy3MkAVcBe/PYZl9+NOpAdlF2HVnZs/tfGjDL+XmEmLO1M4uiYADdsOegt7UAbWMKE/veDXVwMBfdrYsDNheFlsKZDKbFtA0PiWoHqAFzx4zMWSxhTArOwpizzTVr7nHVfCDAHKfWRAqlBqSX+XUB6HZ1eiCGpZZ5KwqVvRYGLQuPxv5lZ7R1CIw1W76xSMfktwj3Lg5j1ksNyEnydPtWZJNl//Ic6ElklG/begDlfgjOrVRuj60C5imAjh5Jq4B6O9Zs29hVo+RsgbmsQlUbpqPBujZn12n7C2sud1Or5y1Q7g2gW9WlC+eYwrAlJd1qAGo7l+PgCoCeNGho558Mq9rOtG2vgpv99rPvx4cyQCY1cdo2C6hOAnS8j0D7OEOy5CeJsRhTAebBniHDTd9ZnL8qb+1xBAarOVQuYKwxydC45Ag6uhxyYNEowDxQWeTCvXubkBsmXPvXn0fHI7pcwpek/eJWXkJjndbTxLxN1l+4DsVTwDPHqgqYtWJUAEsMHgpaMcJFNXY19gnLuGntxSPCjBLXQ9QYehbWbObt+FDumdw+Ky93ResSNuiibhiNDa5INOLKF6FCGDtedTrAzseh/ykwJ47ALAw7eciWLmACXcTEATrKLWl4W3KTJix5U8xZbidmbKsHuDgQysAmZ8syoUshr20N0EXKFdYeWXMHW+LS5Q7gTNnvSF8ogUGUkMjkKKGrANrYNinLNnAmYd5R/ug2tR1gH8v9EJxXlZZOTYH0FGhPsemp4y3MWSlqepm3GVdUY8yrTdptx9eVaNFBOHe5M156YkZhuvGuw0yg/65tIXvS+P3UU7bgHFWSCO5Jt36NKHR0Gzs4TzV9a+7ezogxdeOrHiQ+UJw4r9xtbZtVXlED0HYPoWWM4eaxALMzWdJ7N6GhNDGb45eBcxZwXozAIgOLDFpkYMECKo2TP7nJVr/3fUzXVgbbywsv1IEz7od2MzwAyvHYNwSAy7pt0pwq/ql4N5fKJeTYYpMdlLXJiTQfd+iLBuIhPMBfNQdwt+et2o6b9uC6Q9szN2hsXSb2KQNj65KjHQxts3LbgHO0NBFc/wlPrd1HbzBVwKxzsRyrMmaQeMdr6BtZo3Ato5jrztFOtU2ZtEvXsfnmwpxtEMfVmhN6EGZIWgkbWg2so4NYUp4Lv7aZtDMGJCxgaWvKa+JwNzWnt7iCrqltPvA6x2QUIMvlQME57f0npZx//vlO9a3u2rXLv2dmnH/++di9ezcOO+wwnHHGGbjuuuuqc2xtbeEVr3gFjjnmGOzcuRPPe97zcPPNNx/Y3XvZ7umn9NbtQHoVCqwC6UiRKJwTmJD0cNNQAOkpj+x6JjlP/DO9tYZzM4ovB2ctB2pFWRSHXCNbtsXDVXXbCQAKrRcFDorgmdKVaNXr2W4WYir8qg3DigtPeJ5rNKFWrLmvoRm9uA6l6jMsxKmsDqEKFy9KHefAuACGBTDMpS60zreA+RzYmgNbi7KdL/TzULbzsdRFrsAaFVhz2W9ZYTSjtzUzeJQKZYvFcajsZ6swgslha718oocbIDe3Y2nDR2atptPo+Uy/UYC2aXdW5YMHBi/Cc2vlOYPnAObQLUu138zZFRhesK4Qqc8fgNnXuAgptLitNobszxhhtAeredDxhrZmeJjVmEMdZWtuBjGSrCgR3Czrybqsp8WnawIZX+IzVMRt9IMxYK7lUjvfHBk0B0lXgDGGUZUBXWBQWHNC7+Cc1Bs9YVNBugxQxg6w5kS0OmIHSljVJkZsaJ1hxAwZM2TuwSwAD8ha1vavQ0LHdieEngkzqwjRkzb025o1vFRrn3FAZb+Z8xOf+ER86EMf8s9dVwzqr3vd6/D6178e73jHO/C4xz0OF1xwAZ7xjGfg+uuvx5FHHgkAOOecc/CBD3wAl156KR760Ifi3HPPxZlnnokrr7yyOte/Tdkf5jxl6m6PtcDcgrLtF92xHqaWyrOILZowY0+bs8tykSNq1jyVU5ubmrG9Ud4U+/h56u3E87VPGatFtky1ZGTQdsGKFezNsBGpfXuBtiGmytR3zooIbmstqFKAzuJgIi0yUzgYPlOfVcqmJObolFDW4jXNQ/tNDIz1OGYziauEHhSA5xnYUnCR9OzCwhcZWKSaMS8CQLdVQUgAOZcUljlrMo+kgAwHZVIP8aw0lDiIYTaOEryYG4FdDKSN7Yg5TMFzFROcSRWFMRgqqAZEuR0JpzK/u2LF0NernZWrGwjzzkFjZdOzVHtgnXWwx63Cy3Xf5HEK+233st+7+XqqcOgagTVn3SZvY45nBdhn9kusMo++n5whq7zwrZkTGjMKL5MHNDKqBunWGazi9qjN2WZ27rT2oc7QBYA2Bk3uCWp8VnpbSW9sYB8dEGUvVepiL+2ADk/4iz/Dju85Af/8m2djz99/ED1n9EwCsAzNzkuSIc+Gfug/3pc6+OwWM9DdW+Dc933Flq0wM97whjfgta99LV7wghcAAC655BIce+yx+NM//VO89KUvxR133IG3ve1teNe73oUf+7EfAwC8+93vxiMf+Uh86EMfwrOe9awDe4ql0krkKVCe+pt9AewWjFtgBqahsJiB6rjnabCOSUZKLbCdwnZAca8odxMEUSUgpVqcshFM+35qutaevJUf8Ql7w7HwRC1jjgC9BMwBlA2YI0D7fmDR1bz0lOFj6vW0XWFqa5KQUczaRutMZiWgxMNYy4ZGMmkEBrK2HiUJYSIS4GwXuDZ0MdN5n00ilBPmQKOM8XkFMKcA0gxeZLnmIitFq+mYs+Mxg0ejpQzOWavOKWf2HNWSOWpEVm9e8+51MaioNR37Wnr2yIxM7Ay6uEJW+kJhzCTm8FGBOds2gDO0CVlBNHa4yit8Ql925zBXvuyzOYQ1f1PrIUs6eegVy4Mn9jcOn63PxI5qwMyiz5lFgsi8wsuSHlTdWDHXVgANmROwrivH7eIZVGkoEh1QnFSH0mANMCcsv+daEpLfLUDhXwTmTv/16AIwdw7MmwrMMUyDvJnkqgOKMbo0Ypk/n8FkroX+HfnkJ+CI7/s+AMCxr3gNvvqJv8GMhTX3TOh1/eyUWRZ3cYWNQ/8hV/A8pr4DZvdWKNUNN9yA3bt3Y3NzE6eccgouvPBCPOYxj8GNN96IW2+9Fc985jP9t5ubmzj99NPxyU9+Ei996Utx5ZVXYrFYVL/ZvXs3nvSkJ+GTn/zkSnDe2trC1lZZFPPOO+/chzudgpj28z1RV5UIh8sgbVpniX+uOzw1HT/6N4rftuiLtk2AhthPJ5tv1YW2GkAD9Rx0xK1tlHt/umhNNoBugXkSO3m6RVv5tbKs0qVWvbLtjk89WGZYmI4wZugXCTqxKZ/tbwgok7GsE5GNgudrLyNoNqoA+JKRStMkwFauFUF2IeZa2orgrOBvJl0DaP0bHnMw2QogG1uW7QjOCZxHOIHmVDyQmTG6R5Z479p64wievIA4HUXFMlPNqNwYQcWhMZp643bMXHJojKXZok7jIUcmMFV2c2hqe7cemrVE4blizva955rRV+Hrj3PA1NBRM6sCut3AAdfKWfWlzW2WXFojqxMSWOOny3pfhUEXUK5TbZYH8qU7wd44hTnXwGx/s5wMySbW5FqtU1j9LzZPBOdU/SvA3DcAXeaey7yUzTsXKsIqdXgJnEVBSWTm+V7N9qIQ7Ln2eiy+/i/oH/Jg3PW+P8MsEzaygPIsU5VFjTLcR5PMyNBBZq6Cb4P1r417A5xPOeUUvPOd78TjHvc4fO1rX8MFF1yA0047Dddddx1uvfVWAMCxxx5b/c2xxx6Lm266CQBw6623YmNjAw95yEOWfmN/P1Uuuugi/PZv//b+3Oq/sqyS4O33U6XS4UNt1e6aTcfPNNnFS+e3zENjpYtGUG5U+BV3NKXw2zlaE/fUNp4vsvHImt3azGWuOQLxUgvbd1Hg7W/ZV5DeDrwNYRkBmDlMlNvP9EZZqZ1hr3kFuf3UvJcySuISoLLLullDEWlpPWdFBVsy0uaUbQ51i3QeNQHzDPZwKS7zsY52ypwjMGu6ypwTOKfAlIHMGWPl0as9MMxTLvVpruciGTpvTGHihtmBuXIqVyAacsBIKqbt5VFTBGJxBJM/XPLUtv9Cm9fm7RXVADq82gjQS+eGq2+FQTel6uM6AAw4625ZwiITxzZgvUaRDWbO5qilBNO0qfFy3WhWiFpN68VSO6m273rZPgJEUC4lrkFV/KgLMBs8yz8D6eQe2wLOlpwku5SBKyZsL53gd1EUC8vDqc5nnJA4oVsscMPJP4SN2RybGwtsbBA2WIBZUt0TOgt5NL+NEPEAjX12ZmN9qwNm90ac87Of/WzfP/HEE3HqqafihBNOwCWXXIKnPvWp0vRE1d9YsoLtyt5+8+pXvxqvfOUr/fOdd96JRz7ykftz6/tY9saG91a2A+a9g3QL1nH2poCygPAYBmIcwKuegpvt1JPHv50CbKB4W7dPbMf3NU3L1LRwe60lHSMIw6WmXlVWgfGU+8AUQBujNe2iWlQCS6bRMgdtbMiYSQRpUvRAOX+c07Yk5Z0pAwER4ny0zSPbcuBzVuacK+YswJwdlCNLRpVDugPzCGYFZmXNMsdMWmUe2BgzYyimUhOAXPpxDv3XqwN0wD1mDFREqPuukc05s6/iNIYmyyQ4UjlkqQ6EFIC57WirhuPURPg2w5W5GEm8f6K+jn1eBdCVPhi6jiuxqhea5cmms9r5XUJR4lPQOKpEvhwnlrjSXPxsHJAn2DPqcKoC0u3U2xRbXgbomjdHo3aB5MKe65jnDVjMs2VzyCjgDE25xP5U1g4DzF2V0IFYr8gJHSd1/ErOmjcyabr8YMbWsMPix4FayMV3qf2I5ite/F7KvyqUaufOnTjxxBNxww034PnPfz4AYcfHHXec/+a2225zNr1r1y7M53N84xvfqNjzbbfdhtNOO23ldTY3N7G5eYDZw/epTAHy/oB02/3aUc/Vfpx3rvcLkNtAa+fsYm4dx4OqrmLQq5881oyCWYxlE3c81oJyBOe9gbFXDkLIhJMJOjRAvKpixbFVD7qvNxfP13rMmR3VHjjKPGvFmEXCncuyThxaRdma3LOVRDqGrxNtD2VU1uOZubjeb5F4Ii8AcmDOYtL2sK8Mm7cu88o1axbmHMFY2IVdlsCQXMuFORd2VgAh+u22Ijy6PNYOYM2UL4fjppvkwt1Ym8S34V25iTFUK7FfRcvvEkDHrV7QmXLT36zbtVYfY8/gFQBNZUOwNhbFRBYLse6lfiYUPOQVmpa3Qa7Yu4K5jmqCFu3YxSzM4f0NoRYwnmbOy7KqhujyoHFVsRi2ZABdXMEElg2mzXfaUnoyZsgKtBIARUGORk0si0KiabtkYZYCzMmBOaHPSczY6pltZm1bC927eRt+uMCys47JhoQDzhCW9v6T1WVrawuf//zncdxxx+H444/Hrl27cPnll/v38/kcV1xxhQPvySefjNlsVv3mlltuwbXXXrstON87ZX/BuN2PIzVPfJ4ywpUtN3833dnLNzaE4rCb6jex/0yFtNp2yTzYtMwUrrWpWfw7Xu0JPoWDQCCkBtBtk7af26ad+u1U2Q6g26xjcZktZ7OowTMCaPSsji1qTly2tQQii1HDoTQ0amuUMKk9ur/HatYaPm9Z5VJDWBB7+JQBNLvzV/HGjsCsTFhr5hGZB62yP7LEjo48YIR8HjFgtH8s2wEZAySf3YCMhW6lirhfsG7BFRBHI2oE5aJbsGc2tZDxKqRoWK5xEHAbQ7hqYEwBc8OYrZ+1lpxWOjAQk4ktSwRTOsKxMRwfHYib34dQNvZtbmoAVX234CItvLWXGquWEHXWwlwB9Gpg3m4IGnOOccXL7HnmWzN0z5RRz6r5aIuNhnty+zJSiGZsxCspMEsNIVM+34zgpQ94Jr8BsFS4S7Gp8xX1AMp+MedXvepVeO5zn4tHPepRuO2223DBBRfgzjvvxFlnnQUiwjnnnIMLL7wQj33sY/HYxz4WF154IQ4//HD8/M//PADgqKOOwkte8hKce+65eOhDH4qjjz4ar3rVq3DiiSe69/Z9V9qutKprxe9bJGjp1nZ1FVC3IB3NQ+adWfRDY86rGPSqOgWYCfUdxlIBaTi+CuNWAXNkzOBlgG5B2c3YLQDvrcbX0j5E2xDbhWCZZLUDxoA7BjqqNZFJ02mW35tLMQgeC5Ma5uzmB6NKXE/Sg8v9ZATTNoCBwHOWNJxDqueZo/PXmGGrLAkgByGuebGZNdVmAIFR03KObPdR1EKCpdiaSpozYdZGzb1aTraUgRRcQo1ZQbl53R52bNXo6pRJu3o/qIfgdrXpY2bStlOZpcctPhPdAShMupUG0YxtViy3rQWmbI510fNd5EHxmC9m7WinMIO4zdF2Erfuf8UobycCcgHmqLGY0x817DkOwOkhWEB5VRBV51v5Z/Bty/UWJm1rPavM46wWEtb7DBNs3IFIYpqjI1oHWgJoZ8ytVatlzx2F6afwoJE53xvgfPPNN+OFL3whbr/9djzsYQ/DU5/6VHzqU5/Cox/9aADAr//6r+Puu+/Gr/zKr+Ab3/gGTjnlFFx22WUe4wwAv/u7v4u+7/EzP/MzuPvuu/H0pz8d73jHO+6FGOftSqvrTn2/Svq3ULaKNdeSoB0ScT+e30Ikls3b9dkFoLcH5FWEcUpFiC0xZe2NZu9V1uHJfa7PCS6m7cmmDsfa+ebq8xR4x4eIZW8aSmtPaiXsGIDZ5qFNqiJIbHAAZtuqGCfAPeTaruImiQDO8WEMpaKQ8PhmLMcvW4x1Tg7KCCZtBJAWlpyQeax6qwCEefQaACg4cy2w69jXFqYDQHsoFdznrnhuF0B2FgkF5rQapN20TUWPiplFvRUDwDZDczUo70VBdIAO2/jaYrHTxS4m41qc7nxcUrylYl8TsI5wGKVD7S4nrdkhgrNNBcSbK3DfemZHP5h4bm7uqr6T+uGjI1gcgiXoKWbkMtO2MWkKIJv9c8kSVq48oiSG7UEeVlXn+hJHMNKaPNmIhU1R1Q9WgPRgSjqmwdm0sHvDW/vSSy/d9nsiwvnnn4/zzz9/5W927NiBN77xjXjjG9+4P5e+D8uUdI/HbXTSxLH9qwWky/nlzNMOFsVJrHT21jSWJraR4a7i7qswrd22wD+FeZEt23J58e9XXccaYClUZR+F5ZJ8WDr5Nje+dGMq6aPtPk0B9PKfBYmK4hym6JGBep1N/Z1JZ5PUfg8ofxeFRONBilHYMTVLHhodZl9NqzWD2lwyhYW3JMewpUmMWbENmAm1AK+XNW0hu0BG7KuV/5WBdfhsTeUe2anst+83NrPVqk+3Q7UF4e1AOfxdZM/xO7u07bdl6vLUfE7hVccu0koNa9eYkCTAeGlxji1Pev0odTj8Ppqta4Ceahiu9upnBOphEdlznH+Oc88FTuUz6cCzECmYkgEJpZK+yVX/rNeKVp7OCYnsyqlcl/V6bAESptWFhp/y4Lcx57KDisCyTrBeleqeKK005xXf7cv3EyP5AKu94/bo1H6U8an53JKBqcG+qrTAbPt7q2CgdcRfCcrNoy95Zh9o0049THsTU1qGnd/NBPowS85jHLSOoKQ5kgDFIQzlxAb2UYJzc83WW85fNGvmqgDMLk8J7r3lL5nR2n7ZKhgG0ibEa/dDuKlbwKL0HkId+mdMqvUkbn8R9ZDRYp8Z4sXNxhi5NJ02Zw77ng3MfqOAXWmrU+/a2rHtP62Wup3yN3Uue2VY/bk9vs9d2Z7T/sX2WfFPGqcwavjW3oIVu8P4XXxj9d/ZO1629k09SV2mFHszby+buwvXtW8FiA2YpYpDGFCcZeV4e7bI2/2MGh4obiOETqdvll7AKqtKC9Kxr9k4Hic6wD6UNTjvV+GJ/bYTtvtTv9seCttvCgkof7c9HtVDaUrObGcF3humcfM59scpvGt/u90Dx9/He1jJntubb86317KtZrG33zGq1GZo/y6I4AjU9sOVORvjdblmzsAyyzZArmimCRgOwAz4MowquKMABwSsfRsEe+FlKMe4COoGOvyvWvG9d6Po9KPJo2jfb3Se2DQwgG7LVFPHv90bEG/zqvYGwFN/ThPfrxqLst+Mey5ti+r3U4BZv5EC1iU4M/5qO2kRgd+25FffvqnKEKFJuTDBcxEZdoTy5KBM1beFly973VTAbDH7DXybrjxZJzvpihoB+YEEzrwk1PYm5Fa19JQKpOle3FZh6eFalcj+pp1wsO/M27F14dtCWYoiuvtF3+nlUIUgEgGUmOd2CBPKFMe2gLiihdpWsdaYesrWN8LyYSwtrpHVRwm1921caTGPIlQ5bjUNXr36EEpITLzpEfCsfNHzus2G0i6KMXU8Npxdwx+U61e6ZZUlCcgWa6wx6xywbmUyFT4hau/MmPikN10A5irLRXlmbl+Cdyl2h7A8ZGAkUB7BIyHnEVmXhMyabGRklLA2BmzNaWad02MJmJIpNksVGzKDBc9fVl9tWzOtzgqfMWL0T56IBDZjuByBUDI5a82QeWe9zZzgc9FuGKCmovQbju24r4J46rvw95X3NvbOnt1sjRpKjfSbg2fWFq2ZoRly4zTCgF4Ba8SIVNla4zCR9h/QY0DSWnyy1R9f39EI8bVfIGOO6G9vf0He+aQf5PCXY/jlAmUxyDmyzhyPGghl69rL9UbMMGCBHgv0mOucc4LRE8mQOEAWsuj9GeT+JbKAMQfzAkR7kCB1hi1sYAtDnmNMc41EWEj0QR4wjiNGGtGnDBqzRF4MGb5SnI3JaOKLyq+HQqISmHeqQ9gybm1fDklw/vrXv77NtxGsDp2yDwr6oVXa13CA2uPBX3jF/n1zF4d8/7mfPMiBP8ahKb8O2nIQNeddd92Fo446ap9/f0iC89FHHw0A+PKXv7xfD7su08Uyrn3lK1/Bgx70oPv6dg7psm7Le7as2/OeK+u2vGfLvrYnM+Ouu+7C7t279+v8hyQ4pySmmqOOOmrdye7B8qAHPWjdnvdQWbflPVvW7XnPlXVb3rNlX9rzQEjklOvEuqzLuqzLuqzLutyHZQ3O67Iu67Iu67IuB1k5JMF5c3MT55133r/xYhgPnLJuz3uurNvyni3r9rznyrot79nyb92exPvr370u67Iu67Iu67Iu/6blkGTO67Iu67Iu67Iu9+eyBud1WZd1WZd1WZeDrKzBeV3WZV3WZV3W5SAra3Bel3VZl3VZl3U5yMoanNdlXdZlXdZlXQ6yckiC85ve9CYcf/zx2LFjB04++WR8/OMfv69v6aArH/vYx/Dc5z4Xu3fvBhHhL//yL6vvmRnnn38+du/ejcMOOwxnnHEGrrvuuuo3W1tbeMUrXoFjjjkGO3fuxPOe9zzcfPPN9+JTHBzloosuwg/8wA/gyCOPxHd913fh+c9/Pq6//vrqN+v23Pfy5je/GSeddJJnVjr11FPxt3/7t/79ui0PvFx00UUgIpxzzjl+bN2e+17OP/98EFFVd+3a5d/fq23Jh1i59NJLeTab8Vve8hb+3Oc+x2effTbv3LmTb7rppvv61g6q8jd/8zf82te+lt/znvcwAH7f+95XfX/xxRfzkUceye95z3v4mmuu4Z/92Z/l4447ju+8807/zcte9jJ++MMfzpdffjlfddVV/LSnPY2f/OQn8zAM9/LT3LflWc96Fr/97W/na6+9lq+++mp+znOew4961KP4W9/6lv9m3Z77Xt7//vfzBz/4Qb7++uv5+uuv59e85jU8m8342muvZeZ1Wx5o+fSnP83f/d3fzSeddBKfffbZfnzdnvtezjvvPH7iE5/It9xyi9fbbrvNv7832/KQA+cf/MEf5Je97GXVse/93u/l3/iN37iP7ujgLy0455x5165dfPHFF/uxPXv28FFHHcV/+Id/yMzM3/zmN3k2m/Gll17qv/nqV7/KKSX+u7/7u3vt3g/GcttttzEAvuKKK5h53Z73RHnIQx7Cb33rW9dteYDlrrvu4sc+9rF8+eWX8+mnn+7gvG7P/SvnnXceP/nJT5787t5uy0PKrD2fz3HllVfimc98ZnX8mc98Jj75yU/eR3d16JUbb7wRt956a9WOm5ubOP30070dr7zySiwWi+o3u3fvxpOe9KQHfFvfcccdAMrqaOv2PPAyjiMuvfRSfPvb38app566bssDLL/6q7+K5zznOfixH/ux6vi6Pfe/3HDDDdi9ezeOP/54/NzP/Ry++MUvArj32/KQWpXq9ttvxziOOPbYY6vjxx57LG699db76K4OvWJtNdWON910k/9mY2MDD3nIQ5Z+80Bua2bGK1/5SvzwD/8wnvSkJwFYt+eBlGuuuQannnoq9uzZgyOOOALve9/78IQnPMEF2Lot971ceumluOqqq/CP//iPS9+t++b+lVNOOQXvfOc78bjHPQ5f+9rXcMEFF+C0007Dddddd6+35SEFzlaIqPrMzEvH1mXv5UDa8YHe1i9/+cvx2c9+Fp/4xCeWvlu3576Xxz/+8bj66qvxzW9+E+95z3tw1lln4YorrvDv1225b+UrX/kKzj77bFx22WXYsWPHyt+t23PfyrOf/WzfP/HEE3HqqafihBNOwCWXXIKnPvWpAO69tjykzNrHHHMMuq5b0kBuu+22JW1mXVYX8z7crh137dqF+XyOb3zjGyt/80Arr3jFK/D+978fH/nIR/CIRzzCj6/bc//LxsYGvud7vgdPecpTcNFFF+HJT34yfu/3fm/dlvtZrrzyStx22204+eST0fc9+r7HFVdcgd///d9H3/feHuv2PLCyc+dOnHjiibjhhhvu9b55SIHzxsYGTj75ZFx++eXV8csvvxynnXbafXRXh145/vjjsWvXrqod5/M5rrjiCm/Hk08+GbPZrPrNLbfcgmuvvfYB19bMjJe//OV473vfiw9/+MM4/vjjq+/X7fmvL8yMra2tdVvuZ3n605+Oa665BldffbXXpzzlKXjRi16Eq6++Go95zGPW7fmvKFtbW/j85z+P44477t7vm/vlPnYQFAuletvb3saf+9zn+JxzzuGdO3fyl770pfv61g6qctddd/FnPvMZ/sxnPsMA+PWvfz1/5jOf8ZCziy++mI866ih+73vfy9dccw2/8IUvnAwJeMQjHsEf+tCH+KqrruIf/dEffUCGV/zyL/8yH3XUUfzRj360CrH4zne+479Zt+e+l1e/+tX8sY99jG+88Ub+7Gc/y695zWs4pcSXXXYZM6/b8l9borc287o996ece+65/NGPfpS/+MUv8qc+9Sk+88wz+cgjj3R8uTfb8pADZ2bmP/iDP+BHP/rRvLGxwd///d/vIS3rUspHPvIRBrBUzzrrLGaWsIDzzjuPd+3axZubm/wjP/IjfM0111TnuPvuu/nlL385H3300XzYYYfxmWeeyV/+8pfvg6e5b8tUOwLgt7/97f6bdXvue3nxi1/s4/dhD3sYP/3pT3dgZl635b+2tOC8bs99Lxa3PJvNePfu3fyCF7yAr7vuOv/+3mzL9XrO67Iu67Iu67IuB1k5pOac12Vd1mVd1mVdHghlDc7rsi7rsi7rsi4HWVmD87qsy7qsy7qsy0FW1uC8LuuyLuuyLutykJU1OK/LuqzLuqzLuhxkZQ3O67Iu67Iu67IuB1lZg/O6rMu6rMu6rMtBVtbgvC7rsi7rsi7rcpCVNTivy7qsy7qsy7ocZGUNzuuyLuuyLuuyLgdZWYPzuqzLuqzLuqzLQVb+f9kH3KsI8wJ4AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
    " ] @@ -147,6 +147,14 @@ "source": [ "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "588274db-be02-4cce-84bc-a3a0160c92ce", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..75d8a18 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs @@ -0,0 +1,93 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..f245000 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "lhwE$$MmxH}a7eE(#2l9}`F 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 YoZMJbcI-1O=Qn~jEwkAN$b*Cb2k2WV5&!@I literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..50b68d4 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs @@ -0,0 +1,44 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c GIT binary patch literal 5936 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 EzoF}P2><{9 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata new file mode 100644 index 0000000..d47caf5 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata @@ -0,0 +1,182 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", "with coordinate systems:\n", @@ -135,7 +129,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 5, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -159,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -168,7 +162,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_scale.zarr to \n", - " \u001b[35m/tmp/tmphz5xe90i/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmp5i7g8haz/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" ] } ], @@ -186,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "id": "3583c7fd-a779-4353-aade-834b0b6f62d2", "metadata": {}, "outputs": [ @@ -202,7 +196,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -214,6 +208,14 @@ "source": [ "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61110f2c-9dfc-4c52-8184-8f8e86f50869", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..b064678 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs @@ -0,0 +1,98 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 1.0, + 2.0 + ], + "type": "scale" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..f245000 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "lhwE$$MmxH}a7eE(#2l9}`F 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 YoZMJbcI-1O=Qn~jEwkAN$b*Cb2k2WV5&!@I literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..f1e1747 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs @@ -0,0 +1,48 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 2.0, + 1.0 + ], + "type": "scale" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c GIT binary patch literal 5936 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 EzoF}P2><{9 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata new file mode 100644 index 0000000..9f69a9b --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata @@ -0,0 +1,191 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 1.0, + 2.0 + ], + "type": "scale" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "lhwE$$MmxH}a7eE(#2l9}`F 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 YoZMJbcI-1O=Qn~jEwkAN$b*Cb2k2WV5&!@I literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..50788d7 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs @@ -0,0 +1,48 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 100.0, + 0.0 + ], + "type": "translation" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c GIT binary patch literal 5936 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 EzoF}P2><{9 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata new file mode 100644 index 0000000..112efe7 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata @@ -0,0 +1,191 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 0.0, + 0.0, + 100.0 + ], + "type": "translation" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": " Date: Wed, 23 Aug 2023 17:13:28 +0200 Subject: [PATCH 07/25] added sequence --- .../storage_format/transformation_scale.ipynb | 28 +- .../transformation_sequence.ipynb | 306 +++++++++++++++ .../transformation_sequence.zarr/.zgroup | 3 + .../images/.zgroup | 3 + .../images/blobs_image/.zattrs | 187 ++++++++++ .../images/blobs_image/.zgroup | 3 + .../images/blobs_image/0/.zarray | 25 ++ .../images/blobs_image/0/0/0/0 | Bin 0 -> 21819 bytes .../points/.zgroup | 3 + .../points/blobs_points/.zattrs | 120 ++++++ .../points/blobs_points/.zgroup | 3 + .../points.parquet/part.0.parquet | Bin 0 -> 5936 bytes .../transformation_sequence.zarr/zmetadata | 352 ++++++++++++++++++ .../transformation_translation.ipynb | 6 +- 14 files changed, 1021 insertions(+), 18 deletions(-) create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.ipynb create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/0/0/0 create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/points.parquet/part.0.parquet create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata diff --git a/notebooks/developers_resources/storage_format/transformation_scale.ipynb b/notebooks/developers_resources/storage_format/transformation_scale.ipynb index d6a4a08..68cf046 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_scale.ipynb @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", "metadata": {}, "outputs": [ @@ -85,6 +85,12 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" ] @@ -112,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", "metadata": {}, "outputs": [ @@ -129,7 +135,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 14, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -153,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -162,7 +168,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_scale.zarr to \n", - " \u001b[35m/tmp/tmp5i7g8haz/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmp4jnoek20/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" ] } ], @@ -180,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "id": "3583c7fd-a779-4353-aade-834b0b6f62d2", "metadata": {}, "outputs": [ @@ -196,7 +202,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -208,14 +214,6 @@ "source": [ "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "61110f2c-9dfc-4c52-8184-8f8e86f50869", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.ipynb b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb new file mode 100644 index 0000000..2492700 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "64609fbc-a482-4d17-97cc-99dcacb7cd5e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext jupyter_black" + ] + }, + { + "cell_type": "markdown", + "id": "7bf33a06-009a-487a-991b-715a28b1069b", + "metadata": {}, + "source": [ + "# Scope and description" + ] + }, + { + "cell_type": "markdown", + "id": "d96031b8-ee40-43ca-9001-011f4751d4c1", + "metadata": {}, + "source": [ + "A raster and a vector elements with a sequence transformation, combining a scale and a translation, and a single coordinate system ('global').\n", + "\n", + "Elements contained:\n", + "- 2D image (cyx)\n", + "- 2D points" + ] + }, + { + "cell_type": "markdown", + "id": "5a4c6566-882a-48d4-a4cd-0777332a5a99", + "metadata": {}, + "source": [ + "# Prepare the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "094509a1-86fb-4aa6-b920-11e34ed43e1c", + "metadata": {}, + "outputs": [], + "source": [ + "NAME = \"transformation_sequence\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" + ] + } + ], + "source": [ + "import spatialdata as sd\n", + "import spatialdata_plot\n", + "from spatialdata.datasets import blobs\n", + "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "import numpy as np\n", + "\n", + "delete_old_data(name=NAME)\n", + "sdata = blobs(length=32)\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" + ] + }, + { + "cell_type": "markdown", + "id": "b8d31311-aaa2-4ea4-bdfa-7519f6bb1d1d", + "metadata": {}, + "source": [ + "Set the affine transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SpatialData object with:\n", + "├── Images\n", + "│ └── 'blobs_image': SpatialImage[cyx] (3, 32, 32)\n", + "└── Points\n", + " └── 'blobs_points': DataFrame with shape: (, 4) (2D points)\n", + "with coordinate systems:\n", + "▸ 'global', with elements:\n", + " blobs_image (Images), blobs_points (Points)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scale = sd.transformations.Scale(scale=[2.0, 0.5], axes=(\"x\", \"y\"))\n", + "translation = sd.transformations.Translation(translation=[10.0, 30.0], axes=(\"x\", \"y\"))\n", + "# translation is applied before scale\n", + "sequence = sd.transformations.Sequence([translation, scale])\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=sequence, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=sequence, to_coordinate_system=\"global\"\n", + ")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "800a540b-2906-46c9-8245-99def219692f", + "metadata": {}, + "source": [ + "# Read-write and IO validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b6c01345-27de-42f3-af07-75a43e84808a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_sequence.zarr to \n", + " \u001b[35m/tmp/tmpmmgs9nxm/\u001b[0m\u001b[95mtransformation_sequence2.zarr\u001b[0m \n" + ] + } + ], + "source": [ + "write_sdata_and_check_consistency(sdata=sdata, name=NAME)" + ] + }, + { + "cell_type": "markdown", + "id": "06806f13-f346-410f-ab04-fdd61fd77a10", + "metadata": {}, + "source": [ + "# Plot the data" + ] + }, + { + "cell_type": "markdown", + "id": "27f9aa03-58a5-4ed6-ba16-8a352bc90125", + "metadata": {}, + "source": [ + "Doesn't work, tracked here: https://github.com/scverse/spatialdata-plot/issues/146.\n", + "\n", + "```python\n", + "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "543c8687-d74b-40ac-9bc9-972c13e76f2b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", + " layer = self._viewer.layers.selection._current\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", + " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", + "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", + " layer = self._viewer.layers.selection._current\n", + "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", + " layer = self._viewer.layers.selection._current\n", + "\u001b[32m2023-08-23 17:12:30.364\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "\u001b[32m2023-08-23 17:12:30.365\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", + " layer = self._viewer.layers.selection._current\n", + "\u001b[32m2023-08-23 17:12:32.795\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "\u001b[32m2023-08-23 17:12:32.797\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", + " layer = self._viewer.layers.selection._current\n", + "\u001b[32m2023-08-23 17:12:32.800\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "\u001b[32m2023-08-23 17:12:32.801\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", + "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=320.924,627.538 gbl=320.924,627.538 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-320.924,-627.538 last=-320.924,-627.538 Δ 320.924,627.538) : no target window\n", + "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=320.924,627.538 gbl=320.924,627.538 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-320.924,-627.538 last=-320.924,-627.538 Δ 320.924,627.538) : no target window\n", + "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=527.994,830.858 gbl=527.994,830.858 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-527.994,-830.858 last=-527.994,-830.858 Δ 527.994,830.858) : no target window\n", + "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=527.994,830.858 gbl=527.994,830.858 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-527.994,-830.858 last=-527.994,-830.858 Δ 527.994,830.858) : no target window\n", + "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=640.64,527.409 gbl=640.64,527.409 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-640.64,-527.409 last=-640.64,-527.409 Δ 640.64,527.409) : no target window\n", + "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=640.64,527.409 gbl=640.64,527.409 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-640.64,-527.409 last=-640.64,-527.409 Δ 640.64,527.409) : no target window\n" + ] + } + ], + "source": [ + "from napari_spatialdata import Interactive\n", + "\n", + "Interactive(sdata)" + ] + }, + { + "cell_type": "markdown", + "id": "f22ac27f-b649-4ab2-83c3-cdaeb168d10f", + "metadata": {}, + "source": [ + "Screenshot from napari, notice the padding due to the translation." + ] + }, + { + "attachments": { + "280fc662-7567-445a-8ecb-e3b652681e31.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "532c0fc5-39e3-48f7-9bd3-9e845020b246", + "metadata": {}, + "source": [ + "![image.png](attachment:280fc662-7567-445a-8ecb-e3b652681e31.png)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs new file mode 100644 index 0000000..247659c --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs @@ -0,0 +1,187 @@ +{ + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "transformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 0.0, + 30.0, + 10.0 + ], + "type": "translation" + }, + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 0.5, + 2.0 + ], + "type": "scale" + } + ], + "type": "sequence" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray new file mode 100644 index 0000000..f245000 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray @@ -0,0 +1,25 @@ +{ + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "lhwE$$MmxH}a7eE(#2l9}`F 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 YoZMJbcI-1O=Qn~jEwkAN$b*Cb2k2WV5&!@I literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs new file mode 100644 index 0000000..ab90cb2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs @@ -0,0 +1,120 @@ +{ + "axes": null, + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "transformations": [ + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 10.0, + 30.0 + ], + "type": "translation" + }, + { + "input": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "xy" + }, + "output": { + "axes": [ + { + "name": "x", + "type": "space", + "unit": "unit" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 2.0, + 0.5 + ], + "type": "scale" + } + ], + "type": "sequence" + } + ], + "encoding-type": "ngff:points", + "spatialdata_attrs": { + "feature_key": "genes", + "instance_key": "instance_id", + "version": "0.1" + } +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup new file mode 100644 index 0000000..3b7daf2 --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup @@ -0,0 +1,3 @@ +{ + "zarr_format": 2 +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/points.parquet/part.0.parquet new file mode 100644 index 0000000000000000000000000000000000000000..53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c GIT binary patch literal 5936 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 EzoF}P2><{9 literal 0 HcmV?d00001 diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata new file mode 100644 index 0000000..282b1df --- /dev/null +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata @@ -0,0 +1,352 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "transformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "translation": [ + 0.0, + 30.0, + 10.0 + ], + "type": "translation" + }, + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "scale": [ + 1.0, + 0.5, + 2.0 + ], + "type": "scale" + } + ], + "type": "sequence" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 32, + 32 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": ", 4) (2D points)\n", "with coordinate systems:\n", @@ -170,7 +170,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_translation.zarr to \n", - " \u001b[35m/tmp/tmpsujko4mw/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpnxta4qob/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" ] } ], From 85bf0bc08d258508b579b8a8681e498fa154f671 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 18:19:27 +0200 Subject: [PATCH 08/25] added tech notes to readme --- notebooks/developers_resources/storage_format/Readme.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index e30dd31..479c3a2 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -32,3 +32,7 @@ git diff \ $(git rev-list -n 1 main) -- data # TODO: test the command ``` + +## Important technical notes +- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. Example: +- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). Example: From 0dc43af3634d37caa5a8ff129a39a2de556ef4f2 Mon Sep 17 00:00:00 2001 From: LucaMarconato <2664412+LucaMarconato@users.noreply.github.com> Date: Wed, 23 Aug 2023 18:23:03 +0200 Subject: [PATCH 09/25] Update Readme.md: fixed links --- notebooks/developers_resources/storage_format/Readme.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index 479c3a2..bb7ae5b 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -34,5 +34,5 @@ git diff \ ``` ## Important technical notes -- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. Example: -- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). Example: +- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). +- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). From 2079e59fce081bc3d4d2e408da27578d9ef19740 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 18:25:46 +0200 Subject: [PATCH 10/25] autorun: storage format --- .../storage_format/multiple_elements.ipynb | 18 ++---- .../transformation_affine.ipynb | 18 ++++-- .../transformation_identity.ipynb | 24 ++++---- .../storage_format/transformation_scale.ipynb | 2 +- .../transformation_sequence.ipynb | 55 +------------------ .../transformation_translation.ipynb | 2 +- 6 files changed, 33 insertions(+), 86 deletions(-) diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index f68298b..e4747ad 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -133,8 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] }, { @@ -142,15 +142,15 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", - " \u001b[35m/tmp/tmpxu474pqt/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpapfx6khv/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] } ], @@ -434,14 +434,6 @@ "source": [ "sdata.pl.render_shapes('blobs_multipolygons').pl.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1308121b-0f6f-41a2-8a33-ceac4dc56ea2", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/transformation_affine.ipynb b/notebooks/developers_resources/storage_format/transformation_affine.ipynb index 411d448..3b8eea1 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_affine.ipynb @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "d5fa9f79-145c-47fe-943f-6c6b56ad4e1d", "metadata": {}, "outputs": [ @@ -48,6 +48,12 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" ] @@ -75,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "3d4f59a6-48b9-4444-8f7d-490237b9e469", "metadata": {}, "outputs": [ @@ -92,7 +98,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 7, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -115,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -124,7 +130,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_affine.zarr to \n", - " \u001b[35m/tmp/tmp1667komg/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpw_7saqxd/\u001b[0m\u001b[95mtransformation_affine2.zarr\u001b[0m \n" ] } ], @@ -142,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "af8d7108-8b7c-461e-871e-77d82de82af6", "metadata": {}, "outputs": [ diff --git a/notebooks/developers_resources/storage_format/transformation_identity.ipynb b/notebooks/developers_resources/storage_format/transformation_identity.ipynb index bfbc7e4..8c0a61e 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_identity.ipynb @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "332c9c62-7451-4d8e-ba9e-13c12131c312", "metadata": {}, "outputs": [ @@ -48,6 +48,12 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/__init__.py:9: UserWarning: Geopandas was set to use PyGEOS, changing to shapely 2.0 with:\n", + "\n", + "\tgeopandas.options.use_pygeos = True\n", + "\n", + "If you intended to use PyGEOS, set the option to False.\n", + " _check_geopandas_using_shapely()\n", "/Users/macbook/embl/projects/basel/spatialdata/src/spatialdata/_core/operations/aggregate.py:244: UserWarning: Converting `region_key: region` to categorical dtype.\n", " table = TableModel.parse(table, region=shapes_name, region_key=region_key, instance_key=instance_key)\n" ] @@ -65,7 +71,7 @@ " blobs_image (Images), blobs_points (Points)" ] }, - "execution_count": 5, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -92,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "b6c01345-27de-42f3-af07-75a43e84808a", "metadata": {}, "outputs": [ @@ -101,7 +107,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_identity.zarr to \n", - " \u001b[35m/tmp/tmpoi4qpp72/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpxskndwun/\u001b[0m\u001b[95mtransformation_identity2.zarr\u001b[0m \n" ] } ], @@ -119,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "af8d7108-8b7c-461e-871e-77d82de82af6", "metadata": {}, "outputs": [ @@ -147,14 +153,6 @@ "source": [ "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "588274db-be02-4cce-84bc-a3a0160c92ce", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/notebooks/developers_resources/storage_format/transformation_scale.ipynb b/notebooks/developers_resources/storage_format/transformation_scale.ipynb index 68cf046..c9f4fc7 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_scale.ipynb @@ -168,7 +168,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_scale.zarr to \n", - " \u001b[35m/tmp/tmp4jnoek20/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpqpqs_41a/\u001b[0m\u001b[95mtransformation_scale2.zarr\u001b[0m \n" ] } ], diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.ipynb b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb index 2492700..b215dbb 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb @@ -173,7 +173,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_sequence.zarr to \n", - " \u001b[35m/tmp/tmpmmgs9nxm/\u001b[0m\u001b[95mtransformation_sequence2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmp_ng4wk0o/\u001b[0m\u001b[95mtransformation_sequence2.zarr\u001b[0m \n" ] } ], @@ -202,58 +202,9 @@ ] }, { - "cell_type": "code", - "execution_count": 6, - "id": "543c8687-d74b-40ac-9bc9-972c13e76f2b", + "cell_type": "raw", + "id": "e16b06da-714d-4a1d-b36b-275b1a15a475", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", - " layer = self._viewer.layers.selection._current\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/macbook/miniconda3/envs/ome/lib/python3.10/site-packages/anndata/_core/anndata.py:117: ImplicitModificationWarning: Transforming to str index.\n", - " warnings.warn(\"Transforming to str index.\", ImplicitModificationWarning)\n", - "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", - " layer = self._viewer.layers.selection._current\n", - "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", - " layer = self._viewer.layers.selection._current\n", - "\u001b[32m2023-08-23 17:12:30.364\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "\u001b[32m2023-08-23 17:12:30.365\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", - " layer = self._viewer.layers.selection._current\n", - "\u001b[32m2023-08-23 17:12:32.795\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "\u001b[32m2023-08-23 17:12:32.797\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "/Users/macbook/embl/projects/basel/napari-spatialdata/src/napari_spatialdata/_view.py:233: FutureWarning: Private attribute access ('Selection._current') in this context (e.g. inside a plugin widget or dock widget) is deprecated and will be unavailable in version 0.5.0\n", - " layer = self._viewer.layers.selection._current\n", - "\u001b[32m2023-08-23 17:12:32.800\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "\u001b[32m2023-08-23 17:12:32.801\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36mnapari_spatialdata._view\u001b[0m:\u001b[36m_on_layer_update\u001b[0m:\u001b[36m221\u001b[0m - \u001b[1mUpdating layer.\u001b[0m\n", - "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=320.924,627.538 gbl=320.924,627.538 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-320.924,-627.538 last=-320.924,-627.538 Δ 320.924,627.538) : no target window\n", - "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=320.924,627.538 gbl=320.924,627.538 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-320.924,-627.538 last=-320.924,-627.538 Δ 320.924,627.538) : no target window\n", - "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=527.994,830.858 gbl=527.994,830.858 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-527.994,-830.858 last=-527.994,-830.858 Δ 527.994,830.858) : no target window\n", - "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=527.994,830.858 gbl=527.994,830.858 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-527.994,-830.858 last=-527.994,-830.858 Δ 527.994,830.858) : no target window\n", - "WARNING: skipping QEventPoint(id=1 ts=0 pos=0,0 scn=640.64,527.409 gbl=640.64,527.409 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-640.64,-527.409 last=-640.64,-527.409 Δ 640.64,527.409) : no target window\n", - "WARNING:vispy:skipping QEventPoint(id=1 ts=0 pos=0,0 scn=640.64,527.409 gbl=640.64,527.409 Released ellipse=(1x1 ∡ 0) vel=0,0 press=-640.64,-527.409 last=-640.64,-527.409 Δ 640.64,527.409) : no target window\n" - ] - } - ], "source": [ "from napari_spatialdata import Interactive\n", "\n", diff --git a/notebooks/developers_resources/storage_format/transformation_translation.ipynb b/notebooks/developers_resources/storage_format/transformation_translation.ipynb index b8e386c..f489dc0 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_translation.ipynb @@ -170,7 +170,7 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from transformation_translation.zarr to \n", - " \u001b[35m/tmp/tmpnxta4qob/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmp4phbwf2q/\u001b[0m\u001b[95mtransformation_translation2.zarr\u001b[0m \n" ] } ], From f797d965515807097035b79bb7b809222b4d6e4a Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 18:30:18 +0200 Subject: [PATCH 11/25] autorun: storage format; spatialdata from fa096da (v0.0.12) --- .../storage_format/multiple_elements.ipynb | 12 +- .../points.parquet/part.0.parquet | Bin 6226 -> 6094 bytes .../multiple_elements.zarr/zmetadata | 1407 ----------------- .../transformation_affine.ipynb | 4 +- .../points.parquet/part.0.parquet | Bin 5936 -> 5736 bytes .../transformation_affine.zarr/zmetadata | 214 --- .../transformation_identity.ipynb | 4 +- .../points.parquet/part.0.parquet | Bin 5936 -> 5736 bytes .../transformation_identity.zarr/zmetadata | 182 --- .../storage_format/transformation_scale.ipynb | 4 +- .../points.parquet/part.0.parquet | Bin 5936 -> 5736 bytes .../transformation_scale.zarr/zmetadata | 191 --- .../transformation_sequence.ipynb | 2 +- .../points.parquet/part.0.parquet | Bin 5936 -> 5736 bytes .../transformation_sequence.zarr/zmetadata | 352 ----- .../transformation_translation.ipynb | 2 +- .../points.parquet/part.0.parquet | Bin 5936 -> 5736 bytes .../transformation_translation.zarr/zmetadata | 191 --- 18 files changed, 14 insertions(+), 2551 deletions(-) delete mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata delete mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata delete mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata delete mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata delete mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata delete mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index e4747ad..1661757 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -133,8 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] }, { @@ -142,15 +142,15 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", - " \u001b[35m/tmp/tmpapfx6khv/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpmvkgspfo/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] } ], @@ -192,7 +192,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/points.parquet/part.0.parquet index f8b0606b86efd179a47e754b1357ef6f0f828a8e..cdea2197ab868c930dd33b6708678c9dcee2e4bc 100644 GIT binary patch delta 1221 zcmb``OGp%P9Ki9J*_mk{j;^{h`*3Z2tdp8=S5Vp1b+=4Q(#7>bR0?J$6&eZJpR?D_9Ymu;c#wWSA7F-upn(tbxc&a$-%KRDjdvH= zoQXWm4>SA&kc6n%MH9iCoCpA+AR0u05D*7qKoIZ+i69;bz#l{c zAFv1P1qNUOVIT<@K`eJjPV9yU9Y_WdKm$}D9GHO~qyRr)0X$FwEl_iEYap?HB}hur z7@D&2rjsi-o&+LNzU8ZwLz>(^E!lF_WU8M=G2w6(*A?nym4?BxPm{6Ic*1c{Wm#X^ z^m1eNIMKtHdsEZru2^nm?GA4~`!UJJzI08^*(##W72V74@6dR%vJX_9J{8gXZ6g15 z^1%tI=Z-o(s(*j0+3I-Z@3nW**YfU`)E+Il_@Jrg%Xs~pU+U_PIHxzS=4!2#SH42bn{8!#}0w{8Yni|F2b+cDzC8NjWZT(R9Jtq`2DOaw)LU zYkT5w*~^XddI#m?9#`wfyk>*bW+*GPRI$x!q2=$9Z-bC+Lq+BokwliQ7iW+&)F7@@WeE9HLzK L89va#JyZS$oOtQ< delta 1334 zcmb``eMl2=9LMpy-EF%~XKQ-bIj338)3kD_^P$Ylo`*(QVWo+b1qM=kPRv%qR*ESh7|aRgV(t2zu)ikzQ>7A9PXua z@~4ZucvCM9a=Bu)$XFPrpW}6mfn_Ee^gI(`5*QOqfN3xlqQMElFdf2SBG@1uQo#a2 zFa@-b01g-j;~^1dnA`$m#X|-pK_rMU31)&3;y@2$AO)g;12fn`0SRV779@iJVUP)9 zK?Ct%fLI6x7D8}>%rxfDM?UPcO~@MhA+Ud+BqmM>_*XS^;c7IibK8AgDIS0J;S}fc z^=pC~SG`QFh|)0e1AXFFf5TwKc) z7tG7wc&)9sXGQzPuw{N%?So4H{9DeFb*=_}`R%^))2~kT=9&BU)<+}@rEeaZx)WD> zEG%D3(aN~=XqV=c(_N`~qGr4*HS^Fv1QyslBDo*;aj`V9BPC zRp!zv=ANaoF!^3i*>l~IK>3#;@Bt?*Z#&|{3RpW1;nfz4% diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata deleted file mode 100644 index 02f0faf..0000000 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata +++ /dev/null @@ -1,1407 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "type": "identity" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 64, - 64 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": "" ] diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/points.parquet/part.0.parquet index 53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c..d06d555661e93f98eceb06dad48e17ea9b3e8ca5 100644 GIT binary patch delta 906 zcmdm>_d=&Wz%j^BltuIaqiBVXsDvnk5CcO33pWENBZD9(I|~CpF9!n;5DNgY5D<$1 zu`m$x0WmKxhYc441c<_E(OZn74;XbsCoqc&h_Z>Y$w+X(Bqcat%EcHoAfjwQeL&&K z6IdkcLsLxJRT8EJXq9S&bZ1lrd2%zVrwNyrPjaymTIN#FID2)vwnO(Mj__1%rr?bo z8bve1wE{|2v?ekXnhTpw*Pf`bD3Ynfd)kUAk_KBPtsOM21-CixWH3|c%4prSDlB4_ z+COF)Q5H#40R}cn3C0RhCb0?3VmnyGzA>xKV^mY+!0%M3OYd+=)nf#hFet$IK>-E| zAW%SY1F*BgZ}h=j2>t}IAUZCGd$oZTp5!MK@W zoAZhS=7}!CoYQwoWi;)o=1gz!5}sm`SnU>K6m76krE#`~L1B4{ly^x)=5o;mf>Srn zUZ^m|q?%b}MJ7Y^?C2$dMoK#i+%~tew5ab;TgQnMWR=K4c20v$Z3io{VK%vzIhJV= z&*VGIGOY8s)n0LJ{>#kA$kZY@nU__GbqSx^BHqdSxa~FDq36#q>A%PhmJhUOo8Y+e!K7W<2iKA}b47z+DZ6mjRuVYd2H&-@wEEx~dy*gm;CtYKcv(_7L2UT^znxlhyrlhpSGns|UyZ9RyJ*kVBvja-#<<^( z$RnQ1`9?n*Kb2OU78v%@Q&pqq%jo=VZEd1|%2M3uyL&H`I^I&?bfp)#doNU2K38|! zU;5plMrudR#Mkn;W$#eOiJPq5G5e-+`0!X}eP>=|Vt;mg)#-(rlG_h@)iL9WP7NzM zsR3SX(r;RCDD4S#kQy*+*9C=rY*N38T2N5568a0}kJ2WD1b)b(4oL7eUUTqBGaEJ! z1{fzpwb-@qTrxYCpe`b9E8m^F=EeD!dt=M{+hFUQ%SNlKhKgNlAa(UDy9{!d1Ma=b M$xq`4`wh>8ABV=?pa1{> diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata deleted file mode 100644 index edfd783..0000000 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata +++ /dev/null @@ -1,214 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "affine": [ - [ - 1.0, - 0.0, - 0.0, - 0.0 - ], - [ - 0.0, - 2.0, - 1.0, - 3.0 - ], - [ - 0.0, - 5.0, - 4.0, - 6.0 - ] - ], - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "type": "affine" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 32, - 32 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": "" ] diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/points.parquet/part.0.parquet index 53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c..d06d555661e93f98eceb06dad48e17ea9b3e8ca5 100644 GIT binary patch delta 906 zcmdm>_d=&Wz%j^BltuIaqiBVXsDvnk5CcO33pWENBZD9(I|~CpF9!n;5DNgY5D<$1 zu`m$x0WmKxhYc441c<_E(OZn74;XbsCoqc&h_Z>Y$w+X(Bqcat%EcHoAfjwQeL&&K z6IdkcLsLxJRT8EJXq9S&bZ1lrd2%zVrwNyrPjaymTIN#FID2)vwnO(Mj__1%rr?bo z8bve1wE{|2v?ekXnhTpw*Pf`bD3Ynfd)kUAk_KBPtsOM21-CixWH3|c%4prSDlB4_ z+COF)Q5H#40R}cn3C0RhCb0?3VmnyGzA>xKV^mY+!0%M3OYd+=)nf#hFet$IK>-E| zAW%SY1F*BgZ}h=j2>t}IAUZCGd$oZTp5!MK@W zoAZhS=7}!CoYQwoWi;)o=1gz!5}sm`SnU>K6m76krE#`~L1B4{ly^x)=5o;mf>Srn zUZ^m|q?%b}MJ7Y^?C2$dMoK#i+%~tew5ab;TgQnMWR=K4c20v$Z3io{VK%vzIhJV= z&*VGIGOY8s)n0LJ{>#kA$kZY@nU__GbqSx^BHqdSxa~FDq36#q>A%PhmJhUOo8Y+e!K7W<2iKA}b47z+DZ6mjRuVYd2H&-@wEEx~dy*gm;CtYKcv(_7L2UT^znxlhyrlhpSGns|UyZ9RyJ*kVBvja-#<<^( z$RnQ1`9?n*Kb2OU78v%@Q&pqq%jo=VZEd1|%2M3uyL&H`I^I&?bfp)#doNU2K38|! zU;5plMrudR#Mkn;W$#eOiJPq5G5e-+`0!X}eP>=|Vt;mg)#-(rlG_h@)iL9WP7NzM zsR3SX(r;RCDD4S#kQy*+*9C=rY*N38T2N5568a0}kJ2WD1b)b(4oL7eUUTqBGaEJ! z1{fzpwb-@qTrxYCpe`b9E8m^F=EeD!dt=M{+hFUQ%SNlKhKgNlAa(UDy9{!d1Ma=b M$xq`4`wh>8ABV=?pa1{> diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata deleted file mode 100644 index d47caf5..0000000 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata +++ /dev/null @@ -1,182 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "type": "identity" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 32, - 32 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": "" ] diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/points.parquet/part.0.parquet b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/points.parquet/part.0.parquet index 53a3c3e98edd9c3b2b6f10e8194e680f4eeb4c6c..d06d555661e93f98eceb06dad48e17ea9b3e8ca5 100644 GIT binary patch delta 906 zcmdm>_d=&Wz%j^BltuIaqiBVXsDvnk5CcO33pWENBZD9(I|~CpF9!n;5DNgY5D<$1 zu`m$x0WmKxhYc441c<_E(OZn74;XbsCoqc&h_Z>Y$w+X(Bqcat%EcHoAfjwQeL&&K z6IdkcLsLxJRT8EJXq9S&bZ1lrd2%zVrwNyrPjaymTIN#FID2)vwnO(Mj__1%rr?bo z8bve1wE{|2v?ekXnhTpw*Pf`bD3Ynfd)kUAk_KBPtsOM21-CixWH3|c%4prSDlB4_ z+COF)Q5H#40R}cn3C0RhCb0?3VmnyGzA>xKV^mY+!0%M3OYd+=)nf#hFet$IK>-E| zAW%SY1F*BgZ}h=j2>t}IAUZCGd$oZTp5!MK@W zoAZhS=7}!CoYQwoWi;)o=1gz!5}sm`SnU>K6m76krE#`~L1B4{ly^x)=5o;mf>Srn zUZ^m|q?%b}MJ7Y^?C2$dMoK#i+%~tew5ab;TgQnMWR=K4c20v$Z3io{VK%vzIhJV= z&*VGIGOY8s)n0LJ{>#kA$kZY@nU__GbqSx^BHqdSxa~FDq36#q>A%PhmJhUOo8Y+e!K7W<2iKA}b47z+DZ6mjRuVYd2H&-@wEEx~dy*gm;CtYKcv(_7L2UT^znxlhyrlhpSGns|UyZ9RyJ*kVBvja-#<<^( z$RnQ1`9?n*Kb2OU78v%@Q&pqq%jo=VZEd1|%2M3uyL&H`I^I&?bfp)#doNU2K38|! zU;5plMrudR#Mkn;W$#eOiJPq5G5e-+`0!X}eP>=|Vt;mg)#-(rlG_h@)iL9WP7NzM zsR3SX(r;RCDD4S#kQy*+*9C=rY*N38T2N5568a0}kJ2WD1b)b(4oL7eUUTqBGaEJ! z1{fzpwb-@qTrxYCpe`b9E8m^F=EeD!dt=M{+hFUQ%SNlKhKgNlAa(UDy9{!d1Ma=b M$xq`4`wh>8ABV=?pa1{> diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata deleted file mode 100644 index 9f69a9b..0000000 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata +++ /dev/null @@ -1,191 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "scale": [ - 1.0, - 1.0, - 2.0 - ], - "type": "scale" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 32, - 32 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": "_d=&Wz%j^BltuIaqiBVXsDvnk5CcO33pWENBZD9(I|~CpF9!n;5DNgY5D<$1 zu`m$x0WmKxhYc441c<_E(OZn74;XbsCoqc&h_Z>Y$w+X(Bqcat%EcHoAfjwQeL&&K z6IdkcLsLxJRT8EJXq9S&bZ1lrd2%zVrwNyrPjaymTIN#FID2)vwnO(Mj__1%rr?bo z8bve1wE{|2v?ekXnhTpw*Pf`bD3Ynfd)kUAk_KBPtsOM21-CixWH3|c%4prSDlB4_ z+COF)Q5H#40R}cn3C0RhCb0?3VmnyGzA>xKV^mY+!0%M3OYd+=)nf#hFet$IK>-E| zAW%SY1F*BgZ}h=j2>t}IAUZCGd$oZTp5!MK@W zoAZhS=7}!CoYQwoWi;)o=1gz!5}sm`SnU>K6m76krE#`~L1B4{ly^x)=5o;mf>Srn zUZ^m|q?%b}MJ7Y^?C2$dMoK#i+%~tew5ab;TgQnMWR=K4c20v$Z3io{VK%vzIhJV= z&*VGIGOY8s)n0LJ{>#kA$kZY@nU__GbqSx^BHqdSxa~FDq36#q>A%PhmJhUOo8Y+e!K7W<2iKA}b47z+DZ6mjRuVYd2H&-@wEEx~dy*gm;CtYKcv(_7L2UT^znxlhyrlhpSGns|UyZ9RyJ*kVBvja-#<<^( z$RnQ1`9?n*Kb2OU78v%@Q&pqq%jo=VZEd1|%2M3uyL&H`I^I&?bfp)#doNU2K38|! zU;5plMrudR#Mkn;W$#eOiJPq5G5e-+`0!X}eP>=|Vt;mg)#-(rlG_h@)iL9WP7NzM zsR3SX(r;RCDD4S#kQy*+*9C=rY*N38T2N5568a0}kJ2WD1b)b(4oL7eUUTqBGaEJ! z1{fzpwb-@qTrxYCpe`b9E8m^F=EeD!dt=M{+hFUQ%SNlKhKgNlAa(UDy9{!d1Ma=b M$xq`4`wh>8ABV=?pa1{> diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata deleted file mode 100644 index 282b1df..0000000 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata +++ /dev/null @@ -1,352 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "transformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "translation": [ - 0.0, - 30.0, - 10.0 - ], - "type": "translation" - }, - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "scale": [ - 1.0, - 0.5, - 2.0 - ], - "type": "scale" - } - ], - "type": "sequence" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 32, - 32 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": "_d=&Wz%j^BltuIaqiBVXsDvnk5CcO33pWENBZD9(I|~CpF9!n;5DNgY5D<$1 zu`m$x0WmKxhYc441c<_E(OZn74;XbsCoqc&h_Z>Y$w+X(Bqcat%EcHoAfjwQeL&&K z6IdkcLsLxJRT8EJXq9S&bZ1lrd2%zVrwNyrPjaymTIN#FID2)vwnO(Mj__1%rr?bo z8bve1wE{|2v?ekXnhTpw*Pf`bD3Ynfd)kUAk_KBPtsOM21-CixWH3|c%4prSDlB4_ z+COF)Q5H#40R}cn3C0RhCb0?3VmnyGzA>xKV^mY+!0%M3OYd+=)nf#hFet$IK>-E| zAW%SY1F*BgZ}h=j2>t}IAUZCGd$oZTp5!MK@W zoAZhS=7}!CoYQwoWi;)o=1gz!5}sm`SnU>K6m76krE#`~L1B4{ly^x)=5o;mf>Srn zUZ^m|q?%b}MJ7Y^?C2$dMoK#i+%~tew5ab;TgQnMWR=K4c20v$Z3io{VK%vzIhJV= z&*VGIGOY8s)n0LJ{>#kA$kZY@nU__GbqSx^BHqdSxa~FDq36#q>A%PhmJhUOo8Y+e!K7W<2iKA}b47z+DZ6mjRuVYd2H&-@wEEx~dy*gm;CtYKcv(_7L2UT^znxlhyrlhpSGns|UyZ9RyJ*kVBvja-#<<^( z$RnQ1`9?n*Kb2OU78v%@Q&pqq%jo=VZEd1|%2M3uyL&H`I^I&?bfp)#doNU2K38|! zU;5plMrudR#Mkn;W$#eOiJPq5G5e-+`0!X}eP>=|Vt;mg)#-(rlG_h@)iL9WP7NzM zsR3SX(r;RCDD4S#kQy*+*9C=rY*N38T2N5568a0}kJ2WD1b)b(4oL7eUUTqBGaEJ! z1{fzpwb-@qTrxYCpe`b9E8m^F=EeD!dt=M{+hFUQ%SNlKhKgNlAa(UDy9{!d1Ma=b M$xq`4`wh>8ABV=?pa1{> diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata deleted file mode 100644 index 112efe7..0000000 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata +++ /dev/null @@ -1,191 +0,0 @@ -{ - "metadata": { - ".zgroup": { - "zarr_format": 2 - }, - "images/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/.zattrs": { - "channels_metadata": { - "channels": [ - { - "label": 0 - }, - { - "label": 1 - }, - { - "label": 2 - } - ] - }, - "multiscales": [ - { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space" - }, - { - "name": "x", - "type": "space" - } - ], - "coordinateTransformations": [ - { - "input": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "cyx" - }, - "output": { - "axes": [ - { - "name": "c", - "type": "channel" - }, - { - "name": "y", - "type": "space", - "unit": "unit" - }, - { - "name": "x", - "type": "space", - "unit": "unit" - } - ], - "name": "global" - }, - "translation": [ - 0.0, - 0.0, - 100.0 - ], - "type": "translation" - } - ], - "datasets": [ - { - "coordinateTransformations": [ - { - "scale": [ - 1.0, - 1.0, - 1.0 - ], - "type": "scale" - } - ], - "path": "0" - } - ], - "name": "/images/blobs_image", - "version": "0.4" - } - ] - }, - "images/blobs_image/.zgroup": { - "zarr_format": 2 - }, - "images/blobs_image/0/.zarray": { - "chunks": [ - 3, - 32, - 32 - ], - "compressor": { - "blocksize": 0, - "clevel": 5, - "cname": "lz4", - "id": "blosc", - "shuffle": 1 - }, - "dimension_separator": "/", - "dtype": " Date: Wed, 23 Aug 2023 19:04:28 +0200 Subject: [PATCH 12/25] fix readme --- .../storage_format/Readme.md | 31 +++++++------------ 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index bb7ae5b..df35cef 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -9,30 +9,23 @@ This repository addresses the need for communicating the storage specification t ## What this repository contains This directory contains notebooks that operate on lightweight datasets. - Each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks. -- All the notebooks are run every 24h. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. -- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit. -- The notebooks are run daily against both the latest `release` and the latest `main` versions of the `spatialdata` library. -- The corresponding produced data is available in the current directory, in different commits. Specifically, `release` data is tagged and both `release` and `main` data have the commit message `autorun: storage format`). -- The data is also uploaded at these two S3 location (latest) [release](https://s3.embl.de/spatialdata/developers_resources/storage_format/release) and (latest) [main](https://s3.embl.de/spatialdata/developers_resources/storage_format/main). +- All the notebooks are run every 24h against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. +- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: + - `autorun: storage format; spatialdata from al29fak` + - `autorun: storage format; spatialdata from fa096da (v0.0.12)` +- The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. +- The data is also [uploaded to S3](https://s3.embl.de/spatialdata/developers_resources/storage_format). ## How to use this repository -Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, is guaranteed to run correctly on any SpatialData dataset. +Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. We recommend the following. -- Implement your readers on the latest `release` version of the data; you can checkout it with the following command (run from the current folder): -```bash -git checkout $(git describe --tags --abbrev=0) -# TODO: test the command -``` -- Set up an automated test (e.g. daily) that downloads the latest `release` (with the above command) and runs your reader on it. Optionally you can also run your tool against the latest `main` version of the data (`git checkout`) -- If your reader fails, you can check the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, to compare the current release with the latest release you can use the following command (run from the current folder): -```bash -git diff \ - $(git rev-list -n 1 $(git describe --tags --abbrev=0)) \ - $(git rev-list -n 1 main) -- data -# TODO: test the command -``` +- Implement your readers on the data from the latest run available (look for the latest commit with message `autorun: storage format; ...`). +- Set up an automated test (e.g. daily) that performs a `git pull` to get the latest converted data and to run your code on it. +- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 ## Important technical notes - The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). - The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). +- Please keep in mind that the data that we generate daily are produced against the latest `main` and not the latest release. This means that in the event of a format change (which should anyway happen less and less frequently as the frameworks become more mature), this does not immediately translate into a bug for the user. In fact, the user will still be using the latest release version for a while, giving time to developers to update the tools before the users are affected. +- When the format will become more mature we will provide converters between previous version of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata. From 9e2adc61f7a0eb2c086a81d39af31c43aeba0ee4 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 19:23:47 +0200 Subject: [PATCH 13/25] index.html --- .../storage_format/Readme.md | 2 +- .../storage_format/index.html | 25 + .../storage_format/io_utils.py | 43 +- .../storage_format/multiple_elements.ipynb | 10 +- .../multiple_elements.zarr/zmetadata | 1407 +++++++++++++++++ .../transformation_affine.ipynb | 2 +- .../transformation_affine.zarr/zmetadata | 214 +++ .../transformation_identity.ipynb | 2 +- .../transformation_identity.zarr/zmetadata | 182 +++ .../storage_format/transformation_scale.ipynb | 2 +- .../transformation_scale.zarr/zmetadata | 191 +++ .../transformation_sequence.ipynb | 2 +- .../transformation_sequence.zarr/zmetadata | 352 +++++ .../transformation_translation.ipynb | 2 +- .../transformation_translation.zarr/zmetadata | 191 +++ 15 files changed, 2615 insertions(+), 12 deletions(-) create mode 100644 notebooks/developers_resources/storage_format/index.html create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata create mode 100644 notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index df35cef..62e06e7 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -14,7 +14,7 @@ This directory contains notebooks that operate on lightweight datasets. - `autorun: storage format; spatialdata from al29fak` - `autorun: storage format; spatialdata from fa096da (v0.0.12)` - The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. -- The data is also [uploaded to S3](https://s3.embl.de/spatialdata/developers_resources/storage_format). +- The data is also [uploaded to S3](https://s3.embl.de/spatialdata/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. ## How to use this repository Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. diff --git a/notebooks/developers_resources/storage_format/index.html b/notebooks/developers_resources/storage_format/index.html new file mode 100644 index 0000000..6502950 --- /dev/null +++ b/notebooks/developers_resources/storage_format/index.html @@ -0,0 +1,25 @@ + + + + Index + + + + + + + + + + + + + + + +
    ElementLinkZip
    transformation_scaletransformation_scale.zarrtransformation_scale.zarr.zip
    transformation_identitytransformation_identity.zarrtransformation_identity.zarr.zip
    multiple_elementsmultiple_elements.zarrmultiple_elements.zarr.zip
    transformation_translationtransformation_translation.zarrtransformation_translation.zarr.zip
    transformation_sequencetransformation_sequence.zarrtransformation_sequence.zarr.zip
    transformation_affinetransformation_affine.zarrtransformation_affine.zarr.zip
    +## Note +Opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `.zgroup` to any of the URLs above you will be able to see that file. + + + \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py index 3e8929c..5b468aa 100644 --- a/notebooks/developers_resources/storage_format/io_utils.py +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -4,6 +4,7 @@ import zarr from ome_zarr.io import parse_url import tempfile +import shutil def delete_old_data(name: str) -> None: f1 = f'{name}.zarr' @@ -54,4 +55,44 @@ def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: sdata2 = sd.read_zarr(f1) f2 = os.path.join(tmpdir, f'{name}2.zarr') sdata2.write(f2) - assert _are_directories_identical(f1, f2) \ No newline at end of file + assert _are_directories_identical(f1, f2) + + shutil.make_archive(f1, 'zip', f1) + +def make_index_html(elements: list[str]) -> None: + # Define the beginning of the HTML string + html = """ + + + Index + + + + + + + + + """ + + BASE_URL = 'https://s3.embl.de/spatialdata/developers_resources/storage_format/' + + # Populate the HTML string with table data + for element in elements: + html += f"\n" + + # Close the HTML string + html += """ +
    ElementLinkZip
    {element}{element}.zarr{element}.zarr.zip
    +Note: opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the .zarr URLs above you will be able to see that file. + + + """ + + # Write the HTML string to a file + with open("index.html", "w") as file: + file.write(html) + +if __name__ == '__main__': + notebooks = [f.replace('.ipynb', '') for f in os.listdir() if f.endswith('.ipynb') and f != '__template__.ipynb'] + make_index_html(notebooks) \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index 1661757..2881ac2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -133,8 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] }, { @@ -142,15 +142,15 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", - " \u001b[35m/tmp/tmpmvkgspfo/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpv1cupwu1/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] } ], diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata new file mode 100644 index 0000000..02f0faf --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata @@ -0,0 +1,1407 @@ +{ + "metadata": { + ".zgroup": { + "zarr_format": 2 + }, + "images/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/.zattrs": { + "channels_metadata": { + "channels": [ + { + "label": 0 + }, + { + "label": 1 + }, + { + "label": 2 + } + ] + }, + "multiscales": [ + { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space" + }, + { + "name": "x", + "type": "space" + } + ], + "coordinateTransformations": [ + { + "input": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "cyx" + }, + "output": { + "axes": [ + { + "name": "c", + "type": "channel" + }, + { + "name": "y", + "type": "space", + "unit": "unit" + }, + { + "name": "x", + "type": "space", + "unit": "unit" + } + ], + "name": "global" + }, + "type": "identity" + } + ], + "datasets": [ + { + "coordinateTransformations": [ + { + "scale": [ + 1.0, + 1.0, + 1.0 + ], + "type": "scale" + } + ], + "path": "0" + } + ], + "name": "/images/blobs_image", + "version": "0.4" + } + ] + }, + "images/blobs_image/.zgroup": { + "zarr_format": 2 + }, + "images/blobs_image/0/.zarray": { + "chunks": [ + 3, + 64, + 64 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": " Date: Wed, 23 Aug 2023 19:26:17 +0200 Subject: [PATCH 14/25] fix readmes --- datasets/README.md | 24 +++++++++---------- .../storage_format/Readme.md | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/datasets/README.md b/datasets/README.md index 3dbe187..a434f03 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -6,19 +6,19 @@ Here you can find the dataset hosted in S3 object storage. | Dataset | .zarr.zip | S3 (see note below!) | |:------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| -| cosmx_io | | | -| mcmicro_io | | | -| merfish | | | -| mibitof | | | -| steinbock_io | | | -| toy | | | -| visium | | | -| visium_io | | | -| visium_associated_xenium_io | | | -| xenium_rep1_io | | | -| xenium_rep2_io | | | +| cosmx_io | | | +| mcmicro_io | | | +| merfish | | | +| mibitof | | | +| steinbock_io | | | +| toy | | | +| visium | | | +| visium_io | | | +| visium_associated_xenium_io | | | +| xenium_rep1_io | | | +| xenium_rep2_io | | | | [additional resources for methods developers](../notebooks/developers_resources/storage_format/) | - | - | ## Note -Opening the above URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `.zgroup` to any of the URLs above you will be able to see that file. +Opening the above URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the `.zarr` URLs above you will be able to see that file. diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index 62e06e7..71b016c 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -8,7 +8,7 @@ This repository addresses the need for communicating the storage specification t ## What this repository contains This directory contains notebooks that operate on lightweight datasets. -- Each notebook covers a particular aspect of the storage specification and all the edge cases of the specification are covered in at least one of the notebooks. +- Each notebook covers a particular aspect of the storage specification and ~~all the~~ *the main (work in progress)* edge cases of the specification are covered in at least one of the notebooks. - All the notebooks are run every 24h against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. - The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: - `autorun: storage format; spatialdata from al29fak` From c0977a60de81b1b6d41313cb8a3d205cb59df0ca Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 19:33:45 +0200 Subject: [PATCH 15/25] fix readme --- notebooks/developers_resources/storage_format/Readme.md | 6 +++--- notebooks/developers_resources/storage_format/index.html | 3 +-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index 71b016c..2d20eb9 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -14,15 +14,15 @@ This directory contains notebooks that operate on lightweight datasets. - `autorun: storage format; spatialdata from al29fak` - `autorun: storage format; spatialdata from fa096da (v0.0.12)` - The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. -- The data is also [uploaded to S3](https://s3.embl.de/spatialdata/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. +- The data is also [uploaded to S3](index.html), both as Zarr directories and as zipped files. ## How to use this repository Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. We recommend the following. - Implement your readers on the data from the latest run available (look for the latest commit with message `autorun: storage format; ...`). -- Set up an automated test (e.g. daily) that performs a `git pull` to get the latest converted data and to run your code on it. -- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification and update your reader accordingly; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 +- Set up an automated test (e.g. daily) that gets the latest converted data (you can use a `git pull` or download the data from S3) and runs your code on it. +- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 ## Important technical notes - The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). diff --git a/notebooks/developers_resources/storage_format/index.html b/notebooks/developers_resources/storage_format/index.html index 6502950..887d991 100644 --- a/notebooks/developers_resources/storage_format/index.html +++ b/notebooks/developers_resources/storage_format/index.html @@ -18,8 +18,7 @@ transformation_affine    transformation_affine.zarrtransformation_affine.zarr.zip -## Note -Opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `.zgroup` to any of the URLs above you will be able to see that file. +Note: opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the .zarr URLs above you will be able to see that file. \ No newline at end of file From aed6644334b8f6df7d27114e271465ee1fd2f526 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 19:34:47 +0200 Subject: [PATCH 16/25] preview html --- notebooks/developers_resources/storage_format/Readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index 2d20eb9..ec6c37b 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -14,7 +14,7 @@ This directory contains notebooks that operate on lightweight datasets. - `autorun: storage format; spatialdata from al29fak` - `autorun: storage format; spatialdata from fa096da (v0.0.12)` - The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. -- The data is also [uploaded to S3](index.html), both as Zarr directories and as zipped files. +- The data is also [uploaded to S3](https://refined-github-html-preview.kidonng.workers.dev/scverse/spatialdata-notebooks/raw/dev_notebooks/notebooks/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. ## How to use this repository Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. From c31df08defff26ba707e152ded4fd0b0d721592a Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 19:36:45 +0200 Subject: [PATCH 17/25] fix --- notebooks/developers_resources/storage_format/Readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index ec6c37b..bf7c325 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -28,4 +28,4 @@ We recommend the following. - The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). - The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). - Please keep in mind that the data that we generate daily are produced against the latest `main` and not the latest release. This means that in the event of a format change (which should anyway happen less and less frequently as the frameworks become more mature), this does not immediately translate into a bug for the user. In fact, the user will still be using the latest release version for a while, giving time to developers to update the tools before the users are affected. -- When the format will become more mature we will provide converters between previous version of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata. +- When the format will become more mature we will provide converters between previous versions of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata and relatively small conversions of the geometries. From a9c9c4f0704b77f0d0f993a23d44c60d759c3f3d Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Wed, 23 Aug 2023 19:38:57 +0200 Subject: [PATCH 18/25] fix readme --- notebooks/developers_resources/storage_format/Readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index bf7c325..cc7eeee 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -9,7 +9,7 @@ This repository addresses the need for communicating the storage specification t ## What this repository contains This directory contains notebooks that operate on lightweight datasets. - Each notebook covers a particular aspect of the storage specification and ~~all the~~ *the main (work in progress)* edge cases of the specification are covered in at least one of the notebooks. -- All the notebooks are run every 24h against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. +- All the notebooks are run every 24h (work in progress, automatic run temporarily disabled) against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. - The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: - `autorun: storage format; spatialdata from al29fak` - `autorun: storage format; spatialdata from fa096da (v0.0.12)` From db5240e88689e6db79571180ad895626bf1f23a4 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 23 Aug 2023 17:41:56 +0000 Subject: [PATCH 19/25] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- datasets/README.md | 6 +- .../storage_format/Readme.md | 36 ++--- .../storage_format/__template__.ipynb | 2 +- .../storage_format/index.html | 124 +++++++++++++++--- .../storage_format/io_utils.py | 43 +++--- .../storage_format/multiple_elements.ipynb | 16 ++- .../multiple_elements.zarr/.zgroup | 2 +- .../multiple_elements.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/.zattrs | 2 +- .../images/blobs_multiscale_image/.zgroup | 2 +- .../images/blobs_multiscale_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/1/.zarray | 2 +- .../images/blobs_multiscale_image/2/.zarray | 2 +- .../multiple_elements.zarr/labels/.zattrs | 2 +- .../multiple_elements.zarr/labels/.zgroup | 2 +- .../labels/blobs_labels/.zattrs | 2 +- .../labels/blobs_labels/.zgroup | 2 +- .../labels/blobs_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/.zattrs | 2 +- .../labels/blobs_multiscale_labels/.zgroup | 2 +- .../labels/blobs_multiscale_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/1/.zarray | 2 +- .../labels/blobs_multiscale_labels/2/.zarray | 2 +- .../multiple_elements.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../multiple_elements.zarr/shapes/.zgroup | 2 +- .../shapes/blobs_circles/.zattrs | 2 +- .../shapes/blobs_circles/.zgroup | 2 +- .../shapes/blobs_circles/Index/.zarray | 2 +- .../shapes/blobs_circles/coords/.zarray | 2 +- .../shapes/blobs_circles/radius/.zarray | 2 +- .../shapes/blobs_multipolygons/.zattrs | 2 +- .../shapes/blobs_multipolygons/.zgroup | 2 +- .../shapes/blobs_multipolygons/Index/.zarray | 2 +- .../shapes/blobs_multipolygons/coords/.zarray | 2 +- .../blobs_multipolygons/offset0/.zarray | 2 +- .../blobs_multipolygons/offset1/.zarray | 2 +- .../blobs_multipolygons/offset2/.zarray | 2 +- .../shapes/blobs_polygons/.zattrs | 2 +- .../shapes/blobs_polygons/.zgroup | 2 +- .../shapes/blobs_polygons/Index/.zarray | 2 +- .../shapes/blobs_polygons/coords/.zarray | 2 +- .../shapes/blobs_polygons/offset0/.zarray | 2 +- .../shapes/blobs_polygons/offset1/.zarray | 2 +- .../multiple_elements.zarr/table/.zgroup | 2 +- .../table/table/.zattrs | 2 +- .../table/table/.zgroup | 2 +- .../table/table/X/.zattrs | 2 +- .../table/table/X/.zgroup | 2 +- .../table/table/X/indices/.zarray | 2 +- .../table/table/X/indptr/.zarray | 2 +- .../table/table/layers/.zattrs | 2 +- .../table/table/layers/.zgroup | 2 +- .../table/table/obs/.zattrs | 2 +- .../table/table/obs/.zgroup | 2 +- .../table/table/obs/_index/.zarray | 2 +- .../table/table/obs/_index/.zattrs | 2 +- .../table/table/obs/instance_id/.zarray | 2 +- .../table/table/obs/instance_id/.zattrs | 2 +- .../table/table/obs/region/.zattrs | 2 +- .../table/table/obs/region/.zgroup | 2 +- .../table/table/obs/region/categories/.zarray | 2 +- .../table/table/obs/region/categories/.zattrs | 2 +- .../table/table/obs/region/codes/.zarray | 2 +- .../table/table/obs/region/codes/.zattrs | 2 +- .../table/table/obsm/.zattrs | 2 +- .../table/table/obsm/.zgroup | 2 +- .../table/table/obsp/.zattrs | 2 +- .../table/table/obsp/.zgroup | 2 +- .../table/table/uns/.zattrs | 2 +- .../table/table/uns/.zgroup | 2 +- .../table/table/uns/spatialdata_attrs/.zattrs | 2 +- .../table/table/uns/spatialdata_attrs/.zgroup | 2 +- .../spatialdata_attrs/instance_key/.zarray | 2 +- .../spatialdata_attrs/instance_key/.zattrs | 2 +- .../uns/spatialdata_attrs/region/.zarray | 2 +- .../uns/spatialdata_attrs/region/.zattrs | 2 +- .../uns/spatialdata_attrs/region_key/.zarray | 2 +- .../uns/spatialdata_attrs/region_key/.zattrs | 2 +- .../table/table/var/.zattrs | 2 +- .../table/table/var/.zgroup | 2 +- .../table/table/var/_index/.zarray | 2 +- .../table/table/var/_index/.zattrs | 2 +- .../table/table/varm/.zattrs | 2 +- .../table/table/varm/.zgroup | 2 +- .../table/table/varp/.zattrs | 2 +- .../table/table/varp/.zgroup | 2 +- .../multiple_elements.zarr/zmetadata | 2 +- .../transformation_affine.ipynb | 20 +-- .../transformation_affine.zarr/.zgroup | 2 +- .../transformation_affine.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../transformation_affine.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_affine.zarr/zmetadata | 2 +- .../transformation_identity.ipynb | 8 +- .../transformation_identity.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_identity.zarr/zmetadata | 2 +- .../storage_format/transformation_scale.ipynb | 4 +- .../transformation_scale.zarr/.zgroup | 2 +- .../transformation_scale.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../transformation_scale.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_scale.zarr/zmetadata | 2 +- .../transformation_sequence.ipynb | 4 +- .../transformation_sequence.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_sequence.zarr/zmetadata | 2 +- .../transformation_translation.ipynb | 4 +- .../transformation_translation.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_translation.zarr/zmetadata | 2 +- 142 files changed, 315 insertions(+), 214 deletions(-) diff --git a/datasets/README.md b/datasets/README.md index a434f03..3343808 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -4,8 +4,8 @@ The example notebooks operate on a set of spatial omics datasets that can be dow Here you can find the dataset hosted in S3 object storage. -| Dataset | .zarr.zip | S3 (see note below!) | -|:------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| +| Dataset | .zarr.zip | S3 (see note below!) | +| :----------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------: | | cosmx_io | | | | mcmicro_io | | | | merfish | | | @@ -17,7 +17,7 @@ Here you can find the dataset hosted in S3 object storage. | visium_associated_xenium_io | | | | xenium_rep1_io | | | | xenium_rep2_io | | | -| [additional resources for methods developers](../notebooks/developers_resources/storage_format/) | - | - | +| [additional resources for methods developers](../notebooks/developers_resources/storage_format/) | - | - | ## Note diff --git a/notebooks/developers_resources/storage_format/Readme.md b/notebooks/developers_resources/storage_format/Readme.md index cc7eeee..2db0581 100644 --- a/notebooks/developers_resources/storage_format/Readme.md +++ b/notebooks/developers_resources/storage_format/Readme.md @@ -3,29 +3,35 @@ This directory offers comprehensive resources for developers that want to interface their methods with the SpatialData format in a robust way. ## Why this repository -The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses *some* less-documented features of the OME-NGFF specification that are still [under review](https://github.com/ome/ngff/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc), or experimental storage strategies that will be eventually discussed with the NGFF community. + +The file storage format adopted by SpatialData is built on top of the latest version of the well-documented [OME-NGFF specification](https://ngff.openmicroscopy.org/latest/index.html), but it also uses _some_ less-documented features of the OME-NGFF specification that are still [under review](https://github.com/ome/ngff/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc), or experimental storage strategies that will be eventually discussed with the NGFF community. This repository addresses the need for communicating the storage specification to other developers in a complete and robust way. ## What this repository contains + This directory contains notebooks that operate on lightweight datasets. -- Each notebook covers a particular aspect of the storage specification and ~~all the~~ *the main (work in progress)* edge cases of the specification are covered in at least one of the notebooks. -- All the notebooks are run every 24h (work in progress, automatic run temporarily disabled) against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. -- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: - - `autorun: storage format; spatialdata from al29fak` - - `autorun: storage format; spatialdata from fa096da (v0.0.12)` -- The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. -- The data is also [uploaded to S3](https://refined-github-html-preview.kidonng.workers.dev/scverse/spatialdata-notebooks/raw/dev_notebooks/notebooks/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. + +- Each notebook covers a particular aspect of the storage specification and ~~all the~~ _the main (work in progress)_ edge cases of the specification are covered in at least one of the notebooks. +- All the notebooks are run every 24h (work in progress, automatic run temporarily disabled) against the `main` branch of the `spatialdata` repository. Each notebook creates a dataset, writes it to disk, reloads it in memory, rewrites it to disk to check for consistency, reloads it again in memory and plots it. +- The disk storage is committed to GitHub so that the output of each daily run is associated to a commit, the commit message is "autorun: storage format; spatialdata from ". Examples of commit messages are: + - `autorun: storage format; spatialdata from al29fak` + - `autorun: storage format; spatialdata from fa096da (v0.0.12)` +- The `.zarr` data produced by every run is available in the current directory, in the commit corresponding to the run. +- The data is also [uploaded to S3](https://refined-github-html-preview.kidonng.workers.dev/scverse/spatialdata-notebooks/raw/dev_notebooks/notebooks/developers_resources/storage_format/index.html), both as Zarr directories and as zipped files. ## How to use this repository + Practically, a third party tool (e.g. R reader, format converter, JavaScript data visualizer, etc.) that runs correctly on the lightweight datasets from this repository, should be guaranteed to run correctly on any SpatialData dataset. We recommend the following. -- Implement your readers on the data from the latest run available (look for the latest commit with message `autorun: storage format; ...`). -- Set up an automated test (e.g. daily) that gets the latest converted data (you can use a `git pull` or download the data from S3) and runs your code on it. -- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 + +- Implement your readers on the data from the latest run available (look for the latest commit with message `autorun: storage format; ...`). +- Set up an automated test (e.g. daily) that gets the latest converted data (you can use a `git pull` or download the data from S3) and runs your code on it. +- If your reader fails, you can inspect the corresponding commit in this repository to see what has changed in the storage specification; in particular, you may find useful to compare different commits using the GitHub compare function, accessible with the following syntax: https://github.com/scverse/spatialdata-notebooks/compare/267adb1..5847084 ## Important technical notes -- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). -- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). -- Please keep in mind that the data that we generate daily are produced against the latest `main` and not the latest release. This means that in the event of a format change (which should anyway happen less and less frequently as the frameworks become more mature), this does not immediately translate into a bug for the user. In fact, the user will still be using the latest release version for a while, giving time to developers to update the tools before the users are affected. -- When the format will become more mature we will provide converters between previous versions of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata and relatively small conversions of the geometries. + +- The most crucial part of the metadata is stored, for each spatial element, in the `.zattr` file. [Example](transformation_identity.zarr/images/blobs_image/.zattrs). +- The `zmetadata` in the root folder stores redundant information and is used for storage systems that do not support `ls` operations (e.g. S3). [Example](transformation_identity.zarr/zmetadata). +- Please keep in mind that the data that we generate daily are produced against the latest `main` and not the latest release. This means that in the event of a format change (which should anyway happen less and less frequently as the frameworks become more mature), this does not immediately translate into a bug for the user. In fact, the user will still be using the latest release version for a while, giving time to developers to update the tools before the users are affected. +- When the format will become more mature we will provide converters between previous versions of the format. Luckily, heavy data like images and labels are stable from NGFF v0.4, therefore the converters will mostly perform lightweight conversions of the metadata and relatively small conversions of the geometries. diff --git a/notebooks/developers_resources/storage_format/__template__.ipynb b/notebooks/developers_resources/storage_format/__template__.ipynb index 6e74e0e..44bd797 100644 --- a/notebooks/developers_resources/storage_format/__template__.ipynb +++ b/notebooks/developers_resources/storage_format/__template__.ipynb @@ -40,7 +40,7 @@ "metadata": {}, "outputs": [], "source": [ - "NAME = 'name_of_the_notebook'" + "NAME = \"name_of_the_notebook\"" ] }, { diff --git a/notebooks/developers_resources/storage_format/index.html b/notebooks/developers_resources/storage_format/index.html index 887d991..1d4f176 100644 --- a/notebooks/developers_resources/storage_format/index.html +++ b/notebooks/developers_resources/storage_format/index.html @@ -1,24 +1,108 @@ - - + - Index + Index - - - - - - - - - - - - - -
    ElementLinkZip
    transformation_scaletransformation_scale.zarrtransformation_scale.zarr.zip
    transformation_identitytransformation_identity.zarrtransformation_identity.zarr.zip
    multiple_elementsmultiple_elements.zarrmultiple_elements.zarr.zip
    transformation_translationtransformation_translation.zarrtransformation_translation.zarr.zip
    transformation_sequencetransformation_sequence.zarrtransformation_sequence.zarr.zip
    transformation_affinetransformation_affine.zarrtransformation_affine.zarr.zip
    -Note: opening the above .zarr URLs in a web browser would not work, you need to treat the URLs as Zarr stores. For example if you append `/.zgroup` to any of the .zarr URLs above you will be able to see that file. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    ElementLinkZip
    transformation_scale + transformation_scale.zarr + + transformation_scale.zarr.zip +
    transformation_identity + transformation_identity.zarr + + transformation_identity.zarr.zip +
    multiple_elements + multiple_elements.zarr + + multiple_elements.zarr.zip +
    transformation_translation + transformation_translation.zarr + + transformation_translation.zarr.zip +
    transformation_sequence + transformation_sequence.zarr + + transformation_sequence.zarr.zip +
    transformation_affine + transformation_affine.zarr + + transformation_affine.zarr.zip +
    + Note: opening the above .zarr URLs in a web browser would not work, you + need to treat the URLs as Zarr stores. For example if you append + `/.zgroup` to any of the .zarr URLs above you will be able to see that + file. - - \ No newline at end of file + diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py index 5b468aa..7b6948a 100644 --- a/notebooks/developers_resources/storage_format/io_utils.py +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -1,18 +1,20 @@ -from spatialdata._io._utils import _are_directories_identical -import spatialdata as sd import os +import shutil +import tempfile + +import spatialdata as sd import zarr from ome_zarr.io import parse_url -import tempfile -import shutil +from spatialdata._io._utils import _are_directories_identical + def delete_old_data(name: str) -> None: - f1 = f'{name}.zarr' + f1 = f"{name}.zarr" if os.path.isdir(f1): store = parse_url(f1, mode="w").store root = zarr.group(store=store, overwrite=True) store.close() - os.remove(os.path.join(f1, '.zgroup')) + os.remove(os.path.join(f1, ".zgroup")) os.rmdir(f1) """ Safely delete an old Zarr store, it if exists. @@ -20,13 +22,14 @@ def delete_old_data(name: str) -> None: name : str The name of the file (without extension) to write to and read from. """ - + + def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: """ Write SpatialData instance to file, reload it, and check for consistency. This function writes the input `sdata` to a file using the specified `name`.zarr. - The data is then reloaded from the file and written again, and the two outputs + The data is then reloaded from the file and written again, and the two outputs folders are compared recursively and binary wise, to check for the consistency of the read-write operations. @@ -47,17 +50,18 @@ def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: >>> write_sdata_and_check_consistency(sdata, 'testfile') # will create testfile.zarr """ - f1 = f'{name}.zarr' + f1 = f"{name}.zarr" assert not os.path.exists(f1) sdata.write(f1) - + with tempfile.TemporaryDirectory() as tmpdir: sdata2 = sd.read_zarr(f1) - f2 = os.path.join(tmpdir, f'{name}2.zarr') + f2 = os.path.join(tmpdir, f"{name}2.zarr") sdata2.write(f2) assert _are_directories_identical(f1, f2) - shutil.make_archive(f1, 'zip', f1) + shutil.make_archive(f1, "zip", f1) + def make_index_html(elements: list[str]) -> None: # Define the beginning of the HTML string @@ -75,12 +79,12 @@ def make_index_html(elements: list[str]) -> None: """ - BASE_URL = 'https://s3.embl.de/spatialdata/developers_resources/storage_format/' - + BASE_URL = "https://s3.embl.de/spatialdata/developers_resources/storage_format/" + # Populate the HTML string with table data for element in elements: html += f"{element}{element}.zarr{element}.zarr.zip\n" - + # Close the HTML string html += """ @@ -88,11 +92,12 @@ def make_index_html(elements: list[str]) -> None: """ - + # Write the HTML string to a file with open("index.html", "w") as file: file.write(html) -if __name__ == '__main__': - notebooks = [f.replace('.ipynb', '') for f in os.listdir() if f.endswith('.ipynb') and f != '__template__.ipynb'] - make_index_html(notebooks) \ No newline at end of file + +if __name__ == "__main__": + notebooks = [f.replace(".ipynb", "") for f in os.listdir() if f.endswith(".ipynb") and f != "__template__.ipynb"] + make_index_html(notebooks) diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index 2881ac2..2858465 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -51,7 +51,7 @@ "metadata": {}, "outputs": [], "source": [ - "NAME = 'multiple_elements'" + "NAME = \"multiple_elements\"" ] }, { @@ -107,8 +107,8 @@ "source": [ "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=64)\n", @@ -202,7 +202,9 @@ } ], "source": [ - "sdata.pl.render_images('blobs_image').pl.render_labels('blobs_labels').pl.render_points('blobs_points', na_color='w').pl.show()" + "sdata.pl.render_images(\"blobs_image\").pl.render_labels(\"blobs_labels\").pl.render_points(\n", + " \"blobs_points\", na_color=\"w\"\n", + ").pl.show()" ] }, { @@ -361,7 +363,7 @@ } ], "source": [ - "sdata.pl.render_labels('blobs_labels', color='channel_0_sum').pl.show()" + "sdata.pl.render_labels(\"blobs_labels\", color=\"channel_0_sum\").pl.show()" ] }, { @@ -390,7 +392,7 @@ } ], "source": [ - "sdata.pl.render_shapes('blobs_circles', fill_alpha=0.5).pl.show()" + "sdata.pl.render_shapes(\"blobs_circles\", fill_alpha=0.5).pl.show()" ] }, { @@ -411,7 +413,7 @@ } ], "source": [ - "sdata.pl.render_shapes('blobs_polygons').pl.show()" + "sdata.pl.render_shapes(\"blobs_polygons\").pl.show()" ] }, { @@ -432,7 +434,7 @@ } ], "source": [ - "sdata.pl.render_shapes('blobs_multipolygons').pl.show()" + "sdata.pl.render_shapes(\"blobs_multipolygons\").pl.show()" ] } ], diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs index 75d8a18..dbec22e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs @@ -90,4 +90,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray index 37dfbfc..08f0a41 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs index cd2bc87..fc3e6dd 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs @@ -116,4 +116,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray index 37dfbfc..08f0a41 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray index cdeee2a..92446ef 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray @@ -22,4 +22,4 @@ 16 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs index 90c6a5d..94ec98f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs @@ -3,4 +3,4 @@ "blobs_labels", "blobs_multiscale_labels" ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs index 1be5678..9e47e76 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs @@ -67,4 +67,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray index 00ce34c..784c320 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs index eb666af..242c42f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs @@ -91,4 +91,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray index 00ce34c..784c320 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray index 3f12448..814fc75 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray @@ -20,4 +20,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray index 1373fa1..92f43d7 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray @@ -20,4 +20,4 @@ 16 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs index 50b68d4..3c27423 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs @@ -41,4 +41,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs index a8cb6fc..32831c8 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray index 11f83d7..587511e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs index dbcdf7f..cf683ab 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray index 6f767bd..97aaf24 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray index 908fd0c..f7f6352 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray index 908fd0c..f7f6352 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs index 204ea77..521c9a3 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray index a97e38f..4f02ddb 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs index 6e9445e..33ffa12 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs @@ -6,4 +6,4 @@ "region_key": "region", "spatialdata-encoding-type": "ngff:regions_table", "version": "0.1" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs index 59901f8..c528b61 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs @@ -5,4 +5,4 @@ 10, 3 ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray index 50f4374..a24717f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray @@ -18,4 +18,4 @@ 30 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray index 3ed4552..2d58283 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs index 4419949..8f96ebc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs @@ -6,4 +6,4 @@ ], "encoding-type": "dataframe", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray index 8ddc86e..f54362a 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray @@ -22,4 +22,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray index 61786cf..50970c8 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray @@ -18,4 +18,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs index 2b8d6d9..ecdb601 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs index 198a2dd..2dbe306 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs @@ -2,4 +2,4 @@ "encoding-type": "categorical", "encoding-version": "0.2.0", "ordered": false -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray index 7b6a20f..23873b0 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray @@ -22,4 +22,4 @@ 1 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray index 2f626d2..5430d04 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray @@ -18,4 +18,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs index 2b8d6d9..ecdb601 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray index bef650f..47f1efc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray index 673b378..6297f30 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray index 5f8af9e..ff79b02 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs index 7c9c5f9..67cac68 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs @@ -3,4 +3,4 @@ "column-order": [], "encoding-type": "dataframe", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray index 2abe5a8..1cffc94 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray @@ -22,4 +22,4 @@ 3 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata index 02f0faf..cb1894a 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata @@ -1404,4 +1404,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.ipynb b/notebooks/developers_resources/storage_format/transformation_affine.ipynb index 75e0f52..ab480da 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_affine.ipynb @@ -35,7 +35,7 @@ "metadata": {}, "outputs": [], "source": [ - "NAME = 'transformation_affine'" + "NAME = \"transformation_affine\"" ] }, { @@ -60,15 +60,15 @@ } ], "source": [ + "import numpy as np\n", "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", - "import numpy as np\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=32)\n", - "sdata = sd.SpatialData(images={'blobs_image': sdata['blobs_image']}, points={'blobs_points': sdata['blobs_points']})" + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})" ] }, { @@ -105,9 +105,13 @@ ], "source": [ "matrix = np.array([[1, 2, 3], [4, 5, 6], [0, 0, 1]])\n", - "affine = sd.transformations.Affine(matrix=matrix, input_axes=('x', 'y'), output_axes=('x', 'y'))\n", - "sd.transformations.set_transformation(element=sdata['blobs_image'], transformation=affine, to_coordinate_system='global')\n", - "sd.transformations.set_transformation(element=sdata['blobs_points'], transformation=affine, to_coordinate_system='global')\n", + "affine = sd.transformations.Affine(matrix=matrix, input_axes=(\"x\", \"y\"), output_axes=(\"x\", \"y\"))\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_image\"], transformation=affine, to_coordinate_system=\"global\"\n", + ")\n", + "sd.transformations.set_transformation(\n", + " element=sdata[\"blobs_points\"], transformation=affine, to_coordinate_system=\"global\"\n", + ")\n", "sdata" ] }, @@ -174,7 +178,7 @@ } ], "source": [ - "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" ] }, { diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs index 964245a..e36d6d4 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs @@ -110,4 +110,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs index 976c318..600e416 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs @@ -53,4 +53,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata index edfd783..a41d5cd 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata @@ -211,4 +211,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.ipynb b/notebooks/developers_resources/storage_format/transformation_identity.ipynb index 224a70e..4c7c592 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_identity.ipynb @@ -35,7 +35,7 @@ "metadata": {}, "outputs": [], "source": [ - "NAME = 'transformation_identity'" + "NAME = \"transformation_identity\"" ] }, { @@ -79,12 +79,12 @@ "source": [ "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=32)\n", - "sdata = sd.SpatialData(images={'blobs_image': sdata['blobs_image']}, points={'blobs_points': sdata['blobs_points']})\n", + "sdata = sd.SpatialData(images={\"blobs_image\": sdata[\"blobs_image\"]}, points={\"blobs_points\": sdata[\"blobs_points\"]})\n", "sdata" ] }, @@ -151,7 +151,7 @@ } ], "source": [ - "sdata.pl.render_images().pl.render_points(na_color='w').pl.show()" + "sdata.pl.render_images().pl.render_points(na_color=\"w\").pl.show()" ] } ], diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs index 75d8a18..dbec22e 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs @@ -90,4 +90,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs index 50b68d4..3c27423 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs @@ -41,4 +41,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata index d47caf5..8d7806c 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata @@ -179,4 +179,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.ipynb b/notebooks/developers_resources/storage_format/transformation_scale.ipynb index fe97cfe..9376dc2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_scale.ipynb @@ -97,11 +97,11 @@ } ], "source": [ + "import numpy as np\n", "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", - "import numpy as np\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=32)\n", diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs index b064678..a7d80df 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs @@ -95,4 +95,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs index f1e1747..dd0d1f8 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs @@ -45,4 +45,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata index 9f69a9b..4224fa8 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata @@ -188,4 +188,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.ipynb b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb index 3d2bd26..9252f0f 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_sequence.ipynb @@ -97,11 +97,11 @@ } ], "source": [ + "import numpy as np\n", "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", - "import numpy as np\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=32)\n", diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs index 247659c..ce42fb6 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs @@ -184,4 +184,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs index ab90cb2..d4631e3 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs @@ -117,4 +117,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata index 282b1df..e5c2f5f 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata @@ -349,4 +349,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.ipynb b/notebooks/developers_resources/storage_format/transformation_translation.ipynb index da8381b..514b3be 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.ipynb +++ b/notebooks/developers_resources/storage_format/transformation_translation.ipynb @@ -97,11 +97,11 @@ } ], "source": [ + "import numpy as np\n", "import spatialdata as sd\n", "import spatialdata_plot\n", - "from spatialdata.datasets import blobs\n", "from io_utils import delete_old_data, write_sdata_and_check_consistency\n", - "import numpy as np\n", + "from spatialdata.datasets import blobs\n", "\n", "delete_old_data(name=NAME)\n", "sdata = blobs(length=32)\n", diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs index 14364cb..ff754fc 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs @@ -95,4 +95,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs index 50788d7..581b179 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs @@ -45,4 +45,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata index 112efe7..c98e0cc 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata @@ -188,4 +188,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} From 7fed5c86b36a4dfa63b8d0fb5831b55d376bddea Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Thu, 24 Aug 2023 00:38:04 +0200 Subject: [PATCH 20/25] fix pre-commit --- conf.py | 2 + datasets/README.md | 28 ++++----- .../storage_format/io_utils.py | 60 ++++++++++++------- 3 files changed, 53 insertions(+), 37 deletions(-) diff --git a/conf.py b/conf.py index c0e43e9..a7e8a41 100644 --- a/conf.py +++ b/conf.py @@ -107,6 +107,8 @@ "notebooks/paper_reproducibility", "notebooks/examples/*.zarr" "references.md", "Readme.md", # hack cause git his acting up + "notebooks/developers_resources/storage_format/*.ipynb", + "notebooks/developers_resources/storage_format/Readme.md" ] # Ignore warnings. nitpicky = False # TODO: solve upstream. diff --git a/datasets/README.md b/datasets/README.md index a434f03..23826b2 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -4,20 +4,20 @@ The example notebooks operate on a set of spatial omics datasets that can be dow Here you can find the dataset hosted in S3 object storage. -| Dataset | .zarr.zip | S3 (see note below!) | -|:------------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| -| cosmx_io | | | -| mcmicro_io | | | -| merfish | | | -| mibitof | | | -| steinbock_io | | | -| toy | | | -| visium | | | -| visium_io | | | -| visium_associated_xenium_io | | | -| xenium_rep1_io | | | -| xenium_rep2_io | | | -| [additional resources for methods developers](../notebooks/developers_resources/storage_format/) | - | - | +| Dataset | .zarr.zip | S3 (see note below!) | +|:----------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| +| cosmx_io | | | +| mcmicro_io | | | +| merfish | | | +| mibitof | | | +| steinbock_io | | | +| toy | | | +| visium | | | +| visium_io | | | +| visium_associated_xenium_io | | | +| xenium_rep1_io | | | +| xenium_rep2_io | | | +| [additional resources for methods developers](https://github.com/scverse/spatialdata-notebooks/blob/main/notebooks/notebooks/developers_resources/storage_format/) | - | - | ## Note diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py index 5b468aa..156e362 100644 --- a/notebooks/developers_resources/storage_format/io_utils.py +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -6,35 +6,39 @@ import tempfile import shutil + def delete_old_data(name: str) -> None: - f1 = f'{name}.zarr' - if os.path.isdir(f1): - store = parse_url(f1, mode="w").store - root = zarr.group(store=store, overwrite=True) - store.close() - os.remove(os.path.join(f1, '.zgroup')) - os.rmdir(f1) """ Safely delete an old Zarr store, it if exists. - name : str + Parameters + ---------- + name The name of the file (without extension) to write to and read from. """ - + f1 = f"{name}.zarr" + if os.path.isdir(f1): + store = parse_url(f1, mode="w").store + _ = zarr.group(store=store, overwrite=True) + store.close() + os.remove(os.path.join(f1, ".zgroup")) + os.rmdir(f1) + + def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: """ Write SpatialData instance to file, reload it, and check for consistency. This function writes the input `sdata` to a file using the specified `name`.zarr. - The data is then reloaded from the file and written again, and the two outputs + The data is then reloaded from the file and written again, and the two outputs folders are compared recursively and binary wise, to check for the consistency of the read-write operations. Parameters ---------- - sdata : sd.SpatialData + sdata The SpatialData instance to be written to a file. - name : str + name The name of the file to write to and read from. Returns @@ -47,19 +51,28 @@ def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: >>> write_sdata_and_check_consistency(sdata, 'testfile') # will create testfile.zarr """ - f1 = f'{name}.zarr' + f1 = f"{name}.zarr" assert not os.path.exists(f1) sdata.write(f1) - + with tempfile.TemporaryDirectory() as tmpdir: sdata2 = sd.read_zarr(f1) - f2 = os.path.join(tmpdir, f'{name}2.zarr') + f2 = os.path.join(tmpdir, f"{name}2.zarr") sdata2.write(f2) assert _are_directories_identical(f1, f2) - shutil.make_archive(f1, 'zip', f1) + shutil.make_archive(f1, "zip", f1) + def make_index_html(elements: list[str]) -> None: + """ + Make an index.html file which links to the data produced by the notebook and uploaded to S3. + + Parameters + ---------- + elements + name of the data from the notebooks, to be included in the index.html file + """ # Define the beginning of the HTML string html = """ @@ -75,12 +88,12 @@ def make_index_html(elements: list[str]) -> None: """ - BASE_URL = 'https://s3.embl.de/spatialdata/developers_resources/storage_format/' - + BASE_URL = "https://s3.embl.de/spatialdata/developers_resources/storage_format/" + # Populate the HTML string with table data for element in elements: html += f"{element}{element}.zarr{element}.zarr.zip\n" - + # Close the HTML string html += """ @@ -88,11 +101,12 @@ def make_index_html(elements: list[str]) -> None: """ - + # Write the HTML string to a file with open("index.html", "w") as file: file.write(html) -if __name__ == '__main__': - notebooks = [f.replace('.ipynb', '') for f in os.listdir() if f.endswith('.ipynb') and f != '__template__.ipynb'] - make_index_html(notebooks) \ No newline at end of file + +if __name__ == "__main__": + notebooks = [f.replace(".ipynb", "") for f in os.listdir() if f.endswith(".ipynb") and f != "__template__.ipynb"] + make_index_html(notebooks) From ff574cef0857de37075c7fc60943a0e3b98c778c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 23 Aug 2023 22:40:21 +0000 Subject: [PATCH 21/25] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- conf.py | 2 +- datasets/README.md | 29 +++++++++---------- .../storage_format/io_utils.py | 1 - 3 files changed, 15 insertions(+), 17 deletions(-) diff --git a/conf.py b/conf.py index a7e8a41..0cd1f1e 100644 --- a/conf.py +++ b/conf.py @@ -108,7 +108,7 @@ "notebooks/examples/*.zarr" "references.md", "Readme.md", # hack cause git his acting up "notebooks/developers_resources/storage_format/*.ipynb", - "notebooks/developers_resources/storage_format/Readme.md" + "notebooks/developers_resources/storage_format/Readme.md", ] # Ignore warnings. nitpicky = False # TODO: solve upstream. diff --git a/datasets/README.md b/datasets/README.md index 62d86a9..141cf6b 100644 --- a/datasets/README.md +++ b/datasets/README.md @@ -4,21 +4,20 @@ The example notebooks operate on a set of spatial omics datasets that can be dow Here you can find the dataset hosted in S3 object storage. -| Dataset | .zarr.zip | S3 (see note below!) | -|:----------------------------------------------------------------------------------------------:|:------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------:| -| cosmx_io | | | -| mcmicro_io | | | -| merfish | | | -| mibitof | | | -| steinbock_io | | | -| toy | | | -| visium | | | -| visium_io | | | -| visium_associated_xenium_io | | | -| xenium_rep1_io | | | -| xenium_rep2_io | | | -| [additional resources for methods developers](https://github.com/scverse/spatialdata-notebooks/blob/main/notebooks/notebooks/developers_resources/storage_format/) | - | - | - +| Dataset | .zarr.zip | S3 (see note below!) | +| :----------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------: | +| cosmx_io | | | +| mcmicro_io | | | +| merfish | | | +| mibitof | | | +| steinbock_io | | | +| toy | | | +| visium | | | +| visium_io | | | +| visium_associated_xenium_io | | | +| xenium_rep1_io | | | +| xenium_rep2_io | | | +| [additional resources for methods developers](https://github.com/scverse/spatialdata-notebooks/blob/main/notebooks/notebooks/developers_resources/storage_format/) | - | - | ## Note diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py index 0418a52..d67f582 100644 --- a/notebooks/developers_resources/storage_format/io_utils.py +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -8,7 +8,6 @@ from spatialdata._io._utils import _are_directories_identical - def delete_old_data(name: str) -> None: """ Safely delete an old Zarr store, it if exists. From 283598d7965d8c486973a231acedd5468539ba52 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Thu, 24 Aug 2023 00:42:55 +0200 Subject: [PATCH 22/25] fix pre-commit --- notebooks/developers_resources/storage_format/io_utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/notebooks/developers_resources/storage_format/io_utils.py b/notebooks/developers_resources/storage_format/io_utils.py index 0418a52..a02ccfe 100644 --- a/notebooks/developers_resources/storage_format/io_utils.py +++ b/notebooks/developers_resources/storage_format/io_utils.py @@ -52,7 +52,6 @@ def write_sdata_and_check_consistency(sdata: sd.SpatialData, name: str) -> None: >>> sdata = sd.SpatialData() # assume SpatialData instance is created >>> write_sdata_and_check_consistency(sdata, 'testfile') # will create testfile.zarr """ - f1 = f"{name}.zarr" assert not os.path.exists(f1) sdata.write(f1) From c082a78a1bc2b4399e2b312787d947581ccf95f6 Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Tue, 19 Sep 2023 10:17:05 +0200 Subject: [PATCH 23/25] table data was missing (gitignore) --- notebooks/developers_resources/.gitignore | 1 + .../storage_format/multiple_elements.ipynb | 10 ++++----- .../multiple_elements.zarr/.zgroup | 2 +- .../multiple_elements.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/.zattrs | 2 +- .../images/blobs_multiscale_image/.zgroup | 2 +- .../images/blobs_multiscale_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/1/.zarray | 2 +- .../images/blobs_multiscale_image/2/.zarray | 2 +- .../multiple_elements.zarr/labels/.zattrs | 2 +- .../multiple_elements.zarr/labels/.zgroup | 2 +- .../labels/blobs_labels/.zattrs | 2 +- .../labels/blobs_labels/.zgroup | 2 +- .../labels/blobs_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/.zattrs | 2 +- .../labels/blobs_multiscale_labels/.zgroup | 2 +- .../labels/blobs_multiscale_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/1/.zarray | 2 +- .../labels/blobs_multiscale_labels/2/.zarray | 2 +- .../multiple_elements.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../multiple_elements.zarr/shapes/.zgroup | 2 +- .../shapes/blobs_circles/.zattrs | 2 +- .../shapes/blobs_circles/.zgroup | 2 +- .../shapes/blobs_circles/Index/.zarray | 2 +- .../shapes/blobs_circles/coords/.zarray | 2 +- .../shapes/blobs_circles/radius/.zarray | 2 +- .../shapes/blobs_multipolygons/.zattrs | 2 +- .../shapes/blobs_multipolygons/.zgroup | 2 +- .../shapes/blobs_multipolygons/Index/.zarray | 2 +- .../shapes/blobs_multipolygons/coords/.zarray | 2 +- .../blobs_multipolygons/offset0/.zarray | 2 +- .../blobs_multipolygons/offset1/.zarray | 2 +- .../blobs_multipolygons/offset2/.zarray | 2 +- .../shapes/blobs_polygons/.zattrs | 2 +- .../shapes/blobs_polygons/.zgroup | 2 +- .../shapes/blobs_polygons/Index/.zarray | 2 +- .../shapes/blobs_polygons/coords/.zarray | 2 +- .../shapes/blobs_polygons/offset0/.zarray | 2 +- .../shapes/blobs_polygons/offset1/.zarray | 2 +- .../multiple_elements.zarr/table/.zgroup | 2 +- .../table/table/.zattrs | 2 +- .../table/table/.zgroup | 2 +- .../table/table/X/.zattrs | 2 +- .../table/table/X/.zgroup | 2 +- .../table/table/X/data/.zarray | 21 ++++++++++++++++++ .../table/table/X/data/0 | Bin 0 -> 256 bytes .../table/table/X/indices/.zarray | 2 +- .../table/table/X/indptr/.zarray | 2 +- .../table/table/layers/.zattrs | 2 +- .../table/table/layers/.zgroup | 2 +- .../table/table/obs/.zattrs | 2 +- .../table/table/obs/.zgroup | 2 +- .../table/table/obs/_index/.zarray | 2 +- .../table/table/obs/_index/.zattrs | 2 +- .../table/table/obs/instance_id/.zarray | 2 +- .../table/table/obs/instance_id/.zattrs | 2 +- .../table/table/obs/region/.zattrs | 2 +- .../table/table/obs/region/.zgroup | 2 +- .../table/table/obs/region/categories/.zarray | 2 +- .../table/table/obs/region/categories/.zattrs | 2 +- .../table/table/obs/region/codes/.zarray | 2 +- .../table/table/obs/region/codes/.zattrs | 2 +- .../table/table/obsm/.zattrs | 2 +- .../table/table/obsm/.zgroup | 2 +- .../table/table/obsp/.zattrs | 2 +- .../table/table/obsp/.zgroup | 2 +- .../table/table/uns/.zattrs | 2 +- .../table/table/uns/.zgroup | 2 +- .../table/table/uns/spatialdata_attrs/.zattrs | 2 +- .../table/table/uns/spatialdata_attrs/.zgroup | 2 +- .../spatialdata_attrs/instance_key/.zarray | 2 +- .../spatialdata_attrs/instance_key/.zattrs | 2 +- .../uns/spatialdata_attrs/region/.zarray | 2 +- .../uns/spatialdata_attrs/region/.zattrs | 2 +- .../uns/spatialdata_attrs/region_key/.zarray | 2 +- .../uns/spatialdata_attrs/region_key/.zattrs | 2 +- .../table/table/var/.zattrs | 2 +- .../table/table/var/.zgroup | 2 +- .../table/table/var/_index/.zarray | 2 +- .../table/table/var/_index/.zattrs | 2 +- .../table/table/varm/.zattrs | 2 +- .../table/table/varm/.zgroup | 2 +- .../table/table/varp/.zattrs | 2 +- .../table/table/varp/.zgroup | 2 +- .../multiple_elements.zarr/zmetadata | 2 +- .../transformation_affine.ipynb | 2 +- .../transformation_affine.zarr/.zgroup | 2 +- .../transformation_affine.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../transformation_affine.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_affine.zarr/zmetadata | 2 +- .../transformation_identity.ipynb | 2 +- .../transformation_identity.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_identity.zarr/zmetadata | 2 +- .../storage_format/transformation_scale.ipynb | 2 +- .../transformation_scale.zarr/.zgroup | 2 +- .../transformation_scale.zarr/images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../transformation_scale.zarr/points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_scale.zarr/zmetadata | 2 +- .../transformation_sequence.ipynb | 2 +- .../transformation_sequence.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_sequence.zarr/zmetadata | 2 +- .../transformation_translation.ipynb | 2 +- .../transformation_translation.zarr/.zgroup | 2 +- .../images/.zgroup | 2 +- .../images/blobs_image/.zattrs | 2 +- .../images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../points/.zgroup | 2 +- .../points/blobs_points/.zattrs | 2 +- .../points/blobs_points/.zgroup | 2 +- .../transformation_translation.zarr/zmetadata | 2 +- 140 files changed, 163 insertions(+), 141 deletions(-) create mode 100644 notebooks/developers_resources/.gitignore create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray create mode 100644 notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/0 diff --git a/notebooks/developers_resources/.gitignore b/notebooks/developers_resources/.gitignore new file mode 100644 index 0000000..d0e8fdb --- /dev/null +++ b/notebooks/developers_resources/.gitignore @@ -0,0 +1 @@ +!data/ diff --git a/notebooks/developers_resources/storage_format/multiple_elements.ipynb b/notebooks/developers_resources/storage_format/multiple_elements.ipynb index 2858465..d052fe5 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.ipynb +++ b/notebooks/developers_resources/storage_format/multiple_elements.ipynb @@ -133,8 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] }, { @@ -142,15 +142,15 @@ "output_type": "stream", "text": [ "\u001b[34mINFO \u001b[0m The Zarr file used for backing will now change from multiple_elements.zarr to \n", - " \u001b[35m/tmp/tmpv1cupwu1/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" + " \u001b[35m/tmp/tmpbxulxg2m/\u001b[0m\u001b[95mmultiple_elements2.zarr\u001b[0m \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "no parent found for : None\n", - "no parent found for : None\n" + "no parent found for : None\n", + "no parent found for : None\n" ] } ], diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs index dbec22e..75d8a18 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs @@ -90,4 +90,4 @@ "version": "0.4" } ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray index 08f0a41..37dfbfc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs index fc3e6dd..cd2bc87 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs @@ -116,4 +116,4 @@ "version": "0.4" } ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray index 08f0a41..37dfbfc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray index 8e38e52..f245000 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray index 92446ef..cdeee2a 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray @@ -22,4 +22,4 @@ 16 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs index 94ec98f..90c6a5d 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs @@ -3,4 +3,4 @@ "blobs_labels", "blobs_multiscale_labels" ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs index 9e47e76..1be5678 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs @@ -67,4 +67,4 @@ "version": "0.4" } ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray index 784c320..00ce34c 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs index 242c42f..eb666af 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs @@ -91,4 +91,4 @@ "version": "0.4" } ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray index 784c320..00ce34c 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray index 814fc75..3f12448 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray @@ -20,4 +20,4 @@ 32 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray index 92f43d7..1373fa1 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray @@ -20,4 +20,4 @@ 16 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs index 3c27423..50b68d4 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs @@ -41,4 +41,4 @@ "instance_key": "instance_id", "version": "0.1" } -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs index 32831c8..a8cb6fc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray index 558908e..ed01e15 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray index 587511e..11f83d7 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray index 558908e..ed01e15 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs index cf683ab..dbcdf7f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray index 558908e..ed01e15 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray index 97aaf24..6f767bd 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray index f7f6352..908fd0c 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray index f7f6352..908fd0c 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray index a5998d9..96d00b5 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs index 521c9a3..204ea77 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray index 558908e..ed01e15 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray index 4f02ddb..a97e38f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray index a5998d9..96d00b5 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray index a5998d9..96d00b5 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs index 33ffa12..6e9445e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs @@ -6,4 +6,4 @@ "region_key": "region", "spatialdata-encoding-type": "ngff:regions_table", "version": "0.1" -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs index c528b61..59901f8 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs @@ -5,4 +5,4 @@ 10, 3 ] -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup index 3f3fad2..3b7daf2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} +} \ No newline at end of file diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray new file mode 100644 index 0000000..9730452 --- /dev/null +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray @@ -0,0 +1,21 @@ +{ + "chunks": [ + 30 + ], + "compressor": { + "blocksize": 0, + "clevel": 5, + "cname": "lz4", + "id": "blosc", + "shuffle": 1 + }, + "dimension_separator": "/", + "dtype": "2!T(S$SFXrLebj_@CiV>1G!d;vk^clcp;%u4kkc=o}ff~#0x;> zlcM64u^ zc?>{`6;#(p9_Bv`e53EECPY9)mE#t?>OeqK!p%HcYDqw0c{+L!)XYC4q6c_o1p+|5 zF_fGQOJYB$z4u7CX7fLwnGaKzdE`HLx(_;u4zNE}6f3L^EF3_Ve#lf~_!B^pxW6?g GHX1 Date: Tue, 19 Sep 2023 08:17:33 +0000 Subject: [PATCH 24/25] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../storage_format/multiple_elements.zarr/.zgroup | 2 +- .../storage_format/multiple_elements.zarr/images/.zgroup | 2 +- .../multiple_elements.zarr/images/blobs_image/.zattrs | 2 +- .../multiple_elements.zarr/images/blobs_image/.zgroup | 2 +- .../multiple_elements.zarr/images/blobs_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/.zattrs | 2 +- .../images/blobs_multiscale_image/.zgroup | 2 +- .../images/blobs_multiscale_image/0/.zarray | 2 +- .../images/blobs_multiscale_image/1/.zarray | 2 +- .../images/blobs_multiscale_image/2/.zarray | 2 +- .../storage_format/multiple_elements.zarr/labels/.zattrs | 2 +- .../storage_format/multiple_elements.zarr/labels/.zgroup | 2 +- .../multiple_elements.zarr/labels/blobs_labels/.zattrs | 2 +- .../multiple_elements.zarr/labels/blobs_labels/.zgroup | 2 +- .../multiple_elements.zarr/labels/blobs_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/.zattrs | 2 +- .../labels/blobs_multiscale_labels/.zgroup | 2 +- .../labels/blobs_multiscale_labels/0/.zarray | 2 +- .../labels/blobs_multiscale_labels/1/.zarray | 2 +- .../labels/blobs_multiscale_labels/2/.zarray | 2 +- .../storage_format/multiple_elements.zarr/points/.zgroup | 2 +- .../multiple_elements.zarr/points/blobs_points/.zattrs | 2 +- .../multiple_elements.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/multiple_elements.zarr/shapes/.zgroup | 2 +- .../multiple_elements.zarr/shapes/blobs_circles/.zattrs | 2 +- .../multiple_elements.zarr/shapes/blobs_circles/.zgroup | 2 +- .../multiple_elements.zarr/shapes/blobs_circles/Index/.zarray | 2 +- .../multiple_elements.zarr/shapes/blobs_circles/coords/.zarray | 2 +- .../multiple_elements.zarr/shapes/blobs_circles/radius/.zarray | 2 +- .../multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs | 2 +- .../multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup | 2 +- .../shapes/blobs_multipolygons/Index/.zarray | 2 +- .../shapes/blobs_multipolygons/coords/.zarray | 2 +- .../shapes/blobs_multipolygons/offset0/.zarray | 2 +- .../shapes/blobs_multipolygons/offset1/.zarray | 2 +- .../shapes/blobs_multipolygons/offset2/.zarray | 2 +- .../multiple_elements.zarr/shapes/blobs_polygons/.zattrs | 2 +- .../multiple_elements.zarr/shapes/blobs_polygons/.zgroup | 2 +- .../multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray | 2 +- .../multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray | 2 +- .../shapes/blobs_polygons/offset0/.zarray | 2 +- .../shapes/blobs_polygons/offset1/.zarray | 2 +- .../storage_format/multiple_elements.zarr/table/.zgroup | 2 +- .../storage_format/multiple_elements.zarr/table/table/.zattrs | 2 +- .../storage_format/multiple_elements.zarr/table/table/.zgroup | 2 +- .../storage_format/multiple_elements.zarr/table/table/X/.zattrs | 2 +- .../storage_format/multiple_elements.zarr/table/table/X/.zgroup | 2 +- .../multiple_elements.zarr/table/table/X/data/.zarray | 2 +- .../multiple_elements.zarr/table/table/X/indices/.zarray | 2 +- .../multiple_elements.zarr/table/table/X/indptr/.zarray | 2 +- .../multiple_elements.zarr/table/table/layers/.zattrs | 2 +- .../multiple_elements.zarr/table/table/layers/.zgroup | 2 +- .../multiple_elements.zarr/table/table/obs/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obs/.zgroup | 2 +- .../multiple_elements.zarr/table/table/obs/_index/.zarray | 2 +- .../multiple_elements.zarr/table/table/obs/_index/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obs/instance_id/.zarray | 2 +- .../multiple_elements.zarr/table/table/obs/instance_id/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obs/region/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obs/region/.zgroup | 2 +- .../table/table/obs/region/categories/.zarray | 2 +- .../table/table/obs/region/categories/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obs/region/codes/.zarray | 2 +- .../multiple_elements.zarr/table/table/obs/region/codes/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obsm/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obsm/.zgroup | 2 +- .../multiple_elements.zarr/table/table/obsp/.zattrs | 2 +- .../multiple_elements.zarr/table/table/obsp/.zgroup | 2 +- .../multiple_elements.zarr/table/table/uns/.zattrs | 2 +- .../multiple_elements.zarr/table/table/uns/.zgroup | 2 +- .../table/table/uns/spatialdata_attrs/.zattrs | 2 +- .../table/table/uns/spatialdata_attrs/.zgroup | 2 +- .../table/table/uns/spatialdata_attrs/instance_key/.zarray | 2 +- .../table/table/uns/spatialdata_attrs/instance_key/.zattrs | 2 +- .../table/table/uns/spatialdata_attrs/region/.zarray | 2 +- .../table/table/uns/spatialdata_attrs/region/.zattrs | 2 +- .../table/table/uns/spatialdata_attrs/region_key/.zarray | 2 +- .../table/table/uns/spatialdata_attrs/region_key/.zattrs | 2 +- .../multiple_elements.zarr/table/table/var/.zattrs | 2 +- .../multiple_elements.zarr/table/table/var/.zgroup | 2 +- .../multiple_elements.zarr/table/table/var/_index/.zarray | 2 +- .../multiple_elements.zarr/table/table/var/_index/.zattrs | 2 +- .../multiple_elements.zarr/table/table/varm/.zattrs | 2 +- .../multiple_elements.zarr/table/table/varm/.zgroup | 2 +- .../multiple_elements.zarr/table/table/varp/.zattrs | 2 +- .../multiple_elements.zarr/table/table/varp/.zgroup | 2 +- .../storage_format/multiple_elements.zarr/zmetadata | 2 +- .../storage_format/transformation_affine.zarr/.zgroup | 2 +- .../storage_format/transformation_affine.zarr/images/.zgroup | 2 +- .../transformation_affine.zarr/images/blobs_image/.zattrs | 2 +- .../transformation_affine.zarr/images/blobs_image/.zgroup | 2 +- .../transformation_affine.zarr/images/blobs_image/0/.zarray | 2 +- .../storage_format/transformation_affine.zarr/points/.zgroup | 2 +- .../transformation_affine.zarr/points/blobs_points/.zattrs | 2 +- .../transformation_affine.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/transformation_affine.zarr/zmetadata | 2 +- .../storage_format/transformation_identity.zarr/.zgroup | 2 +- .../storage_format/transformation_identity.zarr/images/.zgroup | 2 +- .../transformation_identity.zarr/images/blobs_image/.zattrs | 2 +- .../transformation_identity.zarr/images/blobs_image/.zgroup | 2 +- .../transformation_identity.zarr/images/blobs_image/0/.zarray | 2 +- .../storage_format/transformation_identity.zarr/points/.zgroup | 2 +- .../transformation_identity.zarr/points/blobs_points/.zattrs | 2 +- .../transformation_identity.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/transformation_identity.zarr/zmetadata | 2 +- .../storage_format/transformation_scale.zarr/.zgroup | 2 +- .../storage_format/transformation_scale.zarr/images/.zgroup | 2 +- .../transformation_scale.zarr/images/blobs_image/.zattrs | 2 +- .../transformation_scale.zarr/images/blobs_image/.zgroup | 2 +- .../transformation_scale.zarr/images/blobs_image/0/.zarray | 2 +- .../storage_format/transformation_scale.zarr/points/.zgroup | 2 +- .../transformation_scale.zarr/points/blobs_points/.zattrs | 2 +- .../transformation_scale.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/transformation_scale.zarr/zmetadata | 2 +- .../storage_format/transformation_sequence.zarr/.zgroup | 2 +- .../storage_format/transformation_sequence.zarr/images/.zgroup | 2 +- .../transformation_sequence.zarr/images/blobs_image/.zattrs | 2 +- .../transformation_sequence.zarr/images/blobs_image/.zgroup | 2 +- .../transformation_sequence.zarr/images/blobs_image/0/.zarray | 2 +- .../storage_format/transformation_sequence.zarr/points/.zgroup | 2 +- .../transformation_sequence.zarr/points/blobs_points/.zattrs | 2 +- .../transformation_sequence.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/transformation_sequence.zarr/zmetadata | 2 +- .../storage_format/transformation_translation.zarr/.zgroup | 2 +- .../transformation_translation.zarr/images/.zgroup | 2 +- .../transformation_translation.zarr/images/blobs_image/.zattrs | 2 +- .../transformation_translation.zarr/images/blobs_image/.zgroup | 2 +- .../images/blobs_image/0/.zarray | 2 +- .../transformation_translation.zarr/points/.zgroup | 2 +- .../transformation_translation.zarr/points/blobs_points/.zattrs | 2 +- .../transformation_translation.zarr/points/blobs_points/.zgroup | 2 +- .../storage_format/transformation_translation.zarr/zmetadata | 2 +- 132 files changed, 132 insertions(+), 132 deletions(-) diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs index 75d8a18..dbec22e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zattrs @@ -90,4 +90,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray index 37dfbfc..08f0a41 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs index cd2bc87..fc3e6dd 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zattrs @@ -116,4 +116,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray index 37dfbfc..08f0a41 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/0/.zarray @@ -22,4 +22,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/1/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray index cdeee2a..92446ef 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/images/blobs_multiscale_image/2/.zarray @@ -22,4 +22,4 @@ 16 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs index 90c6a5d..94ec98f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zattrs @@ -3,4 +3,4 @@ "blobs_labels", "blobs_multiscale_labels" ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs index 1be5678..9e47e76 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zattrs @@ -67,4 +67,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray index 00ce34c..784c320 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs index eb666af..242c42f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zattrs @@ -91,4 +91,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray index 00ce34c..784c320 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/0/.zarray @@ -20,4 +20,4 @@ 64 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray index 3f12448..814fc75 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/1/.zarray @@ -20,4 +20,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray index 1373fa1..92f43d7 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/labels/blobs_multiscale_labels/2/.zarray @@ -20,4 +20,4 @@ 16 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs index 50b68d4..3c27423 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zattrs @@ -41,4 +41,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs index a8cb6fc..32831c8 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray index 11f83d7..587511e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_circles/radius/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs index dbcdf7f..cf683ab 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray index 6f767bd..97aaf24 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray index 908fd0c..f7f6352 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset0/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray index 908fd0c..f7f6352 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset1/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_multipolygons/offset2/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs index 204ea77..521c9a3 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zattrs @@ -43,4 +43,4 @@ }, "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray index ed01e15..558908e 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/Index/.zarray @@ -18,4 +18,4 @@ 5 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray index a97e38f..4f02ddb 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/coords/.zarray @@ -20,4 +20,4 @@ 2 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset0/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray index 96d00b5..a5998d9 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/shapes/blobs_polygons/offset1/.zarray @@ -18,4 +18,4 @@ 6 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs index 6e9445e..33ffa12 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zattrs @@ -6,4 +6,4 @@ "region_key": "region", "spatialdata-encoding-type": "ngff:regions_table", "version": "0.1" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs index 59901f8..c528b61 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zattrs @@ -5,4 +5,4 @@ 10, 3 ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray index 9730452..7d79544 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/data/.zarray @@ -18,4 +18,4 @@ 30 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray index 50f4374..a24717f 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indices/.zarray @@ -18,4 +18,4 @@ 30 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray index 3ed4552..2d58283 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/X/indptr/.zarray @@ -18,4 +18,4 @@ 11 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/layers/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs index 4419949..8f96ebc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zattrs @@ -6,4 +6,4 @@ ], "encoding-type": "dataframe", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray index 8ddc86e..f54362a 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zarray @@ -22,4 +22,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/_index/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray index 61786cf..50970c8 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zarray @@ -18,4 +18,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs index 2b8d6d9..ecdb601 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/instance_id/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs index 198a2dd..2dbe306 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zattrs @@ -2,4 +2,4 @@ "encoding-type": "categorical", "encoding-version": "0.2.0", "ordered": false -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray index 7b6a20f..23873b0 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zarray @@ -22,4 +22,4 @@ 1 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/categories/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray index 2f626d2..5430d04 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zarray @@ -18,4 +18,4 @@ 10 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs index 2b8d6d9..ecdb601 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obs/region/codes/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsm/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/obsp/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray index bef650f..47f1efc 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/instance_key/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray index 673b378..6297f30 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray index 5f8af9e..ff79b02 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zarray @@ -8,4 +8,4 @@ "order": "C", "shape": [], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs index da704d9..63c4f27 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/uns/spatialdata_attrs/region_key/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs index 7c9c5f9..67cac68 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zattrs @@ -3,4 +3,4 @@ "column-order": [], "encoding-type": "dataframe", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray index 2abe5a8..1cffc94 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zarray @@ -22,4 +22,4 @@ 3 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs index 6e14470..ed07997 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/var/_index/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "string-array", "encoding-version": "0.2.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varm/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs index a204673..947f8b2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zattrs @@ -1,4 +1,4 @@ { "encoding-type": "dict", "encoding-version": "0.1.0" -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/table/table/varp/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata index 02f0faf..cb1894a 100644 --- a/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/multiple_elements.zarr/zmetadata @@ -1404,4 +1404,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs index 964245a..e36d6d4 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zattrs @@ -110,4 +110,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs index 976c318..600e416 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zattrs @@ -53,4 +53,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata index edfd783..a41d5cd 100644 --- a/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_affine.zarr/zmetadata @@ -211,4 +211,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs index 75d8a18..dbec22e 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zattrs @@ -90,4 +90,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs index 50b68d4..3c27423 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zattrs @@ -41,4 +41,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata index d47caf5..8d7806c 100644 --- a/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_identity.zarr/zmetadata @@ -179,4 +179,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs index b064678..a7d80df 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zattrs @@ -95,4 +95,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs index f1e1747..dd0d1f8 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zattrs @@ -45,4 +45,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata index 9f69a9b..4224fa8 100644 --- a/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_scale.zarr/zmetadata @@ -188,4 +188,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs index 247659c..ce42fb6 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zattrs @@ -184,4 +184,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs index ab90cb2..d4631e3 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zattrs @@ -117,4 +117,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata index 282b1df..e5c2f5f 100644 --- a/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_sequence.zarr/zmetadata @@ -349,4 +349,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs index 14364cb..ff754fc 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zattrs @@ -95,4 +95,4 @@ "version": "0.4" } ] -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray index f245000..8e38e52 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/images/blobs_image/0/.zarray @@ -22,4 +22,4 @@ 32 ], "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs index 50788d7..581b179 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zattrs @@ -45,4 +45,4 @@ "instance_key": "instance_id", "version": "0.1" } -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup index 3b7daf2..3f3fad2 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/points/blobs_points/.zgroup @@ -1,3 +1,3 @@ { "zarr_format": 2 -} \ No newline at end of file +} diff --git a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata index 112efe7..c98e0cc 100644 --- a/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata +++ b/notebooks/developers_resources/storage_format/transformation_translation.zarr/zmetadata @@ -188,4 +188,4 @@ } }, "zarr_consolidated_format": 1 -} \ No newline at end of file +} From 8bad376c0f3377486a9d7d796e76f4204c8c9a7a Mon Sep 17 00:00:00 2001 From: Luca Marconato Date: Sun, 24 Sep 2023 22:52:49 +0200 Subject: [PATCH 25/25] fix docs --- notebooks.md | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/notebooks.md b/notebooks.md index d59c858..7c15db1 100644 --- a/notebooks.md +++ b/notebooks.md @@ -148,17 +148,4 @@ Many different technologies can be visualised out-of-the-box. See below for a co notebooks/examples/technology_cosmx.ipynb - .. grid-item:: - - .. container:: custom-card - - .. image:: _static/img/curio.png - :target: notebooks/examples/technology_curio.html - - .. toctree:: - :maxdepth: 1 - - notebooks/examples/technology_curio.ipynb - - ```