From 4373fb4dc5d716fe68f6603bade42257bd6ad9a9 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Mon, 23 Dec 2024 21:50:30 -0600 Subject: [PATCH 01/10] set up STAC metadata --- LICENSE | 2 +- README-template.md | 67 - README.md | 99 +- ...5b01-5d46-4cb5-8449-5b27bcbfe445-c000.json | 179 + examples/collection.json | 65 +- examples/example-item/example-item.json | 87 - pyproject.toml | 18 +- scripts/generate-test-data | 8 + scripts/generate_test_data.sql | 16 + scripts/update-examples | 12 +- src/stactools/overture_maps/constants.py | 15 + src/stactools/overture_maps/metadata.py | 428 + src/stactools/overture_maps/stac.py | 44 +- ...-8449-5b27bcbfe445-c000.zstd.parquet].yaml | 7930 +++++++++++++++++ ...-adaf-0c6d59a3b7d9-c000.zstd.parquet].yaml | 1293 +++ tests/conftest.py | 2 + tests/data/asset.tif | Bin 799760 -> 0 bytes ...8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet | Bin 0 -> 1150 bytes ...6-4cb5-8449-5b27bcbfe445-c000.zstd.parquet | Bin 0 -> 123405 bytes tests/test_stac.py | 22 +- uv.lock | 898 +- 21 files changed, 10835 insertions(+), 350 deletions(-) delete mode 100644 README-template.md create mode 100644 examples/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.json delete mode 100644 examples/example-item/example-item.json create mode 100755 scripts/generate-test-data create mode 100644 scripts/generate_test_data.sql create mode 100644 src/stactools/overture_maps/constants.py create mode 100644 src/stactools/overture_maps/metadata.py create mode 100644 tests/cassettes/test_stac/test_create_item[https---overturemapswestus2.blob.core.windows.net-release-2024-12-18.0-theme=buildings-type=building-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet].yaml create mode 100644 tests/cassettes/test_stac/test_create_item[s3---overturemaps-us-west-2-release-2024-12-18.0-theme=buildings-type=building-part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet].yaml create mode 100644 tests/conftest.py delete mode 100644 tests/data/asset.tif create mode 100644 tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet create mode 100644 tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet diff --git a/LICENSE b/LICENSE index 9f4fda8..49b1193 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ This software is licensed under the Apache 2 license, quoted below. -Copyright 2022 COMPANY [COMPANY WEBPAGE URL] +Copyright 2022 Development Seed [https://developmentseed.org] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of diff --git a/README-template.md b/README-template.md deleted file mode 100644 index f5a2b50..0000000 --- a/README-template.md +++ /dev/null @@ -1,67 +0,0 @@ -# stactools-overture-maps - -[![PyPI](https://img.shields.io/pypi/v/stactools-overture-maps?style=for-the-badge)](https://pypi.org/project/stactools-overture-maps/) -![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/stactools-packages/overture-maps/continuous-integration.yml?style=for-the-badge) - -- Name: overture-maps -- Package: `stactools.overture_maps` -- [stactools-overture-maps on PyPI](https://pypi.org/project/stactools-overture-maps/) -- Owner: @githubusername -- [Dataset homepage](http://example.com) -- STAC extensions used: - - [proj](https://github.com/stac-extensions/projection/) -- Extra fields: - - `overture-maps:custom`: A custom attribute -- [Browse the example in human-readable form](https://radiantearth.github.io/stac-browser/#/external/raw.githubusercontent.com/stactools-packages/overture-maps/main/examples/collection.json) -- [Browse a notebook demonstrating the example item and collection](https://github.com/stactools-packages/overture-maps/tree/main/docs/example.ipynb) - -A short description of the package and its usage. - -## STAC examples - -- [Collection](examples/collection.json) -- [Item](examples/item/item.json) - -## Installation - -```shell -pip install stactools-overture-maps -``` - -## Command-line usage - -Description of the command line functions - -```shell -stac overture-maps create-item source destination -``` - -Use `stac overture-maps --help` to see all subcommands and options. - -## Contributing - -We use [pre-commit](https://pre-commit.com/) to check any changes. -To set up your development environment: - -```shell -uv sync -uv run pre-commit install -``` - -To check all files: - -```shell -uv run pre-commit run --all-files -``` - -To run the tests: - -```shell -uv run pytest -vv -``` - -If you've updated the STAC metadata output, update the examples: - -```shell -uv run scripts/update-examples -``` diff --git a/README.md b/README.md index 2819a7b..e72cc96 100644 --- a/README.md +++ b/README.md @@ -1,23 +1,76 @@ -# stactools-template - -This is a template repo used for creating new packages for `stactools`. - -## How to use - -1. Clone this template repository as your package name, e.g. `landsat`. - This name should be short, memorable, and a valid Python package name (i.e. - it shouldn't start with a number, etc). It can, however, include a hyphen, in - which case the name for Python imports will be the underscored version, e.g. - `landsat-8` goes to `stactools.landsat_8`. Your name will be used on PyPI to - publish the package in the stactools namespace, e.g. `stactools-landsat`. -2. Change into the top-level directory of your package and run `scripts/rename`. - This will update _most_ of the files in the repository with your new package name. -3. Update `pyproject.toml` with your package description and such. -4. Install with the development requirements (`uv sync`). -5. Update the LICENSE with your company's information (or whomever holds the copyright). -6. Edit or replace the existing functions to create stac Items and Collections - for your dataset. -7. Add example Items (and Collections and Catalogs, if included) to an - `examples/` directory. -8. Delete this file, and rename `README-template.md` to `README.md`. Update your - new README to provide information about how to use your package. +# stactools-overture-maps + +[![PyPI](https://img.shields.io/pypi/v/stactools-overture-maps?style=for-the-badge)](https://pypi.org/project/stactools-overture-maps/) +![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/stactools-packages/overture-maps/continuous-integration.yml?style=for-the-badge) + +- Name: overture-maps +- Package: `stactools.overture_maps` +- [stactools-overture-maps on PyPI](https://pypi.org/project/stactools-overture-maps/) +- Owner: @githubusername +- [Dataset homepage](http://example.com) +- STAC extensions used: + - [proj](https://github.com/stac-extensions/projection/) +- Extra fields: + - `overture-maps:custom`: A custom attribute +- [Browse the example in human-readable form](https://radiantearth.github.io/stac-browser/#/external/raw.githubusercontent.com/stactools-packages/overture-maps/main/examples/collection.json) +- [Browse a notebook demonstrating the example item and collection](https://github.com/stactools-packages/overture-maps/tree/main/docs/example.ipynb) + +A short description of the package and its usage. + +## STAC examples + +- [Collection](examples/collection.json) +- [Item](examples/item/item.json) + +## Installation + +```shell +pip install stactools-overture-maps +``` + +## Command-line usage + +Description of the command line functions + +```shell +stac overture-maps create-item source destination +``` + +Use `stac overture-maps --help` to see all subcommands and options. + +## Contributing + +We use [pre-commit](https://pre-commit.com/) to check any changes. +To set up your development environment: + +```shell +uv sync +uv run pre-commit install +``` + +To check all files: + +```shell +uv run pre-commit run --all-files +``` + +To run the tests: + +```shell +uv run pytest -vv +``` + +If you've updated the STAC metadata output, update the examples: + +```shell +uv run scripts/update-examples +``` + +To update the test data: + +- install [`gpq`](https://github.com/planetlabs/gpq) +- install [`duckdb`](https://duckdb.org/docs/installation/?version=stable&environment=cli&platform=linux&download_method=direct&architecture=x86_64) + +```bash +scripts/generate-test-data +``` diff --git a/examples/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.json b/examples/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.json new file mode 100644 index 0000000..7817635 --- /dev/null +++ b/examples/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.json @@ -0,0 +1,179 @@ +{ + "type": "Feature", + "stac_version": "1.0.0", + "stac_extensions": [ + "https://stac-extensions.github.io/version/v1.2.0/schema.json", + "https://stac-extensions.github.io/table/v1.2.0/schema.json" + ], + "id": "buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000", + "geometry": { + "type": "Polygon", + "coordinates": [ + [ + [ + -179.9999966, + -83.6500139 + ], + [ + -2.8229824, + -83.6500139 + ], + [ + -2.8229824, + -0.00313771110055319 + ], + [ + -179.9999966, + -0.00313771110055319 + ], + [ + -179.9999966, + -83.6500139 + ] + ] + ] + }, + "bbox": [ + -179.9999966, + -83.6500139, + -2.8229824, + -0.00313771110055319 + ], + "properties": { + "overture:theme": "buildings", + "overture:type": "building", + "version": "2024-12-18.0", + "table:row_count": 11529498, + "table:columns": [ + { + "name": "id", + "col_type": "string" + }, + { + "name": "geometry", + "col_type": "binary" + }, + { + "name": "bbox", + "col_type": "struct" + }, + { + "name": "version", + "col_type": "integer" + }, + { + "name": "sources", + "col_type": "array" + }, + { + "name": "level", + "col_type": "integer" + }, + { + "name": "subtype", + "col_type": "string" + }, + { + "name": "class", + "col_type": "string" + }, + { + "name": "height", + "col_type": "double" + }, + { + "name": "names", + "col_type": "struct" + }, + { + "name": "has_parts", + "col_type": "boolean" + }, + { + "name": "is_underground", + "col_type": "boolean" + }, + { + "name": "num_floors", + "col_type": "integer" + }, + { + "name": "num_floors_underground", + "col_type": "integer" + }, + { + "name": "min_height", + "col_type": "double" + }, + { + "name": "min_floor", + "col_type": "integer" + }, + { + "name": "facade_color", + "col_type": "string" + }, + { + "name": "facade_material", + "col_type": "string" + }, + { + "name": "roof_material", + "col_type": "string" + }, + { + "name": "roof_shape", + "col_type": "string" + }, + { + "name": "roof_direction", + "col_type": "double" + }, + { + "name": "roof_orientation", + "col_type": "string" + }, + { + "name": "roof_color", + "col_type": "string" + }, + { + "name": "roof_height", + "col_type": "double" + } + ], + "table:primary_geometry": "Polygon", + "datetime": "2024-01-18T00:12:00Z" + }, + "links": [ + { + "rel": "root", + "href": "../collection.json", + "type": "application/json" + }, + { + "rel": "collection", + "href": "../collection.json", + "type": "application/json" + }, + { + "rel": "parent", + "href": "../collection.json", + "type": "application/json" + } + ], + "assets": { + "data": { + "href": "https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet", + "type": "application/x-parquet", + "table:storage_options": { + "anon": true, + "account_name": "overturemapswestus2" + }, + "roles": [ + "data" + ] + } + }, + "collection": "overture-maps-buildings" +} \ No newline at end of file diff --git a/examples/collection.json b/examples/collection.json index d6db4b8..35a3137 100644 --- a/examples/collection.json +++ b/examples/collection.json @@ -1,42 +1,79 @@ { "type": "Collection", - "id": "example-collection", + "id": "overture-maps-buildings", "stac_version": "1.0.0", - "description": "An example collection", + "description": "## Overture Maps - buildings\n\nThis collection contains items for the buildings theme.\n\nThe Overture Maps buildings theme describes human-made structures with roofs or interior spaces that are permanently or semi-permanently in one place (source: [OSM building definition](https://wiki.openstreetmap.org/wiki/Key:building)). The theme includes two feature types:\n\n- **`building`**: The most basic form of a building feature. The geometry is expected to be the most outer footprint—roofprint if traced from satellite/aerial imagery—of a building. Buildings have a boolean attribute `has_parts` that describe whether there are any associated building parts.\n- **`building_part`**: A single part of a building. Building parts may share the same properties as buildings. A building part is associated with a parent building via a `building_id`.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThis STAC collection has one STAC item per individual parquet file and represents the following feature types:\n\n- ('building', )\n- ('building_part', )\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", "href": "./collection.json", - "type": "application/json", - "title": "Example collection" + "type": "application/json" + }, + { + "rel": "license", + "href": "https://opendatacommons.org/licenses/odbl/1.0/", + "type": "text/html", + "title": "ODbL 1.0" }, { "rel": "item", - "href": "./example-item/example-item.json", + "href": "./buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000/buildings-building-2024-12-18.0-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.json", "type": "application/json" } ], - "custom_attribute": "foo", - "title": "Example collection", + "stac_extensions": [ + "https://stac-extensions.github.io/item-assets/v1.0.0/schema.json" + ], + "item_assets": { + "data": { + "title": "Geoparquet partition", + "description": "Geoparquet partition", + "type": "application/x-parquet", + "roles": [ + "data" + ] + } + }, "extent": { "spatial": { "bbox": [ [ - -61.287624, - 72.229798, - -52.301599, - 74.622043 + -179.9999966, + -83.6500139, + -2.8229824, + -0.00313771110055319 ] ] }, "temporal": { "interval": [ [ - "2023-09-12T11:48:03.199913Z", - "2023-09-12T11:48:03.199913Z" + "2024-01-18T00:12:00Z", + "2024-01-18T00:12:00Z" ] ] } }, - "license": "proprietary" + "license": "ODbL 1.0", + "keywords": [ + "building", + "building_part", + "buildings" + ], + "providers": [ + { + "name": "Overture Maps Foundation", + "roles": [ + "producer" + ], + "url": "https://overturemaps.org/" + }, + { + "name": "Microsoft", + "roles": [ + "host" + ], + "url": "https://microsoft.com" + } + ] } \ No newline at end of file diff --git a/examples/example-item/example-item.json b/examples/example-item/example-item.json deleted file mode 100644 index 17cf5cf..0000000 --- a/examples/example-item/example-item.json +++ /dev/null @@ -1,87 +0,0 @@ -{ - "type": "Feature", - "stac_version": "1.0.0", - "id": "example-item", - "properties": { - "proj:epsg": 32621, - "proj:transform": [ - 100.01126757344893, - 0.0, - 373185.0, - 0.0, - -100.01126757344893, - 8286015.0 - ], - "proj:shape": [ - 2667, - 2658 - ], - "custom_attribute": "foo", - "datetime": "2023-09-12T11:48:03.199913Z" - }, - "geometry": { - "type": "Polygon", - "coordinates": [ - [ - [ - -52.916275, - 72.229798 - ], - [ - -52.301599, - 74.613784 - ], - [ - -61.287624, - 74.622043 - ], - [ - -60.726346, - 72.236891 - ], - [ - -52.916275, - 72.229798 - ] - ] - ] - }, - "links": [ - { - "rel": "root", - "href": "../collection.json", - "type": "application/json", - "title": "Example collection" - }, - { - "rel": "collection", - "href": "../collection.json", - "type": "application/json", - "title": "Example collection" - }, - { - "rel": "parent", - "href": "../collection.json", - "type": "application/json", - "title": "Example collection" - } - ], - "assets": { - "data": { - "href": "../../tests/data/asset.tif", - "roles": [ - "data" - ] - } - }, - "bbox": [ - -61.287624, - 72.229798, - -52.301599, - 74.622043 - ], - "stac_extensions": [ - "https://stac-extensions.github.io/projection/v1.1.0/schema.json" - ], - "collection": "example-collection" -} \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 1df6372..c74ef21 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -19,7 +19,13 @@ classifiers = [ "Programming Language :: Python :: 3.12", ] requires-python = ">=3.9" -dependencies = ["stactools>=0.4.0"] +dependencies = [ + "geojson-pydantic>=1.2.0", + "httpx>=0.28.1", + "parse>=1.20.2", + "pyarrow>=18.1.0", + "stactools>=0.4.0", +] [dependency-groups] dev = [ @@ -30,6 +36,8 @@ dev = [ "pytest~=8.2", "requests~=2.32", "ruff==0.8.3", + "ipython>=8.18.1", + "pytest-recording>=0.13.2", ] docs = ["pystac~=1.10", "ipykernel~=6.29", "jinja2~=3.1"] @@ -37,6 +45,14 @@ docs = ["pystac~=1.10", "ipykernel~=6.29", "jinja2~=3.1"] Github = "https://github.com/stactools-packages/overture-maps" Issues = "https://github.com/stactools-packages/overture-maps/issues" +[project.optional-dependencies] +azure = [ + "adlfs>=2024.12.0", +] +aws = [ + "s3fs>=2024.12.0", +] + [build-system] requires = ["setuptools", "wheel"] build-backend = "setuptools.build_meta" diff --git a/scripts/generate-test-data b/scripts/generate-test-data new file mode 100755 index 0000000..7d45149 --- /dev/null +++ b/scripts/generate-test-data @@ -0,0 +1,8 @@ +#!/bin/bash + +mkdir -p tests/data/release/2024-12-18.0/theme=buildings/type=building + +duckdb < scripts/generate_test_data.sql + +gpq convert /tmp/buildings.zstd.parquet tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + diff --git a/scripts/generate_test_data.sql b/scripts/generate_test_data.sql new file mode 100644 index 0000000..65e8008 --- /dev/null +++ b/scripts/generate_test_data.sql @@ -0,0 +1,16 @@ +INSTALL SPATIAL; +INSTALL azure; + +LOAD spatial; --noqa + +SET azure_storage_connection_string = 'DefaultEndpointsProtocol=https;AccountName=overturemapswestus2;AccountKey=;EndpointSuffix=core.windows.net'; +SET azure_transport_option_type = 'curl'; + +COPY( + SELECT + * + FROM read_parquet('azure://release/2024-12-18.0/theme=buildings/type=building/*', filename=true, hive_partitioning=1) + WHERE filename = 'azure://release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet' + LIMIT 1000 +) TO '/tmp/buildings.zstd.parquet'; + diff --git a/scripts/update-examples b/scripts/update-examples index 468355b..6ce99ad 100755 --- a/scripts/update-examples +++ b/scripts/update-examples @@ -6,12 +6,20 @@ from pathlib import Path from pystac import CatalogType import stactools.overture_maps.stac +from stactools.overture_maps.constants import AZURE_NETLOC +from stactools.overture_maps.metadata import StorageBackend, Theme root = Path(__file__).parents[1] examples = root / "examples" -collection = stactools.overture_maps.stac.create_collection() -item = stactools.overture_maps.stac.create_item(str(root / "tests" / "data" / "asset.tif")) +collection = stactools.overture_maps.stac.create_collection( + theme=Theme.BUILDINGS, + storage_backend=StorageBackend.AZURE, + latest_release="2024-12-18.0", +) +item = stactools.overture_maps.stac.create_item( + f"https://{AZURE_NETLOC}/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet" +) collection.add_item(item) collection.update_extent_from_items() collection.normalize_hrefs(str(examples)) diff --git a/src/stactools/overture_maps/constants.py b/src/stactools/overture_maps/constants.py new file mode 100644 index 0000000..5affd5a --- /dev/null +++ b/src/stactools/overture_maps/constants.py @@ -0,0 +1,15 @@ +from datetime import datetime, timezone + +AZURE_NETLOC = "overturemapswestus2.blob.core.windows.net" +S3_NETLOC = "overturemaps-us-west-2" +FIRST_RELEASE_DATE = datetime(year=2023, month=7, day=26, tzinfo=timezone.utc) +PARTITION_FORMAT = ( + "/release/{release}/theme={theme}/type={type}/part-{part}-{uid}.zstd.parquet" +) +COLLECTION_ID_FORMAT = "overture-maps-{theme}" + +ODBL_LICENSE_ATTRIBUTES = { + "href": "https://opendatacommons.org/licenses/odbl/1.0/", + "title": "ODbL 1.0", + "type": "text/html", +} diff --git a/src/stactools/overture_maps/metadata.py b/src/stactools/overture_maps/metadata.py new file mode 100644 index 0000000..e7d3c47 --- /dev/null +++ b/src/stactools/overture_maps/metadata.py @@ -0,0 +1,428 @@ +import json +import re +from dataclasses import dataclass +from datetime import datetime +from enum import Enum +from typing import Any, Collection, Dict, List, Optional, TypedDict, Union +from urllib.parse import urlparse + +import httpx +import pyarrow.parquet as pq +from adlfs import AzureBlobFileSystem +from geojson_pydantic import Polygon +from parse import Result, parse +from pystac import ( + Asset, + Collection, + Extent, + Item, + Link, + MediaType, + Provider, + ProviderRole, + RelType, + SpatialExtent, + TemporalExtent, +) +from pystac.extensions import table +from pystac.extensions.item_assets import AssetDefinition, ItemAssetsExtension +from pystac.extensions.version import VersionExtension +from s3fs import S3FileSystem + +from stactools.overture_maps.constants import ( + AZURE_NETLOC, + COLLECTION_ID_FORMAT, + FIRST_RELEASE_DATE, + ODBL_LICENSE_ATTRIBUTES, + PARTITION_FORMAT, +) + +COLLECTION_DESCRIPTION_FORMAT = ( + "## Overture Maps - {theme}\n\n" + "This collection contains items for the {theme} theme.\n\n" + "{theme_description}\n\n" + "## Data assets\n\n" + "The features are provided as a set of " + "[geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data " + "are partitioned by\n\n" + "1. Theme\n2. Type\n\n" + "Each `(Theme, Type)` pair will have one or more geoparquet files, depending on " + "the density of the of the features in that area.\n\n" + "Note that older items in this dataset (version 2024.02.15-alpha.0 and earier) are " + "**not** spatially partitioned. We recommend using data with a release of " + "2023-03-12-alpha.0 or newer. " + "The release is part of the URL for each parquet file and is captured in the STAC " + "metadata for each item (see below).\n\n" + "## STAC metadata\n\n" + "This STAC collection has one STAC item per individual parquet file and represents " + "the following feature types:\n\n" + "{feature_types}\n\n" + "The `overture:type` property can be used to filter items to a specific feature " + "type, and the `overture:release` property can be used to filter items to a " + "specific release.\n\n" + "## About Overture Maps\n\n" + "Overture is a collaborative open-data initiative led by software developers, data " + "experts,cartographic engineers, and product managers from dozens of Overture Maps " + "Foundation member companies. Since our launch in December 2022, Overture members " + "have been working toward a shared vision: to create reliable, user-friendly, and " + "interoperable open map data that supports both current and future map products. " + "We envision a world where shared, open base layers drive collaboration and " + "innovation across industries and communities.\n\n" + "For more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n" +) + + +class PyarrowArgs(TypedDict): + where: str + filesystem: Optional[Union[S3FileSystem, AzureBlobFileSystem]] + + +class Theme(str, Enum): + ADDRESSES = "addresses" + BASE = "base" + BUILDINGS = "buildings" + DIVISIONS = "divisions" + PLACES = "places" + TRANSPORTATION = "transportation" + + +class FeatureType(Enum): + ADDRESS = ("address", Theme.ADDRESSES) + BUILDING = ("building", Theme.BUILDINGS) + BUILDING_PART = ("building_part", Theme.BUILDINGS) + DIVISION = ("division", Theme.DIVISIONS) + DIVISION_AREA = ("division_area", Theme.DIVISIONS) + DIVISION_BOUNDARY = ("division_boundary", Theme.DIVISIONS) + PLACE = ("place", Theme.PLACES) + SEGMENT = ("segment", Theme.TRANSPORTATION) + CONNECTOR = ("connector", Theme.TRANSPORTATION) + BATHYMETRY = ("bathymetry", Theme.BASE) + INFRASTRUCTURE = ("infrastructure", Theme.BASE) + LAND = ("land", Theme.BASE) + LAND_COVER = ("land_cover", Theme.BASE) + LAND_USE = ("land_use", Theme.BASE) + WATER = ("water", Theme.BASE) + + def __init__(self, type_name: str, theme: Theme): + self.type_name = type_name + self.theme = theme + + @classmethod + def from_string(cls, type_name: str) -> "FeatureType": + """Get FeatureType enum from string name""" + for feature_type in cls: + if feature_type.type_name == type_name: + return feature_type + raise ValueError(f"Unknown feature type: {type_name}") + + @classmethod + def get_types_for_theme(cls, theme: Theme) -> list["FeatureType"]: + """Get all feature types for a given theme""" + return [ft for ft in cls if ft.theme == theme] + + +class StorageBackend(str, Enum): + AWS = "aws" + AZURE = "azure" + LOCAL = "local" + + +CLOUD_PROVIDERS = { + StorageBackend.AWS: Provider( + name="Amazon Web Services", + roles=[ProviderRole.PRODUCER], + url="https://aws.amazon.com", + ), + StorageBackend.AZURE: Provider( + name="Microsoft", + roles=[ProviderRole.HOST], + url="https://microsoft.com", + ), +} + +THEME_LICENSES = { + Theme.ADDRESSES: { + "href": "https://docs.overturemaps.org/attribution/#addresses", + "title": "CC BY 4.0", + "type": "text/html", + }, + Theme.PLACES: { + "href": "https://cdla.dev/permissive-2-0/", + "title": "CDLA Permissive 2.0", + "type": "text/html", + }, +} + + +@dataclass +class CollectionInfo: + storage_backend: StorageBackend + theme: Theme + latest_release: str + + @property + def theme_description(self) -> str: + """Scrape theme description from OvertureMaps/docs repo""" + # Get the raw content + raw_url = f"https://raw.githubusercontent.com/OvertureMaps/docs/refs/heads/main/docs/guides/{self.theme.value}.mdx" + response = httpx.get(raw_url) + + response.raise_for_status() + + content = response.text + + pattern = "## Overview\n\n(.*?)\n\n##" + match = re.search(pattern, content, re.DOTALL) + + if match: + return match.group(1).strip() + else: + raise ValueError( + f"could not retrive content for the {self.theme.value} theme from {raw_url}" + ) + + def to_collection(self) -> Collection: + extent = Extent( + SpatialExtent([[-180.0, 90.0, 180.0, -90.0]]), + TemporalExtent( + [ + [ + FIRST_RELEASE_DATE, + datetime.strptime(self.latest_release[:10], "%Y-%M-%d"), + ] + ] + ), + ) + + feature_types_md = "\n".join( + f"- {feature_type.value}" + for feature_type in FeatureType.get_types_for_theme(self.theme) + ) + + providers = [ + Provider( + name="Overture Maps Foundation", + roles=[ProviderRole.PRODUCER], + url="https://overturemaps.org/", + ) + ] + if cloud_provider := CLOUD_PROVIDERS.get(self.storage_backend): + providers.append(cloud_provider) + + keywords = [ + feature_type.value[0] + for feature_type in FeatureType.get_types_for_theme(self.theme) + ] + if self.theme != Theme.BASE: + keywords.append(self.theme.value) + + collection = Collection( + id=COLLECTION_ID_FORMAT.format(theme=self.theme.value), + description=COLLECTION_DESCRIPTION_FORMAT.format( + theme=self.theme.value, + theme_description=self.theme_description, + feature_types=feature_types_md, + ), + extent=extent, + license=THEME_LICENSES.get(self.theme, ODBL_LICENSE_ATTRIBUTES)["title"], + providers=providers, + keywords=keywords, + ) + + item_assets_ext = ItemAssetsExtension.ext(collection, add_if_missing=True) + item_assets_ext.item_assets = { + "data": AssetDefinition.create( + media_type=MediaType.PARQUET, + roles=["data"], + title="Geoparquet partition", + description="Geoparquet partition", + ) + } + + # links + collection_license = THEME_LICENSES.get(self.theme, ODBL_LICENSE_ATTRIBUTES) + collection.add_links( + links=[ + Link( + rel=RelType.LICENSE, + target=collection_license["href"], + title=collection_license["title"], + media_type=collection_license["type"], + ) + ] + ) + + return collection + + +@dataclass +class PartitionInfo: + href: str + storage_backend: StorageBackend + release: str + theme: Theme + feature_type: FeatureType + part: str + uid: str + _datetime: datetime + _metadata: Optional[pq.FileMetaData] = None + + @classmethod + def from_href(cls, href: str) -> "PartitionInfo": + """Parse PartitionInfo from a href string. + + Args: + href: URL or file path string following a pattern: + '{protocol}://{netloc}/release/{release}/theme={theme}/type={type}/part-{part}-{uid}.zstd.parquet' + + Returns: + PartitionInfo object + """ + # Parse URL to get just the path portion + parsed_url = urlparse(href) + + protocol = parsed_url.scheme or "file" + + if protocol == "file": + storage_backend = StorageBackend.LOCAL + elif protocol == "s3": + storage_backend = StorageBackend.AWS + elif parsed_url.netloc == AZURE_NETLOC: + storage_backend = StorageBackend.AZURE + else: + raise ValueError(f"could not parse storage backend from {href}") + + path = parsed_url.path + + # If there's no path component (like in s3://), use the whole href + if not path: + path = href + + # Find the 'release' part in the path and only parse from there + release_idx = path.find("/release/") + if release_idx == -1: + raise ValueError(f"could not find /release/ in path: {path}") + + path_to_parse = path[release_idx:] + parsed = parse(PARTITION_FORMAT, path_to_parse) + + if not isinstance(parsed, Result): + raise ValueError(f"could not parse partition info from {href}") + + return cls( + href=href, + storage_backend=storage_backend, + release=parsed["release"], + theme=parsed["theme"], + feature_type=parsed["type"], + part=parsed["part"], + uid=parsed["uid"], + _datetime=datetime.strptime(parsed["release"][:10], "%Y-%M-%d"), + ) + + @property + def metadata(self) -> pq.FileMetaData: + """Parquet file metadata""" + if self._metadata is None: + pyarrow_args: PyarrowArgs + + if self.storage_backend == StorageBackend.AZURE: + import adlfs + + pyarrow_args = { + "where": self.href.replace(f"https://{AZURE_NETLOC}/", ""), + "filesystem": adlfs.AzureBlobFileSystem( + **PYARROW_CONFIGS[self.storage_backend] + ), + } + elif self.storage_backend == StorageBackend.AWS: + import s3fs + + pyarrow_args = { + "where": self.href, + "filesystem": s3fs.S3FileSystem( + **PYARROW_CONFIGS[self.storage_backend] + ), + } + else: + pyarrow_args = {"where": self.href, "filesystem": None} + + self._metadata = pq.read_metadata(**pyarrow_args) + + return self._metadata + + @property + def geo_metadata(self) -> Dict[str, Any]: + return json.loads(self.metadata.metadata[b"geo"].decode("utf-8")) + + @property + def bbox(self) -> List[float]: + return self.geo_metadata["columns"]["geometry"]["bbox"] + + def to_item(self) -> Item: + collection = COLLECTION_ID_FORMAT.format(theme=self.theme) + asset = Asset( + href=self.href, + roles=["data"], + media_type=MediaType.PARQUET, + ) + + item = Item( + id=f"{self.theme}-{self.feature_type}-{self.release}-part-{self.part}-{self.uid}", + datetime=self._datetime, + bbox=self.bbox, + geometry=Polygon.from_bounds(*self.bbox).model_dump(exclude_none=True), + properties={ + "overture:theme": self.theme, + "overture:type": self.feature_type, + }, + assets={"data": asset}, + collection=collection, + ) + + # verion extension + VersionExtension.ext(item, add_if_missing=True) + item.ext.version.version = self.release + + # table extension + table.TableExtension.ext(asset, add_if_missing=True) + if storage_options := PYARROW_CONFIGS.get(self.storage_backend): + asset.ext.table.storage_options = storage_options + + table.TableExtension.ext(item, add_if_missing=True) + item.ext.table.row_count = self.metadata.num_rows + + item.ext.table.columns = [ + table.Column( + properties={ + "name": col["name"], + "col_type": col["type"] + if isinstance(col["type"], str) + else col["type"].get("type"), + } + ) + for col in json.loads( + self.metadata.metadata[b"org.apache.spark.sql.parquet.row.metadata"] + )["fields"] + ] + + # set primary geometry type to first geometry_type in geoparquet metadata + item.ext.table.primary_geometry = self.geo_metadata["columns"]["geometry"][ + "geometry_types" + ][0] + + item.add_link( + Link( + RelType.COLLECTION, + collection, + media_type=MediaType.JSON, + ) + ) + + return item + + +PYARROW_CONFIGS = { + StorageBackend.AWS: {"anon": True}, + StorageBackend.AZURE: {"anon": True, "account_name": "overturemapswestus2"}, +} diff --git a/src/stactools/overture_maps/stac.py b/src/stactools/overture_maps/stac.py index 55d9138..6360509 100644 --- a/src/stactools/overture_maps/stac.py +++ b/src/stactools/overture_maps/stac.py @@ -1,17 +1,20 @@ -from datetime import datetime, timezone - from pystac import ( Collection, - Extent, Item, - SpatialExtent, - TemporalExtent, ) -import stactools.core.create +from stactools.overture_maps.metadata import ( + PYARROW_CONFIGS, + CollectionInfo, + PartitionInfo, + StorageBackend, + Theme, +) -def create_collection() -> Collection: +def create_collection( + theme: Theme, storage_backend: StorageBackend, latest_release: str +) -> Collection: """Creates a STAC Collection. This function should create a collection for this dataset. See `the STAC @@ -24,18 +27,18 @@ def create_collection() -> Collection: Returns: Collection: STAC Collection object """ - extent = Extent( - SpatialExtent([[-180.0, 90.0, 180.0, -90.0]]), - TemporalExtent([[datetime.now(tz=timezone.utc), None]]), + pyarrow_config = PYARROW_CONFIGS.get(storage_backend) + if not storage_backend: + raise ValueError( + f"no configuration for this cloud provider: {storage_backend.value}" + ) + collection_config = CollectionInfo( + storage_backend=storage_backend, + theme=theme, + latest_release=latest_release, ) + collection = collection_config.to_collection() - collection = Collection( - id="example-collection", - title="Example collection", - description="An example collection", - extent=extent, - extra_fields={"custom_attribute": "foo"}, - ) return collection @@ -62,7 +65,8 @@ def create_item(asset_href: str) -> Item: Returns: Item: STAC Item object """ - item = stactools.core.create.item(asset_href) - item.id = "example-item" - item.properties["custom_attribute"] = "foo" + partition_info = PartitionInfo.from_href(asset_href) + + item = partition_info.to_item() + return item diff --git a/tests/cassettes/test_stac/test_create_item[https---overturemapswestus2.blob.core.windows.net-release-2024-12-18.0-theme=buildings-type=building-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet].yaml b/tests/cassettes/test_stac/test_create_item[https---overturemapswestus2.blob.core.windows.net-release-2024-12-18.0-theme=buildings-type=building-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet].yaml new file mode 100644 index 0000000..88e56c2 --- /dev/null +++ b/tests/cassettes/test_stac/test_create_item[https---overturemapswestus2.blob.core.windows.net-release-2024-12-18.0-theme=buildings-type=building-part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet].yaml @@ -0,0 +1,7930 @@ +interactions: +- request: + body: null + headers: + Accept: + - application/xml + User-Agent: + - azsdk-python-storage-blob/12.24.0 Python/3.13.0 (Linux-6.8.0-51-generic-x86_64-with-glibc2.39) + x-ms-client-request-id: + - 60b8726e-c153-11ef-9896-c9ef2e2fb316 + x-ms-date: + - Mon, 23 Dec 2024 17:28:52 GMT + x-ms-version: + - '2025-01-05' + method: HEAD + uri: https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + response: + body: + string: '' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '1074202619' + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:51 GMT + Etag: + - '"0x8DD1F961B620B78"' + Last-Modified: + - Wed, 18 Dec 2024 18:59:32 GMT + Server: + - Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0 + x-ms-access-tier: + - Hot + x-ms-access-tier-inferred: + - 'true' + x-ms-acl: + - user::rw-,group::r--,other::--- + x-ms-blob-type: + - BlockBlob + x-ms-client-request-id: + - 60b8726e-c153-11ef-9896-c9ef2e2fb316 + x-ms-copy-completion-time: + - Wed, 18 Dec 2024 18:59:31 GMT + x-ms-copy-id: + - 9095c449-d3ff-4970-bdb1-5880129928f7 + x-ms-copy-progress: + - 1074202619/1074202619 + x-ms-copy-source: + - https://overturemapswestus2.blob.core.windows.net:443/release/_$azuretmpfolder$/06834b8a-d222-4de1-981a-d1968e73a843part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet?ss=bfqt&api-version=2019-02-02&st=2024-03-07T02%3a47%3a36Z&se=2025-03-01T10%3a47%3a36Z&sv=2022-11-02&srt=sco&spr=https&sp=rwdlacupyx + x-ms-copy-status: + - success + x-ms-creation-time: + - Wed, 18 Dec 2024 18:55:51 GMT + x-ms-group: + - $superuser + x-ms-lease-state: + - available + x-ms-lease-status: + - unlocked + x-ms-meta-hdi_permission: + - '{"owner":"root","group":"supergroup","permissions":"rw-r--r--"}' + x-ms-owner: + - $superuser + x-ms-permissions: + - rw-r----- + x-ms-request-id: + - 475b0f36-e01e-005a-2860-558037000000 + x-ms-resource-type: + - file + x-ms-server-encrypted: + - 'true' + x-ms-version: + - '2025-01-05' + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - application/xml + User-Agent: + - azsdk-python-storage-blob/12.24.0 Python/3.13.0 (Linux-6.8.0-51-generic-x86_64-with-glibc2.39) + x-ms-client-request-id: + - 60e6ecac-c153-11ef-9896-c9ef2e2fb316 + x-ms-date: + - Mon, 23 Dec 2024 17:28:52 GMT + x-ms-version: + - '2025-01-05' + method: HEAD + uri: https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + response: + body: + string: '' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '1074202619' + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:51 GMT + Etag: + - '"0x8DD1F961B620B78"' + Last-Modified: + - Wed, 18 Dec 2024 18:59:32 GMT + Server: + - Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0 + x-ms-access-tier: + - Hot + x-ms-access-tier-inferred: + - 'true' + x-ms-acl: + - user::rw-,group::r--,other::--- + x-ms-blob-type: + - BlockBlob + x-ms-client-request-id: + - 60e6ecac-c153-11ef-9896-c9ef2e2fb316 + x-ms-copy-completion-time: + - Wed, 18 Dec 2024 18:59:31 GMT + x-ms-copy-id: + - 9095c449-d3ff-4970-bdb1-5880129928f7 + x-ms-copy-progress: + - 1074202619/1074202619 + x-ms-copy-source: + - https://overturemapswestus2.blob.core.windows.net:443/release/_$azuretmpfolder$/06834b8a-d222-4de1-981a-d1968e73a843part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet?ss=bfqt&api-version=2019-02-02&st=2024-03-07T02%3a47%3a36Z&se=2025-03-01T10%3a47%3a36Z&sv=2022-11-02&srt=sco&spr=https&sp=rwdlacupyx + x-ms-copy-status: + - success + x-ms-creation-time: + - Wed, 18 Dec 2024 18:55:51 GMT + x-ms-group: + - $superuser + x-ms-lease-state: + - available + x-ms-lease-status: + - unlocked + x-ms-meta-hdi_permission: + - '{"owner":"root","group":"supergroup","permissions":"rw-r--r--"}' + x-ms-owner: + - $superuser + x-ms-permissions: + - rw-r----- + x-ms-request-id: + - 475b0f47-e01e-005a-3460-558037000000 + x-ms-resource-type: + - file + x-ms-server-encrypted: + - 'true' + x-ms-version: + - '2025-01-05' + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - application/xml + User-Agent: + - azsdk-python-storage-blob/12.24.0 Python/3.13.0 (Linux-6.8.0-51-generic-x86_64-with-glibc2.39) + x-ms-client-request-id: + - 60f10282-c153-11ef-9896-c9ef2e2fb316 + x-ms-date: + - Mon, 23 Dec 2024 17:28:52 GMT + x-ms-version: + - '2025-01-05' + method: HEAD + uri: https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + response: + body: + string: '' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '1074202619' + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:51 GMT + Etag: + - '"0x8DD1F961B620B78"' + Last-Modified: + - Wed, 18 Dec 2024 18:59:32 GMT + Server: + - Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0 + x-ms-access-tier: + - Hot + x-ms-access-tier-inferred: + - 'true' + x-ms-acl: + - user::rw-,group::r--,other::--- + x-ms-blob-type: + - BlockBlob + x-ms-client-request-id: + - 60f10282-c153-11ef-9896-c9ef2e2fb316 + x-ms-copy-completion-time: + - Wed, 18 Dec 2024 18:59:31 GMT + x-ms-copy-id: + - 9095c449-d3ff-4970-bdb1-5880129928f7 + x-ms-copy-progress: + - 1074202619/1074202619 + x-ms-copy-source: + - https://overturemapswestus2.blob.core.windows.net:443/release/_$azuretmpfolder$/06834b8a-d222-4de1-981a-d1968e73a843part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet?ss=bfqt&api-version=2019-02-02&st=2024-03-07T02%3a47%3a36Z&se=2025-03-01T10%3a47%3a36Z&sv=2022-11-02&srt=sco&spr=https&sp=rwdlacupyx + x-ms-copy-status: + - success + x-ms-creation-time: + - Wed, 18 Dec 2024 18:55:51 GMT + x-ms-group: + - $superuser + x-ms-lease-state: + - available + x-ms-lease-status: + - unlocked + x-ms-meta-hdi_permission: + - '{"owner":"root","group":"supergroup","permissions":"rw-r--r--"}' + x-ms-owner: + - $superuser + x-ms-permissions: + - rw-r----- + x-ms-request-id: + - 475b0f5b-e01e-005a-4160-558037000000 + x-ms-resource-type: + - file + x-ms-server-encrypted: + - 'true' + x-ms-version: + - '2025-01-05' + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - application/xml + User-Agent: + - azsdk-python-storage-blob/12.24.0 Python/3.13.0 (Linux-6.8.0-51-generic-x86_64-with-glibc2.39) + x-ms-client-request-id: + - 60fb4dd2-c153-11ef-9896-c9ef2e2fb316 + x-ms-date: + - Mon, 23 Dec 2024 17:28:52 GMT + x-ms-range: + - bytes=1074137083-1074202618 + x-ms-version: + - '2025-01-05' + method: GET + uri: https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + response: + body: + string: !!binary | + ByNGRjAwMDAYByM3Nzg4OTkAGRwVABUAFRAAABa+gYWACBXUARa2iNn/BxWSAQAm9vK3zQYcFQoZ + NQYIABkYC3Jvb2ZfaGVpZ2h0FQwWrOcSFpAEFqAFJvbyt80GPDas5xIAGRwVABUAFRAAABaSg4WA + CBXSARbIidn/BxV2ABbY9Z4bFqznEiaq09y+BhbspNsOFHQAGfwmJpb4t80GHBUMGTUGCAAZGAJp + ZBUMFqzxEhaA9acFFpTXvQEmlvi3zQY8NgAoIDA4YmIyYzU3YWVkNzVmZmYwMjAwYjZhMzkyYjAx + MTNlGCAwOGJiMmM1NDQxMDY5ZmZmMDIwMDE4ODhjYjZlODA1MwAZHBUAFQAVEAAAFuSEhYAIFfIB + Fr6K2f8HFdYIACaqz/XOBhwVDBk1BggAGRgIZ2VvbWV0cnkVDBas8RIW5NeGERbg568KJqrP9c4G + PDYAKMMBAAAAAAYAAAACAAAAAAMAAAABAAAABcBRrKv5F65ywECzzDkpFnrAUayqNp/PPsBAs8x9 + G7SRwFGsqV3HW3TAQLO81d7ERsBRrKsf09rewECzvJHsJi7AUayr+ReucsBAs8w5KRZ6AAAAAAMA + AAABAAAABcBRrKkecdsPwECzzJjKZsHAUaynZ7h1/sBAs8zinEHrwFGspnilLUzAQLO9VInFEMBR + rKgvXpJdwECzvQuOqXzAUaypHnHbD8BAs8yYymbBGE0AAAAAAwAAAAEAAAAEwFGiuDozj9zAQNqO + SrhF9MBRorh2wsNFwEDajUyfw2bAUaK5G8B+08BA2o7g6e2qwFGiuDozj9zAQNqOSrhF9AAZHBUA + FQAVJgAAFtaGhYAIFbwEFpST2f8HFbYnACa6o63ZBhwVCBk1BggEGSgEYmJveAR4bWluFQwWrPES + FqCjLha+tiomuqOt2QYmirel2QYcGARg+ozCGASeao3CFgAoBGD6jMIYBJ5qjcIAGSwVBBUEFQIA + FQAVBBUQAAAWkouFgAgV8gEWyrrZ/wcV1gEAJqDc19kGHBUIGTUGCAQZKARiYm94BHhtYXgVDBas + 8RIW4KYuFua4Kiag3NfZBibI7c/ZBhwYBFX6jMIYBHxqjcIWACgEVfqMwhgEfGqNwgAZLBUEFQQV + AgAVABUEFRAAABaEjYWACBXyARagvNn/BxXWAQAmuKKJ2gYcFQgZNQYIBBkoBGJib3gEeW1pbhUM + FqzxEhayqjoWxsYxJriiidoGJq6m+tkGHBgECpgFwhgEBAAHwhYAKAQKmAXCGAQEAAfCABksFQQV + BBUCABUAFQQVEAAAFvaOhYAIFfIBFva92f8HFdYBACag7braBhwVCBk1BggEGSgEYmJveAR5bWF4 + FQwWrPESFsKwOhaQyzEmoO262gYm9Oyr2gYcGATRlwXCGATo/wbCFgAoBNGXBcIYBOj/BsIAGSwV + BBUEFQIAFQAVBBUQAAAW6JCFgAgV8gEWzL/Z/wcV1gEAJsS43doGHBUCGTUGCAQZGAd2ZXJzaW9u + FQwWrPESFv4EFqAGJsS43doGJoS43doGHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQV + BBUCABUAFQQVEAAAFtqShYAIFdIBFqLB2f8HFdYBACbkvt3aBhwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAhwcm9wZXJ0eRUMFqzxEhb+BRagBybkvt3aBiakvt3aBhwYABgAFgAoABgAABks + FQQVBBUCABUAFQQVEAAAFqyUhYAIFdIBFvjC2f8HFVYAJojH3doGHBUMGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50B2RhdGFzZXQVDBas8RIWsNkEFoqUAyaIx93aBibExd3aBhw2ACgNT3BlblN0 + cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFv6VhYAIFeIB + Fs7D2f8HFfYEACbO2eDaBhwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQV + DBas8RIW0obTAhawjXwmztng2gY8NgAoDHc5ODQxNDE3NTRAMRgMMDAwMGZhNjZjNjhmABkcFQAV + ABUQAAAW4JeFgAgV8gEWxMjZ/wcV1gMAJryp3tsGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVt + ZW50C3VwZGF0ZV90aW1lFQwWrPESFsq9HhaEiQomvKne2wYm/ubc2wYcNgAoGDIwMjQtMTEtMjdU + MjI6MDQ6NDkuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAA + FtKZhYAIFe4BFprM2f8HFdYGACaiiujbBhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApj + b25maWRlbmNlFQwWrPESFtqbFBao9BAmooro2wYmgvDm2wYcGAicM6K0N/juPxgIzczMzMzM5D8W + /N0LKAicM6K0N/juPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWwJuFgAgV8gEW8NLZ/wcV + 9gIAJvrk99sGHBUCGTUGCAQZGAVsZXZlbBUMFqzxEha2BxbYCCb65PfbBiaq5PfbBhwYBAMAAAAY + BP////8W4PASKAQDAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFrKdhYAIFdgBFubV2f8HFfYB + ACao7/fbBhwVDBk1BggEGRgHc3VidHlwZRUMFqzxEha0aha2WSao7/fbBiaC7ffbBhw2ksgRKA50 + cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFoqfhYAIFeIBFtzX + 2f8HFZYDACbUyvjbBhwVDBk1BggEGRgFY2xhc3MVDBas8RIWsm4WpF4m1Mr42wYmuMb42wYcNoDM + ESgJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFuyghYAIFeIBFvLa2f8H + FYIDACa0pfnbBhwVChk1BggEGRgGaGVpZ2h0FQwWrPESFpYFFrgGJrSl+dsGJtyk+dsGHBgIAAAA + AAAAFEAYCAAAAAAAABBAFqDxEigIAAAAAAAAFEAYCAAAAAAAABBAABksFQQVBBUCABUAFQQVEAAA + Fs6ihYAIFdIBFvTd2f8HFbYBACaUq/nbBhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFqzxEhbi + 3AIWxs4BJpSr+dsGPDb64xIoGHJlc3RhdXJhbnQgRWwgTXVuZGlhbGl0bxgLIkRvbiBDaGFteSIA + GRwVABUAFRAAABagpIWACBXiARaq39n/BxWyBAAm2vn62wYcFQwZJQYAGUgFbmFtZXMGY29tbW9u + CWtleV92YWx1ZQNrZXkVDBas8RIWrDUW3CQm2vn62wY8NqjxEigCZXMYAmVuABkcFQAVABUQAAAW + gqaFgAgV4gEW3OPZ/wcVhgEAJrae+9sGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUF + dmFsdWUVDBas8RIW6D8Wzicmtp772wY8NqjxEigfTXVzZXVtIG9mIE1lbW9yeSAmIEh1bWFuIFJp + Z2h0cxgFRWtvbm8AGRwVABUAFRAAABbkp4WACBXiARbi5Nn/BxWGAgAmgMf72wYcFQwZJQYEGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBay8RIWwEAW0CgmgMf72wYmhMb72wYc + NobxEigFc2hvcnQYCWFsdGVybmF0ZQAZLBUEFQQVAgAVABUEFRAAABbGqYWACBXiARbo5tn/BxWU + AgAm1O772wYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWsvES + FqQ/FqInJtTu+9sGPDay8RIAGRwVABUAFRAAABaoq4WACBXiARb86Nn/BxV2ACb2lfzbBhwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBay8RIW3EgWkC8m9pX82wY8Nobx + EigCVkYYH0JhbmNvIEJpbGJhbyBWaXpjYXlhIEFyZ2VudGFyaWEAGRwVABUAFRAAABaKrYWACBXi + ARby6dn/BxXSBAAmhsX82wYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdl + ZW4EbGlzdAdlbGVtZW50FQwWsvESFqg/FqQnJobF/NsGPDay8RIAGRwVABUAFRAAABbsroWACBXi + ARbE7tn/BxV2ACaq7PzbBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUM + FrLxEhakPxaiJyaq7PzbBjw2svESABkcFQAVABUQAAAWzrCFgAgV4gEWuu/Z/wcVdgAmzJP92wYc + FQAZNQYIABkYCWhhc19wYXJ0cxUMFqzxEha2sgIWzAYmzJP92wY8GAEBGAEAFgAoAQEYAQAAGRwV + ABUAFRAAABawsoWACBXSARaw8Nn/BxV2ACaYmv3bBhwVABk1BggAGRgOaXNfdW5kZXJncm91bmQV + DBas8RIWtrICFrAGJpia/dsGPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWgrSFgAgV0gEWpvHZ + /wcVdgAm2KH92wYcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBas8RIWjg8W3g8m2KH92wYmyKD92wYc + GAQYAAAAGAQBAAAAFvbpEigEGAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbUtYWACBXeARac + 8tn/BxX2AQAmprD92wYcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBas8RIWoAQW + sAUmprD92wY8GAQBAAAAGAQBAAAAFqrxEigEAQAAABgEAQAAAAAZHBUAFQAVEAAAFrK3hYAIFdIB + FpL02f8HFYYBACbWtf3bBhwVChk1BggAGRgKbWluX2hlaWdodBUMFqzxEhaQBBagBSbWtf3bBjw2 + rPESABkcFQAVABUQAAAWhLmFgAgV0gEWmPXZ/wcVdgAm9rr92wYcFQIZNQYIABkYCW1pbl9mbG9v + chUMFqzxEhaQBBagBSb2uv3bBjw2rPESABkcFQAVABUQAAAW1rqFgAgV0gEWjvbZ/wcVdgAmlsD9 + 2wYcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFqzxEhaQBBagBSaWwP3bBjw2rPESABkcFQAVABUQ + AAAWqLyFgAgV0gEWhPfZ/wcVdgAmtsX92wYcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFqzx + Eha8BBbMBSa2xf3bBjwYDGNlbWVudF9ibG9jaxgMY2VtZW50X2Jsb2NrFqrxEigMY2VtZW50X2Js + b2NrGAxjZW1lbnRfYmxvY2sAGRwVABUAFRAAABb6vYWACBXUARb699n/BxWmAQAmgsv92wYcFQwZ + NQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBas8RIWkAQWoAUmgsv92wY8NqzxEgAZHBUAFQAVEAAAFs6/ + hYAIFdIBFqD52f8HFXYAJqLQ/dsGHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWrPESFpAEFqAFJqLQ + /dsGPDas8RIAGRwVABUAFRAAABagwYWACBXSARaW+tn/BxV2ACbC1f3bBhwVChk1BggAGRgOcm9v + Zl9kaXJlY3Rpb24VDBas8RIWkAQWoAUmwtX92wY8NqzxEgAZHBUAFQAVEAAAFvLChYAIFdIBFoz7 + 2f8HFXYAJuLa/dsGHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWrPESFpAEFqAFJuLa/dsG + PDas8RIAGRwVABUAFRAAABbExIWACBXSARaC/Nn/BxV2ACaC4P3bBhwVDBk1BggAGRgKcm9vZl9j + b2xvchUMFqzxEhaQBBagBSaC4P3bBjw2rPESABkcFQAVABUQAAAWlsaFgAgV0gEW+PzZ/wcVdgAm + ouX92wYcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWrPESFpAEFqAFJqLl/dsGPDas8RIAGRwVABUA + FRAAABbox4WACBXSARbu/dn/BxV2ABaU1pcbFqzxEiaW+LfNBhas8sUOFHYAGfwmJsLq/dsGHBUM + GTUGCAAZGAJpZBUMFsD2EhbQrqkFFvaNvAEmwur92wY8NgAoIDA4YmIyYzU3NzZjZGNmZmYwMjAw + Y2QzNzgzODJmMTYxGCAwOGJiMmM1MDkyNDAwZmZmMDIwMDA1ZDVlZDgyNjIyOAAZHBUAFQAVEAAA + FrrJhYAIFfIBFuT+2f8HFdYIACa4+LndBhwVDBk1BggAGRgIZ2VvbWV0cnkVDBbA9hIWlr2CERb8 + nbAKJrj4ud0GPDYAKI0GAAAAAAMAAAAFAAAAG8BRpQKpJ6wWwEDHuHyzr8XAUaUBym/7O8BAx7hE + f4vRwFGlAoeZvNXAQMewE1iiWcBRpQN0lCaTwEDHsE4RBQvAUaUDX5txCsBAx7E1l5GCwFGlBSZF + DifAQMexp61Yk8BRpQVeDdJRwEDHr0J4SpTAUaUHrkoqxsBAx6/XyYARwFGlB4D9wWHAQMexzkPF + UsBRpQoliE/FwEDHsne28MLAUaUKQTcB9cBAx7FJuYd2wFGlC756I7PAQMexqVrXvcBRpQsDaUEM + wEDHubt4ELPAUaUJ9vnHAcBAx7l4XDIwwFGlCXahRw3AQMe+/4Sv/sBRpQcL+FvHwEDHvmRUPW/A + UaUHLYZLCMBAx7zzOvWfwFGlCBXjlxTAQMe9LfNYUsBRpQhtjMtVwEDHuWKMvRLAUaUF9roGIcBA + x7jEAUwwwFGlBckCPPHAQMe6vq1PWcBRpQPIC5zswEDHuj5Uz2XAUaUD5JEOscBAx7kCFK02wFGl + A2msbATAQMe44wr8s8BRpQOR8FfswEDHtyTE22fAUaUCzGMagsBAx7bzRrQZwFGlAqknrBbAQMe4 + fLOvxQAAAAXAUaUKMASqisBAx7QrFVeAwFGlCZgvNk7AQMe0AE0s2cBRpQlD4QBgwEDHtz3vTtjA + UaUJ27Z0nMBAx7dot3l+wFGlCjAEqorAQMe0KxVXgAAAAAXAUaUIOsyEqMBAx7MkhRqHwFGlB7Gl + KRrAQMey/sVtXcBRpQc42WViwEDHt7hokbrAUaUHwmwgu8BAx7fe/v54wFGlCDrMhKjAQMezJIUa + hwAAAAXAUaUFto3GJ8BAx7SEAKshwFGlBTDBaOvAQMe0YnK738BRpQT4jUT4wEDHttNmRALAUaUF + fsUB/cBAx7b09DNDwFGlBbaNxifAQMe0hACrIQAAAAXAUaUEPlMh5sBAx7LLmcbmwFGlA6qva5PA + QMeyo1Xa/sBRpQNo1axvwEDHtUQaC0TAUaUD/HliwsBAx7VsXfcswFGlBD5TIebAQMeyy5nG5hhN + AAAAAAMAAAABAAAABMBRmJSLxJG1wEDLbZLgqxLAUZiUYXa7YMBAy26lqSqPwFGYk+YBGonAQMtu + cGhfvcBRmJSLxJG1wEDLbZLgqxIAGRwVABUAFSYAABasy4WACBW+BBa6h9r/BxW2JwAmoKz05wYc + FQgZNQYIBBkoBGJib3gEeG1pbhUMFsD2Eha+hjEWyOksJqCs9OcGJrSW6ucGHBgECKCMwhgEGlSN + whYAKAQIoIzCGAQaVI3CABksFQQVBBUCABUAFQQVEAAAFurPhYAIFfIBFvCu2v8HFdYBACa4k6Ho + BhwVCBk1BggEGSgEYmJveAR4bWF4FQwWwPYSFryDMRaW5ywmuJOh6AYm/P+W6AYcGAT6n4zCGAT8 + U43CFgAoBPqfjMIYBPxTjcIAGSwVBBUEFQIAFQAVBBUQAAAW3NGFgAgV8gEWxrDa/wcV1gEAJvLY + zugGHBUIGTUGCAQZKARiYm94BHltaW4VDBbA9hIW1tAyFoi7LSby2M7oBiaS58PoBhwYBIYIBsIY + BC7+BsIWACgEhggGwhgELv4GwgAZLBUEFQQVAgAVABUEFRAAABbO04WACBXyARacstr/BxXWAQAm + mJH86AYcFQgZNQYIBBkoBGJib3gEeW1heBUMFsD2EhamzTIW+rgtJpiR/OgGJpqi8egGHBgEXggG + whgEGf4GwhYAKAReCAbCGAQZ/gbCABksFQQVBBUCABUAFQQVEAAAFsDVhYAIFfIBFvKz2v8HFdYB + ACbU257pBhwVAhk1BggEGRgHdmVyc2lvbhUMFsD2Ehb+BBagBibU257pBiaU257pBhwYBAAAAAAY + BAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABay14WACBXSARbItdr/BxXWAQAm + 9OGe6QYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbA9hIW/AUWngcm + 9OGe6QYmtOGe6QYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABaE2YWACBXSARaet9r/BxVW + ACaW6p7pBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWwPYSFp7bBBaW + igMmluqe6QYm0uie6QYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZ + LBUEFQQVAgAVABUEFRAAABbW2oWACBXiARb0t9r/BxX2BAAm6PKh6QYcFQwZJQYAGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWwPYSFqTPzgIW0vl/JujyoekGPDYAKAx3OTkzNzI0 + MDY2QDEYDDAwMDEzZjkxOGY4OQAZHBUAFQAVEAAAFrjchYAIFfIBFuq82v8HFdYDACas+aLqBhwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFsD2EhaY8RoW/LAIJqz5 + ouoGJrrsoeoGHDYAKBgyMDI0LTExLTI3VDE5OjQyOjA0LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6 + MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABaq3oWACBXmARbAwNr/BxXWBgAmrrCr6gYcFQoZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsD2EhayxxIWgpgPJq6wq+oGJrad + quoGHBgIXynLEMe67j8YCM3MzMzMzOQ/FvrZDCgIXynLEMe67j8YCM3MzMzMzOQ/ABksFQQVBBUC + ABUAFQQVEAAAFpDghYAIFfIBFpbH2v8HFfYCACaAtrnqBhwVAhk1BggEGRgFbGV2ZWwVDBbA9hIW + 8gYWlAgmgLa56gYmuLW56gYcGAQBAAAAGAT/////FvT1EigEAQAAABgE/////wAZLBUEFQQVAgAV + ABUEFRAAABaC4oWACBXWARaMytr/BxX2AQAm2L+56gYcFQwZNQYIBBkYB3N1YnR5cGUVDBbA9hIW + tmYWwlYm2L+56gYmzL256gYcNtbbESgHc2VydmljZRgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUA + FQQVEAAAFtjjhYAIFeIBFoLM2v8HFfwCACbSmLrqBhwVDBk1BggEGRgFY2xhc3MVDBbA9hIWqGUW + zlgm0pi66gYmjpS66gYcNqbfESgKdW5pdmVyc2l0eRgPYWxsb3RtZW50X2hvdXNlABksFQQVBBUC + ABUAFQQVEAAAFrrlhYAIFeIBFv7O2v8HFZIDACbc7LrqBhwVChk1BggAGRgGaGVpZ2h0FQwWwPYS + FqgSFrgKJtzsuuoGPBgIAAAAAADARUAYCAAAAAAAAAhAFoj1EigIAAAAAADARUAYCAAAAAAAAAhA + ABkcFQAVABUQAAAWnOeFgAgV3AEWkNLa/wcVlgIAJpT3uuoGHBUMGTUGCAAZKAVuYW1lcwdwcmlt + YXJ5FQwWwPYSFrrWAhb8yAEmlPe66gY8NsjpEigHdG9ycmUgNBgINCBQdW50b3MAGRwVABUAFRAA + ABb46IWACBXiARam1Nr/BxWEBAAmkMC86gYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1 + ZQNrZXkVDBbC9hIWgjoWrCcmkMC86gY8Nrj2EigCemgYAmVuABkcFQAVABUQAAAW2uqFgAgV4gEW + qtja/wcVjgEAJrznvOoGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbC + 9hIWhEYWrCkmvOe86gY8Nrj2EigG5pen6ZO6GCsxYSBDb21wYcOxw61hIGRlIEJvbWJlcm9zIE1l + dHJvcG9saXRhbm8gU3VyABkcFQAVABUQAAAWvOyFgAgV4gEWuNna/wcVlgMAJuiQveoGHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWxvYSFsRHFv4pJuiQveoGPDag + 9hIoBXNob3J0GAlhbHRlcm5hdGUAGRwVABUAFRAAABae7oWACBXiARbO3Nr/BxW2AgAm5rq96gYc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWxvYSFvhDFqAnJua6 + veoGPDbG9hIAGRwVABUAFRAAABaA8IWACBXiARaE39r/BxV2ACaG4r3qBhwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbG9hIWkkwWjC4mhuK96gY8NqD2EigDVUREGB9C + YW5jbyBkZSBDcsOpZGl0byBlIEludmVyc2lvbmVzABkcFQAVABUQAAAW4vGFgAgV4gEW+t/a/wcV + hgUAJpKQvuoGHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QH + ZWxlbWVudBUMFsb2Ehb+QxamJyaSkL7qBjw2xvYSABkcFQAVABUQAAAWxPOFgAgV4gEWgOXa/wcV + dgAmuLe+6gYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbG9hIW+EMW + oCcmuLe+6gY8Nsb2EgAZHBUAFQAVEAAAFqb1hYAIFeIBFvbl2v8HFXYAJtjevuoGHBUAGTUGCAAZ + GAloYXNfcGFydHMVDBbA9hIWiLMCFswGJtjevuoGPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAW + iPeFgAgV0gEW7Oba/wcVdgAmpOW+6gYcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWwPYSFoiz + AhawBiak5b7qBjwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFtr4hYAIFdIBFuLn2v8HFXYAJv7s + vuoGHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWwPYSFq4VFuIVJv7svuoGJtTrvuoGHBgEEgAAABgE + AQAAABbW4xIoBBIAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWrPqFgAgV3gEW2Oja/wcV9gEA + JraBv+oGHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWwPYSFqIEFrIFJraBv+oG + PBgEAgAAABgEAgAAABa+9hIoBAIAAAAYBAIAAAAAGRwVABUAFRAAABaK/IWACBXSARbO6tr/BxWG + AQAm6Ia/6gYcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbA9hIWkAQWoAUm6Ia/6gY8NsD2EgAZHBUA + FQAVEAAAFtz9hYAIFdIBFtTr2v8HFXYAJoiMv+oGHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbA9hIW + kAQWoAUmiIy/6gY8NsD2EgAZHBUAFQAVEAAAFq7/hYAIFdIBFsrs2v8HFXYAJqiRv+oGHBUMGTUG + CAAZGAxmYWNhZGVfY29sb3IVDBbA9hIW9gUWxAYmqJG/6gY8NrD2EigHI0ZGRkZGRhgHIzY3MDAy + MAAZHBUAFQAVEAAAFoCBhoAIFdYBFsDt2v8HFa4BACbsl7/qBhwVDBk1BggAGRgPZmFjYWRlX21h + dGVyaWFsFQwWwPYSFsYLFuAGJuyXv+oGPDbm9RIoCGNvbmNyZXRlGAVicmljawAZHBUAFQAVEAAA + FtaChoAIFdYBFu7u2v8HFaoBACbMnr/qBhwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFsD2Eha+ + DRacBibMnr/qBjwYCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMW8PUSKApyb29mX3RpbGVzGApyb29m + X3RpbGVzABkcFQAVABUQAAAWrISGgAgV1AEWmPDa/wcVngEAJuikv+oGHBUMGTUGCAAZGApyb29m + X3NoYXBlFQwWwPYSFrAMFrgGJuikv+oGPDbg9RIoBmhpcHBlZBgGZ2FibGVkABkcFQAVABUQAAAW + gIaGgAgV1AEWtvHa/wcVjgEAJqCrv+oGHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFsD2EhaQ + BBagBSagq7/qBjw2wPYSABkcFQAVABUQAAAW1IeGgAgV0gEWxPLa/wcVdgAmwLC/6gYcFQwZNQYI + ABkYEHJvb2Zfb3JpZW50YXRpb24VDBbA9hIWxgUW7gUmwLC/6gY8NrD2EigFYWxvbmcYBmFjcm9z + cwAZHBUAFQAVEAAAFqaJhoAIFdQBFrrz2v8HFYwBACautr/qBhwVDBk1BggAGRgKcm9vZl9jb2xv + chUMFsD2EhauBRaUBiautr/qBjw2tvYSKAcjNzc4ODk5GAcjMDAwMDAwABkcFQAVABUQAAAW+oqG + gAgV1AEWxvTa/wcVrgEAJsK8v+oGHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFsD2EhbWChaSBybC + vL/qBjwYCAAAAAAAAAhAGAhcj8L1KFznPxbi9RIoCAAAAAAAAAhAGAhcj8L1KFznPwAZHBUAFQAV + EAAAFs6MhoAIFdQBFvT12v8HFZYBABbi6YEbFsD2EibC6v3bBhaS2cEOFHgAGfwmJtTDv+oGHBUM + GTUGCAAZGAJpZBUMFtiMExawza8FFo6+vQEm1MO/6gY8NgAoIDA4YmIyYzU3MzRiYjVmZmYwMjAw + ZDNiMzk0MmJiODY2GCAwOGJiMmM1MDgwMDAxZmZmMDIwMDRkZmYxZTE1YWVkNgAZHBUAFQAVEAAA + FqKOhoAIFfIBFor32v8HFdYIACbigf3rBhwVDBk1BggAGRgIZ2VvbWV0cnkVDBbYjBMW7pD5EBa4 + v4sKJuKB/esGPDYAKMACAAAAAAYAAAADAAAAAAMAAAABAAAAB8BRqmxXrI9AwEC8PeK5nhzAUapr + 4I5KscBAvEeF0I75wFGqaSTyJ9DAQLxHJ9y93MBRqml0N+BBwEC8QLux8lbAUappLixjNcBAvECy + d7bxwFGqaVYE71PAQLw9e4uRmcBRqmxXrI9AwEC8PeK5nhwAAAAAAwAAAAEAAAAFwFGqcXttXqjA + QLw+fDyRgcBRqnFcY64lwEC8Q+iNHLTAUapvKe7m08BAvEOd5IH1wFGqb212JSDAQLw+SDordcBR + qnF7bV6owEC8Pnw8kYEAAAAAAwAAAAEAAAAFwFGqdG7SRbPAQLw+xuUsP8BRqnRLltdHwEC8SCUy + v3DAUapxWXQPnMBAvEfn9h3/wFGqcaGYa5zAQLw+eo8SV8BRqnRu0kWzwEC8PsblLD8YTQAAAAAD + AAAAAQAAAATAUaP5MD79CsBAyCAf4RAEwFGj+ROklWnAQMge/r1+ZsBRo/nRVHJUwEDIH/M0ouHA + UaP5MD79CsBAyCAf4RAEABkcFQAVABUmAAAWlJCGgAgVvAQW4P/a/wcVticAJv7ijvYGHBUIGTUG + CAQZKARiYm94BHhtaW4VDBbYjBMWvuQrFqzHKCb+4o72BiaawYj2BhwYBOT6jMIYBB5UjcIWACgE + 5PqMwhgEHlSNwgAZLBUEFQQVAgAVABUEFRAAABbQlIaACBXyARaWp9v/BxXWAQAm2Kq39gYcFQgZ + NQYIBBkoBGJib3gEeG1heBUMFtiMExaI5SsW9McoJtiqt/YGJsaIsfYGHBgE3/qMwhgE/VONwhYA + KATf+ozCGAT9U43CABksFQQVBBUCABUAFQQVEAAAFsKWhoAIFfIBFuyo2/8HFdYBACa8+eL2BhwV + CBk1BggEGSgEYmJveAR5bWluFQwW2IwTFoaBMBa2/ysmvPni9gYmutDZ9gYcGASK2wXCGAQwTAbC + FgAoBIrbBcIYBDBMBsIAGSwVBBUEFQIAFQAVBBUQAAAWtJiGgAgV8gEWwqrb/wcV1gEAJoz5jvcG + HBUIGTUGCAQZKARiYm94BHltYXgVDBbYjBMWhoEwFtD/KyaM+Y73Bibwz4X3BhwYBBrbBcIYBPhL + BsIWACgEGtsFwhgE+EsGwgAZLBUEFQQVAgAVABUEFRAAABammoaACBXyARaYrNv/BxXWAQAmgNCx + 9wYcFQIZNQYIBBkYB3ZlcnNpb24VDBbYjBMW/gQWoAYmgNCx9wYmwM+x9wYcGAQAAAAAGAQAAAAA + FgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWmJyGgAgV0gEW7q3b/wcV1gEAJqDWsfcG + HBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW2IwTFv4FFqAHJqDWsfcG + JuDVsfcGHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW6p2GgAgV0gEWxK/b/wcVVgAmxN6x + 9wYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFtiMExbq3gQWnKEDJsTe + sfcGJoDdsfcGHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUE + FQIAFQAVBBUQAAAWvJ+GgAgV4gEWmrDb/wcV9gQAJpz+tPcGHBUMGSUGABlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50CXJlY29yZF9pZBUMFtiMExaawdACFuiAeSac/rT3Bjw2ACgMdzk5MDE2NDc4OEAx + GAwwMDAwZjkxM2JmMTgAGRwVABUAFRAAABaeoYaACBXyARaQtdv/BxXWAwAmouKv+AYcFQwZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbYjBMWjIMhFoCKDCai4q/4BiaE + /634Bhw2ACgYMjAyNC0xMS0yOVQxNzoyNTowMi4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAw + MFoAGSwVBBUEFQIAFQAVBBUQAAAWkKOGgAgV8AEW5rjb/wcV1gYAJt6Yu/gGHBUKGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbYjBMW6pgSFqrlDibemLv4BiaEibr4BhwY + COeMKO0Nvu4/GAjNzMzMzMzkPxaclA0oCOeMKO0Nvu4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUE + FRAAABaApYaACBXyARa8v9v/BxX2AgAm/u7I+AYcFQIZNQYIBBkYBWxldmVsFQwW2IwTFsQIFswJ + Jv7uyPgGJq7uyPgGHBgEAgAAABgE/////xbiixMoBAIAAAAYBP////8AGSwVBBUEFQIAFQAVBBUQ + AAAW8qaGgAgV2gEWssLb/wcV1gEAJqD6yPgGHBUMGTUGCAQZGAdzdWJ0eXBlFQwW2IwTFprDARaS + pAEmoPrI+AYm+vfI+AYcNr6NECgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQV + AgAVABUEFRAAABbMqIaACBXiARaIxNv/BxWwAwAmpKHK+AYcFQwZNQYIBBkYBWNsYXNzFQwW2IwT + FpjmARbgugEmpKHK+AYmjJzK+AYcNvSSECgJd2FyZWhvdXNlGA9hbGxvdG1lbnRfaG91c2UAGSwV + BBUEFQIAFQAVBBUQAAAWrqqGgAgV4gEWuMfb/wcVpgMAJtzYy/gGHBUKGTUGCAQZGAZoZWlnaHQV + DBbYjBMWuBMW9hEm3NjL+AYm7NbL+AYcGAgAAAAAAMBZQBgIAAAAAAAA8D8W5IITKAgAAAAAAMBZ + QBgIAAAAAAAA8D8AGSwVBBUEFQIAFQAVBBUQAAAWkKyGgAgV2AEW3srb/wcVlgIAJqqEzfgGHBUM + GTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwW2IwTFvSiAxai2wEmqoTN+AYm4ujL+AYcNrL8EigSw5Nw + dGljYSBOZXdHbGFzc2VzGB8xIEp1emdhZG8gZGUgRmFtaWxpYSBTYW4gTWlndWVsABksFQQVBBUC + ABUAFQQVEAAAFuithoAIFeIBFvTM2/8HFYYFACaExM34BhwVDBklBgAZSAVuYW1lcwZjb21tb24J + a2V5X3ZhbHVlA2tleRUMFtyMExbMPxbWKSaExM34Bjw2wIwTKAJlcxgCZW4AGRwVABUAFRAAABbK + r4aACBXiARb60dv/BxWeAQAm2u3N+AYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2 + YWx1ZRUMFtyMExbgThauLiba7c34Bjw2wIwTKBFZaW4tSGUgUmVzdGF1dGFudBgVQWNhZGVteSBv + ZiBQaGlsb3NvcGh5ABkcFQAVABUQAAAWrLGGgAgV4gEWmNPb/wcVyAMAJoSdzvgGHBUMGSUGBBlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW4IwTFspLFtwrJoSdzvgGJoiczvgG + HDagjBMoBXNob3J0GAlhbHRlcm5hdGUAGSwVBBUEFQIAFQAVBBUQAAAWjrOGgAgV4gEW4Nbb/wcV + vAIAJuTHzvgGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFuCM + ExasShaoKibkx874Bjw24IwTABkcFQAVABUQAAAW8LSGgAgV4gEWnNnb/wcVdgAmjPLO+AYcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW4IwTFv5WFrg0JozyzvgGPDag + jBMoD1TDum5lbCBVbml2ZXJzbxgaNHRhIENvbWlzYXLDrWEgZGUgU2FudGlhZ28AGRwVABUAFRAA + ABbStoaACBXiARaS2tv/BxXKBAAmxKbP+AYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW4IwTFrZKFrYqJsSmz/gGPDbgjBMAGRwVABUAFRAA + ABa0uIaACBXiARbc3tv/BxV2ACb60M/4BhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQEc2lkZRUMFuCMExasShaoKib60M/4Bjw24IwTABkcFQAVABUQAAAWlrqGgAgV4gEW0t/b/wcV + dgAmovvP+AYcFQAZNQYIABkYCWhhc19wYXJ0cxUMFtiMExbstQIWwgYmovvP+AY8GAEBGAEAFgAo + AQEYAQAAGRwVABUAFRAAABb4u4aACBXSARbI4Nv/BxV2ACbkgdD4BhwVABk1BggAGRgOaXNfdW5k + ZXJncm91bmQVDBbYjBMW7LUCFrAGJuSB0PgGPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWyr2G + gAgV0gEWvuHb/wcVdgAmqonQ+AYcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbYjBMWiDAWziomqonQ + +AYmlIjQ+AYcGAQkAAAAGAQBAAAAFqLiEigEJAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABac + v4aACBXiARa04tv/BxX2AQAm4rLQ+AYcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQV + DBbYjBMWxgQW1gUm4rLQ+AY8GAQCAAAAGAQBAAAAFtKMEygEAgAAABgEAQAAAAAZHBUAFQAVEAAA + Fv7AhoAIFdIBFqrk2/8HFZYBACa4uND4BhwVChk1BggAGRgKbWluX2hlaWdodBUMFtiMExaQBBag + BSa4uND4Bjw22IwTABkcFQAVABUQAAAW0MKGgAgV0gEWwOXb/wcVdgAm2L3Q+AYcFQIZNQYIABkY + CW1pbl9mbG9vchUMFtiMExaQBBagBSbYvdD4Bjw22IwTABkcFQAVABUQAAAWosSGgAgV0gEWtubb + /wcVdgAm+MLQ+AYcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFtiMExbOBBbeBSb4wtD4BjwYByNG + RkZGRkYYByNGRkZGRkYW1IwTKAcjRkZGRkZGGAcjRkZGRkZGABkcFQAVABUQAAAW9MWGgAgV0gEW + rOfb/wcVrgEAJtbI0PgGHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbYjBMW0AQW4AUm1sjQ + +AY8NtSMEygIY29uY3JldGUYBWJyaWNrABkcFQAVABUQAAAWxseGgAgV1AEW2ujb/wcVkAEAJrbO + 0PgGHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW2IwTFrYEFsYFJrbO0PgGPBgKcm9vZl90aWxl + cxgKcm9vZl90aWxlcxbWjBMoCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMAGRwVABUAFRAAABaayYaA + CBXSARbq6dv/BxWeAQAm3NTQ+AYcFQwZNQYIBBkYCnJvb2Zfc2hhcGUVDBbYjBMWtgUW2AYm3NTQ + +AYm/NPQ+AYcNr6MEygGaGlwcGVkGAZnYWJsZWQAGSwVBBUEFQIAFQAVBBUQAAAW7MqGgAgV0gEW + iOvb/wcVvgEAJtTa0PgGHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFtiMExaQBBagBSbU2tD4 + Bjw22IwTABkcFQAVABUQAAAWvsyGgAgV0gEWxuzb/wcVdgAm9N/Q+AYcFQwZNQYIABkYEHJvb2Zf + b3JpZW50YXRpb24VDBbYjBMW/gQW5AUm9N/Q+AY8GAVhbG9uZxgFYWxvbmcWzowTKAVhbG9uZxgF + YWxvbmcAGRwVABUAFRAAABaQzoaACBXSARa87dv/BxWeAQAm2OXQ+AYcFQwZNQYIABkYCnJvb2Zf + Y29sb3IVDBbYjBMWkgUW7AUm2OXQ+AY8Ns6MEygHI0ZGRkZGRhgHIzhCNDUxMwAZHBUAFQAVEAAA + FuLPhoAIFdQBFtru2/8HFa4BACbE69D4BhwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbYjBMWkAQW + oAUmxOvQ+AY8NtiMEwAZHBUAFQAVEAAAFrbRhoAIFdIBFojw2/8HFXYAFoq3+RoW2IwTJtTDv+oG + FpCtkQ4UegAZ/CYm5PDQ+AYcFQwZNQYIABkYAmlkFQwWsNASFozSngUWkMS6ASbk8ND4Bjw2ACgg + MDhiYjJjNTU2ZWRiNmZmZjAyMDBjMGZhNjM3MTQ0NmQYIDA4YmIyYzUwODA5MDBmZmYwMjAwNmNl + M2Q4ZjYyN2Q3ABkcFQAVABUQAAAWiNOGgAgV8gEW/vDb/wcV1ggAJvS0i/oGHBUMGTUGCAAZGAhn + ZW9tZXRyeRUMFrDQEhai1fMRFpTK2Qom9LSL+gY8ABkcFQAVABUoAAAW+tSGgAgV2gQW1Pnb/wcV + vikAJqSJ64QHHBUIGTUGCAQZKARiYm94BHhtaW4VDBaw0BIW9qkqFq6YJyakieuEByaI/+SEBxwY + BJ4FjcIYBDVUjcIWACgEngWNwhgENVSNwgAZLBUEFQQVAgAVABUEFRAAABbU2YaACBXyARaSo9z/ + BxXWAQAmgKKShQccFQgZNQYIBBkoBGJib3gEeG1heBUMFrDQEhauqioWxqEnJoCikoUHJraXjIUH + HBgElQWNwhgE/FONwhYAKASVBY3CGAT8U43CABksFQQVBBUCABUAFQQVEAAAFsbbhoAIFfIBFuik + 3P8HFdYBACaI77qFBxwVCBk1BggEGSgEYmJveAR5bWluFQwWsNASFpz5LBaWmykmiO+6hQcm/Liz + hQccGAQGmAXCGARg8gXCFgAoBAaYBcIYBGDyBcIAGSwVBBUEFQIAFQAVBBUQAAAWuN2GgAgV8gEW + vqbc/wcV1gEAJu6J5IUHHBUIGTUGCAQZKARiYm94BHltYXgVDBaw0BIW3vgsFuiaKSbuieSFByaS + 1NyFBxwYBJ6XBcIYBPzxBcIWACgEnpcFwhgE/PEFwgAZLBUEFQQVAgAVABUEFRAAABaq34aACBXy + ARaUqNz/BxXWAQAmuu+FhgccFQIZNQYIBBkYB3ZlcnNpb24VDBaw0BIW/gQWoAYmuu+Fhgcm+u6F + hgccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWnOGGgAgV0gEW + 6qnc/wcV1gEAJtr1hYYHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW + sNASFv4FFqAHJtr1hYYHJpr1hYYHHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW7uKGgAgV + 0gEWwKvc/wcVVgAm/v2FhgccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUM + FrDQEhbcxQQWjp4DJv79hYYHJrr8hYYHHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBC + dWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWwOSGgAgV4gEWlqzc/wcV9gQAJsiaiYYHHBUMGSUG + ABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFrDQEhbO+McCFo6ccCbImomGBzw2 + ACgMdzk5NDk2MTgzOEAxGAwwMDA2ZGI5ZDNhZmMAGRwVABUAFRAAABai5oaACBXyARaMsdz/BxXW + AwAmnL6AhwccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBaw0BIW + 7t8+FuKvFSacvoCHBybWtvmGBxw2ACgYMjAyNC0xMS0zMFQxODo1MTo1Ni4wMDBaGBgyMDAwLTAx + LTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWlOiGgAgV8AEW4rTc/wcV1gYAJpT6 + j4cHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBaw0BIWzLQRFuyE + DiaU+o+HBya45o6HBxwYCGwJ+aBns+4/GAjNzMzMzMzkPxbihA0oCGwJ+aBns+4/GAjNzMzMzMzk + PwAZLBUEFQQVAgAVABUEFRAAABaE6oaACBXyARa4u9z/BxX2AgAmlOychwccFQIZNQYIBBkYBWxl + dmVsFQwWsNASFoQSFvAQJpTsnIcHJqTrnIcHHBgEBQAAABgE/P///xbgzBIoBAUAAAAYBPz///8A + GSwVBBUEFQIAFQAVBBUQAAAW9uuGgAgV4AEWrr7c/wcV9gEAJrr+nIcHHBUMGTUGCAQZGAdzdWJ0 + eXBlFQwWsNASFrycAhbE5AEmuv6chwcmlPychwccNpSIDygOdHJhbnNwb3J0YXRpb24YDGFncmlj + dWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABbW7YaACBXiARakwNz/BxW0AwAm+OaehwccFQwZNQYI + BBkYBWNsYXNzFQwWsNASFtaJAxbAmwIm+Oaehwcm2OCehwccNvyVDygJd2FyZWhvdXNlGA9hbGxv + dG1lbnRfaG91c2UAGSwVBBUEFQIAFQAVBBUQAAAWuO+GgAgV4gEW2MPc/wcVsgMAJpj8oIcHHBUK + GTUGCAAZGAZoZWlnaHQVDBaw0BIWhCEWlhEmmPyghwc8GAgAAAAAAMByQBgIAAAAAAAA8D8WpM0S + KAgAAAAAAMByQBgIAAAAAAAA8D8AGRwVABUAFRAAABaa8YaACBXgARaKx9z/BxX2AgAmsIilhwcc + FQwZNQYIBBkoBW5hbWVzB3ByaW1hcnkVDBaw0BIWoKULFsazBSawiKWHByaujaGHBxw2kpUSKBTD + kXXDsW9hIFZpZGEgVG9ycmUgMhgdMSBDb21pc2Fyw61hIFNhbnRpYWdvIENlbnRyYWwAGSwVBBUE + FQIAFQAVBBUQAAAW+vKGgAgV4gEWgMrc/wcV7gUAJrLCpocHHBUMGSUGBBlIBW5hbWVzBmNvbW1v + bglrZXlfdmFsdWUDa2V5FQwWptESFqykARbwXyaywqaHByb0wKaHBxw2mM8SKAJ6aBgCYXIAGSwV + BBUEFQIAFQAVBBUQAAAW3PSGgAgV4gEW7s/c/wcVrgEAJuSgp4cHHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUFdmFsdWUVDBam0RIW7vwBFtaGASbkoKeHBzw2mM8SKBfsuaDroIgg7Iic + 67O17J2MIOq1kO2ajBgPQUROIFJhZGlvIENoaWxlABkcFQAVABUQAAAWvvaGgAgV4gEWnNHc/wcV + zgUAJraoqIcHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWoNES + FoDJARakaCa2qKiHBya6p6iHBxw2vs0SKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQV + EAAAFqD4hoAIFeIBFurW3P8HFeQCACbej6mHBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQIbGFuZ3VhZ2UVDBag0RIW9MgBFrJmJt6PqYcHPDb00BIoAnB0GAJlbgAZHBUAFQAVEAAA + FoL6hoAIFeIBFs7Z3P8HFZ4BACbwmKqHBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQFdmFsdWUVDBag0RIWpIsCFpaNASbwmKqHByaQ9qmHBxw2vs0SKAJVThgEQUNIUwAZLBUEFQQV + AgAVABUEFRAAABbk+4aACBXiARbs2tz/BxX8BAAmpoOrhwccFQoZJQYAGXgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWoNESFr7HARa6ZSamg6uHBzw2oNES + ABkcFQAVABUQAAAWxv2GgAgV4gEW6N/c/wcVdgAm4OirhwccFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50BHNpZGUVDBag0RIW8MYBFrBlJuDoq4cHPDag0RIAGRwVABUAFRAAABao/4aA + CBXiARbe4Nz/BxV2ACaQzqyHBxwVABk1BggAGRgJaGFzX3BhcnRzFQwWsNASFqiuAhbkCiaQzqyH + BzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFoqBh4AIFdwBFtTh3P8HFXYAJvTYrIcHHBUAGTUG + CAAZGA5pc191bmRlcmdyb3VuZBUMFrDQEhakrgIWrgYm9Nishwc8GAEAGAEAFgAoAQAYAQAAGRwV + ABUAFRAAABbmgoeACBXSARbK4tz/BxV2ACbW4KyHBxwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFrDQ + Ehae3gEW8LYBJtbgrIcHJqLfrIcHHBgEQAAAABgEAQAAABaCrREoBEAAAAAYBAEAAAAAGSwVBBUE + FQIAFQAVBBUQAAAWuISHgAgV4gEWwOPc/wcV9gEAJpKWrocHHBUCGTUGCAAZGBZudW1fZmxvb3Jz + X3VuZGVyZ3JvdW5kFQwWsNASFqoHFpYIJpKWrocHPBgEBwAAABgEAQAAABaA0BIoBAcAAAAYBAEA + AAAAGRwVABUAFRAAABaahoeACBXYARa25dz/BxXWAQAmqJ6uhwccFQoZNQYIABkYCm1pbl9oZWln + aHQVDBaw0BIW1AQW5AUmqJ6uhwc8GAgAAAAAAAA7QBgIAAAAAAAAAAAWqtASKAgAAAAAAAA7QBgI + AAAAAAAAAAAAGRwVABUAFRAAABbyh4eACBXSARaM59z/BxW2AQAmjKSuhwccFQIZNQYIABkYCW1p + bl9mbG9vchUMFrDQEhaiBBayBSaMpK6HBzwYBAEAAAAYBAEAAAAWrtASKAQBAAAAGAQBAAAAABkc + FQAVABUQAAAWxImHgAgV0gEWwujc/wcVhgEAJr6procHHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IV + DBaw0BIW4gYWqgcmvqmuhwc8NprQEigHI0ZGRkZGRhgHIzQ4NTk2QgAZHBUAFQAVEAAAFpaLh4AI + FdgBFsjp3P8HFeYBACbosK6HBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWsNASFrIQFpgL + JuiwrocHPDayzxIoB3BsYXN0ZXIYBWJyaWNrABkcFQAVABUQAAAW7oyHgAgV3AEWruvc/wcVjAIA + JoC8rocHHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWsNASFoQFFogGJoC8rocHPDao0BIoCnJv + b2ZfdGlsZXMYBWdsYXNzABkcFQAVABUQAAAWyo6HgAgV1AEWuu3c/wcVlAEAJv7DrocHHBUMGTUG + CAQZGApyb29mX3NoYXBlFQwWsNASFr4pFtokJv7DrocHJojCrocHHDakuBIoCHNraWxsaW9uGARk + b21lABksFQQVBBUCABUAFQQVEAAAFp6Qh4AIFd4BFs7u3P8HFZQCACbi5q6HBxwVChk1BggAGRgO + cm9vZl9kaXJlY3Rpb24VDBaw0BIWqgQWugUm4uauhwc8GAgAAAAAAABZQBgIAAAAAAAAWUAWrtAS + KAgAAAAAAABZQBgIAAAAAAAAWUAAGRwVABUAFRAAABb8kYeACBXSARbi8Nz/BxWWAQAmnOyuhwcc + FQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBaw0BIWshsWlgcmnOyuhwc8Nv7NEigFYWxvbmcY + BmFjcm9zcwAZHBUAFQAVEAAAFs6Th4AIFdYBFvjx3P8HFbgBACay866HBxwVDBk1BggAGRgKcm9v + Zl9jb2xvchUMFrDQEhamBRa2Biay866HBzw2ptASKAcjRkZGRkZGGAcjNzc4ODk5ABkcFQAVABUQ + AAAWpJWHgAgV1AEWsPPc/wcV5gEAJuj5rocHHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFrDQEhbA + BRasBibo+a6HBzwYCAAAAAAAAC5AGAiamZmZmZnZPxag0BIoCAAAAAAAAC5AGAiamZmZmZnZPwAZ + HBUAFQAVEAAAFviWh4AIFdYBFpb13P8HFdYBABbo0YEcFrDQEibk8ND4Bhawj94OFHwAGfwmJpSA + r4cHHBUMGTUGCAAZGAJpZBUMFsyaExb+wbMFFobcwQEmlICvhwc8NgAoIDA4YmIyYzVjZGE3YjZm + ZmYwMjAwZWRjNWFjZTExNGY2GCAwOGJiMmM0MjQwMDlhZmZmMDIwMDJkMTE4ZjdlZjM2MAAZHBUA + FQAVEAAAFs6Yh4AIFfIBFuz23P8HFdYIACaa3PCIBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBbMmhMW + 9MLlEBaG8ZMKJprc8IgHPDYAKOMCAAAAAAYAAAACAAAAAAMAAAABAAAACcBRsN1B+nZTwECw27Fs + HjbAUbDPYdKC78BAsOvMbFS9wFGwusO1zNbAQLC6Qa/NucBRsMhOuMq3wECwqojVJjjAUbDTpgTh + 58BAsMXJo0yhwFGw0qEiJBfAQLDG+U41F8BRsNjvGf6vwECw1h9b5drAUbDaSY0RzMBAsNSMtK7J + wFGw3UH6dlPAQLDbsWweNgAAAAADAAAAAQAAAAvAUbDddE9dNcBAsOE+c9kWwFGw4+Sr5qPAQLDw + 8W9DhcBRsOUUwi7kwECw75YlcNPAUbDrw515IsBAsP/G9Rx3wFGw6l6uC0HAQLEBV+7UX8BRsPI2 + EuGEwECxE6rXr3/AUbDlCCz1LMBAsSVgC9lSwFGw2XaT2xTAQLEJKkstJcBRsNoQ7Y4NwECxCHoi + BQ7AUbDQMdwbHsBAsPBos0fBwFGw3XRPXTXAQLDhPnPZFhhNAAAAAAMAAAABAAAABMBRosI40xcJ + wEC1JWpIoavAUaLB+CpJVcBAtSQ4ptomwFGiws5SFcLAQLUlEU+6J8BRosI40xcJwEC1JWpIoasA + GRwVABUAFSYAABbAmoeACBW+BBbC/9z/BxW2JwAmxI+RkwccFQgZNQYIBBkoBGJib3gEeG1pbhUM + FsyaExbI9jUW2PIuJsSPkZMHJqDNhJMHHBgEg6CMwhgEBgiOwhYAKASDoIzCGAQGCI7CABksFQQV + BBUCABUAFQQVEAAAFv6eh4AIFfIBFvim3f8HFdYBACaI/b+TBxwVCBk1BggEGSgEYmJveAR4bWF4 + FQwWzJoTFsigNRa+4S4miP2/kwcm+L+zkwccGARwoIzCGAT9B47CFgAoBHCgjMIYBP0HjsIAGSwV + BBUEFQIAFQAVBBUQAAAW8KCHgAgV8gEWzqjd/wcV1gEAJtK28pMHHBUIGTUGCAQZKARiYm94BHlt + aW4VDBbMmhMW6KA8FvK+MybStvKTBya2oeKTBxwYBCXkBMIYBPJLBsIWACgEJeQEwhgE8ksGwgAZ + LBUEFQQVAgAVABUEFRAAABbiooeACBXyARakqt3/BxXWAQAm/vmllAccFQgZNQYIBBkoBGJib3gE + eW1heBUMFsyaExaQpzwWvMIzJv75pZQHJqjglZQHHBgEGeQEwhgE5UsGwhYAKAQZ5ATCGATlSwbC + ABksFQQVBBUCABUAFQQVEAAAFtSkh4AIFfIBFvqr3f8HFdYBACako8mUBxwVAhk1BggEGRgHdmVy + c2lvbhUMFsyaExb+BBagBiako8mUBybkosmUBxwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZ + LBUEFQQVAgAVABUEFRAAABbGpoeACBXSARbQrd3/BxXWAQAmxKnJlAccFQwZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbMmhMW/gUWoAcmxKnJlAcmhKnJlAccGAAYABYAKAAY + AAAZLBUEFQQVAgAVABUEFRAAABaYqIeACBXSARamr93/BxVWACboscmUBxwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWzJoTFsTeBBaQjgMm6LHJlAcmpLDJlAccNgAoDU9w + ZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbqqYeA + CBXiARb8r93/BxX2BAAmtL7MlAccFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3Jk + X2lkFQwWzJoTFuys2QIWoJaAASa0vsyUBzw2ACgMdzk5NDAwMzEwM0AyGAwwMDAxOGE1MzY0YTYA + GRwVABUAFRAAABbMq4eACBXyARbytN3/BxXWAwAm4rPOlQccFQwZJQYEGUgHc291cmNlcwRsaXN0 + B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbMmhMWvL8gFuCSCibis86VBybU1MyVBxw2ACgYMjAyNC0x + MS0zMFQwMzo1Nzo0OS4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAV + BBUQAAAWvq2HgAgV7AEWyLjd/wcV1gYAJsCB2JUHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVt + ZW50CmNvbmZpZGVuY2UVDBbMmhMWrtQUFralESbAgdiVBya059aVBxwYCB1aZDvfT+8/GAjNzMzM + zMzkPxaU3gsoCB1aZDvfT+8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABaqr4eACBXyARae + v93/BxX2AgAmuo3olQccFQIZNQYIBBkYBWxldmVsFQwWzJoTFroJFsIKJrqN6JUHJuqM6JUHHBgE + AwAAABgE/////xbGmRMoBAMAAAAYBP////8AGSwVBBUEFQIAFQAVBBUQAAAWnLGHgAgV3gEWlMLd + /wcV5gEAJtKZ6JUHHBUMGTUGCAQZGAdzdWJ0eXBlFQwWzJoTFrR8Fv5lJtKZ6JUHJqyX6JUHHDa4 + jhIoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW+rKHgAgV + 4gEW+sPd/wcVxAMAJs6C6ZUHHBUMGTUGCAQZGAVjbGFzcxUMFsyaExb6jAEWznMmzoLplQcmqv3o + lQccNuaSEigJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFty0h4AIFeIB + Fr7H3f8HFYwDACas8umVBxwVChk1BggEGRgGaGVpZ2h0FQwWzJoTFtgHFpIIJqzy6ZUHJvjw6ZUH + HBgIAAAAAACAUUAYCAAAAAAAAABAFqSaEygIAAAAAACAUUAYCAAAAAAAAABAABksFQQVBBUCABUA + FQQVEAAAFr62h4AIFdYBFsrK3f8HFfYBACaK+emVBxwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUM + FsyaExbg8wIW0tgBJor56ZUHPDacjBMoCsOTcHRpY2EgSkMYDiMwMTUxIE1lY2FuaWNhABkcFQAV + ABUQAAAWlLiHgAgV4gEWwMzd/wcV/gQAJtzR65UHHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlf + dmFsdWUDa2V5FQwW3JoTFpo4FqYmJtzR65UHPDawmhMoAmZyGAJhcgAZHBUAFQAVEAAAFva5h4AI + FeIBFr7R3f8HFa4BACaC+OuVBxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVl + FQwW3JoTFqpHFsosJoL465UHPDawmhMoINiz2YHYp9ix2Kkg2K/ZiNmE2Kkg2YHZhNiz2LfZitmG + GBZBbWJhc3NhZGUgZGUgUGFsZXN0aW5lABkcFQAVABUQAAAW2LuHgAgV4gEW7NLd/wcV4gQAJsil + 7JUHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW5poTFuxBFvYo + Jsil7JUHJsyk7JUHHDaOmhMoBXNob3J0GAlhbHRlcm5hdGUAGSwVBBUEFQIAFQAVBBUQAAAWur2H + gAgV4gEWztfd/wcVsAIAJsLN7JUHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhs + YW5ndWFnZRUMFuaaExacQRb2JybCzeyVBzw22JoTKAJlcxgCZW4AGRwVABUAFRAAABacv4eACBXi + ARb+2d3/BxWGAQAmuPXslQccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVl + FQwW5poTFqhUFp40Jrj17JUHPDaOmhMoA1dPTRgDQVZPABkcFQAVABUQAAAW/sCHgAgV4gEWhNvd + /wcVqAQAJtap7ZUHHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxp + c3QHZWxlbWVudBUMFuaaExbWQBa2JybWqe2VBzw25poTABkcFQAVABUQAAAW4MKHgAgV4gEWrN/d + /wcVdgAmjNHtlQccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbmmhMW + yEAWticmjNHtlQc8NuaaEwAZHBUAFQAVEAAAFsLEh4AIFeIBFqLg3f8HFXYAJsL47ZUHHBUAGTUG + CAAZGAloYXNfcGFydHMVDBbMmhMWyrcCFtgGJsL47ZUHPBgBARgBABYAKAEBGAEAABkcFQAVABUQ + AAAWpMaHgAgV1AEWmOHd/wcVdgAmmv/tlQccFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWzJoT + Fsq3AhawBiaa/+2VBzwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFvjHh4AIFdIBFo7i3f8HFXYA + JtqG7pUHHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWzJoTFrgsFoolJtqG7pUHJsqF7pUHHBgEHAAA + ABgEAQAAABbOgxMoBBwAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWysmHgAgV3gEWhOPd/wcV + 5gEAJtSq7pUHHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWzJoTFo4EFp4FJtSq + 7pUHPDbMmhMAGRwVABUAFRAAABaoy4eACBXSARbq5N3/BxV2ACbyr+6VBxwVChk1BggAGRgKbWlu + X2hlaWdodBUMFsyaExaOBBaeBSbyr+6VBzw2zJoTABkcFQAVABUQAAAW+syHgAgV0gEW4OXd/wcV + dgAmkLXulQccFQIZNQYIABkYCW1pbl9mbG9vchUMFsyaExaOBBaeBSaQte6VBzw2zJoTABkcFQAV + ABUQAAAWzM6HgAgV0gEW1ubd/wcVdgAmrrrulQccFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFsya + ExbkBBb0BSauuu6VBzw2xpoTKAcjRkZGRkZGGAcjN0IzRjAwABkcFQAVABUQAAAWntCHgAgV1AEW + zOfd/wcVrgEAJqLA7pUHHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbMmhMWyAQW2AUmosDu + lQc8GAVnbGFzcxgFZ2xhc3MWyJoTKAVnbGFzcxgFZ2xhc3MAGRwVABUAFRAAABby0YeACBXSARb6 + 6N3/BxWeAQAm+sXulQccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbMmhMWjgQWngUm+sXulQc8 + NsyaEwAZHBUAFQAVEAAAFsTTh4AIFdIBFpjq3f8HFXYAJvjL7pUHHBUMGTUGCAQZGApyb29mX3No + YXBlFQwWzJoTFu4FFpAHJvjL7pUHJpjL7pUHHDaqmhMoBmhpcHBlZBgGZ2FibGVkABksFQQVBBUC + ABUAFQQVEAAAFpbVh4AIFdYBFo7r3f8HFaYBACao0u6VBxwVChk1BggAGRgOcm9vZl9kaXJlY3Rp + b24VDBbMmhMWjgQWngUmqNLulQc8NsyaEwAZHBUAFQAVEAAAFuzWh4AIFdIBFrTs3f8HFXYAJsbX + 7pUHHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWzJoTFo4EFp4FJsbX7pUHPDbMmhMAGRwV + ABUAFRAAABa+2IeACBXSARaq7d3/BxV2ACbk3O6VBxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFsya + ExaOBBaeBSbk3O6VBzw2zJoTABkcFQAVABUQAAAWkNqHgAgV0gEWoO7d/wcVdgAmguLulQccFQoZ + NQYIABkYC3Jvb2ZfaGVpZ2h0FQwWzJoTFrYEFsYFJoLi7pUHPBgIw/UoXI/CFUAYCBSuR+F6FAZA + FsiaEygIw/UoXI/CFUAYCBSuR+F6FAZAABkcFQAVABUQAAAW4tuHgAgV0gEWlu/d/wcVlgEAFsDA + nhsWzJoTJpSAr4cHFrTnvw4UfgAZ/CYmyOfulQccFQwZNQYIABkYAmlkFQwWvLUTFsCJuwUW5PTF + ASbI5+6VBzw2ACggMDhiYjJjNWRiMmMwM2ZmZjAyMDBiZmU0ZDFhYTRmN2MYIDA4YmIyYzQyMmRi + MjJmZmYwMjAwYWVkZDliODBiODIyABkcFQAVABUQAAAWtN2HgAgV8gEWrPDd/wcV1ggAJqzctJcH + HBUMGTUGCAAZGAhnZW9tZXRyeRUMFry1ExaMkcYQFsak+QkmrNy0lwc8NgAowwIAAAAABgAAAAIA + AAAAAwAAAAEAAAAFwFGq/6hWy7/AQKt04iosI8BRqwBObvjcwECreIEbHZPAUar9TTK4usBAq3oC + JJ1uwFGq/KeF62fAQKt2YzOr/8BRqv+oVsu/wECrdOIqLCMAAAAAAwAAAAEAAAANwFGrAwrh21LA + QKt3/WefTMBRqwOrGstdwECre6PlTPbAUasDEFW4mcBAq3vttyggwFGrA1WKdhDAQKt9gTUexsBR + qwP+JuHswECrfTCtRvbAUasEo9OvP8BAq4D2NKUjwFGrBB0wkm/AQKuBNsxE6MBRqwRbQ/N1wECr + gqIGT6XAUasE0Yt4b8BAq4Jo+2wdwFGrBYoYHFbAQKuGnT2TCcBRqwMZj/P+wECrh8ff/gLAUasA + l2oUccBAq3kpt4lvwFGrAwrh21LAQKt3/WefTBhNAAAAAAMAAAABAAAABMBRqta5+61PwECgPoMs + m7TAUarXc9i8c8BAoELzI+b6wFGq1sTUn+3AQKBC99cTDcBRqta5+61PwECgPoMsm7QAGRwVABUA + FSYAABam34eACBW8BBaC+d3/BxW2JwAmtLi3oQccFQgZNQYIBBkoBGJib3gEeG1pbhUMFry1ExbG + xTEWku8sJrS4t6EHJvKArqEHHBgEAlSNwhgEAQiOwhYAKAQCVI3CGAQBCI7CABksFQQVBBUCABUA + FQQVEAAAFuLjh4AIFfIBFrig3v8HFdYBACaAp+ShBxwVCBk1BggEGSgEYmJveAR4bWF4FQwWvLUT + FubEMRbK7iwmgKfkoQcmhPDaoQccGATWU43CGAT5B47CFgAoBNZTjcIYBPkHjsIAGSwVBBUEFQIA + FQAVBBUQAAAW1OWHgAgV8gEWjqLe/wcV1gEAJuaDnKIHHBUIGTUGCAQZKARiYm94BHltaW4VDBa8 + tRMWxNhCFp7AOCbmg5yiBybO3oeiBxwYBAkwBMIYBNeMBcIWACgECTAEwhgE14wFwgAZLBUEFQQV + AgAVABUEFRAAABbG54eACBXyARbko97/BxXWAQAm4sjUogccFQgZNQYIBBkoBGJib3gEeW1heBUM + Fry1Exae3kIW/MQ4JuLI1KIHJuyewKIHHBgE+y8EwhgEtowFwhYAKAT7LwTCGAS2jAXCABksFQQV + BBUCABUAFQQVEAAAFrjph4AIFfIBFrql3v8HFdYBACao5PiiBxwVAhk1BggEGRgHdmVyc2lvbhUM + Fry1Exb+BBagBiao5PiiBybo4/iiBxwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQV + AgAVABUEFRAAABaq64eACBXSARaQp97/BxXWAQAmyOr4ogccFQwZJQYEGUgHc291cmNlcwRsaXN0 + B2VsZW1lbnQIcHJvcGVydHkVDBa8tRMW/gUWoAcmyOr4ogcmiOr4ogccGAAYABYAKAAYAAAZLBUE + FQQVAgAVABUEFRAAABb87IeACBXSARbmqN7/BxVWACbs8viiBxwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAdkYXRhc2V0FQwWvLUTFrzdBBba9QIm7PL4ogcmqPH4ogccNgAoDU9wZW5TdHJl + ZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbO7oeACBXiARa8 + qd7/BxX2BAAmguf7ogccFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW + vLUTFsr55QIWwISCASaC5/uiBzw2ACgMdzk3NjQxNjE3NEAxGAwwMDAxMjIzNDQ5ZGIAGRwVABUA + FRAAABaw8IeACBXyARayrt7/BxXUAwAmutD+owccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQLdXBkYXRlX3RpbWUVDBa8tRMWnqsZFrCiBya60P6jBybC6/2jBxw2ACgYMjAyNC0xMS0zMFQx + NTo1NDowMy4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAW + ovKHgAgV4gEWhrLe/wcV1gYAJpyqhqQHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNv + bmZpZGVuY2UVDBa8tRMWnNUXFo66FCacqoakBybyjYWkBxwYCKmkTkATYe8/GAjNzMzMzMzkPxbG + gQooCKmkTkATYe8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABaE9IeACBXyARbcuN7/BxX2 + AgAmxsiZpAccFQIZNQYIBBkYBWxldmVsFQwWvLUTFsoHFtYIJsbImaQHJoDImaQHHBgEBQAAABgE + AQAAABbmtBMoBAUAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAW9vWHgAgV2AEW0rve/wcV1gEA + JvrSmaQHHBUMGTUGCAQZGAdzdWJ0eXBlFQwWvLUTFqo+FtYzJvrSmaQHJtbQmaQHHDaIjBMoDnRy + YW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWzveHgAgV4gEWqL3e + /wcVmAMAJviHmqQHHBUMGTUGCAQZGAVjbGFzcxUMFry1Exb4PRbsNCb4h5qkByashJqkBxw28I0T + KAl3YXJlaG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWsPmHgAgV4gEWwMDe/wcV + 9gIAJpi5mqQHHBUKGTUGCAAZGAZoZWlnaHQVDBa8tRMWxAQW1AUmmLmapAc8GAgAAAAAAAAuQBgI + AAAAAAAACEAWuLUTKAgAAAAAAAAuQBgIAAAAAAAACEAAGRwVABUAFRAAABaS+4eACBXSARa2w97/ + BxW2AQAm7L6apAccFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBa8tRMW8MEBFrR5Juy+mqQHPDbI + rRMoBHVwYSEYDEEgRG9zIEZ1ZWdvcwAZHBUAFQAVEAAAFuT8h4AIFeIBFuzE3v8HFf4DACaguJuk + BxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFry1ExaaIxayGiaguJukBzw2 + uLUTKAN5dWUYAmVuABkcFQAVABUQAAAWxv6HgAgV4gEW6sje/wcVigEAJtLSm6QHHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBa8tRMWyikWkBwm0tKbpAc8Nri1EygG5pif + 6LS1GBdPdXIgTGFkeSBvZiBTY2hvZW5zdGF0dAAZHBUAFQAVEAAAFqiAiIAIFeIBFvTJ3v8HFeoB + ACbe75ukBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFsq1ExbG + KhaKHSbe75ukBybi7pukBxw2orUTKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAA + FoqCiIAIFeIBFt7L3v8HFZoCACbsi5ykBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQIbGFuZ3VhZ2UVDBbKtRMWzCkWgBwm7IucpAc8Nsa1EygCZXMYAmVuABkcFQAVABUQAAAW7IOI + gAgV4gEW+M3e/wcVfgAm7KecpAccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZh + bHVlFQwWyrUTFrQzFt4iJuynnKQHPDaitRMoBlRvdHR1cxgDQkNJABkcFQAVABUQAAAWzoWIgAgV + 4gEW9s7e/wcVzAQAJsrKnKQHHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3 + ZWVuBGxpc3QHZWxlbWVudBUMFsq1Exa+KRb4GybKypykBzw2yrUTABkcFQAVABUQAAAWsIeIgAgV + 4gEWwtPe/wcVdgAmwuacpAccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUV + DBbKtRMWtCkW6BsmwuacpAc8Nsq1EwAZHBUAFQAVEAAAFpKJiIAIFeIBFrjU3v8HFXYAJqqCnaQH + HBUAGTUGCAAZGAloYXNfcGFydHMVDBa8tRMW+LoCFswGJqqCnaQHPBgBARgBABYAKAEBGAEAABkc + FQAVABUQAAAW9IqIgAgV0gEWrtXe/wcVdgAm9oidpAccFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5k + FQwWvLUTFvi6AhawBib2iJ2kBzwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFsaMiIAIFdIBFqTW + 3v8HFXYAJp6QnaQHHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWvLUTFu4LFtgMJp6QnaQHJqaPnaQH + HBgECgAAABgEAQAAABbcshMoBAoAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWmI6IgAgV2gEW + mtfe/wcV9gEAJv6bnaQHHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWvLUTFpAE + FqAFJv6bnaQHPDa8tRMAGRwVABUAFRAAABbyj4iACBXSARaQ2d7/BxV2ACaeoZ2kBxwVChk1BggA + GRgKbWluX2hlaWdodBUMFry1ExaQBBagBSaeoZ2kBzw2vLUTABkcFQAVABUQAAAWxJGIgAgV0gEW + htre/wcVdgAmvqadpAccFQIZNQYIABkYCW1pbl9mbG9vchUMFry1ExaQBBagBSa+pp2kBzw2vLUT + ABkcFQAVABUQAAAWlpOIgAgV0gEW/Nre/wcVdgAm3qudpAccFQwZNQYIABkYDGZhY2FkZV9jb2xv + chUMFry1ExaQBBagBSbeq52kBzw2vLUTABkcFQAVABUQAAAW6JSIgAgV0gEW8tve/wcVdgAm/rCd + pAccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFry1ExaQBBagBSb+sJ2kBzw2vLUTABkcFQAV + ABUQAAAWupaIgAgV0gEW6Nze/wcVdgAmnradpAccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBa8 + tRMWkAQWoAUmnradpAc8Nry1EwAZHBUAFQAVEAAAFoyYiIAIFdIBFt7d3v8HFXYAJr67naQHHBUM + GTUGCAAZGApyb29mX3NoYXBlFQwWvLUTFqoEFroFJr67naQHPBgEZmxhdBgEZmxhdBa6tRMoBGZs + YXQYBGZsYXQAGRwVABUAFRAAABbemYiACBXSARbU3t7/BxWGAQAm+MCdpAccFQoZNQYIABkYDnJv + b2ZfZGlyZWN0aW9uFQwWvLUTFpAEFqAFJvjAnaQHPDa8tRMAGRwVABUAFRAAABawm4iACBXSARba + 397/BxV2ACaYxp2kBxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFry1ExaQBBagBSaYxp2k + Bzw2vLUTABkcFQAVABUQAAAWgp2IgAgV0gEW0ODe/wcVdgAmuMudpAccFQwZNQYIABkYCnJvb2Zf + Y29sb3IVDBa8tRMWsAQWwAUmuMudpAc8GAcjMDAwMDAwGAcjMDAwMDAwFrq1EygHIzAwMDAwMBgH + IzAwMDAwMAAZHBUAFQAVEAAAFtSeiIAIFdIBFsbh3v8HFZIBACb40J2kBxwVChk1BggAGRgLcm9v + Zl9oZWlnaHQVDBa8tRMWkAQWoAUm+NCdpAc8Nry1EwAZHBUAFQAVEAAAFqagiIAIFdIBFtji3v8H + FXYAFprfjxsWvLUTJsjn7pUHFtDurg4UgAEAGfwmJpjWnaQHHBUMGTUGCAAZGAJpZBUMFozXEhb8 + w6AFFsTRvQEmmNadpAc8NgAoIDA4YmIyYzVkYjMwY2RmZmYwMjAwOTg2YzA5ODUyYTMxGCAwOGJi + MmM0MDkwNDliZmZmMDIwMGFjNmY3NGRiYjMzZQAZHBUAFQAVEAAAFvihiIAIFfIBFs7j3v8HFdYI + ACbcp9ulBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBaM1xIWxsv6EBbgpL4KJtyn26UHPDYAKJcFAAAA + AAYAAAAGAAAAAAMAAAABAAAABcBRqXqgsA5QwECy4HvWOjTAUal7rmGnu8BAsuw2Hp/+wFGped+/ + 7pjAQLLsqeHmOsBRqXjSDlUtwECy4O+ZgG/AUal6oLAOUMBAsuB71jo0AAAAAAMAAAABAAAACcBR + qX616IS5wECy3s5XEIjAUamAAGtfysBAsu+yquKXwFGpdZdb0bjAQLLx6bzHnMBRqXRPyJUwwECy + 4SfNpGPAUal2CC95asBAsuDJ2dNGwFGpdxSe83bAQLLuhzG4CcBRqX4Vr5SuwECy7QmDNoHAUal9 + BlB8GcBAst8pxqLnwFGpfrXohLnAQLLezlcQiAAAAAADAAAAAQAAAAXAUamAU+LWJMBAsvHggow3 + wFGpgRF394jAQLL8Sz+Zc8BRqX8/e0ASwECy/KeF62fAUal+geYercBAsvI8yN4rwFGpgFPi1iTA + QLLx4IKMNwAAAAADAAAAAQAAAAXAUal8LQyohcBAsvLsG0atwFGpfOqhyerAQLL9V68TfsBRqXsY + pRJ0wECy/bP1ZXLAUal6Ww/xD8BAsvNIYZihwFGpfC0MqIXAQLLy7BtGrQAAAAADAAAAAQAAAAXA + Ual3IZ+M+cBAsvRLltdHwFGpd980rl3AQLL+tyqkGMBRqXYNN/bnwECy/xNw9gzAUal1T6LVgsBA + svSos+jQwFGpdyGfjPnAQLL0S5bXRwAAAAADAAAAAQAAAAfAUalxOFGAJcBAsvWvRCXKwFGpcinp + B5bAQLMCm7uyycBRqYFwQog7wECy/4B+P6HAUamBsbDnlMBAswMDwH7hwFGpcITNWbvAQLMGgfpA + o8BRqW9Rx3LxwECy9hFptNDAUalxOFGAJcBAsvWvRCXKGE0AAAAAAwAAAAEAAAAEwFGe749e6mzA + QK3E75JPB8BRnu8t6LK2wECtxg+8fu7AUZ7ur+vN5sBArcWXtHJ5wFGe749e6mzAQK3E75JPBwAZ + HBUAFQAVJgAAFuqjiIAIFb4EFqTs3v8HFbYnACbe3KWwBxwVCBk1BggEGSgEYmJveAR4bWluFQwW + jNcSFr7/MxbYtS4m3tylsAcmvMyZsAccGAQIoIzCGAQmUY/CFgAoBAigjMIYBCZRj8IAGSwVBBUE + FQIAFQAVBBUQAAAWqKiIgAgV8gEW2pPf/wcV1gEAJp6R1LAHHBUIGTUGCAQZKARiYm94BHhtYXgV + DBaM1xIWyvwzFqa0LiaekdSwByaUgsiwBxwYBPifjMIYBB9Rj8IWACgE+J+MwhgEH1GPwgAZLBUE + FQQVAgAVABUEFRAAABaaqoiACBXyARawld//BxXWAQAmurb2sAccFQgZNQYIABkoBGJib3gEeW1p + bhUMFozXEhaA4UoW7K4oJrq29rAHPBgEoh4EwhgEZZgFwhYAKASiHgTCGARlmAXCABkcFQAVABUQ + AAAWjKyIgAgV8gEWhpff/wcV1gEAJoKwr7EHHBUIGTUGCAQZKARiYm94BHltYXgVDBaM1xIWnJQ7 + FpL/MiaCsK+xByam5Z6xBxwYBDEeBMIYBPyXBcIWACgEMR4EwhgE/JcFwgAZLBUEFQQVAgAVABUE + FRAAABb+rYiACBXyARbcmN//BxXWAQAm+OTRsQccFQIZNQYIBBkYB3ZlcnNpb24VDBaM1xIW/gQW + oAYm+OTRsQcmuOTRsQccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQ + AAAW8K+IgAgV0gEWsprf/wcV1gEAJpjr0bEHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CHByb3BlcnR5FQwWjNcSFv4FFqAHJpjr0bEHJtjq0bEHHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAV + BBUQAAAWwrGIgAgV0gEWiJzf/wcVVgAmvPPRsQccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQHZGF0YXNldBUMFozXEha01gQW8PsCJrzz0bEHJvjx0bEHHDYAKA1PcGVuU3RyZWV0TWFwGBVH + b29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWlLOIgAgV4gEW3pzf/wcV9gQA + Jujt1LEHHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFozXEhbuh9IC + FtCzfybo7dSxBzw2ACgMdzk5OTI3MDI2MkAxGAwwMDAxNGM0OWZlNWYAGRwVABUAFRAAABb2tIiA + CBXyARbUod//BxXUAwAmvLvVsgccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRl + X3RpbWUVDBaM1xIWmpQcFo6uCCa8u9WyBya4odSyBxw2ACgYMjAyNC0xMS0zMFQxNTo1NDowMy4w + MDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAW6LaIgAgV6gEW + qKXf/wcV1gYAJsLn3bIHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UV + DBaM1xIWqJgVFs75ESbC592yBybGz9yyBxwYCJwzorQ3+O4/GAjNzMzMzMzkPxbu8QooCJwzorQ3 + +O4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABbSuIiACBXyARb+q9//BxX0AgAm5Mnusgcc + FQIZNQYIBBkYBWxldmVsFQwWjNcSFoQIFqYJJuTJ7rIHJpTJ7rIHHBgEAgAAABgE/////xaq1hIo + BAIAAAAYBP////8AGSwVBBUEFQIAFQAVBBUQAAAWxLqIgAgV3AEW8q7f/wcV9gEAJtzU7rIHHBUM + GTUGCAQZGAdzdWJ0eXBlFQwWjNcSFrBdFspIJtzU7rIHJrrS7rIHHDbWlhIoDnRyYW5zcG9ydGF0 + aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWoLyIgAgV4gEW6LDf/wcVogMAJoCf + 77IHHBUMGTUGCAQZGAVjbGFzcxUMFozXEhauYRbYTCaAn++yByaEm++yBxw27pkSKAl3YXJlaG91 + c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWgr6IgAgV4gEWirTf/wcVogMAJtzn77IH + HBUKGTUGCAAZGAZoZWlnaHQVDBaM1xIWwhQWkgom3Ofvsgc8GAgAAAAAAMBSQBgIKVyPwvUoBEAW + qNUSKAgAAAAAAMBSQBgIKVyPwvUoBEAAGRwVABUAFRAAABbkv4iACBXYARast9//BxWWAgAm7vHv + sgccFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaM1xIW9sICFsLCASbu8e+yBzw25MgSKAbFoGtv + ZGEYCTEwMCBBdXRvcwAZHBUAFQAVEAAAFrzBiIAIFeIBFsK53/8HFdgDACawtPGyBxwVDBklBgAZ + SAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFqLXEhaoNBaQJCawtPGyBzw27tYSKAJ6aBgC + YXIAGRwVABUAFRAAABaew4iACBXiARaavd//BxWOAQAmwNjxsgccFQwZJQYAGUgFbmFtZXMGY29t + bW9uCWtleV92YWx1ZQV2YWx1ZRUMFqLXEhaIRRaIKybA2PGyBzw27tYSKAnlrp3pqazljoIYFUFt + YmFzc2FkZSBkJ0FsbGVtYWduZQAZHBUAFQAVEAAAFoDFiIAIFeIBFqi+3/8HFa4CACbEhPKyBxwV + DBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFqDXEhbCPBbUJibEhPKy + BybIg/KyBxw23tYSKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAAFuLGiIAIFeIB + FtbA3/8HFbgCACacqvKyBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3Vh + Z2UVDBag1xIW5DsW2iUmnKrysgc8NpbXEigCZXMYAmRlABkcFQAVABUQAAAWxMiIgAgV4gEWjsPf + /wcVhgEAJprW8rIHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFqDX + EhaMRRaULCaa1vKyByb2z/KyBxw23tYSKBBTdGFyYnVja3MgQ29mZmVlGB9CYW5jbyBCaWxiYW8g + Vml6Y2F5YSBBcmdlbnRhcmlhABksFQQVBBUCABUAFQQVEAAAFqbKiIAIFeIBFpTE3/8HFeoFACaK + /PKyBxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1l + bnQVDBag1xIWuDsWvCUmivzysgc8NqDXEgAZHBUAFQAVEAAAFojMiIAIFeIBFv7J3/8HFXYAJsah + 87IHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWoNcSFqg7FrIlJsah + 87IHPDag1xIAGRwVABUAFRAAABbqzYiACBXiARb0yt//BxV2ACb4xvOyBxwVABk1BggAGRgJaGFz + X3BhcnRzFQwWjNcSFpKvAhbMBib4xvOyBzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFszPiIAI + FdIBFurL3/8HFXYAJsTN87IHHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFozXEhaSrwIWsAYm + xM3zsgc8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABae0YiACBXSARbgzN//BxV2ACb00/OyBxwV + Ahk1BggAGRgKbnVtX2Zsb29ycxUMFozXEhaGRhaqHSb00/OyBzwYBCEAAAAYBAEAAAAWtMoSKAQh + AAAAGAQBAAAAABkcFQAVABUQAAAW8NKIgAgV4AEW1s3f/wcV9gEAJp7x87IHHBUCGTUGCAAZGBZu + dW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWjNcSFrwEFswFJp7x87IHPBgEBgAAABgEBQAAABaG1xIo + BAYAAAAYBAUAAAAAGRwVABUAFRAAABbQ1IiACBXSARbMz9//BxWWAQAm6vbzsgccFQoZNQYIABkY + Cm1pbl9oZWlnaHQVDBaM1xIWkAQWoAUm6vbzsgc8NozXEgAZHBUAFQAVEAAAFqLWiIAIFdIBFuLQ + 3/8HFXYAJor887IHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBaM1xIWkAQWoAUmivzzsgc8NozXEgAZ + HBUAFQAVEAAAFvTXiIAIFdIBFtjR3/8HFXYAJqqB9LIHHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IV + DBaM1xIW7gQW/gUmqoH0sgc8NobXEigHI0ZGRkZGRhgHI0ZGQzBDQgAZHBUAFQAVEAAAFsbZiIAI + FdQBFs7S3/8HFa4BACaoh/SyBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWjNcSFtwGFsQG + JqiH9LIHPDbu1hIoBWdsYXNzGAVicmljawAZHBUAFQAVEAAAFprbiIAIFdYBFvzT3/8HFZ4BACbs + jfSyBxwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFozXEhaQBBagBSbsjfSyBzw2jNcSABkcFQAV + ABUQAAAW8NyIgAgV0gEWmtXf/wcVdgAmjJP0sgccFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaM1xIW + mg0WxggmjJP0sgc8NqzWEigHc2FsdGJveBgEZmxhdAAZHBUAFQAVEAAAFsLeiIAIFdgBFpDW3/8H + Fb4BACbSm/SyBxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaM1xIWkAQWoAUm0pv0sgc8NozX + EgAZHBUAFQAVEAAAFprgiIAIFdIBFs7X3/8HFXYAJvKg9LIHHBUMGTUGCAAZGBByb29mX29yaWVu + dGF0aW9uFQwWjNcSFpAEFqAFJvKg9LIHPDaM1xIAGRwVABUAFRAAABbs4YiACBXSARbE2N//BxV2 + ACaSpvSyBxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFozXEhawBBbABSaSpvSyBzwYByNGRjAwMDAY + ByNGRjAwMDAWitcSKAcjRkYwMDAwGAcjRkYwMDAwABkcFQAVABUQAAAWvuOIgAgV0gEWutnf/wcV + kgEAJtKr9LIHHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFozXEhbCBBbSBSbSq/SyBzwYCAAAAAAA + APQ/GAiamZmZmZnpPxaI1xIoCAAAAAAAAPQ/GAiamZmZmZnpPwAZHBUAFQAVEAAAFpDliIAIFdQB + Fsza3/8HFZYBABauwZ4bFozXEiaY1p2kBxaM29YOFIIBABn8JiaksfSyBxwVDBk1BggAGRgCaWQV + DBaEiRUWqsr2BRa2ldABJqSx9LIHPDYAKCAwOGJiMmM0NDY1Yjc1ZmZmMDIwMGM4ZGE1MDIzODI2 + YhggMDhiYjJjNDAwMTA1Y2ZmZjAyMDBlOTRiZDYyMjA0YzkAGRwVABUAFRIAABbk5oiACBWQAhbi + 29//BxXeCQAm2sbEtAccFQwZNQYIABkYCGdlb21ldHJ5FQwWhIkVFqzNyhEW2NqqCibaxsS0Bzw2 + ACiTAgAAAAAGAAAAAgAAAAADAAAAAQAAAArAUd84/DVwJMBAhJkGzKLbwFHfLY8Z49fAQISgEYLf + Q8BR3y0xkXKEwECEnmdes+rAUd8sz2vjfsBAhJydWhh6wFHfMjrlrxzAQISZVNA77cBR3zJcCD6T + wECEme5TL1LAUd8zVSyCP8BAhJlXVHqswFHfMzW3cfLAQISYxV5DgsBR3zhE6uucwECElbQxy1TA + Ud84/DVwJMBAhJkGzKLbAAAAAAMAAAABAAAABcBR3zgUruOuwECElNKKe+/AUd8snKuc0cBAhJuA + +mZjwFHfK/EfkmzAQISYRdyDI8BR3zdot3l+wECEkZaV2RvAUd84FK7jrsBAhJTSinvvGE0AAAAA + AwAAAAEAAAAEwFHZlRKQC9DAQIFMeowaHMBR2ZUlAdIXwECBS37xPR7AUdmVrI6YmMBAgUyamkLk + wFHZlRKQC9DAQIFMeowaHAAZHBUAFQAVKAAAFvToiIAIFdwEFsDl3/8HFb4pACb6wfq+BxwVCBk1 + BggEGSgEYmJveAR4bWluFQwWhIkVFsijNha40TEm+sH6vgcmsqHvvgccGAQDvI7CGAQ6To/CFgAo + BAO8jsIYBDpOj8IAGSwVBBUEFQIAFQAVBBUSAAAW0O2IgAgVkAIW/o7g/wcV7gEAJq6WrL8HHBUI + GTUGCAQZKARiYm94BHhtYXgVDBaEiRUWvqc2FrLUMSaulqy/Bybq8qC/BxwYBPi7jsIYBCpOj8IW + ACgE+LuOwhgEKk6PwgAZLBUEFQQVAgAVABUEFRIAABbg74iACBWQAhbskOD/BxXuAQAm/ovbvwcc + FQgZNQYIBBkoBGJib3gEeW1pbhUMFoSJFRau2DEWuIAuJv6L278HJpzH0r8HHBgEZLUDwhgEYjAE + whYAKARktQPCGARiMATCABksFQQVBBUCABUAFQQVEgAAFvDxiIAIFZACFtqS4P8HFe4BACb8ionA + BxwVCBk1BggEGSgEYmJveAR5bWF4FQwWhIkVFr7WMRb+/i0m/IqJwAcm1MeAwAccGARTtQPCGAT7 + LwTCFgAoBFO1A8IYBPsvBMIAGSwVBBUEFQIAFQAVBBUSAAAWgPSIgAgVkAIWyJTg/wcV7gEAJpLH + rsAHHBUCGTUGCAQZGAd2ZXJzaW9uFQwWhIkVFsgFFvwGJpLHrsAHJtLGrsAHHBgEAAAAABgEAAAA + ABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEgAAFpD2iIAIFewBFraW4P8HFe4BACaOzq7A + BxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFoSJFRbYBhaMCCaOzq7A + BybOza7ABxwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFvz3iIAIFewBFqSY4P8HFV4AJp7X + rsAHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaEiRUWvp4FFsq7Ayae + 167AByba1a7ABxw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQV + BBUCABUAFQQVEgAAFuj5iIAIFf4BFoKZ4P8HFcIFACakkbLABxwVDBklBgAZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAlyZWNvcmRfaWQVDBaEiRUWqtqQAxaguXompJGywAc8NgAoDHc5OTY3MTg5MDZA + MRgMMDAwMGZlMTBmYmExABkcFQAVABUSAAAW5vuIgAgVkAIWxJ7g/wcVjgQAJtbOr8EHHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWhIkVFq7JKhaQ9gwm1s6vwQcm + xMqswQccNgAoGDIwMjQtMTEtMjlUMTg6MzA6MDIuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4w + MDBaABksFQQVBBUCABUAFQQVEgAAFvb9iIAIFYoCFtKi4P8HFb4HACbK4LrBBxwVChklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWhIkVFsa2HRbYhRomyuC6wQcm1MC5wQcc + GAjnHafoSC7vPxgIzczMzMzM5D8WxLgIKAjnHafoSC7vPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAV + BBUSAAAWgICJgAgVkAIWkKrg/wcVmAMAJpTH08EHHBUCGTUGCAQZGAVsZXZlbBUMFoSJFRacCRbG + CiaUx9PBByasxtPBBxwYBAUAAAAYBP7///8WoIgVKAQFAAAAGAT+////ABksFQQVBBUCABUAFQQV + EgAAFpCCiYAIFfYBFqit4P8HFfIBACaq09PBBxwVDBk1BggEGRgHc3VidHlwZRUMFoSJFRaesQEW + 2owBJqrT08EHJvLQ08EHHDaAuBMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUE + FQIAFQAVBBUSAAAWhoSJgAgV/gEWmq/g/wcVwAMAJsbi1MEHHBUMGTUGCAQZGAVjbGFzcxUMFoSJ + FRa6yAEWxpwBJsbi1MEHJszd1MEHHDbavBMoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQV + AgAVABUEFRIAABaEhomACBX+ARbasuD/BxXaAwAmkvrVwQccFQoZNQYIABkYBmhlaWdodBUMFoSJ + FRbgChbaCCaS+tXBBzwYCAAAAAAAADlAGAgAAAAAAAAAQBa6iBUoCAAAAAAAADlAGAgAAAAAAAAA + QAAZHBUAFQAVEgAAFoKIiYAIFfABFrS24P8HFeIBACbsgtbBBxwVDBk1BggAGSgFbmFtZXMHcHJp + bWFyeRUMFoSJFRa04AUW0u0CJuyC1sEHPDbK6xQoF8OBcmVhIFNhbHVkIFZhbHBhcmHDrXNvGBox + IENvbWlzYXLDrWEgVmnDsWEgZGVsIE1hcgAZHBUAFQAVEgAAFvKJiYAIFf4BFpa44P8HFcoFACa+ + 8NjBBxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFoyJFRaOURaUNia+8NjB + Bzw2+ogVKAJlcxgCZW4AGRwVABUAFRIAABbwi4mACBX+ARbgveD/BxWaAQAm0qbZwQccFQwZJQYA + GUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFoyJFRbkZxbcPibSptnBBzw2+ogVKApT + dGF0ZSBCYW5rGAxCYW5jbyBFc3RhZG8AGRwVABUAFRIAABbujYmACBX+ARb6vuD/BxW8AwAmqubZ + wQccFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaUiRUW0GMWxjsm + qubZwQcmruXZwQccNs6IFSgFc2hvcnQYCWFsdGVybmF0ZQAZLBUEFQQVAgAVABUEFRIAABbsj4mA + CBX+ARa2wuD/BxXgAgAm9KDawQccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxh + bmd1YWdlFQwWlIkVFrpiFqY6JvSg2sEHPDaQiRUoAmVzGAJlbgAZHBUAFQAVEgAAFuqRiYAIFf4B + FpbF4P8HFYoBACbK4trBBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUV + DBaUiRUWoG0WqEImyuLawQcmmtvawQccNs6IFSgDVE5FGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENo + aWxlABksFQQVBBUCABUAFQQVEgAAFuiTiYAIFf4BFqDG4P8HFZgFACbCndvBBxwVChklBgAZeAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBaUiRUWqGIWjjom + wp3bwQc8NpSJFQAZHBUAFQAVEgAAFuaViYAIFf4BFrjL4P8HFYIBACbQ19vBBxwVDBklBgAZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFpSJFRaiYhaWOibQ19vBBzw2lIkVABkcFQAV + ABUSAAAW5JeJgAgV/gEWuszg/wcVggEAJuaR3MEHHBUAGTUGCAAZGAloYXNfcGFydHMVDBaEiRUW + 9tUCFpAIJuaR3MEHPBgBARgBABYAKAEBGAEAABkcFQAVABUSAAAW4pmJgAgV8AEWvM3g/wcVggEA + JvaZ3MEHHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFoSJFRb21QIWlgcm9pncwQc8GAEAGAEA + FgAoAQAYAQAAGRwVABUAFRIAABbSm4mACBXsARa+zuD/BxWCAQAmpKLcwQccFQIZNQYIBBkYCm51 + bV9mbG9vcnMVDBaEiRUWqpwBFvyBASakotzBByaModzBBxwYBB4AAAAYBAEAAAAW+I4UKAQeAAAA + GAQBAAAAABksFQQVBBUCABUAFQQVEgAAFr6diYAIFf4BFsDP4P8HFZICACaIo93BBxwVAhk1BggA + GRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFoSJFRb2BBaYBiaIo93BBzwYBAIAAAAYBAEAAAAW + gIkVKAQCAAAAGAQBAAAAABkcFQAVABUSAAAWvJ+JgAgV7AEW0tHg/wcVkgEAJqCp3cEHHBUKGTUG + CAAZGAptaW5faGVpZ2h0FQwWhIkVFtIEFvQFJqCp3cEHPDaEiRUAGRwVABUAFRIAABaooYmACBXs + ARbk0uD/BxWCAQAmlK/dwQccFQIZNQYIABkYCW1pbl9mbG9vchUMFoSJFRbSBBb0BSaUr93BBzw2 + hIkVABkcFQAVABUSAAAWlKOJgAgV7AEW5tPg/wcVggEAJoi13cEHHBUMGTUGCAAZGAxmYWNhZGVf + Y29sb3IVDBaEiRUW0gQW9AUmiLXdwQc8NoSJFQAZHBUAFQAVEgAAFoCliYAIFewBFujU4P8HFYIB + ACb8ut3BBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWhIkVFtYFFvgGJvy63cEHPDb8iBUo + BW1ldGFsGAxjZW1lbnRfYmxvY2sAGRwVABUAFRIAABbspomACBXuARbq1eD/BxXYAQAm9MHdwQcc + FQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaEiRUW0gQW9AUm9MHdwQc8NoSJFQAZHBUAFQAVEgAA + FtqoiYAIFewBFsLX4P8HFYIBACbcyd3BBxwVDBk1BggEGRgKcm9vZl9zaGFwZRUMFoSJFRakIBa6 + HCbcyd3BBybox93BBxw2ovUUKAhza2lsbGlvbhgEZG9tZQAZLBUEFQQVAgAVABUEFRIAABbGqomA + CBX4ARbE2OD/BxXEAgAmouTdwQccFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWhIkVFtIEFvQF + JqLk3cEHPDaEiRUAGRwVABUAFRIAABa+rImACBXsARaI2+D/BxWCAQAmlurdwQccFQwZNQYIABkY + EHJvb2Zfb3JpZW50YXRpb24VDBaEiRUW0gQW9AUmlurdwQc8NoSJFQAZHBUAFQAVEgAAFqquiYAI + FewBForc4P8HFYIBACaK8N3BBxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFoSJFRbSBBb0BSaK8N3B + Bzw2hIkVABkcFQAVABUSAAAWlrCJgAgV7AEWjN3g/wcVggEAJv713cEHHBUKGTUGCAAZGAtyb29m + X2hlaWdodBUMFoSJFRbSBBb0BSb+9d3BBzw2hIkVABkcFQAVABUSAAAWgrKJgAgV7AEWjt7g/wcV + ggEAFsjNhB0WhIkVJqSx9LIHFs7K6Q4UhAEAGfwmJvL73cEHHBUMGTUGCAAZGAJpZBUMFpyVFRaK + gfoFFqrW1gEm8vvdwQc8NgAoIDA4YmIyYzRjNmVkYjZmZmYwMjAwZjJlODVmOTkzZTVlGCAwOGJi + MmM0MDAwMDY0ZmZmMDIwMDQ2MDhkMjNiZjFjYQAZHBUAFQAVEgAAFu6ziYAIFZACFpDf4P8HFd4J + ACac0rTDBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBaclRUW7tuwERbkjqIKJpzStMMHPDYAKNkFAAAA + AAMAAAAEAAAAHcBR4gHaYDNGwEBjuKrW2L/AUeICHDnyasBAY7ybJmGUwFHiAqXMrcPAQGO8gfvu + I8BR4gKyzUdGwEBjvUmiCoHAUeICY/LuoMBAY71X5MNkwFHiAngU5JTAQGO+jJgpV8BR4gLhW9AK + wEBjvnlM8vjAUeIC7fEJw8BAY789mBEDwFHiAow22ojAQGO/UAyHzsBR4gLAOUCTwEBjwmz3eiDA + UeICVhuViMBAY8KAQrB/wFHiAmPy7qDAQGPDViuFwMBR4gHySIdYwEBjw2skO0nAUeIB4ezvgsBA + Y8Js93ogwFHiAUoXe0fAQGPCiKYsT8BR4gFacxMdwEBjw4iAbKLAUeIBAYe/fcBAY8OYcKSuwFHi + APTyhcTAQGPC2S4EH8BR4f77HUIwwEBjwzch1T3AUeH/Btu8VMBAY8Pu17mQwFHh/mi7qzzAQGPE + DDPq6cBR4f5daJDjwEBjw1mGhBPAUeH8b1HHc8BAY8O09hZywFHh/GVAzHnAQGPDGBgkusBR4fVT + aTOgwEBjxGbMvbPAUeH0xTlalcBAY7vpT7pSwFHh/TdjQ5zAQGO6WFYCa8BR4f0pi+qEwEBjuYkj + KdHAUeIB2mAzRsBAY7iq1ti/AAAABcBR4fkMxrfgwEBjv7m+0w/AUeH3JxNqQMBAY8AL9CoJwFHh + 9zwMH8nAQGPBbEZ6OMBR4fkhv21pwEBjwRk6Y6nAUeH5DMa34MBAY7+5vtMPAAAABcBR4fuuzQeF + wEBjvXlysqXAUeH661ipD8BAY72aKeJSwFHh+yOMzQLAQGPBN21Ul8BR4fvmlcuvwEBjwRXfZVbA + UeH7rs0HhcBAY715crKlAAAABcBR4gAp8WsSwEBju76Hj6zAUeH/Fsv0YMBAY7v6FrHzwFHh/3I7 + hr/AQGPApyScl8BR4gCFYP1xwEBjwGxsOeXAUeIAKfFrEsBAY7u+h4+sGE0AAAAAAwAAAAEAAAAE + wFHPzOQ15SjAQHSMjvrb4sBRz8ySnpCqwEB0jaGYc5XAUc/MJmlrycBAdI1GGNwkwFHPzOQ15SjA + QHSMjvrb4gAZHBUAFQAVKAAAFv61iYAIFdwEFu7o4P8HFb4pACaCxOTNBxwVCBk1BggEGSgEYmJv + eAR4bWluFQwWnJUVFtz6Oxai2zQmgsTkzQcmgOHWzQccGAQFYo7CGATaF4/CFgAoBAVijsIYBNoX + j8IAGSwVBBUEFQIAFQAVBBUSAAAW2rqJgAgVkAIWrJLh/wcV7gEAJoqfmc4HHBUIGTUGCAQZKARi + Ym94BHhtYXgVDBaclRUW+vo7Fp7aNCaKn5nOByaivIvOBxwYBPRhjsIYBMsXj8IWACgE9GGOwhgE + yxePwgAZLBUEFQQVAgAVABUEFRIAABbqvImACBWQAhaalOH/BxXuAQAm6ODVzgccFQgZNQYIBBko + BGJib3gEeW1pbhUMFpyVFRbw0kcW5PE8Jujg1c4HJsCWwM4HHBgECsgCwhgEPjAEwhYAKAQKyALC + GAQ+MATCABksFQQVBBUCABUAFQQVEgAAFvq+iYAIFZACFoiW4f8HFe4BACaU1ZLPBxwVCBk1BggE + GSgEYmJveAR5bWF4FQwWnJUVFpzWRxao8zwmlNWSzwcmpIj9zgccGATvxwLCGAT5LwTCFgAoBO/H + AsIYBPkvBMIAGSwVBBUEFQIAFQAVBBUSAAAWisGJgAgVkAIW9pfh/wcV7gEAJoz8uc8HHBUCGTUG + CAQZGAd2ZXJzaW9uFQwWnJUVFsgFFvwGJoz8uc8HJsz7uc8HHBgEAAAAABgEAAAAABYAKAQAAAAA + GAQAAAAAABksFQQVBBUCABUAFQQVEgAAFprDiYAIFewBFuSZ4f8HFe4BACaIg7rPBxwVDBklBgQZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFpyVFRbWBhaKCCaIg7rPBybIgrrPBxwY + ABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFobFiYAIFewBFtKb4f8HFV4AJpaMus8HHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaclRUWwJ8FFsaHAyaWjLrPBybSirrP + Bxw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQV + EgAAFvLGiYAIFf4BFrCc4f8HFcIFACaYkr3PBxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAlyZWNvcmRfaWQVDBaclRUW/tqcAxaw+38mmJK9zwc8NgAoDHc5OTg1ODQwNjhAMRgMMDAwMDRl + NjlhM2JiABkcFQAVABUSAAAW8MiJgAgVkAIW8qHh/wcVjgQAJoDcvdAHHBUMGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWnJUVFoSfGBaW8gYmgNy90AcmyI290AccNgAo + GDIwMjQtMTEtMjBUMDU6MTg6MzEuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQV + BBUCABUAFQQVEgAAFoDLiYAIFf4BFoCm4f8HFb4HACbipMXQBxwVChklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudApjb25maWRlbmNlFQwWnJUVFqrXIBb8+Rwm4qTF0Acm3v/D0AccGAiBBMWPMXfv + PxgIzczMzMzM5D8WtrMGKAiBBMWPMXfvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUSAAAW/syJ + gAgVkAIWvq3h/wcVkAMAJqL64NAHHBUCGTUGCAQZGAVsZXZlbBUMFpyVFRb4BhasCCai+uDQByba + +eDQBxwYBAEAAAAYBP////8W5pQVKAQBAAAAGAT/////ABksFQQVBBUCABUAFQQVEgAAFo7PiYAI + FfABFs6w4f8HFYICACashOHQBxwVDBk1BggEGRgHc3VidHlwZRUMFpyVFRb8Nhb6LSashOHQByaG + guHQBxw2yO8UKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEgAA + Fv7QiYAIFf4BFtCy4f8HFdwDACa0tOHQBxwVDBk1BggEGRgFY2xhc3MVDBaclRUWrDgWjDAmtLTh + 0AcmgLDh0AccNubwFCgJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEgAAFvzS + iYAIFf4BFqy24f8HFcIDACaM4OHQBxwVChk1BggAGRgGaGVpZ2h0FQwWnJUVFvoKFtIIJozg4dAH + PBgIAAAAAACASEAYCAAAAAAAAABAFsqUFSgIAAAAAACASEAYCAAAAAAAAABAABkcFQAVABUSAAAW + +tSJgAgV8AEW7rnh/wcVggIAJt7o4dAHHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWnJUVFqJp + FrRGJt7o4dAHPDaokRUoCGEgQ3VlbnRhGBsxZXJhIENvbXBhw7HDrWEgZGUgQm9tYmVyb3MAGRwV + ABUAFRIAABbq1omACBX+ARbwu+H/BxW+BAAmkq/i0AccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQNrZXkVDBaclRUWkhYWohMmkq/i0Ac8NpyVFQAZHBUAFQAVEgAAFujYiYAIFf4BFq7A + 4f8HFYIBACa0wuLQBxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWnJUV + FpwZFv4TJrTC4tAHPDaclRUAGRwVABUAFRIAABbm2omACBX+ARawweH/BxWCAQAmstbi0AccFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaelRUWpBoWihUmstbi0Ac8 + NpSVFSgIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEgAAFuTciYAIFf4BFrLC4f8HFYgCACa8 + 6+LQBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBaelRUWqBkW + mhQmvOvi0Ac8Np6VFQAZHBUAFQAVEgAAFuLeiYAIFf4BFrrE4f8HFYIBACbW/+LQBxwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBaelRUWxBsWmBYm1v/i0Ac8NpSVFSgh + Q2VudHJvIGRlIFNhbHVkIEZhbWlsaWFyIFF1aW50ZXJvGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENo + aWxlABkcFQAVABUSAAAW4OCJgAgV/gEWvMXh/wcVggQAJu6V49AHHBUKGSUGABl4BW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFp6VFRaqGRacFCbulePQBzw2 + npUVABkcFQAVABUSAAAW3uKJgAgV/gEWvsnh/wcVggEAJoqq49AHHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWnpUVFqgZFpoUJoqq49AHPDaelRUAGRwVABUAFRIAABbc + 5ImACBX+ARbAyuH/BxWCAQAmpL7j0AccFQAZNQYIABkYCWhhc19wYXJ0cxUMFpyVFRa41wIWlgcm + pL7j0Ac8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABba5omACBXsARbCy+H/BxWCAQAmusXj0Acc + FQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWnJUVFrjXAhaWBya6xePQBzwYAQAYAQAWACgBABgB + AAAZHBUAFQAVEgAAFsboiYAIFewBFsTM4f8HFYIBACb6zePQBxwVAhk1BggEGRgKbnVtX2Zsb29y + cxUMFpyVFRbkGhacGSb6zePQBybQzOPQBxwYBBgAAAAYBAEAAAAW7IIVKAQYAAAAGAQBAAAAABks + FQQVBBUCABUAFQQVEgAAFrLqiYAIFfoBFsbN4f8HFZICACbs5ePQBxwVAhk1BggAGRgWbnVtX2Zs + b29yc191bmRlcmdyb3VuZBUMFpyVFRbSBBb0BSbs5ePQBzw2nJUVABkcFQAVABUSAAAWrOyJgAgV + 7AEW2M/h/wcVggEAJuDr49AHHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWnJUVFtIEFvQFJuDr49AH + PDaclRUAGRwVABUAFRIAABaY7omACBXsARba0OH/BxWCAQAm1PHj0AccFQIZNQYIABkYCW1pbl9m + bG9vchUMFpyVFRbSBBb0BSbU8ePQBzw2nJUVABkcFQAVABUSAAAWhPCJgAgV7AEW3NHh/wcVggEA + Jsj349AHHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBaclRUW0gQW9AUmyPfj0Ac8NpyVFQAZHBUA + FQAVEgAAFvDxiYAIFewBFt7S4f8HFYIBACa8/ePQBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFs + FQwWnJUVFtIEFvQFJrz949AHPDaclRUAGRwVABUAFRIAABbc84mACBXsARbg0+H/BxWCAQAmsIPk + 0AccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaclRUW0gQW9AUmsIPk0Ac8NpyVFQAZHBUAFQAV + EgAAFsj1iYAIFewBFuLU4f8HFYIBACakieTQBxwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFpyVFRas + HBbYCSakieTQBzw2jpMVKAZoaXBwZWQYBmdhYmxlZAAZHBUAFQAVEgAAFrT3iYAIFe4BFuTV4f8H + FeIBACb8kuTQBxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaclRUW0gQW9AUm/JLk0Ac8NpyV + FQAZHBUAFQAVEgAAFqL5iYAIFewBFsbX4f8HFYIBACbwmOTQBxwVDBk1BggAGRgQcm9vZl9vcmll + bnRhdGlvbhUMFpyVFRbSBBb0BSbwmOTQBzw2nJUVABkcFQAVABUSAAAWjvuJgAgV7AEWyNjh/wcV + ggEAJuSe5NAHHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWnJUVFtIEFvQFJuSe5NAHPDaclRUAGRwV + ABUAFRIAABb6/ImACBXsARbK2eH/BxWCAQAm2KTk0AccFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW + nJUVFtIEFvQFJtik5NAHPDaclRUAGRwVABUAFRIAABbm/omACBXsARbM2uH/BxWCAQAW5KiWHRac + lRUm8vvdwQcW2q6GDxSGAQAZ/CYmzKrk0AccFQwZNQYIABkYAmlkFQwWuMITFq7cvgUWoKrHASbM + quTQBzw2ACggMDhiYjJlMjZlYzkyNGZmZjAyMDA3YzI4ZGI1NWY1MWYYIDA4YmIyYzQwNGQ5YTlm + ZmYwMjAwMTRlNmQ4NWE0ZTYyABkcFQAVABUQAAAW0oCKgAgV8gEWztvh/wcV1ggAJuzUq9IHHBUM + GTUGCAAZGAhnZW9tZXRyeRUMFrjCExayk5sQFsT70Akm7NSr0gc8NgAowwEAAAAABgAAAAIAAAAA + AwAAAAEAAAAFwFHMi3R7RW/AQGYjULjYw8BRzIotj3GqwEBmJALm0i/AUcyJ1ZF23cBAZiI2PfCd + wFHMixx9P0jAQGYhhA/+nMBRzIt0e0VvwEBmI1C42MMAAAAAAwAAAAEAAAAFwFHMiuoBM6vAQGYg + e8ObYcBRzIgXJQ6AwEBmIgW9GfXAUcyH6pkC28BAZiEche1lwFHMir11G1rAQGYfkox348BRzIrq + ATOrwEBmIHvDm2EYTQAAAAADAAAAAQAAAATAUctyDx3casBAY/nSKJIxwFHLcc4cAibAQGP4sMe0 + LsBRy3KOJdxowEBj+YCzzQfAUctyDx3casBAY/nSKJIxABkcFQAVABUkAAAWxIKKgAgVoAQWpOTh + /wcVriUAJoCnitwHHBUIGTUGCAQZKARiYm94BHhtaW4VDBa4whMWotQ4FuqnMSaAp4rcByaw0Pzb + BxwYBA4IjsIYBGHzjsIWACgEDgiOwhgEYfOOwgAZLBUEFQQVAgAVABUEFRAAABbkhoqACBXyARbS + ieL/BxXWAQAmnNG73AccFQgZNQYIBBkoBGJib3gEeG1heBUMFrjCExaq2DgWsqgxJpzRu9wHJpr4 + rdwHHBgE8geOwhgEVPOOwhYAKATyB47CGARU847CABksFQQVBBUCABUAFQQVEAAAFtaIioAIFfIB + FqiL4v8HFdYBACamwPjcBxwVCBk1BggEGSgEYmJveAR5bWluFQwWuMITFvqsSRbg2T0mpsD43Acm + zKDf3AccGAQLYAHCGAQNMATCFgAoBAtgAcIYBA0wBMIAGSwVBBUEFQIAFQAVBBUQAAAWyIqKgAgV + 8gEW/ozi/wcV1gEAJqCatt0HHBUIGTUGCAQZKARiYm94BHltYXgVDBa4whMWqK1JFr7aPSagmrbd + Byas+pzdBxwYBPBfAcIYBPMvBMIWACgE8F8BwhgE8y8EwgAZLBUEFQQVAgAVABUEFRAAABa6jIqA + CBXyARbUjuL/BxXWAQAmqtXa3QccFQIZNQYIBBkYB3ZlcnNpb24VDBa4whMW/AQWngYmqtXa3Qcm + 6tTa3QccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWrI6KgAgV + 0gEWqpDi/wcV1gEAJsjb2t0HHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5 + FQwWuMITFv4FFqAHJsjb2t0HJojb2t0HHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW/o+K + gAgV0gEWgJLi/wcVVgAm7OPa3QccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNl + dBUMFrjCExbW7wQW9vsCJuzj2t0HJqji2t0HHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3Bl + biBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW0JGKgAgV4gEW1pLi/wcV9gQAJp7e3d0HHBUM + GSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFrjCExaw3PoCFsT/dyae3t3d + Bzw2ACgMdzk4OTI0OTk1N0AxGAwwMDAwNmQyM2RkMWMAGRwVABUAFRAAABayk4qACBXyARbMl+L/ + BxXWAwAmpKzW3gccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBa4 + whMW4NEWFrbZBiakrNbeBybi3dXeBxw2ACgYMjAyNC0xMS0yM1QxMjoyNzo1NS4wMDBaGBgyMDAw + LTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWpJWKgAgV4gEWopvi/wcV1gYA + JtbZ3d4HHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBa4whMWnOwd + FuaqGibW2d3eByaYt9zeBxwYCAaBlUOLbO8/GAjNzMzMzMzkPxbSoQYoCAaBlUOLbO8/GAjNzMzM + zMzkPwAZLBUEFQQVAgAVABUEFRAAABaGl4qACBXyARb4oeL/BxXmAgAmzuL23gccFQIZNQYIBBkY + BWxldmVsFQwWuMITFvQGFoQIJs7i9t4HJv7h9t4HHBgEAQAAABgE/////xa+wRMoBAEAAAAYBP// + //8AGSwVBBUEFQIAFQAVBBUQAAAW+JiKgAgV1gEW3qTi/wcVxgEAJqbs9t4HHBUMGTUGCAQZGAdz + dWJ0eXBlFQwWuMITFphCFtw4Jqbs9t4HJoLq9t4HHDbSjBMoDnRyYW5zcG9ydGF0aW9uGAxhZ3Jp + Y3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWzpqKgAgV4gEWpKbi/wcVogMAJpKn994HHBUMGTUG + CAQZGAVjbGFzcxUMFrjCExbyRBbyOyaSp/feBybeovfeBxw2kI4TKAl3YXJlaG91c2UYCmFwYXJ0 + bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWsJyKgAgV4gEWxqni/wcVlgMAJtDe994HHBUKGTUGCAAZ + GAZoZWlnaHQVDBa4whMWngYWggcm0N733gc8GAgAAAAAAAA5QBgIAAAAAAAAAEAWoMITKAgAAAAA + AAA5QBgIAAAAAAAAAEAAGRwVABUAFRAAABaSnoqACBXYARbcrOL/BxWWAgAm0uX33gccFQwZNQYI + ABkoBW5hbWVzB3ByaW1hcnkVDBa4whMWvIcBFqhXJtLl994HPDaOvRMoA2lzdBgjM3JhIENvbXBh + w7HDrWEgQm9tYmVyb3MgTWFpdGVuY2lsbG8AGRwVABUAFRAAABbqn4qACBXiARbyruL/BxWcBQAm + +rz43gccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbAwhMWqBgWlBQm+rz4 + 3gc8Nq7CEygCZXMYAmVuABkcFQAVABUQAAAWzKGKgAgV4gEWjrTi/wcVhgEAJo7R+N4HHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbAwhMWsB0WqBYmjtH43gc8Nq7CEygK + U3RhdGUgQmFuaxgMQmFuY28gRXN0YWRvABkcFQAVABUQAAAWrqOKgAgV4gEWlLXi/wcV2gEAJrbn + +N4HHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWzMITFtYfFrIX + Jrbn+N4HPDaewhMoCG9mZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRAAABaQpYqACBXiARbutuL/ + BxXAAgAm6P743gccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW + zMITFuwbFsAVJuj++N4HPDbAwhMoAmVzGAJlbgAZHBUAFQAVEAAAFvKmioAIFeIBFq654v8HFX4A + JqiU+d4HHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFszCExaoJxb6 + GyaolPneBzw2nsITKCpTZXJ2aWNpbyBkZSBBdGVuY2nDs24gUHJpbWFyaWEgZGUgVXJnZW5jaWEY + H0JhbmNvIEJpbGJhbyBWaXpjYXlhIEFyZ2VudGFyaWEAGRwVABUAFRAAABbUqIqACBXiARasuuL/ + BxXkBgAmorD53gccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlz + dAdlbGVtZW50FQwWzMITFrIbFp4VJqKw+d4HPDbMwhMAGRwVABUAFRAAABa2qoqACBXiARaQweL/ + BxV2ACbAxfneBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFszCExai + GxacFSbAxfneBzw2zMITABkcFQAVABUQAAAWmKyKgAgV4gEWhsLi/wcVdgAm3Nr53gccFQAZNQYI + ABkYCWhhc19wYXJ0cxUMFrjCExbIvAIWsAYm3Nr53gc8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAA + ABb6rYqACBXSARb8wuL/BxV2ACaM4fneBxwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBa4whMW + yLwCFrAGJozh+d4HPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWzK+KgAgV0gEW8sPi/wcVdgAm + tOj53gccFQIZNQYIBBkYCm51bV9mbG9vcnMVDBa4whMWpg0Wmg4mtOj53gcmvOf53gccGAQKAAAA + GAQBAAAAFuy9EygECgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABaesYqACBXgARboxOL/BxX2 + AQAm1vX53gccFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBa4whMWkAQWoAUm1vX5 + 3gc8NrjCEwAZHBUAFQAVEAAAFv6yioAIFdIBFt7G4v8HFXYAJvb6+d4HHBUKGTUGCAAZGAptaW5f + aGVpZ2h0FQwWuMITFpAEFqAFJvb6+d4HPDa4whMAGRwVABUAFRAAABbQtIqACBXSARbUx+L/BxV2 + ACaWgPreBxwVAhk1BggAGRgJbWluX2Zsb29yFQwWuMITFpAEFqAFJpaA+t4HPDa4whMAGRwVABUA + FRAAABaitoqACBXSARbKyOL/BxV2ACa2hfreBxwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWuMIT + FpAEFqAFJraF+t4HPDa4whMAGRwVABUAFRAAABb0t4qACBXSARbAyeL/BxV2ACagi/reBxwVDBk1 + BggEGRgPZmFjYWRlX21hdGVyaWFsFQwWuMITFugEFooGJqCL+t4HJtaK+t4HHBgFbWV0YWwYBW1l + dGFsFrDCEygFbWV0YWwYBW1ldGFsABksFQQVBBUCABUAFQQVEAAAFsa5ioAIFdIBFrbK4v8HFYoB + ACbgkPreBxwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFrjCExaQBBagBSbgkPreBzw2uMITABkc + FQAVABUQAAAWmLuKgAgV0gEWwMvi/wcVdgAmgJb63gccFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBa4 + whMWqgUW5gUmgJb63gc8GAZnYWJsZWQYBmdhYmxlZBaswhMoBmdhYmxlZBgGZ2FibGVkABkcFQAV + ABUQAAAW6ryKgAgV1AEWtszi/wcVjgEAJuab+t4HHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUM + FrjCExaQBBagBSbmm/reBzw2uMITABkcFQAVABUQAAAWvr6KgAgV0gEWxM3i/wcVdgAmhqH63gcc + FQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBa4whMWkAQWoAUmhqH63gc8NrjCEwAZHBUAFQAV + EAAAFpDAioAIFdIBFrrO4v8HFXYAJoin+t4HHBUMGTUGCAQZGApyb29mX2NvbG9yFQwWuMITFoAF + FqIGJoin+t4HJqam+t4HHDaywhMoByNGRjAwMDAYByM3Nzg4OTkAGSwVBBUEFQIAFQAVBBUQAAAW + 4sGKgAgV0gEWsM/i/wcVkgEAJsis+t4HHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFrjCExaQBBag + BSbIrPreBzw2uMITABkcFQAVABUQAAAWtMOKgAgV0gEWwtDi/wcVdgAWgK2bGxa4whMmzKrk0AcW + nIeWDhSIAQAZ/CYm6LH63gccFQwZNQYIABkYAmlkFQwWjLETFvzruQUWorTIASbosfreBzw2ACgg + MDhiYjJlMzc5ZWRiNWZmZjAyMDBkMmFlOGY0NzFmYWUYIDA4YmIyYzQ4MDBkOTNmZmYwMjAwMGY3 + ZWVhM2IwZDdmABkcFQAVABUQAAAWhsWKgAgV8gEWuNHi/wcV1ggAJormwuAHHBUMGTUGCAAZGAhn + ZW9tZXRyeRUMFoyxExaqioEQFvbHxAkmiubC4Ac8NgAo7QMAAAAAAwAAAAUAAAAJwFGuW9obaenA + QGBa5tZjT8BRrl3mZSRHwEBgZflZHNLAUa5ai9IwusBAYGe6+jxywFGuWgt5sMbAQGBlBT1Wo8BR + rlc4y/lowEBgZn+Q2dfAUa5W5wICOcBAYGTEpbbewFGuU1V9ChfAQGBmosxIQ8BRrlIbVcbcwEBg + YADxl4fAUa5b2htp6cBAYFrm1mNPAAAABcBRrlxbSqlxwEBgY9WSbizAUa5bblA/s8BAYGRETTbq + wFGuW51KKELAQGBlXv9p2MBRrlyJ2TI2wEBgZPEbYK/AUa5cW0qpccBAYGPVkm4sAAAABcBRrls+ + 6vdawEBgXrI8/o7AUa5ZXCdIQ8BAYF+HTxQ6wFGuWb3hd3/AQGBh+Rlb8sBRrlugpSaWwEBgYSMw + hrHAUa5bPur3WsBAYF6yPP6OAAAABcBRrlgiAAUIwEBgYFCir8PAUa5W9G37hsBAYGDPTbCNwFGu + V0ppsJ7AQGBjEUdQIcBRrlh3kFpWwEBgYpKcT1bAUa5YIgAFCMBAYGBQoq/DAAAABcBRrlVMzg7s + wEBgYWf55F3AUa5T4tYjjsBAYGIbfgrIwFGuVEtGT3DAQGBkcMLgu8BRrlW1qZqZwEBgY7xn+rvA + Ua5VTM4O7MBAYGFn+eRdGE0AAAAAAwAAAAEAAAAEwFGsSIPcKUDAQGxgIhW28cBRrEihToZVwEBs + YZup4nfAUaxH5DmBesBAbGHFsUzLwFGsSIPcKUDAQGxgIhW28QAZHBUAFQAVJAAAFvjGioAIFaAE + Fo7a4v8HFa4lACaArofqBxwVCBk1BggAGSgEYmJveAR4bWluFQwWjLETFoDJTRbamiomgK6H6gc8 + GAQFVI3CGARM5Y7CFgAoBAVUjcIYBEzljsIAGRwVABUAFRAAABaYy4qACBXyARa8/+L/BxXWAQAm + 2six6gccFQgZNQYIABkoBGJib3gEeG1heBUMFoyxExb+yE0W2pwqJtrIseoHPBgE41ONwhgEO+WO + whYAKATjU43CGAQ75Y7CABkcFQAVABUQAAAWis2KgAgV8gEWkoHj/wcV1gEAJrTl2+oHHBUIGTUG + CAAZKARiYm94BHltaW4VDBaMsRMW/shNFqyULSa05dvqBzwYBAZgAcIYBAswBMIWACgEBmABwhgE + CzAEwgAZHBUAFQAVEAAAFvzOioAIFfIBFuiC4/8HFdYBACbg+YjrBxwVCBk1BggAGSgEYmJveAR5 + bWF4FQwWjLETFvzITRbCli0m4PmI6wc8GATvXwHCGATzLwTCFgAoBO9fAcIYBPMvBMIAGRwVABUA + FRAAABbu0IqACBXyARa+hOP/BxXWAQAm4pC26wccFQIZNQYIBBkYB3ZlcnNpb24VDBaMsRMW/gQW + oAYm4pC26wcmopC26wccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQ + AAAW4NKKgAgV0gEWlIbj/wcV1gEAJoKXtusHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CHByb3BlcnR5FQwWjLETFv4FFqAHJoKXtusHJsKWtusHHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAV + BBUQAAAWstSKgAgV0gEW6ofj/wcVVgAmpp+26wccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQHZGF0YXNldBUMFoyxExaQ5AQWvNgCJqaftusHJuKdtusHHDYAKA1PcGVuU3RyZWV0TWFwGBVH + b29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWhNaKgAgV4gEWwIjj/wcV9gQA + Jp72uOsHHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFoyxExaO/PcC + FoiVfSae9rjrBzw2ACgMdzk5Mzk5NjA5MkAxGAwwMDAwMjIzZWMwM2YAGRwVABUAFRAAABbm14qA + CBXyARa2jeP/BxXUAwAm+Ki27AccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRl + X3RpbWUVDBaMsRMWmsoQFtCOBSb4qLbsByami7bsBxw2ACgYMjAyNC0xMS0yMFQwNzowNzozNi4w + MDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAW2NmKgAgV4gEW + ipHj/wcV1gYAJvi9vOwHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UV + DBaMsRMWiNAdFpKSGib4vbzsByb2mbvsBxwYCFioNc07Tu8/GAjNzMzMzMzkPxacnQYoCFioNc07 + Tu8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABa624qACBXyARbgl+P/BxXmAgAmiKzV7Acc + FQIZNQYIABkYBWxldmVsFQwWjLETFsAFFtAGJois1ewHPBgEAQAAABgEAQAAABb4sBMoBAEAAAAY + BAEAAAAAGRwVABUAFRAAABas3YqACBXSARbGmuP/BxXWAQAmgLXV7AccFQwZNQYIBBkYB3N1YnR5 + cGUVDBaMsRMWoBYWghUmgLXV7Acm2LLV7AccNpqsEygOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0 + dXJhbAAZLBUEFQQVAgAVABUEFRAAABb+3oqACBXiARacnOP/BxW2AwAmmMvV7AccFQwZNQYIBBkY + BWNsYXNzFQwWjLETFqAWFuYUJpjL1ewHJtrH1ewHHDbkrBMoCXdhcmVob3VzZRgKYXBhcnRtZW50 + cwAZLBUEFQQVAgAVABUEFRAAABbg4IqACBXiARbSn+P/BxWQAwAmwNzV7AccFQoZNQYIABkYBmhl + aWdodBUMFoyxExaQBBagBSbA3NXsBzw2jLETABkcFQAVABUQAAAWwuKKgAgV0gEW4qLj/wcVdgAm + 4OHV7AccFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaMsRMW6i8W9CUm4OHV7Ac8NsyvEygSw5Nw + dGljYSBCZWxsYXZpc3RhGAZBYmNkaW4AGRwVABUAFRAAABaU5IqACBXiARbYo+P/BxX6BQAm1IfW + 7AccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBaMsRMWqAwWsAwm1IfW7Ac8 + NoyxEwAZHBUAFQAVEAAAFvblioAIFeIBFtKp4/8HFXYAJoSU1uwHHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUFdmFsdWUVDBaMsRMW0A0WqAwmhJTW7Ac8NoyxEwAZHBUAFQAVEAAAFtjn + ioAIFeIBFsiq4/8HFXYAJqyg1uwHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2 + YXJpYW50FQwWjLETFpwOFvwMJqyg1uwHPBgIb2ZmaWNpYWwYCG9mZmljaWFsFoaxEygIb2ZmaWNp + YWwYCG9mZmljaWFsABkcFQAVABUQAAAWuumKgAgV4gEWvqvj/wcV1gEAJqit1uwHHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFoyxExbQDRa6DCaordbsBzw2jLET + ABkcFQAVABUQAAAWnOuKgAgV4gEWlK3j/wcVdgAm4rnW7AccFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50BXZhbHVlFQwWjLETFo4PFvINJuK51uwHPDaGsRMoGUJhbmNvIGRlbCBFc3Rh + ZG8gZGUgQ2hpbGUYH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJzaW9uZXMAGRwVABUAFRAAABb+ + 7IqACBXiARaKruP/BxW6AwAm1MfW7AccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWjLETFtANFroMJtTH1uwHPDaMsRMAGRwVABUAFRAAABbg + 7oqACBXiARbEseP/BxV2ACaO1NbsBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQE + c2lkZRUMFoyxExbQDRa6DCaO1NbsBzw2jLETABkcFQAVABUQAAAWwvCKgAgV4gEWurLj/wcVdgAm + yODW7AccFQAZNQYIABkYCWhhc19wYXJ0cxUMFoyxExayugIWsAYmyODW7Ac8GAEAGAEAFgAoAQAY + AQAAGRwVABUAFRAAABak8oqACBXSARaws+P/BxV2ACb45tbsBxwVABk1BggAGRgOaXNfdW5kZXJn + cm91bmQVDBaMsRMWsroCFrAGJvjm1uwHPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAW9vOKgAgV + 0gEWprTj/wcVdgAmmO7W7AccFQIZNQYIBBkYCm51bV9mbG9vcnMVDBaMsRMW4gYWhAgmmO7W7Acm + qO3W7AccGAQIAAAAGAQBAAAAFsSwEygECAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbI9YqA + CBXWARacteP/BxXGAQAmrPXW7AccFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaM + sRMWkAQWoAUmrPXW7Ac8NoyxEwAZHBUAFQAVEAAAFp73ioAIFdIBFuK24/8HFXYAJsz61uwHHBUK + GTUGCAAZGAptaW5faGVpZ2h0FQwWjLETFpAEFqAFJsz61uwHPDaMsRMAGRwVABUAFRAAABbw+IqA + CBXSARbYt+P/BxV2ACbs/9bsBxwVAhk1BggAGRgJbWluX2Zsb29yFQwWjLETFpAEFqAFJuz/1uwH + PDaMsRMAGRwVABUAFRAAABbC+oqACBXSARbOuOP/BxV2ACaMhdfsBxwVDBk1BggAGRgMZmFjYWRl + X2NvbG9yFQwWjLETFpAEFqAFJoyF1+wHPDaMsRMAGRwVABUAFRAAABaU/IqACBXSARbEueP/BxV2 + ACasitfsBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWjLETFpAEFqAFJqyK1+wHPDaMsRMA + GRwVABUAFRAAABbm/YqACBXSARa6uuP/BxV2ACbMj9fsBxwVDBk1BggAGRgNcm9vZl9tYXRlcmlh + bBUMFoyxExaQBBagBSbMj9fsBzw2jLETABkcFQAVABUQAAAWuP+KgAgV0gEWsLvj/wcVdgAm7JTX + 7AccFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaMsRMWkAQWoAUm7JTX7Ac8NoyxEwAZHBUAFQAVEAAA + FoqBi4AIFdIBFqa84/8HFXYAJoya1+wHHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFoyxExaQ + BBagBSaMmtfsBzw2jLETABkcFQAVABUQAAAW3IKLgAgV0gEWnL3j/wcVdgAmrJ/X7AccFQwZNQYI + ABkYEHJvb2Zfb3JpZW50YXRpb24VDBaMsRMWkAQWoAUmrJ/X7Ac8NoyxEwAZHBUAFQAVEAAAFq6E + i4AIFdIBFpK+4/8HFXYAJsyk1+wHHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWjLETFpAEFqAFJsyk + 1+wHPDaMsRMAGRwVABUAFRAAABaAhouACBXSARaIv+P/BxV2ACbsqdfsBxwVChk1BggAGRgLcm9v + Zl9oZWlnaHQVDBaMsRMWkAQWoAUm7KnX7Ac8NoyxEwAZHBUAFQAVEAAAFtKHi4AIFdIBFv6/4/8H + FXYAFtyOoxsWjLETJuix+t4HFqT93A0UigEAGfwmJoyv1+wHHBUMGTUGCAAZGAJpZBUMFszCExb+ + 4b4FFrziyQEmjK/X7Ac8NgAoIDA4YmIyZTNjZGVhYjFmZmYwMjAwMjI3NGZjYWZmMzMxGCAwOGJi + MmM0ODRkOTA5ZmZmMDIwMGEwMjczYjg4ZDUwNwAZHBUAFQAVEAAAFqSJi4AIFfIBFvTA4/8HFdYI + ACbIkaHuBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBbMwhMWitb7DxaAgrsJJsiRoe4HPDYAKO0HAAAA + AAMAAAAFAAAAKcBRpYFbSdKywEBsPqSAfWnAUaWDKD4Mq8BAbEKhZT/2wFGlgtnPE8/AQGxDIOcA + VcBRpYP1w2YcwEBsRZEDyOLAUaWFNjVGM8BAbEQbuMMrwFGlhv4hAq/AQGxH35KiL8BRpYWYxjUD + wEBsSX+l0o3AUaWGo/OPr8BAbEvE+nB0wFGlhw7n+lDAQGxLUuSpYsBRpYesMUvSwEBsTGo73f3A + UaWIzgTbMcBAbEr+KxOqwFGlieSFUDbAQGxNBkMQIMBRpYSkPw8KwEBsVJL/S6XAUaWE+3zjgMBA + bFVKtS/4wFGlg9mpVCLAQGxW5paibsBRpYNutOmBwEBsVf8QFfjAUaWC/kyhmcBAbFaRBk0hwFGl + grVRhgXAQGxWCEpRXcBRpYEasjLuwEBsWGATZg7AUaWA8FVoEcBAbFglWwNcwFGlf8kN+2vAQGxV + jPpO5sBRpYGb4XJ2wEBsUwEu1CnAUaWArM4pxMBAbFD+H1UwwFGlfq0ZqR7AQGxTe6gXC8BRpXsp + AKpKwEBsTKJwAfHAUaV8i2vZbcBAbEq23Xc/wFGle/v54QLAQGxJg9eQdcBRpXnefc85wEBsTFRs + aN/AUaV5JYXLhsBAbEr/AdM/wFGlebalQxvAQGxKLHP8UcBRpXiO8narwEBsR8nDLRHAUaV6ncBv + x8BAbEUhckCPwFGley2dx/3AQGxGOnb0U8BRpXtd2c/rwEBsRe1KGtbAUaV6g788wcBAbERLiWtO + wFGlfEJwvdjAQGxCASxP6sBRpXqk4cw4wEBsPptGQgTAUaV8R+SbIMBAbDyE64yrwFGlfSBRrx/A + QGw+RbXstsBRpX7woOdswEBsQfwj0m3AUaWBW0nSssBAbD6kgH1pAAAABcBRpYFxhKeawEBsRIz3 + yqfAUaWAgnFe6MBAbEXqxdwYwFGlgNFLt47AQGxGeIpVWcBRpYG/HODhwEBsRSZ6vgzAUaWBcYSn + msBAbESM98qnAAAABcBRpYMbqNLzwEBsR7TKd4jAUaWCT9D4q8BAbEjeliLtwFGlgo3kWbHAQGxJ + S6NsgcBRpYNYDrTPwEBsSDAaef/AUaWDG6jS88BAbEe0yneIAAAABcBRpYR54kQtwEBsSpsuxQ/A + UaWDpukNdcBAbEvONKvZwFGlg+1f6kvAQGxMUr7ptcBRpYTAWSEEwEBsSxqwhW7AUaWEeeJELcBA + bEqbLsUPAAAABcBRpYXr0kuSwEBsTbdC98zAUaWFdzhFwsBAbE5chGVVwFGlhbHwqHTAQGxO0Eer + kMBRpYYoOC1uwEBsTiiB/0nAUaWF69JLksBAbE23QvfMGE0AAAAAAwAAAAEAAAAEwFGluHleBK3A + QGqrD/DCKcBRpbizbcbQwEBqrBI/VQLAUaW4CREf1cBAaqx/bFJcwFGluHleBK3AQGqrD/DCKQAZ + HBUAFQAVJAAAFpaLi4AIFaAEFsrJ4/8HFa4lACbIk9z3BxwVCBk1BggAGSgEYmJveAR4bWluFQwW + zMITFoCPThbqsysmyJPc9wc8GAQJoIzCGAR/Go/CFgAoBAmgjMIYBH8aj8IAGRwVABUAFRAAABa2 + j4uACBXyARb47uP/BxXWAQAmsseH+AccFQgZNQYIABkoBGJib3gEeG1heBUMFszCExb+jk4W6qwr + JrLHh/gHPBgE/Z+MwhgEdBqPwhYAKAT9n4zCGAR0Go/CABkcFQAVABUQAAAWqJGLgAgV8gEWzvDj + /wcV1gEAJpz0svgHHBUIGTUGCAAZKARiYm94BHltaW4VDBbMwhMW/o5OFsq4Liac9LL4BzwYBMzW + /sEYBJAvBMIWACgEzNb+wRgEkC8EwgAZHBUAFQAVEAAAFpqTi4AIFfIBFqTy4/8HFdYBACbmrOH4 + BxwVCBk1BggAGSgEYmJveAR5bWF4FQwWzMITFoCPThastS4m5qzh+Ac8GASn1v7BGAR+LwTCFgAo + BKfW/sEYBH4vBMIAGRwVABUAFRAAABaMlYuACBXyARb68+P/BxXWAQAm0uKP+QccFQIZNQYIBBkY + B3ZlcnNpb24VDBbMwhMW/gQWoAYm0uKP+QcmkuKP+QccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAA + AAAAGSwVBBUEFQIAFQAVBBUQAAAW/paLgAgV0gEW0PXj/wcV1gEAJvLoj/kHHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWzMITFv4FFqAHJvLoj/kHJrLoj/kHHBgAGAAW + ACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW0JiLgAgV0gEWpvfj/wcVVgAmlvGP+QccFQwZJQYEGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFszCExaQzwQWztUCJpbxj/kHJtLvj/kHHDYA + KA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW + opqLgAgV4gEW/Pfj/wcV9gQAJqDFkvkHHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJl + Y29yZF9pZBUMFszCExaO5f4CFtrOeyagxZL5Bzw2ACgMdzk5Mzk3NDM4NUAxGAwwMDAwZDE0NmY0 + ZGQAGRwVABUAFRAAABaEnIuACBXyARby/OP/BxXWAwAmksiO+gccFQwZJQYEGUgHc291cmNlcwRs + aXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbMwhMW/NcSFp64BSaSyI76Byb6k476Bxw2ACgYMjAy + NC0xMC0xOFQwMDo0MzoyNS4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIA + FQAVBBUQAAAW9p2LgAgV4gEWyIDk/wcV1gYAJprtlPoHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdl + bGVtZW50CmNvbmZpZGVuY2UVDBbMwhMW+NEeFsKfGyaa7ZT6ByaYzJP6BxwYCBe30QDeAu8/GAjN + zMzMzMzkPxaauQUoCBe30QDeAu8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABbYn4uACBXy + ARaeh+T/BxXmAgAm2uuu+gccFQIZNQYIABkYBWxldmVsFQwWzMITFrgFFqQGJtrrrvoHPBgEAQAA + ABgEAQAAABa2whMoBAEAAAAYBAEAAAAAGRwVABUAFRAAABbKoYuACBXWARaEiuT/BxW2AQAmhvSu + +gccFQwZNQYIBBkYB3N1YnR5cGUVDBbMwhMWvB8W8h0mhvSu+gcm/vGu+gccNtykEygOdHJhbnNw + b3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABago4uACBXiARa6i+T/BxXE + AwAmtpOv+gccFQwZNQYIBBkYBWNsYXNzFQwWzMITFtwgFtweJraTr/oHJvCPr/oHHDa0pRMoCnVu + aXZlcnNpdHkYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWgqWLgAgV4gEW/o7k/wcVlAMA + Jsyur/oHHBUKGTUGCAAZGAZoZWlnaHQVDBbMwhMWqgQWugUmzK6v+gc8GAgAAAAAAAAsQBgIAAAA + AAAALEAWysITKAgAAAAAAAAsQBgIAAAAAAAALEAAGRwVABUAFRAAABbkpouACBXSARaSkuT/BxWW + AQAmhrSv+gccFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBbMwhMW2C0WoiMmhrSv+gc8NobBEygQ + cGFzdGVsIGRlIGNob2NsbxgMQmFuY28gRXN0YWRvABkcFQAVABUQAAAWtqiLgAgV4gEWqJPk/wcV + 2AUAJqjXr/oHHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWzMITFtIMFsYM + JqjXr/oHPDbMwhMAGRwVABUAFRAAABaYqouACBXgARaAmeT/BxV2ACbu46/6BxwVDBklBgAZSAVu + YW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWzMITFoAOFtIMJu7jr/oHPDbMwhMAGRwVABUA + FRAAABb4q4uACBXgARb2meT/BxV2ACbA8K/6BxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQHdmFyaWFudBUMFtDCExaQDxa0DSbA8K/6Bzw2xsITKAhvZmZpY2lhbBgJYWx0ZXJuYXRl + ABkcFQAVABUQAAAW2K2LgAgV4AEW7Jrk/wcVuAEAJvT9r/oHHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFtDCExaUDhbmDCb0/a/6Bzw20MITABkcFQAVABUQAAAW + uK+LgAgV4AEWpJzk/wcVdgAm2oqw+gccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + BXZhbHVlFQwW0MITFt4QFooOJtqKsPoHPDbGwhMoGENlbnRybyBkZSBTYWx1ZCBGYW1pbGlhchgZ + QmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFpixi4AIFeABFpqd5P8HFdICACbk + mLD6BxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1l + bnQVDBbQwhMWmA4W6Awm5Jiw+gc8NtDCEwAZHBUAFQAVEAAAFviyi4AIFeABFuyf5P8HFXYAJsyl + sPoHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW0MITFpQOFuYMJsyl + sPoHPDbQwhMAGRwVABUAFRAAABbYtIuACBXgARbioOT/BxV2ACaysrD6BxwVABk1BggAGRgJaGFz + X3BhcnRzFQwWzMITFsq8AhawBiaysrD6BzwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFri2i4AI + FdIBFtih5P8HFXYAJuK4sPoHHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFszCExbKvAIWsAYm + 4riw+gc8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaKuIuACBXSARbOouT/BxV2ACaSv7D6BxwV + Ahk1BggAGRgKbnVtX2Zsb29ycxUMFszCExbyCBbgByaSv7D6BzwYBAoAAAAYBAEAAAAW5sETKAQK + AAAAGAQBAAAAABkcFQAVABUQAAAW3LmLgAgV2AEWxKPk/wcVtgEAJvLGsPoHHBUCGTUGCAAZGBZu + dW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWzMITFpAEFqAFJvLGsPoHPDbMwhMAGRwVABUAFRAAABa0 + u4uACBXSARb6pOT/BxV2ACaSzLD6BxwVChk1BggAGRgKbWluX2hlaWdodBUMFszCExaQBBagBSaS + zLD6Bzw2zMITABkcFQAVABUQAAAWhr2LgAgV0gEW8KXk/wcVdgAmstGw+gccFQIZNQYIABkYCW1p + bl9mbG9vchUMFszCExaQBBagBSay0bD6Bzw2zMITABkcFQAVABUQAAAW2L6LgAgV0gEW5qbk/wcV + dgAm0taw+gccFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFszCExaQBBagBSbS1rD6Bzw2zMITABkc + FQAVABUQAAAWqsCLgAgV0gEW3Kfk/wcVdgAm8tuw+gccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlh + bBUMFszCExaQBBagBSby27D6Bzw2zMITABkcFQAVABUQAAAW/MGLgAgV0gEW0qjk/wcVdgAmkuGw + +gccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbMwhMWkAQWoAUmkuGw+gc8NszCEwAZHBUAFQAV + EAAAFs7Di4AIFdIBFsip5P8HFXYAJrLmsPoHHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWzMITFpYF + FtQFJrLmsPoHPBgEZmxhdBgEZmxhdBa+whMoBGZsYXQYBGZsYXQAGRwVABUAFRAAABagxYuACBXU + ARa+quT/BxWGAQAmhuyw+gccFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWzMITFpAEFqAFJobs + sPoHPDbMwhMAGRwVABUAFRAAABb0xouACBXSARbEq+T/BxV2ACam8bD6BxwVDBk1BggAGRgQcm9v + Zl9vcmllbnRhdGlvbhUMFszCExaQBBagBSam8bD6Bzw2zMITABkcFQAVABUQAAAWxsiLgAgV0gEW + uqzk/wcVdgAmxvaw+gccFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbMwhMWkAQWoAUmxvaw+gc8NszC + EwAZHBUAFQAVEAAAFpjKi4AIFdIBFrCt5P8HFXYAJub7sPoHHBUKGTUGCAAZGAtyb29mX2hlaWdo + dBUMFszCExaQBBagBSbm+7D6Bzw2zMITABkcFQAVABUQAAAW6suLgAgV0gEWpq7k/wcVdgAWoOqu + GxbMwhMmjK/X7AcW+tHZDRSMAQAZ/CYmhoGx+gccFQwZNQYIABkYAmlkFQwW0PIGFpyg+AEWwsNH + JoaBsfoHPDYAKCAwOGJiMmUzZGI0MDZlZmZmMDIwMGI0OWJhYjkyYjQyNRggMDhiYjJlMDZjODI4 + MGZmZjAyMDA2NTBiNmYyMTgxOWMAGRwVABUAFQYAABa8zYuACBVcFpyv5P8HFa4DACbIxPj6BxwV + DBk1BggAGRgIZ2VvbWV0cnkVDBbQ8gYW6oW9BRa015kDJsjE+PoHPDYAKOECAAAAAAMAAAACAAAA + EMBR31rfSacTwD/ob4/a0/fAUd9ZmxFo3sA/6HxmguvYwFHfWI6h7tPAP+h56Pop/cBR31bXfSn3 + wD/odiytBzXAUd9T+lMX1cA/6HEWw5DkwFHfUdBBzFPAP+ht+dieksBR31JPw4yywD/oaPFbIY/A + Ud9XQgY0zcA/6HCyGcMgwFHfV3Ux20TAP+humTrPCcBR31VThAuTwD/oaqPiyLjAUd9Seou3WcA/ + 6Ga9pDrdwFHfUw/c7NbAP+hh0awvnsBR31UTwytjwD/oZF5OafDAUd9XcQAdXMA/6GhwK+IGwFHf + WRskSLXAP+hrxiG34cBR31rfSacTwD/ob4/a0/cAAAAFwFHfWWpqASbAP+hygSbcDcBR31iS06y7 + wD/ocT1Z/aLAUd9YSJZxx8A/6HN2GWHRwFHfWSAsxjLAP+h0ueZAO8BR31lqagEmwD/ocoEm3A0Y + TQAAAAADAAAAAQAAAATAUbNzYfxBAcBAHU5U2KLxwFGzcypLldjAQB1PaMww/cBRs3KN2XsMwEAd + Tw2NYwbAUbNzYfxBAcBAHU5U2KLxABkcFQAVABUOAAAWmM6LgAgV1AEWyrLk/wcVzg4AJtjDnv4H + HBUIGTUGCAQZKARiYm94BHhtaW4VDBbQ8gYW0IseFrz2GCbYw57+Byb8m5L+BxwYBJugjMIYBJ0d + j8IWACgEm6CMwhgEnR2PwgAZLBUEFQQVAgAVABUEFQYAABbsz4uACBVcFpjB5P8HFV4AJsS2t/4H + HBUIGTUGCAQZKARiYm94BHhtYXgVDBbQ8gYWuIYeFuDyGCbEtrf+Bya4kqv+BxwYBJSgjMIYBJUd + j8IWACgElKCMwhgElR2PwgAZLBUEFQQVAgAVABUEFQYAABbI0IuACBVcFvbB5P8HFV4AJpiFxP4H + HBUIGTUGCAAZKARiYm94BHltaW4VDBbQ8gYWnswbFsS/EiaYhcT+BzwYBA8g/cEYBNFfAcIWACgE + DyD9wRgE0V8BwgAZHBUAFQAVBgAAFqTRi4AIFVwW1MLk/wcVXgAm3MTW/gccFQgZNQYIABkoBGJi + b3gEeW1heBUMFtDyBhaezBsWxL0SJtzE1v4HPBgE4B/9wRgEw18BwhYAKATgH/3BGATDXwHCABkc + FQAVABUGAAAWgNKLgAgVXBayw+T/BxVeACbggun+BxwVAhk1BggEGRgHdmVyc2lvbhUMFtDyBhaM + AhbUAibggun+Byaggun+BxwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUE + FQYAABbc0ouACBVQFpDE5P8HFV4AJrSF6f4HHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CHByb3BlcnR5FQwW0PIGFroCFoIDJrSF6f4HJvSE6f4HHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAV + BBUGAAAWrNOLgAgVUBbuxOT/BxUuACa6ien+BxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAdkYXRhc2V0FQwW0PIGFtyaARboZSa6ien+Byb2h+n+Bxw2ACgNT3BlblN0cmVldE1hcBgVR29v + Z2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVBgAAFvzTi4AIFVYWnMXk/wcV+gEAJt7t + 6f4HHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFtDyBhbu8oYBFvC5 + Kibe7en+Bzw2ACgMdzk4MTA1MzM2OEAxGAwwMDAyYmM0OWRjMGYAGRwVABUAFQYAABbS1IuACBVc + FpbH5P8HFb4BACbumpX/BxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGlt + ZRUMFtDyBhbS9QsW/K8DJu6alf8HJs6nlP8HHDYAKBgyMDI0LTExLTExVDAwOjA0OjU0LjAwMFoY + GDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFQYAABau1YuACBVYFtTI5P8H + Fc4CACbA8pj/BxwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW0PIG + FuTzCxas8AkmwPKY/wcmyteX/wccGAhz1xLyQc/uPxgIzczMzMzM5D8WxP4BKAhz1xLyQc/uPxgI + zczMzMzM5D8AGSwVBBUEFQIAFQAVBBUGAAAWhtaLgAgVXBaiy+T/BxWWAQAm9seh/wccFQIZNQYI + ABkYBWxldmVsFQwW0PIGFugBFp4CJvbHof8HPBgEAQAAABgEAQAAABbM8gYoBAEAAAAYBAEAAAAA + GRwVABUAFQYAABbi1ouACBVQFrjM5P8HFVoAJqrMof8HHBUMGTUGCAQZGAdzdWJ0eXBlFQwW0PIG + FpQOFtIMJqrMof8HJpTKof8HHDbk6AYoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwV + BBUEFQIAFQAVBBUGAAAWsteLgAgVVhaSzeT/BxW+AQAm5Nih/wccFQwZNQYIBBkYBWNsYXNzFQwW + 0PIGFogNFpQMJuTYof8HJubWof8HHDaQ6QYoDXRyYWluX3N0YXRpb24YBmNodXJjaAAZLBUEFQQV + AgAVABUEFQYAABaI2IuACBVWFtDO5P8HFZoBACb64qH/BxwVChk1BggAGRgGaGVpZ2h0FQwW0PIG + FsYBFvwBJvriof8HPDbQ8gYAGRwVABUAFQYAABbe2IuACBVQFurP5P8HFToAJvbkof8HHBUMGTUG + CAAZKAVuYW1lcwdwcmltYXJ5FQwW0PIGFpITFpgOJvbkof8HPDaQ8gYoDFNhbnRhIEVtaWxpYRgR + OCBRdWVicmFkYXMgSG91c2UAGRwVABUAFQYAABau2YuACBVWFqTQ5P8HFYICACbe86H/BxwVDBkl + BgQZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFtLyBhaEBRaIBSbe86H/ByaO86H/Bxw2 + zPIGKAJlcxgCZW4AGSwVBBUEFQIAFQAVBBUGAAAWhNqLgAgVVBam0uT/BxVCACaW+KH/BxwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW0vIGFtAFFqAFJpb4of8HPDbM8gYo + ClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVBgAAFtjai4AIFVYW6NLk/wcVZgAmhP6h + /wccFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbU8gYWuAUWmgUm + hP6h/wcmtv2h/wccGAhvZmZpY2lhbBgIb2ZmaWNpYWwWzvIGKAhvZmZpY2lhbBgIb2ZmaWNpYWwA + GSwVBBUEFQIAFQAVBBUGAAAWrtuLgAgVVhbO0+T/BxVaACbQgqL/BxwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbU8gYWjAUW3AQm0IKi/wc8NtDyBigCZXMYAmVu + ABkcFQAVABUGAAAWhNyLgAgVVhao1OT/BxVCACbciKL/BxwVDBklBgQZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQFdmFsdWUVDBbU8gYWnAYW/gUm3Iii/wcmrIei/wccNs7yBigaQmFuayBvZiB0 + aGUgU3RhdGUgb2YgQ2hpbGUYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGSwVBBUEFQIAFQAV + BBUGAAAW2tyLgAgVVhbq1OT/BxWgAQAmqo2i/wccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdl + bGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW1PIGFvYEFsYEJqqNov8HPDbU8gYAGRwVABUA + FQYAABaw3YuACBVWForW5P8HFToAJvCRov8HHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudARzaWRlFQwW1PIGFvQEFsQEJvCRov8HPDbU8gYAGRwVABUAFQYAABaG3ouACBVWFsTW5P8H + FToAJrSWov8HHBUAGTUGCAAZGAloYXNfcGFydHMVDBbQ8gYW9m8WsgImtJai/wc8GAEAGAEAFgAo + AQAYAQAAGRwVABUAFQYAABbc3ouACBVQFv7W5P8HFToAJuaYov8HHBUAGTUGCAAZGA5pc191bmRl + cmdyb3VuZBUMFtDyBhb2bxayAibmmKL/BzwYAQAYAQAWACgBABgBAAAZHBUAFQAVBgAAFqzfi4AI + FVAWuNfk/wcVOgAm4Jui/wccFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbQ8gYWpAIW7AIm4Jui/wcm + mJui/wccGAQDAAAAGAQBAAAAFsryBigEAwAAABgEAQAAAAAZLBUEFQQVAgAVABUEFQYAABb834uA + CBVQFvLX5P8HFUoAJoSeov8HHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW0PIG + FsYBFvwBJoSeov8HPDbQ8gYAGRwVABUAFQYAABbM4IuACBVQFrzY5P8HFToAJoCgov8HHBUKGTUG + CAAZGAptaW5faGVpZ2h0FQwW0PIGFsYBFvwBJoCgov8HPDbQ8gYAGRwVABUAFQYAABac4YuACBVQ + FvbY5P8HFToAJvyhov8HHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbQ8gYWxgEW/AEm/KGi/wc8NtDy + BgAZHBUAFQAVBgAAFuzhi4AIFVAWsNnk/wcVOgAm+KOi/wccFQwZNQYIABkYDGZhY2FkZV9jb2xv + chUMFtDyBhbGARb8ASb4o6L/Bzw20PIGABkcFQAVABUGAAAWvOKLgAgVUBbq2eT/BxU6ACb0paL/ + BxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwW0PIGFsYBFvwBJvSlov8HPDbQ8gYAGRwVABUA + FQYAABaM44uACBVQFqTa5P8HFToAJvCnov8HHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW0PIG + FsYBFvwBJvCnov8HPDbQ8gYAGRwVABUAFQYAABbc44uACBVQFt7a5P8HFToAJriqov8HHBUMGTUG + CAQZGApyb29mX3NoYXBlFQwW0PIGFpYCFt4CJriqov8HJuypov8HHBgGZ2FibGVkGAZnYWJsZWQW + wvIGKAZnYWJsZWQYBmdhYmxlZAAZLBUEFQQVAgAVABUEFQYAABas5IuACBVQFpjb5P8HFVIAJsqs + ov8HHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFtDyBhbGARb8ASbKrKL/Bzw20PIGABkcFQAV + ABUGAAAW/OSLgAgVUBbq2+T/BxU6ACbGrqL/BxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUM + FtDyBhbGARb8ASbGrqL/Bzw20PIGABkcFQAVABUGAAAWzOWLgAgVUBak3OT/BxU6ACbCsKL/BxwV + DBk1BggAGRgKcm9vZl9jb2xvchUMFtDyBhbGARb8ASbCsKL/Bzw20PIGABkcFQAVABUGAAAWnOaL + gAgVUBbe3OT/BxU6ACa+sqL/BxwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbQ8gYWxgEW/AEmvrKi + /wc8NtDyBgAZHBUAFQAVBgAAFuzmi4AIFVAWmN3k/wcVOgAW7JbLCRbQ8gYmhoGx+gcWtLPxBBSO + AQAZXBgDZ2VvGLkCeyJ2ZXJzaW9uIjoiMS4xLjAiLCJwcmltYXJ5X2NvbHVtbiI6Imdlb21ldHJ5 + IiwiY29sdW1ucyI6eyJnZW9tZXRyeSI6eyJlbmNvZGluZyI6IldLQiIsImdlb21ldHJ5X3R5cGVz + IjpbIlBvbHlnb24iLCJNdWx0aVBvbHlnb24iXSwiYmJveCI6Wy0xNzkuOTk5OTk2NiwtODMuNjUw + MDEzOSwtMi44MjI5ODI0LC0wLjAwMzEzNzcxMTEwMDU1MzE5XSwiY292ZXJpbmciOnsiYmJveCI6 + eyJ4bWluIjpbImJib3giLCJ4bWluIl0sInltaW4iOlsiYmJveCIsInltaW4iXSwieG1heCI6WyJi + Ym94IiwieG1heCJdLCJ5bWF4IjpbImJib3giLCJ5bWF4Il19fX19fQAYHG9yZy5hcGFjaGUuc3Bh + cmsubGVnYWN5SU5UOTYYAAAYGG9yZy5hcGFjaGUuc3BhcmsudmVyc2lvbhgFMy40LjEAGClvcmcu + YXBhY2hlLnNwYXJrLnNxbC5wYXJxdWV0LnJvdy5tZXRhZGF0YRjuF3sidHlwZSI6InN0cnVjdCIs + ImZpZWxkcyI6W3sibmFtZSI6ImlkIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJt + ZXRhZGF0YSI6e319LHsibmFtZSI6Imdlb21ldHJ5IiwidHlwZSI6ImJpbmFyeSIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6ImJib3giLCJ0eXBlIjp7InR5cGUiOiJzdHJ1 + Y3QiLCJmaWVsZHMiOlt7Im5hbWUiOiJ4bWluIiwidHlwZSI6ImZsb2F0IiwibnVsbGFibGUiOnRy + dWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoieG1heCIsInR5cGUiOiJmbG9hdCIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InltaW4iLCJ0eXBlIjoiZmxvYXQiLCJudWxs + YWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJ5bWF4IiwidHlwZSI6ImZsb2F0Iiwi + bnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX1dfSwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRh + Ijp7fX0seyJuYW1lIjoidmVyc2lvbiIsInR5cGUiOiJpbnRlZ2VyIiwibnVsbGFibGUiOnRydWUs + Im1ldGFkYXRhIjp7fX0seyJuYW1lIjoic291cmNlcyIsInR5cGUiOnsidHlwZSI6ImFycmF5Iiwi + ZWxlbWVudFR5cGUiOnsidHlwZSI6InN0cnVjdCIsImZpZWxkcyI6W3sibmFtZSI6InByb3BlcnR5 + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + ImRhdGFzZXQiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0s + eyJuYW1lIjoicmVjb3JkX2lkIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRh + ZGF0YSI6e319LHsibmFtZSI6InVwZGF0ZV90aW1lIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6ImNvbmZpZGVuY2UiLCJ0eXBlIjoiZG91Ymxl + IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX1dfSwiY29udGFpbnNOdWxsIjp0cnVlfSwi + bnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoibGV2ZWwiLCJ0eXBlIjoiaW50 + ZWdlciIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InN1YnR5cGUiLCJ0 + eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiY2xh + c3MiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1l + IjoiaGVpZ2h0IiwidHlwZSI6ImRvdWJsZSIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319 + LHsibmFtZSI6Im5hbWVzIiwidHlwZSI6eyJ0eXBlIjoic3RydWN0IiwiZmllbGRzIjpbeyJuYW1l + IjoicHJpbWFyeSIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9 + fSx7Im5hbWUiOiJjb21tb24iLCJ0eXBlIjp7InR5cGUiOiJtYXAiLCJrZXlUeXBlIjoic3RyaW5n + IiwidmFsdWVUeXBlIjoic3RyaW5nIiwidmFsdWVDb250YWluc051bGwiOnRydWV9LCJudWxsYWJs + ZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJydWxlcyIsInR5cGUiOnsidHlwZSI6ImFy + cmF5IiwiZWxlbWVudFR5cGUiOnsidHlwZSI6InN0cnVjdCIsImZpZWxkcyI6W3sibmFtZSI6InZh + cmlhbnQiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJu + YW1lIjoibGFuZ3VhZ2UiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRh + Ijp7fX0seyJuYW1lIjoidmFsdWUiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1l + dGFkYXRhIjp7fX0seyJuYW1lIjoiYmV0d2VlbiIsInR5cGUiOnsidHlwZSI6ImFycmF5IiwiZWxl + bWVudFR5cGUiOiJkb3VibGUiLCJjb250YWluc051bGwiOnRydWV9LCJudWxsYWJsZSI6dHJ1ZSwi + bWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJzaWRlIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319XX0sImNvbnRhaW5zTnVsbCI6dHJ1ZX0sIm51bGxhYmxlIjp0cnVl + LCJtZXRhZGF0YSI6e319XX0sIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + Imhhc19wYXJ0cyIsInR5cGUiOiJib29sZWFuIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7 + fX0seyJuYW1lIjoiaXNfdW5kZXJncm91bmQiLCJ0eXBlIjoiYm9vbGVhbiIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Im51bV9mbG9vcnMiLCJ0eXBlIjoiaW50ZWdlciIs + Im51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Im51bV9mbG9vcnNfdW5kZXJn + cm91bmQiLCJ0eXBlIjoiaW50ZWdlciIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsi + bmFtZSI6Im1pbl9oZWlnaHQiLCJ0eXBlIjoiZG91YmxlIiwibnVsbGFibGUiOnRydWUsIm1ldGFk + YXRhIjp7fX0seyJuYW1lIjoibWluX2Zsb29yIiwidHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6 + dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJmYWNhZGVfY29sb3IiLCJ0eXBlIjoic3RyaW5n + IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiZmFjYWRlX21hdGVyaWFs + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + InJvb2ZfbWF0ZXJpYWwiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRh + Ijp7fX0seyJuYW1lIjoicm9vZl9zaGFwZSIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1 + ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJyb29mX2RpcmVjdGlvbiIsInR5cGUiOiJkb3VibGUi + LCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJyb29mX29yaWVudGF0aW9u + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + InJvb2ZfY29sb3IiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7 + fX0seyJuYW1lIjoicm9vZl9oZWlnaHQiLCJ0eXBlIjoiZG91YmxlIiwibnVsbGFibGUiOnRydWUs + Im1ldGFkYXRhIjp7fX1dfQAYH29yZy5hcGFjaGUuc3BhcmsubGVnYWN5RGF0ZVRpbWUYAAAYWnBh + cnF1ZXQtbXIgdmVyc2lvbiAxLjEyLjMtZGF0YWJyaWNrcy0wMDAyIChidWlsZCAyNDg0YTk1ZGJl + MTZhMDAyM2UzZWIyOWMyMDFmOTlmZjllYTc3MWVlKRn8JhwAABwAABwAABwAABwAABwAABwAABwA + ABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwA + ABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAAAAVjgUAUEFSMQ== + headers: + Accept-Ranges: + - bytes + Content-Length: + - '65536' + Content-Range: + - bytes 1074137083-1074202618/1074202619 + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:51 GMT + Etag: + - '"0x8DD1F961B620B78"' + Last-Modified: + - Wed, 18 Dec 2024 18:59:32 GMT + Server: + - Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0 + x-ms-acl: + - user::rw-,group::r--,other::--- + x-ms-blob-type: + - BlockBlob + x-ms-client-request-id: + - 60fb4dd2-c153-11ef-9896-c9ef2e2fb316 + x-ms-copy-completion-time: + - Wed, 18 Dec 2024 18:59:31 GMT + x-ms-copy-id: + - 9095c449-d3ff-4970-bdb1-5880129928f7 + x-ms-copy-progress: + - 1074202619/1074202619 + x-ms-copy-source: + - https://overturemapswestus2.blob.core.windows.net:443/release/_$azuretmpfolder$/06834b8a-d222-4de1-981a-d1968e73a843part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet?ss=bfqt&api-version=2019-02-02&st=2024-03-07T02%3a47%3a36Z&se=2025-03-01T10%3a47%3a36Z&sv=2022-11-02&srt=sco&spr=https&sp=rwdlacupyx + x-ms-copy-status: + - success + x-ms-creation-time: + - Wed, 18 Dec 2024 18:55:51 GMT + x-ms-group: + - $superuser + x-ms-lease-state: + - available + x-ms-lease-status: + - unlocked + x-ms-meta-hdi_permission: + - '{"owner":"root","group":"supergroup","permissions":"rw-r--r--"}' + x-ms-owner: + - $superuser + x-ms-permissions: + - rw-r----- + x-ms-request-id: + - 475b0f66-e01e-005a-4a60-558037000000 + x-ms-resource-type: + - file + x-ms-server-encrypted: + - 'true' + x-ms-version: + - '2025-01-05' + status: + code: 206 + message: Partial Content +- request: + body: null + headers: + Accept: + - application/xml + User-Agent: + - azsdk-python-storage-blob/12.24.0 Python/3.13.0 (Linux-6.8.0-51-generic-x86_64-with-glibc2.39) + x-ms-client-request-id: + - 611881cc-c153-11ef-9896-c9ef2e2fb316 + x-ms-date: + - Mon, 23 Dec 2024 17:28:52 GMT + x-ms-range: + - bytes=1073838558-1074202618 + x-ms-version: + - '2025-01-05' + method: GET + uri: https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet + response: + body: + string: !!binary | + FQIZ/DNIDHNwYXJrX3NjaGVtYRUwABUMJQIYAmlkJQBMHAAAABUMJQIYCGdlb21ldHJ5ADUCGARi + Ym94FQgAFQglAhgEeG1pbgAVCCUCGAR4bWF4ABUIJQIYBHltaW4AFQglAhgEeW1heAAVAiUCGAd2 + ZXJzaW9uADUCGAdzb3VyY2VzFQIVBkw8AAAANQQYBGxpc3QVAgA1AhgHZWxlbWVudBUKABUMJQIY + CHByb3BlcnR5JQBMHAAAABUMJQIYB2RhdGFzZXQlAEwcAAAAFQwlAhgJcmVjb3JkX2lkJQBMHAAA + ABUMJQIYC3VwZGF0ZV90aW1lJQBMHAAAABUKJQIYCmNvbmZpZGVuY2UAFQIlAhgFbGV2ZWwAFQwl + AhgHc3VidHlwZSUATBwAAAAVDCUCGAVjbGFzcyUATBwAAAAVCiUCGAZoZWlnaHQANQIYBW5hbWVz + FQYAFQwlAhgHcHJpbWFyeSUATBwAAAA1AhgGY29tbW9uFQIVAkwsAAAANQQYCWtleV92YWx1ZRUE + ABUMJQAYA2tleSUATBwAAAAVDCUCGAV2YWx1ZSUATBwAAAA1AhgFcnVsZXMVAhUGTDwAAAA1BBgE + bGlzdBUCADUCGAdlbGVtZW50FQoAFQwlAhgHdmFyaWFudCUATBwAAAAVDCUCGAhsYW5ndWFnZSUA + TBwAAAAVDCUCGAV2YWx1ZSUATBwAAAA1AhgHYmV0d2VlbhUCFQZMPAAAADUEGARsaXN0FQIAFQol + AhgHZWxlbWVudAAVDCUCGARzaWRlJQBMHAAAABUAJQIYCWhhc19wYXJ0cwAVACUCGA5pc191bmRl + cmdyb3VuZAAVAiUCGApudW1fZmxvb3JzABUCJQIYFm51bV9mbG9vcnNfdW5kZXJncm91bmQAFQol + AhgKbWluX2hlaWdodAAVAiUCGAltaW5fZmxvb3IAFQwlAhgMZmFjYWRlX2NvbG9yJQBMHAAAABUM + JQIYD2ZhY2FkZV9tYXRlcmlhbCUATBwAAAAVDCUCGA1yb29mX21hdGVyaWFsJQBMHAAAABUMJQIY + CnJvb2Zfc2hhcGUlAEwcAAAAFQolAhgOcm9vZl9kaXJlY3Rpb24AFQwlAhgQcm9vZl9vcmllbnRh + dGlvbiUATBwAAAAVDCUCGApyb29mX2NvbG9yJQBMHAAAABUKJQIYC3Jvb2ZfaGVpZ2h0ABa0tP8K + GfxIGfwmJggcFQwZNQYIABkYAmlkFQwWtP8SFp7vqwUWyNHKASYIPDYAKCAwOGJmMzVhZDZhM2I0 + ZmZmMDIwMGFiOGNmYjA4ODFlZBggMDhiOWEwMjAwNDEzMGZmZjAyMDBhNWRkY2UwMGY4ZmEAGRwV + ABUAFRAAABbS3eT/BxXUARa6tKL/BxXWCAAm0NHKARwVDBk1BggAGRgIZ2VvbWV0cnkVDBa0/xIW + tv+SERas5KgKJtDRygE8NgAovQQAAAAABgAAAAQAAAAAAwAAAAEAAAAFwGXmjh+zI67ANSJRZvrg + 3MBl5o2Gm5AUwDUiVUF69JPAZeaNOCyXOMA1IlKfCUUjwGXmjdFEKtLANSJOxIkxbcBl5o4fsyOu + wDUiUWb64NwAAAAAAwAAAAEAAAAGwGXmjnJT2nPANSJggHNX5sBl5o18wET/wDUiWHKH3NnAZeaO + IqLCN8A1IlQl8gIQwGXmjxg2V6vANSJcM919HsBl5o6TQLoEwDUiX6FQR0DAZeaOclPac8A1ImCA + c1fmAAAAAAMAAAABAAAABsBl5o3KIs5hwDUiZbmYPKLAZeaOZEbRdsA1ImGmDUVjwGXmjoUzsQfA + NSJgxuo0vcBl5o+m0ZCBwDUiahOaELjAZeaO6/ZdwMA1Im8GSBiewGXmjcoizmHANSJluZg8ogAA + AAADAAAAAQAAAA/AZeaMYnlx3MA1Im5tm+TNwGXmjWkJrtXANSJnrzvCTsBl5o24uscRwDUialNa + 8OfAZeaNjfKcasA1ImttNmRAwGXmjmyqTUbANSJy0AE0s8Bl5o6dvRTJwDUicY3h1XPAZeaO7Jdt + b8A1InQrSwdlwGXmjr+As/DANSJ1UpJ0C8Bl5o71ZkkKwDUidxrpkFLAZeaOFdfYmsA1InzW6zPA + wGXmjHxE9P3ANSJvRgj4zcBl5ovFm4AkwDUic9kVsGvAZeaLVqsHgMA1InAUZRHTwGXmjA0ezHTA + NSJrgVhaNMBl5oxieXHcwDUibm2b5M0YTQAAAAADAAAAAQAAAATAZXZoruBSvMAsDXHsrGYlwGV2 + aQqFlQDALA1xc+CibcBldmfFCzdswCwNgSeyzHHAZXZoruBSvMAsDXHsrGYlABkcFQAVABUmAAAW + pt/k/wcVmAQWkL2i/wcVticAJvy18wscFQgZNQYIABkoBGJib3gEeG1pbhUMFrT/EhacgkwWmvgp + Jvy18ws8GATiAAfDGAQAADTDFgAoBOIAB8MYBAAANMMAGRwVABUAFRAAABa+4+T/BxXiARbG5KL/ + BxXWAQAmlq6dDBwVCBk1BggAGSgEYmJveAR4bWF4FQwWtP8SFqCCTBbq+ikmlq6dDDwYBNoAB8MY + BPn/M8MWACgE2gAHwxgE+f8zwwAZHBUAFQAVEAAAFqDl5P8HFeIBFpzmov8HFdYBACaAqccMHBUI + GTUGCAAZKARiYm94BHltaW4VDBa0/xIWoIJMFqLmNiaAqccMPBgEiPtSwRgEz0ynwhYAKASI+1LB + GATPTKfCABkcFQAVABUQAAAWgufk/wcV4gEW8uei/wcV1gEAJqKP/gwcFQgZNQYIABkoBGJib3gE + eW1heBUMFrT/EhacgkwWoKw3JqKP/gw8GAQ3+1LBGATJTKfCFgAoBDf7UsEYBMlMp8IAGRwVABUA + FRAAABbk6OT/BxXiARbI6aL/BxXWAQAmgry1DRwVAhk1BggEGRgHdmVyc2lvbhUMFrT/Ehb+BBag + BiaCvLUNJsK7tQ0cGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW + xurk/wcVwgEWnuui/wcV1gEAJqLCtQ0cFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJv + cGVydHkVDBa0/xIW/gUWoAcmosK1DSbiwbUNHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW + iOzk/wcVwgEW9Oyi/wcVVgAm3Mm1DRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRh + c2V0FQwWtP8SFpgGFroHJtzJtQ0mgsm1DRwYDU9wZW5TdHJlZXRNYXAYDU9wZW5TdHJlZXRNYXAW + ACgNT3BlblN0cmVldE1hcBgNT3BlblN0cmVldE1hcAAZLBUEFQQVAgAVABUEFRAAABbK7eT/BxXC + ARbK7aL/BxX2AwAmvNC1DRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQV + DBa0/xIW4PuzAhb8yD8mvNC1DTw2ACgMdzk5ODk1OTAzNkAxGAtyMTAxMzAxOTFAMQAZHBUAFQAV + EAAAFozv5P8HFeIBFsDxov8HFcADACb8/oAOHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + C3VwZGF0ZV90aW1lFQwWtP8SFrr/YhaepiYm/P6ADia4mfUNHDYAKBgyMDI0LTExLTIzVDIyOjMw + OjA5LjAwMFoYGDIwMTAtMTEtMjJUMDY6MzE6MzguMDAwWgAZLBUEFQQVAgAVABUEFRAAABbu8OT/ + BxXiARaA9aL/BxXWBgAm1r+bDhwVChklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRl + bmNlFQwWtP8SFpAFFqAGJta/mw48NrT/EgAZHBUAFQAVEAAAFtDy5P8HFcIBFtb7ov8HFXYAJsbG + mw4cFQIZNQYIBBkYBWxldmVsFQwWtP8SFsIOFtwOJsbGmw4m9sWbDhwYBAIAAAAYBP////8WwPwS + KAQCAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFpL05P8HFdIBFsz8ov8HFfYBACaG15sOHBUM + GTUGCAQZGAdzdWJ0eXBlFQwWtP8SFpLJARaglQEmhtebDibS1JsOHDaKwBAoDnRyYW5zcG9ydGF0 + aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW5PXk/wcV0gEWwv6i/wcVvAMAJoLw + nA4cFQwZNQYIBBkYBWNsYXNzFQwWtP8SFva7ARbekAEmgvCcDiby6ZwOHDb6yhAoCXdhcmVob3Vz + ZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABa29+T/BxXSARb+gaP/BxWIAwAm0PqdDhwV + Chk1BggAGRgGaGVpZ2h0FQwWtP8SFqoFFroGJtD6nQ48GAgAAAAAAAAqQBgIAAAAAAAAFEAWqP8S + KAgAAAAAAAAqQBgIAAAAAAAAFEAAGRwVABUAFRAAABaI+eT/BxXGARaGhaP/BxX2AQAmwJqfDhwV + DBk1BggEGSgFbmFtZXMHcHJpbWFyeRUMFrT/Eha6iQMW7tgBJsCanw4mioGeDhw2zu0SKAbnqYDl + gIkYECJBcGkta28tSG90YXB1Ii4AGSwVBBUEFQIAFQAVBBUQAAAWzvrk/wcV0gEW/Iaj/wcVmAQA + JpLbnw4cFQwZJQYEGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbK/xIWzjcWhCgmktuf + Dib42Z8OHDaE/xIoAnNtGAJkZQAZLBUEFQQVAgAVABUEFRAAABag/OT/BxXSARaUi6P/BxWwAQAm + rougDhwVDBklBgQZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWyv8SFppQFpIyJq6L + oA4m/IGgDhw2hP8SKAVXYWloaRgfQWx0YSBDb21pc2nDs24gZGUgTnVldmEgWmVsYW5kYQAZLBUE + FQQVAgAVABUEFRAAABby/eT/BxXSARbEjKP/BxXkBQAmjrSgDhwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFrT/EhauQxaKKSaOtKAOPDaU/xIoCG9mZmljaWFsGAlh + bHRlcm5hdGUAGRwVABUAFRAAABbE/+T/BxXSARaokqP/BxXEAgAmmN2gDhwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBa0/xIWrEAWyCcmmN2gDjwYAmRlGAJkZRaw + /xIoAmRlGAJkZQAZHBUAFQAVEAAAFpaB5f8HFdIBFuyUo/8HFYYBACbghKEOHBUMGSUGABlYBW5h + bWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFrT/Eha+SBaOLybghKEOPDaU/xIoGFNvbWFv + YW4gSmFpbCBOYXZ5IE5vLiA3MhgPQXZpcyBDYXIgUmVudGFsABkcFQAVABUQAAAW6ILl/wcV0gEW + 8pWj/wcV/AUAJu6zoQ4cFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4E + bGlzdAdlbGVtZW50FQwWtP8SFpRAFrYnJu6zoQ48NrT/EgAZHBUAFQAVEAAAFrqE5f8HFdIBFu6b + o/8HFXYAJqTboQ4cFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBa0/xIW + lEAWticmpNuhDjw2tP8SABkcFQAVABUQAAAWjIbl/wcV0gEW5Jyj/wcVdgAm2oKiDhwVABk1BggA + GRgJaGFzX3BhcnRzFQwWtP8SFpi0Aha6BibagqIOPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAW + 3ofl/wcVwgEW2p2j/wcVdgAmlImiDhwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBa0/xIWmLQC + FrAGJpSJog48GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABagieX/BxXCARbQnqP/BxV2ACackKIO + HBUCGTUGCAQZGApudW1fZmxvb3JzFQwWtP8SFsITFs4TJpyQog4mxI+iDhwYBAYAAAAYBAEAAAAW + 1PMSKAQGAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFuKK5f8HFc4BFsafo/8HFfYBACaSo6IO + HBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWtP8SFqIEFrIFJpKjog48GAQBAAAA + GAQBAAAAFrL/EigEAQAAABgEAQAAAAAZHBUAFQAVEAAAFrCM5f8HFcIBFryho/8HFYYBACbEqKIO + HBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWtP8SFpAEFqAFJsSoog48NrT/EgAZHBUAFQAVEAAAFvKN + 5f8HFcIBFsKio/8HFXYAJuStog4cFQIZNQYIABkYCW1pbl9mbG9vchUMFrT/EhaQBBagBSbkraIO + PDa0/xIAGRwVABUAFRAAABa0j+X/BxXCARa4o6P/BxV2ACaEs6IOHBUMGTUGCAAZGAxmYWNhZGVf + Y29sb3IVDBa0/xIWsAQWwAUmhLOiDjwYByMwMDAwRkYYByMwMDAwRkYWsv8SKAcjMDAwMEZGGAcj + MDAwMEZGABkcFQAVABUQAAAW9pDl/wcVwgEWrqSj/wcVkgEAJsS4og4cFQwZNQYIABkYD2ZhY2Fk + ZV9tYXRlcmlhbBUMFrT/EhaQBBagBSbEuKIOPDa0/xIAGRwVABUAFRAAABa4kuX/BxXCARbApaP/ + BxV2ACbkvaIOHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWtP8SFpAEFqAFJuS9og48NrT/EgAZ + HBUAFQAVEAAAFvqT5f8HFcIBFramo/8HFXYAJurEog4cFQwZNQYIBBkYCnJvb2Zfc2hhcGUVDBa0 + /xIWoBAWhhAm6sSiDiaEw6IOHDbk9RIoCHNraWxsaW9uGARmbGF0ABksFQQVBBUCABUAFQQVEAAA + FryV5f8HFcoBFqyno/8HFfABACaK06IOHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFrT/EhaQ + BBagBSaK06IOPDa0/xIAGRwVABUAFRAAABaGl+X/BxXCARacqaP/BxV2ACaq2KIOHBUMGTUGCAAZ + GBByb29mX29yaWVudGF0aW9uFQwWtP8SFpAEFqAFJqrYog48NrT/EgAZHBUAFQAVEAAAFsiY5f8H + FcIBFpKqo/8HFXYAJsrdog4cFQwZNQYIABkYCnJvb2ZfY29sb3IVDBa0/xIWkAQWoAUmyt2iDjw2 + tP8SABkcFQAVABUQAAAWiprl/wcVwgEWiKuj/wcVdgAm6uKiDhwVChk1BggAGRgLcm9vZl9oZWln + aHQVDBa0/xIWkAQWoAUm6uKiDjw2tP8SABkcFQAVABUQAAAWzJvl/wcVwgEW/quj/wcVdgAWxLWV + HBa0/xImCBaC6KIOFAAAGfwmJoroog4cFQwZNQYIABkYAmlkFQwWuNoQFuK72QQWmNCwASaK6KIO + PDYAKCAwOGJiNGVlNDkzN2I1ZmZmMDIwMGE1YjUwMTNiYWIwMRggMDhiNmM1YTIyMTZlNWZmZjAy + MDA2MjhiZWE5Mzc5ZjUAGRwVABUAFQ4AABaOneX/BxXGARb0rKP/BxXOBwAmorjTDxwVDBk1BggA + GRgIZ2VvbWV0cnkVDBa42hAWkJDAERa8nuwKJqK40w88ABkcFQAVABUoAAAW1J7l/wcVtAQWwrSj + /wcVvikAJt7WvxocFQgZNQYIABkoBGJib3gEeG1pbhUMFrjaEBbm7UIWvNkjJt7Wvxo8GAQg67XC + GAQFhSzDFgAoBCDrtcIYBAWFLMMAGRwVABUAFQ4AABaIo+X/BxXGARaA3qP/BxW+AQAmmrDjGhwV + CBk1BggAGSgEYmJveAR4bWF4FQwWuNoQFubtQha62SMmmrDjGjwYBA/rtcIYBP+ELMMWACgED+u1 + whgE/4QswwAZHBUAFQAVDgAAFs6k5f8HFcYBFr7fo/8HFb4BACbUiYcbHBUIGTUGCAAZKARiYm94 + BHltaW4VDBa42hAW5O1CFqLvLibUiYcbPBgEqelRuxgEyYfZwRYAKASp6VG7GATJh9nBABkcFQAV + ABUOAAAWlKbl/wcVxgEW/OCj/wcVvgEAJvb4tRscFQgZNQYIABkoBGJib3gEeW1heBUMFrjaEBbk + 7UIWoskuJvb4tRs8GAQNok27GARnh9nBFgAoBA2iTbsYBGeH2cEAGRwVABUAFQ4AABbap+X/BxXG + ARa64qP/BxW+AQAm2MLkGxwVAhk1BggEGRgHdmVyc2lvbhUMFrjaEBa0BBbEBSbYwuQbJpjC5Bsc + GAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUOAAAWoKnl/wcVqgEW+OOj + /wcVvgEAJpzI5BscFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBa42hAW + pAUWtAYmnMjkGybcx+QbHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUOAAAWyqrl/wcVqgEWtuWj + /wcVTgAmnM/kGxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWuNoQFqQb + FuYbJpzP5BsmkM7kGxw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABks + FQQVBBUCABUAFQQVDgAAFvSr5f8HFawBFoTmo/8HFcoDACb26eQbHBUMGSUGABlIB3NvdXJjZXME + bGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFrjaEBay4I8CFsT+PCb26eQbPDYAKAx3OTk5Njg2MTM1 + QDEYEDcwNjEzMTAwMzUwNzAyMjIAGRwVABUAFQ4AABagreX/BxXGARbO6aP/BxWaAwAm4M2mHBwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFrjaEBba9CoWzOQPJuDN + phwmuuihHBw2ACgYMjAyNC0xMS0zMFQxODoyNDoyMC4wMDBaGBgyMDEwLTEyLTE0VDE4OjQyOjMw + LjAwMFoAGSwVBBUEFQIAFQAVBBUOAAAW5q7l/wcVwAEW6Oyj/wcV7gUAJobNsRwcFQoZJQYAGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFrjaEBaEoQYWssACJobNsRw8GAiTqYJR + SZ3uPxgIzczMzMzM5D8WyP0PKAiTqYJRSZ3uPxgIzczMzMzM5D8AGRwVABUAFQ4AABamsOX/BxWu + ARbW8qP/BxWKAQAmiI60HBwVAhk1BggEGRgFbGV2ZWwVDBa42hAWsAsW0gsmiI60HCa4jbQcHBgE + AgAAABgE/////xaM2BAoBAIAAAAYBP////8AGSwVBBUEFQIAFQAVBBUOAAAW1LHl/wcVtAEW4POj + /wcV2gEAJsKbtBwcFQwZNQYIBBkYB3N1YnR5cGUVDBa42hAW2NUBFrSjASbCm7QcJoqZtBwcNoL+ + DigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFQ4AABaIs+X/BxW4 + ARa69aP/BxW6AwAmqMO1HBwVDBk1BggEGRgFY2xhc3MVDBa42hAW1uQBFrCzASaow7UcJr68tRwc + NoaMDygJd2FyZWhvdXNlGA9hbGxvdG1lbnRfaG91c2UAGSwVBBUEFQIAFQAVBBUOAAAWwLTl/wcV + uAEW9Pij/wcV+gIAJu7vthwcFQoZNQYIABkYBmhlaWdodBUMFrjaEBb6BhagBybu77YcPBgIAAAA + AAAAOUAYCDMzMzMzMwVAFpbaECgIAAAAAAAAOUAYCDMzMzMzMwVAABkcFQAVABUOAAAW+LXl/wcV + sgEW7vuj/wcVygIAJpSVuhwcFQwZNQYIBBkoBW5hbWVzB3ByaW1hcnkVDBa42hAWpKEJFtjIBCaU + lbocJo73thwcNpqhECgRw6ljb2xlIGRlIG1hcm9rYXUYEydHb3Zlcm5tZW50JyBvZmZpY2UAGSwV + BBUEFQIAFQAVBBUOAAAWqrfl/wcVuAEWuP6j/wcVpgUAJua/uxwcFQwZJQYAGUgFbmFtZXMGY29t + bW9uCWtleV92YWx1ZQNrZXkVDBbO2hAWhpgBFrZXJua/uxw8NtDZECgCdHkYAmRlABkcFQAVABUO + AAAW4rjl/wcVuAEW3oOk/wcVogEAJpyXvBwcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1 + ZQV2YWx1ZRUMFs7aEBasywEWxG4mnJe8HDw20NkQKDzQnNC10LbQtNGD0L3QsNGA0L7QtNC90YvQ + uSDQsNGN0YDQvtC/0L7RgNGCINCc0LDRgtCw0LLQtdGA0LgYEEFkdmVudGlzdCBDaHVyY2gAGRwV + ABUAFQ4AABaauuX/BxW4ARaAhaT/BxXuBQAm3Ia9HBwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHdmFyaWFudBUMFrraEBa6tAEW4Fwm3Ia9HCbghb0cHDa82RAoBXNob3J0GAlhbHRl + cm5hdGUAGSwVBBUEFQIAFQAVBBUOAAAW0rvl/wcVuAEW7oqk/wcVrgIAJsDivRwcFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWutoQFpKzARaWWybA4r0cPBgCZnIY + AmZyFrjaECgCZnIYAmZyABkcFQAVABUOAAAWir3l/wcVuAEWnI2k/wcVcgAm1r2+HBwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBa62hAWzMcBFpBsJta9vhw8NrzZECgX + w4lnbGlzZSBNYXJpYSBubyB0ZSBIYXUYCkFpciBNb29yZWEAGRwVABUAFQ4AABbCvuX/BxW4ARaO + jqT/BxWaBQAm5qm/HBwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRs + aXN0B2VsZW1lbnQVDBa62hAWiLMBFpBbJuapvxw8NrraEAAZHBUAFQAVDgAAFvq/5f8HFbgBFqiT + pP8HFWoAJvaEwBwcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBa62hAW + hrMBFo5bJvaEwBw8NrraEAAZHBUAFQAVDgAAFrLB5f8HFbgBFpKUpP8HFWoAJoTgwBwcFQAZNQYI + ABkYCWhhc19wYXJ0cxUMFrjaEBaEjwIWuAYmhODAHDwYAQEYAQAWACgBARgBAAAZHBUAFQAVDgAA + FurC5f8HFa4BFvyUpP8HFWoAJrzmwBwcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWuNoQFoSP + AhbKBSa85sAcPBgBABgBABYAKAEAGAEAABkcFQAVABUOAAAWmMTl/wcVqgEW5pWk/wcVagAm/uzA + HBwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFrjaEBawLRa8Jyb+7MAcJobswBwcGAQKAAAAGAQBAAAA + FtSkECgECgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFQ4AABbCxeX/BxW4ARbQlqT/BxXaAQAmwpPB + HBwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFrjaEBbiAxbgBCbCk8EcPBgEAQAA + ABgEAQAAABa22hAoBAEAAAAYBAEAAAAAGRwVABUAFQ4AABb6xuX/BxWqARaqmKT/BxV6ACaimMEc + HBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWuNoQFs4DFswEJqKYwRw8NrjaEAAZHBUAFQAVDgAAFqTI + 5f8HFaoBFqSZpP8HFWoAJu6cwRwcFQIZNQYIABkYCW1pbl9mbG9vchUMFrjaEBbgAxbeBCbunMEc + PBgEAQAAABgEAQAAABa22hAoBAEAAAAYBAEAAAAAGRwVABUAFQ4AABbOyeX/BxWqARaOmqT/BxV6 + ACbMocEcHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBa42hAW7gMW7AQmzKHBHDwYByNGRkZGRkYY + ByNGRkZGRkYWttoQKAcjRkZGRkZGGAcjRkZGRkZGABkcFQAVABUOAAAW+Mrl/wcVqgEWiJuk/wcV + hgEAJuKnwRwcFQwZNQYIBBkYD2ZhY2FkZV9tYXRlcmlhbBUMFrjaEBaywwEWwKIBJuKnwRwmuKbB + HBw2ipIIKAR3b29kGAxjZW1lbnRfYmxvY2sAGSwVBBUEFQIAFQAVBBUOAAAWoszl/wcVtgEWjpyk + /wcVpgIAJvjIwhwcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBa42hAW6gMW6AQm+MjCHDwYBWds + YXNzGAVnbGFzcxa22hAoBWdsYXNzGAVnbGFzcwAZHBUAFQAVDgAAFtjN5f8HFaoBFrSepP8HFX4A + JpLPwhwcFQwZNQYIBBkYCnJvb2Zfc2hhcGUVDBa42hAWgggWiAkmks/CHCbgzcIcHDbE2BAoCHNr + aWxsaW9uGARmbGF0ABksFQQVBBUCABUAFQQVDgAAFoLP5f8HFbABFrKfpP8HFYACACbo1sIcHBUK + GTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFrjaEBbOAxbMBCbo1sIcPDa42hAAGRwVABUAFQ4AABay + 0OX/BxWqARayoaT/BxVqACa028IcHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWuNoQFuwD + FuoEJrTbwhw8GAZhY3Jvc3MYBmFjcm9zcxa22hAoBmFjcm9zcxgGYWNyb3NzABkcFQAVABUOAAAW + 3NHl/wcVqgEWnKKk/wcVggEAJp7gwhwcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBa42hAW7gMW7AQm + nuDCHDwYByMwMDAwRkYYByMwMDAwRkYWttoQKAcjMDAwMEZGGAcjMDAwMEZGABkcFQAVABUOAAAW + htPl/wcVqgEWnqOk/wcVhgEAJorlwhwcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWuNoQFs4DFswE + Jorlwhw8NrjaEAAZHBUAFQAVDgAAFrDU5f8HFaoBFqSkpP8HFWoAFrC9gxsWuNoQJoroog4WzIGg + DhQCABn8JibW6cIcHBUMGTUGCAAZGAJpZBUMFoCcExbO9LMFFqyj0gEm1unCHDw2ACggMDhiZWY0 + OTEwZTE0MWZmZjAyMDBmYjAzMjA2ZjcwMmUYIDA4YjZjNTgyZDMyYWRmZmYwMjAwZTQwNzEwYzJk + MTg1ABkcFQAVABUQAAAW2tXl/wcV4gEWjqWk/wcV1ggAJoKNlR4cFQwZNQYIABkYCGdlb21ldHJ5 + FQwWgJwTFr6u2w8W7pG3CSaCjZUePDYAKLoFAAAAAAYAAAAFAAAAAAMAAAABAAAAE8BREKU7+atS + wEtlm7/khv7AURCkT2qhX8BLZZ3OsoAawFEQqD7jap7AS2WgKP/TisBREKfwdHHCwEtloNd7fHjA + URCqNp/PPsBLZaIznA6/wFEQqaKQuSDAS2WjfHFqpsBREKcig7iHwEtlof3sKYnAURCl7dBSk8BL + ZaSs8xKywFEQpAxOwtzAS2WjjThiR8BREKSvC/GmwEtloiLVFx7AURCiuJGsZcBLZaD2hSz7wFEQ + oldC3PTAS2WhzvJA+8BREKFtOBG/wEtloULbRuPAURChxo7FKsBLZaB8C+oZwFEQoGEz937AS2Wf + pvnUbcBREKHT+r54wEtlnG2JcFfAURCiSkJDccBLZZy0AE0twFEQo0ALiMrAS2WakRBeHMBREKU7 + +atSwEtlm7/khv4AAAAAAwAAAAEAAAAFwFEQrsNh6gDAS2WfpiMU2MBREKtydJGiwEtlpwZppo3A + URCpYzs4u8BLZaXL1wOHwFEQrLQokRnAS2WearmyPsBREK7DYeoAwEtln6YjFNgAAAAAAwAAAAEA + AAAFwFEQpOS71tvAS2WmfAArn8BREKPc6XqCwEtlqNwsvCHAURCeZof0VsBLZaW2B45qwFEQn25a + UK7AS2WjVdr96MBREKTku9bbwEtlpnwAK58AAAAAAwAAAAEAAAAFwFEQqBd2PkvAS2Wk6Vj0jsBR + EKaRz6C9wEtlqLxMTAnAURClEFrBF8BLZafvnbItwFEQppWV/trAS2WkHYEaR8BREKgXdj5LwEtl + pOlY9I4AAAAAAwAAAAEAAAAFwFEQrM/XQ0jAS2WbpQyUY8BREKuauH2KwEtlniUZlPzAURCoLAOU + CcBLZZvwi+62wFEQqWEiWcfAS2WZcVWtscBREKzP10NIwEtlm6UMlGMYTQAAAAADAAAAAQAAAATA + UOsJiRW918BK6FN8ftagwFDrCSl0bZDASuhR8xHa9MBQ6wrhb/IAwEroUV3ApXfAUOsJiRW918BK + 6FN8ftagABkcFQAVABUkAAAWvNfl/wcV/AMW5K2k/wcVriUAJvCezCccFQgZNQYIABkoBGJib3gE + eG1pbhUMFoCcExbQ9EwWtLAxJvCezCc8GARW/YXCGAQvzrbCFgAoBFb9hcIYBC/OtsIAGRwVABUA + FRAAABa42+X/BxXiARaS06T/BxXWAQAmpM/9JxwVCBk1BggAGSgEYmJveAR4bWF4FQwWgJwTFtD0 + TBa8pTAmpM/9JzwYBDT9hcIYBCnOtsIWACgENP2FwhgEKc62wgAZHBUAFQAVEAAAFprd5f8HFeIB + FujUpP8HFdYBACbg9K0oHBUIGTUGCAAZKARiYm94BHltaW4VDBaAnBMW0PRMFrjeNCbg9K0oPBgE + zLaZuxgEmqqOwhYAKATMtpm7GASaqo7CABkcFQAVABUQAAAW/N7l/wcV4gEWvtak/wcV1gEAJpjT + 4igcFQgZNQYIABkoBGJib3gEeW1heBUMFoCcExbO9EwWisQ0JpjT4ig8GAQ+zpi7GAQ8qo7CFgAo + BD7OmLsYBDyqjsIAGRwVABUAFRAAABbe4OX/BxXiARaU2KT/BxXWAQAm4peXKRwVAhk1BggEGRgH + dmVyc2lvbhUMFoCcExb+BBagBibil5cpJqKXlykcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAA + GSwVBBUEFQIAFQAVBBUQAAAWwOLl/wcVwgEW6tmk/wcV1gEAJoKelykcFQwZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBaAnBMW/gUWoAcmgp6XKSbCnZcpHBgAGAAWACgAGAAA + GSwVBBUEFQIAFQAVBBUQAAAWguTl/wcVwgEWwNuk/wcVVgAmpqaXKRwVDBklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWgJwTFuz5Axa6zwImpqaXKSbipJcpHDYAKA1PcGVuU3Ry + ZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWxOXl/wcV0gEW + ltyk/wcV9gQAJpz0mSkcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW + gJwTFu6E3gIW8tCBASac9JkpPDYAKAx3OTk3NjIzMTYwQDEYDDAwMDE1OWE0ZTczMAAZHBUAFQAV + EAAAFpbn5f8HFeIBFozhpP8HFdYDACbQ/JwqHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + C3VwZGF0ZV90aW1lFQwWgJwTFuCDGRbQiAgm0PycKiaOxZsqHDYAKBgyMDI0LTExLTMwVDIzOjM4 + OjIwLjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABb46OX/ + BxXUARbi5KT/BxXWBgAm1PKlKhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRl + bmNlFQwWgJwTFuqTIxbe0CAm1PKlKibezaMqHBgIAAAAAAAA8D8YCAAAAKDvp9I/FuzIASgIAAAA + AAAA8D8YCAAAAKDvp9I/ABksFQQVBBUCABUAFQQVEAAAFszq5f8HFeIBFrjrpP8HFeYCACaUn8Qq + HBUCGTUGCAQZGAVsZXZlbBUMFoCcExb8BhaeCCaUn8QqJryexCocGAQCAAAAGAT/////FsqbEygE + AgAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABau7OX/BxXGARae7qT/BxXWAQAmkKnEKhwVDBk1 + BggEGRgHc3VidHlwZRUMFoCcExbcNBaWLSaQqcQqJtqmxCocNoqCEygOdHJhbnNwb3J0YXRpb24Y + DGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABb07eX/BxXSARb076T/BxXgAwAmitnEKhwV + DBk1BggEGRgFY2xhc3MVDBaAnBMW/jcW3C8mitnEKibw08QqHDbihBMoCXdhcmVob3VzZRgKYXBh + cnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABbG7+X/BxXSARbU86T/BxWUAwAmzIPFKhwVChk1BggA + GRgGaGVpZ2h0FQwWgJwTFoAxFuAPJsyDxSo8GAgAAAAAAAA0QBgIAAAAAAAA8D8WhJcTKAgAAAAA + AAA0QBgIAAAAAAAA8D8AGRwVABUAFRAAABaY8eX/BxXKARbo9qT/BxW2AgAmrJPFKhwVDBk1BggA + GSgFbmFtZXMHcHJpbWFyeRUMFoCcExauhQMWnNEBJqyTxSo8NpKIEygPw5NwdGljYSBkZWwgU3Vy + GAExABkcFQAVABUQAAAW4vLl/wcV0gEWnvmk/wcV9AMAJrDlxiocFQwZJQYEGUgFbmFtZXMGY29t + bW9uCWtleV92YWx1ZQNrZXkVDBaMnBMW3i4WmiMmsOXGKibI5MYqHDbsmxMoAmZyGAJkZQAZLBUE + FQQVAgAVABUEFRAAABa09OX/BxXSARaS/aT/BxWeAQAm4ofHKhwVDBklBgAZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlBXZhbHVlFQwWjJwTFqQ8FpwqJuKHxyo8NuybEygdU3VwZXJtYXJjaMOpIFRp + ZXJyYSBkZWwgRnVlZ28YDUJhbmNvIE5hY2nDs24AGRwVABUAFRAAABaG9uX/BxXSARaw/qT/BxXW + AwAm/rHHKhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFoicExbs + OhbCJyb+sccqPDbYmxMoBXNob3J0GAlhbHRlcm5hdGUAGRwVABUAFRAAABbY9+X/BxXSARaGgqX/ + BxWsAgAmwNnHKhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBaI + nBMW+DYWwiUmwNnHKjw2gJwTKAJlcxgCZW4AGRwVABUAFRAAABaq+eX/BxXSARayhKX/BxWGAQAm + gv/HKhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBaInBMW+D8Wuiwm + gv/HKjw22JsTKBZQb3J0ZXLDrWEgTGFndW5hIEhvbmRhGARBbGVtABkcFQAVABUQAAAW/Prl/wcV + 0gEWuIWl/wcVvAMAJryryCocFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdl + ZW4EbGlzdAdlbGVtZW50FQwWiJwTFsw2FpwlJryryCo8NoicEwAZHBUAFQAVEAAAFs785f8HFdIB + FvSIpf8HFXYAJtjQyCocFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaI + nBMWyDYWniUm2NDIKjw2iJwTABkcFQAVABUQAAAWoP7l/wcV0gEW6oml/wcVdgAm9vXIKhwVABk1 + BggAGRgJaGFzX3BhcnRzFQwWgJwTFuC3AhbmBib29cgqPBgBARgBABYAKAEBGAEAABkcFQAVABUQ + AAAW8v/l/wcVwgEW4Iql/wcVdgAm3PzIKhwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaAnBMW + 4LcCFrAGJtz8yCo8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABa0geb/BxXCARbWi6X/BxV2ACaU + hMkqHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWgJwTFtgXFtgWJpSEySomjIPJKhwYBAoAAAAYBAEA + AAAWlpITKAQKAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFvaC5v8HFdABFsyMpf8HFfYBACbk + mckqHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWgJwTFpAEFqAFJuSZySo8NoCc + EwAZHBUAFQAVEAAAFsaE5v8HFcIBFsKOpf8HFXYAJoSfySocFQoZNQYIABkYCm1pbl9oZWlnaHQV + DBaAnBMWkAQWoAUmhJ/JKjw2gJwTABkcFQAVABUQAAAWiIbm/wcVwgEWuI+l/wcVdgAmpKTJKhwV + Ahk1BggAGRgJbWluX2Zsb29yFQwWgJwTFpAEFqAFJqSkySo8NoCcEwAZHBUAFQAVEAAAFsqH5v8H + FcIBFq6Qpf8HFXYAJsSpySocFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFoCcExacBRaIBibEqckq + PDb2mxMoByNGRkZGRkYYByMwMDAwRkYAGRwVABUAFRAAABaMieb/BxXGARakkaX/BxWuAQAmprDJ + KhwVDBk1BggEGRgPZmFjYWRlX21hdGVyaWFsFQwWgJwTFo4FFrAGJqawySomzK/JKhw25JsTKAR3 + b29kGAVtZXRhbAAZLBUEFQQVAgAVABUEFRAAABbSiub/BxXCARbSkqX/BxWYAQAm4LbJKhwVDBk1 + BggEGRgNcm9vZl9tYXRlcmlhbBUMFoCcExaUBRa2BibgtskqJvy1ySocNuKbEygJdGFyX3BhcGVy + GAVtZXRhbAAZLBUEFQQVAgAVABUEFRAAABaUjOb/BxXCARbqk6X/BxWmAQAm5r3JKhwVDBk1BggE + GRgKcm9vZl9zaGFwZRUMFoCcExbABxbiCCbmvckqJrK8ySocNrCbEygHc2FsdGJveBgEZG9tZQAZ + LBUEFQQVAgAVABUEFRAAABbWjeb/BxXGARaQlaX/BxXQAQAmlMXJKhwVChk1BggAGRgOcm9vZl9k + aXJlY3Rpb24VDBaAnBMWkAQWoAUmlMXJKjw2gJwTABkcFQAVABUQAAAWnI/m/wcVwgEW4Jal/wcV + dgAmtMrJKhwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFoCcExauBBa+BSa0yskqPBgGYWNy + b3NzGAZhY3Jvc3MW/psTKAZhY3Jvc3MYBmFjcm9zcwAZHBUAFQAVEAAAFt6Q5v8HFcIBFtaXpf8H + FY4BACbI0ckqHBUMGTUGCAQZGApyb29mX2NvbG9yFQwWgJwTFoAJFp4JJsjRySom8s/JKhw2ipsT + KAcjRkZGRkZGGAcjMDAwMDAwABksFQQVBBUCABUAFQQVEAAAFqCS5v8HFcQBFuSYpf8HFcoBACaQ + 2ckqHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFoCcExa6BBbKBSaQ2ckqPBgIAAAAAAAA+D8YCAAA + AAAAAPA/FvybEygIAAAAAAAA+D8YCAAAAAAAAPA/ABkcFQAVABUQAAAW5JPm/wcVwgEWrpql/wcV + lgEAFp6L7hoWgJwTJtbpwhwWhPWGDhQEABn8Jiba3skqHBUMGTUGCAAZGAJpZBUMFsC3ExbQ0rsF + Fq78zgEm2t7JKjw2ACggMDhiZGY2ZDZmMjJhNWZmZjAyMDA2MzkyZjlmZjlhOTYYIDA4YmNmMTA0 + MDBjMjBmZmYwMjAwNDgyNjIyOWM5MzU5ABkcFQAVABUQAAAWppXm/wcV4gEWxJul/wcV1ggAJojb + mCwcFQwZNQYIABkYCGdlb21ldHJ5FQwWwLcTFsyMhRAW/p3RCSaI25gsPDYAKJEKAAAAAAMAAAAK + AAAAIcBSFPN+fN2hwEnEooGfp9HAUhTzQ1kbJMBJxKqotZZPwFIU8ppRT37AScSqoSjaFMBSFPKS + WTN4wEnEq7Ackt7AUhTwlFIx/MBJxKuZdl4rwFIU8JiD7+TAScSrBqlnbcBSFO/7Op5hwEnEqv/z + asbAUhTv9p2Ar8BJxKugLFrSwFIU7kaaGEXAScSrjOEkc8BSFO5O/ZQVwEnEqmnLdbXAUhTtAR+6 + sMBJxKpasf0+wFIU7PyCnP7AScSrBqlnbcBSFOlWcE8dwEnEqt2Ou/DAUhTpT07yrMBJxKvQ08KK + wFIU6GaGRtbAScSrxsLHkMBSFOhu6cKnwEnEqqBSGn/AUhTe7PVhQcBJxKo08lAUwFIU3xHeTtXA + ScSlJOgW1cBSFN4Kd1JHwEnEpRkpnLHAUhTeDWbw0MBJxKSnE9WgwFIU3CRYpN3AScSkkURggsBS + FNxLWnFmwEnEnzTkDVvAUhTfAzA2KcBJxJ9TFv5JwFIU30LxFljAScSWl4aZ48BSFOTdZMqFwEnE + ltZwun3AUhTk6EyFFMBJxJVYwjj1wFIU7bPNIYbAScSVu76HkMBSFO2nN+fOwEnEl3NOrDXAUhTu + Cwr1/cBJxJd4VymzwFIU7hHA8qTAScSWjXWe6cBSFPISbBNPwEnElrnrSLnAUhTxvUcdzMBJxKJu + VHFxwFIU83583aHAScSigZ+n0QAAAAXAUhTk5p8F6sBJxKD3W+yQwFIU5RgdLTfAScSX5WRzR8BS + FOR3DX2XwEnEl+Bb9crAUhTkRfq2FMBJxKDyU28TwFIU5OafBerAScSg91vskAAAAAXAUhTpdlC/ + NcBJxKCkT9YBwFIU6auVRKDAScSYRC8D+sBSFOkGU9cYwEnEmD5PxujAUhTo0Xqxd8BJxKCecJjv + wFIU6XZQvzXAScSgpE/WAQAAAAXAUhTuD6gTsMBJxJ9mYjSowFIU7iPKCaTAScSYU0h8ccBSFO2H + wteBwEnEmFDEPbLAUhTtc6DhjMBJxJ9j3fXqwFIU7g+oE7DAScSfZmI0qAAAAAXAUhTt7UNk2sBJ + xKIgUNhgwFIU7e1DZNrAScSgFotcwMBSFO1DZNmewEnEoBaLXMDAUhTtQ2TZnsBJxKIgUNhgwFIU + 7e1DZNrAScSiIFDYYAAAAAXAUhTxQLT79sBJxKcOzSJdwFIU8UM5OrTAScSlWBO9TMBSFPBSDRMO + wEnEpVWPfo7AUhTwT4jUT8BJxKcMSOOfwFIU8UC0+/bAScSnDs0iXQAAAAXAUhTtlMNxA8BJxKfW + cz68wFIU7ZvkzXXAScSlWBO9TMBSFO0Re1KHwEnEpVWPfo7AUhTtCln2FsBJxKfT7v/9wFIU7ZTD + cQPAScSn1nM+vAAAAAXAUhTpKmYFGMBJxKTVNv6awFIU6TLJgOjAScSj5Uz2U8BSFOi2N18SwEnE + o96W+azAUhTordPjQsBJxKTOgQHzwFIU6SpmBRjAScSk1Tb+mgAAAAXAUhTpCUN1ocBJxKkKT+Ub + wFIU6R48KynAScSm1BS/q8BSFOihqglTwEnEpsyIA2/AUhTojLFTy8BJxKkDmeh0wFIU6QlDdaHA + ScSpCk/lGwAAAAXAUhTkmDANDsBJxKmT4qB0wFIU5LPevz7AScSi1Ku+X8BSFOIoE0SAwEnEosS7 + hlPAUhTiDGSSUcBJxKmD8mhowFIU5JgwDQ7AScSpk+KgdBhNAAAAAAMAAAABAAAABMBRuHNMk1aJ + wEqRabnX/YLAUbh7S9C468BKkWkgVQoewFG4c55dTbnASpF06bboX8BRuHNMk1aJwEqRabnX/YIA + GRwVABUAFSQAABaIl+b/BxX8AxaapKX/BxWuJQAm0M+HNhwVCBk1BggEGSgEYmJveAR4bWluFQwW + wLcTFvCUTBawikEm0M+HNiaG+ek1HBgEqSeIwhgEAUCSwhYAKASpJ4jCGAQBQJLCABksFQQVBBUC + ABUAFQQVEAAAFoSb5v8HFeIBFsjJpf8HFdYBACbg1cg2HBUIGTUGCAQZKARiYm94BHhtYXgVDBbA + txMW9o5MFrCGQSbg1cg2JraDqzYcGASXJ4jCGAT4P5LCFgAoBJcniMIYBPg/ksIAGSwVBBUEFQIA + FQAVBBUQAAAW5pzm/wcV4gEWnsul/wcV1gEAJoDljjccFQgZNQYIBBkoBGJib3gEeW1pbhUMFsC3 + Exb+vlQWnORHJoDljjcm5onsNhwYBAqASsIYBAzAVcIWACgECoBKwhgEDMBVwgAZLBUEFQQVAgAV + ABUEFRAAABbInub/BxXiARb0zKX/BxXWAQAmosXWNxwVCBk1BggEGSgEYmJveAR5bWF4FQwWwLcT + FpC5VBaW4kcmosXWNyaC7rM3HBgE/39KwhgE9b9VwhYAKAT/f0rCGAT1v1XCABksFQQVBBUCABUA + FQQVEAAAFqqg5v8HFeIBFsrOpf8HFdYBACbY0Ps3HBUCGTUGCAQZGAd2ZXJzaW9uFQwWwLcTFv4E + FqAGJtjQ+zcmmND7NxwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAA + ABaMoub/BxXCARag0KX/BxXWAQAm+Nb7NxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhw + cm9wZXJ0eRUMFsC3Exb+BRagByb41vs3JrjW+zccGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAA + ABbOo+b/BxXCARb20aX/BxVWACac3/s3HBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2Rh + dGFzZXQVDBbAtxMWiuIEFsCAAyac3/s3Jtjd+zccNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBP + cGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABaQpeb/BxXSARbM0qX/BxX2BAAmmN7+NxwV + DBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbAtxMWrLnnAhbk7IQBJpje + /jc8NgAoDHc5OTc1ODc2MjVAMRgMMDAwMDQ4NjFlYzY4ABkcFQAVABUQAAAW4qbm/wcV4gEWwtel + /wcV1gMAJo6+hDkcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbA + txMWoMgYFqi3ByaOvoQ5JvzKgzkcNgAoGDIwMjQtMTEtMTRUMjM6MjU6MjMuMDAwWhgYMjAxMC0w + Ni0wOFQxNjo1ODozNy4wMDBaABksFQQVBBUCABUAFQQVEAAAFsSo5v8HFdQBFpjbpf8HFdYGACaa + ro05HBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbAtxMWgNMjFoCX + ISaaro05JqSCizkcGAgAAAAAAADwPxgIAAAAIOJY2z8Whp4BKAgAAAAAAADwPxgIAAAAIOJY2z8A + GSwVBBUEFQIAFQAVBBUQAAAWmKrm/wcV4gEW7uGl/wcV5gIAJqSZrDkcFQIZNQYIABkYBWxldmVs + FQwWwLcTFqoFFroGJqSZrDk8GAQBAAAAGAT/////Fq63EygEAQAAABgE/////wAZHBUAFQAVEAAA + Fvqr5v8HFcQBFtTkpf8HFcYBACaEoqw5HBUMGTUGCAQZGAdzdWJ0eXBlFQwWwLcTFsoqFpwmJoSi + rDkm3p+sORw2uJUTKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EAAAFr6t5v8HFdIBFprmpf8HFcQDACasyqw5HBUMGTUGCAQZGAVjbGFzcxUMFsC3Exa0KRaYJSas + yqw5JvrFrDkcNoaXEygJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFpCv + 5v8HFdIBFt7ppf8HFYADACaS66w5HBUKGTUGCAAZGAZoZWlnaHQVDBbAtxMWkggWngcmkuusOTwY + CAAAAAAAYGBAGAgAAAAAAAAIQBaQtxMoCAAAAAAAYGBAGAgAAAAAAAAIQAAZHBUAFQAVEAAAFuKw + 5v8HFcQBFt7spf8HFZYCACaw8qw5HBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWwLcTFv6mARaq + aSaw8qw5PDaashMoDnJpbmPDs24gZGUgbW9lGBUzIENvbWlzYXLDrWEgUG9ydmVuaXIAGRwVABUA + FRAAABamsub/BxXSARb07qX/BxXyBQAm2tutORwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3Zh + bHVlA2tleRUMFsy3ExaIHRaMFyba2605PDaktxMoAnpoGAJlbgAZHBUAFQAVEAAAFviz5v8HFdIB + Fub0pf8HFZ4BACbm8q05HBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbM + txMWjicWqB4m5vKtOTw2pLcTKBLlva3loZTojrHmlq/noIHlpLQYDkFyZ2VudGluZSBNYWlsABkc + FQAVABUQAAAWyrXm/wcV0gEWhPal/wcVogQAJo6RrjkcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50B3ZhcmlhbnQVDBbMtxMW0iIW3BgmjpGuOTw2prcTKAVzaG9ydBgJYWx0ZXJuYXRl + ABkcFQAVABUQAAAWnLfm/wcV0gEWpvql/wcVigIAJuqprjkcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWzLcTFtQfFrAXJuqprjk8NsS3EygCZXMYAmVuABkcFQAV + ABUQAAAW7rjm/wcV0gEWsPyl/wcVhgEAJprBrjkcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdl + bGVtZW50BXZhbHVlFQwWzLcTFt4mFoYdJprBrjk8Nqa3EygPU2FudGFuZGVyIEdyb3VwGBdBZXJv + cHVlcnRvIFB1bnRhIEFyZW5hcwAZHBUAFQAVEAAAFsC65v8HFdIBFrb9pf8HFa4EACag3q45HBUK + GSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFsy3 + ExasHxaaFyag3q45PDbMtxMAGRwVABUAFRAAABaSvOb/BxXSARbkgab/BxV2ACa69a45HBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWzLcTFqYfFpAXJrr1rjk8Nsy3EwAZ + HBUAFQAVEAAAFuS95v8HFdIBFtqCpv8HFXYAJsqMrzkcFQAZNQYIABkYCWhhc19wYXJ0cxUMFsC3 + ExaYuwIW2AYmyoyvOTwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFra/5v8HFcIBFtCDpv8HFXYA + JqKTrzkcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWwLcTFpi7AhawBiaik685PBgBABgBABYA + KAEAGAEAABkcFQAVABUQAAAW+MDm/wcVwgEWxoSm/wcVdgAmwpqvORwVAhk1BggEGRgKbnVtX2Zs + b29ycxUMFsC3ExaKCRaeCibCmq85JtKZrzkcGAQKAAAAGAQBAAAAFrK2EygECgAAABgEAQAAAAAZ + LBUEFQQVAgAVABUEFRAAABa6wub/BxXMARa8hab/BxX2AQAm8KOvORwVAhk1BggAGRgWbnVtX2Zs + b29yc191bmRlcmdyb3VuZBUMFsC3ExaQBBagBSbwo685PDbAtxMAGRwVABUAFRAAABaGxOb/BxXC + ARayh6b/BxV2ACaQqa85HBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWwLcTFpAEFqAFJpCprzk8NsC3 + EwAZHBUAFQAVEAAAFsjF5v8HFcIBFqiIpv8HFXYAJrCurzkcFQIZNQYIABkYCW1pbl9mbG9vchUM + FsC3ExaQBBagBSawrq85PDbAtxMAGRwVABUAFRAAABaKx+b/BxXCARaeiab/BxV2ACbQs685HBUM + GTUGCAAZGAxmYWNhZGVfY29sb3IVDBbAtxMWsAQWwAUm0LOvOTwYByNGRkE1MDAYByNGRkE1MDAW + vrcTKAcjRkZBNTAwGAcjRkZBNTAwABkcFQAVABUQAAAWzMjm/wcVwgEWlIqm/wcVkgEAJpC5rzkc + FQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFsC3ExaOBRbKBSaQua85PBgEd29vZBgEd29vZBay + txMoBHdvb2QYBHdvb2QAGRwVABUAFRAAABaOyub/BxXCARami6b/BxWGAQAm2r6vORwVDBk1BggA + GRgNcm9vZl9tYXRlcmlhbBUMFsC3ExaOBRbKBSbavq85PBgEd29vZBgEd29vZBaytxMoBHdvb2QY + BHdvb2QAGRwVABUAFRAAABbQy+b/BxXCARasjKb/BxWGAQAmpMSvORwVDBk1BggAGRgKcm9vZl9z + aGFwZRUMFsC3ExbaBxasByakxK85PDactxMoCHNraWxsaW9uGARmbGF0ABkcFQAVABUQAAAWks3m + /wcVyAEWso2m/wcV3AEAJtDLrzkcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWwLcTFpAEFqAF + JtDLrzk8NsC3EwAZHBUAFQAVEAAAFtrO5v8HFcIBFo6Ppv8HFXYAJvDQrzkcFQwZNQYIABkYEHJv + b2Zfb3JpZW50YXRpb24VDBbAtxMW5gQWzAUm8NCvOTwYBWFsb25nGAVhbG9uZxa4txMoBWFsb25n + GAVhbG9uZwAZHBUAFQAVEAAAFpzQ5v8HFcQBFoSQpv8HFYoBACa81q85HBUMGTUGCAAZGApyb29m + X2NvbG9yFQwWwLcTFogFFvoFJrzWrzk8Nri3EygHI0ZGMDAwMBgHIzAwMDBGRgAZHBUAFQAVEAAA + FuDR5v8HFcQBFo6Rpv8HFZIBACa23K85HBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFsC3Exb8BBbG + BSa23K85PBgIAAAAAAAA4D8YCAAAAAAAAOA/FrS3EygIAAAAAAAA4D8YCAAAAAAAAOA/ABkcFQAV + ABUQAAAWpNPm/wcVwgEWoJKm/wcVlgEAFpDmsxsWwLcTJtreySoWooPmDhQGABn8Jib84a85HBUM + GTUGCAAZGAJpZBUMFrikExaupLYFFuyh1QEm/OGvOTw2ACggMDhiY2ZhZWRiMzM4YmZmZjAyMDBl + ZDA3YzA5NTA2NTUYIDA4YmNlMTQwYjAxMDJmZmYwMjAwZWVkNDYzZmI3MjYzABkcFQAVABUQAAAW + 5tTm/wcV4gEWtpOm/wcV1ggAJuiDhTscFQwZNQYIABkYCGdlb21ldHJ5FQwWuKQTFrzc8Q8W8IW+ + CSbog4U7PDYAKIsUAAAAAAYAAAAKAAAAAAMAAAABAAAAEcBRIfPHd/k2wEkCq1Zaf6jAUSHyup0f + YMBJAqtSKMHAwFEh8kKoGz3ASQKrUHtClsBRIfJHsJi6wEkCqQ2q427AUSHywwCbMMBJAqkPWGKY + wFEh9RdusY/ASQKpF7veaMBRIfUZHDC4wEkCqEHTCSfAUSH1yod4L8BJAqhEV0flwFEh9lmOEM/A + SQKoRgTHD8BRIfZXdTHbwEkCqSsHFMfAUSH2hMGbQMBJAqkrBxTHwFEh9oRWO3bASQKpYLb5/cBR + IfaAJH2OwEkCq2chd0nAUSH1fIPfHcBJAqtjxnj2wFEh9Xd7YaDASQKtpOlY9cBRIfPCb3u5wEkC + rZ8KG+PAUSHzx3f5NsBJAqtWWn+oAAAAAAMAAAABAAAAD8BRIe/K/pZzwEkCv6nOmwPAUSHw58mo + VcBJAr+pzpsDwFEh8WCVbA3ASQK/qc6bA8BRIfFhAMvYwEkCweye+izAUSHw5vLowMBJAsHtdbnB + wFEh7pLwMi3ASQLB7kx5VcBRIe6S8DItwEkCwshnDH/AUSHt4fBKgMBJAsLIZwx/wFEh7VJ+UhXA + SQLCyT3ME8BRIe1SflIVwEkCweUSPfDAUSHtI+/JUcBJAsHlEj3wwFEh7SPvyVHASQLBsDkYUMBR + Ie0jhGmHwEkCv6qlWpjAUSHuv9E7x8BJAr+qpVqYwFEh78r+lnPASQK/qc6bAwAAAAADAAAAAQAA + AA/AUSH6FQR0A8BJArPzt/MhwFEh+PfOAlfASQKz8Fz0zsBRIfh/Aj6fwEkCs++GNTnAUSH4gsic + vMBJArGr3xZ7wFEh+P1B357ASQKxrLXWEMBRIftQ2TZowEkCsbNr0rfAUSH7Uoa1kcBJArDZUT+O + wFEh/AOGnT7ASQKw2v6+t8BRIfyS+JWowEkCsNysPeHAUSH8kUsWf8BJArHAAQxvwFEh/L/Zn0PA + SQKxwNfMBMBRIfy/bj95wEkCsfWw8aXAUSH8vBNBJcBJArP7RK9cwFEh+yAxzq/ASQKz9jwx38BR + IfoVBHQDwEkCs/O38yEAAAAAAwAAAAEAAAAPwFEh9voyYKXASQK2O5DPxsBRIfgW/XKHwEkCtjuQ + z8bAUSH4j8k2P8BJArY7kM/GwFEh+JCf9dTASQK4fmEu78BRIfgWJrLywEkCuH837oTAUSH1wiP8 + X8BJAriADq4ZwFEh9cKPXCnASQK5WilBQsBRIfURj3R9wEkCuVopQULAUSH0gh18EsBJArlbAADX + wFEh9IGyHEfASQK4dtRys8BRIfRTI5ODwEkCuHbUcrPAUSH0UyOTg8BJArhB+00TwFEh9FK4M7nA + SQK2PGePW8BRIfXvBQX5wEkCtjxnj1vAUSH2+jJgpcBJArY7kM/GAAAAAAMAAAABAAAAD8BRIfDe + j2zwwEkCs/IKc/fAUSHx+1p+0sBJArPyCnP3wFEh8nQmQorASQKz8gpz98BRIfJ0kaJUwEkCtjWx + krXAUSHx+oO/PcBJArY1sZK1wFEh76aBCKnASQK2NohSScBRIe+m7Gh0wEkCtxCi5XPAUSHu9eyA + x8BJArcQouVzwFEh7mZ6iFzASQK3EXmlCMBRIe5mDyiSwEkCti1OFuTAUSHuN4CfzsBJArYtThbk + wFEh7jeAn87ASQK1+HTxRMBRIe43FUADwEkCs/O38yHAUSHv02ISRMBJArPy4TOMwFEh8N6PbPDA + SQKz8gpz9wAAAAADAAAAAQAAAA/AUSHpZfUnX8BJArcxWhUfwFEh6oLAOUHASQK3MVoVH8BRIer7 + i/z5wEkCtzFaFR/AUSHq+/dcw8BJArl0KnRIwFEh6oHpeazASQK5dQEz3cBRIegt5sMYwEkCuXXX + 83HAUSHoLlIi48BJArpP8oabwFEh531SOzbASQK6T/KGm8BRIebt4ELLwEkCulDJRjDAUSHm7XTj + AcBJArlsnbgMwFEh5r7mWj3ASQK5bJ24DMBRIea+5lo9wEkCuTfEkmzAUSHmvnr6csBJArcyMNS0 + wFEh6FrHzLPASQK3MjDUtMBRIell9SdfwEkCtzFaFR8AAAAAAwAAAAEAAAAPwFEh4si3lFbASQKv + mN9fd8BRIePlgqY4wEkCr5jfX3fAUSHkXrnJu8BJAq+Y3193wFEh5F8lKYXASQKx3IZ+NMBRIePk + q+ajwEkCsdyGfjTAUSHhkRSP2sBJArHdXT3JwFEh4ZEUj9rASQKyt3fQ8sBRIeDgFKguwEkCsrd3 + 0PLAUSHgUKKvw8BJArK4TpCHwFEh4FCir8PASQKx1CMCZMBRIeAhqMc0wEkCsdQjAmTAUSHgIajH + NMBJArGfSdzDwFEh4CE9Z2rASQKvmozeoMBRIeG9ijmqwEkCr5m2HwvAUSHiyLeUVsBJAq+Y3193 + AAAAAAMAAAABAAAAD8BRIeX5xHycwEkCrDgBzw3AUSHk3Plqu8BJAqwyIpH7wFEh5GQtpwLASQKs + L55TPcBRIeRrTwNzwEkCqev3NH/AUSHk5chGVcBJAqnue3M+wFEh5zlfnR/ASQKp+xCs9sBRIec8 + TzunwEkCqSAfWjjAUSHn7U8jVMBJAqkkURghwFEh6HzBG7/ASQKpJtVW38BRIeh50X02wEkCqgsA + 5QLAUSHoqGAF+sBJAqoL16SXwFEh6KeJRmXASQKqQLDKOMBRIeihPqmJwEkCrEVtyFrAUSHnBPHX + SMBJAqw9CkyKwFEh5fnEfJzASQKsOAHPDQAAAAADAAAAAQAAAA/AUSHtmcvugMBJAqL3EG02wFEh + 7H0A3J/ASQKi8TEwJMBRIewENRjnwEkCou6s8WXAUSHsC1Z1WMBJAqCrBdKowFEh7IVkWG/ASQKg + rYoRZsBRIe7ZZw8DwEkCoLofSx/AUSHu2+tNwcBJAp/fLfhhwFEh74zrNW7ASQKf41+2ScBRIfAc + XS3ZwEkCn+Xj9QfAUSHwGW2PUMBJAqDJOMOWwFEh8Ehnd97ASQKgyuZCwMBRIfBHkLhKwEkCoP+/ + aGDAUSHwQUYbbcBJAqMEfGaDwFEh7qT5SS3ASQKi/Bjqs8BRIe2Zy+6AwEkCovcQbTYAAAAAAwAA + AAEAAAAPwFEh7KJVKf7ASQKung2cocBRIeuFihgcwEkCrpguX4/AUSHrDL5UZMBJAq6VqiDQwFEh + 6xPfsNXASQKsUgMCE8BRIeuN7ZPtwEkCrFSHQNLAUSHt4fBKgMBJAqxhHHqKwFEh7eR0iT/ASQKr + hwHnYcBRIe6VdHDrwEkCq4pc5bTAUSHvJOZpVsBJAquNt+QHwFEh7yH2ys3ASQKscQyylsBRIe9Q + hVORwEkCrHHjcivAUSHvUBnzx8BJAqymvJfLwFEh70lj9yDASQKurFBVg8BRIe2tgoSqwEkCrqPs + 2bPAUSHsolUp/sBJAq6eDZyhGE0AAAAAAwAAAAEAAAAEwFFPNAlJ4Q7ASc9iMNHAcMBRTzRb+58j + wEnPXkfOv67AUU828N/UZcBJz2KQB2oswFFPNAlJ4Q7ASc9iMNHAcAAZHBUAFQAVJAAAFsjW5v8H + FfwDFoycpv8HFa4lACaY7edEHBUIGTUGCAQZKARiYm94BHhtaW4VDBa4pBMW+KJXFvrVSiaY7edE + JtiJw0QcGARKfojCGATiRpfCFgAoBEp+iMIYBOJGl8IAGSwVBBUEFQIAFQAVBBUQAAAWxNrm/wcV + 4gEWusGm/wcV1gEAJvrGskUcFQgZNQYIBBkoBGJib3gEeG1heBUMFrikExbgqVcW5NlKJvrGskUm + 0t+NRRwYBEB+iMIYBLNGl8IWACgEQH6IwhgEs0aXwgAZLBUEFQQVAgAVABUEFRAAABam3Ob/BxXi + ARaQw6b/BxXWAQAmtrnYRRwVCBk1BggAGSgEYmJveAR5bWluFQwWuKQTFrCWTRbckTMmtrnYRTwY + BBkANMIYBAQeUMIWACgEGQA0whgEBB5QwgAZHBUAFQAVEAAAFoje5v8HFeIBFubEpv8HFdYBACaS + y4tGHBUIGTUGCAAZKARiYm94BHltYXgVDBa4pBMWrpZNFp67MyaSy4tGPBgE9/8zwhgE+h1QwhYA + KAT3/zPCGAT6HVDCABkcFQAVABUQAAAW6t/m/wcV4gEWvMam/wcV1gEAJvCGv0YcFQIZNQYIBBkY + B3ZlcnNpb24VDBa4pBMW/gQWoAYm8Ia/Riawhr9GHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAA + ABksFQQVBBUCABUAFQQVEAAAFszh5v8HFcIBFpLIpv8HFdYBACaQjb9GHBUMGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWuKQTFv4FFqAHJpCNv0Ym0Iy/RhwYABgAFgAoABgA + ABksFQQVBBUCABUAFQQVEAAAFo7j5v8HFcIBFujJpv8HFVYAJrSVv0YcFQwZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFrikExbGpwQW6uMCJrSVv0Ym8JO/Rhw2ACgNT3BlblN0 + cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFtDk5v8HFdIB + Fr7Kpv8HFfYEACba98FGHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUM + FrikExbch98CFoKOhAEm2vfBRjw2ACgMdzk5OTQ4OTE4NkAxGAwwMDAwMjk1NDJmZTEAGRwVABUA + FRAAABai5ub/BxXiARa0z6b/BxXWAwAmioXHRxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAt1cGRhdGVfdGltZRUMFrikExaOyBQWrp4HJoqFx0cm3IXGRxw2ACgYMjAyNC0xMS0yNVQxMzox + NToyNC4wMDBaGBgyMDExLTA2LTEwVDAzOjU2OjA0LjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWhOjm + /wcV1AEWitOm/wcV1gYAJtLMz0ccFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlk + ZW5jZRUMFrikExbIlSIW4tEfJtLMz0cmiqTNRxwYCAAAAAAAAPA/GAgAAACgXP7bPxb4/QEoCAAA + AAAAAPA/GAgAAACgXP7bPwAZLBUEFQQVAgAVABUEFRAAABbY6eb/BxXiARbg2ab/BxXoAgAmtPbs + RxwVAhk1BggEGRgFbGV2ZWwVDBa4pBMWsgYW1AcmtPbsRybs9exHHBgEAQAAABgE/////xaKpBMo + BAEAAAAYBP////8AGSwVBBUEFQIAFQAVBBUQAAAWuuvm/wcVxgEWyNym/wcV5gEAJvb/7EccFQwZ + NQYIBBkYB3N1YnR5cGUVDBa4pBMWtCUWjCMm9v/sRybA/exHHDbYhxMoDnRyYW5zcG9ydGF0aW9u + GAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWgO3m/wcV0gEWrt6m/wcV0gMAJuik7Ucc + FQwZNQYIBBkYBWNsYXNzFQwWuKQTFp4lFqQiJuik7UcmzKDtRxw2rokTKAl3YXJlaG91c2UYCmFw + YXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAW0u7m/wcV0gEWgOKm/wcVgAMAJvbD7UccFQoZNQYI + BBkYBmhlaWdodBUMFrikExbaBha4Byb2w+1HJvDC7UccGAgAAAAAAAA0QBgIAAAAAAAAAEAW+qMT + KAgAAAAAAAA0QBgIAAAAAAAAAEAAGSwVBBUEFQIAFQAVBBUQAAAWpPDm/wcVxAEWgOWm/wcV9gEA + JtSJ7kccFQwZNQYIBBkoBW5hbWVzB3ByaW1hcnkVDBa4pBMWrJoBFtpaJtSJ7kcmqMrtRxw24J0T + KA/Dk3B0aWNhIENlbnRyYWwYATEAGSwVBBUEFQIAFQAVBBUQAAAW6PHm/wcV0gEW9uam/wcVygYA + JoKl7kccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbCpBMWhhkW8hQmgqXu + Rzw2kqQTKAJwdBgCZW4AGRwVABUAFRAAABa68+b/BxXSARbA7ab/BxWeAQAm9LnuRxwVDBklBgAZ + SAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWwqQTFrQhFtoaJvS57kc8NpKkEygNVGVj + aGFkbyBOZWdybxgOQXJnZW50aW5lIE1haWwAGRwVABUAFRAAABaM9eb/BxXSARbe7qb/BxXmAgAm + ztTuRxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFsSkExb2HRbE + FibO1O5HPDagpBMoBXNob3J0GAlhbHRlcm5hdGUAGRwVABUAFRAAABbe9ub/BxXSARbE8ab/BxWU + AgAmkuvuRxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbEpBMW + hhsWphUmkuvuRzw2uKQTKAJlcxgCZW4AGRwVABUAFRAAABaw+Ob/BxXSARbY86b/BxWOAQAmuIDv + RxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbEpBMW5iIWlhsmuIDv + Rzw2oKQTKCNUZXJtaW5hbCBkZSDDk21uaWJ1cyBkZSBFbCBDYWxhZmF0ZRgNQkJWQSBGcmFuY8Op + cwAZHBUAFQAVEAAAFoL65v8HFdIBFub0pv8HFZ4EACbOm+9HHBUKGSUGABl4BW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFsSkExbEGhbkFCbOm+9HPDbEpBMA + GRwVABUAFRAAABbU++b/BxXSARaE+ab/BxV2ACaysO9HHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudARzaWRlFQwWxKQTFr4aFuIUJrKw70c8NsSkEwAZHBUAFQAVEAAAFqb95v8HFdIB + Fvr5pv8HFXYAJpTF70ccFQAZNQYIABkYCWhhc19wYXJ0cxUMFrikExbouAIWugYmlMXvRzwYAQEY + AQAWACgBARgBAAAZHBUAFQAVEAAAFvj+5v8HFcIBFvD6pv8HFXYAJs7L70ccFQAZNQYIABkYDmlz + X3VuZGVyZ3JvdW5kFQwWuKQTFui4AhawBibOy+9HPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAW + uoDn/wcVwgEW5vum/wcVdgAm9tLvRxwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFrikExaaCxaiDCb2 + 0u9HJv7R70ccGAQPAAAAGAQBAAAAFtKeEygEDwAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABb8 + gef/BxXMARbc/Kb/BxXWAQAmoN7vRxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUM + FrikExaOBBaeBSag3u9HPDa4pBMAGRwVABUAFRAAABbIg+f/BxXCARay/qb/BxV2ACa+4+9HHBUK + GTUGCAAZGAptaW5faGVpZ2h0FQwWuKQTFo4EFp4FJr7j70c8NrikEwAZHBUAFQAVEAAAFoqF5/8H + FcIBFqj/pv8HFXYAJtzo70ccFQIZNQYIABkYCW1pbl9mbG9vchUMFrikExaOBBaeBSbc6O9HPDa4 + pBMAGRwVABUAFRAAABbMhuf/BxXCARaegKf/BxV2ACb67e9HHBUMGTUGCAAZGAxmYWNhZGVfY29s + b3IVDBa4pBMWiAUWigYm+u3vRzw2sKQTKAcjRkZGRjAwGAcjOEI0NTEzABkcFQAVABUQAAAWjojn + /wcVxAEWlIGn/wcVrgEAJoT070ccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFrikExaOBBae + BSaE9O9HPDa4pBMAGRwVABUAFRAAABbSief/BxXCARbCgqf/BxV2ACai+e9HHBUMGTUGCAAZGA1y + b29mX21hdGVyaWFsFQwWuKQTFo4EFp4FJqL570c8NrikEwAZHBUAFQAVEAAAFpSL5/8HFcIBFriD + p/8HFXYAJsD+70ccFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBa4pBMWxgYW6AYmwP7vRzw2oKQTKAlw + eXJhbWlkYWwYBGZsYXQAGRwVABUAFRAAABbWjOf/BxXGARauhKf/BxW8AQAmqIXwRxwVChk1BggA + GRgOcm9vZl9kaXJlY3Rpb24VDBa4pBMWjgQWngUmqIXwRzw2uKQTABkcFQAVABUQAAAWnI7n/wcV + wgEW6oWn/wcVdgAmxorwRxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFrikExasBBa8BSbG + ivBHPBgFYWxvbmcYBWFsb25nFrakEygFYWxvbmcYBWFsb25nABkcFQAVABUQAAAW3o/n/wcVwgEW + 4Ian/wcVigEAJoKQ8EccFQwZNQYIABkYCnJvb2ZfY29sb3IVDBa4pBMWjAcWwAYmgpDwRzw2nKQT + KAcjRkZGRjAwGAcjMDAwMDAwABkcFQAVABUQAAAWoJHn/wcVxgEW6oen/wcVygEAJsKW8EccFQoZ + NQYIABkYC3Jvb2ZfaGVpZ2h0FQwWuKQTFqgEFrgFJsKW8Ec8GAgAAAAAAAAAQBgIAAAAAAAAAEAW + tqQTKAgAAAAAAAAAQBgIAAAAAAAAAEAAGRwVABUAFRAAABbmkuf/BxXCARa0iaf/BxWWAQAWqICU + Gxa4pBMm/OGvORb+ucAOFAgAGfwmJvqb8EccFQwZNQYIABkYAmlkFQwWgKsTFtCQuAUWvPjRASb6 + m/BHPDYAKCAwOGJjZmIxYmIwMDRiZmZmMDIwMDcyZGExMDg0MDBlZhggMDhiY2UxNmMxMDdiMmZm + ZjAyMDBiNzkxM2Q3NTJkMjgAGRwVABUAFRAAABaolOf/BxXiARbKiqf/BxXWCAAmtpTCSRwVDBk1 + BggAGRgIZ2VvbWV0cnkVDBaAqxMWrtvPDxa056gJJraUwkk8ABkcFQAVABUkAAAWipbn/wcV/AMW + oJOn/wcVriUAJur76lIcFQgZNQYIABkoBGJib3gEeG1pbhUMFoCrExbMsE0W4L0wJur76lI8GAR8 + AIfCGAQBQJLCFgAoBHwAh8IYBAFAksIAGRwVABUAFRAAABaGmuf/BxXiARbOuKf/BxXWAQAmyrmb + UxwVCBk1BggAGSgEYmJveAR4bWF4FQwWgKsTFtCwTRa4rzAmyrmbUzwYBHIAh8IYBPk/ksIWACgE + cgCHwhgE+T+SwgAZHBUAFQAVEAAAFuib5/8HFeIBFqS6p/8HFdYBACaC6ctTHBUIGTUGCAAZKARi + Ym94BHltaW4VDBaAqxMW0LBNFviHMiaC6ctTPBgEUwA0whgEt19IwhYAKARTADTCGAS3X0jCABkc + FQAVABUQAAAWyp3n/wcV4gEW+run/wcV1gEAJvrw/VMcFQgZNQYIABkoBGJib3gEeW1heBUMFoCr + ExbQsE0W9IwyJvrw/VM8GARIADTCGASuX0jCFgAoBEgANMIYBK5fSMIAGRwVABUAFRAAABasn+f/ + BxXiARbQvaf/BxXWAQAmrv6vVBwVAhk1BggEGRgHdmVyc2lvbhUMFoCrExb+BBagBiau/q9UJu79 + r1QcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWjqHn/wcVwgEW + pr+n/wcV1gEAJs6EsFQcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBaA + qxMW/gUWoAcmzoSwVCaOhLBUHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW0KLn/wcVwgEW + /MCn/wcVVgAm8oywVBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWgKsT + FsTEBBa29QIm8oywVCaui7BUHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGlu + Z3MAGSwVBBUEFQIAFQAVBBUQAAAWkqTn/wcV0gEW0sGn/wcV9gQAJuSAs1QcFQwZJQYAGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWgKsTFoL34QIW6N2IASbkgLNUPDYAKAx3OTk1 + MDM1MTE0QDEYDDAwMDA3OWU1MDMzYgAZHBUAFQAVEAAAFuSl5/8HFeIBFsjGp/8HFdYDACam6rxV + HBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWgKsTFu7XGRbOugcm + puq8VSbM3rtVHDYAKBgyMDI0LTExLTEwVDIzOjA2OjAzLjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6 + MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABbGp+f/BxXUARaeyqf/BxXWBgAmor3FVRwVChklBgQZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWgKsTFvKvIxaW+iAmor3FVSaamcNV + HBgIAAAAAAAA8D8YCAAAAOBNYuA/FpqjASgIAAAAAAAA8D8YCAAAAOBNYuA/ABksFQQVBBUCABUA + FQQVEAAAFpqp5/8HFeIBFvTQp/8HFeYCACaAlORVHBUCGTUGCAQZGAVsZXZlbBUMFoCrExauBhbQ + ByaAlORVJrCT5FUcGAQCAAAAGAT/////FtSqEygEAgAAABgE/////wAZLBUEFQQVAgAVABUEFRAA + ABb8quf/BxXGARba06f/BxXWAQAmrJ3kVRwVDBk1BggEGRgHc3VidHlwZRUMFoCrExbqKhaYJias + neRVJoCb5FUcNs6IEygOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUE + FRAAABbCrOf/BxXSARaw1af/BxXuAwAm8MXkVRwVDBk1BggEGRgFY2xhc3MVDBaAqxMWziwWsicm + 8MXkVSaYweRVHDbuiRMoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABaU + ruf/BxXSARae2af/BxX0AgAmtunkVRwVChk1BggEGRgGaGVpZ2h0FQwWgKsTFv4FFvQGJrbp5FUm + yujkVRwYCAAAAAAAAC5AGAgAAAAAAAAIQBbuqhMoCAAAAAAAAC5AGAgAAAAAAAAIQAAZLBUEFQQV + AgAVABUEFRAAABbmr+f/BxXCARaS3Kf/BxWWAgAmypvlVRwVDBk1BggEGSgFbmFtZXMHcHJpbWFy + eRUMFoCrExbgbxaCRCbKm+VVJr7v5FUcNtKmEygTc2FuIGxvcmVuem8gc2hlbHRlchghMcK6IEFs + aWFuemEgQ3Jpc3RpYW5hIHkgTWlzaW9uZXJhABksFQQVBBUCABUAFQQVEAAAFqix5/8HFdIBFqje + p/8HFawFACbAs+VVHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWiKsTFu4W + FrYTJsCz5VU8NuyqEygCZnIYAmVuABkcFQAVABUQAAAW+rLn/wcV0gEW1OOn/wcVpgEAJvbG5VUc + FQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFoirExakHBaKFyb2xuVVPDbs + qhMoClN0YXRlIEJhbmsYDkFsIHN1ciBkZWwgc3VyABkcFQAVABUQAAAWzLTn/wcV0gEW+uSn/wcV + rAMAJvze5VUcFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaOqxMW + 8BkWnBUm/N7lVSaA3uVVHDbsqhMoBXNob3J0GAlhbHRlcm5hdGUAGSwVBBUEFQIAFQAVBBUQAAAW + nrbn/wcV0gEWpuin/wcVuAIAJpzz5VUcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + CGxhbmd1YWdlFQwWjqsTFp4ZFqAUJpzz5VU8NoKrEygCZXMYAmVuABkcFQAVABUQAAAW8Lfn/wcV + 0gEW3uqn/wcVjgEAJpyL5lUcFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVl + FQwWjqsTFqAeFoYYJpyL5lUmvIfmVRw27KoTKBRTdXBlcm1lcmNhZG8gTGxvcmVkYRgfQmFuY28g + ZGUgQ3LDqWRpdG8gZSBJbnZlcnNpb25lcwAZLBUEFQQVAgAVABUEFRAAABbCuef/BxXSARbs66f/ + BxWOBQAmwp/mVRwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0 + B2VsZW1lbnQVDBaOqxMW3hgW9BMmwp/mVTw2jqsTABkcFQAVABUQAAAWlLvn/wcV0gEW+vCn/wcV + dgAmtrPmVRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFo6rExbWGBb2 + Eya2s+ZVPDaOqxMAGRwVABUAFRAAABbmvOf/BxXSARbw8af/BxV2ACasx+ZVHBUAGTUGCAAZGAlo + YXNfcGFydHMVDBaAqxMW0LkCFroGJqzH5lU8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABa4vuf/ + BxXCARbm8qf/BxV2ACbmzeZVHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFoCrExbQuQIWsAYm + 5s3mVTwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFvq/5/8HFcIBFtzzp/8HFXYAJobV5lUcFQIZ + NQYIBBkYCm51bV9mbG9vcnMVDBaAqxMW4BEW8BEmhtXmVSaW1OZVHBgECgAAABgEAQAAABbQlhMo + BAoAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWvMHn/wcVzgEW0vSn/wcV9gEAJobm5lUcFQIZ + NQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaAqxMWkAQWoAUmhubmVTw2gKsTABkcFQAV + ABUQAAAWisPn/wcVwgEWyPan/wcVdgAmpuvmVRwVChk1BggAGRgKbWluX2hlaWdodBUMFoCrExaQ + BBagBSam6+ZVPDaAqxMAGRwVABUAFRAAABbMxOf/BxXCARa+96f/BxV2ACbG8OZVHBUCGTUGCAAZ + GAltaW5fZmxvb3IVDBaAqxMWkAQWoAUmxvDmVTw2gKsTABkcFQAVABUQAAAWjsbn/wcVwgEWtPin + /wcVdgAm5vXmVRwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWgKsTFpAFFqAGJub15lU8NviqEygH + I0ZGMDAwMBgHIzAwODAwMAAZHBUAFQAVEAAAFtDH5/8HFcIBFqr5p/8HFeYBACaG/OZVHBUMGTUG + CAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBaAqxMWiLEBFvwKJob85lU8NsCbEygEd29vZBgIY29uY3Jl + dGUAGRwVABUAFRAAABaSyef/BxXIARaQ+6f/BxW2AQAmgofnVRwVDBk1BggAGRgNcm9vZl9tYXRl + cmlhbBUMFoCrExbSBha6BiaCh+dVPBgFbWV0YWwYBW1ldGFsFuaqEygFbWV0YWwYBW1ldGFsABkc + FQAVABUQAAAW2srn/wcVxgEWxvyn/wcVngEAJryN51UcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaA + qxMW2KQBFvAKJryN51U8NrCbEygIc2tpbGxpb24YBmdhYmxlZAAZHBUAFQAVEAAAFqDM5/8HFcgB + FuT9p/8HFdwBACasmOdVHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFoCrExaQBBagBSasmOdV + PDaAqxMAGRwVABUAFRAAABbozef/BxXCARbA/6f/BxV2ACbMnedVHBUMGTUGCAAZGBByb29mX29y + aWVudGF0aW9uFQwWgKsTFpAEFqAFJsyd51U8NoCrEwAZHBUAFQAVEAAAFqrP5/8HFcIBFraAqP8H + FXYAJuyi51UcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBaAqxMW6LMBFuwOJuyi51U8NrSbEygHI0ZG + RkYwMBgHIzAwMDAwMAAZHBUAFQAVEAAAFuzQ5/8HFcgBFqyBqP8HFcoBACbYsedVHBUKGTUGCAAZ + GAtyb29mX2hlaWdodBUMFoCrExaQBBagBSbYsedVPDaAqxMAGRwVABUAFRAAABa00uf/BxXCARb2 + gqj/BxV2ABaeue0aFoCrEyb6m/BHFv6a9w0UCgAZ/CYm+LbnVRwVDBk1BggAGRgCaWQVDBaolxMW + 8MuyBRaq8csBJvi251U8NgAoIDA4YmNmOWViYjZjOTVmZmYwMjAwMjVmMDM1ZjI1NDIzGCAwOGJj + ZWE0ODIyMGUyZmZmMDIwMGI2OTc2NDRhNWUwYQAZHBUAFQAVEAAAFvbT5/8HFeIBFuyDqP8HFdYI + ACaiqLNXHBUMGTUGCAAZGAhnZW9tZXRyeRUMFqiXExbW+IgQFpjevgkmoqizVzw2ACiBCgAAAAAG + AAAACAAAAAADAAAAAQAAAAfAUObcuGe6+sBHSGlZX+2mwFDm3P9J95vAR0htM+ABXcBQ5twdN0hs + wEdIbVLpseDAUObcEDau6cBHSGycCo0iwFDm2ewEoHnAR0hs5rMn4MBQ5tmyjl0lwEdIacI7eVPA + UObcuGe6+sBHSGlZX+2mAAAAAAMAAAABAAAACcBQ5uceHEq5wEdIawsQ1TrAUObm9dhe0cBHSGik + LkgSwFDm6Vt4zJrAR0hoWK7tv8BQ5umCepkjwEdIaq+hQtvAUOboyKvV3MBHSGrGR3eOwFDm6NCj + 8eLAR0hrPjx7scBQ5uhX2C4qwEdIa01V9CjAUOboUSIxg8BHSGrlUSgRwFDm5x4cSrnAR0hrCxDV + OgAAAAADAAAAAQAAAA/AUObqzdQzycBHSGK1AP4twFDm7Utc9aTAR0hiX3Co4MBQ5u1moEgKwEdI + Y9xIatPAUObswco6S8BHSGPy7p+FwFDm7POzwWPAR0hmsryATsBQ5u0ha4qTwEdIZqzdQz3AUObt + UTwytsBHSGlL8/RZwFDm7QucFXXAR0hpVgTvU8BQ5u0rfIWNwEdIaxN0UQvAUObp8F6iTcBHSGuD + BdlewFDm6cMSOOjAR0hpCAFWQcBQ5umZIM3WwEdIZr56+nLAUObpblijL8BHSGRhqWhEwFDm6ukX + hi/AR0hkLn3BzcBQ5urN1DPJwEdIYrUA/i0AAAAAAwAAAAEAAAAOwFDm5LytmtjAR0hdPPH41sBQ + 5uR8gVrewEdIWbmvuZfAUOblmbfMi8BHSFmT8AxtwFDm5bY9Pk/AR0hbKETCqMBQ5uW88zr2wEdI + W4SLFJzAUObnpSrHVMBHSFtCRfWuwFDm58IbmOPAR0hc1O0sv8BQ5ufmmSatwEdIXtcl7CPAUObm + Nb7+rsBHSF8R3k7VwFDm5kdctePAR0hgBEyV28BQ5uXOJZJhwEdIYBUTjXvAUObl3apqosBHSGDu + V2EQwFDm5QJNuBrAR0hhC7OSacBQ5uS8rZrYwEdIXTzx+NYAAAAAAwAAAAEAAAAFwFDm1U+9rXXA + R0hbv0N3TsBQ5tWaZkgzwEdIX+Hn5wXAUObUUSWMgsBHSGANhtFAwFDm1AZ88cPAR0hb6uJhisBQ + 5tVPva11wEdIW79Dd04AAAAAAwAAAAEAAAAJwFDm1r5StobAR0hhui87V8BQ5tZ3cHnmwEdIXcuN + MazAUObWUANNksBHSFuc3sh4wFDm2CmMwUTAR0hbXfSn3cBQ5thQjo3NwEdIXYyjERLAUObYl3DK + bcBHSGF7RRq8wFDm2LiTWeTAR0hjUQgwUMBQ5tbfdUX9wEdIY4/yUOvAUObWvlK2hsBHSGG6LztX + AAAAAAMAAAABAAAACcBQ5tAk24GbwEdIX5CJT5/AUObQm/nGKsBHSGY9S7rpwFDmz4oWbtfAR0hm + YV3o6cBQ5s9doMUHwEdIY+Sr5qPAUObMSsbNr8BHSGRMsLK7wFDmzA31jAnAR0hg6U7jk8BQ5s8g + z4NgwEdIYIFKF3vAUObPEozKfsBHSF+0m32fwFDm0CTbgZvAR0hfkIlPnwAAAAADAAAAAQAAAAXA + UObRONe34sBHSG8CFlq1wFDm0Q04zafAR0hsk6cRUcBQ5tMUegqIwEdIbE0wNHvAUObTQO+0WMBH + SG68dj10wFDm0TjXt+LAR0hvAhZatRhNAAAAAAMAAAABAAAABMBQ4QMRl9f4wEc5YIV71WPAUOEE + 6XPMgMBHOV5l5uSmwFDhBGQSzxDARzljFXkOCcBQ4QMRl9f4wEc5YIV71WMAGRwVABUAFSQAABbY + 1ef/BxX8AxbCjKj/BxWuJQAmuobyYBwVCBk1BggAGSgEYmJveAR4bWluFQwWqJcTFvDhTBaszS0m + uobyYDwYBAgAh8IYBPrXkMIWACgECACHwhgE+teQwgAZHBUAFQAVEAAAFtTZ5/8HFeIBFvCxqP8H + FdYBACbm059hHBUIGTUGCAAZKARiYm94BHhtYXgVDBaolxMW8OFMFojGLSbm059hPBgE5f+GwhgE + 8NeQwhYAKATl/4bCGATw15DCABkcFQAVABUQAAAWttvn/wcV4gEWxrOo/wcV1gEAJu6ZzWEcFQgZ + NQYIABkoBGJib3gEeW1pbhUMFqiXExbu4UwWkvIuJu6ZzWE8GAQMADTCGAT/Pz/CFgAoBAwANMIY + BP8/P8IAGRwVABUAFRAAABaY3ef/BxXiARactaj/BxXWAQAmgIz8YRwVCBk1BggAGSgEYmJveAR5 + bWF4FQwWqJcTFvDhTBb0ji8mgIz8YTwYBPn/M8IYBPM/P8IWACgE+f8zwhgE8z8/wgAZHBUAFQAV + EAAAFvre5/8HFeIBFvK2qP8HFdYBACa0m6tiHBUCGTUGCAQZGAd2ZXJzaW9uFQwWqJcTFv4EFqAG + JrSbq2Im9JqrYhwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbc + 4Of/BxXCARbIuKj/BxXWAQAm1KGrYhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9w + ZXJ0eRUMFqiXExb+BRagBybUoatiJpShq2IcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABae + 4uf/BxXCARaeuqj/BxVWACb4qatiHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFz + ZXQVDBaolxMWvNcDFv65Aib4qatiJrSoq2IcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVu + IEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbg4+f/BxXSARb0uqj/BxX2BAAmsuKtYhwVDBkl + BgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaolxMWvqzqAhaWv3smsuKtYjw2 + ACgMdzk5NDkwODM1NEAyGAwwMDAwZmFmNDcyZjMAGRwVABUAFRAAABay5ef/BxXiARbqv6j/BxXe + AwAm3saqYxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFqiXExak + zxYWys4HJt7GqmMmyKGpYxw2ACgYMjAyNC0xMS0yNFQyMzo0MjoxNS4wMDBaGBgyMDExLTAyLTEy + VDEwOjA2OjU2LjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWlOfn/wcV1gEWyMOo/wcV1gYAJsqUs2Mc + FQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFqiXExa8niIWlNofJsqU + s2MmkvCwYxwYCAAAAAAAAPA/GAgAAABg9+TdPxbo7wEoCAAAAAAAAPA/GAgAAABg9+TdPwAZLBUE + FQQVAgAVABUEFRAAABbq6Of/BxXiARaeyqj/BxXmAgAm7srQYxwVAhk1BggEGRgFbGV2ZWwVDBao + lxMWrAUWzgYm7srQYyamytBjHBgEAgAAABgEAQAAABaYlxMoBAIAAAAYBAEAAAAAGSwVBBUEFQIA + FQAVBBUQAAAWzOrn/wcVwgEWhM2o/wcVxgEAJpTT0GMcFQwZNQYIBBkYB3N1YnR5cGUVDBaolxMW + nBkW3hcmlNPQYyb00NBjHDaejBMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUE + FQIAFQAVBBUQAAAWjuzn/wcV0gEWys6o/wcVhAMAJoDs0GMcFQwZNQYIBBkYBWNsYXNzFQwWqJcT + FtYYFp4XJoDs0GMm0ujQYxw28IwTKAl3YXJlaG91c2UYBGJhcm4AGSwVBBUEFQIAFQAVBBUQAAAW + 4O3n/wcV0gEWztGo/wcVmgMAJvD/0GMcFQoZNQYIABkYBmhlaWdodBUMFqiXExa6ExaiCSbw/9Bj + PBgIAAAAAAAANEAYCAAAAAAAAPg/FtSVEygIAAAAAAAANEAYCAAAAAAAAPg/ABkcFQAVABUQAAAW + su/n/wcVygEW6NSo/wcV9gEAJpKJ0WMcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaolxMWmGYW + 2EUmkonRYzw2spMTKBdhdXRvc2VydmljaW8gbGEgZXNxdWluYRgEMjAwMwAZHBUAFQAVEAAAFvzw + 5/8HFdIBFt7WqP8HFYgFACbqztFjHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5 + FQwWqpcTFpQVFvwRJurO0WM8NqCXEygCZXMYAmVuABkcFQAVABUQAAAWzvLn/wcV0gEW5tuo/wcV + jgEAJubg0WMcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFqqXExaEGRbc + Eybm4NFjPDaglxMoEFRpZW5kYSBIb29saWdhbnMYCUJhbG1hY2VkYQAZHBUAFQAVEAAAFqD05/8H + FdIBFvTcqP8HFaICACbC9NFjHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJp + YW50FQwWrJcTFoIZFowTJsL00WM8Np6XEygIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAA + FvL15/8HFdIBFpbfqP8HFbwBACbOh9JjHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVu + dAhsYW5ndWFnZRUMFqyXExbqFxbOEibOh9JjPDaolxMoAmVzGAJlbgAZHBUAFQAVEAAAFsT35/8H + FdIBFtLgqP8HFX4AJpya0mMcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVl + FQwWrJcTFvwaFvgUJpya0mM8Np6XEygNU2F0dXJubyBIb2dhchgNQkJWQSBGcmFuY8OpcwAZHBUA + FQAVEAAAFpb55/8HFdIBFtDhqP8HFfoCACaUr9JjHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFqyXExbUFxa4EiaUr9JjPDaslxMAGRwVABUA + FRAAABbo+uf/BxXSARbK5Kj/BxV2ACbMwdJjHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudARzaWRlFQwWrJcTFtAXFrISJszB0mM8NqyXEwAZHBUAFQAVEAAAFrr85/8HFdIBFsDlqP8H + FXYAJv7T0mMcFQAZNQYIABkYCWhhc19wYXJ0cxUMFqiXExaWtwIWtAYm/tPSYzwYAQEYAQAWACgB + ARgBAAAZHBUAFQAVEAAAFoz+5/8HFcIBFrbmqP8HFXYAJrLa0mMcFQAZNQYIABkYDmlzX3VuZGVy + Z3JvdW5kFQwWqJcTFpa3AhawBiay2tJjPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWzv/n/wcV + wgEWrOeo/wcVdgAm4uDSYxwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFqiXExa8BRbMBibi4NJjPBgE + AwAAABgEAQAAABaUlxMoBAMAAAAYBAEAAAAAGRwVABUAFRAAABaQgej/BxXGARai6Kj/BxXGAQAm + rufSYxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFqiXExaQBBagBSau59JjPDao + lxMAGRwVABUAFRAAABbWguj/BxXCARbo6aj/BxV2ACbO7NJjHBUKGTUGCAAZGAptaW5faGVpZ2h0 + FQwWqJcTFpAEFqAFJs7s0mM8NqiXEwAZHBUAFQAVEAAAFpiE6P8HFcIBFt7qqP8HFXYAJu7x0mMc + FQIZNQYIABkYCW1pbl9mbG9vchUMFqiXExaQBBagBSbu8dJjPDaolxMAGRwVABUAFRAAABbahej/ + BxXCARbU66j/BxV2ACaO99JjHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBaolxMWkAQWoAUmjvfS + Yzw2qJcTABkcFQAVABUQAAAWnIfo/wcVwgEWyuyo/wcVdgAmrvzSYxwVDBk1BggAGRgPZmFjYWRl + X21hdGVyaWFsFQwWqJcTFpAEFqAFJq780mM8NqiXEwAZHBUAFQAVEAAAFt6I6P8HFcIBFsDtqP8H + FXYAJs6B02McFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaolxMWkAQWoAUmzoHTYzw2qJcTABkc + FQAVABUQAAAWoIro/wcVwgEWtu6o/wcVdgAm7obTYxwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFqiX + ExaQBBagBSbuhtNjPDaolxMAGRwVABUAFRAAABbii+j/BxXCARas76j/BxV2ACaOjNNjHBUKGTUG + CAAZGA5yb29mX2RpcmVjdGlvbhUMFqiXExaQBBagBSaOjNNjPDaolxMAGRwVABUAFRAAABakjej/ + BxXCARai8Kj/BxV2ACaukdNjHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWqJcTFpAEFqAF + Jq6R02M8NqiXEwAZHBUAFQAVEAAAFuaO6P8HFcIBFpjxqP8HFXYAJs6W02McFQwZNQYIABkYCnJv + b2ZfY29sb3IVDBaolxMWkAQWoAUmzpbTYzw2qJcTABkcFQAVABUQAAAWqJDo/wcVwgEWjvKo/wcV + dgAm7pvTYxwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBaolxMWkAQWoAUm7pvTYzw2qJcTABkcFQAV + ABUQAAAW6pHo/wcVwgEWhPOo/wcVdgAWhsSdGxaolxMm+LbnVRaW6usNFAwAGfwmJo6h02McFQwZ + NQYIABkYAmlkFQwW4JkVFpik+wUW1rHcASaOodNjPDYAKCAwOGJlZWIzZDY0NzMwZmZmMDIwMGZj + OTA3YTFkZjAyYxggMDhiYjI5YjQwMWMzNmZmZjAyMDA3NmNkNzRjMmYwMmUAGRwVABUAFRIAABas + k+j/BxX+ARb686j/BxXeCQAm5NKvZRwVDBk1BggAGRgIZ2VvbWV0cnkVDBbgmRUW7uK4ERaI6Z4K + JuTSr2U8NgAosRgAAAAABgAAABgAAAAAAwAAAAEAAAAFwFDgsLK60s/ARvGg7vhwwMBQ4K8L8aXK + wEbxoh3MmaHAUOCui5kl1sBG8aDCgsbvwFDgsDJiUtvARvGfk66eDsBQ4LCyutLPwEbxoO74cMAA + AAAAAwAAAAEAAAAFwFDgrxbZYFnARvGloQ7Y4cBQ4K50HDGPwEbxo+2wciPAUOCwNb1RL8BG8aKo + NhSPwFDgsNh6f/nARvGkWr27uMBQ4K8W2WBZwEbxpaEO2OEAAAAAAwAAAAEAAAAHwFDgrBWdIDfA + RvGjwuhHfcBQ4KtWWn+owEbxoZ8hmNfAUOCt8oGSPMBG8Z/b0voNwFDgrk5chGXARvGg5BC2McBQ + 4K10rVEHwEbxoXbdrO/AUOCt16mfocBG8aKTPV8GwFDgrBWdIDfARvGjwuhHfQAAAAADAAAAAQAA + AAXAUOCop1OWgMBG8YnF5v9+wFDgqUXfB2LARvGLjWdcMMBQ4KeYX922wEbxjK+mS1nAUOCm+dRs + 1MBG8YroJe6nwFDgqKdTloDARvGJxeb/fgAAAAADAAAAAQAAAAnAUOCgBO2lisBG8ZHOyf0PwFDg + n3ZSbLTARvGQNkOI7MBQ4KCPwoBDwEbxj3iuZ4fAUOCgUNhfqMBG8Y7FKkEcwFDgokkAJBLARvGN + cJZrEcBQ4KKwLjCVwEbxjSofjjvAUOCjfUgqO8BG8Y92KijIwFDgoUahpQHARvGQ9YYpesBQ4KAE + 7aWKwEbxkc7J/Q8AAAAAAwAAAAEAAAAHwFDgqJuVHFzARvGIEbHZK8BQ4KXsjjM0wEbxieJscULA + UOClfPyq4cBG8Yii0VDAwFDgpu0/MxzARvGHqa0NFMBQ4KZYWV1pwEbxhf+I4bvAUOCnkNMhe8BG + 8YUsJEs5wFDgqJuVHFzARvGIEbHZKwAAAAADAAAAAQAAAAbAUOCnEbzA5sBG8Y0LFd24wFDgp+yu + E6TARvGPfo2kmcBQ4KbCdwh1wEbxkEfhQCHAUOCl54W1t8BG8Y3UaXlAwFDgplZAfnXARvGNicDe + gsBQ4KcRvMDmwEbxjQsV3bgAAAAAAwAAAAEAAAAHwFDgo9QanujARvGSNs7JJsBQ4KQ89iqUwEbx + k2Mes0nAUOCiNvcNEsBG8ZTJUECKwFDgoXJAjzzARvGSlMKaRMBQ4KHEdeY2wEbxkl1lNeXAUOCj + eliLssBG8ZE1RwmqwFDgo9QanujARvGSNs7JJgAAAAADAAAAAQAAAAXAUOCowH4J8cBG8ZwTx10h + wFDgptElISLARvGdYnv2G8BQ4KXHOeXVwEbxmmjMcjTAUOCntpLOpMBG8ZkaF9k7wFDgqMB+CfHA + RvGcE8ddIQAAAAADAAAAAQAAAAbAUOCnmTadS8BG8aEO2ODXwFDgpqG/2MnARvGeSFUDaMBQ4Kl/ + VUq1wEbxnFe5+znAUOCqdzdvAsBG8Z8ePdipwFDgqcurZJ3ARvGfktfeecBQ4KeZNp1LwEbxoQ7Y + 4NcAAAAAAwAAAAEAAAAFwFDgqxuiHPbARvGmrlUSgcBQ4KgFbSdLwEbxqMPZCETAUOCnMMZxacBG + 8aZhKDkEwFDgqkYkp3/ARvGkSs2DrMBQ4Ksbohz2wEbxpq5VEoEAAAAAAwAAAAEAAAAIwFDgqzCa + 0n/ARvGpJf6XSsBQ4KrZXP4IwEbxqWC2+f3AUOCpJ6wWdMBG8aqGUOd5wFDgqLYBry3ARvGpPykK + u8BQ4KpRd8HYwEbxqCiolbbAUOCqhKNoT8BG8ai8TEwJwFDgqvGwseTARvGocnpw38BQ4KswmtJ/ + wEbxqSX+l0oAAAAAAwAAAAEAAAAMwFDgriRrGVTARvGxlTjhycBQ4K53C9AYwEbxsrd30PLAUOCs + gj8KAcBG8bPyCnP3wFDgrCoqdfXARvGy4j/7mcBQ4KvYy96QwEbxsxVrohDAUOCrkemh8MBG8bI6 + ek9RwFDgq/pZzdLARvGx+Qvv+MBQ4KvMNqTYwEbxsWmZ943AUOCrXRB8T8BG8bGwENRkwFDgquFV + Gg7ARvGwMYuTR8BQ4K1PxGNywEbxrqqi1lnAUOCuJGsZVMBG8bGVOOHJAAAAAAMAAAABAAAACcBQ + 4LBg8NugwEbxsBNYolnAUOCvQuOqX8BG8aze8Lu/wFDgsdXQgY3ARvGrIYFaCMBQ4LLFuonUwEbx + rdI1wlrAUOCzAbUL5sBG8a59Vmz0wFDgsk9zBNrARvGu8scyWcBQ4LJnW1jswEbxrzk+Dy/AUOCw + hCxKC8BG8bB4AnAdwFDgsGDw26DARvGwE1iiWQAAAAADAAAAAQAAAAXAUOCzt71xD8BG8acAiml7 + wFDgtIsiB5LARvGpTWvDncBQ4LO8xe6MwEbxqdir/iDAUOCy7mnVh8BG8aeIb6WqwFDgs7e9cQ/A + RvGnAIppewAAAAADAAAAAQAAAA3AUOCxtEKSTMBG8ahcqvvCwFDgrnSHkVnARvGqj4si3sBQ4K3d + 9Dx9wEbxqOBeegnAUOCvUz9CNcBG8afj3zgJwFDgrx0j/TXARvGnR9gF5sBQ4LC27JC3wEbxpjMF + EArAUOCwfeGtL8BG8aWQR+FAwFDgsmdbWOzARvGkRcUGL8BQ4LM0dVKSwEbxppKmYFHAUOCx8sFT + HMBG8adswPN7wFDgsa7OtQTARvGmqUyVBMBQ4LE4hzALwEbxpvnUbNTAUOCxtEKSTMBG8ahcqvvC + AAAAAAMAAAABAAAACcBQ4K69gqzuwEbxpr/yybfAUOCtbs4T9cBG8aehmhkbwFDgrQWHKH7ARvGm + c5yvz8BQ4Ky4xa7LwEbxpZb93efAUOCsWLj+usBG8aSD2Gc1wFDgrhVRoN3ARvGjV4h9EsBQ4K7M + nCVlwEbxpWPSN3DAUOCuXky8ccBG8aWuetIuwFDgrr2CrO7ARvGmv/LJtwAAAAADAAAAAQAAAAXA + UOCxj8UEgcBG8aD9OymiwFDgsfA9FF7ARvGiD4ngv8BQ4LEH38hSwEbxoq0+kgzAUOCwp9MYQMBG + 8aGa79rvwFDgsY/FBIHARvGg/TspogAAAAADAAAAAQAAAAXAUOCtH4hbhMBG8Z1UOT04wFDgrF6Y + O8zARvGbLe5P1MBQ4K7epTxlwEbxmXqP6RfAUOCvn5VcHcBG8Zug2tZ7wFDgrR+IW4TARvGdVDk9 + OAAAAAADAAAAAQAAAAjAUOCsqu5VtMBG8ZozHIz/wFDgqw94QwjARvGbSZ0CBMBQ4KrCS2mLwEbx + m32faBDAUOCqA9+IkcBG8ZlcXPgpwFDgq2UImFXARvGYbUmvdsBQ4Kum4ld5wEbxmSu1kHDAUOCs + LseTqMBG8ZjPbz58wFDgrKruVbTARvGaMxyM/wAAAAADAAAAAQAAAAbAUOCo0ALiM8BG8ZSomRDe + wFDgqOQk2CfARvGU4M000sBQ4KlF3wdiwEbxlfPyq4TAUOCoD+mCD8BG8ZbJBMEwwFDgp5oNXODA + RvGVfasmisBQ4KjQAuIzwEbxlKiZEN4AAAAAAwAAAAEAAAAGwFDgqjcLLwjARvGXaT2xO8BQ4Km8 + /UvxwEbxl7tzCDXAUOCo67GUYsBG8ZhJN4F3wFDgqG1x82LARvGW3tQ2TsBQ4Km4y44IwEbxlf7a + ZhPAUOCqNwsvCMBG8ZdpPbE7AAAAAAMAAAABAAAACcBQ4KrgEvqvwEbxlvcn6irAUOCqepJtVcBG + 8ZXUEjtswFDgqgtsRM3ARvGWHrrWKsBQ4KmiJVlWwEbxlPGULHLAUOCrr0XTScBG8ZON5t3wwFDg + q/H2UgHARvGUTgA+E8BQ4Kxsb5TjwEbxk/r0J4XAUOCs+IaO+8BG8ZWMxJ8BwFDgquAS+q/ARvGW + 9yfqKgAAAAADAAAAAQAAAA3AUOCmm+Cbt8BG8ZQK5F+RwFDgpfQa73DARvGSNSFJ/cBQ4Kg00m+k + wEbxkKT+UarAUOCoc7yQP8BG8ZFV/jlWwFDgqz4Gy8zARvGPZjnwvcBQ4KxFAmiQwEbxkkURggnA + UOCpO2KsnsBG8ZRgdLTewFDgqQRwqAnARvGTxvHBecBQ4KhG24akwEbxlEnOgCvAUOCoHVV7XcBG + 8ZPWCznwwFDgp32H6xvARvGURZzCQ8BQ4Kc/3+ngwEbxk5jOmH/AUOCmm+Cbt8BG8ZQK5F+RGE0A + AAAAAwAAAAEAAAAEwFADP6OD/ifAUDGTCcf/3sBQAzkPFUa5wFAxke+BLLvAUAM+CVAK2sBQMZAF + MMFpwFADP6OD/ifAUDGTCcf/3gAZHBUAFQAVKAAAFqqV6P8HFbQEFtj9qP8HFb4pACaO5ulvHBUI + GTUGCAQZKARiYm94BHhtaW4VDBbgmRUW4PVMFtC2QiaO5ulvJuy7zm8cGASXsjTAGASLp6HCFgAo + BJeyNMAYBIunocIAGSwVBBUEFQIAFQAVBBUSAAAW3pno/wcV/gEWlqep/wcV7gEAJsSZrHAcFQgZ + NQYIBBkoBGJib3gEeG1heBUMFuCZFRaA8kwWzLJCJsSZrHAmvPKQcBwYBL6rNMAYBIGnocIWACgE + vqs0wBgEgaehwgAZLBUEFQQVAgAVABUEFRIAABbcm+j/BxX+ARaEqan/BxXuAQAmqrzycBwVCBk1 + BggEGSgEYmJveAR5bWluFQwW4JkVFojrUhaCiEgmqrzycCaIpdNwHBgEew0HwhgEt7+bwhYAKAR7 + DQfCGAS3v5vCABksFQQVBBUCABUAFQQVEgAAFtqd6P8HFf4BFvKqqf8HFe4BACa8yrpxHBUIGTUG + CAQZKARiYm94BHltYXgVDBbgmRUW0vNSFoaPSCa8yrpxJoqtm3EcGARsDQfCGASsv5vCFgAoBGwN + B8IYBKy/m8IAGSwVBBUEFQIAFQAVBBUSAAAW2J/o/wcV/gEW4Kyp/wcV7gEAJtC843EcFQIZNQYI + BBkYB3ZlcnNpb24VDBbgmRUWyAUW/AYm0LzjcSaQvONxHBgEAAAAABgEAAAAABYAKAQAAAAAGAQA + AAAAABksFQQVBBUCABUAFQQVEgAAFtah6P8HFdoBFs6uqf8HFe4BACbMw+NxHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW4JkVFtgGFowIJszD43EmjMPjcRwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVEgAAFrCj6P8HFdoBFrywqf8HFV4AJtzM43EcFQwZJQYEGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFuCZFRbS5QEWzKUBJtzM43EmmMvjcRw2ACgNT3Bl + blN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEgAAFoql6P8H + FewBFpqxqf8HFcIFACbk8ORxHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9p + ZBUMFuCZFRaCoKkDFtDhcibk8ORxPDYAKAx3OTk5OTA1NTA2QDEYDDAwMDI3OGE4NTgxZgAZHBUA + FQAVEgAAFvam6P8HFf4BFty2qf8HFcAEACb6pNlyHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVt + ZW50C3VwZGF0ZV90aW1lFQwW4JkVFpKyDxamtQUm+qTZcia00tdyHDYAKBgyMDI0LTExLTI5VDEw + OjUzOjM4LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRIAABb0 + qOj/BxXuARacu6n/BxW+BwAmvJHfchwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25m + aWRlbmNlFQwW4JkVFqrMJBbEiSImvJHfcibah91yHBgIAAAAAAAA8D8YCAAAAMDlP9w/FqDpASgI + AAAAAAAA8D8YCAAAAMDlP9w/ABksFQQVBBUCABUAFQQVEgAAFuKq6P8HFf4BFtrCqf8HFY4DACbu + kf9yHBUCGTUGCAQZGAVsZXZlbBUMFuCZFRaIBxa8CCbukf9yJp6R/3IcGAQCAAAAGAT/////FqSZ + FSgEAgAAABgE/////wAZLBUEFQQVAgAVABUEFRIAABbgrOj/BxXeARboxan/BxWCAgAmkJz/chwV + DBk1BggEGRgHc3VidHlwZRUMFuCZFRaOJxaaJCaQnP9yJtqZ/3IcNtyDFSgOdHJhbnNwb3J0YXRp + b24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRIAABa+ruj/BxXsARbqx6n/BxWGBAAmisP/ + chwVDBk1BggEGRgFY2xhc3MVDBbgmRUWsCkWziUmisP/cib0vf9yHDaahRUoCXdhcmVob3VzZRgK + YXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRIAABaqsOj/BxXsARbwy6n/BxWyAwAmwuP/chwVChk1 + BggAGRgGaGVpZ2h0FQwW4JkVFpgyFugPJsLj/3I8GAgAAAAAAABEQBgIAAAAAAAA8D8W6JQVKAgA + AAAAAABEQBgIAAAAAAAA8D8AGRwVABUAFRIAABaWsuj/BxXkARaiz6n/BxWiAgAmqvP/chwVDBk1 + BggAGSgFbmFtZXMHcHJpbWFyeRUMFuCZFRb85wEW1I4BJqrz/3I8NviPFSgP7Lih7KeA6rSA7Lih + 64+ZGAM3MTMAGRwVABUAFRIAABb6s+j/BxXsARbE0an/BxXsBAAm/oGBcxwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFqibFRaKMRakGyb+gYFzPDbklxUoAnpoGAJkZQAZHBUA + FQAVEgAAFua16P8HFewBFrDWqf8HFaIBACainYFzHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlf + dmFsdWUFdmFsdWUVDBaomxUW1mcW5EQmop2Bczw25JcVKAzsg53tmZzqtIDrj5kYCEFiYXR0b2ly + ABkcFQAVABUSAAAW0rfo/wcV7AEW0tep/wcVyAMAJobigXMcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbqmRUWoicWrhomhuKBczw2mJkVKAhvZmZpY2lhbBgJYWx0 + ZXJuYXRlABkcFQAVABUSAAAWvrno/wcV7AEWmtup/wcV0gIAJrT8gXMcFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW6pkVFtYfFtYYJrT8gXM8Nt6ZFSgCcnUYAmVu + ABkcFQAVABUSAAAWqrvo/wcV7AEW7N2p/wcVmgEAJoqVgnMcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50BXZhbHVlFQwW6pkVFo4xFvglJoqVgnM8NpiZFSgb0KDRg9GB0LrQsNGC0LAg + 0LHQsNGA0LDQutCwGCZBc29jaWFjacOzbiBkZSBEb2NlbnRlcyBVbml2ZXJzaXRhcmlvcwAZHBUA + FQAVEgAAFpa96P8HFewBFobfqf8HFcoFACaCu4JzHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFuqZFRaWHxauGCaCu4JzPDbqmRUAGRwVABUA + FRIAABaCv+j/BxXsARbQ5Kn/BxWCAQAmsNOCcxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQEc2lkZRUMFuqZFRaOHxakGCaw04JzPDbqmRUAGRwVABUAFRIAABbuwOj/BxXsARbS5an/ + BxWCAQAm1OuCcxwVABk1BggAGRgJaGFzX3BhcnRzFQwW4JkVFoDYAhayBybU64JzPBgBARgBABYA + KAEBGAEAABkcFQAVABUSAAAW2sLo/wcV2gEW1Oap/wcVggEAJobzgnMcFQAZNQYIABkYDmlzX3Vu + ZGVyZ3JvdW5kFQwW4JkVFoDYAhaWByaG84JzPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAWtMTo + /wcV2gEW1uep/wcVggEAJpT7gnMcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbgmRUWrgwWsg0mlPuC + cyac+oJzHBgEDwAAABgEAQAAABbmlRUoBA8AAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUSAAAWjsbo + /wcV5gEW2Oip/wcV8gEAJs6Hg3McFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbg + mRUW0gQW9AUmzoeDczw24JkVABkcFQAVABUSAAAW9Mfo/wcV2gEWyuqp/wcVggEAJsKNg3McFQoZ + NQYIABkYCm1pbl9oZWlnaHQVDBbgmRUW0gQW9AUmwo2Dczw24JkVABkcFQAVABUSAAAWzsno/wcV + 2gEWzOup/wcVggEAJraTg3McFQIZNQYIABkYCW1pbl9mbG9vchUMFuCZFRaEBRaQBia2k4NzPBgE + AQAAABgEAQAAABbWmRUoBAEAAAAYBAEAAAAAGRwVABUAFRIAABaoy+j/BxXaARbO7Kn/BxWSAQAm + xpmDcxwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwW4JkVFvAMFrwHJsaZg3M8NoaZFSgHI0ZGNDUw + MBgHIzAwMDAwMAAZHBUAFQAVEgAAFoLN6P8HFd4BFuDtqf8HFdYBACaCoYNzHBUMGTUGCAAZGA9m + YWNhZGVfbWF0ZXJpYWwVDBbgmRUW3AUW8gYmgqGDczw21pkVKAR3b29kGAhjb25jcmV0ZQAZHBUA + FQAVEgAAFuDO6P8HFd4BFrbvqf8HFbQBACb0p4NzHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW + 4JkVFvAEFpIGJvSng3M8GAZ0aGF0Y2gYBnRoYXRjaBbemRUoBnRoYXRjaBgGdGhhdGNoABkcFQAV + ABUSAAAWvtDo/wcV2gEW6vCp/wcVmgEAJoaug3McFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBbgmRUW + 9AgWjAgmhq6Dczw2spkVKAhza2lsbGlvbhgGZ2FibGVkABkcFQAVABUSAAAWmNLo/wcV4AEWhPKp + /wcVzAEAJpK2g3McFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW4JkVFvwEFp4GJpK2g3M8GAgA + AAAAAMBsQBgIAAAAAADAbEAW3JkVKAgAAAAAAMBsQBgIAAAAAADAbEAAGRwVABUAFRIAABb40+j/ + BxXaARbQ86n/BxWiAQAmsLyDcxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFuCZFRbsBBaO + BiawvINzPBgFYWxvbmcYBWFsb25nFt6ZFSgFYWxvbmcYBWFsb25nABkcFQAVABUSAAAW0tXo/wcV + 2gEW8vSp/wcVlgEAJr7Cg3McFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbgmRUWmg4WmggmvsKDczw2 + +pgVKAcjRkY0NTAwGAcjMDAwMDAwABkcFQAVABUSAAAWrNfo/wcV4AEWiPap/wcV1gEAJtjKg3Mc + FQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW4JkVFuwEFo4GJtjKg3M8GAgAAAAAAAAEQBgIAAAAAAAA + BEAW3pkVKAgAAAAAAAAEQBgIAAAAAAAABEAAGRwVABUAFRIAABaM2ej/BxXaARbe96n/BxWiAQAW + yKbeHRbgmRUmjqHTYxbYr7APFA4AGfwmJubQg3McFQwZNQYIABkYAmlkFQwW4PYUFpi48QUWxsTa + ASbm0INzPDYAKCAwOGJjZWFlYmI1ZGE1ZmZmMDIwMDM5MzE1ZDMzNGQ2ORggMDhiY2UxMjY4YjA5 + OGZmZjAyMDAxYTkwYTkxNTE0NzIAGRwVABUAFRIAABbm2uj/BxX+ARaA+an/BxXeCQAmrJXedBwV + DBk1BggAGRgIZ2VvbWV0cnkVDBbg9hQW4qj1EBaatoYKJqyV3nQ8NgAo5QYAAAAAAwAAAAcAAAAS + wFJnp92Umy3ARY4REaA7dMBSZ6f8nkuwwEWOC9Dumn3AUmepDGjED8BFjgveWpPKwFJnqTAPkkTA + RY4F036XtsBSZ6hLeKRXwEWOBciW3SfAUmeodJNP08BFjf7TsBXdwFJnqJHvgS3ARY354CtOYsBS + Z6gGQ+bgwEWN+diekifAUmeoFV1fV8BFjfdRBNVSwFJnqOyIU/fARY33W+yP4cBSZ6j3225QwEWN + 9Wz/BtzAUme6BowLPMBFjfZElVtGwFJnuZg8okjARY4I3R5TqMBSZ7uul1egwEWOCPcfhq7AUme7 + j/kG58BFjg4c+TULwFJnupUnRBLARY4OETq658BSZ7p+Fa+VwEWOEfyBxj7AUmen3ZSbLcBFjhER + oDt0AAAABcBSZ7gzuJQxwEWOALo6IxHAUme3EXmlCMBFjgCm7uyywFJntwJgLJHARY4CkNP4OsBS + Z7gkM7vvwEWOAqQfLpnAUme4M7iUMcBFjgC6OiMRAAAACcBSZ7VM6ObfwEWOAMKdnuLAUme0f2ON + bsBFjgCw/+eswFJntAR+6sLARY4My8BdU8BSZ7T1P7KdwEWODN/iU0fAUme1MTo0r8BFjgb05sdK + wFJntJiOAN/ARY4G6FGNkcBSZ7SmZVn3wEWOBYww+0vAUme1G9YfXMBFjgWWQfZFwFJntUzo5t/A + RY4Awp2e4gAAAAXAUme1fmcOLMBFjfpRalXfwFJntLPRU0TARY36Q/5cksBSZ7SE12q2wEWOABrX + 8pvAUme1T20lncBFjgAoQ+vowFJntX5nDizARY36UWpV3wAAAAXAUmexcf1zXsBFjf3T1dWKwFJn + rKeTV2DARY39f/L/ZsBSZ6ydglxmwEWN/rcqpBjAUmexZ+x4ZMBFjf8LDXo8wFJnsXH9c17ARY39 + 09XVigAAAAXAUmexDiplLsBFjga0TyeGwFJnsEOUqkfARY4Gpgxuo8BSZ7AUmsG4wEWODHzmBKzA + Umew3zB8oMBFjgyKUf36wFJnsQ4qZS7ARY4GtE8nhgAAAAXAUmetME9TJMBFjgYf1LGewFJnrGW5 + mD3ARY4GEmi4UMBSZ6w2v6+uwEWOC+lCTlnAUmetAVVqlsBFjgv2rkenwFJnrTBPUyTARY4GH9Sx + nhhNAAAAAAMAAAABAAAABMBSWlMz+QQ0wEVFo2RaYR7AUlpSy+1EzcBFRaTDsOnzwFJaUh9oxfjA + RUWkU/MamMBSWlMz+QQ0wEVFo2RaYR4AGRwVABUAFSYAABbk3Oj/BxWYBBbegqr/BxW2JwAmxsvk + fhwVCBk1BggAGSgEYmJveAR4bWluFQwW4PYUFpjgUxaCrTEmxsvkfjwYBCVAksIYBCFilMIWACgE + JUCSwhgEIWKUwgAZHBUAFQAVEgAAFvzg6P8HFf4BFpSqqv8HFe4BACbI+JV/HBUIGTUGCAAZKARi + Ym94BHhtYXgVDBbg9hQWmuBTFo6wMSbI+JV/PBgEF0CSwhgEFmKUwhYAKAQXQJLCGAQWYpTCABkc + FQAVABUSAAAW+uLo/wcV/gEWgqyq/wcV7gEAJtiF638cFQgZNQYIBBkoBGJib3gEeW1pbhUMFuD2 + FBaw91sWtIdNJtiF638m1qjHfxwYBEAMKMIYBP+dLMIWACgEQAwowhgE/50swgAZLBUEFQQVAgAV + ABUEFRIAABb45Oj/BxWGAhbwrar/BxXuAQAm3oq4gAEcFQgZNQYIBBkoBGJib3gEeW1heBUMFuD2 + FBaI9VsWgIVNJt6KuIABJoqwlIABHBgEKQwowhgE6Z0swhYAKAQpDCjCGATpnSzCABksFQQVBBUC + ABUAFQQVEgAAFv7m6P8HFZACFt6vqv8HFe4BACbKteGAARwVAhk1BggEGRgHdmVyc2lvbhUMFuD2 + FBbIBRb8BibKteGAASaKteGAARwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAV + ABUEFRIAABaO6ej/BxXsARbMsar/BxXuAQAmxrzhgAEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQIcHJvcGVydHkVDBbg9hQW2AYWjAgmxrzhgAEmhrzhgAEcGAAYABYAKAAYAAAZLBUEFQQV + AgAVABUEFRIAABb66uj/BxXsARa6s6r/BxVeACbWxeGAARwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAdkYXRhc2V0FQwW4PYUFpKNBRb8hgMm1sXhgAEmksThgAEcNgAoDU9wZW5TdHJlZXRN + YXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABbm7Oj/BxX+ARaYtKr/ + BxXCBQAmjsvkgAEcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW4PYU + FrTcmgMWopSIASaOy+SAATw2ACgMdzk5NzQ0MDY1NkAxGAwwMDAwNzcwNWM1YTUAGRwVABUAFRIA + ABbk7uj/BxWQAhbauar/BxWOBAAm1vztgQEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQL + dXBkYXRlX3RpbWUVDBbg9hQWlsQaFq7OBybW/O2BASaw3+yBARw2ACgYMjAyNC0xMS0yNVQyMjoz + NzoyMS4wMDBaGBgyMDExLTAyLTI4VDE2OjQyOjE5LjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAW9PDo + /wcV/gEW6L2q/wcVvgcAJrbK9YEBHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZp + ZGVuY2UVDBbg9hQW3N8gFraJHSa2yvWBASberfSBARwYCC6QoPgx5u4/GAjNzMzMzMzkPxaq5QUo + CC6QoPgx5u4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRIAABby8uj/BxWQAhamxar/BxWQAwAm + lLeRggEcFQIZNQYIABkYBWxldmVsFQwW4PYUFp4GFsAHJpS3kYIBPBgEAgAAABgEAQAAABbI9hQo + BAIAAAAYBAEAAAAAGRwVABUAFRIAABaC9ej/BxXuARa2yKr/BxXiAQAmgMGRggEcFQwZNQYIBBkY + B3N1YnR5cGUVDBbg9hQWhFcWmEomgMGRggEm1L6RggEcNpCqFCgOdHJhbnNwb3J0YXRpb24YDGFn + cmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRIAABbw9uj/BxX+ARaYyqr/BxWABAAmyI2SggEcFQwZ + NQYIBBkYBWNsYXNzFQwW4PYUFvpZFpRMJsiNkoIBJuyIkoIBHDbgqxQoCXdhcmVob3VzZRgKYXBh + cnRtZW50cwAZLBUEFQQVAgAVABUEFRIAABbu+Oj/BxX+ARaYzqr/BxWAAwAm5tWSggEcFQoZNQYI + BBkYBmhlaWdodBUMFuD2FBakBha2Bybm1ZKCASaA1ZKCARwYCAAAAAAAAC5AGAgAAAAAAAAEQBbU + 9hQoCAAAAAAAAC5AGAgAAAAAAAAEQAAZLBUEFQQVAgAVABUEFRIAABbs+uj/BxXsARaY0ar/BxWC + AgAmttySggEcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBbg9hQWjJUBFv5eJrbckoIBPDbA8RQo + GFVuaXZlcnNpZGFkIGRlIExvcyBMYWdvcxgCMTAAGRwVABUAFRIAABbY/Oj/BxX+ARaa06r/BxW+ + BgAmtLuTggEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbg9hQWpBoWzhUm + tLuTggE8GAJlbhgCZW4W3PYUKAJlbhgCZW4AGRwVABUAFRIAABbW/uj/BxX+ARbY2ar/BxWSAQAm + gtGTggEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFuD2FBbeHhakFyaC + 0ZOCATw23PYUKAxSRkYgU2VydmljZXMYE0hvc3BpdGFsIFB1cXVlbGTDs24AGRwVABUAFRIAABbU + gOn/BxX+ARbq2qr/BxX+AQAmpuiTggEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B3ZhcmlhbnQVDBbq9hQWvCEW4BkmpuiTggE8Nsz2FCgIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUA + FQAVEgAAFtKC6f8HFf4BFujcqv8HFewCACaGgpSCARwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQIbGFuZ3VhZ2UVDBbq9hQWxh4WyhcmhoKUggE8Nur2FAAZHBUAFQAVEgAAFtCE6f8H + Ff4BFtTfqv8HFYIBACbQmZSCARwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFs + dWUVDBbq9hQW0iUW9hwm0JmUggE8Nsz2FCgeSWdsZXNpYSBkZSBTYW4gQ2FybG9zIEJvcnJvbWVv + GB9CYW5jbyBkZSBDcsOpZGl0byBlIEludmVyc2lvbmVzABkcFQAVABUSAAAWzobp/wcV/gEW1uCq + /wcV/gYAJsa2lIIBHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxp + c3QHZWxlbWVudBUMFur2FBbQHhbMFybGtpSCATw26vYUABkcFQAVABUSAAAWzIjp/wcV/gEW1Oeq + /wcVggEAJpLOlIIBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW6vYU + FsYeFsoXJpLOlIIBPDbq9hQAGRwVABUAFRIAABbKiun/BxX+ARbW6Kr/BxWCAQAm3OWUggEcFQAZ + NQYIABkYCWhhc19wYXJ0cxUMFuD2FBbQ0wIWoAcm3OWUggE8GAEBGAEAFgAoAQEYAQAAGRwVABUA + FRIAABbIjOn/BxXsARbY6ar/BxWCAQAm/OyUggEcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwW + 4PYUFtDTAhaWByb87JSCATwYAQAYAQAWACgBABgBAAAZHBUAFQAVEgAAFrSO6f8HFewBFtrqqv8H + FYIBACaS9JSCARwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFuD2FBa6Chb4CSaS9JSCATwYBAYAAAAY + BAEAAAAW+vUUKAQGAAAAGAQBAAAAABkcFQAVABUSAAAWoJDp/wcV9AEW3Ouq/wcVggIAJor+lIIB + HBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW4PYUFtIEFvQFJor+lIIBPDbg9hQA + GRwVABUAFRIAABaUkun/BxXsARbe7ar/BxWCAQAm/oOVggEcFQoZNQYIABkYCm1pbl9oZWlnaHQV + DBbg9hQW0gQW9AUm/oOVggE8NuD2FAAZHBUAFQAVEgAAFoCU6f8HFewBFuDuqv8HFYIBACbyiZWC + ARwVAhk1BggAGRgJbWluX2Zsb29yFQwW4PYUFtIEFvQFJvKJlYIBPDbg9hQAGRwVABUAFRIAABbs + len/BxXsARbi76r/BxWCAQAm5o+VggEcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFuD2FBbSBBb0 + BSbmj5WCATw24PYUABkcFQAVABUSAAAW2Jfp/wcV7AEW5PCq/wcVggEAJtqVlYIBHBUMGTUGCAAZ + GA9mYWNhZGVfbWF0ZXJpYWwVDBbg9hQW9AQWlgYm2pWVggE8GAhjb25jcmV0ZRgIY29uY3JldGUW + 3vYUKAhjb25jcmV0ZRgIY29uY3JldGUAGRwVABUAFRIAABbEmen/BxXsARbm8ar/BxWiAQAm8JuV + ggEcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbg9hQW0gQW9AUm8JuVggE8NuD2FAAZHBUAFQAV + EgAAFrCb6f8HFewBFojzqv8HFYIBACbkoZWCARwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFuD2FBbw + BBaSBibkoZWCATwYBmdhYmxlZBgGZ2FibGVkFt72FCgGZ2FibGVkGAZnYWJsZWQAGRwVABUAFRIA + ABacnen/BxXsARaK9Kr/BxWaAQAm9qeVggEcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW4PYU + FtIEFvQFJvanlYIBPDbg9hQAGRwVABUAFRIAABaIn+n/BxXsARak9ar/BxWCAQAm6q2VggEcFQwZ + NQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbg9hQW0gQW9AUm6q2VggE8NuD2FAAZHBUAFQAVEgAA + FvSg6f8HFewBFqb2qv8HFYIBACbes5WCARwVDBk1BggAGRgKcm9vZl9jb2xvchUMFuD2FBbSBBb0 + BSbes5WCATw24PYUABkcFQAVABUSAAAW4KLp/wcV7AEWqPeq/wcVggEAJtK5lYIBHBUKGTUGCAAZ + GAtyb29mX2hlaWdodBUMFuD2FBbSBBb0BSbSuZWCATw24PYUABkcFQAVABUSAAAWzKTp/wcV7AEW + qviq/wcVggEAFpS7qx0W4PYUJubQg3MW4O6RDxQQABn8JibGv5WCARwVDBk1BggAGRgCaWQVDBbE + 7RQWquzuBRb839sBJsa/lYIBPDYAKCAwOGJjZWFlYjVlY2VlZmZmMDIwMDRjMGQzODIxNjhkNBgg + MDhiY2VhODQwMDBjYmZmZjAyMDBjYTFiYzIyNDNiZjUAGRwVABUAFRIAABa4pun/BxWQAhas+ar/ + BxXeCQAmwp/xgwEcFQwZNQYIABkYCGdlb21ldHJ5FQwWxO0UFq7m3xAW7LL5CSbCn/GDATw2ACjd + BgAAAAADAAAABQAAABrAUnUKbayrxcBE72OBr5gJwFJ1CBAEWgLARO9kDO/Si8BSdQfPAVpzwETv + YZpOyz/AUnUMLuJrm8BE72CYxwvDwFJ1DFDbuqbARO9h4MWoFcBSdQzTuHlZwETvYcKStyfAUnUM + 7HeM/8BE72Kwz0BFwFJ1DGLk0abARO9i0K+wXMBSdQ0Zw/ZkwETvabMiANzAUnUNko+6HcBE72mX + c06swFJ1DnIeKo3ARO9yAM5cGcBSdQ3czPURwETvciMzCu/AUnUOE775pcBE73Q2MsH0wFJ1DHzm + BKzARO90k0/TfcBSdQxAgCLQwETvckt29tfAUnULkFb6ucBE73JzuuK/wFJ1C8WbgCTARO90c29j + ZcBSdQqEUuB4wETvdL4X/iTAUnUKwLjCVMBE73cGx5pewFJ1BL/twTnARO94aMdptsBSdQR1sIZF + wETvddSYcynAUnUEIIuQwsBE73I00MIlwFJ1AW6VCRHARO9ywOe8PMBSdQC5Y2N9wETva1nrLeHA + UnUK/zeDJMBE72j8QtwewFJ1Cm2sq8XARO9jga+YCQAAAAXAUnULofSx7sBE72tawe12wFJ1CdDO + ug3ARO9rpxgHXsBSdQn6VMVUwETvbdadMCfAUnULy3q9NsBE722KRxY/wFJ1C6H0se7ARO9rWsHt + dgAAAAfAUnUHwmwgu8BE72wf48sWwFJ1BgjDHSHARO9scu/hpcBSdQZVhJbTwETvb/6VnLXAUnUG + uIDlbsBE72/sISXqwFJ1Bq5v6nTARO9vdQLhXMBSdQgFHJ9zwETvbzRrQZfAUnUHwmwgu8BE72wf + 48sWAAAAB8BSdQQ8paK8wETvbIVkWG/AUnUCYkVvdsBE72z9WVyTwFJ1AtTGllLARO9w45fqbcBS + dQOaU9O9wETvcLFDA4vAUnUDdJQmk8BE729qGybNwFJ1BInSfDnARO9vI6RJ98BSdQQ8paK8wETv + bIVkWG8AAAAHwFJ1CKYsTxPARO9x5EjqVcBSdQVw7ajlwETvcnVoYenAUnUFqSHM2cBE73U0X4Md + wFJ1CCVob1XARO90w/c7NcBSdQg8DqQIwETvddwlL2TAUnUI9JtH8MBE73W7bf+4wFJ1CKYsTxPA + RO9x5EjqVRhNAAAAAAMAAAABAAAABMBSSk9ycrPXwEThP/zO6uDAUkpQgXSJvMBE4T7+Ql6JwFJK + UFPkaxDAROFAQ5t3ocBSSk9ycrPXwEThP/zO6uAAGRwVABUAFSYAABbIqOn/BxW+BBaKg6v/BxW2 + JwAmrtLqjQEcFQgZNQYIABkoBGJib3gEeG1pbhUMFsTtFBaqu1MWzI8yJq7S6o0BPBgEBUCSwhgE + DxuUwhYAKAQFQJLCGAQPG5TCABkcFQAVABUSAAAWhq3p/wcVkAIWwKqr/wcV7gEAJvrhnI4BHBUI + GTUGCAAZKARiYm94BHhtYXgVDBbE7RQWqrtTFqSWMib64ZyOATwYBPQ/ksIYBAkblMIWACgE9D+S + whgECRuUwgAZHBUAFQAVEgAAFpav6f8HFZACFq6sq/8HFe4BACae+M6OARwVCBk1BggAGSgEYmJv + eAR5bWluFQwWxO0UFqi7Uxa63jQmnvjOjgE8GASCMSPCGAQOwCjCFgAoBIIxI8IYBA7AKMIAGRwV + ABUAFRIAABamsen/BxWQAhacrqv/BxXuAQAm2NaDjwEcFQgZNQYIABkoBGJib3gEeW1heBUMFsTt + FBaqu1MWjtc0JtjWg48BPBgEdjEjwhgE878owhYAKAR2MSPCGATzvyjCABkcFQAVABUSAAAWtrPp + /wcVkAIWirCr/wcV7gEAJqauuI8BHBUCGTUGCAQZGAd2ZXJzaW9uFQwWxO0UFsgFFvwGJqauuI8B + JuatuI8BHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEgAAFsa16f8H + FewBFvixq/8HFe4BACaitbiPARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0 + eRUMFsTtFBbYBhaMCCaitbiPASbitLiPARwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFrK3 + 6f8HFewBFuazq/8HFV4AJrK+uI8BHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFz + ZXQVDBbE7RQWmI8FFobvAiayvriPASbuvLiPARw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9w + ZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEgAAFp656f8HFf4BFsS0q/8HFcIFACb0q7uPARwV + DBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbE7RQW2LyaAxagz4wBJvSr + u48BPDYAKAx3OTk3NTEwODIwQDEYDDAwMDFjN2QwNDFkYwAZHBUAFQAVEgAAFpy76f8HFZACFoa6 + q/8HFYwEACbAu8iQARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUM + FsTtFBa22RYWrukFJsC7yJABJpT7x5ABHDYAKBgyMDI0LTExLTA5VDE0OjM5OjU1LjAwMFoYGDIw + MTEtMDItMTBUMDM6MTA6MTUuMDAwWgAZLBUEFQQVAgAVABUEFRIAABasven/BxX+ARaSvqv/BxW+ + BwAm/oPPkAEcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsTtFBa0 + mSEWmrUdJv6Dz5ABJsLkzZABHBgI6Ugu/yH97j8YCM3MzMzMzOQ/FsDDBSgI6Ugu/yH97j8YCM3M + zMzMzOQ/ABksFQQVBBUCABUAFQQVEgAAFqq/6f8HFZACFtDFq/8HFZADACbcmeuQARwVAhk1BggA + GRgFbGV2ZWwVDBbE7RQWlgYW/gYm3JnrkAE8GAQBAAAAGAQBAAAAFqjtFCgEAQAAABgEAQAAAAAZ + HBUAFQAVEgAAFrrB6f8HFe4BFuDIq/8HFbIBACbyouuQARwVDBk1BggEGRgHc3VidHlwZRUMFsTt + FBbiHRbuGSbyouuQASbaoOuQARw2lOQUKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABks + FQQVBBUCABUAFQQVEgAAFqjD6f8HFfwBFpLKq/8HFc4DACauveuQARwVDBk1BggEGRgFY2xhc3MV + DBbE7RQWhBsWghgmrr3rkAEmyLrrkAEcNozlFCgOdHJhbnNwb3J0YXRpb24YBGJhcm4AGSwVBBUE + FQIAFQAVBBUSAAAWpMXp/wcV/AEW4M2r/wcV+gIAJsrS65ABHBUKGTUGCAAZGAZoZWlnaHQVDBbE + 7RQW0gQW9AUmytLrkAE8NsTtFAAZHBUAFQAVEgAAFqDH6f8HFewBFtrQq/8HFYIBACa+2OuQARwV + DBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFsTtFBa8ThbWNia+2OuQATw2/uoUKA1sb3MgUGVjZXNp + dG9zGCQywqogQ29tcGHDsWlhIGRlIEJvbWJlcm9zIGRlIENhbGJ1Y28AGRwVABUAFRIAABaMyen/ + BxX8ARbc0av/BxWCBQAmlI/skAEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkV + DBbE7RQWthEW6A8mlI/skAE8NsTtFAAZHBUAFQAVEgAAFojL6f8HFfoBFt7Wq/8HFYIBACb8nuyQ + ARwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWxO0UFtYTFpAQJvye7JAB + PDbE7RQAGRwVABUAFRIAABaCzen/BxX6ARbg16v/BxWCAQAmjK/skAEcFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbE7RQWpBQW3BAmjK/skAE8Nr7tFCgIb2ZmaWNp + YWwYCWFsdGVybmF0ZQAZHBUAFQAVEgAAFvzO6f8HFfoBFuLYq/8HFcgBACbov+yQARwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbE7RQW1hMWkhAm6L/skAE8NsTt + FAAZHBUAFQAVEgAAFvbQ6f8HFfoBFqraq/8HFYIBACb6z+yQARwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbE7RQWjBUWxBEm+s/skAE8Nr7tFCgUVGVybWluYWwgSW50 + ZXJ1cmJhbm8YGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRIAABbw0un/BxX6ARas + 26v/BxXkAgAmvuHskAEcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4E + bGlzdAdlbGVtZW50FQwWxO0UFtYTFpIQJr7h7JABPDbE7RQAGRwVABUAFRIAABbq1On/BxX6ARaQ + 3qv/BxWCAQAm0PHskAEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbE + 7RQW1hMWkhAm0PHskAE8NsTtFAAZHBUAFQAVEgAAFuTW6f8HFfoBFpLfq/8HFYIBACbige2QARwV + ABk1BggAGRgJaGFzX3BhcnRzFQwWxO0UFr7SAhaWBybige2QATwYAQAYAQAWACgBABgBAAAZHBUA + FQAVEgAAFt7Y6f8HFewBFpTgq/8HFYIBACb4iO2QARwVABk1BggAGRgOaXNfdW5kZXJncm91bmQV + DBbE7RQWvtICFpYHJviI7ZABPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAWytrp/wcV7AEWluGr + /wcVggEAJt6Q7ZABHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWxO0UFvQFFqgHJt6Q7ZABJo6Q7ZAB + HBgEAwAAABgEAQAAABa07RQoBAMAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUSAAAWttzp/wcV7AEW + mOKr/wcVwgEAJraX7ZABHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWxO0UFtIE + FvQFJraX7ZABPDbE7RQAGRwVABUAFRIAABai3un/BxXsARba46v/BxWCAQAmqp3tkAEcFQoZNQYI + ABkYCm1pbl9oZWlnaHQVDBbE7RQW0gQW9AUmqp3tkAE8NsTtFAAZHBUAFQAVEgAAFo7g6f8HFewB + Ftzkq/8HFYIBACaeo+2QARwVAhk1BggAGRgJbWluX2Zsb29yFQwWxO0UFtIEFvQFJp6j7ZABPDbE + 7RQAGRwVABUAFRIAABb64en/BxXsARbe5av/BxWCAQAmkqntkAEcFQwZNQYIABkYDGZhY2FkZV9j + b2xvchUMFsTtFBbwBBaSBiaSqe2QATwYByNGRjAwMDAYByNGRjAwMDAWwu0UKAcjRkYwMDAwGAcj + RkYwMDAwABkcFQAVABUSAAAW5uPp/wcV7AEW4Oar/wcVngEAJqSv7ZABHBUMGTUGCAAZGA9mYWNh + ZGVfbWF0ZXJpYWwVDBbE7RQW0gQW9AUmpK/tkAE8NsTtFAAZHBUAFQAVEgAAFtLl6f8HFewBFv7n + q/8HFYIBACaYte2QARwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFsTtFBbSBBb0BSaYte2QATw2 + xO0UABkcFQAVABUSAAAWvufp/wcV7AEWgOmr/wcVggEAJoy77ZABHBUMGTUGCAAZGApyb29mX3No + YXBlFQwWxO0UFtIEFvQFJoy77ZABPDbE7RQAGRwVABUAFRIAABaq6en/BxXsARaC6qv/BxWCAQAm + gMHtkAEcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWxO0UFtIEFvQFJoDB7ZABPDbE7RQAGRwV + ABUAFRIAABaW6+n/BxXsARaE66v/BxWCAQAm9MbtkAEcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRp + b24VDBbE7RQW0gQW9AUm9MbtkAE8NsTtFAAZHBUAFQAVEgAAFoLt6f8HFewBFobsq/8HFYIBACbo + zO2QARwVDBk1BggAGRgKcm9vZl9jb2xvchUMFsTtFBbSBBb0BSbozO2QATw2xO0UABkcFQAVABUS + AAAW7u7p/wcV7AEWiO2r/wcVggEAJtzS7ZABHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFsTtFBbS + BBb0BSbc0u2QATw2xO0UABkcFQAVABUSAAAW2vDp/wcV7AEWiu6r/wcVggEAFtSE/BwWxO0UJsa/ + lYIBFoqZ2A4UEgAZ/CYm0NjtkAEcFQwZNQYIABkYAmlkFQwW7MMTFoCPvwUW0pDLASbQ2O2QATw2 + ACggMDhiY2VhYmRhZDRjNmZmZjAyMDA4Yzg3NDVhMjAzMDEYIDA4YmNlOGM4MDAwMDJmZmYwMjAw + ZmQxMGRlNTE5ZTkzABkcFQAVABUQAAAWxvLp/wcV8gEWjO+r/wcV1ggAJqLpuJIBHBUMGTUGCAAZ + GAhnZW9tZXRyeRUMFuzDExbsru8PFpyMswkmoum4kgE8NgAowQUAAAAAAwAAAAYAAAARwFJJ2Ppt + GQjARHTr89mBEMBSSeB5vVtAwER07M30FDnAUkngK7nCLsBEdPLwTQSWwFJJ4kGpF7zARHTzLYmm + B8BSSeFslwIQwER1A+SRDrHAUkne+Yqa+cBEdQOdQ3JGwFJJ3sB/t3DARHUIFKF3tMBSSd0gbIcS + wER1B+WnjybAUkndLq8/9MBEdQbK9Vw4wFJJ1dNxK7zARHUF9QyG98BSSdYpbODUwER0/zu04fTA + UknT8RjccMBEdP77HUIwwFJJ1Fs2h3zARHT2ooksZMBSSdd4IXnNwER09v0h/y7AUknXjYWPIcBE + dPVT1JNrwFJJ2IGhVVDARHT1b4NFmsBSSdj6bRkIwER06/PZgRAAAAAFwFJJ3T6feADARHUAGSpz + ccBSSdkWG8s4wER0/3FkxyrAUknY8uBczcBEdQF0dEYjwFJJ3RtkCZXARHUCG2My1cBSSd0+n3gA + wER1ABkqc3EAAAAFwFJJ4OWIhXXARHT+NtIkJcBSSd5CQBZxwER0/fSNBTfAUkneNarcuMBEdP8V + HnU2wFJJ4Nleq4fARHT/V2OUJMBSSeDliIV1wER0/jbSJCUAAAAFwFJJ4V6/qPjARHT3Q5jcBMBS + Sd6m6eQ1wER09vZsAojAUknelo5MXsBEdPhL1pgowFJJ4U5kESLARHT4mQNxpcBSSeFev6j4wER0 + 90OY3AQAAAAFwFJJ3gDRtxfARHTwygIXMcBSSdmE1pP2wER08GpgxurAUknZdVG7tMBEdPIS13MZ + wFJJ3fFM3tbARHTycnjDYMBSSd4A0bcXwER08MoCFzEAAAAFwFJJ3elUwtDARHT2xcSaz8BSSdkp + 0mFhwER09kE6XPPAUknZG/sIScBEdPdhy8zzwFJJ3dt9abjARHT35X9LOsBSSd3pVMLQwER09sXE + ms8YTQAAAAADAAAAAQAAAATAUkrD4xk/bMBESsi9c5N2wFJKw4c+TUPARErKtnIXdcBSSsKyl5dh + wERKyDS3l7HAUkrD4xk/bMBESsi9c5N2ABkcFQAVABUkAAAWuPTp/wcVoAQW4ver/wcVriUAJr71 + 65sBHBUIGTUGCAAZKARiYm94BHhtaW4VDBbswxMWgJROFvKBLCa+9eubATwYBARAksIYBHqwk8IW + ACgEBECSwhgEerCTwgAZHBUAFQAVEAAAFtj46f8HFfIBFpCdrP8HFdYBACaw95ecARwVCBk1BggA + GSgEYmJveAR4bWF4FQwW7MMTFv6TThbigywmsPeXnAE8GATmP5LCGARrsJPCFgAoBOY/ksIYBGuw + k8IAGRwVABUAFRAAABbK+un/BxXyARbmnqz/BxXWAQAmkvvDnAEcFQgZNQYIABkoBGJib3gEeW1p + bhUMFuzDExaAlE4W7u0uJpL7w5wBPBgEZlMgwhgEjF0lwhYAKARmUyDCGASMXSXCABkcFQAVABUQ + AAAWvPzp/wcV8gEWvKCs/wcV1gEAJoDp8pwBHBUIGTUGCAAZKARiYm94BHltYXgVDBbswxMWgJRO + FrbzLiaA6fKcATwYBFhTIMIYBH1dJcIWACgEWFMgwhgEfV0lwgAZHBUAFQAVEAAAFq7+6f8HFfIB + FpKirP8HFdYBACb23KGdARwVAhk1BggEGRgHdmVyc2lvbhUMFuzDExb+BBagBib23KGdASa23KGd + ARwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABaggOr/BxXSARbo + o6z/BxXWAQAmluOhnQEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbs + wxMW/gUWoAcmluOhnQEm1uKhnQEcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABbyger/BxXS + ARa+paz/BxVWACa666GdARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwW + 7MMTFtLtBBbU4wImuuuhnQEm9umhnQEcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1 + aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbEg+r/BxXiARaUpqz/BxX2BAAmys2knQEcFQwZJQYA + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW7MMTFqSh+AIW1oeEASbKzaSdATw2 + ACgMdzk5OTY5MDI0NkAyGAwwMDAwNGE4NWJiMjAAGRwVABUAFRAAABamher/BxXyARaKq6z/BxXW + AwAmkIipngEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbswxMW + xvkTFqSeBSaQiKmeASag1aieARw2ACgYMjAyNC0xMS0yNVQyMjozNzoyMS4wMDBaGBgyMDExLTEx + LTEyVDE5OjQ5OjE5LjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWmIfq/wcV4gEW4K6s/wcV1gYAJuyV + r54BHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbswxMWnI4dFs7X + GSbsla+eASbE862eARwYCJ7vp8ZLN+8/GAjNzMzMzMzkPxaI5QYoCJ7vp8ZLN+8/GAjNzMzMzMzk + PwAZLBUEFQQVAgAVABUEFRAAABb6iOr/BxXyARa2taz/BxXoAgAmksvHngEcFQIZNQYIABkYBWxl + dmVsFQwW7MMTFuoEFvoFJpLLx54BPBgEAQAAABgE/////xbiwxMoBAEAAAAYBP////8AGRwVABUA + FRAAABbsiur/BxXUARaeuKz/BxWWAQAmqtPHngEcFQwZNQYIBBkYB3N1YnR5cGUVDBbswxMWlhcW + 6BUmqtPHngEmjNHHngEcNuq8EygOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQV + AgAVABUEFRAAABbAjOr/BxXiARa0uaz/BxXMAwAmvOrHngEcFQwZNQYIBBkYBWNsYXNzFQwW7MMT + FpYWFtIUJrzqx54BJvTmx54BHDbgvRMoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAV + ABUEFRAAABaijur/BxXiARaAvaz/BxWsAwAmxvvHngEcFQoZNQYIABkYBmhlaWdodBUMFuzDExbE + BBbUBSbG+8eeATwYCAAAAAAAAEhAGAgAAAAAAAAcQBbowxMoCAAAAAAAAEhAGAgAAAAAAAAcQAAZ + HBUAFQAVEAAAFoSQ6v8HFdIBFqzArP8HFbYBACaagcieARwVDBk1BggAGSgFbmFtZXMHcHJpbWFy + eRUMFuzDExbSRhbkLyaagcieATw2vsETKApwZXNlYnJlcmFzGCMxIHkgMiBKdXpnYWRvIFBvbGlj + w61hIExvY2FsIE9zb3JubwAZHBUAFQAVEAAAFtaR6v8HFeIBFuLBrP8HFdoFACb+sMieARwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFuzDExaWDxbeDSb+sMieATw27MMTABkc + FQAVABUQAAAWuJPq/wcV4AEWvMes/wcVdgAm3L7IngEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQV2YWx1ZRUMFuzDExaKERaiDibcvsieATw27MMTABkcFQAVABUQAAAWmJXq/wcV4AEW + ssis/wcVdgAm/szIngEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQV + DBbuwxMWkBIWkA8m/szIngE8NuTDEygIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFviW + 6v8HFeABFqjJrP8HFbgBACaO3MieARwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQI + bGFuZ3VhZ2UVDBbuwxMWlBEWtA4mjtzIngE8Nu7DEwAZHBUAFQAVEAAAFtiY6v8HFeABFuDKrP8H + FXYAJsLqyJ4BHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFu7DExb4 + Exa2ECbC6sieATw25MMTKCxTZXJ2aWNpbyBkZSBSZWdpc3RybyBDaXZpbCBlIElkZW50aWZpY2Fj + acOzbhgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFria6v8HFeABFtbLrP8H + FfoCACb4+sieARwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0 + B2VsZW1lbnQVDBbuwxMWlhEWtA4m+PrIngE8Nu7DEwAZHBUAFQAVEAAAFpic6v8HFeABFtDOrP8H + FXYAJqyJyZ4BHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW7sMTFpQR + FrQOJqyJyZ4BPDbuwxMAGRwVABUAFRAAABb4ner/BxXgARbGz6z/BxV2ACbgl8meARwVABk1BggA + GRgJaGFzX3BhcnRzFQwW7MMTFt68Aha+Bibgl8meATwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAA + Ftif6v8HFdIBFrzQrP8HFXYAJp6eyZ4BHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFuzDExbe + vAIWsAYmnp7JngE8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaqoer/BxXSARay0az/BxV2ACbO + pMmeARwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFuzDExbyCRbYCCbOpMmeATwYBBAAAAAYBAEAAAAW + hsMTKAQQAAAAGAQBAAAAABkcFQAVABUQAAAW/KLq/wcV2AEWqNKs/wcVtgEAJqatyZ4BHBUCGTUG + CAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW7MMTFpAEFqAFJqatyZ4BPDbswxMAGRwVABUA + FRAAABbUpOr/BxXSARbe06z/BxV2ACbGssmeARwVChk1BggAGRgKbWluX2hlaWdodBUMFuzDExaQ + BBagBSbGssmeATw27MMTABkcFQAVABUQAAAWpqbq/wcV0gEW1NSs/wcVdgAm5rfJngEcFQIZNQYI + ABkYCW1pbl9mbG9vchUMFuzDExaQBBagBSbmt8meATw27MMTABkcFQAVABUQAAAW+Kfq/wcV0gEW + ytWs/wcVdgAmhr3JngEcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFuzDExaQBBagBSaGvcmeATw2 + 7MMTABkcFQAVABUQAAAWyqnq/wcV0gEWwNas/wcVdgAmpsLJngEcFQwZNQYIABkYD2ZhY2FkZV9t + YXRlcmlhbBUMFuzDExaQBBagBSamwsmeATw27MMTABkcFQAVABUQAAAWnKvq/wcV0gEWttes/wcV + dgAmxsfJngEcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbswxMWkAQWoAUmxsfJngE8NuzDEwAZ + HBUAFQAVEAAAFu6s6v8HFdIBFqzYrP8HFXYAJubMyZ4BHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW + 7MMTFpAEFqAFJubMyZ4BPDbswxMAGRwVABUAFRAAABbArur/BxXSARai2az/BxV2ACaG0smeARwV + Chk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbswxMWkAQWoAUmhtLJngE8NuzDEwAZHBUAFQAVEAAA + FpKw6v8HFdIBFpjarP8HFXYAJqbXyZ4BHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW7MMT + FpAEFqAFJqbXyZ4BPDbswxMAGRwVABUAFRAAABbkser/BxXSARaO26z/BxV2ACbG3MmeARwVDBk1 + BggAGRgKcm9vZl9jb2xvchUMFuzDExaQBBagBSbG3MmeATw27MMTABkcFQAVABUQAAAWtrPq/wcV + 0gEWhNys/wcVdgAm5uHJngEcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW7MMTFpAEFqAFJubhyZ4B + PDbswxMAGRwVABUAFRAAABaIter/BxXSARb63Kz/BxV2ABau15wbFuzDEybQ2O2QARa2jtwNFBQA + GfwmJobnyZ4BHBUMGTUGCAAZGAJpZBUMFojtFBa62+4FFpC92wEmhufJngE8NgAoIDA4YmNmOTlh + ZjE3YWRmZmYwMjAwOWVmZjlmY2Y5NTUyGCAwOGJjZTEyNTkyMTBlZmZmMDIwMDA1YjUwZGE2NjNk + MAAZHBUAFQAVEgAAFtq26v8HFZACFvDdrP8HFd4JACaWpKWgARwVDBk1BggAGRgIZ2VvbWV0cnkV + DBaI7RQWsIbsEBaG3foJJpakpaABPDYAKOAFAAAAAAYAAAADAAAAAAMAAAABAAAAHcBSTVIUNGpr + wEPsoRZlnRPAUk1WsHtdbsBD7KPdwDoXwFJNVcAl9V3AQ+yniUZlP8BSTVUX9OlMwEPspyPF1+bA + Uk1Tgl4TssBD7K1Ykz8NwFJNU/9blVLAQ+ytozvZy8BSTVOKVi+3wEPsr24XNNDAUk1SfXtV4sBD + 7K7MMMWbwFJNUZ8vBNDAQ+yyM8RSq8BSTVKhjYPiwEPsss70xTnAUk1SKgPficBD7LSj4Rs4wFJN + UYiI0B7AQ+y0Q2kLXMBSTVCJ8K8qwEPsuCjQ2aLAUk1REqyq7sBD7Lh7BjCcwFJNUMrzrrnAQ+y5 + lOGj9MBSTVBFJ1F+wEPsuURZzCTAUk1OaELfecBD7MCPp6hQwFJNTRrQZd/AQ+y/xyrMXMBSTU3w + TdtVwEPsvILSrbfAUk1L2LEGnsBD7LtAs053wFJNTTMkGbvAQ+y19fCyhcBSTU9Ar/N4wEPstzIw + 1LTAUk1QTR9thMBD7LMZnV/4wFJNTgnjrpHAQ+yxvKYOHMBSTU+cH4XXwEPsq5byH23AUk1Ryfcv + d8BD7KznVDeQwFJNUoUIEh3AQ+yqC9ekl8BSTVAnX8BawEPsqJ4ZWxvAUk1SFDRqa8BD7KEWZZ0T + AAAAAAMAAAABAAAAB8BSTVD6WPcSwEPsoXUwLcXAUk1N5PrA/MBD7KzPAIOzwFJNTFbwp53AQ+yr + z/0C9cBSTUy57PY4wEPsqmMVeQ7AUk1MCcPOIcBD7KnyrTEmwFJNTrtO9gfAQ+ygBcRlH8BSTVD6 + WPcSwEPsoXUwLcUAAAAAAwAAAAEAAAAHwFJNTTHh+lvAQ+yvMogSicBSTUjzjth1wEPsv05fCKTA + Uk1HNAaXysBD7L44tVM0wFJNR/d69kDAQ+y7UyfFQcBSTUeONArKwEPsuxG5ZejAUk1LCX4uA8BD + 7K3bb/2/wFJNTTHh+lvAQ+yvMogSiRhNAAAAAAMAAAABAAAABMBSK9dgtAyBwEZg+z91IB3AUivW + +lzsy8BGYPnCefMmwFIr2AxZlYTARmD64dPkdsBSK9dgtAyBwEZg+z91IB0AGRwVABUAFSYAABbq + uOr/BxW+BBbO56z/BxW2JwAmnIGgqgEcFQgZNQYIABkoBGJib3gEeG1pbhUMFojtFBa6uVMWhsAw + JpyBoKoBPBgE+aGMwhgEO2iTwhYAKAT5oYzCGAQ7aJPCABkcFQAVABUSAAAWqL3q/wcVkAIWhI+t + /wcV7gEAJqLB0KoBHBUIGTUGCAAZKARiYm94BHhtYXgVDBaI7RQWuLlTFry+MCaiwdCqATwYBOih + jMIYBClok8IWACgE6KGMwhgEKWiTwgAZHBUAFQAVEgAAFri/6v8HFZACFvKQrf8HFe4BACbe/4Cr + ARwVCBk1BggAGSgEYmJveAR5bWluFQwWiO0UFrq5UxaCjjQm3v+AqwE8GARbgB3CGAQAADTCFgAo + BFuAHcIYBAAANMIAGRwVABUAFRIAABbIwer/BxWQAhbgkq3/BxXuAQAm4I21qwEcFQgZNQYIABko + BGJib3gEeW1heBUMFojtFBa6uVMWisA0JuCNtasBPBgEPoAdwhgE8v8zwhYAKAQ+gB3CGATy/zPC + ABkcFQAVABUSAAAW2MPq/wcVkAIWzpSt/wcV7gEAJqrO6asBHBUCGTUGCAQZGAd2ZXJzaW9uFQwW + iO0UFsgFFvwGJqrO6asBJurN6asBHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUC + ABUAFQQVEgAAFujF6v8HFewBFryWrf8HFe4BACam1emrARwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAhwcm9wZXJ0eRUMFojtFBbYBhaMCCam1emrASbm1OmrARwYABgAFgAoABgAABksFQQV + BBUCABUAFQQVEgAAFtTH6v8HFewBFqqYrf8HFV4AJrbe6asBHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50B2RhdGFzZXQVDBaI7RQW0IAFFv66Aya23umrASby3OmrARw2ACgNT3BlblN0cmVl + dE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEgAAFsDJ6v8HFf4BFoiZ + rf8HFcIFACbwl+2rARwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaI + 7RQW1uaFAxaOo4cBJvCX7asBPDYAKAx3OTk5NzYyNzI5QDEYDDAwMDAyZjU3MmEzMQAZHBUAFQAV + EgAAFr7L6v8HFZACFsqerf8HFY4EACbGwvasARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAt1cGRhdGVfdGltZRUMFojtFBamqCIWyvcKJsbC9qwBJv669KwBHDYAKBgyMDI0LTExLTMwVDIy + OjQwOjU2LjAwMFoYGDIwMTEtMDYtMTdUMDE6MTY6NTkuMDAwWgAZLBUEFQQVAgAVABUEFRIAABbO + zer/BxWGAhbYoq3/BxW+BwAmoruBrQEcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29u + ZmlkZW5jZRUMFojtFBagnyAWtt8cJqK7ga0BJsiy/6wBHBgIAAAAAAAA8D8YCAAAAIAW2d4/FtrQ + BigIAAAAAAAA8D8YCAAAAIAW2d4/ABksFQQVBBUCABUAFQQVEgAAFtTP6v8HFZACFpaqrf8HFZQD + ACbWkpytARwVAhk1BggEGRgFbGV2ZWwVDBaI7RQW4goW0Asm1pKcrQEm/pGcrQEcGAQDAAAAGAT+ + ////FuTrFCgEAwAAABgE/v///wAZLBUEFQQVAgAVABUEFRIAABbk0er/BxXyARaqra3/BxWSAgAm + 9J+crQEcFQwZNQYIBBkYB3N1YnR5cGUVDBaI7RQW2owBFrpzJvSfnK0BJs6dnK0BHDaO1BMoDnRy + YW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAW1tPq/wcV/gEWvK+t + /wcVlAQAJqaWna0BHBUMGTUGCAQZGAVjbGFzcxUMFojtFBbSjgEWjHYmppadrQEmiJGdrQEcNuDY + EygJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEgAAFtTV6v8HFf4BFtCzrf8H + FaYDACaUh56tARwVChk1BggAGRgGaGVpZ2h0FQwWiO0UFs4GFrYHJpSHnq0BPBgIAAAAAADgUkAY + CAAAAAAAABhAFvTsFCgIAAAAAADgUkAYCAAAAAAAABhAABkcFQAVABUSAAAW0tfq/wcV8AEW9rat + /wcV4gEAJsqOnq0BHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWiO0UFqauAxbK9QEmyo6erQE8 + NsLdFCgbw5F1a2UgTWFwdSBFbXBvcmlvIEdyb3dzaG9wGA8iTG9zIFRvcnJlb25lcyIAGRwVABUA + FRIAABbC2er/BxX+ARbYuK3/BxWsBwAmlISgrQEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92 + YWx1ZQNrZXkVDBaa7RQW3jwWgCkmlISgrQE8NuLsFCgCZnIYAmVuABkcFQAVABUSAAAWwNvq/wcV + /gEWhMCt/wcVugEAJpStoK0BHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUV + DBaa7RQWqE8WsjEmlK2grQE8NuLsFCgbw5F1a2UgTWFwdSBFbXBvcmlvIEdyb3dzaG9wGBFCYW1i + dSBNZWRpY2FsIFNwYQAZHBUAFQAVEgAAFr7d6v8HFf4BFr7Brf8HFeIFACbG3qCtARwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFpDtFBauSBa2KibG3qCtATw27OwU + KAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUSAAAWvN/q/wcV/gEWoMet/wcVhgIAJvyIoa0B + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFpDtFBaKRRbuKCb8 + iKGtATw2jO0UKAJlcxgCZW4AGRwVABUAFRIAABa64er/BxX+ARamya3/BxWKAQAm6rGhrQEcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWkO0UFphNFsAuJuqxoa0BPDbs + 7BQoKFNlcnZpY2lvIGRlIFVyZ2VuY2lhIGRlIEFsdGEgUmVzb2x1Y2nDs24YH0JhbmNvIGRlIENy + w6lkaXRvIGUgSW52ZXJzaW9uZXMAGRwVABUAFRIAABa44+r/BxX+ARawyq3/BxW0BAAmquChrQEc + FQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW + kO0UFvhEFt4oJqrgoa0BPDaQ7RQAGRwVABUAFRIAABa25er/BxX+ARbkzq3/BxWCAQAmiImirQEc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaQ7RQW8kQW2igmiImirQE8 + NpDtFAAZHBUAFQAVEgAAFrTn6v8HFf4BFubPrf8HFYIBACbisaKtARwVABk1BggAGRgJaGFzX3Bh + cnRzFQwWiO0UFrbSAhagBybisaKtATwYAQEYAQAWACgBARgBAAAZHBUAFQAVEgAAFrLp6v8HFewB + FujQrf8HFYIBACaCuaKtARwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaI7RQWttICFpYHJoK5 + oq0BPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAWnuvq/wcV7AEW6tGt/wcVggEAJrDBoq0BHBUC + GTUGCAQZGApudW1fZmxvb3JzFQwWiO0UFrgbFpQZJrDBoq0BJpjAoq0BHBgEDgAAABgEAQAAABa0 + 3hQoBA4AAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUSAAAWiu3q/wcV9gEW7NKt/wcVkgIAJqzZoq0B + HBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWiO0UFuQEFoYGJqzZoq0BPBgEAQAA + ABgEAQAAABaG7RQoBAEAAAAYBAEAAAAAGRwVABUAFRIAABaA7+r/BxXsARb+1K3/BxWSAQAmst+i + rQEcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBaI7RQW0gQW9AUmst+irQE8NojtFAAZHBUAFQAVEgAA + Fuzw6v8HFewBFpDWrf8HFYIBACam5aKtARwVAhk1BggAGRgJbWluX2Zsb29yFQwWiO0UFtIEFvQF + Jqbloq0BPDaI7RQAGRwVABUAFRIAABbY8ur/BxXsARaS163/BxWCAQAmmuuirQEcFQwZNQYIABkY + DGZhY2FkZV9jb2xvchUMFojtFBbSBBb0BSaa66KtATw2iO0UABkcFQAVABUSAAAWxPTq/wcV7AEW + lNit/wcVggEAJo7xoq0BHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBaI7RQWzA0W1gkmjvGi + rQE8NqTsFCgEd29vZBgFYnJpY2sAGRwVABUAFRIAABaw9ur/BxXwARaW2a3/BxW8AQAm5PqirQEc + FQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaI7RQW0gQW9AUm5PqirQE8NojtFAAZHBUAFQAVEgAA + FqD46v8HFewBFtLarf8HFYIBACbYgKOtARwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFojtFBboQxbY + EibYgKOtATw2rOcUKAhza2lsbGlvbhgEZG9tZQAZHBUAFQAVEgAAFoz66v8HFfQBFtTbrf8HFfwB + ACawk6OtARwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaI7RQW0gQW9AUmsJOjrQE8NojtFAAZ + HBUAFQAVEgAAFoD86v8HFewBFtDdrf8HFYIBACakmaOtARwVDBk1BggAGRgQcm9vZl9vcmllbnRh + dGlvbhUMFojtFBbSBBb0BSakmaOtATw2iO0UABkcFQAVABUSAAAW7P3q/wcV7AEW0t6t/wcVggEA + Jpifo60BHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWiO0UFswFFtYGJpifo60BPDaA7RQoByNGRjAw + MDAYByM3Nzg4OTkAGRwVABUAFRIAABbY/+r/BxXuARbU363/BxWeAQAm7qWjrQEcFQoZNQYIABkY + C3Jvb2ZfaGVpZ2h0FQwWiO0UFtIEFvQFJu6lo60BPDaI7RQAGRwVABUAFRIAABbGgev/BxXsARby + 4K3/BxWCAQAW5IqGHRaI7RQmhufJngEW3MTZDhQWABn8Jibiq6OtARwVDBk1BggAGRgCaWQVDBbs + vhMWgNu9BRaW284BJuKro60BPDYAKCAwOGJjZjliZDllYzZiZmZmMDIwMDQyOGU3YTdjOWE3MRgg + MDhiY2U4NDgwMTU5OWZmZjAyMDAxNjQ0YzQzZDA5NTIAGRwVABUAFRAAABayg+v/BxXyARb04a3/ + BxXWCAAm+IbyrgEcFQwZNQYIABkYCGdlb21ldHJ5FQwW7L4TFr6e3g8W1sSpCSb4hvKuATw2ACiD + AwAAAAAGAAAAAgAAAAADAAAAAQAAABHAUkfWOp84P8BEw7Ikqto0wFJH1B+nZTTARMOwi02mfMBS + R9eUO4vHwETDqAjIJZ7AUkfZXkAnN8BEw6l+EytWwFJH2MWT82fARMOrIy7ZMcBSR9keE+c+wETD + q1+Uuw7AUkfYdQwbl8BEw6zsXLUNwFJH2L2b12HARMOtQRZKxcBSR9lOT+8swETDrBPvoQ3AUkfc + UaUOQsBEw655+26hwFJH21iAypbARMOxG5ZefMBSR9p3sDrGwETDsH64bMPAUkfY1YQrc8BEw7S6 + h0/rwFJH1pKzzEvARMOy5MQ6V8BSR9hE0BOpwETDrj2VjMXAUkfX3F/nx8BEw64BL6rowFJH1jqf + OD/ARMOyJKraNAAAAAADAAAAAQAAAAXAUkfejH1RZMBEw6u/NgtVwFJH3fPRHZTARMOtuQtO6cBS + R9oXOCrqwETDqrb4TzLAUkfa8BCetMBEw6ixZJF6wFJH3ox9UWTARMOrvzYLVRhNAAAAAAMAAAAB + AAAABMBR1Td52W5xwEV0OPSNv9DAUdU3NZ0mdsBFdDgIhtvVwFHVOCvnQbjARXQ4hUqDNMBR1Td5 + 2W5xwEV0OPSNv9AAGRwVABUAFSQAABakhev/BxWgBBbK6q3/BxWuJQAmzsubuAEcFQgZNQYIABko + BGJib3gEeG1pbhUMFuy+ExaAgE4WgqwvJs7Lm7gBPBgEdgGHwhgEEECSwhYAKAR2AYfCGAQQQJLC + ABkcFQAVABUQAAAWxInr/wcV8gEW+I+u/wcV1gEAJtD3yrgBHBUIGTUGCAAZKARiYm94BHhtYXgV + DBbsvhMWgIBOFrqyLybQ98q4ATwYBGcBh8IYBPw/ksIWACgEZwGHwhgE/D+SwgAZHBUAFQAVEAAA + FraL6/8HFfIBFs6Rrv8HFdYBACaKqvq4ARwVCBk1BggAGSgEYmJveAR5bWluFQwW7L4TFv7/TRae + mDImiqr6uAE8GAQ5liXCGAQH/TPCFgAoBDmWJcIYBAf9M8IAGRwVABUAFRAAABaojev/BxXyARak + k67/BxXWAQAmqMKsuQEcFQgZNQYIABkoBGJib3gEeW1heBUMFuy+ExaAgE4WtOkxJqjCrLkBPBgE + KJYlwhgE+fwzwhYAKAQoliXCGAT5/DPCABkcFQAVABUQAAAWmo/r/wcV8gEW+pSu/wcV1gEAJpys + 3rkBHBUCGTUGCAQZGAd2ZXJzaW9uFQwW7L4TFv4EFqAGJpys3rkBJtyr3rkBHBgEAAAAABgEAAAA + ABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFoyR6/8HFdIBFtCWrv8HFdYBACa8st65 + ARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFuy+Exb+BRagBya8st65 + ASb8sd65ARwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFt6S6/8HFdIBFqaYrv8HFVYAJuC6 + 3rkBHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbsvhMWjroEFojzAibg + ut65ASacud65ARw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQV + BBUCABUAFQQVEAAAFrCU6/8HFeIBFvyYrv8HFfYEACakrOG5ARwVDBklBgAZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAlyZWNvcmRfaWQVDBbsvhMWzNj2AhaoqoIBJqSs4bkBPDYAKAx3OTk4NDAwNjQ1 + QDEYDDAwMDQxY2Y5Mjk4MwAZHBUAFQAVEAAAFpKW6/8HFfIBFvKdrv8HFdYDACaeuOS6ARwVDBkl + BgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFuy+ExaKgxYW7McGJp645LoB + JszW47oBHDYAKBgyMDI0LTExLTI2VDE4OjA1OjU1LjAwMFoYGDIwMTEtMTAtMjVUMjE6MzY6MTEu + MDAwWgAZLBUEFQQVAgAVABUEFRAAABaEmOv/BxXiARbIoa7/BxXWBgAmlJDsugEcFQoZJQYEGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFuy+ExakiB0WvuwZJpSQ7LoBJrie6roB + HBgIAAAAAAAA8D8YCAAAAAD5oN8/FojoBigIAAAAAAAA8D8YCAAAAAD5oN8/ABksFQQVBBUCABUA + FQQVEAAAFuaZ6/8HFfIBFp6orv8HFeoCACa+i4S7ARwVAhk1BggEGRgFbGV2ZWwVDBbsvhMW/gYW + oAgmvouEuwEm9oqEuwEcGAQCAAAAGAQBAAAAFrC+EygEAgAAABgEAQAAAAAZLBUEFQQVAgAVABUE + FRAAABbYm+v/BxXaARaIq67/BxXmAQAmupWEuwEcFQwZNQYIBBkYB3N1YnR5cGUVDBbsvhMWpEoW + kEAmupWEuwEmlpOEuwEcNqjbEigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQV + AgAVABUEFRAAABaynev/BxXiARburK7/BxW+AwAmitiEuwEcFQwZNQYIBBkYBWNsYXNzFQwW7L4T + FtBNFupAJorYhLsBJqbThLsBHDbi3BIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAV + ABUEFRAAABaUn+v/BxXiARassK7/BxWKAwAmkJSFuwEcFQoZNQYIABkYBmhlaWdodBUMFuy+Exaq + BBa6BSaQlIW7ATwYCAAAAAAAAAhAGAgAAAAAAAAIQBbqvhMoCAAAAAAAAAhAGAgAAAAAAAAIQAAZ + HBUAFQAVEAAAFvag6/8HFdIBFrazrv8HFZYBACbKmYW7ARwVDBk1BggAGSgFbmFtZXMHcHJpbWFy + eRUMFuy+Exa6gQEW7FYmypmFuwE8Npq6EygUw5NwdGljYSBTYW50YSBMdWPDrWEYCTQ3IFN0cmVl + dAAZHBUAFQAVEAAAFsii6/8HFeIBFsy0rv8HFdwEACa28IW7ARwVDBklBgAZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlA2tleRUMFvi+ExakFxboEya28IW7ATw23r4TKAJmchgCY3kAGRwVABUAFRAA + ABaqpOv/BxXiARaoua7/BxWWAQAmnoSGuwEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1 + ZQV2YWx1ZRUMFvi+ExakHRb2FiaehIa7ATw23r4TKARUb2RvGC5BaXJjcmFmdCBSZXNjdWUgYW5k + IEZpcmVmaWd0aW5nIFNlcnZpY2UgKEFSRkYpABkcFQAVABUQAAAWjKbr/wcV4gEWvrqu/wcV+AMA + JpSbhrsBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW8L4TFoIa + FvwTJpSbhrsBPDbmvhMoCG9mZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRAAABbup+v/BxXiARa2 + vq7/BxWYAQAmkK+GuwEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdl + FQwW8L4TFp4ZFtQTJpCvhrsBPDbsvhMoAmVzGAJlbgAZHBUAFQAVEAAAFtCp6/8HFeIBFs6/rv8H + FX4AJuTChrsBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvC+Exbq + GxbEFSbkwoa7ATw25r4TKDtTb2NpZWRhZCBBbsOzbmltYSBJbXBvcnRhZG9yYSB5IEV4cG9ydGFk + b3JhIGRlIGxhIFBhdGFnb25pYRgNQkJWQSBGcmFuY8OpcwAZHBUAFQAVEAAAFrKr6/8HFeIBFszA + rv8HFYYCACao2Ia7ARwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRs + aXN0B2VsZW1lbnQVDBbwvhMWiBkWwhMmqNiGuwE8NvC+EwAZHBUAFQAVEAAAFpSt6/8HFeIBFtLC + rv8HFXYAJurrhrsBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW8L4T + FoYZFsATJurrhrsBPDbwvhMAGRwVABUAFRAAABb2ruv/BxXiARbIw67/BxV2ACaq/4a7ARwVABk1 + BggAGRgJaGFzX3BhcnRzFQwW7L4TFo68AhbEBiaq/4a7ATwYAQEYAQAWACgBARgBAAAZHBUAFQAV + EAAAFtiw6/8HFdIBFr7Erv8HFXYAJu6Fh7sBHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFuy+ + ExaOvAIWsAYm7oWHuwE8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaqsuv/BxXSARa0xa7/BxV2 + ACamjYe7ARwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFuy+ExbqCxbyDCamjYe7ASaejIe7ARwYBA8A + AAAYBAEAAAAW3LYTKAQPAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFvyz6/8HFdwBFqrGrv8H + FeYBACaQmYe7ARwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFuy+ExaQBBagBSaQ + mYe7ATw27L4TABkcFQAVABUQAAAW2LXr/wcV0gEWkMiu/wcVdgAmsJ6HuwEcFQoZNQYIABkYCm1p + bl9oZWlnaHQVDBbsvhMWkAQWoAUmsJ6HuwE8Nuy+EwAZHBUAFQAVEAAAFqq36/8HFdIBFobJrv8H + FXYAJtCjh7sBHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbsvhMWkAQWoAUm0KOHuwE8Nuy+EwAZHBUA + FQAVEAAAFvy46/8HFdIBFvzJrv8HFXYAJvCoh7sBHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbs + vhMWkAQWoAUm8KiHuwE8Nuy+EwAZHBUAFQAVEAAAFs666/8HFdIBFvLKrv8HFXYAJpCuh7sBHBUM + GTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbsvhMWqgQWugUmkK6HuwE8GAR3b29kGAR3b29kFuq+ + EygEd29vZBgEd29vZAAZHBUAFQAVEAAAFqC86/8HFdIBFujLrv8HFYYBACbKs4e7ARwVDBk1BggA + GRgNcm9vZl9tYXRlcmlhbBUMFuy+ExaQBBagBSbKs4e7ATw27L4TABkcFQAVABUQAAAW8r3r/wcV + 0gEW7syu/wcVdgAm6riHuwEcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBbsvhMWkAQWoAUm6riHuwE8 + Nuy+EwAZHBUAFQAVEAAAFsS/6/8HFdIBFuTNrv8HFXYAJoq+h7sBHBUKGTUGCAAZGA5yb29mX2Rp + cmVjdGlvbhUMFuy+ExaQBBagBSaKvoe7ATw27L4TABkcFQAVABUQAAAWlsHr/wcV0gEW2s6u/wcV + dgAmqsOHuwEcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbsvhMWkAQWoAUmqsOHuwE8Nuy+ + EwAZHBUAFQAVEAAAFujC6/8HFdIBFtDPrv8HFXYAJsrIh7sBHBUMGTUGCAAZGApyb29mX2NvbG9y + FQwW7L4TFpAEFqAFJsrIh7sBPDbsvhMAGRwVABUAFRAAABa6xOv/BxXSARbG0K7/BxV2ACbqzYe7 + ARwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbsvhMWkAQWoAUm6s2HuwE8Nuy+EwAZHBUAFQAVEAAA + FozG6/8HFdIBFrzRrv8HFXYAFsauixsW7L4TJuKro60BFqin5A0UGAAZ/CYmitOHuwEcFQwZNQYI + ABkYAmlkFQwW1IkVFuLg9gUWjOfWASaK04e7ATw2ACggMDhiY2VhZTZkZWMxOGZmZjAyMDA1MmNj + OTc1N2EwZmMYIDA4YmNlODUyNjUxOTZmZmYwMjAwNjkzOTM1ZWViNDk2ABkcFQAVABUSAAAW3sfr + /wcVkAIWstKu/wcV3gkAJpa63rwBHBUMGTUGCAAZGAhnZW9tZXRyeRUMFtSJFRa0ybgRFti1qQom + lrrevAE8NgAo4wEAAAAABgAAAAIAAAAAAwAAAAEAAAAHwFI+hHTFCfLARIpvtosMmMBSPoOKLH1i + wESKb6kAcRTAUj6Dl/S1HsBEim2GMrHMwFI+hjqce3nARIptrSPdPsBSPoYUiYg9wESKdECQplPA + Uj6EWCDFgcBEinQm6ctrwFI+hHTFCfLARIpvtosMmAAAAAADAAAAAQAAAAXAUj6GOpx7ecBEim2t + I90+wFI+hkaIbz7ARIpr1B+9hsBSPoc6FKs5wESKa+IuctPAUj6HLijFAsBEim27MpPPwFI+hjqc + e3nARIptrSPdPhhNAAAAAAMAAAABAAAABMBSOg12JijIwESzKmVANYnAUjoNTa93acBEsyutos8K + wFI6DJH2Kq/ARLMreS3QGsBSOg12JijIwESzKmVANYkAGRwVABUAFSgAABbuyev/BxXcBBaQ3K7/ + BxW+KQAmoOSXxwEcFQgZNQYIBBkoBGJib3gEeG1pbhUMFtSJFRagtj0WmKo2JqDkl8cBJu7vh8cB + HBgEF9iQwhgEGUCSwhYAKAQX2JDCGAQZQJLCABksFQQVBBUCABUAFQQVEgAAFsrO6/8HFZACFs6F + r/8HFe4BACb2i87HARwVCBk1BggEGSgEYmJveAR4bWF4FQwW1IkVFtayPRaEqDYm9ovOxwEmhpq+ + xwEcGAQL2JDCGAT7P5LCFgAoBAvYkMIYBPs/ksIAGSwVBBUEFQIAFQAVBBUSAAAW2tDr/wcVkAIW + vIev/wcV7gEAJu7KisgBHBUIGTUGCAQZKARiYm94BHltaW4VDBbUiRUW6LpHFoL5PCbuyorIASaK + wvTHARwYBCXUI8IYBBbwJcIWACgEJdQjwhgEFvAlwgAZLBUEFQQVAgAVABUEFRIAABbq0uv/BxWQ + Ahaqia//BxXuAQAmgsHHyAEcFQgZNQYIBBkoBGJib3gEeW1heBUMFtSJFRbatkcWwPY8JoLBx8gB + Joy7scgBHBgE/tMjwhgE+O8lwhYAKAT+0yPCGAT47yXCABksFQQVBBUCABUAFQQVEgAAFvrU6/8H + FZACFpiLr/8HFe4BACaMsu7IARwVAhk1BggEGRgHdmVyc2lvbhUMFtSJFRbIBRb8BiaMsu7IASbM + se7IARwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaK1+v/BxXs + ARaGja//BxXuAQAmiLnuyAEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkV + DBbUiRUW2AYWjAgmiLnuyAEmyLjuyAEcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABb22Ov/ + BxXsARb0jq//BxVeACaYwu7IARwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0 + FQwW1IkVFtCbBRbynwMmmMLuyAEm1MDuyAEcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVu + IEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABbi2uv/BxX+ARbSj6//BxXCBQAmxuDxyAEcFQwZ + JQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW1IkVFq7IlwMWtKqBASbG4PHI + ATw2ACgMdzk5ODMwMDY5MUAyGAwwMDAxNTgzNmMyOTEAGRwVABUAFRIAABbg3Ov/BxWQAhaUla// + BxWOBAAmxPX0yQEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbU + iRUW1McgFtKZCSbE9fTJASb6ivPJARw2ACgYMjAyNC0xMS0yOVQxODozMDo0Ni4wMDBaGBgyMDEw + LTAyLTI0VDIxOjAwOjI4LjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAW8N7r/wcVggIWopmv/wcVvgcA + JtzE/ckBHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbUiRUW7KQf + FuTYGybcxP3JASbMpPzJARwYCNJvXwfOGe8/GAjNzMzMzMzkPxb8jAcoCNJvXwfOGe8/GAjNzMzM + zMzkPwAZLBUEFQQVAgAVABUEFRIAABby4Ov/BxWQAhbgoK//BxWSAwAmiP6XygEcFQIZNQYIBBkY + BWxldmVsFQwW1IkVFq4KFrALJoj+l8oBJrD9l8oBHBgEBgAAABgE/////xaoiBUoBAYAAAAYBP// + //8AGSwVBBUEFQIAFQAVBBUSAAAWguPr/wcV9gEW8qOv/wcV4gEAJoaLmMoBHBUMGTUGCAQZGAdz + dWJ0eXBlFQwW1IkVFsJRFsREJoaLmMoBJuCImMoBHDa8vxQoDnRyYW5zcG9ydGF0aW9uGAxhZ3Jp + Y3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAW+OTr/wcV/gEW1KWv/wcVwgMAJqjSmMoBHBUMGTUG + CAQZGAVjbGFzcxUMFtSJFRbwVhbOSSao0pjKASakzZjKARw2wsEUKAl3YXJlaG91c2UYD2FsbG90 + bWVudF9ob3VzZQAZLBUEFQQVAgAVABUEFRIAABb25uv/BxX+ARaWqa//BxXQAwAm8paZygEcFQoZ + NQYIABkYBmhlaWdodBUMFtSJFRbEBhaMBybylpnKATwYCAAAAAAAAC5AGAgAAAAAAAAUQBbAiRUo + CAAAAAAAAC5AGAgAAAAAAAAUQAAZHBUAFQAVEgAAFvTo6/8HFe4BFuasr/8HFcIBACb+nZnKARwV + DBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFtSJFRbm7AEW4JABJv6dmcoBPDa+gRUoEGp1bnRhIGRl + IHZlY2lub3MYGjJkYSBDb21wYcOxw61hIGRlIEJvbWJlcm9zABkcFQAVABUSAAAW4urr/wcV/gEW + qK6v/wcV6gUAJt6umsoBHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW2okV + FpAmFpAdJt6umsoBPDbKiRUoAmVzGAJlbgAZHBUAFQAVEgAAFuDs6/8HFf4BFpK0r/8HFaIBACbu + y5rKARwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW2okVFuwuFpIhJu7L + msoBPDbKiRUoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEgAAFt7u6/8HFf4BFrS1 + r/8HFdQDACbq7ZrKARwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUM + FuKJFRaELRbuHybq7ZrKASaA7ZrKARw2sokVKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABksFQQVBBUC + ABUAFQQVEgAAFtzw6/8HFf4BFoi5r/8HFcwCACbujJvKARwVDBklBgAZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbiiRUWliwW5B4m7oybygE8Nt6JFSgCZXMYAmVuABkcFQAV + ABUSAAAW2vLr/wcV/gEW1Luv/wcVigEAJsqwm8oBHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudAV2YWx1ZRUMFuKJFRb2MxaiJCbKsJvKASbSq5vKARw2sokVKBVUb21wa2lucyBDb25z + ZXJ2YXRpb24YH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJzaW9uZXMAGSwVBBUEFQIAFQAVBBUS + AAAW2PTr/wcV/gEW3ryv/wcVlAYAJvTPm8oBHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFuKJFRaKLBbUHib0z5vKATw24okVABkcFQAVABUS + AAAW1vbr/wcV/gEW8sKv/wcVggEAJsjum8oBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudARzaWRlFQwW4okVFv4rFs4eJsjum8oBPDbiiRUAGRwVABUAFRIAABbU+Ov/BxX+ARb0w6// + BxWCAQAmlo2cygEcFQAZNQYIABkYCWhhc19wYXJ0cxUMFtSJFRaA1gIW4Acmlo2cygE8GAEBGAEA + FgAoAQEYAQAAGRwVABUAFRIAABbS+uv/BxXuARb2xK//BxWCAQAm9pScygEcFQAZNQYIABkYDmlz + X3VuZGVyZ3JvdW5kFQwW1IkVFoDWAhaWByb2lJzKATwYAQAYAQAWACgBABgBAAAZHBUAFQAVEgAA + FsD86/8HFewBFvjFr/8HFYIBACaEnZzKARwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFtSJFRaSGxaw + GSaEnZzKASaMnJzKARwYBBQAAAAYBAEAAAAWyoAVKAQUAAAAGAQBAAAAABksFQQVBBUCABUAFQQV + EgAAFqz+6/8HFfwBFvrGr/8HFZICACa8tZzKARwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdy + b3VuZBUMFtSJFRbSBBb0BSa8tZzKATw21IkVABkcFQAVABUSAAAWqIDs/wcV7AEWjMmv/wcVggEA + JrC7nMoBHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW1IkVFtIEFvQFJrC7nMoBPDbUiRUAGRwVABUA + FRIAABaUguz/BxXsARaOyq//BxWCAQAmpMGcygEcFQIZNQYIABkYCW1pbl9mbG9vchUMFtSJFRbS + BBb0BSakwZzKATw21IkVABkcFQAVABUSAAAWgITs/wcV7AEWkMuv/wcVggEAJpjHnMoBHBUMGTUG + CAAZGAxmYWNhZGVfY29sb3IVDBbUiRUW0gQW9AUmmMecygE8NtSJFQAZHBUAFQAVEgAAFuyF7P8H + FewBFpLMr/8HFYIBACaMzZzKARwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwW1IkVFs4GFtQH + JozNnMoBPDbCiRUoBHdvb2QYBWJyaWNrABkcFQAVABUSAAAW2Ifs/wcV7gEWlM2v/wcV7gEAJuDU + nMoBHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW1IkVFu4EFpAGJuDUnMoBPBgFbWV0YWwYBW1l + dGFsFtKJFSgFbWV0YWwYBW1ldGFsABkcFQAVABUSAAAWxons/wcV7AEWgs+v/wcVlgEAJvDanMoB + HBUMGTUGCAAZGApyb29mX3NoYXBlFQwW1IkVFoYMFuwJJvDanMoBPDaMiRUoCHNraWxsaW9uGARm + bGF0ABkcFQAVABUSAAAWsovs/wcV8gEWmNCv/wcV7gEAJtzknMoBHBUKGTUGCAAZGA5yb29mX2Rp + cmVjdGlvbhUMFtSJFRbsBBaOBibc5JzKATwYCAAAAAAAgGZAGAgAAAAAAIBmQBbSiRUoCAAAAAAA + gGZAGAgAAAAAAIBmQAAZHBUAFQAVEgAAFqSN7P8HFewBFobSr/8HFaIBACbq6pzKARwVDBk1BggA + GRgQcm9vZl9vcmllbnRhdGlvbhUMFtSJFRbuBBaQBibq6pzKATwYBWFsb25nGAVhbG9uZxbSiRUo + BWFsb25nGAVhbG9uZwAZHBUAFQAVEgAAFpCP7P8HFewBFqjTr/8HFZYBACb68JzKARwVDBk1BggA + GRgKcm9vZl9jb2xvchUMFtSJFRbyBBaUBib68JzKATwYByMyODI4MkQYByMyODI4MkQW0okVKAcj + MjgyODJEGAcjMjgyODJEABkcFQAVABUSAAAW/JDs/wcV7AEWvtSv/wcVngEAJo73nMoBHBUKGTUG + CAAZGAtyb29mX2hlaWdodBUMFtSJFRbSBBb0BSaO95zKATw21IkVABkcFQAVABUSAAAW6JLs/wcV + 7AEW3NWv/wcVggEAFoTGoR0W1IkVJorTh7sBFviplQ8UGgAZ/CYmgv2cygEcFQwZNQYIABkYAmlk + FQwW7PIUFsir8AUW/NDZASaC/ZzKATw2ACggMDhiY2VhYWM5YjA5M2ZmZjAyMDAwMTZiNWViNTRh + MGMYIDA4YmNlODA4MDgzYjVmZmYwMjAwMzBlNWMwYjEyOTgzABkcFQAVABUSAAAW1JTs/wcVkAIW + 3tav/wcV3gkAJv7N9ssBHBUMGTUGCAAZGAhnZW9tZXRyeRUMFuzyFBaO/vIQFpijgAom/s32ywE8 + NgAo5w8AAAAABgAAAAYAAAAAAwAAAAEAAAAUwFHQP2jLm3TARJANQTEiuMBR0D7Cs25XwESQDDMU + KYPAUdA+Yqa+RcBEkArfVxMMwFHQPlRkBWPARJAJbxSK0cBR0D6ZmMLawESQCA0Uu3nAUdA/KeF6 + 2sBEkAbiclB/wFHQP/R3NcLARJAGEz935cBR0EDhcZ+AwESQBbb5JfHAUdBBw++uecBEkAXR0RiM + wFHQQpU7ZgjARJAGVltWaMBR0ENAXBCiwESQBzcr5jjAUdBDtB9W3cBEkAhcxdO0wFHQQ+UyHmDA + RJAJqqOtGcBR0EPOi+muwESQCv5gw4/AUdBDcdo378BEkAw3RedrwFHQQtkuBB/ARJANM8UpasBR + 0EIToMa1wESQDduK1bHAUdBBNOkV2cBEkA4dz/SfwFHQQEIPbwnARJAN7FHNUsBR0D9oy5t0wESQ + DUExIrgAAAAAAwAAAAEAAAAUwFHQPUSZjQTARJAEmplz2sBR0DyIRor/wESQA93bEgrAUdA7/QZQ + fMBEkALRa5f/wFHQO7BE1srARJABkPm358BR0DuqZZm4wESQADuPIkfAUdA769P5EcBEj/71PgUe + wFHQPG5FV/nARI/93r2QGcBR0D0j4l1YwESP/RO8dWfAUdA9+qHyLsBEj/yoXKr8wFHQPu17mP7A + RI/8rWUoecBR0D/RpychwESP/Szm6NjAUdBAi3XqaMBEj/4XyHOiwFHQQQZajRTARI//VAiV0cBR + 0EEzO5avwESQALvnojvAUdBBDRCJu8BEkAImSu1kwFHQQJgLJCDARJADZrzNe8BR0D/ibh7CwESQ + BFoB1BbAUdA/AMbPXcBEkATivc/awFHQPh60IC7ARJAE9FuHD8BR0D1EmY0EwESQBJqZc9oAAAAA + AwAAAAEAAAAUwFHQOsT37DXARI/70MZWkcBR0Dn2MHNlwESP+zCNZoXAUdA5U3NEm8BEj/o2kmNE + wFHQOOywl+PARI/4+//AP8BR0DjMZMgBwESP96C17Y3AUdA49erTSMBEj/ZH8FmawFHQOWUQ+9HA + RI/1FBOzO8BR0DoOhCdCwESP9CQpqvTAUdA64X1d+sBEj/OQhfShwFHQO9t4YTvARI/zaRjITsBR + 0DzPKMefwESP88La24PAUdA9oN/e+MBEj/STuzNHwFHQPjdzM9TARI/1wo9cKcBR0D6BRQ7+wESP + 9ywb573AUdA+dYaU2sBEj/imb2rywFHQPhXlRJPARI/6BD18YsBR0D1ttDiBwESP+x1CMCbAUdA8 + kD6nBcBEj/vP75b8wFHQO6rQ+YLARI/8CCO68MBR0DrE9+w1wESP+9DGVpEAAAAAAwAAAAEAAAAU + wFHQOD8LrorARI/ydCZCisBR0Ddtv/b7wESP8dj1z/vAUdA2yBMpqMBEj/Dhfwt5wFHQNl83nfzA + RI/vp8MoCMBR0DY+gG5PwESP7kuilcLAUdA2aN05LMBEj+zy3QHOwFHQNtocQKjARI/rv9cbBMBR + 0DeGfwqiwESP6tJxUXzAUdA4W/yAGcBEj+pFg5fQwFHQOU3/Z1TARI/qJnnnTcBR0Do44PIewESP + 6oLAOUHAUdA7Ap/tccBEj+tOmBOIwFHQO5O/ZQXARI/sc1tBb8BR0DvcTyDQwESP7dEpUuDAUdA7 + 0+uk/8BEj+8+ENzHwFHQO3trsSnARI/wkqSy0sBR0DrdS6ASwESP8ahOaEPAUdA6Cyko7sBEj/Jf + LY0BwFHQOSYm2zbARI/yoklrhMBR0Dg/C66KwESP8nQmQooAAAAAAwAAAAEAAAAVwFHQOvWfU+7A + RJAPu17mP8BR0Ddlx9r2wESQEkSmIj7AUdA2bKOXScBEkBJRO1v3wFHQNXo1UETARJARtF1qPsBR + 0DR2lLHTwESQEBlSt13AUdAtzgQEccBEj/rCqV1cwFHQLTcFT8vARI/4rfwnLcBR0C0dBBzFwESP + 9mzZRy/AUdAtgoSqHsBEj/Q+Kt36wFHQLlyfPUjARI/yYbHLwMBR0C+SlMKawESP8QtwdovAUdAw + 7/d0QMBEj/BnBciXwFHQMl21vb3ARI/wb2lEZ8BR0DO3UhFFwESP8SSa6fzAUdA02SWgo8BEj/J0 + JkKKwFHQNaaq+hTARI/0PH1e0MBR0DwzIZV8wESQCjrsZRnAUdA8cuJ1q8BEkAwFx8AewFHQPDMh + lXzARJANhtE/+cBR0DusExjhwESQDs35HLfAUdA69Z9T7sBEkA+7XuY/AAAAAAMAAAABAAAAFMBR + 0Du3ZjM7wESQGgVkw8/AUdA63HTgfcBEkBoXAnsFwFHQOgik6jDARJAZwJtmIsBR0DlRWmWnwESQ + GQqTAPnAUdA4yQnJrcBEkBgHXcJTwFHQOHqa0NHARJAWtiTqm8BR0Dh8SE/7wESQFVGg3ITAUdA4 + zabnYMBEkBQCFYP2wFHQOWUQ+9HARJAS8J2MbcBR0DoxVDXiwESQEjtr5tnAUdA7GhzhuMBEkBH4 + UAhWwFHQPAO8TSPARJASL61stcBR0DzTxeVSwESQEtrOF1DAUdA9cQ821cBEkBPlkBIxwFHQPcVd + bMPARJAVFuh50cBR0D3WJGRjwESQFmCUlU7AUdA9obaejcBEkBeh3TT6wFHQPS0cmL3ARJAYugsp + KcBR0DyEFM0XwESQGYyZABfAUdA7t2YzO8BEkBoFZMPPGE0AAAAAAwAAAAEAAAAEwFHVeaoNDMnA + RJUXWP/t48BR1Xk/pDjkwESVFfG4ZcXAUdV6SK4MOsBElRbtrcnGwFHVeaoNDMnARJUXWP/t4wAZ + HBUAFQAVJgAAFuSW7P8HFb4EFrzgr/8HFbYnACaW8fbVARwVCBk1BggAGSgEYmJveAR4bWluFQwW + 7PIUFsrQUxaowy4mlvH21QE8GARAoIzCGAQIQJLCFgAoBECgjMIYBAhAksIAGRwVABUAFRIAABai + m+z/BxWQAhbyh7D/BxXuAQAmvrSl1gEcFQgZNQYIABkoBGJib3gEeG1heBUMFuzyFBbI0FMW6sEu + Jr60pdYBPBgENaCMwhgE+j+SwhYAKAQ1oIzCGAT6P5LCABkcFQAVABUSAAAWsp3s/wcVkAIW4Imw + /wcV7gEAJqj209YBHBUIGTUGCAAZKARiYm94BHltaW4VDBbs8hQWxNBTFqDSMSao9tPWATwYBAkg + I8IYBATAKMIWACgECSAjwhgEBMAowgAZHBUAFQAVEgAAFsKf7P8HFZACFs6LsP8HFe4BACbIyIXX + ARwVCBk1BggAGSgEYmJveAR5bWF4FQwW7PIUFsrQUxba1TEmyMiF1wE8GATvHyPCGATlvyjCFgAo + BO8fI8IYBOW/KMIAGRwVABUAFRIAABbSoez/BxWQAha8jbD/BxXuAQAm4p631wEcFQIZNQYIBBkY + B3ZlcnNpb24VDBbs8hQWyAUW/AYm4p631wEmop631wEcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAA + AAAAGSwVBBUEFQIAFQAVBBUSAAAW4qPs/wcV7AEWqo+w/wcV7gEAJt6lt9cBHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW7PIUFtgGFowIJt6lt9cBJp6lt9cBHBgAGAAW + ACgAGAAAGSwVBBUEFQIAFQAVBBUSAAAWzqXs/wcV7AEWmJGw/wcVXgAm7q631wEcFQwZJQYEGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFuzyFBaSkAUW3pcDJu6ut9cBJqqtt9cBHDYA + KA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUSAAAW + uqfs/wcV/gEW9pGw/wcVwgUAJojFutcBHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJl + Y29yZF9pZBUMFuzyFBaI4ZQDFuD/hgEmiMW61wE8NgAoDHc5OTkzMjUxODhAMRgMMDAwMDNjMjdm + YWUyABkcFQAVABUSAAAWuKns/wcVkAIWuJew/wcVjgQAJsq/wtgBHBUMGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW7PIUFvSaGhaW1gcmyr/C2AEm6MTB2AEcNgAoGDIw + MjQtMTEtMjRUMDE6MDA6NTYuMDAwWhgYMjAwOS0wMi0wNlQyMzoxNToyMS4wMDBaABksFQQVBBUC + ABUAFQQVEgAAFsir7P8HFf4BFsabsP8HFb4HACbMx8rYARwVChklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudApjb25maWRlbmNlFQwW7PIUFtrJHxa6iRwmzMfK2AEm/prJ2AEcGAgAAAAAAADwPxgI + zczMzMzM5D8W9ugGKAgAAAAAAADwPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUSAAAWxq3s/wcV + kAIWhKOw/wcVkAMAJrik5dgBHBUCGTUGCAAZGAVsZXZlbBUMFuzyFBa8CxaWCia4pOXYATwYBAQA + AAAYBP////8W/PEUKAQEAAAAGAT/////ABkcFQAVABUSAAAW1q/s/wcV9gEWlKaw/wcV4gEAJvSw + 5dgBHBUMGTUGCAQZGAdzdWJ0eXBlFQwW7PIUFqxJFuA/JvSw5dgBJs6u5dgBHDaWuxQoDnRyYW5z + cG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAWzLHs/wcV/gEW9qew/wcV + /gMAJp7z5dgBHBUMGTUGCAQZGAVjbGFzcxUMFuzyFBacShbePyae8+XYASau7uXYARw20r4UKAl3 + YXJlaG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUSAAAWyrPs/wcV/gEW9Kuw/wcVogMA + Joyu5tgBHBUKGTUGCAAZGAZoZWlnaHQVDBbs8hQWjgYWhAcmjK7m2AE8GAgAAAAAAAA0QBgIAAAA + AAAAEEAW3PIUKAgAAAAAAAA0QBgIAAAAAAAAEEAAGRwVABUAFRIAABbItez/BxXwARaWr7D/BxXi + AQAm2Ljn2AEcFQwZNQYIBBkoBW5hbWVzB3ByaW1hcnkVDBbs8hQWxtACFqy1ASbYuOfYASaQtebY + ARw2vOUUKAdyYXBhbnVpGBciSHVlbXVsIFByb2plY3QiIHJvbWphaQAZLBUEFQQVAgAVABUEFRIA + ABa4t+z/BxX+ARb4sLD/BxXgBQAmvOrn2AEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1 + ZQNrZXkVDBas8xQWpi8WzCEmvOrn2AE8Nq7yFCgCcHQYAmRlABkcFQAVABUSAAAWtrns/wcV/gEW + 2Law/wcVsgEAJs6Y6NgBHBUMGSUGBBlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBas + 8xQWoEYWuDAmzpjo2AEmiIzo2AEcNq7yFCgdV8Okcm1lLSB1bmQgU3Ryw7ZtdW5nc3RoZW9yaWUY + FyJIdWVtdWwgUHJvamVjdCIgcm9tamFpABksFQQVBBUCABUAFQQVEgAAFrS77P8HFf4BFoq4sP8H + FZYEACbAvOjYARwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFvjy + FBb0NBb6IybAvOjYATw2yvIUKAVzaG9ydBgJYWx0ZXJuYXRlABkcFQAVABUSAAAWsr3s/wcV/gEW + oLyw/wcVgAIAJrrg6NgBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFn + ZRUMFvjyFBb4MBaaIia64OjYATw28PIUKAJlcxgCZW4AGRwVABUAFRIAABawv+z/BxX+ARagvrD/ + BxWSAQAm1ILp2AEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW+PIU + FpA5FvAnJtSC6dgBPDbK8hQoDlNhbG9tb24gU3BvcnRzGBBBbHRvcyBkZWwgQm9uaXRvABkcFQAV + ABUSAAAWrsHs/wcV/gEWsr+w/wcVzgQAJsSq6dgBHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFvjyFBbQMBb4ISbEqunYATw2+PIUABkcFQAV + ABUSAAAWrMPs/wcV/gEWgMSw/wcVggEAJrzM6dgBHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudARzaWRlFQwW+PIUFsgwFvYhJrzM6dgBPDb48hQAGRwVABUAFRIAABaqxez/BxX+ARaC + xbD/BxWCAQAmsu7p2AEcFQAZNQYIABkYCWhhc19wYXJ0cxUMFuzyFBaS0wIW5Acmsu7p2AE8GAEB + GAEAFgAoAQEYAQAAGRwVABUAFRIAABaox+z/BxXuARaExrD/BxWCAQAmlvbp2AEcFQAZNQYIABkY + DmlzX3VuZGVyZ3JvdW5kFQwW7PIUFpLTAhaWByaW9unYATwYAQAYAQAWACgBABgBAAAZHBUAFQAV + EgAAFpbJ7P8HFewBFobHsP8HFYIBACbE/unYARwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFuzyFBb+ + ERbUEibE/unYASas/enYARwYBBAAAAAYBAEAAAAW+usUKAQQAAAAGAQBAAAAABksFQQVBBUCABUA + FQQVEgAAFoLL7P8HFfgBFojIsP8HFfIBACaAkOrYARwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRl + cmdyb3VuZBUMFuzyFBbSBBb0BSaAkOrYATw27PIUABkcFQAVABUSAAAW+szs/wcV7AEW+smw/wcV + ggEAJvSV6tgBHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW7PIUFtIEFvQFJvSV6tgBPDbs8hQAGRwV + ABUAFRIAABbmzuz/BxXsARb8yrD/BxWCAQAm6Jvq2AEcFQIZNQYIABkYCW1pbl9mbG9vchUMFuzy + FBaiBRa+Bibom+rYATwYBAIAAAAYBAEAAAAW4PIUKAQCAAAAGAQBAAAAABkcFQAVABUSAAAW0tDs + /wcV7AEW/suw/wcVsgEAJqai6tgBHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbs8hQWkAcWgAgm + pqLq2AE8NtjyFCgHI0ZGRkZGRhgHIzAwMDBGRgAZHBUAFQAVEgAAFr7S7P8HFfABFrDNsP8HFfIB + ACamqurYARwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwW7PIUFqQFFsYGJqaq6tgBPDbm8hQo + BHdvb2QYBW1ldGFsABkcFQAVABUSAAAWrtTs/wcV7AEWos+w/wcVugEAJuyw6tgBHBUMGTUGCAAZ + GA1yb29mX21hdGVyaWFsFQwW7PIUFvgEFpoGJuyw6tgBPBgKcm9vZl90aWxlcxgKcm9vZl90aWxl + cxbq8hQoCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMAGRwVABUAFRIAABaa1uz/BxXsARbc0LD/BxWq + AQAmhrfq2AEcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBbs8hQWvg8W7Aomhrfq2AE8NoDyFCgJcHly + YW1pZGFsGARmbGF0ABkcFQAVABUSAAAWhtjs/wcV9AEWhtKw/wcV/gEAJvLB6tgBHBUKGTUGCAAZ + GA5yb29mX2RpcmVjdGlvbhUMFuzyFBbSBBb0BSbywerYATw27PIUABkcFQAVABUSAAAW+tns/wcV + 7AEWhNSw/wcVggEAJubH6tgBHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW7PIUFu4EFpAG + JubH6tgBPBgFYWxvbmcYBWFsb25nFuryFCgFYWxvbmcYBWFsb25nABkcFQAVABUSAAAW5tvs/wcV + 7AEWhtWw/wcVlgEAJvbN6tgBHBUMGTUGCAAZGApyb29mX2NvbG9yFQwW7PIUFsgNFsQJJvbN6tgB + PDac8hQoByNGRjAwMDAYByMwMDAwMDAAGRwVABUAFRIAABbS3ez/BxXyARac1rD/BxWOAgAmutfq + 2AEcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW7PIUFtIEFvQFJrrX6tgBPDbs8hQAGRwVABUAFRIA + ABbE3+z/BxXsARaq2LD/BxWCAQAW3LySHRbs8hQmgv2cygEWrODNDhQcABn8Jiau3erYARwVDBk1 + BggAGRgCaWQVDBaMsRMWgOy5BRa+tssBJq7d6tgBPDYAKCAwOGJjZWFhN2I2ZDEwZmZmMDIwMGRi + ODE2M2Y1M2MyORggMDhiY2U4MDAwMDBlY2ZmZjAyMDA5MGNiOTgxODFmNDgAGRwVABUAFRAAABaw + 4ez/BxXyARas2bD/BxXWCAAm7JO22gEcFQwZNQYIABkYCGdlb21ldHJ5FQwWjLETFoD+7g8WnpO9 + CSbsk7baATw2ACj9AwAAAAAGAAAABAAAAAADAAAAAQAAAAXAUc7INtB2pcBEkBnKrGEcwFHOyDbQ + dqXARJAcwq5l2cBRzsZccENfwESQHMKuZdnAUc7GXHBDX8BEkBnKrGEcwFHOyDbQdqXARJAZyqxh + HAAAAAADAAAAAQAAAAXAUc7Q6z9+m8BEkBxj49UnwFHOz1pFxrTARJAcMY7uRcBRzs94DVfXwESQ + GhcCewXAUc7RCXJvicBEkBpKLiF7wFHO0Os/fpvARJAcY+PVJwAAAAADAAAAAQAAAAbAUc650oml + MMBEkBYq5LAYwFHOs2NvOyHARJAQM1PqY8BRzrZkq3tDwESQCNjslcDAUc67hXysI8BEkA2aHHZY + wFHOu5XYQ/nARJAR2vPW/cBRzrnSiaUwwESQFirksBgAAAAAAwAAAAEAAAAMwFHO0DzD1a3ARJAQ + QL/jsMBRztEjCELFwESQFV8M1dHAUc7Q79ycTsBEkBgINIHowFHOwqYCXajARJAVkjh8SMBRzr/z + oHYtwESQFuAWVa3AUc6/BPiNRcBEkBTEsyLYwFHOvy9VWCHARJAS3VJWDsBRzr5JEOsKwESQEqlP + 8ALAUc69ySPK4MBEkA+ApoONwFHOv7el9BvARJAPwGdjvMBRzr/aCqLxwESQDNd+13bAUc7QPMPV + rcBEkBBAv+OwGE0AAAAAAwAAAAEAAAAEwFHVgb6NEtDARHy0Ul2yGcBR1YIFKHyFwER8tUGFerXA + UdWBJxi+QMBEfLXYKGnDwFHVgb6NEtDARHy0Ul2yGQAZHBUAFQAVJAAAFqLj7P8HFaAEFoLisP8H + Fa4lACaKp/PjARwVCBk1BggAGSgEYmJveAR4bWluFQwWjLETFoDJTRb04C0miqfz4wE8GAQJoIzC + GAQUQJLCFgAoBAmgjMIYBBRAksIAGRwVABUAFRAAABbC5+z/BxXyARawh7H/BxXWAQAm/oeh5AEc + FQgZNQYIABkoBGJib3gEeG1heBUMFoyxExaAyU0WmOAtJv6HoeQBPBgEBKCMwhgE/T+SwhYAKAQE + oIzCGAT9P5LCABkcFQAVABUQAAAWtOns/wcV8gEWhomx/wcV1gEAJpbozuQBHBUIGTUGCAAZKARi + Ym94BHltaW4VDBaMsRMWgMlNFpbWLyaW6M7kATwYBAxQIMIYBBjvJcIWACgEDFAgwhgEGO8lwgAZ + HBUAFQAVEAAAFqbr7P8HFfIBFtyKsf8HFdYBACasvv7kARwVCBk1BggAGSgEYmJveAR5bWF4FQwW + jLETFv7ITRbE2y8mrL7+5AE8GATuTyDCGAQB7yXCFgAoBO5PIMIYBAHvJcIAGRwVABUAFRAAABaY + 7ez/BxXyARayjLH/BxXWAQAmsJqu5QEcFQIZNQYIBBkYB3ZlcnNpb24VDBaMsRMW/gQWoAYmsJqu + 5QEm8Jmu5QEcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWiu/s + /wcV0gEWiI6x/wcV1gEAJtCgruUBHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3Bl + cnR5FQwWjLETFv4FFqAHJtCgruUBJpCgruUBHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW + 3PDs/wcV0gEW3o+x/wcVVgAm9Kiu5QEcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0 + YXNldBUMFoyxExbI5AQW5OQCJvSoruUBJrCnruUBHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUg + T3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWrvLs/wcV4gEWtJCx/wcV9gQAJpSMseUB + HBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFoyxExaI9/YCFtyyhAEm + lIyx5QE8NgAoDHc5OTkyNjc2NDVAMRgMMDAwMDE5ZGEyNTk1ABkcFQAVABUQAAAWkPTs/wcV8gEW + qpWx/wcV1gMAJqyetuYBHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1l + FQwWjLETFvS1FhbqgQYmrJ625gEm8L615gEcNgAoGDIwMjQtMTEtMzBUMTk6NDI6MjAuMDAwWhgY + MjAxMS0wOC0wOFQxNzowMzo1NS4wMDBaABksFQQVBBUCABUAFQQVEAAAFoL27P8HFeIBFoCZsf8H + FdYGACaK5LzmARwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWjLET + FvKlHRbe8hkmiuS85gEm2sC75gEcGAh8YTJVMCrvPxgIzczMzMzM5D8W7LgGKAh8YTJVMCrvPxgI + zczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW5Pfs/wcV8gEW1p+x/wcV5gIAJoC01eYBHBUCGTUG + CAQZGAVsZXZlbBUMFoyxExaEBhamByaAtNXmASa4s9XmARwYBAEAAAAYBP7///8W7LATKAQBAAAA + GAT+////ABksFQQVBBUCABUAFQQVEAAAFtb57P8HFdYBFryisf8HFdYBACaGvdXmARwVDBk1BggE + GRgHc3VidHlwZRUMFoyxExb8LhacKCaGvdXmASbeutXmARw2wJcTKA50cmFuc3BvcnRhdGlvbhgM + YWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFqz77P8HFeIBFpKksf8HFcIDACaa59XmARwV + DBk1BggEGRgFY2xhc3MVDBaMsRMWnDEW6igmmufV5gEm+uLV5gEcNsqYEygJd2FyZWhvdXNlGAph + cGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFo797P8HFeIBFtSnsf8HFeQCACbki9bmARwVChk1 + BggAGRgGaGVpZ2h0FQwWjLETFpgHFsIGJuSL1uYBPBgIAAAAAAAANEAYCAAAAAAAABBAFuKwEygI + AAAAAAAANEAYCAAAAAAAABBAABkcFQAVABUQAAAW8P7s/wcV1AEWuKqx/wcV1gEAJqaS1uYBHBUM + GTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWjLETFsaTARboXSamktbmATw24KsTKBJ2ZW50YSBkZSBm + cnV0aWxsYXMYAjA2ABkcFQAVABUQAAAWxIDt/wcV4gEWjqyx/wcVjAUAJo7w1uYBHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWjrETFuQXFtoTJo7w1uYBPDaEsRMoAmVzGAJl + bgAZHBUAFQAVEAAAFqaC7f8HFeIBFpqxsf8HFY4BACbog9fmARwVDBklBgAZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlBXZhbHVlFQwWjrETFoAdFpQWJuiD1+YBPDaEsRMoCVRlYSBIb3VzZRgLQ2Fz + YSBkZSBUw6kAGRwVABUAFRAAABaIhO3/BxXiARaosrH/BxWEAwAm/JnX5gEcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaSsRMWqh0W7hUm/JnX5gE8NvywEygIb2Zm + aWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFuqF7f8HFeIBFqy1sf8HFfoBACbqr9fmARwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBaSsRMWnBsWvhQm6q/X5gE8 + NpKxEwAZHBUAFQAVEAAAFsyH7f8HFeIBFqa3sf8HFXYAJqjE1+YBHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFpKxExa2IRbUGCaoxNfmATw2/LATKChTZXJ2aWNpbyBk + ZSBVcmdlbmNpYSBkZSBBbHRhIFJlc29sdWNpw7NuGC5BZG1pbmlzdHJhY2nDs24gRmVkZXJhbCBk + ZSBJbXB1ZXN0b3MgUMO6YmxpY29zABkcFQAVABUQAAAWront/wcV4gEWnLix/wcVzAUAJvzc1+YB + HBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUM + FpKxExaiGxa4FCb83NfmATw2krETABkcFQAVABUQAAAWkIvt/wcV4gEW6L2x/wcVdgAmtPHX5gEc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaSsRMWnBsWvhQmtPHX5gE8 + NpKxEwAZHBUAFQAVEAAAFvKM7f8HFeIBFt6+sf8HFXYAJvKF2OYBHBUAGTUGCAAZGAloYXNfcGFy + dHMVDBaMsRMWsroCFrAGJvKF2OYBPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAW1I7t/wcV0gEW + 1L+x/wcVdgAmoozY5gEcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWjLETFrK6AhawBiaijNjm + ATwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFqaQ7f8HFdIBFsrAsf8HFXYAJsKT2OYBHBUCGTUG + CAQZGApudW1fZmxvb3JzFQwWjLETFrALFpYMJsKT2OYBJtKS2OYBHBgEDAAAABgEAQAAABburRMo + BAwAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAW+JHt/wcV3AEWwMGx/wcVxgEAJuie2OYBHBUC + GTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWjLETFpAEFqAFJuie2OYBPDaMsRMAGRwV + ABUAFRAAABbUk+3/BxXSARaGw7H/BxV2ACaIpNjmARwVChk1BggAGRgKbWluX2hlaWdodBUMFoyx + ExaQBBagBSaIpNjmATw2jLETABkcFQAVABUQAAAWppXt/wcV0gEW/MOx/wcVdgAmqKnY5gEcFQIZ + NQYIABkYCW1pbl9mbG9vchUMFoyxExaQBBagBSaoqdjmATw2jLETABkcFQAVABUQAAAW+Jbt/wcV + 0gEW8sSx/wcVdgAmyK7Y5gEcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFoyxExaQBBagBSbIrtjm + ATw2jLETABkcFQAVABUQAAAWypjt/wcV0gEW6MWx/wcVdgAm6LPY5gEcFQwZNQYIABkYD2ZhY2Fk + ZV9tYXRlcmlhbBUMFoyxExaQBBagBSbos9jmATw2jLETABkcFQAVABUQAAAWnJrt/wcV0gEW3sax + /wcVdgAmiLnY5gEcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaMsRMWkAQWoAUmiLnY5gE8Noyx + EwAZHBUAFQAVEAAAFu6b7f8HFdIBFtTHsf8HFXYAJqi+2OYBHBUMGTUGCAAZGApyb29mX3NoYXBl + FQwWjLETFpAEFqAFJqi+2OYBPDaMsRMAGRwVABUAFRAAABbAne3/BxXSARbKyLH/BxV2ACbIw9jm + ARwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaMsRMWkAQWoAUmyMPY5gE8NoyxEwAZHBUAFQAV + EAAAFpKf7f8HFdIBFsDJsf8HFXYAJujI2OYBHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW + jLETFpAEFqAFJujI2OYBPDaMsRMAGRwVABUAFRAAABbkoO3/BxXSARa2yrH/BxV2ACaIztjmARwV + DBk1BggAGRgKcm9vZl9jb2xvchUMFoyxExaQBBagBSaIztjmATw2jLETABkcFQAVABUQAAAWtqLt + /wcV0gEWrMux/wcVdgAmqNPY5gEcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWjLETFpAEFqAFJqjT + 2OYBPDaMsRMAGRwVABUAFRAAABaIpO3/BxXSARaizLH/BxV2ABaMxJcbFoyxEyau3erYARaa++0N + FB4AGfwmJsjY2OYBHBUMGTUGCAAZGAJpZBUMFoS3ExbgwbsFFtyIzwEmyNjY5gE8NgAoIDA4YmNl + YWE0OTNkOTZmZmYwMjAwZWIzNTQ1M2Y2ZTc2GCAwOGJjZTgxMDAwMTQ2ZmZmMDIwMDg2NTAwNDU5 + NmMxNgAZHBUAFQAVEAAAFtql7f8HFfIBFpjNsf8HFdYIACak4afoARwVDBk1BggAGRgIZ2VvbWV0 + cnkVDBaEtxMWrIDmDxbi97UJJqThp+gBPDYAKNkGAAAAAAMAAAAEAAAAI8BSEJIvQgzrwEQZYAbQ + 1JnAUhCa0uodQMBEGVqSHM2WwFIQmkCIhkzARBlYdQwbl8BSEKMo+fRNwEQZUtPiasTAUhCjDN/i + U8BEGVJstF5BwFIQpNsWO6zARBlRSMfv7sBSEKc6AKzOwEQZWgsOUPzAUhCl9wqN+MBEGVrW5itD + wFIQpdAIwXDARBlaRp1zQ8BSEJ4LGGH3wEQZXy86gC/AUhCemvW6LMBEGWFCOjczwFIQpFpSW+3A + RBldn+5HccBSEKTJ4+RBwEQZXzr4+lLAUhCju8brC8BEGV/lQuVYwFIQo+BEeNbARBlgbFFh8sBS + EKHzb87FwEQZYaOJBqTAUhCh1Tzd18BEGWEz935RwFIQmmSatEzARBll5uSmB8BSEJpRut23wEQZ + ZaIbSFvAUhCaAuCFEMBEGWXTmW+owFIQmiQDFIfARBlmTulyH8BSEJUCxoPdwEQZaYyLlB3AUhCU + EFg82MBEGWYMpFMxwFIQlaUYUt3ARBllDMoS3sBSEJYKLYBswEQZZoLr2CvAUhCWi1y/9MBEGWYx + jUDGwFIQliNX893ARBlksjFAFMBSEJmhkbWgwEQZYnzM2jnAUhCaAZ5lscBEGWPgeii7wFIQnN3x + uD/ARBliEW0PzsBSEJudFHhdwEQZXW9G37jAUhCXq+4v9MBEGV/tpmEowFIQl9a2WpvARBlgi1sS + dcBSEJMhRPQmwEQZY4Qz1sfAUhCSL0IM68BEGWAG0NSZAAAABcBSEKFnxDR4wEQZWIeAkmLAUhCg + pz90isBEGVj88VfHwFIQoOQQtjHARBlZ5vwi/MBSEKGlANXpwEQZWXGLXZfAUhChZ8Q0eMBEGViH + gJJiAAAABcBSEKRBJ+h8wEQZVZEsDM7AUhCit7rs0MBEGVZ7NtgDwFIQozeoDPrARBlYbyzehcBS + EKTAqajbwEQZV4RLU7vAUhCkQSfofMBEGVWRLAzOAAAAB8BSEJ720KxVwEQZWMFiNX/AUhCd0g1+ + bsBEGVluMF9DwFIQnf4XyHTARBlaG9VInMBSEJy8zyjIwEQZWtlqagHAUhCdH2AXmMBEGVxffGda + wFIQn4Vr5SvARBla9EJcnMBSEJ720KxVwEQZWMFiNX8YTQAAAAADAAAAAQAAAATAUiVISH87m8BE + JdQ/WdmYwFIlSNIJllTARCXTAFQDkMBSJUj3Hd2xwEQl1AUgW4jAUiVISH87m8BEJdQ/WdmYABkc + FQAVABUkAAAWzKft/wcVoAQW7tWx/wcVriUAJobZ3fEBHBUIGTUGCAAZKARiYm94BHhtaW4VDBaE + txMW4OBNFvyOMCaG2d3xATwYBAlwj8IYBBpAksIWACgECXCPwhgEGkCSwgAZHBUAFQAVEAAAFuyr + 7f8HFfIBFpz7sf8HFdYBACaC6I3yARwVCBk1BggAGSgEYmJveAR4bWF4FQwWhLcTFuDgTRbWjDAm + guiN8gE8GAT5b4/CGAT7P5LCFgAoBPlvj8IYBPs/ksIAGRwVABUAFRAAABbere3/BxXyARby/LH/ + BxXWAQAm2PS98gEcFQgZNQYIABkoBGJib3gEeW1pbhUMFoS3Exbg4E0WxPwxJtj0vfIBPBgECoAd + whgE5R8jwhYAKAQKgB3CGATlHyPCABkcFQAVABUQAAAW0K/t/wcV8gEWyP6x/wcV1gEAJpzx7/IB + HBUIGTUGCAAZKARiYm94BHltYXgVDBaEtxMW3OBNFo74MSac8e/yATwYBPZ/HcIYBNUfI8IWACgE + 9n8dwhgE1R8jwgAZHBUAFQAVEAAAFsKx7f8HFfIBFp6Asv8HFdYBACbq6aHzARwVAhk1BggEGRgH + dmVyc2lvbhUMFoS3Exb8BBaeBibq6aHzASaq6aHzARwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAA + AAAZLBUEFQQVAgAVABUEFRAAABa0s+3/BxXSARb0gbL/BxXWAQAmiPCh8wEcFQwZJQYEGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBaEtxMW/gUWoAcmiPCh8wEmyO+h8wEcGAAYABYA + KAAYAAAZLBUEFQQVAgAVABUEFRAAABaGte3/BxXSARbKg7L/BxVWACas+KHzARwVDBklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWhLcTFp7vBBbanAMmrPih8wEm6Pah8wEcNgAo + DU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbY + tu3/BxXiARaghLL/BxX2BAAmwpOl8wEcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVj + b3JkX2lkFQwWhLcTFtaI7AIW6t5+JsKTpfMBPDYAKAt3OTY3NzM4NTJAMhgMMDAwMWEzYjhlOTYz + ABkcFQAVABUQAAAWurjt/wcV8gEWlomy/wcV1AMAJpr+pPQBHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWhLcTFp68Gxb4+Qkmmv6k9AEmrPKj9AEcNgAoGDIwMjQt + MDktMjZUMjA6Mzg6MjkuMDAwWhgYMjAxMS0wMS0yNlQwMTo0MDo0NC4wMDBaABksFQQVBBUCABUA + FQQVEAAAFqy67f8HFegBFuqMsv8HFdYGACbkjK/0ARwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudApjb25maWRlbmNlFQwWhLcTFsTTGRa4pRYm5Iyv9AEmpOyt9AEcGAhGJXUCmgjvPxgIzczM + zMzM5D8WmPgIKAhGJXUCmgjvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWlLzt/wcV8gEW + wJOy/wcV8AIAJqSSxPQBHBUCGTUGCAQZGAVsZXZlbBUMFoS3ExaEBxb+ByakksT0ASbckcT0ARwY + BAEAAAAYBP////8WwLYTKAQBAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFoa+7f8HFdYBFrCW + sv8HFcYBACbym8T0ARwVDBk1BggEGRgHc3VidHlwZRUMFoS3ExbapQEWwnwm8pvE9AEm2pnE9AEc + NuLdESgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABbcv+3/ + BxXiARb2l7L/BxWEBAAm5JnF9AEcFQwZNQYIBBkYBWNsYXNzFQwWhLcTFuq2ARaikwEm5JnF9AEm + nJbF9AEcNpDfESgJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFr7B7f8H + FeIBFvqbsv8HFYYDACa+qcb0ARwVChk1BggAGRgGaGVpZ2h0FQwWhLcTFpAEFqAFJr6pxvQBPDaE + txMAGRwVABUAFRAAABagw+3/BxXSARaAn7L/BxV2ACbersb0ARwVDBk1BggAGSgFbmFtZXMHcHJp + bWFyeRUMFoS3ExbehQEWnFIm3q7G9AE8NoCzEygIbW9ybW9uZXMYGDHCsCBDb21wYcOxaWEgSHVl + bGxlbGh1ZQAZHBUAFQAVEAAAFvLE7f8HFeIBFvafsv8HFcIGACb6gMf0ARwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFoS3ExaqFxakEyb6gMf0ATw2hLcTABkcFQAVABUQAAAW + 1Mbt/wcV4gEWuKay/wcVdgAmnpTH9AEcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2 + YWx1ZRUMFoS3ExbgGhb2EyaelMf0ATw2hLcTABkcFQAVABUQAAAWtsjt/wcV4gEWrqey/wcVdgAm + lKjH9AEcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaItxMW8BwW + zhUmlKjH9AE8NvS2EygIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFpjK7f8HFeIBFqSo + sv8HFcACACbivcf0ARwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UV + DBaItxMW8hoWnhQm4r3H9AE8Noi3EwAZHBUAFQAVEAAAFvrL7f8HFeIBFuSqsv8HFXYAJoDSx/QB + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFoi3ExbaHxbGGCaA0sf0 + ATw29LYTKCpTZXJ2aWNpbyBkZSBBdGVuY2nDs24gUHJpbWFyaWEgZGUgVXJnZW5jaWEYEUFkdWFu + YSBFbCBSaW5jw7NuABkcFQAVABUQAAAW3M3t/wcV4gEW2quy/wcVigYAJsbqx/QBHBUKGSUGABl4 + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFoi3Exb4Ghae + FCbG6sf0ATw2iLcTABkcFQAVABUQAAAWvs/t/wcV4gEW5LGy/wcVdgAm5P7H9AEcFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaItxMW8hoWnhQm5P7H9AE8Noi3EwAZHBUA + FQAVEAAAFqDR7f8HFeIBFtqysv8HFXYAJoKTyPQBHBUAGTUGCAAZGAloYXNfcGFydHMVDBaEtxMW + krsCFtgGJoKTyPQBPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAWgtPt/wcV0gEW0LOy/wcVdgAm + 2pnI9AEcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWhLcTFpK7AhawBibamcj0ATwYAQAYAQAW + ACgBABgBAAAZHBUAFQAVEAAAFtTU7f8HFdIBFsa0sv8HFXYAJoqgyPQBHBUCGTUGCAAZGApudW1f + Zmxvb3JzFQwWhLcTFtwdFoQKJoqgyPQBPBgEBwAAABgEAQAAABa4sRMoBAcAAAAYBAEAAAAAGRwV + ABUAFRAAABam1u3/BxXWARa8tbL/BxXmAQAmjqrI9AEcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5k + ZXJncm91bmQVDBaEtxMWogQWsgUmjqrI9AE8GAQBAAAAGAQBAAAAFoK3EygEAQAAABgEAQAAAAAZ + HBUAFQAVEAAAFvzX7f8HFdIBFqK3sv8HFYYBACbAr8j0ARwVChk1BggAGRgKbWluX2hlaWdodBUM + FoS3ExaQBBagBSbAr8j0ATw2hLcTABkcFQAVABUQAAAWztnt/wcV0gEWqLiy/wcVdgAm4LTI9AEc + FQIZNQYIABkYCW1pbl9mbG9vchUMFoS3ExaQBBagBSbgtMj0ATw2hLcTABkcFQAVABUQAAAWoNvt + /wcV0gEWnrmy/wcVdgAmgLrI9AEcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFoS3ExaQBBagBSaA + usj0ATw2hLcTABkcFQAVABUQAAAW8tzt/wcV0gEWlLqy/wcVdgAmoL/I9AEcFQwZNQYIABkYD2Zh + Y2FkZV9tYXRlcmlhbBUMFoS3ExauBBa+BSagv8j0ATwYBWJyaWNrGAVicmljaxaCtxMoBWJyaWNr + GAVicmljawAZHBUAFQAVEAAAFsTe7f8HFdIBFoq7sv8HFYoBACbexMj0ARwVDBk1BggAGRgNcm9v + Zl9tYXRlcmlhbBUMFoS3ExaQBBagBSbexMj0ATw2hLcTABkcFQAVABUQAAAWluDt/wcV0gEWlLyy + /wcVdgAm/snI9AEcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaEtxMWkAQWoAUm/snI9AE8NoS3EwAZ + HBUAFQAVEAAAFujh7f8HFdIBFoq9sv8HFXYAJp7PyPQBHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlv + bhUMFoS3ExaQBBagBSaez8j0ATw2hLcTABkcFQAVABUQAAAWuuPt/wcV0gEWgL6y/wcVdgAmvtTI + 9AEcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBaEtxMWkAQWoAUmvtTI9AE8NoS3EwAZHBUA + FQAVEAAAFozl7f8HFdIBFva+sv8HFXYAJt7ZyPQBHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWhLcT + Fq4EFr4FJt7ZyPQBPBgHI0ZGMDAwMBgHI0ZGMDAwMBaCtxMoByNGRjAwMDAYByNGRjAwMDAAGRwV + ABUAFRAAABbe5u3/BxXSARbsv7L/BxWSAQAmnN/I9AEcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW + hLcTFpAEFqAFJpzfyPQBPDaEtxMAGRwVABUAFRAAABaw6O3/BxXSARb+wLL/BxV2ABa8xokbFoS3 + EybI2NjmARb0i/ANFCAAGfwmJrzkyPQBHBUMGTUGCAAZGAJpZBUMFrSxExae97kFFqzbzAEmvOTI + 9AE8NgAoIDA4YmNlOGVkYjVkNDFmZmYwMjAwNDAxZGM5YWViZWVlGCAwOGJjZTgwMDQzMzgyZmZm + MDIwMDA3MzJhZDlkZWJhYQAZHBUAFQAVEAAAFoLq7f8HFfIBFvTBsv8HFdYIACbov5X2ARwVDBk1 + BggAGRgIZ2VvbWV0cnkVDBa0sRMW5qboDxbUp7cJJui/lfYBPDYAKOMBAAAAAAYAAAACAAAAAAMA + AAABAAAABcBR6TEOlcT5wERhyCdLnmTAUeku79eT0MBEYcgnS55kwFHpLu/Xk9DARGG8E0ElZMBR + 6TEOKmUuwERhvBNBJWTAUekxDpXE+cBEYcgnS55kAAAAAAMAAAABAAAAB8BR6S7Hk6fowERhu8YU + S+fAUekrXr37ecBEYb4hOF7swFHpLWnFlnjARGHE6oA7+8BR6Svi3NmKwERhxfidNTDAUekoxsim + zcBEYbuiAh3nwFHpLbYbsGDARGG4OZfRQsBR6S7Hk6fowERhu8YUS+cYTQAAAAADAAAAAQAAAATA + UdVtICYgusBEE7otVEpewFHVbNQNbifARBO+Ir8iJMBR1Wu/s/04wEQTvM14/z/AUdVtICYgusBE + E7otVEpeABkcFQAVABUkAAAW9Ovt/wcVoAQWysqy/wcVriUAJrznzP8BHBUIGTUGCAAZKARiYm94 + BHhtaW4VDBa0sRMWnspNFrLiLSa858z/ATwYBEKhjMIYBBOMkcIWACgEQqGMwhgEE4yRwgAZHBUA + FQAVEAAAFpTw7f8HFfIBFvjvsv8HFdYBACbuyfr/ARwVCBk1BggAGSgEYmJveAR4bWF4FQwWtLET + FqDKTRbi4S0m7sn6/wE8GAQ4oYzCGAT6i5HCFgAoBDihjMIYBPqLkcIAGRwVABUAFRAAABaG8u3/ + BxXyARbO8bL/BxXWAQAm0KuogAIcFQgZNQYIABkoBGJib3gEeW1pbhUMFrSxExaeyk0WwLEwJtCr + qIACPBgECIAdwhgECyAjwhYAKAQIgB3CGAQLICPCABkcFQAVABUQAAAW+PPt/wcV8gEWpPOy/wcV + 1gEAJpDd2IACHBUIGTUGCAAZKARiYm94BHltYXgVDBa0sRMWoMpNFr6zMCaQ3diAAjwYBOZ/HcIY + BPAfI8IWACgE5n8dwhgE8B8jwgAZHBUAFQAVEAAAFur17f8HFfIBFvr0sv8HFdYBACaOkYmBAhwV + Ahk1BggEGRgHdmVyc2lvbhUMFrSxExb+BBagBiaOkYmBAibOkImBAhwYBAAAAAAYBAAAAAAWACgE + AAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbc9+3/BxXSARbQ9rL/BxXWAQAmrpeJgQIcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBa0sRMW/gUWoAcmrpeJgQIm7paJ + gQIcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABau+e3/BxXSARam+LL/BxVWACbSn4mBAhwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWtLETFrjaBBac+wIm0p+JgQIm + jp6JgQIcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAV + ABUEFRAAABaA++3/BxXiARb8+LL/BxX2BAAmqpmMgQIcFQwZJQYAGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQJcmVjb3JkX2lkFQwWtLETFp6m8AIWhOqCASaqmYyBAjw2ACgMdzk4NjI0NTYzNUAxGAww + MDAwMGI2OTA4ZTYAGRwVABUAFRAAABbi/O3/BxXyARby/bL/BxXWAwAm8rOQggIcFQwZJQYEGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBa0sRMWuqsZFqaqCCbys5CCAiaug4+C + Ahw2ACgYMjAyNC0xMS0yN1QxMzoxMjo0OC4wMDBaGBgyMDEwLTEyLTA2VDA5OjI1OjExLjAwMFoA + GSwVBBUEFQIAFQAVBBUQAAAW1P7t/wcV5gEWyIGz/wcV1gYAJrbJmIICHBUKGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBa0sRMW1tEaFqC5Fya2yZiCAibUrZeCAhwYCKJF + tvP91O4/GAjNzMzMzMzkPxbmgwgoCKJFtvP91O4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAA + ABa6gO7/BxXyARaeiLP/BxXsAgAmvOeuggIcFQIZNQYIBBkYBWxldmVsFQwWtLETFsQGFuYHJrzn + roICJvTmroICHBgEAQAAABgE/////xb8sBMoBAEAAAAYBP////8AGSwVBBUEFQIAFQAVBBUQAAAW + rILu/wcV2AEWiouz/wcVxgEAJoLxroICHBUMGTUGCAQZGAdzdWJ0eXBlFQwWtLETFuZbFtRHJoLx + roICJtruroICHDbMzhIoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAV + BBUQAAAWhITu/wcV4gEW0Iyz/wcVxAMAJqi8r4ICHBUMGTUGCAQZGAVjbGFzcxUMFrSxExbochby + VCaovK+CAiautq+CAhw27tASKAl3YXJlaG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQ + AAAW5oXu/wcV4gEWlJCz/wcV7gIAJqCLsIICHBUKGTUGCAAZGAZoZWlnaHQVDBa0sRMWvgYWhAcm + oIuwggI8GAgAAAAAAAA0QBgIAAAAAAAA8D8WnLETKAgAAAAAAAA0QBgIAAAAAAAA8D8AGRwVABUA + FRAAABbIh+7/BxXWARaCk7P/BxX2AQAmpJKwggIcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBa0 + sRMW5MYBFoZ6JqSSsIICPDbwqRMoE3VuaXZlcnNpdHkgYnVpbGRpbmcYEyJHaGliZWxsLWluYSBU + ZWxhcyIAGRwVABUAFRAAABaeie7/BxXiARb4lLP/BxXwBAAmqoyxggIcFQwZJQYAGUgFbmFtZXMG + Y29tbW9uCWtleV92YWx1ZQNrZXkVDBa2sRMW3hwW6hYmqoyxggI8Nq6xEygCZXMYA2FybgAZHBUA + FQAVEAAAFoCL7v8HFeIBFuiZs/8HFZIBACaUo7GCAhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5 + X3ZhbHVlBXZhbHVlFQwWtrETFrAiFroYJpSjsYICPDausRMoC05hdGlvbiBCYW5rGA9BYmFuZG9u + ZWQgSG90ZWwAGRwVABUAFRAAABbijO7/BxXiARb6mrP/BxWiAgAmzruxggIcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBa4sRMW+CIWohgmzruxggI8NqaxEygFc2hv + cnQYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFsSO7v8HFeIBFpyds/8HFcYBACbw07GCAhwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBa4sRMWviEWyBcm8NOxggI8NrSx + EygCZXMYAmVuABkcFQAVABUQAAAWppDu/wcV4gEW4p6z/wcVfgAmuOuxggIcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWuLETFvYkFpgaJrjrsYICPDamsRMoE015cnRs + ZSBIb3VzZSBvZiBUZWEYDUJCVkEgRnJhbmPDqXMAGRwVABUAFRAAABaIku7/BxXiARbgn7P/BxXK + AgAm0IWyggIcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdl + bGVtZW50FQwWuLETFqghFrQXJtCFsoICPDa4sRMAGRwVABUAFRAAABbqk+7/BxXiARaqorP/BxV2 + ACaEnbKCAhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFrixExamIRaq + FyaEnbKCAjw2uLETABkcFQAVABUQAAAWzJXu/wcV4gEWoKOz/wcVdgAmrrSyggIcFQAZNQYIABkY + CWhhc19wYXJ0cxUMFrSxExa4ugIW2AYmrrSyggI8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABau + l+7/BxXSARaWpLP/BxV2ACaGu7KCAhwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBa0sRMWuLoC + FrAGJoa7soICPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWgJnu/wcV0gEWjKWz/wcVdgAmtsGy + ggIcFQIZNQYIABkYCm51bV9mbG9vcnMVDBa0sRMW4h0WwBAmtsGyggI8GASFAAAAGAQBAAAAFqyt + EygEhQAAABgEAQAAAAAZHBUAFQAVEAAAFtKa7v8HFdgBFoKms/8HFeYBACb20bKCAhwVAhk1BggA + GRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFrSxExaQBBagBSb20bKCAjw2tLETABkcFQAVABUQ + AAAWqpzu/wcV0gEW6Kez/wcVdgAmlteyggIcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBa0sRMWkAQW + oAUmlteyggI8NrSxEwAZHBUAFQAVEAAAFvyd7v8HFdIBFt6os/8HFXYAJrbcsoICHBUCGTUGCAAZ + GAltaW5fZmxvb3IVDBa0sRMWkAQWoAUmttyyggI8NrSxEwAZHBUAFQAVEAAAFs6f7v8HFdIBFtSp + s/8HFXYAJtbhsoICHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBa0sRMWtAUW5AUm1uGyggI8Nqix + EygHI0ZGRkZGRhgHI0ZGRkYwMAAZHBUAFQAVEAAAFqCh7v8HFdQBFsqqs/8HFZIBACa657KCAhwV + DBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWtLETFrwEFswFJrrnsoICPBgEd29vZBgEd29vZBaw + sRMoBHdvb2QYBHdvb2QAGRwVABUAFRAAABb0ou7/BxXUARbcq7P/BxWGAQAmhu2yggIcFQwZNQYI + ABkYDXJvb2ZfbWF0ZXJpYWwVDBa0sRMWthAW1gYmhu2yggI8NpKwEygFc2xhdGUYBW1ldGFsABkc + FQAVABUQAAAWyKTu/wcV1AEW4qyz/wcVngEAJtzzsoICHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW + tLETFvAUFqAIJtzzsoICPDbyrxMoCHNraWxsaW9uGAZnYWJsZWQAGRwVABUAFRAAABacpu7/BxXY + ARaArrP/BxXmAQAm/PuyggIcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWtLETFpAEFqAFJvz7 + soICPDa0sRMAGRwVABUAFRAAABb0p+7/BxXSARbmr7P/BxV2ACacgbOCAhwVDBk1BggAGRgQcm9v + Zl9vcmllbnRhdGlvbhUMFrSxExaoBRb2BSacgbOCAjwYBWFsb25nGAVhbG9uZxamsRMoBWFsb25n + GAVhbG9uZwAZHBUAFQAVEAAAFsap7v8HFdQBFtyws/8HFZ4BACaSh7OCAhwVDBk1BggAGRgKcm9v + Zl9jb2xvchUMFrSxExaABha0BiaSh7OCAjw2orETKAcjQzBDMEMwGAcjMDAwMDAwABkcFQAVABUQ + AAAWmqvu/wcV1AEW+rGz/wcVrgEAJsaNs4ICHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFrSxExaQ + BBagBSbGjbOCAjw2tLETABkcFQAVABUQAAAW7qzu/wcV0gEWqLOz/wcVdgAW/r6MGxa0sRMmvOTI + 9AEWqq7qDRQiABn8JibmkrOCAhwVDBk1BggAGRgCaWQVDBaU8xQW6LbwBRbUhd8BJuaSs4ICPDYA + KCAwOGJjZWIzZGE2MmU1ZmZmMDIwMDg1NzEzZmM1YjQ0YhggMDhiY2U4MDU4MDRkMmZmZjAyMDA4 + MGI0NjM1NWQ1MjkAGRwVABUAFRIAABbAru7/BxWQAhaetLP/BxXeCQAmupiShAIcFQwZNQYIABkY + CGdlb21ldHJ5FQwWlPMUFuLe0BAWouLtCSa6mJKEAjw2ACjDAQAAAAAGAAAAAgAAAAADAAAAAQAA + AAXAURhxHKLN9sBEiMjTQwiTwFEYdVUWssrARIjOqG8fc8BRGHO2RaHLwESI0VJtix7AURhvfdG8 + 98BEiMt8arSqwFEYcRyizfbARIjI00MIkwAAAAADAAAAAQAAAAXAURhtx4O3sMBEiMRDkU9IwFEY + b+6lZKnARIjHR1HOKcBRGGn0kGA1wESI0PwGdjzAURhnzW6zPMBEiM34RfdbwFEYbceDt7DARIjE + Q5FPSBhNAAAAAAMAAAABAAAABMBQ/6hSmgDIwEUQopXBncXAUP+p45O4r8BFEKBjuDY9wFD/qqs5 + 1Q7ARRChn/hYbMBQ/6hSmgDIwEUQopXBncUAGRwVABUAFSYAABbQsO7/BxW+BBb8vbP/BxW2JwAm + 3Pr/jQIcFQgZNQYIABkoBGJib3gEeG1pbhUMFpTzFBbo0VMWntAzJtz6/40CPBgESQCHwhgE4OST + whYAKARJAIfCGATg5JPCABkcFQAVABUSAAAWjrXu/wcVkAIWsuWz/wcV7gEAJvrKs44CHBUIGTUG + CAAZKARiYm94BHhtYXgVDBaU8xQW6NFTFtbaMyb6yrOOAjwYBEEAh8IYBNPkk8IWACgEQQCHwhgE + 0+STwgAZHBUAFQAVEgAAFp637v8HFZACFqDns/8HFe4BACbQpeeOAhwVCBk1BggAGSgEYmJveAR5 + bWluFQwWlPMUFujRUxayzzgm0KXnjgI8GAQQ4BfCGAQSvyjCFgAoBBDgF8IYBBK/KMIAGRwVABUA + FRIAABauue7/BxWQAhaO6bP/BxXuAQAmgvWfjwIcFQgZNQYIABkoBGJib3gEeW1heBUMFpTzFBbq + 0VMWzJk4JoL1n48CPBgE+N8XwhgECL8owhYAKAT43xfCGAQIvyjCABkcFQAVABUSAAAWvrvu/wcV + kAIW/Oqz/wcV7gEAJo6P2I8CHBUCGTUGCAQZGAd2ZXJzaW9uFQwWlPMUFsgFFvwGJo6P2I8CJs6O + 2I8CHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEgAAFs697v8HFewB + Furss/8HFe4BACaKltiPAhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUM + FpTzFBbYBhaMCCaKltiPAibKldiPAhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFrq/7v8H + FewBFtjus/8HFV4AJpqf2I8CHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQV + DBaU8xQWnuUEFozzAiaan9iPAibWndiPAhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4g + QnVpbGRpbmdzABksFQQVBBUCABUAFQQVEgAAFqbB7v8HFf4BFrbvs/8HFcIFACbikNuPAhwVDBkl + BgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaU8xQW/P2GAxb02JMBJuKQ248C + PDYAKAx3OTk3MjEwMzUwQDEYDDAwMDA0MmUyMjQzMQAZHBUAFQAVEgAAFqTD7v8HFZACFvj0s/8H + FY4EACbKsu+QAhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFpTz + FBaA9RcW0M8GJsqy75ACJtbp7pACHDYAKBgyMDI0LTExLTI1VDA3OjQ4OjQ4LjAwMFoYGDIwMTAt + MDMtMTNUMTE6MTc6MTAuMDAwWgAZLBUEFQQVAgAVABUEFRIAABa0xe7/BxX+ARaG+bP/BxW+BwAm + 0Ln3kAIcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFpTzFBaOmh8W + 9tsbJtC595ACJqa59ZACHBgIAAAAAAAA8D8YCAAAAIDpJuE/FvbaBygIAAAAAAAA8D8YCAAAAIDp + JuE/ABksFQQVBBUCABUAFQQVEgAAFrLH7v8HFZACFsSAtP8HFZYDACbclZGRAhwVAhk1BggEGRgF + bGV2ZWwVDBaU8xQW2gYW/Acm3JWRkQImnJWRkQIcGAQBAAAAGAQBAAAAFuLyFCgEAQAAABgEAQAA + AAAZLBUEFQQVAgAVABUEFRIAABbCye7/BxXwARbag7T/BxWyAQAmrJ+RkQIcFQwZNQYIBBkYB3N1 + YnR5cGUVDBaU8xQWkigW5iMmrJ+RkQImmJ2RkQIcNp7RFCgOdHJhbnNwb3J0YXRpb24YDGFncmlj + dWx0dXJhbAAZLBUEFQQVAgAVABUEFRIAABayy+7/BxX8ARaMhbT/BxW2AwAm1sSRkQIcFQwZNQYI + BBkYBWNsYXNzFQwWlPMUFowoFoojJtbEkZECJv7AkZECHDbM0hQoCXdhcmVob3VzZRgKYXBhcnRt + ZW50cwAZLBUEFQQVAgAVABUEFRIAABauze7/BxX8ARbCiLT/BxXOAgAmiOSRkQIcFQoZNQYIABkY + BmhlaWdodBUMFpTzFBasDBaACSaI5JGRAjwYCAAAAAAAACBAGAgAAAAAAAAIQBay8hQoCAAAAAAA + ACBAGAgAAAAAAAAIQAAZHBUAFQAVEgAAFqrP7v8HFfABFpCLtP8HFeIBACaI7ZGRAhwVDBk1BggA + GSgFbmFtZXMHcHJpbWFyeRUMFpTzFBbmjAEW0FYmiO2RkQI8NsbuFCgPcG9zdGEgc2FuaXRhcmlh + GB9BYmFycm90ZXMgeSBjb25maXRlcmlhIERvbiBUaXRvABkcFQAVABUSAAAWmtHu/wcV+gEW8oy0 + /wcVogUAJtjDkpECHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWlvMUFrQW + FvQSJtjDkpECPDaQ8xQoAmVzGAJlbgAZHBUAFQAVEgAAFpTT7v8HFfgBFpSStP8HFZIBACbM1pKR + AhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWlvMUFpgaFu4UJszWkpEC + PDaQ8xQoDFRpcmUgU2VydmljZRgNQmFuY28gTmFjacOzbgAZHBUAFQAVEgAAFozV7v8HFfgBFqaT + tP8HFeIBACa27JKRAhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUM + FpzzFBbaGhbCFSa27JKRAia665KRAhw2hvMUKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUA + FQQVEgAAFoTX7v8HFfgBFoiVtP8HFZoCACb8gJORAhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQIbGFuZ3VhZ2UVDBac8xQW3hkWtBQm/ICTkQI8NpjzFCgCZXMYAmVuABkcFQAVABUS + AAAW/Nju/wcV+AEWope0/wcVigEAJsCYk5ECHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAV2YWx1ZRUMFpzzFBboHRbgFybAmJORAiawlZORAhw2hvMUKChTZXJ2aWNpbyBkZSBVcmdl + bmNpYSBkZSBBbHRhIFJlc29sdWNpw7NuGB1CYW5jbyBkZSBsYSBOYWNpw7NuIEFyZ2VudGluYQAZ + LBUEFQQVAgAVABUEFRIAABb02u7/BxX4ARasmLT/BxWSBQAmkK2TkQIcFQoZJQYAGXgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWnPMUFsoZFqQUJpCtk5EC + PDac8xQAGRwVABUAFRIAABbs3O7/BxX4ARa+nbT/BxWCAQAmtMGTkQIcFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBac8xQWxhkWphQmtMGTkQI8NpzzFAAZHBUAFQAVEgAA + FuTe7v8HFfgBFsCetP8HFYIBACba1ZORAhwVABk1BggAGRgJaGFzX3BhcnRzFQwWlPMUFpjTAhag + Byba1ZORAjwYAQEYAQAWACgBARgBAAAZHBUAFQAVEgAAFtzg7v8HFewBFsKftP8HFYIBACb63JOR + AhwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaU8xQWmNMCFpYHJvrck5ECPBgBABgBABYAKAEA + GAEAABkcFQAVABUSAAAWyOLu/wcV7AEWxKC0/wcVggEAJuDkk5ECHBUCGTUGCAQZGApudW1fZmxv + b3JzFQwWlPMUFswGFoAIJuDkk5ECJpDkk5ECHBgEAwAAABgEAQAAABbw8hQoBAMAAAAYBAEAAAAA + GSwVBBUEFQIAFQAVBBUSAAAWtOTu/wcV7gEWxqG0/wcV4gEAJpDsk5ECHBUCGTUGCAAZGBZudW1f + Zmxvb3JzX3VuZGVyZ3JvdW5kFQwWlPMUFtIEFvQFJpDsk5ECPDaU8xQAGRwVABUAFRIAABai5u7/ + BxXsARaoo7T/BxWCAQAmhPKTkQIcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBaU8xQW0gQW9AUmhPKT + kQI8NpTzFAAZHBUAFQAVEgAAFo7o7v8HFewBFqqktP8HFYIBACb495ORAhwVAhk1BggAGRgJbWlu + X2Zsb29yFQwWlPMUFtIEFvQFJvj3k5ECPDaU8xQAGRwVABUAFRIAABb66e7/BxXsARaspbT/BxWC + AQAm7P2TkQIcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFpTzFBbSBBb0BSbs/ZORAjw2lPMUABkc + FQAVABUSAAAW5uvu/wcV7AEWrqa0/wcVggEAJuCDlJECHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJp + YWwVDBaU8xQW0gQW9AUm4IOUkQI8NpTzFAAZHBUAFQAVEgAAFtLt7v8HFewBFrCntP8HFYIBACbU + iZSRAhwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFpTzFBbSBBb0BSbUiZSRAjw2lPMUABkcFQAV + ABUSAAAWvu/u/wcV7AEWsqi0/wcVggEAJsiPlJECHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWlPMU + FvAEFpIGJsiPlJECPBgGZ2FibGVkGAZnYWJsZWQWkvMUKAZnYWJsZWQYBmdhYmxlZAAZHBUAFQAV + EgAAFqrx7v8HFewBFrSptP8HFZoBACbalZSRAhwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaU + 8xQW0gQW9AUm2pWUkQI8NpTzFAAZHBUAFQAVEgAAFpbz7v8HFewBFs6qtP8HFYIBACbOm5SRAhwV + DBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFpTzFBbSBBb0BSbOm5SRAjw2lPMUABkcFQAVABUS + AAAWgvXu/wcV7AEW0Ku0/wcVggEAJsKhlJECHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWlPMUFvIE + FpQGJsKhlJECPBgHIzAwODAwMBgHIzAwODAwMBaS8xQoByMwMDgwMDAYByMwMDgwMDAAGRwVABUA + FRIAABbu9u7/BxXsARbSrLT/BxWeAQAm1qeUkQIcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWlPMU + FtIEFvQFJtanlJECPDaU8xQAGRwVABUAFRIAABba+O7/BxXsARbwrbT/BxWCAQAW+uHbHBaU8xQm + 5pKzggIW5JrhDhQkABn8JibKrZSRAhwVDBk1BggAGRgCaWQVDBbsvhMW/Nq9BRaU4sYBJsqtlJEC + PDYAKCAwOGJjZThiY2Y2NmYyZmZmMDIwMGIyZTI4YWY5MDU4ZhggMDhiYjJkYTA0OTAwOWZmZjAy + MDA5ZTMxZDI3NDA1OTgAGRwVABUAFRAAABbG+u7/BxXyARbyrrT/BxXWCAAm3o/bkgIcFQwZNQYI + ABkYCGdlb21ldHJ5FQwW7L4TFuzoiRAWtPC7CSbej9uSAjw2ACj5BQAAAAADAAAABAAAABnAUmkf + cbVPAsBCzI2jwhGIwFJpHP/rB0rAQsyWE9Mbm8BSaR14S2s4wELMlmsQ8BLAUmkcvGPI/cBCzJjz + gWx8wFJpG+5zD8LAQsyYXVl3a8BSaRuCPIXCwELMmdN7PLfAUmkY4/yUO8BCzJfrQ7BZwFJpGVU7 + m7jAQsyWZFrzbMBSaRg1FYuCwELMlZKj3BPAUmkXyoyArMBCzJcBOOUkwFJpFPEozKjAQsyU7jku + H8BSaRSCbgPqwELMlmsQ8BLAUmkR9PUKA8BCzJSOl93YwFJpEsBhhH/AQsyR0U47zcBSaRIPYZzT + wELMkVAe/EXAUmkUhjRiB8BCzIjRyzlPwFJpFzU7SzDAQsyKxpf/ZsBSaRi64ei+wELMhYa9HgPA + Umkbm9JY/sBCzIefnBIawFJpGvQMrLfAQsyJ4ZWxrsBSaRo4JQp8wELMiVmwdX7AUmkZjkZ/QMBC + zIujNtFNwFJpHN3xuD/AQsyODJ2dNMBSaR1qCLJWwELMjClujlPAUmkfcbVPAsBCzI2jwhGIAAAA + B8BSaRmwP85MwELMjJnW1jvAUmkZYxL0z8BCzIxieXHcwFJpF4GRZRjAQsyS+WxoCMBSaRgGhwK+ + wELMk1kNuE/AUmkYH7F2L8BCzJMAImSvwFJpF+hUEdDAQsyS2LU4XMBSaRmwP85MwELMjJnW1jsA + AAAHwFJpHFe5+znAQsyOl93Xt8BSaRwKjSG8wELMjmCAc1jAUmkaKQuSBMBCzJT4SikZwFJpGq2V + z+DAQsyVVxS5y8BSaRrHK6McwELMlP8AJcDAUmkaj2Le8sBCzJTWvDnYwFJpHFe5+znAQsyOl93X + twAAAAfAUmkWpPKTMMBCzIuPFNtZwFJpFlnemKfAQsyLWju1ucBSaRTGYKIBwELMkPqOpvfAUmkV + UuL748BCzJFdivWSwFJpFW6RrhPAQsyQ+2VmjMBSaRUtI066wELMkM1CPZLAUmkWpPKTMMBCzIuP + FNtZGE0AAAAAAwAAAAEAAAAEwFJOygoy7HLAQwKAyF7Cd8BSTspcaP9pwEMCgglqVp3AUk7Jmtep + OMBDAoKFf89mwFJOygoy7HLAQwKAyF7CdwAZHBUAFQAVJAAAFrj87v8HFaAEFsi3tP8HFa4lACaS + gJecAhwVCBk1BggAGSgEYmJveAR4bWluFQwW7L4TFv7/TRaQ6ikmkoCXnAI8GAQIQJLCGAQzWpPC + FgAoBAhAksIYBDNak8IAGRwVABUAFRAAABbYgO//BxXyARb23LT/BxXWAQAmourAnAIcFQgZNQYI + ABkoBGJib3gEeG1heBUMFuy+ExaAgE4Wku4pJqLqwJwCPBgE/j+SwhgEIFqTwhYAKAT+P5LCGAQg + WpPCABkcFQAVABUQAAAWyoLv/wcV8gEWzN60/wcV1gEAJrTY6pwCHBUIGTUGCAAZKARiYm94BHlt + aW4VDBbsvhMWgIBOFv6zLSa02OqcAjwYBBzkE8IYBAiUGMIWACgEHOQTwhgECJQYwgAZHBUAFQAV + EAAAFryE7/8HFfIBFqLgtP8HFdYBACayjJidAhwVCBk1BggAGSgEYmJveAR5bWF4FQwW7L4TFoCA + ThastC0msoyYnQI8GAQM5BPCGATskxjCFgAoBAzkE8IYBOyTGMIAGRwVABUAFRAAABauhu//BxXy + ARb44bT/BxXWAQAmnsHFnQIcFQIZNQYIBBkYB3ZlcnNpb24VDBbsvhMW/gQWoAYmnsHFnQIm3sDF + nQIcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWoIjv/wcV0gEW + zuO0/wcV1gEAJr7HxZ0CHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW + 7L4TFv4FFqAHJr7HxZ0CJv7GxZ0CHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW8onv/wcV + 0gEWpOW0/wcVVgAm4s/FnQIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUM + Fuy+Exaq4QQW4IUDJuLPxZ0CJp7OxZ0CHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBC + dWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWxIvv/wcV4gEW+uW0/wcV9gQAJv7TyJ0CHBUMGSUG + ABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFuy+ExbgptsCFsj4gwEm/tPInQI8 + NgAoDHc5NjQwNjg2MThAMRgMMDAwMDgxNzM1NDZiABkcFQAVABUQAAAWpo3v/wcV8gEW8Oq0/wcV + 1AMAJszvzZ4CHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW7L4T + FtaXHRb8hQkmzO/NngImxszMngIcNgAoGDIwMjQtMTEtMjRUMTc6MzA6MTcuMDAwWhgYMjAxMS0w + Ny0xMFQxNjozOTo0My4wMDBaABksFQQVBBUCABUAFQQVEAAAFpiP7/8HFeYBFsTutP8HFdYGACao + 6taeAhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW7L4TFozzExbq + xBAmqOrWngImwtLVngIcGAjdJAaBlUPvPxgIzczMzMzM5D8W3rgMKAjdJAaBlUPvPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAW/pDv/wcV8gEWmvW0/wcV9gIAJqyX5p4CHBUCGTUGCAAZGAVs + ZXZlbBUMFuy+ExayBRa0Biasl+aeAjwYBAEAAAAYBAEAAAAW2r4TKAQBAAAAGAQBAAAAABkcFQAV + ABUQAAAW8JLv/wcV1AEWkPi0/wcVxgEAJvqf5p4CHBUMGTUGCAQZGAdzdWJ0eXBlFQwW7L4TFsY8 + FrA3Jvqf5p4CJuCd5p4CHDaUkRIoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUE + FQIAFQAVBBUQAAAWxJTv/wcV4gEW1vm0/wcVuAMAJrDY5p4CHBUMGTUGCAQZGAVjbGFzcxUMFuy+ + ExaSPBaUNyaw2OaeAiaQ1eaeAhw2opISKAl3YXJlaG91c2UYBWNhYmluABksFQQVBBUCABUAFQQV + EAAAFqaW7/8HFeIBFo79tP8HFb4CACakjOeeAhwVChk1BggAGRgGaGVpZ2h0FQwW7L4TFsQEFtQF + JqSM554CPBgIAAAAAAAAAEAYCAAAAAAAAPA/Fui+EygIAAAAAAAAAEAYCAAAAAAAAPA/ABkcFQAV + ABUQAAAWiJjv/wcV1AEWzP+0/wcVlgEAJviR554CHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwW + 7L4TFpBoFtZFJviR554CPDayuxMoEHphcGF0ZXJpYSBidXJnb3MYFDMgQ29taXNhcsOtYSBDYcOx + ZXRlABkcFQAVABUQAAAW3Jnv/wcV4gEW4oC1/wcV6AQAJs7X554CHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUDa2V5FQwW7r4TFvYTFpIRJs7X554CPDbqvhMoAmVzGAJlbgAZHBUAFQAV + EAAAFr6b7/8HFeIBFsqFtf8HFX4AJuDo554CHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFs + dWUFdmFsdWUVDBbuvhMWiBcWqhIm4OjnngI8Nuq+EygKU3RhdGUgQmFuaxgMQmFuY28gRXN0YWRv + ABkcFQAVABUQAAAWoJ3v/wcV4gEWyIa1/wcVogEAJor7554CHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudAd2YXJpYW50FQwW9L4TFooZFuQTJor7554CPDbcvhMoCG9mZmljaWFsGAlh + bHRlcm5hdGUAGRwVABUAFRAAABaCn+//BxXiARbqh7X/BxW8AgAm7o7ongIcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW9L4TFvwWFqASJu6O6J4CPDbwvhMoAmVz + GAJlbgAZHBUAFQAVEAAAFuSg7/8HFeIBFqaKtf8HFX4AJo6h6J4CHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvS+Exb+HBacFiaOoeieAjw23L4TKDVNdXNlbyBGb2xr + bMOzcmljbyBBcmF1Y2FubyBKdWFuIEFudG9uaW8gUsOtb3MgTW9yYWxlcxgZQmFuY28gZGVsIEVz + dGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFsai7/8HFeIBFqSLtf8HFbAGACaqt+ieAhwVChklBgAZ + eAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBb0vhMW6hYW + nhImqrfongI8NvS+EwAZHBUAFQAVEAAAFqik7/8HFeIBFtSRtf8HFXYAJsjJ6J4CHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW9L4TFuQWFpQSJsjJ6J4CPDb0vhMAGRwV + ABUAFRAAABaKpu//BxXiARbKkrX/BxV2ACbc2+ieAhwVABk1BggAGRgJaGFzX3BhcnRzFQwW7L4T + FpC8AhbsBybc2+ieAjwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFuyn7/8HFdQBFsCTtf8HFXYA + Jsjj6J4CHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFuy+ExaOvAIWsAYmyOPongI8GAEAGAEA + FgAoAQAYAQAAGRwVABUAFRAAABbAqe//BxXSARa2lLX/BxV2ACb46eieAhwVAhk1BggAGRgKbnVt + X2Zsb29ycxUMFuy+ExbQngQWikQm+OnongI8GAQKAAAAGAQBAAAAFqi/EigECgAAABgEAQAAAAAZ + HBUAFQAVEAAAFpKr7/8HFdoBFqyVtf8HFeYBACaCrumeAhwVAhk1BggAGRgWbnVtX2Zsb29yc191 + bmRlcmdyb3VuZBUMFuy+ExaQBBagBSaCrumeAjw27L4TABkcFQAVABUQAAAW7Kzv/wcV0gEWkpe1 + /wcVdgAmorPpngIcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbsvhMWkAQWoAUmorPpngI8Nuy+EwAZ + HBUAFQAVEAAAFr6u7/8HFdIBFoiYtf8HFXYAJsK46Z4CHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbs + vhMWkAQWoAUmwrjpngI8Nuy+EwAZHBUAFQAVEAAAFpCw7/8HFdIBFv6Ytf8HFXYAJuK96Z4CHBUM + GTUGCAAZGAxmYWNhZGVfY29sb3IVDBbsvhMWkAQWoAUm4r3pngI8Nuy+EwAZHBUAFQAVEAAAFuKx + 7/8HFdIBFvSZtf8HFXYAJoLD6Z4CHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbsvhMWkAQW + oAUmgsPpngI8Nuy+EwAZHBUAFQAVEAAAFrSz7/8HFdIBFuqatf8HFXYAJqLI6Z4CHBUMGTUGCAAZ + GA1yb29mX21hdGVyaWFsFQwW7L4TFpAEFqAFJqLI6Z4CPDbsvhMAGRwVABUAFRAAABaGte//BxXS + ARbgm7X/BxV2ACbCzemeAhwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFuy+ExaQBBagBSbCzemeAjw2 + 7L4TABkcFQAVABUQAAAW2Lbv/wcV0gEW1py1/wcVdgAm4tLpngIcFQoZNQYIABkYDnJvb2ZfZGly + ZWN0aW9uFQwW7L4TFpAEFqAFJuLS6Z4CPDbsvhMAGRwVABUAFRAAABaquO//BxXSARbMnbX/BxV2 + ACaC2OmeAhwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFuy+ExaQBBagBSaC2OmeAjw27L4T + ABkcFQAVABUQAAAW/Lnv/wcV0gEWwp61/wcVdgAmot3pngIcFQwZNQYIABkYCnJvb2ZfY29sb3IV + DBbsvhMWkAQWoAUmot3pngI8Nuy+EwAZHBUAFQAVEAAAFs677/8HFdIBFriftf8HFXYAJsLi6Z4C + HBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFuy+ExaQBBagBSbC4umeAjw27L4TABkcFQAVABUQAAAW + oL3v/wcV0gEWrqC1/wcVdgAWmradGxbsvhMmyq2UkQIWmLrVDRQmABn8Jibi5+meAhwVDBk1BggA + GRgCaWQVDBb0gBUW6qX0BRaKrtYBJuLn6Z4CPDYAKCAwOGJjZThlYWY1NzUzZmZmMDIwMGY5MzJi + ZDI4N2UwNBggMDhiYjJkODY5MjE5MGZmZjAyMDAzMWI4NWIxNDZmM2UAGRwVABUAFRIAABbyvu// + BxWQAhakobX/BxXeCQAm7JXAoAIcFQwZNQYIABkYCGdlb21ldHJ5FQwW9IAVFs7flxEW2uOQCibs + lcCgAjw2ACi3BAAAAAAGAAAABgAAAAADAAAAAQAAAAXAUkowwP2LscBCgO9OARTTwFJKMhqZ3zrA + QoDv1DjR2cBSSjG2xtEKwEKA8gtKtt3AUkowYIV71cBCgPF7Af7ewFJKMMD9i7HAQoDvTgEU0wAA + AAADAAAAAQAAAAXAUkoyUSCEBMBCgOo47l4XwFJKMiWBmcnAQoDtNs+f5sBSSisiWBmdwEKA6+TA + CJnAUkorb/BS5MBCgOk7mFyDwFJKMlEghATAQoDqOO5eFwAAAAADAAAAAQAAAAXAUkov5aDZKcBC + gO6rQ+YJwFJKL0oFBtDAQoDyBxj49cBSSigYTP3gwEKA7qtD5gnAUkootthuwcBCgOt75HztwFJK + L+Wg2SnAQoDuq0PmCQAAAAADAAAAAQAAAAXAUko1Ld82XMBCgOsYEW69wFJKNIaE6d/AQoDvmy3u + UMBSSjOSaSOwwEKA70Fr2xrAUko0OcNwLcBCgOq+T1uIwFJKNS3fNlzAQoDrGBFuvQAAAAADAAAA + AQAAAAXAUko0CzTnaMBCgPFmCUlVwFJKM54nndTAQoD0QYXcTcBSSjLW7OE/wEKA8/YGgfrAUkoz + Q/oq1MBCgPEZsy9twFJKNAs052jAQoDxZglJVQAAAAADAAAAAQAAAAXAUko3JZua/MBCgOs90Rvn + wFJKNW7iNevAQoD1FOpy0MBSSjRyzlO2wEKA9KfdKTvAUko2OQyRCMBCgOr4MP6mwFJKNyWbmvzA + QoDrPdEb5xhNAAAAAAMAAAABAAAABMBSJ5+pY4u1wEOu+d/GWH/AUiefXm6ZF8BDrvsNHWnEwFIn + nsRQ3qbAQ676sLma5cBSJ5+pY4u1wEOu+d/GWH8AGRwVABUAFSYAABaCwe//BxW+BBaCq7X/BxW2 + JwAmlqHjqgIcFQgZNQYIBBkoBGJib3gEeG1pbhUMFvSAFRaegT8WqpQ3Jpah46oCJsb50KoCHBgE + A9iQwhgE12ySwhYAKAQD2JDCGATXbJLCABksFQQVBBUCABUAFQQVEgAAFsDF7/8HFZACFrjStf8H + Fe4BACbWtpqrAhwVCBk1BggEGSgEYmJveAR4bWF4FQwW9IAVFo6DPxb2ljcm1raaqwIm8I2IqwIc + GAT315DCGATPbJLCFgAoBPfXkMIYBM9sksIAGSwVBBUEFQIAFQAVBBUSAAAW0Mfv/wcVkAIWptS1 + /wcV7gEAJub436sCHBUIGTUGCAQZKARiYm94BHltaW4VDBb0gBUW8spWFsj5SCbm+N+rAibmpL+r + AhwYBEiLEsIYBCeAHcIWACgESIsSwhgEJ4AdwgAZLBUEFQQVAgAVABUEFRIAABbgye//BxWQAhaU + 1rX/BxXuAQAm5vGorAIcFQgZNQYIBBkoBGJib3gEeW1heBUMFvSAFRbGylYWgP9IJubxqKwCJq6e + iKwCHBgENYsSwhgE+X8dwhYAKAQ1ixLCGAT5fx3CABksFQQVBBUCABUAFQQVEgAAFvDL7/8HFZAC + FoLYtf8HFe4BACbundGsAhwVAhk1BggEGRgHdmVyc2lvbhUMFvSAFRbIBRb8BibundGsAiaundGs + AhwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaAzu//BxXsARbw + 2bX/BxXuAQAm6qTRrAIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBb0 + gBUW2AYWjAgm6qTRrAImqqTRrAIcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABbsz+//BxXs + ARbe27X/BxVeACb6rdGsAhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwW + 9IAVFtCZBRaqnAMm+q3RrAImtqzRrAIcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1 + aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABbY0e//BxX+ARa83LX/BxXCBQAm4MjUrAIcFQwZJQYA + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW9IAVFpD3hgMW8sqLASbgyNSsAjw2 + ACgMdzk5ODc5NzA0OUAzGAwwMDAwMDA0MjA3NWYAGRwVABUAFRIAABbW0+//BxWQAhb+4bX/BxWO + BAAm7NDgrQIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBb0gBUW + zvcXFo7TBibs0OCtAibSk+CtAhw2ACgYMjAyNC0xMC0xOFQxMzo1ODo1NS4wMDBaGBgyMDExLTA1 + LTE2VDIwOjI1OjExLjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAW5tXv/wcVgAIWjOa1/wcVvgcAJo6G + 6K0CHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBb0gBUWorUaFtj3 + FiaOhuitAibg5uatAhwYCIts5/up8e4/GAjNzMzMzMzkPxaIogooCIts5/up8e4/GAjNzMzMzMzk + PwAZLBUEFQQVAgAVABUEFRIAABbm1+//BxWQAhbK7bX/BxWcAwAmgN/9rQIcFQIZNQYIBBkYBWxl + dmVsFQwW9IAVFpoHFs4IJoDf/a0CJrje/a0CHBgEAQAAABgE/////xbEgBUoBAEAAAAYBP////8A + GSwVBBUEFQIAFQAVBBUSAAAW9tnv/wcV8AEW5vC1/wcV8gEAJp7p/a0CHBUMGTUGCAQZGAdzdWJ0 + eXBlFQwW9IAVFrA+Fqg4Jp7p/a0CJobn/a0CHDay+hMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3Vs + dHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAW5tvv/wcV/AEW2PK1/wcVwAMAJtKi/q0CHBUMGTUGCAQZ + GAVjbGFzcxUMFvSAFRb0PRaANybSov6tAiaun/6tAhw2oPsTKAl3YXJlaG91c2UYCmFwYXJ0bWVu + dHMAGSwVBBUEFQIAFQAVBBUSAAAW4t3v/wcV/AEWmPa1/wcVqgMAJo7X/q0CHBUKGTUGCAQZGAZo + ZWlnaHQVDBb0gBUW/gUWmgcmjtf+rQImrtb+rQIcGAgAAAAAAAAgQBgIAAAAAAAAEEAW3oAVKAgA + AAAAAAAgQBgIAAAAAAAAEEAAGSwVBBUEFQIAFQAVBBUSAAAW3t/v/wcV7gEWwvm1/wcVogEAJqr6 + /q0CHBUMGTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwW9IAVFrxHFuItJqr6/q0CJsjd/q0CHDbe/hQo + GVpvbmEgWmVybyBTb3V0aCAmIEZyaWVuZHMYFzEgeSAyIEp1emdhZG8gZGUgbGV0cmFzABksFQQV + BBUCABUAFQQVEgAAFszh7/8HFfwBFuT6tf8HFZgGACaqi/+tAhwVDBklBgAZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlA2tleRUMFvSAFRbMDxaWDyaqi/+tAjw29IAVABkcFQAVABUSAAAWyOPv/wcV + /AEW/IC2/wcVggEAJsCa/60CHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUV + DBb0gBUWtBEWgg8mwJr/rQI8NvSAFQAZHBUAFQAVEgAAFsTl7/8HFfwBFv6Btv8HFYIBACbCqf+t + AhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFvaAFRaQEhbaDybC + qf+tAjw28IAVKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUSAAAWwOfv/wcV/AEWgIO2/wcV + yAEAJpy5/60CHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFvaA + FRbEERaaDyacuf+tAjw29oAVABkcFQAVABUSAAAWvOnv/wcV/AEWyIS2/wcVggEAJrbI/60CHBUM + GSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvaAFRaiExaqECa2yP+tAjw2 + 8IAVKCJDZW50cm8gQ29tdW5pdGFyaW8gZGUgU2FsdWQgTWVudGFsGB9BcmF1Y28gUHJlbWl1bSBP + dXRsZXQgU2FuIFBlZHJvABkcFQAVABUSAAAWuOvv/wcV/AEWyoW2/wcVhgMAJuDY/60CHBUKGSUG + ABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFvaAFRbG + ERacDybg2P+tAjw29oAVABkcFQAVABUSAAAWtO3v/wcV/AEW0Ii2/wcVggEAJvzn/60CHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW9oAVFsQRFpoPJvzn/60CPDb2gBUA + GRwVABUAFRIAABaw7+//BxX8ARbSibb/BxWCAQAmlvf/rQIcFQAZNQYIABkYCWhhc19wYXJ0cxUM + FvSAFRb01AIWlgcmlvf/rQI8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABas8e//BxXsARbUirb/ + BxWCAQAmrP7/rQIcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwW9IAVFvTUAhaWByas/v+tAjwY + AQAYAQAWACgBABgBAAAZHBUAFQAVEgAAFpjz7/8HFewBFtaLtv8HFYIBACaihoCuAhwVAhk1BggE + GRgKbnVtX2Zsb29ycxUMFvSAFRaYCBbECSaihoCuAibChYCuAhwYBAUAAAAYBAEAAAAWhIAVKAQF + AAAAGAQBAAAAABksFQQVBBUCABUAFQQVEgAAFoT17/8HFfABFtiMtv8HFeIBACaGj4CuAhwVAhk1 + BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFvSAFRbkBBaGBiaGj4CuAjwYBAEAAAAYBAEA + AAAW8oAVKAQBAAAAGAQBAAAAABkcFQAVABUSAAAW9Pbv/wcV7AEWuo62/wcVkgEAJoyVgK4CHBUK + GTUGCAAZGAptaW5faGVpZ2h0FQwW9IAVFtIEFvQFJoyVgK4CPDb0gBUAGRwVABUAFRIAABbg+O// + BxXsARbMj7b/BxWCAQAmgJuArgIcFQIZNQYIABkYCW1pbl9mbG9vchUMFvSAFRbSBBb0BSaAm4Cu + Ajw29IAVABkcFQAVABUSAAAWzPrv/wcV7AEWzpC2/wcVggEAJvSggK4CHBUMGTUGCAAZGAxmYWNh + ZGVfY29sb3IVDBb0gBUW0gQW9AUm9KCArgI8NvSAFQAZHBUAFQAVEgAAFrj87/8HFewBFtCRtv8H + FYIBACa4p4CuAhwVDBk1BggEGRgPZmFjYWRlX21hdGVyaWFsFQwW9IAVFsIFFvYGJringK4CJuim + gK4CHBgIY29uY3JldGUYCGNvbmNyZXRlFu6AFSgIY29uY3JldGUYCGNvbmNyZXRlABksFQQVBBUC + ABUAFQQVEgAAFqT+7/8HFewBFtKStv8HFaIBACberYCuAhwVDBk1BggAGRgNcm9vZl9tYXRlcmlh + bBUMFvSAFRbSBBb0BSberYCuAjw29IAVABkcFQAVABUSAAAWkIDw/wcV7AEW9JO2/wcVggEAJp60 + gK4CHBUMGTUGCAQZGApyb29mX3NoYXBlFQwW9IAVFuQFFpgHJp60gK4CJtKzgK4CHBgGZ2FibGVk + GAZnYWJsZWQW5IAVKAZnYWJsZWQYBmdhYmxlZAAZLBUEFQQVAgAVABUEFRIAABb8gfD/BxXuARb2 + lLb/BxWaAQAm6rqArgIcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW9IAVFtIEFvQFJuq6gK4C + PDb0gBUAGRwVABUAFRIAABbqg/D/BxXsARaQlrb/BxWCAQAm3sCArgIcFQwZNQYIABkYEHJvb2Zf + b3JpZW50YXRpb24VDBb0gBUW0gQW9AUm3sCArgI8NvSAFQAZHBUAFQAVEgAAFtaF8P8HFewBFpKX + tv8HFYIBACbWx4CuAhwVDBk1BggEGRgKcm9vZl9jb2xvchUMFvSAFRbMBhb0BybWx4CuAibSxoCu + Ahw23oAVKAcjRkZGRkZGGAcjMDAwMDAwABksFQQVBBUCABUAFQQVEgAAFsKH8P8HFe4BFpSYtv8H + FboBACbGzoCuAhwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBb0gBUW0gQW9AUmxs6ArgI8NvSAFQAZ + HBUAFQAVEgAAFrCJ8P8HFewBFs6Ztv8HFYIBABaYnv4cFvSAFSbi5+meAhbY7JYPFCgAGfwmJrrU + gK4CHBUMGTUGCAAZGAJpZBUMFqjzFBa6vPAFFtLa2AEmutSArgI8NgAoIDA4YmNlOGU2NmRiOWJm + ZmYwMjAwZTY1OTE0ODIwNGUyGCAwOGJjZTg4NDAwMDExZmZmMDIwMDgwZDIxYzE3N2U4OAAZHBUA + FQAVEgAAFpyL8P8HFZACFtCatv8HFd4JACaMr9mvAhwVDBk1BggAGRgIZ2VvbWV0cnkVDBao8xQW + woLxEBb2wfwJJoyv2a8CPDYAKOMBAAAAAAYAAAACAAAAAAMAAAABAAAAB8BSJr36PZeDwENjCks8 + NiHAUia9eqSDucBDYwpsR7fpwFImvUKqVjrAQ2MIWnRDscBSJr6cVnUawENjCADuyVTAUia++5BE + 6cBDYwuGPe2ZwFImviF9HRPAQ2MLvrfsAsBSJr36PZeDwENjCks8NiEAAAAAAwAAAAEAAAAFwFIm + vpxWdRrAQ2MIAO7JVMBSJr55/KFrwENjBtLV4KDAUia/jZQPYsBDYwaLdoojwFImv62PiFLAQ2MH + uix75sBSJr6cVnUawENjCADuyVQYTQAAAAADAAAAAQAAAATAUiKLRpNHRsBDb6Hw+NOYwFIiipo4 + v+/AQ2+hwfif68BSIote7601wENvoRabe0LAUiKLRpNHRsBDb6Hw+NOYABkcFQAVABUmAAAWrI3w + /wcVvgQWrqS2/wcVticAJoLx1bkCHBUIGTUGCAAZKARiYm94BHhtaW4VDBao8xQWutJTFsqmLyaC + 8dW5AjwYBATYkMIYBA9AksIWACgEBNiQwhgED0CSwgAZHBUAFQAVEgAAFuqR8P8HFZACFuTLtv8H + Fe4BACbMl4W6AhwVCBk1BggAGSgEYmJveAR4bWF4FQwWqPMUFrrSUxbQrS8mzJeFugI8GAT815DC + GAT4P5LCFgAoBPzXkMIYBPg/ksIAGRwVABUAFRIAABb6k/D/BxWQAhbSzbb/BxXuAQAmnMW0ugIc + FQgZNQYIABkoBGJib3gEeW1pbhUMFqjzFBa60lMWoOUxJpzFtLoCPBgECbAawhgEFxgcwhYAKAQJ + sBrCGAQXGBzCABkcFQAVABUSAAAWipbw/wcVkAIWwM+2/wcV7gEAJryq5roCHBUIGTUGCAAZKARi + Ym94BHltYXgVDBao8xQWutJTFrjhMSa8qua6AjwYBO+vGsIYBPUXHMIWACgE768awhgE9RccwgAZ + HBUAFQAVEgAAFpqY8P8HFZACFq7Rtv8HFe4BACa0jJi7AhwVAhk1BggEGRgHdmVyc2lvbhUMFqjz + FBbIBRb8Bia0jJi7Aib0i5i7AhwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAV + ABUEFRIAABaqmvD/BxXsARac07b/BxXuAQAmsJOYuwIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQIcHJvcGVydHkVDBao8xQW2AYWjAgmsJOYuwIm8JKYuwIcGAAYABYAKAAYAAAZLBUEFQQV + AgAVABUEFRIAABaWnPD/BxXsARaK1bb/BxVeACbAnJi7AhwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAdkYXRhc2V0FQwWqPMUFuibBRbEkAMmwJyYuwIm/JqYuwIcNgAoDU9wZW5TdHJlZXRN + YXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABaCnvD/BxX+ARbo1bb/ + BxXCBQAmwKubuwIcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWqPMU + FvbVjQMWrKuKASbAq5u7Ajw2ACgMdzk5NzAwOTI3NUAzGAwwMDAwMjk3NjYxYzEAGRwVABUAFRIA + ABaAoPD/BxWQAhaq27b/BxWOBAAm5q2mvAIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQL + dXBkYXRlX3RpbWUVDBao8xQWlqoXFpCRBybmraa8Aibs1qW8Ahw2ACgYMjAyNC0xMS0wOVQxNToz + NToxNi4wMDBaGBgyMDEwLTEyLTIyVDAzOjQ0OjMyLjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAWkKLw + /wcVgAIWuN+2/wcVvgcAJqyHrrwCHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZp + ZGVuY2UVDBao8xQWxqgdFt7fGSash668Aib856y8AhwYCM6I0t7gC+8/GAjNzMzMzMzkPxaGowgo + CM6I0t7gC+8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRIAABaQpPD/BxWQAhb25rb/BxWUAwAm + 2sfGvAIcFQIZNQYIABkYBWxldmVsFQwWqPMUFu4FFvoGJtrHxrwCPBgEAQAAABgE/////xaU8xQo + BAEAAAAYBP////8AGRwVABUAFRIAABagpvD/BxXwARaK6rb/BxWyAQAm1M7GvAIcFQwZNQYIABkY + B3N1YnR5cGUVDBao8xQWupQSFtI4JtTOxrwCPDak2xMoC3Jlc2lkZW50aWFsGAxhZ3JpY3VsdHVy + YWwAGRwVABUAFRIAABaQqPD/BxX8ARa867b/BxXqAwAmpofHvAIcFQwZNQYIABkYBWNsYXNzFQwW + qPMUFpaTCxb0Nyamh8e8Ajw2xtsTKAl3YXJlaG91c2UYCmFwYXJ0bWVudHMAGRwVABUAFRIAABaM + qvD/BxX8ARam77b/BxX4AgAmmr/HvAIcFQoZNQYIABkYBmhlaWdodBUMFqjzFBbSBBb0BSaav8e8 + Ajw2qPMUABkcFQAVABUSAAAWiKzw/wcV7AEWnvK2/wcVggEAJo7Fx7wCHBUMGTUGCAAZKAVuYW1l + cwdwcmltYXJ5FQwWqPMUFuwkFrQeJo7Fx7wCPDaK8hQoD2NvbXBsZWpvIHdpbmZpdBgpN8KqIENv + bXBhw7HDrWEgZGUgQm9tYmVyb3MgZGUgUGl0cnVmcXXDqW4AGRwVABUAFRIAABb0rfD/BxX8ARag + 87b/BxXCBQAmwuPHvAIcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBao8xQW + 9AoW1gsmwuPHvAI8NqjzFAAZHBUAFQAVEgAAFvCv8P8HFfwBFuL4tv8HFYIBACaY78e8AhwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWqPMUFvILFo4MJpjvx7wCPDao8xQA + GRwVABUAFRIAABbssfD/BxX8ARbk+bb/BxWCAQAmpvvHvAIcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50B3ZhcmlhbnQVDBao8xQWjAwWrgwmpvvHvAI8GAlhbHRlcm5hdGUYCWFsdGVy + bmF0ZRam8xQoCWFsdGVybmF0ZRgJYWx0ZXJuYXRlABkcFQAVABUSAAAW6LPw/wcV/AEW5vq2/wcV + pgEAJtSHyLwCHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFqjz + FBbyCxaMDCbUh8i8Ajw2qPMUABkcFQAVABUSAAAW5LXw/wcV/AEWjPy2/wcVggEAJuCTyLwCHBUM + GSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFqjzFBacDBa+DCbgk8i8AjwY + EUFlcm9wdWVydG8gVGVtdWNvGBFBZXJvcHVlcnRvIFRlbXVjbxam8xQoEUFlcm9wdWVydG8gVGVt + dWNvGBFBZXJvcHVlcnRvIFRlbXVjbwAZHBUAFQAVEgAAFuC38P8HFfwBFo79tv8HFcYBACaeoMi8 + AhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQV + DBao8xQW8gsWjAwmnqDIvAI8NqjzFAAZHBUAFQAVEgAAFty58P8HFfwBFtT+tv8HFYIBACaqrMi8 + AhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFqjzFBbyCxaMDCaqrMi8 + Ajw2qPMUABkcFQAVABUSAAAW2Lvw/wcV/AEW1v+2/wcVggEAJra4yLwCHBUAGTUGCAAZGAloYXNf + cGFydHMVDBao8xQWmtMCFpYHJra4yLwCPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAW1L3w/wcV + 7AEW2IC3/wcVggEAJsy/yLwCHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFqjzFBaa0wIWlgcm + zL/IvAI8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABbAv/D/BxXsARbagbf/BxWCAQAm4sbIvAIc + FQIZNQYIABkYCm51bV9mbG9vcnMVDBao8xQWqpQBFvIRJuLGyLwCPBgECQAAABgEAQAAABaM0hQo + BAkAAAAYBAEAAAAAGRwVABUAFRIAABaswfD/BxX6ARbcgrf/BxWCAgAm1NjIvAIcFQIZNQYIABkY + Fm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBao8xQW0gQW9AUm1NjIvAI8NqjzFAAZHBUAFQAVEgAA + FqbD8P8HFewBFt6Et/8HFYIBACbI3si8AhwVChk1BggAGRgKbWluX2hlaWdodBUMFqjzFBbSBBb0 + BSbI3si8Ajw2qPMUABkcFQAVABUSAAAWksXw/wcV7AEW4IW3/wcVggEAJrzkyLwCHBUCGTUGCAAZ + GAltaW5fZmxvb3IVDBao8xQW0gQW9AUmvOTIvAI8NqjzFAAZHBUAFQAVEgAAFv7G8P8HFewBFuKG + t/8HFYIBACaw6si8AhwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWqPMUFuT6ARaUCyaw6si8AjwY + ByNGRkZGRkYYByNGRkZGRkYWrt0UKAcjRkZGRkZGGAcjRkZGRkZGABkcFQAVABUSAAAW6sjw/wcV + 8gEW5Ie3/wcV1gEAJsT1yLwCHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBao8xQW+LgBFpIL + JsT1yLwCPBgEd29vZBgEd29vZBau3RQoBHdvb2QYBHdvb2QAGRwVABUAFRIAABbcyvD/BxXyARa6 + ibf/BxWyAQAm1oDJvAIcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBao8xQW9uwBFtwMJtaAybwC + PBgFbWV0YWwYBW1ldGFsFpTaFCgFbWV0YWwYBW1ldGFsABkcFQAVABUSAAAWzszw/wcV9AEW7Iq3 + /wcV0gEAJrKNybwCHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWqPMUFpzAARaWCyayjcm8AjwYBmdh + YmxlZBgGZ2FibGVkFoLhFCgGZ2FibGVkGAZnYWJsZWQAGRwVABUAFRIAABbCzvD/BxXyARa+jLf/ + BxXKAQAmyJjJvAIcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWqPMUFtIEFvQFJsiYybwCPDao + 8xQAGRwVABUAFRIAABa00PD/BxXsARaIjrf/BxWCAQAmvJ7JvAIcFQwZNQYIABkYEHJvb2Zfb3Jp + ZW50YXRpb24VDBao8xQW8M4BFpwLJryeybwCPBgFYWxvbmcYBWFsb25nFq7dFCgFYWxvbmcYBWFs + b25nABkcFQAVABUSAAAWoNLw/wcV8gEWio+3/wcVvgEAJtipybwCHBUMGTUGCAAZGApyb29mX2Nv + bG9yFQwWqPMUFub6ARasCybYqcm8AjwYByNDMEMwQzAYByNDMEMwQzAWrt0UKAcjQzBDMEMwGAcj + QzBDMEMwABkcFQAVABUSAAAWktTw/wcV8gEWyJC3/wcV1gEAJoS1ybwCHBUKGTUGCAAZGAtyb29m + X2hlaWdodBUMFqjzFBbSBBb0BSaEtcm8Ajw2qPMUABkcFQAVABUSAAAWhNbw/wcV7AEWnpK3/wcV + ggEAFtr/ph0WqPMUJrrUgK4CFr7myA4UKgAZ/CYm+LrJvAIcFQwZNQYIABkYAmlkFQwWiJAVFrrH + +AUW5vfUASb4usm8Ajw2ACggMDhiY2U4ZTNiNmQ1Y2ZmZjAyMDA5YjRiOWYwNmUxMzAYIDA4YmNl + OGE4MDAwNDhmZmYwMjAwODE0MjE3OGNjZjJhABkcFQAVABUSAAAW8Nfw/wcVkAIWoJO3/wcV3gkA + Jt6ynr4CHBUMGTUGCAAZGAhnZW9tZXRyeRUMFoiQFRbq+7MRFujUpgom3rKevgI8NgAojQYAAAAA + AwAAAAUAAAAZwFInVVo6CDrAQ15dPBs5QcBSJ1pItlI3wENeZXWlnovAUidZ2STJ5MBDXmYZOYzq + wFInWqBfhnjAQ15nZWnnJMBSJ12/zreJwENeYtW4LdnAUidf+Pl7gsBDXmaLT1P7wFInXDMGvYnA + Q15sDkYT4cBSJ11JhzKPwENebd8Aq/fAUidacjxdfsBDXnIF1tmWwFInW7FsHjbAQ150Ga1QMMBS + J1jxnj1twENeeB1ID2PAUidXjK7PjMBDXnXKh3gvwFInVEIMFArAQ156mEySgMBSJ1MWkul8wENe + eKUtS5PAUidVy+RvgcBDXnSxgsRrwFInUwcOETvAQ15wE45SPsBSJ1CZ4Oc2wENec52GjiTAUidL + zIcssMBDXmucMEzPwFInTeY84FvAQ15oi9qUNsBSJ02UB4lhwENeaAJH2N3AUidPQl1yosBDXmWN + +VJnwFInTtOiqeTAQ15k1JXu6sBSJ1KaAMemwENeX1J17prAUidTN7V488BDXmBZBiuTwFInVVo6 + CDrAQ15dPBs5QQAAAAXAUidYd5BaVsBDXmfaA+z1wFInVxqZCHrAQ15p4vKo/8BSJ1hZyMkywENe + a+vhZQrAUidZtsAbDsBDXmni8qj/wFInWHeQWlbAQ15n2gPs9QAAAAXAUidYEM2tncBDXm/zreIm + wFInVXKNvBbAQ15rZ1cnLsBSJ1PQzQyOwENebbAGw2nAUidWb3hd4MBDXnI9ND31wFInWBDNrZ3A + Q15v863iJgAAAAXAUidT8sZbmsBDXmI3LLz3wFInUnWDOdzAQ15kXyUphcBSJ1TB+TQ0wENeaD0A + O4/AUidWP6e1vMBDXmYVB88BwFInU/LGW5rAQ15iNyy89wAAAAfAUidP//KUB8BDXmhBMfl3wFIn + TqeYX97AQ15qQb05ssBSJ1D9SJWbwENebhMDEgPAUidStAH6rMBDXmuGYNexwFInUkTb0iPAQ15q + 0FhyiMBSJ1HmEUFxwENea1xvbJ/AUidP//KUB8BDXmhBMfl3GE0AAAAAAwAAAAEAAAAEwFIROz9p + LJbAQ56eYmuDLsBSETujOcPYwEOen6wX4EHAUhE5P+GmWsBDnp/ZDHtXwFIROz9pLJbAQ56eYmuD + LgAZHBUAFQAVKAAAFoDa8P8HFdwEFv6ct/8HFb4pACaQv9XIAhwVCBk1BggEGSgEYmJveAR4bWlu + FQwWiJAVFriePhaSwjYmkL/VyAImxofFyAIcGAQMUZDCGAQRX5HCFgAoBAxRkMIYBBFfkcIAGSwV + BBUEFQIAFQAVBBUSAAAW3N7w/wcVkAIWvMa3/wcV7gEAJuj/i8kCHBUIGTUGCAQZKARiYm94BHht + YXgVDBaIkBUWmpw+Fsq/Nibo/4vJAibYyfvIAhwYBPFQkMIYBPhekcIWACgE8VCQwhgE+F6RwgAZ + LBUEFQQVAgAVABUEFRIAABbs4PD/BxWQAhaqyLf/BxXuAQAm1srFyQIcFQgZNQYIBBkoBGJib3gE + eW1pbhUMFoiQFRaQhEMW2K86JtbKxckCJqKJsskCHBgEC7AawhgEDYAdwhYAKAQLsBrCGAQNgB3C + ABksFQQVBBUCABUAFQQVEgAAFvzi8P8HFZACFpjKt/8HFe4BACbM/P/JAhwVCBk1BggEGSgEYmJv + eAR5bWF4FQwWiJAVFtKGQxa0sjomzPz/yQIm+rjsyQIcGATorxrCGAT3fx3CFgAoBOivGsIYBPd/ + HcIAGSwVBBUEFQIAFQAVBBUSAAAWjOXw/wcVkAIWhsy3/wcV7gEAJu7rpsoCHBUCGTUGCAQZGAd2 + ZXJzaW9uFQwWiJAVFsgFFvwGJu7rpsoCJq7rpsoCHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAA + ABksFQQVBBUCABUAFQQVEgAAFpzn8P8HFewBFvTNt/8HFe4BACbq8qbKAhwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFoiQFRbYBhaMCCbq8qbKAiaq8qbKAhwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVEgAAFojp8P8HFewBFuLPt/8HFV4AJvr7psoCHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaIkBUW6qcFFs6cAyb6+6bKAia2+qbKAhw2ACgN + T3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEgAAFvTq + 8P8HFf4BFsDQt/8HFcIFACaEl6rKAhwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNv + cmRfaWQVDBaIkBUWqL6RAxaCoYQBJoSXqsoCPDYAKAx3OTk3MDA5MjY3QDEYDDAwMDAzMTUwM2U1 + YgAZHBUAFQAVEgAAFvLs8P8HFZACFoLWt/8HFYwEACbOrK/LAhwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFoiQFRa0+xwWjIMIJs6sr8sCJoa4rssCHDYAKBgyMDI0 + LTExLTMwVDEzOjI4OjEzLjAwMFoYGDIwMTAtMDMtMDNUMjM6NTY6MjguMDAwWgAZLBUEFQQVAgAV + ABUEFRIAABaC7/D/BxWAAhaO2rf/BxW+BwAmkNq3ywIcFQoZJQYEGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQKY29uZmlkZW5jZRUMFoiQFRa8vx0W8vwZJpDat8sCJpK7tssCHBgIliGOdXEb7z8YCM3M + zMzMzOQ/Ftq7CCgIliGOdXEb7z8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEgAAFoLx8P8HFZAC + Fszht/8HFZgDACaEuNDLAhwVAhk1BggAGRgFbGV2ZWwVDBaIkBUW7gcWiggmhLjQywI8GAQBAAAA + GAT/////FtKPFSgEAQAAABgE/////wAZHBUAFQAVEgAAFpLz8P8HFfIBFuTkt/8HFdIBACacwtDL + AhwVDBk1BggEGRgHc3VidHlwZRUMFoiQFRb+RxbQPiacwtDLAiaOwNDLAhw29ooUKAdzZXJ2aWNl + GAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAWhPXw/wcV/AEWtua3/wcV1gMAJvaC0csC + HBUMGTUGCAQZGAVjbGFzcxUMFoiQFRaiSxaIQSb2gtHLAibe/tDLAhw23IsUKAl3YXJlaG91c2UY + CmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUSAAAWgPfw/wcV/AEWjOq3/wcVoAMAJua/0csCHBUK + GTUGCAAZGAZoZWlnaHQVDBaIkBUWogUWxAYm5r/RywI8GAgAAAAAAABVQBgIAAAAAAAAHEAWgpAV + KAgAAAAAAABVQBgIAAAAAAAAHEAAGRwVABUAFRIAABb8+PD/BxXsARas7bf/BxXiAQAmqsbRywIc + FQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaIkBUW6JkBFtpfJqrG0csCPDbOihUoD8K0Q2Fzb25h + IE1hbG11cxglMSAyIHkgMyBKdXpnYWRvIFBvbGljw61hIExvY2FsIFRlbXVjbwAZHBUAFQAVEgAA + Fuj68P8HFf4BFo7vt/8HFYYGACbeptLLAhwVDBklBgQZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVl + A2tleRUMFo6QFRaiGBbkFCbeptLLAiaEptLLAhw2/o8VKAJmchgCZW4AGSwVBBUEFQIAFQAVBBUS + AAAW5vzw/wcV+gEWlPW3/wcVmgEAJvy90ssCHBUMGSUGBBlIBW5hbWVzBmNvbW1vbglrZXlfdmFs + dWUFdmFsdWUVDBaOkBUWmh8Wohgm/L3SywIm6LrSywIcNv6PFSgjU291dGhlcm4gQW5kZWFuIFZv + bGNhbm8gT2JzZXJ2YXRvcnkYDkJhbmNvIGRlIENoaWxlABksFQQVBBUCABUAFQQVEgAAFuD+8P8H + FfwBFq72t/8HFfADACaK09LLAhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFy + aWFudBUMFoyQFRbIHBawFiaK09LLAjw2/I8VKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUS + AAAW3IDx/wcV/AEWnvq3/wcVygIAJrrp0ssCHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAhsYW5ndWFnZRUMFoyQFRaCGxbcFCa66dLLAjw2jJAVABkcFQAVABUSAAAW2ILx/wcV/AEW + 6Py3/wcVggEAJpb+0ssCHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUM + FoyQFRacHxaWGCaW/tLLAjw2/I8VKBpUZWF0cm8gTXVuaWNpcGFsIGRlIFRlbXVjbxgZQmFuY28g + ZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEgAAFtSE8f8HFfwBFur9t/8HFY4GACasltPLAhwV + ChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBaM + kBUWhhsW4BQmrJbTywI8NoyQFQAZHBUAFQAVEgAAFtCG8f8HFfwBFviDuP8HFYIBACaMq9PLAhwV + DBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFoyQFRaCGxbcFCaMq9PLAjw2 + jJAVABkcFQAVABUSAAAWzIjx/wcV/AEW+oS4/wcVggEAJui/08sCHBUAGTUGCAAZGAloYXNfcGFy + dHMVDBaIkBUW5NYCFqYHJui/08sCPBgBARgBABYAKAEBGAEAABkcFQAVABUSAAAWyIrx/wcV7AEW + /IW4/wcVggEAJo7H08sCHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFoiQFRbm1gIWlgcmjsfT + ywI8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABa0jPH/BxXsARb+hrj/BxWCAQAmps/TywIcFQIZ + NQYIBBkYCm51bV9mbG9vcnMVDBaIkBUW6BgWnhgmps/TywImpM7TywIcGAQbAAAAGAQBAAAAFo7v + FCgEGwAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABagjvH/BxX6ARaAiLj/BxXyAQAmwubTywIc + FQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaIkBUW0gQW9AUmwubTywI8NoiQFQAZ + HBUAFQAVEgAAFpqQ8f8HFewBFvKJuP8HFYIBACa27NPLAhwVChk1BggAGRgKbWluX2hlaWdodBUM + FoiQFRbSBBb0BSa27NPLAjw2iJAVABkcFQAVABUSAAAWhpLx/wcV7AEW9Iq4/wcVggEAJqry08sC + HBUCGTUGCAAZGAltaW5fZmxvb3IVDBaIkBUW0gQW9AUmqvLTywI8NoiQFQAZHBUAFQAVEgAAFvKT + 8f8HFewBFvaLuP8HFYIBACae+NPLAhwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWiJAVFtIEFvQF + Jp7408sCPDaIkBUAGRwVABUAFRIAABbelfH/BxXsARb4jLj/BxWCAQAmkv7TywIcFQwZNQYIABkY + D2ZhY2FkZV9tYXRlcmlhbBUMFoiQFRbSBBb0BSaS/tPLAjw2iJAVABkcFQAVABUSAAAWypfx/wcV + 7AEW+o24/wcVggEAJoaE1MsCHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWiJAVFtIEFvQFJoaE + 1MsCPDaIkBUAGRwVABUAFRIAABa2mfH/BxXsARb8jrj/BxWCAQAmxorUywIcFQwZNQYIBBkYCnJv + b2Zfc2hhcGUVDBaIkBUWsgUW5gYmxorUywIm+onUywIcGAZnYWJsZWQYBmdhYmxlZBaEkBUoBmdh + YmxlZBgGZ2FibGVkABksFQQVBBUCABUAFQQVEgAAFqKb8f8HFewBFv6PuP8HFZoBACbgkNTLAhwV + Chk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaIkBUW0gQW9AUm4JDUywI8NoiQFQAZHBUAFQAVEgAA + Fo6d8f8HFewBFpiRuP8HFYIBACbUltTLAhwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFoiQ + FRbSBBb0BSbUltTLAjw2iJAVABkcFQAVABUSAAAW+p7x/wcV7AEWmpK4/wcVggEAJsic1MsCHBUM + GTUGCAAZGApyb29mX2NvbG9yFQwWiJAVFvIEFpQGJsic1MsCPBgHIzgwNDA0MBgHIzgwNDA0MBaG + kBUoByM4MDQwNDAYByM4MDQwNDAAGRwVABUAFRIAABbmoPH/BxXsARack7j/BxWeAQAm3KLUywIc + FQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWiJAVFtIEFvQFJtyi1MsCPDaIkBUAGRwVABUAFRIAABbS + ovH/BxXsARa6lLj/BxWCAQAW9K6KHRaIkBUm+LrJvAIW2O2KDxQsABn8JibQqNTLAhwVDBk1BggA + GRgCaWQVDBbArRMW0Oq4BRaC2cwBJtCo1MsCPDYAKCAwOGJjZTlkYjc2YWYwZmZmMDIwMDQ1MWVi + MmFlZmUwZhggMDhiY2U4ODQ4YjY2Y2ZmZjAyMDAwNTg5YTY1ZDUyZmQAGRwVABUAFRAAABa+pPH/ + BxXyARa8lbj/BxXWCAAm0oGhzQIcFQwZNQYIABkYCGdlb21ldHJ5FQwWwK0TFvL/ghAWzIDTCSbS + gaHNAjw2ACjDAQAAAAAGAAAAAgAAAAADAAAAAQAAAAXAUfKTt1M/1MBDoU5m6NKcwFHylDC+HmjA + Q6FOLwcbjcBR8pRpamEBwEOhT1i0V4fAUfKT7/9+hsBDoU+QlhBnwFHyk7dTP9TAQ6FOZujSnAAA + AAADAAAAAQAAAAXAUfKUML4eaMBDoU4vBxuNwFHyk9+fNKzAQ6FMhO/jnsBR8pU70B9HwEOhS+Sv + CfHAUfKVjjYyI8BDoU2VfFl3wFHylDC+HmjAQ6FOLwcbjRhNAAAAAAMAAAABAAAABMBR8N6XLU4+ + wEOJYdB/5prAUfDeWAC89sBDiWDNR9AwwFHw31K1miXAQ4lhYWuJIMBR8N6XLU4+wEOJYdB/5poA + GRwVABUAFSQAABawpvH/BxWgBBaSnrj/BxWuJQAmnoL01gIcFQgZNQYIABkoBGJib3gEeG1pbhUM + FsCtExbOuk0WzuctJp6C9NYCPBgEBnCPwhgEAUCSwhYAKAQGcI/CGAQBQJLCABkcFQAVABUQAAAW + 0Krx/wcV8gEWwMO4/wcV1gEAJuzpodcCHBUIGTUGCAAZKARiYm94BHhtYXgVDBbArRMW0LpNFs7w + LSbs6aHXAjwYBPVvj8IYBPg/ksIWACgE9W+PwhgE+D+SwgAZHBUAFQAVEAAAFsKs8f8HFfIBFpbF + uP8HFdYBACbA/O/XAhwVCBk1BggEGSgEYmJveAR5bWluFQwWwK0TFoy3Uxa0pUYmwPzv1wImutrP + 1wIcGARM/BnCGAQMgB3CFgAoBEz8GcIYBAyAHcIAGSwVBBUEFQIAFQAVBBUQAAAWtK7x/wcV8gEW + 7Ma4/wcV1gEAJvqcttgCHBUIGTUGCAQZKARiYm94BHltYXgVDBbArRMW1K9TFtagRib6nLbYAibu + /5XYAhwYBDf8GcIYBPV/HcIWACgEN/wZwhgE9X8dwgAZLBUEFQQVAgAVABUEFRAAABamsPH/BxXy + ARbCyLj/BxXWAQAmhKHc2AIcFQIZNQYIBBkYB3ZlcnNpb24VDBbArRMW/gQWoAYmhKHc2AImxKDc + 2AIcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWmLLx/wcV0gEW + mMq4/wcV1gEAJqSn3NgCHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW + wK0TFv4FFqAHJqSn3NgCJuSm3NgCHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW6rPx/wcV + 0gEW7su4/wcVVgAmyK/c2AIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUM + FsCtExbY5wQWtoADJsiv3NgCJoSu3NgCHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBC + dWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWvLXx/wcV4gEWxMy4/wcV9gQAJrqu39gCHBUMGSUG + ABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsCtExaa2e4CFv6sggEmuq7f2AI8 + NgAoDHc5OTMxOTA3NjFAMRgMMDAwMjNlOTgyYTJhABkcFQAVABUQAAAWnrfx/wcV8gEWutG4/wcV + 1gMAJtS44tkCHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWwK0T + FuLkGBbuvAcm1Lji2QImuNvh2QIcNgAoGDIwMjQtMTAtMDVUMDY6NTA6NTMuMDAwWhgYMjAxMi0w + OS0xNVQxNToxNjoyNC4wMDBaABksFQQVBBUCABUAFQQVEAAAFpC58f8HFegBFpDVuP8HFdYGACai + t+rZAhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWwK0TFpj3Ghb6 + zRcmorfq2QImppjp2QIcGAh3vp8aL93uPxgIzczMzMzM5D8W3PsHKAh3vp8aL93uPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAW+Lrx/wcV8gEW5tu4/wcV7AIAJuDmgNoCHBUCGTUGCAQZGAVs + ZXZlbBUMFsCtExagBRbCBibg5oDaAiag5oDaAhwYBAEAAAAYBAEAAAAWrq0TKAQBAAAAGAQBAAAA + ABksFQQVBBUCABUAFQQVEAAAFuq88f8HFdIBFtLeuP8HFbYBACb47oDaAhwVDBk1BggEGRgHc3Vi + dHlwZRUMFsCtExb0NhbcLyb47oDaAibi7IDaAhw2qugSKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1 + bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFry+8f8HFeIBFojguP8HFdIDACakoIHaAhwVDBk1BggE + GRgFY2xhc3MVDBbArRMWmjoWujMmpKCB2gImvpyB2gIcNtzoEigJd2FyZWhvdXNlGAphcGFydG1l + bnRzABksFQQVBBUCABUAFQQVEAAAFp7A8f8HFeIBFtrjuP8HFYoDACb4z4HaAhwVChk1BggAGRgG + aGVpZ2h0FQwWwK0TFpAEFqAFJvjPgdoCPDbArRMAGRwVABUAFRAAABaAwvH/BxXSARbk5rj/BxV2 + ACaY1YHaAhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFsCtExakNRaEJyaY1YHaAjw2zqsTKAlw + YW5hZGVyaWEYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFtLD8f8HFeABFtrnuP8HFbwEACac/IHa + AhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFsKtExbuDBa6DCac/IHaAjw2 + uK0TKAJrbxgCZW4AGRwVABUAFRAAABayxfH/BxXgARaW7Lj/BxWOAQAm1oiC2gIcFQwZJQYAGUgF + bmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFsKtExbADxaiDibWiILaAjw2uK0TKA9SZXTD + qW4gQ2hvbGNob2wYE0VkaWZpY2lvIEVsIFBlaHXDqW4AGRwVABUAFRAAABaSx/H/BxXgARak7bj/ + BxXcAgAm+JaC2gIcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbA + rRMWig4Wgg0m+JaC2gI8GAhvZmZpY2lhbBgIb2ZmaWNpYWwWvK0TKAhvZmZpY2lhbBgIb2ZmaWNp + YWwAGRwVABUAFRAAABbyyPH/BxXgARaA8Lj/BxW2AQAm+qOC2gIcFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWwK0TFtYNFs4MJvqjgtoCPDbArRMAGRwVABUAFRAA + ABbSyvH/BxXgARa28bj/BxV2ACbIsILaAhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQFdmFsdWUVDBbArRMWtA8WmA4myLCC2gI8NrytEyhMQ29tcGxlam8gSW50ZXJkaXNjaXBsaW5h + cmlvIHBhcmEgZWwgRGVzYXJyb2xsbyBTdXN0ZW50YWJsZSBNaWNoYWVsIER1cmFuZCBRLhgZQmFu + Y28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFrLM8f8HFeABFqzyuP8HFdoDACbgvoLa + AhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQV + DBbArRMW1g0Wzgwm4L6C2gI8NsCtEwAZHBUAFQAVEAAAFpLO8f8HFeABFob2uP8HFXYAJq7LgtoC + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWwK0TFtYNFs4MJq7LgtoC + PDbArRMAGRwVABUAFRAAABbyz/H/BxXgARb89rj/BxV2ACb814LaAhwVABk1BggAGRgJaGFzX3Bh + cnRzFQwWwK0TFvS5AhbABib814LaAjwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFtLR8f8HFdIB + FvL3uP8HFXYAJrzegtoCHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFsCtExb2uQIWrgYmvN6C + 2gI8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABak0/H/BxXSARbo+Lj/BxV2ACbi5YLaAhwVAhk1 + BggEGRgKbnVtX2Zsb29ycxUMFsCtExa8CBbeCSbi5YLaAibq5ILaAhwYBAoAAAAYBAEAAAAW0qsT + KAQKAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFvbU8f8HFdgBFt75uP8HFaYBACbI7oLaAhwV + Ahk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFsCtExaQBBagBSbI7oLaAjw2wK0TABkc + FQAVABUQAAAWztbx/wcV0gEWhPu4/wcVdgAm6POC2gIcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbA + rRMWkAQWoAUm6POC2gI8NsCtEwAZHBUAFQAVEAAAFqDY8f8HFdIBFvr7uP8HFXYAJoj5gtoCHBUC + GTUGCAAZGAltaW5fZmxvb3IVDBbArRMWkAQWoAUmiPmC2gI8NsCtEwAZHBUAFQAVEAAAFvLZ8f8H + FdIBFvD8uP8HFXYAJqj+gtoCHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbArRMWkAQWoAUmqP6C + 2gI8NsCtEwAZHBUAFQAVEAAAFsTb8f8HFdIBFub9uP8HFXYAJsiDg9oCHBUMGTUGCAAZGA9mYWNh + ZGVfbWF0ZXJpYWwVDBbArRMW+AcW6AUmyIOD2gI8GAR3b29kGAR3b29kFoitEygEd29vZBgEd29v + ZAAZHBUAFQAVEAAAFpbd8f8HFdQBFtz+uP8HFYYBACawiYPaAhwVDBk1BggAGRgNcm9vZl9tYXRl + cmlhbBUMFsCtExasBBa8BSawiYPaAjwYBHdvb2QYBHdvb2QWvq0TKAR3b29kGAR3b29kABkcFQAV + ABUQAAAW6t7x/wcV0gEW4v+4/wcVhgEAJuyOg9oCHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWwK0T + FpAEFqAFJuyOg9oCPDbArRMAGRwVABUAFRAAABa84PH/BxXSARbogLn/BxV2ACaMlIPaAhwVChk1 + BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbArRMWkAQWoAUmjJSD2gI8NsCtEwAZHBUAFQAVEAAAFo7i + 8f8HFdIBFt6Buf8HFXYAJqyZg9oCHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWwK0TFpAE + FqAFJqyZg9oCPDbArRMAGRwVABUAFRAAABbg4/H/BxXSARbUgrn/BxV2ACbMnoPaAhwVDBk1BggA + GRgKcm9vZl9jb2xvchUMFsCtExaQBBagBSbMnoPaAjw2wK0TABkcFQAVABUQAAAWsuXx/wcV0gEW + yoO5/wcVdgAm7KOD2gIcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWwK0TFpAEFqAFJuyjg9oCPDbA + rRMAGRwVABUAFRAAABaE5/H/BxXSARbAhLn/BxV2ABbSrqwbFsCtEybQqNTLAha8gK8OFC4AGfwm + Joypg9oCHBUMGTUGCAAZGAJpZBUMFvDqFBbajO4FFrbH2QEmjKmD2gI8NgAoIDA4YmNlOGJkYjZj + NDFmZmYwMjAwM2ZjZTdmNzJiMDM1GCAwOGJjZTg4NjkyMDUxZmZmMDIwMDc3ODYyOTdkMjZhNAAZ + HBUAFQAVEgAAFtbo8f8HFZACFraFuf8HFd4JACbC8NzbAhwVDBk1BggAGRgIZ2VvbWV0cnkVDBbw + 6hQWiuPrEBbmyoIKJsLw3NsCPDYAKLENAAAAAAMAAAAKAAAANMBSGspl6j+kwENEp1sjPEXAUhrL + Pevz2sBDRKvTWAFJwFIaxKQJXyTAQ0Su4Sl7JMBSGsTY4oTFwENEr/ep8CnAUhrOobkizMBDRKtx + MnJDwFIa0BmIZ0LAQ0SzNiLRvMBSGs+UJ2nRwENEs3Q2MsLAUhrP/Cw16cBDRLWagSAmwFIa0LWP + mWbAQ0S1RPDK2cBSGtMc3YZYwENEwfyPMjjAUhrRRq8Q+sBDRMLV0wXMwFIa0aAFxGXAQ0TErhpa + HsBSGtA8w9WtwENExVKFCBLAUhrQW2ImZsBDRMXzlLezwFIa0Bfa6BnAQ0TGEp5oNcBSGtBs/92b + wENEx9UWR2rAUhrQYoOC18BDRMfaHsTnwFIazgxn7U/AQ0TI7hr7LsBSGs3DbNG6wENEx2tj/CnA + UhrNDPkMx8BDRMfAHZHhwFIay81d7ETAQ0TBJCIeOMBSGsg98dMXwENEwsk9zBPAUhrI5Uwfk8BD + RMY+PVJxwFIaysqUDWnAQ0TFXWzCocBSGss/mXMDwENEx8oujNvAUhrMHXpkSsBDRMdjAIBYwFIa + zP8hs6/AQ0TMDLNsqcBSGstx7lnlwENEzMRpUPzAUhrLlFMIvMBDRM16cbYmwFIax15jYqbAQ0TP + bLo9fsBSGscXgSYFwENEzfaYeDHAUhrFA6qvbMBDRM7sYb2KwFIaxSvum1TAQ0TPwXPTNsBSGsJH + N8z2wENE0RiL6ADAUhrAtj4VD8BDRMjP6ApAwFIavsTMTUvAQ0TJtcEXjcBSGr37eLHDwENExYxm + qzDAUhq+94yT+MBDRMUXzKVgwFIavruSEebAQ0TD2d8EB8BSGr2/Es/mwENExE55CdfAUhq8dI/0 + 1cBDRL16SXI6wFIavoNd7fLAQ0S8hwRroMBSGr43B9QKwENEuvKvtWXAUhq8KlK54cBDRLvlHfxq + wFIauusi+SnAQ0S1TVRGqcBSGroKvckkwENEtbVZEsHAUhq46cD5WsBDRK+88Y12wFIawoVLLfzA + Q0SrS3LFGcBSGsKzAvcrwENErDwzjPXAUhrDsnHXtMBDRKvF7Af7wFIaw3gk1MzAQ0Sqj4si3sBS + Gspl6j+kwENEp1sjPEUAAAAGwFIaw3Fu2CXAQ0SwncIdRsBSGsNIv4xywENEr8YryNzAUhq7+oIR + vsBDRLMnCVlFwFIavCMxXXDAQ0Sz/3ZtRcBSGsFlkH2RwENEsZAwZEzAUhrDcW7YJcBDRLCdwh1G + AAAAB8BSGsgPzqodwENEsCDEm6bAUhrGcdRYssBDRLDii3rzwFIaxrzoUzvAQ0Sya/h2n8BSGsV3 + 2VVxwENEswPN6trAUhrGyDttlMBDRLnmQDtZwFIayatEvMjAQ0S4jXqnZsBSGsgPzqodwENEsCDE + m6YAAAAFwFIazDLeeZ3AQ0SvIcEa6MBSGsvCdjG2wENEr0T8iVPAUhrOZVNA8MBDRLysxBjJwFIa + zsQd0aLAQ0S8QI2OycBSGswy3nmdwENEryHBGugAAAAHwFIaz2D7w1rAQ0S+5YN8+MBSGsyKHE4U + wENEwE45SPfAUhrMsLK608BDRMENe+mFwFIazwPesdLAQ0S/5V29SsBSGs+5EFdmwENEw2LAv3jA + UhrQPMPVrcBDRMMhUmAfwFIaz2D7w1rAQ0S+5YN8+AAAAAfAUhrMFKuIr8BDRLWNFSbZwFIayiC1 + gi3AQ0S2iZRo2MBSGspHt062wENEt0ZSyqjAUhrKwBeypMBDRLcJFik3wFIaywHxccjAQ0S4SYgJ + TsBSGsx9hxRcwENEt4pFaMDAUhrMFKuIr8BDRLWNFSbZAAAABcBSGsV8CxNZwENEuJUHY6LAUhrC + BV4N0sBDRLohz12hwFIawjFoV9jAQ0S7Ebll6MBSGsWoFV1fwENEuYQarFTAUhrFfAsTWcBDRLiV + B2OiAAAABcBSGseuFHrhwENExXGOuJXAUhrEj+dpMMBDRMbsuPtfwFIaxNKX5+nAQ0TIRKfPvcBS + GsfwxPmawENExsl9jPTAUhrHrhR64cBDRMVxjriVAAAABcBSGssSTQmewENEux5On6DAUhrKKRj9 + /sBDRLuPjacdwFIayvQaGLDAQ0S/iECrwsBSGsvdTiRQwENEvxcBpEXAUhrLEk0JnsBDRLseTp+g + AAAABcBSGsQULAbvwENEsdoCP3XAUhrAyzbKl8BDRLNpTngzwFIawPty0oXAQ0S0Y0l7dMBSGsRE + 026nwENEstP9QrbAUhrEFCwG78BDRLHaAj91GE0AAAAAAwAAAAEAAAAEwFJCw0LMFTPAQywG68iP + 5sBSQsNKHzf3wEMsB+Of5GbAUkLCUYsQs8BDLAf12dNuwFJCw0LMFTPAQywG68iP5gAZHBUAFQAV + JgAAFubq8f8HFb4EFpSPuf8HFbYnACaou9/lAhwVCBk1BggAGSgEYmJveAR4bWluFQwW8OoUFtqw + UxaWlTEmqLvf5QI8GAQcJJDCGAQBQJLCFgAoBBwkkMIYBAFAksIAGRwVABUAFRIAABak7/H/BxWQ + AhbKtrn/BxXuAQAmvtCQ5gIcFQgZNQYIABkoBGJib3gEeG1heBUMFvDqFBbasFMWnpkxJr7QkOYC + PBgECiSQwhgE8j+SwhYAKAQKJJDCGATyP5LCABkcFQAVABUSAAAWtPHx/wcVkAIWuLi5/wcV7gEA + JtzpweYCHBUIGTUGCAAZKARiYm94BHltaW4VDBbw6hQW2LBTFpz3Mybc6cHmAjwYBAfgF8IYBCqw + GsIWACgEB+AXwhgEKrAawgAZHBUAFQAVEgAAFsTz8f8HFZACFqa6uf8HFe4BACb44PXmAhwVCBk1 + BggAGSgEYmJveAR5bWF4FQwW8OoUFtqwUxac9jMm+OD15gI8GATx3xfCGAT6rxrCFgAoBPHfF8IY + BPqvGsIAGRwVABUAFRIAABbU9fH/BxWQAhaUvLn/BxXuAQAm1Nep5wIcFQIZNQYIBBkYB3ZlcnNp + b24VDBbw6hQWyAUW/AYm1Nep5wImlNep5wIcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwV + BBUEFQIAFQAVBBUSAAAW5Pfx/wcV7AEWgr65/wcV7gEAJtDeqecCHBUMGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50CHByb3BlcnR5FQwW8OoUFtgGFowIJtDeqecCJpDeqecCHBgAGAAWACgAGAAA + GSwVBBUEFQIAFQAVBBUSAAAW0Pnx/wcV7AEW8L+5/wcVXgAm4Oep5wIcFQwZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFvDqFBaWkwUWmvMCJuDnqecCJpzmqecCHDYAKA1PcGVu + U3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUSAAAWvPvx/wcV + /gEWzsC5/wcVwgUAJrbZrOcCHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9p + ZBUMFvDqFBbWlvICFrSYmwEmttms5wI8NgAoDHc5OTUxMDM5OTZANRgMMDAwMGUyYTc4ZmNkABkc + FQAVABUSAAAWuv3x/wcVkAIWkMa5/wcVjAQAJtSNyOgCHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdl + bGVtZW50C3VwZGF0ZV90aW1lFQwW8OoUFvLdERaavgQm1I3I6AIm6vHH6AIcNgAoGDIwMjQtMTEt + MjRUMTc6MzA6MTcuMDAwWhgYMjAxMC0xMi0yMVQwMDoyMDoyMC4wMDBaABksFQQVBBUCABUAFQQV + EgAAFsr/8f8HFf4BFpzKuf8HFb4HACbgys3oAhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dApjb25maWRlbmNlFQwW8OoUFqKKFRaqvBEm4MrN6AImhLDM6AIcGAgibHh6pSzvPxgIzczMzMzM + 5D8Wir4NKAgibHh6pSzvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUSAAAWyIHy/wcVjgIW2tG5 + /wcVoAMAJq7s3egCHBUCGTUGCAAZGAVsZXZlbBUMFvDqFBamBha6Byau7N3oAjwYBAEAAAAYBP// + //8W1uoUKAQBAAAAGAT/////ABkcFQAVABUSAAAW1oPy/wcV8AEW+tS5/wcV4gEAJur13egCHBUM + GTUGCAQZGAdzdWJ0eXBlFQwW8OoUFp4SFqASJur13egCJujz3egCHDaS5BQoDnRyYW5zcG9ydGF0 + aW9uGAVjaXZpYwAZLBUEFQQVAgAVABUEFRIAABbGhfL/BxX6ARbc1rn/BxXUAwAmiIbe6AIcFQwZ + NQYIABkYBWNsYXNzFQwW8OoUFs5DFsYVJoiG3ugCPDb45BQoCXdhcmVob3VzZRgFY2FiaW4AGRwV + ABUAFRIAABbAh/L/BxX+ARaw2rn/BxXkAgAmzpve6AIcFQoZNQYIABkYBmhlaWdodBUMFvDqFBa6 + BRa+BibOm97oAjwYCAAAAAAAABBAGAgAAAAAAAAIQBbo6hQoCAAAAAAAABBAGAgAAAAAAAAIQAAZ + HBUAFQAVEgAAFr6J8v8HFe4BFpTduf8HFaIBACaMot7oAhwVDBk1BggAGSgFbmFtZXMHcHJpbWFy + eRUMFvDqFBbcRhasNCaMot7oAjw2sOgUKBBqdW50YSBkZSB2ZWNpbm9zGBQxIENvbWlzYXLDrWEg + TGF1dGFybwAZHBUAFQAVEgAAFqyL8v8HFfoBFrbeuf8HFboFACa41t7oAhwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFvbqFBbGEBaqDya41t7oAjw26uoUKAJlcxgCZW4AGRwV + ABUAFRIAABamjfL/BxX6ARbw47n/BxWSAQAm4uXe6AIcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQV2YWx1ZRUMFvbqFBbKExbqECbi5d7oAjw26uoUKApTdGF0ZSBCYW5rGAxCYW5jbyBF + c3RhZG8AGRwVABUAFRIAABagj/L/BxX6ARaC5bn/BxXaAQAmtvfe6AIcFQwZJQYEGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBb46hQW9BIW0BAmtvfe6AImzPbe6AIcNuTqFCgI + b2ZmaWNpYWwYCWFsdGVybmF0ZQAZLBUEFQQVAgAVABUEFRIAABaakfL/BxX6ARbc5rn/BxXkAQAm + nIff6AIcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW+OoUFrAS + Fv4PJpyH3+gCPDbw6hQoAmVzGAJlbgAZHBUAFQAVEgAAFpST8v8HFfoBFsDouf8HFZIBACaAmd/o + AhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBb46hQWlhQW1BEmgJnf + 6AImmpff6AIcNuTqFCgPU2FudGFuZGVyIEdyb3VwGBMxIENvbWlzYXJpYSBMYXV0YXJvABksFQQV + BBUCABUAFQQVEgAAFo6V8v8HFfoBFtLpuf8HFZADACbuqN/oAhwVChklBgAZeAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBb46hQWhBIW4A8m7qjf6AI8Nvjq + FAAZHBUAFQAVEgAAFoiX8v8HFfoBFuLsuf8HFYIBACbOuN/oAhwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQEc2lkZRUMFvjqFBaAEhbkDybOuN/oAjw2+OoUABkcFQAVABUSAAAWgpny + /wcV+gEW5O25/wcVggEAJrLI3+gCHBUAGTUGCAAZGAloYXNfcGFydHMVDBbw6hQWktICFpYHJrLI + 3+gCPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAW/Jry/wcV7AEW5u65/wcVggEAJsjP3+gCHBUA + GTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFvDqFBaS0gIWlgcmyM/f6AI8GAEAGAEAFgAoAQAYAQAA + GRwVABUAFRIAABbonPL/BxXsARbo77n/BxWCAQAm3tbf6AIcFQIZNQYIABkYCm51bV9mbG9vcnMV + DBbw6hQWrgcWwggm3tbf6AI8GAQDAAAAGAQBAAAAFsjqFCgEAwAAABgEAQAAAAAZHBUAFQAVEgAA + FtSe8v8HFfIBFurwuf8HFdIBACag39/oAhwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3Vu + ZBUMFvDqFBbSBBb0BSag39/oAjw28OoUABkcFQAVABUSAAAWxqDy/wcV7AEWvPK5/wcVggEAJpTl + 3+gCHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW8OoUFtIEFvQFJpTl3+gCPDbw6hQAGRwVABUAFRIA + ABayovL/BxXsARa+87n/BxWCAQAmiOvf6AIcFQIZNQYIABkYCW1pbl9mbG9vchUMFvDqFBbSBBb0 + BSaI69/oAjw28OoUABkcFQAVABUSAAAWnqTy/wcV7AEWwPS5/wcVggEAJvzw3+gCHBUMGTUGCAAZ + GAxmYWNhZGVfY29sb3IVDBbw6hQW0gQW9AUm/PDf6AI8NvDqFAAZHBUAFQAVEgAAFoqm8v8HFewB + FsL1uf8HFYIBACbw9t/oAhwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwW8OoUFtIEFvQFJvD2 + 3+gCPDbw6hQAGRwVABUAFRIAABb2p/L/BxXsARbE9rn/BxWCAQAm5Pzf6AIcFQwZNQYIABkYDXJv + b2ZfbWF0ZXJpYWwVDBbw6hQW0gQW9AUm5Pzf6AI8NvDqFAAZHBUAFQAVEgAAFuKp8v8HFewBFsb3 + uf8HFYIBACbYguDoAhwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFvDqFBbSBBb0BSbYguDoAjw28OoU + ABkcFQAVABUSAAAWzqvy/wcV7AEWyPi5/wcVggEAJsyI4OgCHBUKGTUGCAAZGA5yb29mX2RpcmVj + dGlvbhUMFvDqFBbSBBb0BSbMiODoAjw28OoUABkcFQAVABUSAAAWuq3y/wcV7AEWyvm5/wcVggEA + JsCO4OgCHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW8OoUFtIEFvQFJsCO4OgCPDbw6hQA + GRwVABUAFRIAABamr/L/BxXsARbM+rn/BxWCAQAmtJTg6AIcFQwZNQYIABkYCnJvb2ZfY29sb3IV + DBbw6hQW8gQWlAYmtJTg6AI8GAcjMDAwMDAwGAcjMDAwMDAwFu7qFCgHIzAwMDAwMBgHIzAwMDAw + MAAZHBUAFQAVEgAAFpKx8v8HFewBFs77uf8HFZ4BACbImuDoAhwVChk1BggAGRgLcm9vZl9oZWln + aHQVDBbw6hQW0gQW9AUmyJrg6AI8NvDqFAAZHBUAFQAVEgAAFv6y8v8HFewBFuz8uf8HFYIBABbY + 2c0cFvDqFCaMqYPaAhaw99wOFDAAGfwmJryg4OgCHBUMGTUGCAAZGAJpZBUMFvS9Exagub0FFtKN + zwEmvKDg6AI8NgAoIDA4YmNlOWRkYjZhMDVmZmYwMjAwYjczMGFkYTAxODgwGCAwOGJjZTgzMmM4 + MDMyZmZmMDIwMGNmMDA3NjFhYzgxYwAZHBUAFQAVEAAAFuq08v8HFfIBFu79uf8HFdYIACaOrq/q + AhwVDBk1BggAGRgIZ2VvbWV0cnkVDBb0vRMWuv7aDxaI3qwJJo6ur+oCPDYAKPUHAAAAAAMAAAAH + AAAAH8BSFdUvBn3JwEMd49HMEA7AUhXVKFCBIsBDHe4Cp3otwFIV2Awwj+vAQx3uB6/3qsBSFdgI + ajHNwEMd89b80XfAUhXUtCHbHMBDHfPRHZRlwFIV1LGdnF7AQx33Dej2z8BSFdPEozKgwEMd9ww7 + d6XAUhXTwAYU7cBDHf2Ayb77wFIV0uQ+AprAQx39fxw/0sBSFdLgDESywEMeA0vk2uHAUhXRTqct + AMBDHgNJYJwiwFIV0VLY6ujAQx39LObo2MBSFc3PlqupwEMd/ScHq8bAUhXN0vGp/MBDHfgGNnrm + wFIVzCu9HSzAQx34A7I8KMBSFcwkm8C7wEMeAqrVK0DAUhXCyGcMf8BDHgKa5PM0wFIVwsoUi6jA + Qx4AWBSUDMBSFb96aVKqwEMeAFI1VvrAUhW/fBbR1MBDHf3evZAZwFIVwsyYymfAQx395JzNK8BS + FcLQyohPwEMd+BBHdeDAUhW+yCdLnsBDHfgJkXk6wFIVvsvtqbzAQx3yvfgds8BSFcKtjxnkwEMd + 8sSuGlrAUhXCtLB2VcBDHeixLuGVwFIVvrkN0yfAQx3oqnjk7sBSFb681DFFwEMd46wMYuXAUhXC + zW+J/MBDHeOywl+MwFIVzuOS4e/AQx3jx7sVFMBSFdUvBn3JwEMd49HMEA4AAAAFwFIVyeUmX+bA + Qx3w3iQNJsBSFcYYfaVHwEMd8NGO023AUhXGFSKm9MBDHfNoQgi5wFIVyeHLYZPAQx3zdNdCcsBS + FcnlJl/mwEMd8N4kDSYAAAAFwFIVyb9msr3AQx3ordPjQsBSFcYDGY/0wEMd6K3T40LAUhXGAxmP + 9MBDHez1YUCNwFIVyb9msr3AQx3s9WFAjcBSFcm/ZrK9wEMd6K3T40IAAAAFwFIV0nbFWTvAQx32 + quyoNMBSFc6psT7SwEMd9p2ArufAUhXOpy0AE8BDHfg8vR+xwFIV0nRBGn3AQx34Sv/Yk8BSFdJ2 + xVk7wEMd9qrsqDQAAAAFwFIVydZ4RznAQx34auBIq8BSFcXh9wB9wEMd+FrwEJ/AUhXF2tWkDMBD + HfzgkM7wwFIVyc9W6sjAQx3876pHZ8BSFcnWeEc5wEMd+GrgSKsAAAAFwFIVzaqtvhTAQx3qoBxq + msBSFc23QvfMwEMd5VfeDWfAUhXMh5gPVsBDHeVRKBDAwFIVzHsC1Z3AQx3qmI+uXsBSFc2qrb4U + wEMd6qAcapoAAAAFwFIVzZTeSPbAQx3wL6hkOMBSFcyBTXJ6wEMd8C+oZDjAUhXMgU1yesBDHfbH + chn5wFIVzZTeSPbAQx32x3IZ+cBSFc2U3kj2wEMd8C+oZDgYXQAAAAADAAAAAQAAAAXAUZP/vRl/ + qsBDPW2I06L8wFGT/6fI63/AQz1sI+ca8cBRlAByhjbpwEM9bAX6ovfAUZQAh9bSxsBDPW1q5ymh + wFGT/70Zf6rAQz1tiNOi/AAZHBUAFQAVJAAAFty28v8HFaAEFsSGuv8HFa4lACaWjNzzAhwVCBk1 + BggAGSgEYmJveAR4bWluFQwW9L0TFp78TRb43y8mlozc8wI8GAQFoIzCGAQDQJLCFgAoBAWgjMIY + BANAksIAGRwVABUAFRAAABb8uvL/BxXyARbyq7r/BxXWAQAmjuyL9AIcFQgZNQYIABkoBGJib3gE + eG1heBUMFvS9Exag/E0WyOEvJo7si/QCPBgE/Z+MwhgE+D+SwhYAKAT9n4zCGAT4P5LCABkcFQAV + ABUQAAAW7rzy/wcV8gEWyK26/wcV1gEAJtbNu/QCHBUIGTUGCAAZKARiYm94BHltaW4VDBb0vRMW + nvxNFujbMSbWzbv0AjwYBPSGF8IYBAWAHcIWACgE9IYXwhgEBYAdwgAZHBUAFQAVEAAAFuC+8v8H + FfIBFp6vuv8HFdYBACa+qe30AhwVCBk1BggAGSgEYmJveAR5bWF4FQwW9L0TFqD8TRaS3TEmvqnt + 9AI8GATkhhfCGAT7fx3CFgAoBOSGF8IYBPt/HcIAGRwVABUAFRAAABbSwPL/BxXyARb0sLr/BxXW + AQAmkIef9QIcFQIZNQYIBBkYB3ZlcnNpb24VDBb0vRMW/gQWoAYmkIef9QIm0Iaf9QIcGAQAAAAA + GAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWxMLy/wcV0gEWyrK6/wcV1gEA + JrCNn/UCHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW9L0TFv4FFqAH + JrCNn/UCJvCMn/UCHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWlsTy/wcV0gEWoLS6/wcV + VgAm1JWf9QIcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFvS9ExaWrwQW + iOQCJtSVn/UCJpCUn/UCHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MA + GSwVBBUEFQIAFQAVBBUQAAAW6MXy/wcV4gEW9rS6/wcV9gQAJpj4ofUCHBUMGSUGABlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFvS9Exb+l+kCFsbfiQEmmPih9QI8NgAoDHc5OTMy + ODgwOTlAMRgMMDAwMGM2MTRkZDk4ABkcFQAVABUQAAAWysfy/wcV8gEW7Lm6/wcV1gMAJuiurPYC + HBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW9L0TFtbBFBaYowYm + 6K6s9gIm3ter9gIcNgAoGDIwMjQtMTEtMjNUMTU6MjU6MTUuMDAwWhgYMjAxMS0wNi0xOVQxMjoy + NDo1OC4wMDBaABksFQQVBBUCABUAFQQVEAAAFrzJ8v8HFeQBFsK9uv8HFdYGACbSlLP2AhwVChkl + BgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW9L0TFpbhFxbe3xQm0pSz9gIm + 9vqx9gIcGAgMAiuHFtnuPxgIzczMzMzM5D8W1NIJKAgMAiuHFtnuPxgIzczMzMzM5D8AGSwVBBUE + FQIAFQAVBBUQAAAWoMvy/wcV8gEWmMS6/wcV8AIAJtTaxvYCHBUCGTUGCAAZGAVsZXZlbBUMFvS9 + Exa8BRa+BibU2sb2AjwYBAEAAAAYBP////8W4L0TKAQBAAAAGAT/////ABkcFQAVABUQAAAWks3y + /wcV1AEWiMe6/wcV1gEAJrjjxvYCHBUMGTUGCAQZGAdzdWJ0eXBlFQwW9L0TFtYkFrwhJrjjxvYC + JpLhxvYCHDa0mhMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQ + AAAW5s7y/wcV4gEW3si6/wcVsAMAJtqGx/YCHBUMGTUGCAQZGAVjbGFzcxUMFvS9ExaWJBbKICba + hsf2AibOgsf2Ahw2zpsTKAl3YXJlaG91c2UYD2FsbG90bWVudF9ob3VzZQAZLBUEFQQVAgAVABUE + FRAAABbI0PL/BxXiARaOzLr/BxXoAgAmmKPH9gIcFQoZNQYIABkYBmhlaWdodBUMFvS9ExbYExb2 + CCaYo8f2AjwYCAAAAAAAABhAGAgAAAAAAAAAQBaivBMoCAAAAAAAABhAGAgAAAAAAAAAQAAZHBUA + FQAVEAAAFqrS8v8HFdYBFvbOuv8HFbYBACaOrMf2AhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUM + FvS9ExaQcxasSyaOrMf2Ajw2mLoTKAJzcxgWM8KwIENvbXBhw7HDrWEgSGF6LU1hdAAZHBUAFQAV + EAAAFoDU8v8HFeIBFqzQuv8HFcYEACa698f2AhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3Zh + bHVlA2tleRUMFva9ExaAFBaeESa698f2Ajw27r0TKAJlcxgCZW4AGRwVABUAFRAAABbi1fL/BxXi + ARby1Lr/BxWOAQAm2IjI9gIcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUM + Fva9ExbkFxbMEybYiMj2Ajw27r0TKApTdGF0ZSBCYW5rGAxCYW5jbyBFc3RhZG8AGRwVABUAFRAA + ABbE1/L/BxXiARaA1rr/BxXyAgAmpJzI9gIcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50B3ZhcmlhbnQVDBb4vRMWpBcW5hImpJzI9gI8Nu69EygFc2hvcnQYCWFsdGVybmF0ZQAZHBUA + FQAVEAAAFqbZ8v8HFeIBFvLYuv8HFbIBACaKr8j2AhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQIbGFuZ3VhZ2UVDBb4vRMWyBYWqBImiq/I9gI8NvS9EygCZXMYAmVuABkcFQAVABUQ + AAAWiNvy/wcV4gEWpNq6/wcVfgAmssHI9gIcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50BXZhbHVlFQwW+L0TFpwYFsYTJrLByPYCPDbuvRMoElN1cGVybWVyY2FkbyBUZXNvbhgZQmFu + Y28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFurc8v8HFeIBFqLbuv8HFYgCACb41Mj2 + AhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQV + DBb4vRMWshYWmhIm+NTI9gI8Nvi9EwAZHBUAFQAVEAAAFsze8v8HFeIBFqrduv8HFXYAJpLnyPYC + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW+L0TFrAWFpwSJpLnyPYC + PDb4vRMAGRwVABUAFRAAABau4PL/BxXiARag3rr/BxV2ACau+cj2AhwVABk1BggAGRgJaGFzX3Bh + cnRzFQwW9L0TFoC8AhbgBiau+cj2AjwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFpDi8v8HFdQB + Fpbfuv8HFXYAJo6AyfYCHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFvS9ExaAvAIWsAYmjoDJ + 9gI8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABbk4/L/BxXSARaM4Lr/BxV2ACa+hsn2AhwVAhk1 + BggAGRgKbnVtX2Zsb29ycxUMFvS9ExbOQBboDCa+hsn2AjwYBAMAAAAYBAEAAAAWnrATKAQDAAAA + GAQBAAAAABkcFQAVABUQAAAWtuXy/wcV2gEWguG6/wcVxgEAJqaTyfYCHBUCGTUGCAAZGBZudW1f + Zmxvb3JzX3VuZGVyZ3JvdW5kFQwW9L0TFpAEFqAFJqaTyfYCPDb0vRMAGRwVABUAFRAAABaQ5/L/ + BxXSARbI4rr/BxV2ACbGmMn2AhwVChk1BggAGRgKbWluX2hlaWdodBUMFvS9ExaQBBagBSbGmMn2 + Ajw29L0TABkcFQAVABUQAAAW4ujy/wcV0gEWvuO6/wcVdgAm5p3J9gIcFQIZNQYIABkYCW1pbl9m + bG9vchUMFvS9ExaQBBagBSbmncn2Ajw29L0TABkcFQAVABUQAAAWtOry/wcV0gEWtOS6/wcVdgAm + hqPJ9gIcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFvS9ExayBBbCBSaGo8n2AjwYByM3Nzg4OTkY + ByM3Nzg4OTkW8r0TKAcjNzc4ODk5GAcjNzc4ODk5ABkcFQAVABUQAAAWhuzy/wcV0gEWquW6/wcV + kgEAJsioyfYCHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBb0vRMWtm4W+gkmyKjJ9gI8NpSx + EygEd29vZBgFc3RvbmUAGRwVABUAFRAAABbY7fL/BxXUARa85rr/BxWaAQAmwrLJ9gIcFQwZNQYI + ABkYDXJvb2ZfbWF0ZXJpYWwVDBb0vRMWnHsWlgomwrLJ9gI8NpSxEygKcm9vZl90aWxlcxgFbWV0 + YWwAGRwVABUAFRAAABas7/L/BxXUARbW57r/BxWyAQAm2LzJ9gIcFQwZNQYIABkYCnJvb2Zfc2hh + cGUVDBb0vRMW4AQW1AUm2LzJ9gI8GAZnYWJsZWQYBmdhYmxlZBbuvRMoBmdhYmxlZBgGZ2FibGVk + ABkcFQAVABUQAAAWgPHy/wcV1AEWiOm6/wcVjgEAJqzCyfYCHBUKGTUGCAAZGA5yb29mX2RpcmVj + dGlvbhUMFvS9ExaQBBagBSaswsn2Ajw29L0TABkcFQAVABUQAAAW1PLy/wcV0gEWluq6/wcVdgAm + zMfJ9gIcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBb0vRMWxgYW+gUmzMfJ9gI8Nta9EygF + YWxvbmcYBmFjcm9zcwAZHBUAFQAVEAAAFqb08v8HFdQBFozruv8HFaIBACbGzcn2AhwVDBk1BggA + GRgKcm9vZl9jb2xvchUMFvS9ExaQBBagBSbGzcn2Ajw29L0TABkcFQAVABUQAAAW+vXy/wcV0gEW + ruy6/wcVdgAm5tLJ9gIcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW9L0TFtQEFtIFJubSyfYCPBgI + AAAAAAAAAEAYCAAAAAAAAPA/Fu69EygIAAAAAAAAAEAYCAAAAAAAAPA/ABkcFQAVABUQAAAWzPfy + /wcV1AEWpO26/wcVlgEAFszc9BoW9L0TJryg4OgCFvy36Q0UMgAZ/CYmuNjJ9gIcFQwZNQYIABkY + AmlkFQwWpLMTFty6ugUW5tHJASa42Mn2Ajw2ACggMDhiY2U4YjViNmMzMWZmZjAyMDBmZTI1NGUz + NTEzYmIYIDA4YmIyZGIwMDAwODBmZmYwMjAwNjA0NGMzOTllNTA1ABkcFQAVABUQAAAWoPny/wcV + 8gEWuu66/wcV1ggAJp6qk/gCHBUMGTUGCAAZGAhnZW9tZXRyeRUMFqSzExbcvPsPForEwwkmnqqT + +AI8ABkcFQAVABUkAAAWkvvy/wcVoAQWkPe6/wcVriUAJqju1oEDHBUIGTUGCAAZKARiYm94BHht + aW4VDBaksxMW4NFNFoS9LCao7taBAzwYBAXYkMIYBN0/ksIWACgEBdiQwhgE3T+SwgAZHBUAFQAV + EAAAFrL/8v8HFfIBFr6cu/8HFdYBACasq4OCAxwVCBk1BggAGSgEYmJveAR4bWF4FQwWpLMTFtzR + TRaGuCwmrKuDggM8GATy15DCGATPP5LCFgAoBPLXkMIYBM8/ksIAGRwVABUAFRAAABakgfP/BxXy + ARaUnrv/BxXWAQAmsuOvggMcFQgZNQYIABkoBGJib3gEeW1pbhUMFqSzExbg0U0W3NUuJrLjr4ID + PBgEDxAVwhgEFOAXwhYAKAQPEBXCGAQU4BfCABkcFQAVABUQAAAWloPz/wcV8gEW6p+7/wcV1gEA + Jo653oIDHBUIGTUGCAAZKARiYm94BHltYXgVDBaksxMW4NFNFqjTLiaOud6CAzwYBGEPFcIYBPff + F8IWACgEYQ8VwhgE998XwgAZHBUAFQAVEAAAFoiF8/8HFfIBFsChu/8HFdYBACb2jI2DAxwVAhk1 + BggEGRgHdmVyc2lvbhUMFqSzExb+BBagBib2jI2DAya2jI2DAxwYBAAAAAAYBAAAAAAWACgEAAAA + ABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABb6hvP/BxXSARaWo7v/BxXWAQAmlpONgwMcFQwZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBaksxMW/gUWoAcmlpONgwMm1pKNgwMc + GAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABbMiPP/BxXSARbspLv/BxVWACa6m42DAxwVDBkl + BgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWpLMTFprdBBbg/QImupuNgwMm9pmN + gwMcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUE + FRAAABaeivP/BxXiARbCpbv/BxX2BAAm1peQgwMcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQJcmVjb3JkX2lkFQwWpLMTFs6g2QIW4vSMASbWl5CDAzw2ACgMdzk5MjIwNjgzM0AyGAwwMDAw + NTQ4NTYzMTgAGRwVABUAFRAAABaAjPP/BxXyARa4qrv/BxXWAwAm+OidhAMcFQwZJQYEGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBaksxMWlrQYFtj1Bib46J2EAya4jJ2EAxw2 + ACgYMjAyNC0xMS0yOVQxOTozODoyMS4wMDBaGBgyMDEwLTEyLTI0VDA0OjI0OjE0LjAwMFoAGSwV + BBUEFQIAFQAVBBUQAAAW8o3z/wcV5AEWjq67/wcV1gYAJvaapYQDHBUKGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBaksxMW+PQTFuDGECb2mqWEAyaQgqSEAxwYCDeJQWDl + 0O4/GAjNzMzMzMzkPxbEuwwoCDeJQWDl0O4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABbW + j/P/BxXyARbktLv/BxX2AgAm8Mi0hAMcFQIZNQYIABkYBWxldmVsFQwWpLMTFtYFFtYGJvDItIQD + PBgEAgAAABgE/////xaMsxMoBAIAAAAYBP////8AGRwVABUAFRAAABbIkfP/BxXUARbat7v/BxXG + AQAm7tG0hAMcFQwZNQYIBBkYB3N1YnR5cGUVDBaksxMWlBwWghom7tG0hAMmxs+0hAMcNsqoEygO + dHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABack/P/BxXiARag + ubv/BxXkAwAm4Oy0hAMcFQwZNQYIBBkYBWNsYXNzFQwWpLMTFtoZFr4XJuDstIQDJsjptIQDHDbE + qRMoDnRyYW5zcG9ydGF0aW9uGAZjaGFwZWwAGSwVBBUEFQIAFQAVBBUQAAAW/pTz/wcV4gEWhL27 + /wcVjAMAJoaBtYQDHBUKGTUGCAAZGAZoZWlnaHQVDBaksxMWzAYWygYmhoG1hAM8GAgAAAAAAABM + QBgIAAAAAAAAJEAWhLMTKAgAAAAAAABMQBgIAAAAAAAAJEAAGRwVABUAFRAAABbglvP/BxXWARaQ + wLv/BxW2AQAm0Ie1hAMcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaksxMW2nUW+kcm0Ie1hAM8 + NoivEygmw4FyZWEgZGUgQWxtYWNlbmFtaWVudG8gZGUgQ29tYnVzdGlibGUYFTHCsCBKdXpnYWRv + IGRlIExldHJhcwAZHBUAFQAVEAAAFraY8/8HFeIBFsbBu/8HFZoFACbKz7WEAxwVDBklBgAZSAVu + YW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFqazExaaFBagESbKz7WEAzw2nrMTKAJlcxgCZW4A + GRwVABUAFRAAABaYmvP/BxXiARbgxrv/BxWGAQAm6uC1hAMcFQwZJQYAGUgFbmFtZXMGY29tbW9u + CWtleV92YWx1ZQV2YWx1ZRUMFqazExbSFxayEibq4LWEAzw2nrMTKApTdGF0ZSBCYW5rGAxCYW5j + byBFc3RhZG8AGRwVABUAFRAAABb6m/P/BxXiARbmx7v/BxXEAQAmnPO1hAMcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBassxMWrBoW2hMmnPO1hAM8NoazEygFc2hv + cnQYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFtyd8/8HFeIBFqrJu/8HFZwCACb2hraEAxwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBassxMWkBcWhhIm9oa2hAM8Nqiz + EygCZXMYAmVuABkcFQAVABUQAAAWvp/z/wcV4gEWxsu7/wcVfgAm/Ji2hAMcFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWrLMTFsAeFqYXJvyYtoQDPDaGsxMoB1RHMjtU + RzMYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRAAABagofP/BxXiARbEzLv/BxXm + BQAmorC2hAMcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdl + bGVtZW50FQwWrLMTFv4WFvYRJqKwtoQDPDassxMAGRwVABUAFRAAABaCo/P/BxXiARaq0rv/BxV2 + ACaYwraEAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFqyzExb4Fhbu + ESaYwraEAzw2rLMTABkcFQAVABUQAAAW5KTz/wcV4gEWoNO7/wcVdgAmhtS2hAMcFQAZNQYIABkY + CWhhc19wYXJ0cxUMFqSzExbWugIWxAYmhtS2hAM8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABbG + pvP/BxXSARaW1Lv/BxV2ACbK2raEAxwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaksxMW1roC + FrAGJsratoQDPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWmKjz/wcV0gEWjNW7/wcVdgAm0uG2 + hAMcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBaksxMW5gYWiAgm0uG2hAMm+uC2hAMcGAQFAAAAGAQB + AAAAFtiyEygEBQAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbqqfP/BxXWARaC1rv/BxX2AQAm + gum2hAMcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaksxMWkAQWoAUmgum2hAM8 + NqSzEwAZHBUAFQAVEAAAFsCr8/8HFdIBFvjXu/8HFXYAJqLutoQDHBUKGTUGCAAZGAptaW5faGVp + Z2h0FQwWpLMTFpAEFqAFJqLutoQDPDaksxMAGRwVABUAFRAAABaSrfP/BxXSARbu2Lv/BxV2ACbC + 87aEAxwVAhk1BggAGRgJbWluX2Zsb29yFQwWpLMTFpAEFqAFJsLztoQDPDaksxMAGRwVABUAFRAA + ABbkrvP/BxXSARbk2bv/BxV2ACbi+LaEAxwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWpLMTFswG + FpYGJuL4toQDPDaKsxMoByNGRkZGRkYYByMwMDgwMDAAGRwVABUAFRAAABa2sPP/BxXUARba2rv/ + BxWSAQAm+P62hAMcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFqSzExayBhb6BSb4/raEAzw2 + iLMTKAVtZXRhbBgFZ2xhc3MAGRwVABUAFRAAABaKsvP/BxXUARbs27v/BxWKAQAm8oS3hAMcFQwZ + NQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaksxMWsgYW6AUm8oS3hAM8GAVtZXRhbBgFbWV0YWwWiLMT + KAVtZXRhbBgFbWV0YWwAGRwVABUAFRAAABbes/P/BxXUARb23Lv/BxWKAQAm2oq3hAMcFQwZNQYI + ABkYCnJvb2Zfc2hhcGUVDBaksxMWzgYW2gYm2oq3hAM8NoizEygIc2tpbGxpb24YBGZsYXQAGRwV + ABUAFRAAABaytfP/BxXUARaA3rv/BxWmAQAmtJG3hAMcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9u + FQwWpLMTFpAEFqAFJrSRt4QDPDaksxMAGRwVABUAFRAAABaGt/P/BxXSARam37v/BxV2ACbUlreE + AxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFqSzExbgBRaGBibUlreEAzw2krMTKAVhbG9u + ZxgGYWNyb3NzABkcFQAVABUQAAAW2Ljz/wcV1AEWnOC7/wcVjAEAJtqct4QDHBUMGTUGCAAZGApy + b29mX2NvbG9yFQwWpLMTFswGFpwGJtqct4QDPDaKsxMoByNGRkZGRkYYByMwMDgwMDAAGRwVABUA + FRAAABasuvP/BxXUARao4bv/BxWSAQAm9qK3hAMcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWpLMT + FpAFFuYFJvait4QDPBgIAAAAAAAAHEAYCAAAAAAAAAhAFpizEygIAAAAAAAAHEAYCAAAAAAAAAhA + ABkcFQAVABUQAAAWgLzz/wcV1AEWuuK7/wcVlgEAFvqJ/xoWpLMTJrjYyfYCFqTQ7Q0UNAAZ/CYm + 3Ki3hAMcFQwZNQYIABkYAmlkFQwW/I8TFsDDsAUWtsfGASbcqLeEAzw2ACggMDhiY2U5OWJhYjZj + ZWZmZjAyMDA5YjQyMjMzZDBiZDAYIDA4YmIyZGIwMGM4NmFmZmYwMjAwOTU2NGVjNjhiODVmABkc + FQAVABUQAAAW1L3z/wcV8gEW0OO7/wcV1ggAJpLw/YUDHBUMGTUGCAAZGAhnZW9tZXRyeRUMFvyP + ExbIgJsQFv6D5gkmkvD9hQM8NgAouQQAAAAAAwAAAAQAAAATwFIXZOcKZbXAQr0LVMfYccBSF2Uo + 5CTYwEK9Fati77nAUhdjWQBMVsBCvRXH6GF+wFIXY1YQrc3AQr0VWS2Yv8BSF2H3AHz+wEK9FW79 + Dd3AUhdh+lt7UcBCvRX9mEazwFIXYPV4vYHAQr0WDl8+VMBSF2D5qntpwEK9Frb7qjDAUhddcIj/ + GMBCvRbvL84kwFIXXXZoPCnAQr0XzKVfoMBSF1s/wbbvwEK9F+/gzgzAUhdbOySZPMBCvRc2fWqP + wFIXWOeNQnPAQr0XW2ZYJMBSF1jQEE4swEK9E61b7j3AUhdaDScv8MBCvROaELfewFIXWcwkMGHA + Qr0JVsDW9cBSF2EMHvI0wEK9COL9kLrAUhdhHOXp1MBCvQuRLbpNwFIXZOcKZbXAQr0LVMfYcQAA + AAXAUhdfuaP7HMBCvQ27qmWawFIXXt3b6MrAQr0NyRZe58BSF18Dm5XzwEK9E9+w1SDAUhdf32Oo + RsBCvRPSRNvSwFIXX7mj+xzAQr0Nu6plmgAAAAXAUhdc6/7BPMBCvQ4iAbKIwFIXXE1zUFrAQr0O + JwowBcBSF1xepafFwEK9EvCdjG3AUhdc/MW43MBCvRLrlQ7wwFIXXOv+wTzAQr0OIgGyiAAAAAXA + UhdinYQJ5cBCvQ1lQ1C4wFIXYdDVcAnAQr0NdFzJL8BSF2H1Uv3UwEK9Ej7G5SzAUhdiwgGXsMBC + vRIvrWy1wFIXYp2ECeXAQr0NZUNQuBhNAAAAAAMAAAABAAAABMBR/ouKTJ4rwELY3FxBi7zAUf6M + PunKNsBC2NtBIm86wFH+jMbzdHTAQtjeWnW008BR/ouKTJ4rwELY3FxBi7wAGRwVABUAFSQAABbG + v/P/BxWgBBam7Lv/BxWuJQAmkPTjjwMcFQgZNQYIABkoBGJib3gEeG1pbhUMFvyPExbAxEwW3ocq + JpD0448DPBgEB3CPwhgEATKRwhYAKAQHcI/CGAQBMpHCABkcFQAVABUQAAAW5sPz/wcV8gEW1JG8 + /wcV1gEAJu77jZADHBUIGTUGCAAZKARiYm94BHhtYXgVDBb8jxMWwMRMFr6NKibu+42QAzwYBP9v + j8IYBPkxkcIWACgE/2+PwhgE+TGRwgAZHBUAFQAVEAAAFtjF8/8HFfIBFqqTvP8HFdYBACasibiQ + AxwVCBk1BggAGSgEYmJveAR5bWluFQwW/I8TFsDETBaSgi0mrIm4kAM8GAQLEBXCGAQV4BfCFgAo + BAsQFcIYBBXgF8IAGRwVABUAFRAAABbKx/P/BxXyARaAlbz/BxXWAQAmvovlkAMcFQgZNQYIABko + BGJib3gEeW1heBUMFvyPExa+xEwWzPosJr6L5ZADPBgE+g8VwhgE898XwhYAKAT6DxXCGATz3xfC + ABkcFQAVABUQAAAWvMnz/wcV8gEW1pa8/wcV1gEAJsqGkpEDHBUCGTUGCAQZGAd2ZXJzaW9uFQwW + /I8TFv4EFqAGJsqGkpEDJoqGkpEDHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUC + ABUAFQQVEAAAFq7L8/8HFdIBFqyYvP8HFdYBACbqjJKRAxwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAhwcm9wZXJ0eRUMFvyPExb+BRagBybqjJKRAyaqjJKRAxwYABgAFgAoABgAABksFQQV + BBUCABUAFQQVEAAAFoDN8/8HFdIBFoKavP8HFVYAJo6VkpEDHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50B2RhdGFzZXQVDBb8jxMW5sIEFrboAiaOlZKRAybKk5KRAxw2ACgNT3BlblN0cmVl + dE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFtLO8/8HFeIBFtia + vP8HFfYEACaA/JSRAxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBb8 + jxMWqqTNAhb40okBJoD8lJEDPDYAKAx3OTg0MTU2OTY5QDEYDDAwMDA0MDc0MjQ0ZAAZHBUAFQAV + EAAAFrTQ8/8HFfIBFs6fvP8HFdYDACa+2J+SAxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAt1cGRhdGVfdGltZRUMFvyPExb+iBwWqpIIJr7Yn5IDJvjOnpIDHDYAKBgyMDI0LTExLTE1VDE3 + OjU2OjI5LjAwMFoYGDIwMTAtMTItMjlUMjI6MjU6MDMuMDAwWgAZLBUEFQQVAgAVABUEFRAAABam + 0vP/BxXmARako7z/BxXWBgAmovmnkgMcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29u + ZmlkZW5jZRUMFvyPExawkhEW0N4NJqL5p5IDJqLhppIDHBgILpCg+DHm7j8YCM3MzMzMzOQ/FpjY + DSgILpCg+DHm7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFozU8/8HFfABFvqpvP8HFfYC + ACbyv7SSAxwVAhk1BggAGRgFbGV2ZWwVDBb8jxMW1gUW0gYm8r+0kgM8GAQBAAAAGAT/////FuSP + EygEAQAAABgE/////wAZHBUAFQAVEAAAFvzV8/8HFdQBFvCsvP8HFbYBACbsyLSSAxwVDBk1BggE + GRgHc3VidHlwZRUMFvyPExaSGhaSGSbsyLSSAybExrSSAxw2woETKA50cmFuc3BvcnRhdGlvbhgM + YWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFtDX8/8HFeIBFqauvP8HFcgDACb44rSSAxwV + DBk1BggEGRgFY2xhc3MVDBb8jxMW8BoWsBkm+OK0kgMm1t+0kgMcNoKCEygJd2FyZWhvdXNlGAph + cGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFrLZ8/8HFeIBFu6xvP8HFfoCACaG+bSSAxwVChk1 + BggAGRgGaGVpZ2h0FQwW/I8TFqgEFrgFJob5tJIDPBgIAAAAAAAACEAYCAAAAAAAAAhAFvqPEygI + AAAAAAAACEAYCAAAAAAAAAhAABkcFQAVABUQAAAWlNvz/wcV0gEW6LS8/wcVlgEAJoKctZIDHBUM + GTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwW/I8TFuBGFootJoKctZIDJr7+tJIDHDbMjRMoBsOabmlj + bxgJQWJhc3RpYmxlABksFQQVBBUCABUAFQQVEAAAFubc8/8HFeABFv61vP8HFcgEACbIq7WSAxwV + DBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFvyPExaaDhbQDSbIq7WSAzwYAmVz + GAJlcxb6jxMoAmVzGAJlcwAZHBUAFQAVEAAAFsbe8/8HFeABFsa6vP8HFX4AJpi5tZIDHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBb8jxMWiBAW+A0mmLm1kgM8GAdVbmlt + YXJjGAdVbmltYXJjFvqPEygHVW5pbWFyYxgHVW5pbWFyYwAZHBUAFQAVEAAAFqbg8/8HFeIBFsS7 + vP8HFZIBACaQx7WSAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUM + FoCQExa0ERbqDiaQx7WSAzw28o8TKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAWiOLz + /wcV4gEW1ry8/wcVugEAJvrVtZIDHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhs + YW5ndWFnZRUMFoCQExaIEBaADib61bWSAzw2gJATABkcFQAVABUQAAAW6uPz/wcV4gEWkL68/wcV + dgAm+uO1kgMcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWgJATFswT + FpIQJvrjtZIDPDbyjxMoD1NhbnRhbmRlciBHcm91cBgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGls + ZQAZHBUAFQAVEAAAFszl8/8HFeIBFoa/vP8HFdYCACaM9LWSAxwVChklBgAZeAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBaAkBMWjBAWgg4mjPS1kgM8NoCQ + EwAZHBUAFQAVEAAAFq7n8/8HFeIBFtzBvP8HFXYAJo6CtpIDHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudARzaWRlFQwWgJATFogQFoAOJo6CtpIDPDaAkBMAGRwVABUAFRAAABaQ6fP/ + BxXiARbSwrz/BxV2ACaOkLaSAxwVABk1BggAGRgJaGFzX3BhcnRzFQwW/I8TFqC2AhawBiaOkLaS + AzwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFvLq8/8HFdIBFsjDvP8HFXYAJr6WtpIDHBUAGTUG + CAAZGA5pc191bmRlcmdyb3VuZBUMFvyPExagtgIWugYmvpa2kgM8GAEBGAEAFgAoAQEYAQAAGRwV + ABUAFRAAABbE7PP/BxXSARa+xLz/BxV2ACb4nLaSAxwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFvyP + Exa0BxbmBib4nLaSAzwYBBIAAAAYBAEAAAAWso8TKAQSAAAAGAQBAAAAABkcFQAVABUQAAAWlu7z + /wcV1gEWtMW8/wcVpgEAJt6jtpIDHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW + /I8TFo4EFp4FJt6jtpIDPDb8jxMAGRwVABUAFRAAABbs7/P/BxXSARbaxrz/BxV2ACb8qLaSAxwV + Chk1BggAGRgKbWluX2hlaWdodBUMFvyPExaOBBaeBSb8qLaSAzw2/I8TABkcFQAVABUQAAAWvvHz + /wcV0gEW0Me8/wcVdgAmmq62kgMcFQIZNQYIABkYCW1pbl9mbG9vchUMFvyPExaOBBaeBSaarraS + Azw2/I8TABkcFQAVABUQAAAWkPPz/wcV0gEWxsi8/wcVdgAmuLO2kgMcFQwZNQYIABkYDGZhY2Fk + ZV9jb2xvchUMFvyPExaOBBaeBSa4s7aSAzw2/I8TABkcFQAVABUQAAAW4vTz/wcV0gEWvMm8/wcV + dgAm1ri2kgMcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFvyPExaOBBaeBSbWuLaSAzw2/I8T + ABkcFQAVABUQAAAWtPbz/wcV0gEWssq8/wcVdgAm9L22kgMcFQwZNQYIABkYDXJvb2ZfbWF0ZXJp + YWwVDBb8jxMWjgQWngUm9L22kgM8NvyPEwAZHBUAFQAVEAAAFob48/8HFdIBFqjLvP8HFXYAJpLD + tpIDHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW/I8TFo4EFp4FJpLDtpIDPDb8jxMAGRwVABUAFRAA + ABbY+fP/BxXSARaezLz/BxV2ACawyLaSAxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBb8jxMW + jgQWngUmsMi2kgM8NvyPEwAZHBUAFQAVEAAAFqr78/8HFdIBFpTNvP8HFXYAJs7NtpIDHBUMGTUG + CAAZGBByb29mX29yaWVudGF0aW9uFQwW/I8TFo4EFp4FJs7NtpIDPDb8jxMAGRwVABUAFRAAABb8 + /PP/BxXSARaKzrz/BxV2ACbs0raSAxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFvyPExaOBBaeBSbs + 0raSAzw2/I8TABkcFQAVABUQAAAWzv7z/wcV0gEWgM+8/wcVdgAmiti2kgMcFQoZNQYIABkYC3Jv + b2ZfaGVpZ2h0FQwW/I8TFo4EFp4FJorYtpIDPDb8jxMAGRwVABUAFRAAABaggPT/BxXSARb2z7z/ + BxV2ABbs/YMbFvyPEybcqLeEAxbMtP8NFDYAGfwmJqjdtpIDHBUMGTUGCAAZGAJpZBUMFpC9ExaQ + nb0FFpzAygEmqN22kgM8NgAoIDA4YmNlOTkzYWU3OGJmZmYwMjAwYzEyNGNhYWJmM2U2GCAwOGJi + MmQ5NjgzNmQ4ZmZmMDIwMDcyOTMzYjZkZTk3OQAZHBUAFQAVEAAAFvKB9P8HFfIBFuzQvP8HFdYI + ACbEnYGUAxwVDBk1BggAGRgIZ2VvbWV0cnkVDBaQvRMW3ubyDxbG574JJsSdgZQDPDYAKLkDAAAA + AAMAAAAEAAAAC8BSI6js87PBwEKMRQdxDYnAUiOzORJwRcBCjEcI0w1ZwFIjsmxj1mnAQoxRgPwT + 4sBSI7dPIaZDwEKMUnRBGn3AUiO2t7eR0sBCjFowzf4lwFIjtO1HlpjAQoxZ1+KqhcBSI7RjtNs+ + wEKMYOAUqC7AUiOoQWepXcBCjF6DQxX/wFIjqL2Oa2jAQoxYLOe/l8BSI6d7A6xdwEKMV+39nv3A + UiOo7POzwcBCjEUHcQ2JAAAABcBSI7Gza9K3wEKMUfxMFlnAUiOtPpIMB8BCjFD+H1UwwFIjrSXS + +GDAQoxSGNGIHcBSI7GarL8QwEKMUxfVCNvAUiOxs2vSt8BCjFH8TBZZAAAABcBSI7EE8CnJwEKM + S4vvjOvAUiOtNIERDcBCjEq75fS8wFIjrSJ3+g3AQoxLj0qLP8BSI7DzUnKUwEKMTGAq4wPAUiOx + BPApycBCjEuL74zrAAAABcBSI6yDFcmWwEKMSRr8BMnAUiOrs+Lw/MBCjEjuhlr4wFIjqoSjaE/A + QoxW5BJjsMBSI6tUQaC0wEKMVxFezRXAUiOsgxXJlsBCjEka/ATJGE0AAAAAAwAAAAEAAAAEwFI7 + uBmuR+/AQnyGAZ5HdcBSO7g2pQjTwEJ8hO6cks3AUju4mhAQycBCfIYkb+BswFI7uBmuR+/AQnyG + AZ5HdQAZHBUAFQAVJAAAFuSD9P8HFaAEFsLZvP8HFa4lACaKhcCdAxwVCBk1BggAGSgEYmJveAR4 + bWluFQwWkL0TFpD5TRb4siwmioXAnQM8GAQEcI/CGAQKQJLCFgAoBARwj8IYBApAksIAGRwVABUA + FRAAABaEiPT/BxXyARbw/rz/BxXWAQAmgrjsnQMcFQgZNQYIABkoBGJib3gEeG1heBUMFpC9ExaQ + +U0WvqwsJoK47J0DPBgE/W+PwhgE+j+SwhYAKAT9b4/CGAT6P5LCABkcFQAVABUQAAAW9on0/wcV + 8gEWxoC9/wcV1gEAJsDkmJ4DHBUIGTUGCAAZKARiYm94BHltaW4VDBaQvRMWkPlNFpaPLybA5Jie + AzwYBAmoE8IYBAh4FsIWACgECagTwhgECHgWwgAZHBUAFQAVEAAAFuiL9P8HFfIBFpyCvf8HFdYB + ACbW88eeAxwVCBk1BggAGSgEYmJveAR5bWF4FQwWkL0TFpD5TRaQky8m1vPHngM8GATxpxPCGATz + dxbCFgAoBPGnE8IYBPN3FsIAGRwVABUAFRAAABbajfT/BxXyARbyg73/BxXWAQAmpof3ngMcFQIZ + NQYIBBkYB3ZlcnNpb24VDBaQvRMW/gQWoAYmpof3ngMm5ob3ngMcGAQAAAAAGAQAAAAAFgAoBAAA + AAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWzI/0/wcV0gEWyIW9/wcV1gEAJsaN954DHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWkL0TFv4FFqAHJsaN954DJoaN954D + HBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWnpH0/wcV0gEWnoe9/wcVVgAm6pX3ngMcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFpC9ExbK6wQW2ucCJuqV954DJqaU + 954DHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAV + BBUQAAAW8JL0/wcV4gEW9Ie9/wcV9gQAJoD8+Z4DHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVt + ZW50CXJlY29yZF9pZBUMFpC9ExaauNkCFpiWkAEmgPz5ngM8NgAoDHc5OTExOTgxOTFANBgMMDAw + MDFmODliZTQxABkcFQAVABUQAAAW0pT0/wcV8gEW6oy9/wcV1gMAJry/iqADHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWkL0TFpDHEhb4jwUmvL+KoAMmmJKKoAMc + NgAoGDIwMjQtMTEtMDNUMDY6MTg6MDcuMDAwWhgYMjAxMS0wNC0yNlQwMTowNjozMC4wMDBaABks + FQQVBBUCABUAFQQVEAAAFsSW9P8HFeIBFsCQvf8HFdYGACa+upCgAxwVChklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWkL0TFtThExaIsRAmvrqQoAMmkKKPoAMcGAj0bFZ9 + rrbuPxgIzczMzMzM5D8W5OAMKAj0bFZ9rrbuPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW + ppj0/wcV8gEWlpe9/wcV9gIAJpjTn6ADHBUCGTUGCAAZGAVsZXZlbBUMFpC9ExbgBBbqBSaY05+g + AzwYBAEAAAAYBAEAAAAWhr0TKAQBAAAAGAQBAAAAABkcFQAVABUQAAAWmJr0/wcV0gEWjJq9/wcV + lgEAJqjbn6ADHBUMGTUGCAQZGAdzdWJ0eXBlFQwWkL0TFtofFqIcJqjbn6ADJoLZn6ADHDbGphMo + DnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW6pv0/wcV4gEW + opu9/wcVzgMAJtD4n6ADHBUMGTUGCAQZGAVjbGFzcxUMFpC9Exb2IRaIHibQ+J+gAyak9Z+gAxw2 + /KYTKA10cmFpbl9zdGF0aW9uGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFsyd9P8HFeIB + FvCevf8HFa4DACask6CgAxwVChk1BggAGRgGaGVpZ2h0FQwWkL0TFqoEFroFJqyToKADPBgIAAAA + AAAAGEAYCAAAAAAAABhAFo69EygIAAAAAAAAGEAYCAAAAAAAABhAABkcFQAVABUQAAAWrp/0/wcV + 0gEWnqK9/wcVlgEAJuaYoKADHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWkL0TFu4qFvIgJuaY + oKADPDbquxMoD3NlZGUgRWwgUXVpbGxheRgHQWN1ZW50YQAZHBUAFQAVEAAAFoCh9P8HFeABFrSj + vf8HFcgEACbYuaCgAxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFpK9Exb8 + Cxb8CybYuaCgAzw2jr0TKAJlcxgCZW4AGRwVABUAFRAAABbgovT/BxXeARb8p73/BxV+ACbUxaCg + AxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWkr0TFq4NFqwMJtTFoKAD + PDaOvRMoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFr6k9P8HFd4BFvqovf8H + FaIBACaA0qCgAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFp69 + Exa8EBakDiaA0qCgAzw2/rwTKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAWnKb0/wcV + 3gEWnKq9/wcV/gEAJqTgoKADHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5n + dWFnZRUMFp69ExbEDRbiDCak4KCgAzw2mr0TKAJlcxgCZW4AGRwVABUAFRAAABb6p/T/BxXeARaa + rL3/BxV+ACaG7aCgAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBae + vRMWgBUWzBAmhu2goAM8Nv68EygoU2VydmljaW8gZGUgVXJnZW5jaWEgZGUgQWx0YSBSZXNvbHVj + acOzbhgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEAAAFtip9P8HFd4BFpitvf8H + FYAEACbS/aCgAxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0 + B2VsZW1lbnQVDBaevRMWuA0W4Awm0v2goAM8Np69EwAZHBUAFQAVEAAAFrar9P8HFd4BFpixvf8H + FXYAJrKKoaADHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWnr0TFqwN + Fs4MJrKKoaADPDaevRMAGRwVABUAFRAAABaUrfT/BxXeARaOsr3/BxV2ACaAl6GgAxwVABk1BggA + GRgJaGFzX3BhcnRzFQwWkL0TFvK7Aha6BiaAl6GgAzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAA + FvKu9P8HFdIBFoSzvf8HFXYAJrqdoaADHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFpC9Exby + uwIWsAYmup2hoAM8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABbEsPT/BxXSARb6s73/BxV2ACbq + o6GgAxwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFpC9ExbSJhb2Cybqo6GgAzwYBBMAAAAYBAEAAAAW + 7LUTKAQTAAAAGAQBAAAAABkcFQAVABUQAAAWlrL0/wcV2AEW8LS9/wcVxgEAJuCvoaADHBUCGTUG + CAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWkL0TFpAEFqAFJuCvoaADPDaQvRMAGRwVABUA + FRAAABbus/T/BxXSARa2tr3/BxV2ACaAtaGgAxwVChk1BggAGRgKbWluX2hlaWdodBUMFpC9ExaQ + BBagBSaAtaGgAzw2kL0TABkcFQAVABUQAAAWwLX0/wcV0gEWrLe9/wcVdgAmoLqhoAMcFQIZNQYI + ABkYCW1pbl9mbG9vchUMFpC9ExaQBBagBSaguqGgAzw2kL0TABkcFQAVABUQAAAWkrf0/wcV0gEW + ori9/wcVdgAmwL+hoAMcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFpC9ExaQBBagBSbAv6GgAzw2 + kL0TABkcFQAVABUQAAAW5Lj0/wcV0gEWmLm9/wcVdgAm4MShoAMcFQwZNQYIABkYD2ZhY2FkZV9t + YXRlcmlhbBUMFpC9ExaQBBagBSbgxKGgAzw2kL0TABkcFQAVABUQAAAWtrr0/wcV0gEWjrq9/wcV + dgAmgMqhoAMcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaQvRMWkAQWoAUmgMqhoAM8NpC9EwAZ + HBUAFQAVEAAAFoi89P8HFdIBFoS7vf8HFXYAJqDPoaADHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW + kL0TFpAEFqAFJqDPoaADPDaQvRMAGRwVABUAFRAAABbavfT/BxXSARb6u73/BxV2ACbA1KGgAxwV + Chk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaQvRMWkAQWoAUmwNShoAM8NpC9EwAZHBUAFQAVEAAA + Fqy/9P8HFdIBFvC8vf8HFXYAJuDZoaADHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWkL0T + FpAEFqAFJuDZoaADPDaQvRMAGRwVABUAFRAAABb+wPT/BxXSARbmvb3/BxV2ACaA36GgAxwVDBk1 + BggAGRgKcm9vZl9jb2xvchUMFpC9ExaQBBagBSaA36GgAzw2kL0TABkcFQAVABUQAAAW0ML0/wcV + 0gEW3L69/wcVdgAmoOShoAMcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWkL0TFpAEFqAFJqDkoaAD + PDaQvRMAGRwVABUAFRAAABaixPT/BxXSARbSv73/BxV2ABau6PMaFpC9Eyao3baSAxaYjOsNFDgA + GfwmJsDpoaADHBUMGTUGCAAZGAJpZBUMFrCMExaQwq8FFrrAvwEmwOmhoAM8NgAoIDA4YmIyZGJk + NzRkYWVmZmYwMjAwZjUzMjU4ZjE3MjUyGCAwOGJiMmQ4NjgwMDIxZmZmMDIwMDE4MjczNDcxZjBm + NwAZHBUAFQAVEAAAFvTF9P8HFfIBFsjAvf8HFdYIACb6qeGhAxwVDBk1BggAGRgIZ2VvbWV0cnkV + DBawjBMWrr/iEBbG7ZIKJvqp4aEDPDYAKI0GAAAAAAMAAAAFAAAAG8BSRofUdTe7wEJgD7L7am/A + UkaIv1bChMBCYBO4Q6jMwFJGhwJSwJfAQmAUvSZmnMBSRoc4AqXNwEJgFam1cJDAUkaHrd7K/MBC + YBVk7BLjwFJGh+kCjXnAQmAWaCFRicBSRohkve+6wEJgFh8mNfXAUkaI3svS0sBCYBg2V6riwFJG + iDizpbTAQmAYl6Z6U8BSRoh5tqVDwEJgGbQGLGrAUkaJIr5w6cBCYBlRCd3PwFJGicSk4B/AQmAc + GGR61MBSRokZhDWEwEJgHHw3iQPAUkaJQwpAzMBCYB0yP+4twFJGifGF6bnAQmAcy+ihP8BSRoqg + AZKnwEJgH8gcY+TAUkaKBhM/eMBCYCAitTauwFJGiiXzr5DAQmAgrEfyB8BSRorUb1h9wEJgIEXw + pRnAUkaLigxd3MBCYCNhLhhBwFJGiNtw1H7AQmAk89VPUsBSRomaSBVDwEJgKDdWrmLAUkaF/kbC + XMBCYCpUZ2BhwFJGhWUvLsLAQmAntVCvRcBSRoTgpPDmwEJgKANUSFfAUkaAVZBVTcBCYBQWN3nq + wFJGh9R1N7vAQmAPsvtqbwAAAAXAUkaGVRk3CcBCYBSyPqwNwFJGg9V3ljrAQmAWGUb448BSRoQr + B+uHwEJgF59Y9jvAUkaGqj4si8BCYBY4UKlmwFJGhlUZNwnAQmAUsj6sDQAAAAXAUkaHN5dGAsBC + YBlAQuYvwFJGg9LzV3vAQmAbKv6xS8BSRoQLkts5wEJgHCuvsTPAUkaHcDbJwcBCYBpA8+YWwFJG + hzeXRgLAQmAZQELmLwAAAAXAUkaIIg1xAsBCYBzCrmXZwFJGhL1pgnvAQmAerWow9sBSRoT2CQY5 + wEJgH64bMN7AUkaIWqz0wMBCYB3DX2XBwFJGiCINcQLAQmAcwq5l2QAAAAXAUkaJDjEbK8BCYCB+ + +4iiwFJGhamNLKTAQmAiabdTv8BSRoXiLLBiwEJgI2mRlBLAUkaJRtCe6cBCYCF+1cj1wFJGiQ4x + GyvAQmAgfvuIohhNAAAAAAMAAAABAAAABMBSQmUjWEnVwEJnZlmJtU3AUkJk7kefScBCZ2d7pBm1 + wFJCZHph+bfAQmdnRM+bR8BSQmUjWEnVwEJnZlmJtU0AGRwVABUAFSYAABbmx/T/BxW+BBaeyb3/ + BxW2JwAm8tj+qwMcFQgZNQYIBBkoBGJib3gEeG1pbhUMFrCMExbuoDIWpowuJvLY/qsDJsCX9KsD + HBgEB9iQwhgEJkCSwhYAKAQH2JDCGAQmQJLCABksFQQVBBUCABUAFQQVEAAAFqTM9P8HFfIBFtTw + vf8HFdYBACbM4qysAxwVCBk1BggEGSgEYmJveAR4bWF4FQwWsIwTFrSdMhbYiS4mzOKsrAMm5qOi + rAMcGATv15DCGAT8P5LCFgAoBO/XkMIYBPw/ksIAGSwVBBUEFQIAFQAVBBUQAAAWls70/wcV8gEW + qvK9/wcV1gEAJr6t0KwDHBUIGTUGCAAZKARiYm94BHltaW4VDBawjBMWkLZMFsLSKCa+rdCsAzwY + BAf0EsIYBA1cFMIWACgEB/QSwhgEDVwUwgAZHBUAFQAVEAAAFojQ9P8HFfIBFoD0vf8HFdYBACaA + gPmsAxwVCBk1BggAGSgEYmJveAR5bWF4FQwWsIwTFpC2TBaUyygmgID5rAM8GASu8xLCGATxWxTC + FgAoBK7zEsIYBPFbFMIAGRwVABUAFRAAABb60fT/BxXyARbW9b3/BxXWAQAm1MuhrQMcFQIZNQYI + BBkYB3ZlcnNpb24VDBawjBMW/gQWoAYm1MuhrQMmlMuhrQMcGAQAAAAAGAQAAAAAFgAoBAAAAAAY + BAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW7NP0/wcV0gEWrPe9/wcV1gEAJvTRoa0DHBUMGSUGBBlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWsIwTFv4FFqAHJvTRoa0DJrTRoa0DHBgA + GAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWvtX0/wcV0gEWgvm9/wcVVgAmmNqhrQMcFQwZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFrCMExao2gQW0vkCJpjaoa0DJtTYoa0D + HDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQ + AAAWkNf0/wcV4gEW2Pm9/wcV9gQAJqbSpK0DHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CXJlY29yZF9pZBUMFrCMExbsuM0CFsC+hwEmptKkrQM8NgAoDHc5ODM3OTczOTdAMRgMMDAwMGM5 + NjMyMTUyABkcFQAVABUQAAAW8tj0/wcV8gEWzv69/wcV1gMAJuq/ra4DHBUMGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWsIwTFparGha25wcm6r+trgMm5pCsrgMcNgAo + GDIwMjQtMTEtMjlUMjE6NDM6NTIuMDAwWhgYMjAxMC0xMC0yN1QxNjoxMzo1Ni4wMDBaABksFQQV + BBUCABUAFQQVEAAAFuTa9P8HFeQBFqSCvv8HFdYGACbSirWuAxwVChklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudApjb25maWRlbmNlFQwWsIwTFsizERbu9Q0m0oq1rgMmnPizrgMcGAhg5dAi2/nu + PxgIzczMzMzM5D8WyM8NKAhg5dAi2/nuPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWyNz0 + /wcV8gEW+oi+/wcV9gIAJtruwa4DHBUCGTUGCAQZGAVsZXZlbBUMFrCMExbYBxb6CCba7sGuAyaK + 7sGuAxwYBAMAAAAYBP////8W3osTKAQDAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFrre9P8H + FdoBFvCLvv8HFeYBACaq+cGuAxwVDBk1BggEGRgHc3VidHlwZRUMFrCMExacVxaaRyaq+cGuAyaE + 98GuAxw2xL4SKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAA + FpTg9P8HFeIBFtaNvv8HFZwDACaWw8KuAxwVDBk1BggEGRgFY2xhc3MVDBawjBMWqlsW0EsmlsPC + rgMmnr7CrgMcNpjBEigJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFvbh + 9P8HFeIBFvKQvv8HFaYDACbuicOuAxwVChk1BggAGRgGaGVpZ2h0FQwWsIwTFoZjFtYZJu6Jw64D + PBgIAAAAAADAU0AYCAAAAAAAAABAFpyBEygIAAAAAADAU0AYCAAAAAAAAABAABkcFQAVABUQAAAW + 2OP0/wcV2gEWmJS+/wcVtgIAJsSjw64DHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWsIwTFoLX + AhakvgEmxKPDrgM8No7/EigTY2FzZXRhIGRlIHNlZ3VyaWRhZBgOIkxvcyBWaWxsYW5vcyIAGRwV + ABUAFRAAABay5fT/BxXiARbOlr7/BxXUBAAm6OHErgMcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQNrZXkVDBayjBMWki0WyCAm6OHErgM8NoqMEygCcHQYAmVuABkcFQAVABUQAAAWlOf0 + /wcV4gEWopu+/wcVrgEAJrCCxa4DHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFs + dWUVDBayjBMWxEAW/ikmsILFrgM8NoqMEygHVW5pbWFyYxgJQ2VQSUEtSU1PABkcFQAVABUQAAAW + 9uj0/wcV4gEW0Jy+/wcVpAkAJq6sxa4DHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVu + dAd2YXJpYW50FQwWtowTFow3FrYjJq6sxa4DPDaUjBMoBXNob3J0GAlhbHRlcm5hdGUAGRwVABUA + FRAAABbY6vT/BxXiARb0pb7/BxWuAgAm5M/FrgMcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdl + bGVtZW50CGxhbmd1YWdlFQwWtowTFuozFrIhJuTPxa4DPDa2jBMAGRwVABUAFRAAABa67PT/BxXi + ARaiqL7/BxV2ACaW8cWuAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUV + DBa2jBMW5jsWvCgmlvHFrgM8NpSMEygYV3luZGhhbSBIb3RlbHMgJiBSZXNvcnRzGCxBY2FkZW1p + YSBkZSBJZGlvbWFzIHkgRXN0dWRpb3MgUHJvZmVzaW9uYWxlcwAZHBUAFQAVEAAAFpzu9P8HFeIB + Fpipvv8HFbYFACbSmcauAxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2Vl + bgRsaXN0B2VsZW1lbnQVDBa2jBMW8DMWtiEm0pnGrgM8NraMEwAZHBUAFQAVEAAAFv7v9P8HFeIB + Fs6uvv8HFXYAJoi7xq4DHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW + towTFuozFrIhJoi7xq4DPDa2jBMAGRwVABUAFRAAABbg8fT/BxXiARbEr77/BxV2ACa63MauAxwV + ABk1BggAGRgJaGFzX3BhcnRzFQwWsIwTFua1AhaUBya63MauAzwYAQEYAQAWACgBARgBAAAZHBUA + FQAVEAAAFsLz9P8HFdYBFrqwvv8HFXYAJs7jxq4DHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUM + FrCMExbmtQIWsAYmzuPGrgM8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaY9fT/BxXSARawsb7/ + BxV2ACaI68auAxwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFrCMExaqIRacHyaI68auAyb+6cauAxwY + BBkAAAAYBAEAAAAWyvgSKAQZAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFur29P8HFeIBFqay + vv8HFfYBACaaiceuAxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFrCMExaQBBag + BSaaiceuAzw2sIwTABkcFQAVABUQAAAWzPj0/wcV0gEWnLS+/wcVdgAmuo7HrgMcFQoZNQYIABkY + Cm1pbl9oZWlnaHQVDBawjBMWkAQWoAUmuo7HrgM8NrCMEwAZHBUAFQAVEAAAFp769P8HFdIBFpK1 + vv8HFXYAJtqTx64DHBUCGTUGCAAZGAltaW5fZmxvb3IVDBawjBMWkAQWoAUm2pPHrgM8NrCMEwAZ + HBUAFQAVEAAAFvD79P8HFdIBFoi2vv8HFXYAJvqYx64DHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IV + DBawjBMWkAQWoAUm+pjHrgM8NrCMEwAZHBUAFQAVEAAAFsL99P8HFdIBFv62vv8HFXYAJpqex64D + HBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBawjBMWkAQWoAUmmp7HrgM8NrCMEwAZHBUAFQAV + EAAAFpT/9P8HFdIBFvS3vv8HFXYAJrqjx64DHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWsIwT + FpAEFqAFJrqjx64DPDawjBMAGRwVABUAFRAAABbmgPX/BxXSARbquL7/BxV2ACbaqMeuAxwVDBk1 + BggAGRgKcm9vZl9zaGFwZRUMFrCMExbOBBbeBSbaqMeuAzw2rIwTKAdzYWx0Ym94GAZnYWJsZWQA + GRwVABUAFRAAABa4gvX/BxXSARbgub7/BxWqAQAmuK7HrgMcFQoZNQYIABkYDnJvb2ZfZGlyZWN0 + aW9uFQwWsIwTFpAEFqAFJriux64DPDawjBMAGRwVABUAFRAAABaKhPX/BxXSARaKu77/BxV2ACbY + s8euAxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFrCMExaQBBagBSbYs8euAzw2sIwTABkc + FQAVABUQAAAW3IX1/wcV0gEWgLy+/wcVdgAm+LjHrgMcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBaw + jBMWkAQWoAUm+LjHrgM8NrCMEwAZHBUAFQAVEAAAFq6H9f8HFdIBFva8vv8HFXYAJpi+x64DHBUK + GTUGCAAZGAtyb29mX2hlaWdodBUMFrCMExaQBBagBSaYvseuAzw2sIwTABkcFQAVABUQAAAWgIn1 + /wcV0gEW7L2+/wcVdgAWhNSaGxawjBMmwOmhoAMW+NmlDhQ6ABn8Jia4w8euAxwVDBk1BggAGRgC + aWQVDBag+RQWmJLyBRaQ0NcBJrjDx64DPDYAKCAwOGJiMmRiYmI1OTgxZmZmMDIwMDhjN2Y0ZmZi + NDQ2OBggMDhiYjJkODIwMDA0ZWZmZjAyMDAwYjFiZGZkMjBhYmEAGRwVABUAFRIAABbSivX/BxWQ + Ahbivr7/BxXeCQAmyJOfsAMcFQwZNQYIABkYCGdlb21ldHJ5FQwWoPkUFvrX+RAWkrmHCibIk5+w + Azw2ACj5BQAAAAADAAAABAAAAB3AUgSZJq0S88BClIbLYLwCwFIEmZGhfZTAQpSJN0vGqMBSBJko + xfHnwEKUiWVu76LAUgSbFZqb+MBClJSOl93YwFIEm9g4OtrAQpSUOQeIisBSBJxSRh3ywEKUlvtZ + qBLAUgSbiwthXcBClJdZTXkwwFIEnL7oB7zAQpSeVpe8SsBSBJQnadFVwEKUoi6TkULAUgSTwsAD + kcBClJ/nkXQxwFIEk2Rg0qnAQpSgGQ+bfsBSBJMGbQGLwEKUnZF13qnAUgSTbZsODsBClJ1fIPfH + wFIEkcN24rXAQpSTsEuMxsBSBJGJKd/NwEKUk8l2ADfAUgSRRGCCIcBClJI1+AmRwFIEkX6thQnA + QpSSIqzTMsBSBJEDXYKSwEKUj0L+glHAUgSQ1M75zsBClI9kjHGTwFIEkAKsgqrAQpSKbayrxcBS + BI7fltPswEKUiu4FK7nAUgSOY9txq8BClIfKZDzAwFIEliKBNEjAQpSEPefCHMBSBJYETkNawEKU + g0qiu4HAUgSXxe9i+sBClIJ3PiT/wFIEmCtv8FPAQpSE0LS42sBSBJmPHT7VwEKUhC7OSaXAUgSZ + 8oTtOsBClIZydWhiwFIEmSatEvPAQpSGy2C8AgAAAAfAUgSTW/1W2MBClJFnm/CMwFIEmCN31E3A + QpSPP6OD/sBSBJbXstncwEKUh/KoKKnAUgSWNIpLSMBClIg7o0Q9wFIElhWAmsXAQpSHjSebT8BS + BJHxLqvlwEKUiWtOLLTAUgSTW/1W2MBClJFnm/CMAAAABcBSBJhhH9WIwEKUkINwYmnAUgSW23k3 + +sBClJEtuk1uwFIEmNEcvabAQpScjxdfmMBSBJpWw1s0wEKUm+TNdJLAUgSYYR/ViMBClJCDcGJp + AAAABcBSBJT3CAm6wEKUkjRKimjAUgSTfLSGhcBClJLelHVtwFIElX4WhlTAQpSeLlPQYsBSBJb4 + agmJwEKUnYQJ5VzAUgSU9wgJusBClJI0SopoGE0AAAAAAwAAAAEAAAAEwFIjPOIyHifAQkvC31bg + TsBSIzydXVcbwEJLxCYpW4fAUiM8FPfGa8BCS8PbcWwvwFIjPOIyHifAQkvC31bgTgAZHBUAFQAV + JgAAFuKM9f8HFb4EFsDIvv8HFbYnACba7766AxwVCBk1BggEGSgEYmJveAR4bWluFQwWoPkUFpD1 + Sha+yz8m2u++ugMm2symugMcGAQEJJDCGAQVQJLCFgAoBAQkkMIYBBVAksIAGSwVBBUEFQIAFQAV + BBUSAAAWoJH1/wcVkAIW9u++/wcV7gEAJqLB/roDHBUIGTUGCAQZKARiYm94BHhtYXgVDBag+RQW + qP9KFujQPyaiwf66AyaYmOa6AxwYBKUjkMIYBP0/ksIWACgEpSOQwhgE/T+SwgAZLBUEFQQVAgAV + ABUEFRIAABawk/X/BxWQAhbk8b7/BxXuAQAmgOmluwMcFQgZNQYIABkoBGJib3gEeW1pbhUMFqD5 + FBaa6lMWsLQxJoDppbsDPBgEDkASwhgEDBAVwhYAKAQOQBLCGAQMEBXCABkcFQAVABUSAAAWwJX1 + /wcVkAIW0vO+/wcV7gEAJrCd17sDHBUIGTUGCAAZKARiYm94BHltYXgVDBag+RQWmOpTFuayMSaw + nde7AzwYBPo/EsIYBPcPFcIWACgE+j8SwhgE9w8VwgAZHBUAFQAVEgAAFtCX9f8HFZACFsD1vv8H + Fe4BACbW0Ii8AxwVAhk1BggEGRgHdmVyc2lvbhUMFqD5FBbIBRb8BibW0Ii8AyaW0Ii8AxwYBAAA + AAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABbgmfX/BxXsARau977/BxXu + AQAm0teIvAMcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBag+RQW2AYW + jAgm0teIvAMmkteIvAMcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABbMm/X/BxXsARac+b7/ + BxVeACbi4Ii8AxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWoPkUFpSg + BRbc/wIm4uCIvAMmnt+IvAMcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5n + cwAZLBUEFQQVAgAVABUEFRIAABa4nfX/BxX+ARb6+b7/BxXCBQAm+t6LvAMcFQwZJQYAGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWoPkUFtTp9QIW1IKZASb63ou8Azw2ACgMdzk5 + NDA4NDE1OEAxGAwwMDAxMjRjOGZjYWIAGRwVABUAFRIAABa2n/X/BxWQAha8/77/BxWOBAAmqoul + vQMcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBag+RQWjNgVFojT + BSaqi6W9AybO4aS9Axw2ACgYMjAyNC0xMS0wNVQyMTo0ODo0OS4wMDBaGBgyMDExLTA2LTA1VDIz + OjUxOjMyLjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAWxqH1/wcV/gEWyoO//wcVvgcAJpTLq70DHBUK + GSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBag+RQWlvAVFoy0EiaUy6u9 + AybWtKq9AxwYCJm7lpAPeu4/GAjNzMzMzMzkPxb+nQ0oCJm7lpAPeu4/GAjNzMzMzMzkPwAZLBUE + FQQVAgAVABUEFRIAABbEo/X/BxWQAhaIi7//BxWgAwAmoum8vQMcFQIZNQYIBBkYBWxldmVsFQwW + oPkUFvQFFqgHJqLpvL0DJuLovL0DHBgEAQAAABgEAQAAABaO+RQoBAEAAAAYBAEAAAAAGSwVBBUE + FQIAFQAVBBUSAAAW1KX1/wcV7AEWqI6//wcVwgEAJqLyvL0DHBUMGTUGCAQZGAdzdWJ0eXBlFQwW + oPkUFuQXFvgWJqLyvL0DJorwvL0DHDb08RQoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwA + GSwVBBUEFQIAFQAVBBUSAAAWwKf1/wcV/AEW6o+//wcVyAMAJpiKvb0DHBUMGTUGCAQZGAVjbGFz + cxUMFqD5FBaAFxacFiaYir29AyaCh729Axw2zvIUKA10cmFpbl9zdGF0aW9uGAphcGFydG1lbnRz + ABksFQQVBBUCABUAFQQVEgAAFryp9f8HFfoBFrKTv/8HFYgDACaKnr29AxwVChk1BggEGRgGaGVp + Z2h0FQwWoPkUFr4GFsYHJoqevb0DJp6dvb0DHBgIAAAAAAAALkAYCAAAAAAAAAxAFuz4FCgIAAAA + AAAALkAYCAAAAAAAAAxAABksFQQVBBUCABUAFQQVEgAAFrar9f8HFe4BFrqWv/8HFcIBACbewL29 + AxwVDBk1BggEGSgFbmFtZXMHcHJpbWFyeRUMFqD5FBaYRRaULSbewL29AybkpL29Axw27vYUKBDD + gXJlYSBkZSB0aWVuZGFzGAgoRS05MDI4KQAZLBUEFQQVAgAVABUEFRIAABakrfX/BxX+ARb8l7// + BxXIBQAm+NG9vQMcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBag+RQWiBAW + hg8m+NG9vQM8Npj5FCgCcnUYAmVuABkcFQAVABUSAAAWoq/1/wcV/AEWxJ2//wcVkgEAJv7gvb0D + HBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBag+RQWphQWqhEm/uC9vQM8 + Npj5FCgM0KPQsNGB0LrQsNGAGC9UaGUgQ2h1cmNoIG9mIEplc3VzIENocmlzdCBvZiBMYXR0ZXIt + RGF5IFNhaW50cwAZHBUAFQAVEgAAFp6x9f8HFf4BFtaev/8HFbQDACao8r29AxwVDBklBgAZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFqb5FBbqExa0ESao8r29Azw2kvkUKAVz + aG9ydBgJYWx0ZXJuYXRlABkcFQAVABUSAAAWnLP1/wcV/gEWiqK//wcVhAIAJtyDvr0DHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFqb5FBbyERbqDybcg769Azw2 + pvkUABkcFQAVABUSAAAWmrX1/wcV/gEWjqS//wcVggEAJsaTvr0DHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFqb5FBbIFhb8EibGk769Azw2kvkUKBFDcm9zc3ZpbGxl + IEZhYnJpYxgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEgAAFpi39f8HFf4BFpCl + v/8HFbIEACbCpr69AxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRs + aXN0B2VsZW1lbnQVDBam+RQW9hEW7g8mwqa+vQM8Nqb5FAAZHBUAFQAVEgAAFpa59f8HFf4BFsKp + v/8HFYIBACawtr69AxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFqb5 + FBbyERbqDyawtr69Azw2pvkUABkcFQAVABUSAAAWlLv1/wcV/gEWxKq//wcVggEAJprGvr0DHBUA + GTUGCAAZGAloYXNfcGFydHMVDBag+RQW+NMCFqoHJprGvr0DPBgBARgBABYAKAEBGAEAABkcFQAV + ABUSAAAWkr31/wcV7AEWxqu//wcVggEAJsTNvr0DHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUM + FqD5FBb40wIWlgcmxM2+vQM8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABb+vvX/BxXsARbIrL// + BxWCAQAmytW+vQMcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBag+RQWpgcW2ggmytW+vQMm2tS+vQMc + GAQKAAAAGAQBAAAAFvD3FCgECgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABbqwPX/BxXwARbK + rb//BxWyAQAmtN2+vQMcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBag+RQW0gQW + 9AUmtN2+vQM8NqD5FAAZHBUAFQAVEgAAFtrC9f8HFewBFvyuv/8HFYIBACao4769AxwVChk1BggA + GRgKbWluX2hlaWdodBUMFqD5FBbSBBb0BSao4769Azw2oPkUABkcFQAVABUSAAAWxsT1/wcV7AEW + /q+//wcVggEAJpzpvr0DHBUCGTUGCAAZGAltaW5fZmxvb3IVDBag+RQW0gQW9AUmnOm+vQM8NqD5 + FAAZHBUAFQAVEgAAFrLG9f8HFewBFoCxv/8HFYIBACaQ7769AxwVDBk1BggAGRgMZmFjYWRlX2Nv + bG9yFQwWoPkUFtIEFvQFJpDvvr0DPDag+RQAGRwVABUAFRIAABaeyPX/BxXsARaCsr//BxWCAQAm + hPW+vQMcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFqD5FBbSBBb0BSaE9b69Azw2oPkUABkc + FQAVABUSAAAWisr1/wcV7AEWhLO//wcVggEAJvj6vr0DHBUMGTUGCAAZGA1yb29mX21hdGVyaWFs + FQwWoPkUFtIEFvQFJvj6vr0DPDag+RQAGRwVABUAFRIAABb2y/X/BxXsARaGtL//BxWCAQAm7IC/ + vQMcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBag+RQW0gQW9AUm7IC/vQM8NqD5FAAZHBUAFQAVEgAA + FuLN9f8HFewBFoi1v/8HFYIBACbghr+9AxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBag+RQW + 0gQW9AUm4Ia/vQM8NqD5FAAZHBUAFQAVEgAAFs7P9f8HFewBFoq2v/8HFYIBACbUjL+9AxwVDBk1 + BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFqD5FBbSBBb0BSbUjL+9Azw2oPkUABkcFQAVABUSAAAW + utH1/wcV7AEWjLe//wcVggEAJsiSv70DHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWoPkUFvIEFpQG + JsiSv70DPBgHIzk3QTJCRRgHIzk3QTJCRRae+RQoByM5N0EyQkUYByM5N0EyQkUAGRwVABUAFRIA + ABam0/X/BxXsARaOuL//BxWeAQAm3Ji/vQMcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWoPkUFtIE + FvQFJtyYv70DPDag+RQAGRwVABUAFRIAABaS1fX/BxXsARasub//BxWCAQAWyvjXHBag+RQmuMPH + rgMWmNv3DhQ8ABn8JibQnr+9AxwVDBk1BggAGRgCaWQVDBakrhMW4Ia5BRbI+cgBJtCev70DPDYA + KCAwOGJiMmRiYjc1ZGFkZmZmMDIwMGQzMjMwY2FiMmZlNRggMDhiYjJkODIwOTAyMGZmZjAyMDA2 + MmUxNTAzMjdlNzQAGRwVABUAFRAAABb+1vX/BxXyARauur//BxXWCAAmmJiIvwMcFQwZNQYIABkY + CGdlb21ldHJ5FQwWpK4TFrjEgRAW3J3OCSaYmIi/Azw2ACi5BAAAAAADAAAABAAAABPAUhl1Ng0C + R8BChNkWhysCwFIZdWGr7ILAQoTcrRSgocBSGXTEzfrKwEKE3L+JF2vAUhl00PfUuMBChN3DlRWm + wFIZdWu853zAQoTdsSCe3MBSGXWWhRIjwEKE4TvvmlfAUhl01L4y1sBChOFTbI6fwFIZdOB8rPrA + QoTiRC1WesBSGXY7xn+swEKE4ho762nAUhl2bobGWMBChOZCv5gxwFIZdS2phnfAQoTmaizEhMBS + GXUz9CNTwEKE5u63AmDAUhl2jE5XfMBChObExZdOwFIZdsBQvYjAQoTrC3w1BcBSGW8VYZEVwEKE + 6/jh/o3AUhluqFRHgMBChOL6NbukwFIZb9lBT1bAQoTi1iONpMBSGW9rXUYswEKE2ck0kdjAUhl1 + Ng0CR8BChNkWhysCAAAABcBSGXP8UR7XwEKE4VvQCm/AUhlwZ9yILMBChOIEbHZLwFIZcHg4IALA + QoTi58FE2cBSGXQMrLatwEKE4j8k2P3AUhlz/FEe18BChOFb0ApvAAAABcBSGXRWEzIMwEKE5h3W + qpzAUhlxpPNp8MBChOaMkXNawFIZcbaRISXAQoTnnuAqeMBSGXRnRYl3wEKE5zAlYbnAUhl0VhMy + DMBChOYd1qqcAAAABcBSGXOT4PL0wEKE3Lf8WzDAUhlxGbMvbcBChN0uQ+AqwFIZcStQ5qLAQoTe + Hi3occBSGXOlfqoqwEKE3afmY3fAUhlzk+Dy9MBChNy3/FswGE0AAAAAAwAAAAEAAAAEwFIBVOJ/ + u9fAQnk01CgnSsBSAVSgUNmUwEJ5NcurKGrAUgFUDW1xT8BCeTVmdNd3wFIBVOJ/u9fAQnk01Cgn + SgAZHBUAFQAVJAAAFvDY9f8HFaAEFoTDv/8HFa4lACb0tdbIAxwVCBk1BggAGSgEYmJveAR4bWlu + FQwWpK4TFuC9TRbwsSsm9LXWyAM8GAQVcI/CGAQG2JDCFgAoBBVwj8IYBAbYkMIAGRwVABUAFRAA + ABaQ3fX/BxXyARay6L//BxXWAQAm5OeByQMcFQgZNQYIABkoBGJib3gEeG1heBUMFqSuExbevU0W + zK4rJuTngckDPBgEDnCPwhgE+9eQwhYAKAQOcI/CGAT715DCABkcFQAVABUQAAAWgt/1/wcV8gEW + iOq//wcV1gEAJrCWrckDHBUIGTUGCAAZKARiYm94BHltaW4VDBakrhMW4L1NFu7kLSawlq3JAzwY + BBBAEsIYBAgQFcIWACgEEEASwhgECBAVwgAZHBUAFQAVEAAAFvTg9f8HFfIBFt7rv/8HFdYBACae + +9rJAxwVCBk1BggAGSgEYmJveAR5bWF4FQwWpK4TFt69TRaO4i0mnvvayQM8GAT0PxLCGAT4DxXC + FgAoBPQ/EsIYBPgPFcIAGRwVABUAFRAAABbm4vX/BxXyARa07b//BxXWAQAm7N2IygMcFQIZNQYI + BBkYB3ZlcnNpb24VDBakrhMW/gQWoAYm7N2IygMmrN2IygMcGAQAAAAAGAQAAAAAFgAoBAAAAAAY + BAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW2OT1/wcV0gEWiu+//wcV1gEAJozkiMoDHBUMGSUGBBlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWpK4TFv4FFqAHJozkiMoDJszjiMoDHBgA + GAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWqub1/wcV0gEW4PC//wcVVgAmsOyIygMcFQwZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFqSuExae3gQWouMCJrDsiMoDJuzqiMoD + HDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQ + AAAW/Of1/wcV4gEWtvG//wcV9gQAJo7Oi8oDHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CXJlY29yZF9pZBUMFqSuExbk1NMCFtbqjwEmjs6LygM8NgAoC3c5OTgwOTEzNUAxGAwwMDAxODJk + YjlhYmMAGRwVABUAFRAAABbe6fX/BxXyARas9r//BxXSAwAmkuubywMcFQwZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBakrhMWookUFvqoBSaS65vLAybkuJvLAxw2ACgY + MjAyNC0xMC0xMlQxNjowMjoyNS4wMDBaGBgyMDExLTAyLTE1VDAxOjEyOjI5LjAwMFoAGSwVBBUE + FQIAFQAVBBUQAAAW0Ov1/wcV4gEW/vm//wcV1gYAJsD6ocsDHBUKGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50CmNvbmZpZGVuY2UVDBakrhMWprUSFpr2DibA+qHLAybe4aDLAxwYCISezarP1e4/ + GAjNzMzMzMzkPxbUtA0oCISezarP1e4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABay7fX/ + BxXyARbUgMD/BxX2AgAm+NevywMcFQIZNQYIABkYBWxldmVsFQwWpK4TFp4FFqgGJvjXr8sDPBgE + AQAAABgEAQAAABaUrhMoBAEAAAAYBAEAAAAAGRwVABUAFRAAABak7/X/BxXUARbKg8D/BxXGAQAm + muCvywMcFQwZNQYIBBkYB3N1YnR5cGUVDBakrhMWiBMW/hImmuCvywMmoN6vywMcNrykEygOdHJh + bnNwb3J0YXRpb24YBWNpdmljABksFQQVBBUCABUAFQQVEAAAFvjw9f8HFeABFpCFwP8HFYQDACbW + 86/LAxwVDBk1BggEGRgFY2xhc3MVDBakrhMWqBIWlBIm1vOvywMmnvGvywMcNuykEygKdW5pdmVy + c2l0eRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABbY8vX/BxXeARaUiMD/BxXCAgAmsoOw + ywMcFQoZNQYIABkYBmhlaWdodBUMFqSuExbyBhbYBiayg7DLAzwYCAAAAAAAABxAGAgAAAAAAAAI + QBaErhMoCAAAAAAAABxAGAgAAAAAAAAIQAAZHBUAFQAVEAAAFrb09f8HFdQBFtaKwP8HFbYBACaK + irDLAxwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFqSuExbQOxbsKiaKirDLAzw2sKwTKBdyYW1w + YSBkZXNjYXJnYSBjYW1pb25lcxgTMyBDb21pc2Fyw61hIEJ1bG5lcwAZHBUAFQAVEAAAFor29f8H + FeABFoyMwP8HFeYFACb2tLDLAxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUM + FqSuExbkCxbuCyb2tLDLAzw2pK4TABkcFQAVABUQAAAW6vf1/wcV3gEW8pHA/wcVdgAm5MCwywMc + FQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFqSuExaIDRasDCbkwLDLAzw2 + pK4TABkcFQAVABUQAAAWyPn1/wcV3gEW6JLA/wcVdgAmkM2wywMcFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBakrhMWoA0WygwmkM2wywM8GAhvZmZpY2lhbBgIb2Zm + aWNpYWwWoq4TKAhvZmZpY2lhbBgIb2ZmaWNpYWwAGRwVABUAFRAAABam+/X/BxXeARbek8D/BxWW + AQAm2tmwywMcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWpK4T + FogNFrAMJtrZsMsDPDakrhMAGRwVABUAFRAAABaE/fX/BxXeARb0lMD/BxV2ACaK5rDLAxwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBakrhMWwg0W+gwmiuawywM8GBlC + YW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlFqKuEygZ + QmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZRgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUA + FQAVEAAAFuL+9f8HFd4BFuqVwP8HFdoBACaE87DLAxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBakrhMWiA0WsAwmhPOwywM8NqSuEwAZHBUA + FQAVEAAAFsCA9v8HFd4BFsSXwP8HFXYAJrT/sMsDHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudARzaWRlFQwWpK4TFogNFrAMJrT/sMsDPDakrhMAGRwVABUAFRAAABaegvb/BxXeARa6 + mMD/BxV2ACbki7HLAxwVABk1BggAGRgJaGFzX3BhcnRzFQwWpK4TFoa6AhawBibki7HLAzwYAQAY + AQAWACgBABgBAAAZHBUAFQAVEAAAFvyD9v8HFdIBFrCZwP8HFXYAJpSSscsDHBUAGTUGCAAZGA5p + c191bmRlcmdyb3VuZBUMFqSuExaGugIWsAYmlJKxywM8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAA + ABbOhfb/BxXSARammsD/BxV2ACbEmLHLAxwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFqSuExbCBxbI + BybEmLHLAzwYBAQAAAAYBAEAAAAW6K0TKAQEAAAAGAQBAAAAABkcFQAVABUQAAAWoIf2/wcV1gEW + nJvA/wcVxgEAJoygscsDHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWpK4TFpAE + FqAFJoygscsDPDakrhMAGRwVABUAFRAAABb2iPb/BxXSARbinMD/BxV2ACaspbHLAxwVChk1BggA + GRgKbWluX2hlaWdodBUMFqSuExaQBBagBSaspbHLAzw2pK4TABkcFQAVABUQAAAWyIr2/wcV0gEW + 2J3A/wcVdgAmzKqxywMcFQIZNQYIABkYCW1pbl9mbG9vchUMFqSuExaQBBagBSbMqrHLAzw2pK4T + ABkcFQAVABUQAAAWmoz2/wcV0gEWzp7A/wcVdgAm7K+xywMcFQwZNQYIABkYDGZhY2FkZV9jb2xv + chUMFqSuExaQBBagBSbsr7HLAzw2pK4TABkcFQAVABUQAAAW7I32/wcV0gEWxJ/A/wcVdgAmjLWx + ywMcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFqSuExaQBBagBSaMtbHLAzw2pK4TABkcFQAV + ABUQAAAWvo/2/wcV0gEWuqDA/wcVdgAmrLqxywMcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBak + rhMWkAQWoAUmrLqxywM8NqSuEwAZHBUAFQAVEAAAFpCR9v8HFdIBFrChwP8HFXYAJsy/scsDHBUM + GTUGCAAZGApyb29mX3NoYXBlFQwWpK4TFpAEFqAFJsy/scsDPDakrhMAGRwVABUAFRAAABbikvb/ + BxXSARamosD/BxV2ACbsxLHLAxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBakrhMWkAQWoAUm + 7MSxywM8NqSuEwAZHBUAFQAVEAAAFrSU9v8HFdIBFpyjwP8HFXYAJozKscsDHBUMGTUGCAAZGBBy + b29mX29yaWVudGF0aW9uFQwWpK4TFpAEFqAFJozKscsDPDakrhMAGRwVABUAFRAAABaGlvb/BxXS + ARaSpMD/BxV2ACasz7HLAxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFqSuExaQBBagBSasz7HLAzw2 + pK4TABkcFQAVABUQAAAW2Jf2/wcV0gEWiKXA/wcVdgAmzNSxywMcFQoZNQYIABkYC3Jvb2ZfaGVp + Z2h0FQwWpK4TFpAEFqAFJszUscsDPDakrhMAGRwVABUAFRAAABaqmfb/BxXSARb+pcD/BxV2ABbO + r/YaFqSuEybQnr+9Axacu/INFD4AGfwmJuzZscsDHBUMGTUGCAAZGAJpZBUMFqirExbwm7gFFpqd + yQEm7NmxywM8NgAoIDA4YmNlOWJkNzZjZGNmZmYwMjAwZmQ1ZjgwMzczZTZjGCAwOGJiMmQ5MDAw + MjQ4ZmZmMDIwMDljYjI0NWMwYWUwZAAZHBUAFQAVEAAAFvya9v8HFfIBFvSmwP8HFdYIACaG9/rM + AxwVDBk1BggAGRgIZ2VvbWV0cnkVDBaoqxMW/NydEBaavN8JJob3+swDPDYAKP0CAAAAAAYAAAAE + AAAAAAMAAAABAAAABcBR2EHSnccmwEKxKV6eGwnAUdg/6zz6XMBCsS1UzODvwFHYPruSEebAQrEr + 47OZH8BR2ECi8t6vwEKxJ+5bks7AUdhB0p3HJsBCsSlenhsJAAAAAAMAAAABAAAABcBR2EeysZiU + wEKxMMdIKI7AUdhHWVrlKcBCsTMBtQvmwFHYRG7E2bnAQrEx20Re1cBR2ETHsC1awEKxL6DXe3zA + UdhHsrGYlMBCsTDHSCiOAAAAAAMAAAABAAAABcBR2EQF6U4NwEKxLcYL6GzAUdhCDOrKDsBCsTAw + SXPnwFHYQTx10hTAQrEugspKPMBR2EM137XewEKxLBiMvsDAUdhEBelODcBCsS3GC+hsAAAAAAMA + AAABAAAABcBR2DzHnAtkwEKxNe7PVhTAUdg7EU4GHcBCsTd6wJB+wFHYOj5Uz2XAQrE1LQh2x8BR + 2Dv0otSswEKxM6EXPF3AUdg8x5wLZMBCsTXuz1YUGE0AAAAAAwAAAAEAAAAEwFH5kHaJb63AQlmU + pYP438BR+ZDfBVKPwEJZk9MW6c3AUfmRWoTR98BCWZRyI5mhwFH5kHaJb63AQlmUpYP43wAZHBUA + FQAVJAAAFu6c9v8HFZ4EFsqvwP8HFa4lACaClfHWAxwVCBk1BggEGSgEYmJveAR4bWluFQwWqKsT + FpSERBaWszomgpXx1gMmoLPa1gMcGAQ4oIzCGARxUJDCFgAoBDigjMIYBHFQkMIAGSwVBBUEFQIA + FQAVBBUQAAAWjKH2/wcV8gEW+NTA/wcV1gEAJoDBq9cDHBUIGTUGCAQZKARiYm94BHhtYXgVDBao + qxMW6vlDFvCsOiaAwavXAya25pTXAxwYBCugjMIYBGVQkMIWACgEK6CMwhgEZVCQwgAZLBUEFQQV + AgAVABUEFRAAABb+ovb/BxXyARbO1sD/BxXWAQAm0Izp1wMcFQgZNQYIBBkoBGJib3gEeW1pbhUM + FqirExbqkUkW3Ks+JtCM6dcDJqaTz9cDHBgEDkASwhgE998XwhYAKAQOQBLCGAT33xfCABksFQQV + BBUCABUAFQQVEAAAFvCk9v8HFfIBFqTYwP8HFdYBACbcvqfYAxwVCBk1BggEGSgEYmJveAR5bWF4 + FQwWqKsTFvqaSRbGsj4m3L6n2AMmgr+N2AMcGAT2PxLCGATp3xfCFgAoBPY/EsIYBOnfF8IAGSwV + BBUEFQIAFQAVBBUQAAAW4qb2/wcV8gEW+tnA/wcV1gEAJojyy9gDHBUCGTUGCAQZGAd2ZXJzaW9u + FQwWqKsTFv4EFqAGJojyy9gDJsjxy9gDHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQV + BBUCABUAFQQVEAAAFtSo9v8HFdIBFtDbwP8HFdYBACao+MvYAxwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAhwcm9wZXJ0eRUMFqirExb+BRagByao+MvYAybo98vYAxwYABgAFgAoABgAABks + FQQVBBUCABUAFQQVEAAAFqaq9v8HFdIBFqbdwP8HFVYAJsyAzNgDHBUMGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50B2RhdGFzZXQVDBaoqxMWvMgEFtz0AibMgMzYAyaI/8vYAxw2ACgNT3BlblN0 + cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFvir9v8HFeIB + FvzdwP8HFfYEACbk887YAxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQV + DBaoqxMW0KnUAhbev4oBJuTzztgDPDYAKAx3OTkyNTk0NDU0QDEYDDAwMDAyYzMzMzQ4YQAZHBUA + FQAVEAAAFtqt9v8HFfIBFvLiwP8HFdQDACbg6NrZAxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudAt1cGRhdGVfdGltZRUMFqirExbGjR4WsssIJuDo2tkDJsKz2dkDHDYAKBgyMDI0LTExLTE5 + VDA5OjI3OjA3LjAwMFoYGDIwMDgtMTEtMTJUMDE6MDI6MzcuMDAwWgAZLBUEFQQVAgAVABUEFRAA + ABbMr/b/BxXmARbG5sD/BxXWBgAmtJfj2QMcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQK + Y29uZmlkZW5jZRUMFqirExb6pRIWrOkOJrSX49kDJvT+4dkDHBgIJ8KGp1fK7j8YCM3MzMzMzOQ/ + FrqYDSgIJ8KGp1fK7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFrKx9v8HFfIBFpztwP8H + FfYCACbg6PDZAxwVAhk1BggEGRgFbGV2ZWwVDBaoqxMW0AUW8gYm4Ojw2QMmoOjw2QMcGAQBAAAA + GAQBAAAAFoarEygEAQAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABaks/b/BxXSARaS8MD/BxXW + AQAmuPHw2QMcFQwZNQYIBBkYB3N1YnR5cGUVDBaoqxMW6DkW7jMmuPHw2QMmku/w2QMcNu7SEigO + dHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABb2tPb/BxXiARbo + 8cD/BxWiAwAmjKjx2QMcFQwZNQYIBBkYBWNsYXNzFQwWqKsTFtA9Ft43Joyo8dkDJoCj8dkDHDaa + 1BIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABbYtvb/BxXiARaK9cD/ + BxXmAgAm0Nvx2QMcFQoZNQYIBBkYBmhlaWdodBUMFqirExbGBxayCCbQ2/HZAybe2vHZAxwYCAAA + AAAAAC5AGAgAAAAAAAAIQBaoqhMoCAAAAAAAAC5AGAgAAAAAAAAIQAAZLBUEFQQVAgAVABUEFRAA + ABa6uPb/BxXWARbw98D/BxW2AQAmkOPx2QMcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaoqxMW + jIMBFrRSJpDj8dkDPDaCpxMoFMOTcHRpY2EgVmlzaW9uIENsYXJhGCUxIHkgMiBKdXpnYWRvIFBv + bGljw61hIExvY2FsIENoaWxsw6FuABkcFQAVABUQAAAWkLr2/wcV4gEWpvnA/wcVjAUAJsS18tkD + HBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWqKsTFoQVFrgRJsS18tkDPDao + qxMAGRwVABUAFRAAABbyu/b/BxXgARay/sD/BxV2ACb8xvLZAxwVDBklBgAZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlBXZhbHVlFQwWqKsTFqAYFtwSJvzG8tkDPDaoqxMAGRwVABUAFRAAABbSvfb/ + BxXiARao/8D/BxV2ACbY2fLZAxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFy + aWFudBUMFqyrExawGRbgEybY2fLZAzw2oqsTKAVzaG9ydBgJYWx0ZXJuYXRlABkcFQAVABUQAAAW + tL/2/wcV4gEWnoDB/wcVtAEAJrjt8tkDHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVu + dAhsYW5ndWFnZRUMFqyrExa2GBbsEia47fLZAzw2rKsTABkcFQAVABUQAAAWlsH2/wcV4gEW0oHB + /wcVdgAmpIDz2QMcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWrKsT + FrgaFsAUJqSA89kDPDaiqxMoClNNTCDDkXVibGUYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUA + GRwVABUAFRAAABb4wvb/BxXiARbIgsH/BxW0AgAm5JTz2QMcFQoZJQYAGXgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWrKsTFrgYFuwSJuSU89kDPDasqxMA + GRwVABUAFRAAABbaxPb/BxXiARb8hMH/BxV2ACbQp/PZAxwVDBklBgAZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQEc2lkZRUMFqyrExa2GBbsEibQp/PZAzw2rKsTABkcFQAVABUQAAAWvMb2/wcV + 4gEW8oXB/wcVdgAmvLrz2QMcFQAZNQYIABkYCWhhc19wYXJ0cxUMFqirExbWuQIW3gYmvLrz2QM8 + GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABaeyPb/BxXUARbohsH/BxV2ACaawfPZAxwVABk1BggA + GRgOaXNfdW5kZXJncm91bmQVDBaoqxMW1rkCFrAGJprB89kDPBgBABgBABYAKAEAGAEAABkcFQAV + ABUQAAAW8sn2/wcV0gEW3ofB/wcVdgAm4sjz2QMcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBaoqxMW + 9BEWnBEm4sjz2QMmysfz2QMcGAQVAAAAGAQBAAAAFqqiEygEFQAAABgEAQAAAAAZLBUEFQQVAgAV + ABUEFRAAABbEy/b/BxXWARbUiMH/BxXWAQAm5tjz2QMcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5k + ZXJncm91bmQVDBaoqxMWkAQWoAUm5tjz2QM8NqirEwAZHBUAFQAVEAAAFprN9v8HFdIBFqqKwf8H + FXYAJobe89kDHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWqKsTFpAEFqAFJobe89kDPDaoqxMAGRwV + ABUAFRAAABbszvb/BxXSARagi8H/BxV2ACam4/PZAxwVAhk1BggAGRgJbWluX2Zsb29yFQwWqKsT + FpAEFqAFJqbj89kDPDaoqxMAGRwVABUAFRAAABa+0Pb/BxXSARaWjMH/BxV2ACbG6PPZAxwVDBk1 + BggAGRgMZmFjYWRlX2NvbG9yFQwWqKsTFpAEFqAFJsbo89kDPDaoqxMAGRwVABUAFRAAABaQ0vb/ + BxXSARaMjcH/BxV2ACbm7fPZAxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWqKsTFpAEFqAF + Jubt89kDPDaoqxMAGRwVABUAFRAAABbi0/b/BxXSARaCjsH/BxV2ACaG8/PZAxwVDBk1BggAGRgN + cm9vZl9tYXRlcmlhbBUMFqirExaQBBagBSaG8/PZAzw2qKsTABkcFQAVABUQAAAWtNX2/wcV0gEW + +I7B/wcVdgAmpvjz2QMcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaoqxMW3AQW5AUmpvjz2QM8NqKr + EygFcm91bmQYBmdhYmxlZAAZHBUAFQAVEAAAFobX9v8HFdIBFu6Pwf8HFaIBACaK/vPZAxwVChk1 + BggAGRgOcm9vZl9kaXJlY3Rpb24VDBaoqxMWkAQWoAUmiv7z2QM8NqirEwAZHBUAFQAVEAAAFtjY + 9v8HFdIBFpCRwf8HFXYAJqqD9NkDHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWqKsTFpAE + FqAFJqqD9NkDPDaoqxMAGRwVABUAFRAAABaq2vb/BxXSARaGksH/BxV2ACbKiPTZAxwVDBk1BggA + GRgKcm9vZl9jb2xvchUMFqirExaQBBagBSbKiPTZAzw2qKsTABkcFQAVABUQAAAW/Nv2/wcV0gEW + /JLB/wcVdgAm6o302QMcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWqKsTFroEFsoFJuqN9NkDPBgI + AAAAAAAA8D8YCAAAAAAAAPA/FqSrEygIAAAAAAAA8D8YCAAAAAAAAPA/ABkcFQAVABUQAAAWzt32 + /wcV0gEW8pPB/wcVlgEAFua5ghsWqKsTJuzZscsDFsi5wg4UQAAZ/CYmtJP02QMcFQwZNQYIABkY + AmlkFQwW6PoUFrrK8gUWhLnYASa0k/TZAzw2ACggMDhiY2U5ZWRiMTZmMWZmZjAyMDA5ODJkY2Q2 + ZWQ2YzAYIDA4YmIyY2EyMGJiMTlmZmYwMjAwMjVlNjRmNGM1NTFjABkcFQAVABUSAAAWoN/2/wcV + kAIWiJXB/wcV3gkAJrjMzNsDHBUMGTUGCAAZGAhnZW9tZXRyeRUMFuj6FBbiqJYRFr7pggomuMzM + 2wM8NgAokwIAAAAABgAAAAIAAAAAAwAAAAEAAAAKwFEyQIldC3TAQ6Fl6xZj8MBRMkAj3H4bwEOh + Z+78on3AUTI/PgNwzsBDoWeCxhh+wFEyPUcdy8PAQ6FmlWBO9cBRMj0th/iHwEOhZxdmThPAUTI7 + SYIqEcBDoWYzOr/vwFEyN6tn+DfAQ6Fmt8T9y8BRMjeBdo0lwEOhY/wo2uvAUTI7SYIqEcBDoWNx + v1/9wFEyQIldC3TAQ6Fl6xZj8AAAAAADAAAAAQAAAAXAUTI2XEf/c8BDoWeVOo9IwFEyLUnlJmDA + Q6Fsfq5byMBRMiyyD7IlwEOhahHskY7AUTI1zoOGMsBDoWUhwshnwFEyNlxH/3PAQ6FnlTqPSBhN + AAAAAAMAAAABAAAABMBRDoiosI3SwEN6i/cZp3HAUQ6PsiSq2sBDeovQgzqzwFEOj8KAQrDAQ3qR + 5/RwgMBRDoiosI3SwEN6i/cZp3EAGRwVABUAFSYAABaw4fb/BxW+BBbmnsH/BxW2JwAm9rXP5QMc + FQgZNQYIABkoBGJib3gEeG1pbhUMFuj6FBa68FMW2totJva1z+UDPBgEFgCHwhgEcW+PwhYAKAQW + AIfCGARxb4/CABkcFQAVABUSAAAW7uX2/wcVkAIWnMbB/wcV7gEAJtCQ/eUDHBUIGTUGCAAZKARi + Ym94BHhtYXgVDBbo+hQWtvBTFujbLSbQkP3lAzwYBA8Ah8IYBGhvj8IWACgEDwCHwhgEaG+PwgAZ + HBUAFQAVEgAAFv7n9v8HFZACForIwf8HFe4BACa47KrmAxwVCBk1BggAGSgEYmJveAR5bWluFQwW + 6PoUFrrwUxaSxC8muOyq5gM8GAQJQBLCGASufx3CFgAoBAlAEsIYBK5/HcIAGRwVABUAFRIAABaO + 6vb/BxWQAhb4ycH/BxXuAQAmyrDa5gMcFQgZNQYIABkoBGJib3gEeW1heBUMFuj6FBa68FMWusUv + Jsqw2uYDPBgE6j8SwhgEoH8dwhYAKATqPxLCGASgfx3CABkcFQAVABUSAAAWnuz2/wcVkAIW5svB + /wcV7gEAJsT2iecDHBUCGTUGCAQZGAd2ZXJzaW9uFQwW6PoUFsgFFvwGJsT2iecDJoT2iecDHBgE + AAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEgAAFq7u9v8HFewBFtTNwf8H + Fe4BACbA/YnnAxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFuj6FBbY + BhaMCCbA/YnnAyaA/YnnAxwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFprw9v8HFewBFsLP + wf8HFV4AJtCGiucDHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbo+hQW + gIEBFopYJtCGiucDJoyFiucDHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGlu + Z3MAGSwVBBUEFQIAFQAVBBUSAAAWhvL2/wcV/gEWoNDB/wcVwgUAJpbdiucDHBUMGSUGABlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFuj6FBayhbQDFuD6ayaW3YrnAzw2ACgMdzk4 + MjA2MTk2OEAxGAwwMDJjODU3MDk5MjgAGRwVABUAFRIAABaE9Pb/BxWQAhbi1cH/BxXIBAAm/LP3 + 5wMcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbo+hQW9K8GFsSv + Aib8s/fnAyb21/bnAxw2ACgYMjAyNC0xMS0yOVQyMDo0NDowOC4wMDBaGBgyMDA4LTEyLTEyVDIy + OjUzOjM0LjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAWlPb2/wcV/gEWqtrB/wcVvgcAJozF+ucDHBUK + GSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbo+hQW4tgiFobvICaMxfrn + Aya6h/nnAxwYCAAAAAAAAPA/GAjNzMzMzMzkPxaibygIAAAAAAAA8D8YCM3MzMzMzOQ/ABksFQQV + BBUCABUAFQQVEgAAFpL49v8HFZACFujhwf8HFZADACaA95noAxwVAhk1BggEGRgFbGV2ZWwVDBbo + +hQWsAkWygomgPeZ6AMmwPaZ6AMcGAQBAAAAGAQBAAAAFtT5FCgEAQAAABgEAQAAAAAZLBUEFQQV + AgAVABUEFRIAABai+vb/BxX0ARb45MH/BxWCAgAmroOa6AMcFQwZNQYIBBkYB3N1YnR5cGUVDBbo + +hQWvj8WtjYmroOa6AMmioGa6AMcNvraFCgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZ + LBUEFQQVAgAVABUEFRIAABaW/Pb/BxX+ARb65sH/BxWKBAAmqrya6AMcFQwZNQYIBBkYBWNsYXNz + FQwW6PoUFoI9Fo41Jqq8mugDJsC3mugDHDao3xQoCXdhcmVob3VzZRgPYWxsb3RtZW50X2hvdXNl + ABksFQQVBBUCABUAFQQVEgAAFpT+9v8HFf4BFoTrwf8HFcgDACbo7ZroAxwVChk1BggEGRgGaGVp + Z2h0FQwW6PoUFrw2FuorJujtmugDJs7smugDHBgIAAAAAAAAOEAYCAAAAAAAAABAFrjfFCgIAAAA + AAAAOEAYCAAAAAAAAABAABksFQQVBBUCABUAFQQVEgAAFpKA9/8HFfgBFszuwf8HFeICACa8tJzo + AxwVDBk1BggEGSgFbmFtZXMHcHJpbWFyeRUMFuj6FBaEuAMW3NwBJry0nOgDJriYm+gDHDa+6BQo + D8OTcHRpY2EgVmlzacOzbhgRMzYgQ29tdW5pY2FjaW9uZXMAGSwVBBUEFQIAFQAVBBUSAAAWioL3 + /wcV/gEWrvHB/wcVvgYAJpT1nOgDHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5 + FQwW6PoUFqI1FsQmJpT1nOgDPDbo+hQAGRwVABUAFRIAABaIhPf/BxX+ARbs98H/BxWCAQAm2Jud + 6AMcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFuj6FBaEQBaSKSbYm53o + Azw26PoUABkcFQAVABUSAAAWhob3/wcV/gEW7vjB/wcVggEAJurEnegDHBUMGSUGABlYBW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW6PoUFrhHFsosJurEnegDPDaU+hQoBXNob3J0 + GAlhbHRlcm5hdGUAGRwVABUAFRIAABaEiPf/BxX+ARbw+cH/BxW4AgAmtPGd6AMcFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW6PoUFoJAFvIpJrTxnegDPDbo+hQA + GRwVABUAFRIAABaCivf/BxX+ARao/MH/BxWCAQAmppue6AMcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50BXZhbHVlFQwW6PoUFqpJFsoxJqabnugDPDaU+hQoC2VzdHJ1Y3V0dXJhGAZB + TUVKVU4AGRwVABUAFRIAABaAjPf/BxX+ARaq/cH/BxWqAwAm8Mye6AMcFQoZJQYAGXgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW6PoUFoJAFvIpJvDMnugD + PDbo+hQAGRwVABUAFRIAABb+jff/BxX+ARbUgML/BxWCAQAm4vae6AMcFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbo+hQWgkAW8ikm4vae6AM8Nuj6FAAZHBUAFQAVEgAA + FvyP9/8HFf4BFtaBwv8HFYIBACbUoJ/oAxwVABk1BggAGRgJaGFzX3BhcnRzFQwW6PoUFpbUAhbm + CSbUoJ/oAzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEgAAFvqR9/8HFfIBFtiCwv8HFYIBACa6qp/o + AxwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBbo+hQWktQCFpYHJrqqn+gDPBgBABgBABYAKAEA + GAEAABkcFQAVABUSAAAW7JP3/wcV7AEW2oPC/wcVggEAJtCyn+gDHBUCGTUGCAQZGApudW1fZmxv + b3JzFQwW6PoUFpIWFvoUJtCyn+gDJtCxn+gDHBgEEAAAABgEAQAAABaC8hQoBBAAAAAYBAEAAAAA + GSwVBBUEFQIAFQAVBBUSAAAW2JX3/wcV+gEW3ITC/wcVkgIAJsrGn+gDHBUCGTUGCAAZGBZudW1f + Zmxvb3JzX3VuZGVyZ3JvdW5kFQwW6PoUFtIEFvQFJsrGn+gDPDbo+hQAGRwVABUAFRIAABbSl/f/ + BxXsARbuhsL/BxWCAQAmvsyf6AMcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbo+hQW0gQW9AUmvsyf + 6AM8Nuj6FAAZHBUAFQAVEgAAFr6Z9/8HFewBFvCHwv8HFYIBACay0p/oAxwVAhk1BggAGRgJbWlu + X2Zsb29yFQwW6PoUFtIEFvQFJrLSn+gDPDbo+hQAGRwVABUAFRIAABaqm/f/BxXsARbyiML/BxWC + AQAmptif6AMcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFuj6FBbqDBaaCiam2J/oAzw2nvoUKAcj + RkI5ODk4GAcjMDAwMDAwABkcFQAVABUSAAAWlp33/wcV8AEW9InC/wcVjgIAJsDin+gDHBUMGTUG + CAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbo+hQW1AYWygcmwOKf6AM8Ntb6FCgFc3RvbmUYBWJyaWNr + ABkcFQAVABUSAAAWhp/3/wcV8AEWgozC/wcVvgEAJorqn+gDHBUMGTUGCAAZGA1yb29mX21hdGVy + aWFsFQwW6PoUFtYFFuwGJorqn+gDPDbg+hQoCnJvb2ZfdGlsZXMYBW1ldGFsABkcFQAVABUSAAAW + 9qD3/wcV7gEWwI3C/wcVyAEAJvbwn+gDHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW6PoUFpYJFtYI + Jvbwn+gDPDbA+hQoCHNraWxsaW9uGARkb21lABkcFQAVABUSAAAW5KL3/wcV8gEWiI/C/wcV4gEA + Jsz5n+gDHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFuj6FBbSBBb0BSbM+Z/oAzw26PoUABkc + FQAVABUSAAAW1qT3/wcV7AEW6pDC/wcVggEAJsD/n+gDHBUMGTUGCAAZGBByb29mX29yaWVudGF0 + aW9uFQwW6PoUFtIEFvQFJsD/n+gDPDbo+hQAGRwVABUAFRIAABbCpvf/BxXsARbskcL/BxWCAQAm + tIWg6AMcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbo+hQWsDAWsggmtIWg6AM8Nvz2FCgHI0QyNTE1 + MRgHIzAwMDAwMAAZHBUAFQAVEgAAFq6o9/8HFfABFu6Swv8HFdYBACbOjqDoAxwVChk1BggEGRgL + cm9vZl9oZWlnaHQVDBbo+hQWsgcWuggmzo6g6AMm5o2g6AMcGAgAAAAAAAAcQBgIAAAAAAAA8D8W + wPoUKAgAAAAAAAAcQBgIAAAAAAAA8D8AGSwVBBUEFQIAFQAVBBUSAAAWnqr3/wcV7gEWxJTC/wcV + ggIAFsa6xR0W6PoUJrST9NkDFuyCrA4UQgAZ/CYmoJag6AMcFQwZNQYIABkYAmlkFQwWqP0UFrqk + 8wUW8NnSASaglqDoAzw2ACggMDhiY2U5Mzc3NjViNGZmZjAyMDAxNDY4ZjU3ODQ1NjEYIDA4YmMz + NjZkMzQ5ODJmZmYwMjAwNDliYTc0MDVlNWM5ABkcFQAVABUSAAAWjKz3/wcVkAIWxpbC/wcV3gkA + JpDw8ukDHBUMGTUGCAAZGAhnZW9tZXRyeRUMFqj9FBayu+4RFoCttgomkPDy6QM8NgAogwIAAAAA + BgAAAAIAAAAAAwAAAAEAAAAIwFEDOOc8upvAQ3hpPof7DMBRAzkDVsyVwEN4hI5vmezAUQMy5nG5 + gcBDeISZV1R7wFEDMuUvmiHAQ3iDZKPuh8BRAzLh1JvOwEN4gI4v2QzAUQMy3GC+h8BDeHuy/sVt + wFEDMtA25JnAQ3hr1GRww8BRAzjnPLqbwEN4aT6H+wwAAAAAAwAAAAEAAAAGwFEDKuREuJfAQ3h7 + yM46i8BRAyruVbORwEN4hK8myZjAUQMqkaQB0sBDeISnmg1dwFEDEUiSQAnAQ3iE+PikwsBRAxE5 + 5CdcwEN4fBh/UsbAUQMq5ES4l8BDeHvIzjqLGE0AAAAAAwAAAAEAAAAEwFDjrMn4BjbAQ4N/iHZb + p8BQ468GfciDwEODexHvFc3AUOOxwGxsOsBDg35eqrBCwFDjrMn4BjbAQ4N/iHZbpwAZHBUAFQAV + KAAAFpyu9/8HFdwEFqSgwv8HFb4pACbwqbX0AxwVCBk1BggEGSgEYmJveAR4bWluFQwWqP0UFuav + OBb44DIm8Km19AMmkJ2p9AMcGAQFAIfCGAQiaIjCFgAoBAUAh8IYBCJoiMIAGSwVBBUEFQIAFQAV + BBUSAAAW+LL3/wcVkAIW4snC/wcV7gEAJr6K6PQDHBUIGTUGCAQZKARiYm94BHhtYXgVDBao/RQW + 3q44FpbhMia+iuj0AyaI/tv0AxwYBPr/hsIYBPlniMIWACgE+v+GwhgE+WeIwgAZLBUEFQQVAgAV + ABUEFRIAABaItff/BxWQAhbQy8L/BxXuAQAm9Mma9QMcFQgZNQYIBBkoBGJib3gEeW1pbhUMFqj9 + FBb+yTgWovsyJvTJmvUDJp7fjvUDHBgECmQbwhgE70QcwhYAKAQKZBvCGATvRBzCABksFQQVBBUC + ABUAFQQVEgAAFpi39/8HFZACFr7Nwv8HFe4BACaYys31AxwVCBk1BggEGSgEYmJveAR5bWF4FQwW + qP0UFu7QOBbugDMmmMrN9QMmwNrB9QMcGAS7YxvCGATTRBzCFgAoBLtjG8IYBNNEHMIAGSwVBBUE + FQIAFQAVBBUSAAAWqLn3/wcVkAIWrM/C/wcV7gEAJu7b9PUDHBUCGTUGCAQZGAd2ZXJzaW9uFQwW + qP0UFsgFFvwGJu7b9PUDJq7b9PUDHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUC + ABUAFQQVEgAAFri79/8HFewBFprRwv8HFe4BACbq4vT1AxwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAhwcm9wZXJ0eRUMFqj9FBbYBhaMCCbq4vT1Ayaq4vT1AxwYABgAFgAoABgAABksFQQV + BBUCABUAFQQVEgAAFqS99/8HFewBFojTwv8HFV4AJvrr9PUDHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50B2RhdGFzZXQVDBao/RQW0p4BFr5nJvrr9PUDJrbq9PUDHDYAKA1PcGVuU3RyZWV0 + TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUSAAAWkL/3/wcV/gEW5tPC + /wcVwgUAJvTR9fUDHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFqj9 + FBaQkbMDFvi4Xyb00fX1Azw2ACgMdzk5NzY0MjA3NUAxGAwwNDM0MWU0ZGMyZmMAGRwVABUAFRIA + ABaOwff/BxWQAhao2cL/BxXeBAAmvP3V9gMcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQL + dXBkYXRlX3RpbWUVDBao/RQWuOwHFsyVAya8/dX2AybsitX2Axw2ACgYMjAyNC0xMS0yMVQwMTow + NTo1Ny4wMDBaGBgyMDEyLTA4LTA2VDE1OjI2OjQzLjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAWnsP3 + /wcV/gEWht7C/wcVvgcAJojJ2fYDHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZp + ZGVuY2UVDBao/RQWhJoiFoyqICaIydn2Aya4oNj2AxwYCAAAAAAAAPA/GAjNzMzMzMzkPxbmpQEo + CAAAAAAAAPA/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRIAABacxff/BxWQAhbE5cL/BxWQAwAm + rMv49gMcFQIZNQYIBBkYBWxldmVsFQwWqP0UFsgVFvYTJqzL+PYDJsTK+PYDHBgECgAAABgE//// + /xb89xQoBAoAAAAYBP////8AGSwVBBUEFQIAFQAVBBUSAAAWrMf3/wcV/AEW1OjC/wcVkgIAJtzg + +PYDHBUMGTUGCAQZGAdzdWJ0eXBlFQwWqP0UFoxuFpBZJtzg+PYDJrre+PYDHDaEthQoDnRyYW5z + cG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUSAAAWqMn3/wcV/gEW5urC/wcV + 0gMAJrS8+fYDHBUMGTUGCAQZGAVjbGFzcxUMFqj9FBbebBaMWia0vPn2AybKt/n2Axw26r4UKAl3 + YXJlaG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUSAAAWpsv3/wcV/gEWuO7C/wcV2AMA + JoKU+vYDHBUKGTUGCAQZGAZoZWlnaHQVDBao/RQWnIQBFp5qJoKU+vYDJtaR+vYDHBgIAAAAAAAA + XEAYCAAAAAAAAPA/FoynFCgIAAAAAAAAXEAYCAAAAAAAAPA/ABksFQQVBBUCABUAFQQVEgAAFqTN + 9/8HFfwBFpDywv8HFaIDACaQ6P32AxwVDBk1BggEGSgFbmFtZXMHcHJpbWFyeRUMFqj9FBao4AcW + oOgDJpDo/fYDJvT7+vYDHDa+1BQoEsOTcHRpY2EgZGVsIFBhcnF1ZRgDMS0yABksFQQVBBUCABUA + FQQVEgAAFqDP9/8HFf4BFrL1wv8HFdIFACb85P72AxwVDBklBgQZSAVuYW1lcwZjb21tb24Ja2V5 + X3ZhbHVlA2tleRUMFrT9FBbOXRb8PSb85P72AyaU5P72Axw2lv0UKAJpdBgCZW4AGSwVBBUEFQIA + FQAVBBUSAAAWntH3/wcV/gEWhPvC/wcVsgEAJtKk//YDHBUMGSUGBBlIBW5hbWVzBmNvbW1vbglr + ZXlfdmFsdWUFdmFsdWUVDBa0/RQWnnYWtEUm0qT/9gMmkKL/9gMcNpb9FCgiU2N1b2xhIGRpIEl0 + YWxpYW5vIERhbnRlIEFsaWdoaWVyaRgLQkJWQSBGcmFuY2UAGSwVBBUEFQIAFQAVBBUSAAAWnNP3 + /wcV/gEWtvzC/wcVlgQAJsDo//YDHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2 + YXJpYW50FQwWvP0UFux0FppGJsDo//YDJsTn//YDHDaK+hQoBXNob3J0GAlhbHRlcm5hdGUAGSwV + BBUEFQIAFQAVBBUSAAAWmtX3/wcV/gEWzIDD/wcVnAMAJq6ugPcDHBUMGSUGBBlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFrz9FBbScxaWRCauroD3AyberYD3Axw2rP0UKAJl + cxgCZW4AGSwVBBUEFQIAFQAVBBUSAAAWmNf3/wcV/gEW6IPD/wcVmgEAJoCXgfcDHBUMGSUGBBlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFrz9FBb4tAEWpG0mgJeB9wMm9PGA9wMc + Nor6FCgNw5puaWNhO0dyZW1pbxgGQUNJUEFOABksFQQVBBUCABUAFQQVEgAAFpbZ9/8HFf4BFoKF + w/8HFcQEACaY34H3AxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRs + aXN0B2VsZW1lbnQVDBa8/RQWgHMWrEMmmN+B9wM8Nrz9FAAZHBUAFQAVEgAAFpTb9/8HFf4BFsaJ + w/8HFYIBACbEooL3AxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFrz9 + FBb0chayQybEooL3Azw2vP0UABkcFQAVABUSAAAWkt33/wcV/gEWyIrD/wcVggEAJvblgvcDHBUA + GTUGCAAZGAloYXNfcGFydHMVDBao/RQWwtQCFpwTJvblgvcDPBgBARgBABYAKAEBGAEAABkcFQAV + ABUSAAAWkN/3/wcV9gEWyovD/wcVggEAJpL5gvcDHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUM + Fqj9FBa61AIWlgcmkvmC9wM8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABaG4ff/BxXsARbMjMP/ + BxWCAQAmroGD9wMcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBao/RQW9EkWhj8mroGD9wMmqICD9wMc + GAQcAAAAGAQBAAAAFtLYFCgEHAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABby4vf/BxX+ARbO + jcP/BxWSAgAmrr+D9wMcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBao/RQW0gQW + 9AUmrr+D9wM8Nqj9FAAZHBUAFQAVEgAAFvDk9/8HFewBFuCPw/8HFYIBACaixYP3AxwVChk1BggA + GRgKbWluX2hlaWdodBUMFqj9FBboBBaKBiaixYP3AzwYCAAAAAAAABhAGAgAAAAAAAAYQBam/RQo + CAAAAAAAABhAGAgAAAAAAAAYQAAZHBUAFQAVEgAAFtzm9/8HFewBFuKQw/8HFaIBACasy4P3AxwV + Ahk1BggAGRgJbWluX2Zsb29yFQwWqP0UFtIEFvQFJqzLg/cDPDao/RQAGRwVABUAFRIAABbI6Pf/ + BxXsARaEksP/BxWCAQAmoNGD9wMcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFqj9FBb0RxaCHSag + 0YP3Azw2nvgUKAcjRkZGRkZGGAcjMDAwMDAwABkcFQAVABUSAAAWtOr3/wcV/AEWhpPD/wcV4gIA + JqLug/cDHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBao/RQWyiQWnBEmou6D9wM8Ntb6FCgE + d29vZBgFYnJpY2sAGRwVABUAFRIAABaw7Pf/BxX0ARbolcP/BxXoAQAmvv+D9wMcFQwZNQYIABkY + DXJvb2ZfbWF0ZXJpYWwVDBao/RQWgBIWoAkmvv+D9wM8Nrz8FCgKcm9vZl90aWxlcxgIY29uY3Jl + dGUAGRwVABUAFRIAABak7vf/BxXyARbQl8P/BxWAAgAm3oiE9wMcFQwZNQYIABkYCnJvb2Zfc2hh + cGUVDBao/RQWhCcW2hEm3oiE9wM8NsD6FCgIc2tpbGxpb24YBGRvbWUAGRwVABUAFRIAABaW8Pf/ + BxX6ARbQmcP/BxW6AgAmuJqE9wMcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWqP0UFsYGFvoG + JriahPcDPBgIAAAAAABAckAYCAAAAAAAADZAFpL9FCgIAAAAAABAckAYCAAAAAAAADZAABkcFQAV + ABUSAAAWkPL3/wcV7gEWipzD/wcVogEAJrKhhPcDHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9u + FQwWqP0UFtoGFowHJrKhhPcDPBgGYWNyb3NzGAZhY3Jvc3MWlv0UKAZhY3Jvc3MYBmFjcm9zcwAZ + HBUAFQAVEgAAFv7z9/8HFfABFqydw/8HFbIBACa+qIT3AxwVDBk1BggAGRgKcm9vZl9jb2xvchUM + Fqj9FBboEBbUCya+qIT3Azw2uPwUKAcjRkZGRkZGGAcjMDAwMDAwABkcFQAVABUSAAAW7vX3/wcV + 9gEW3p7D/wcVqgIAJpK0hPcDHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFqj9FBaWHxb8DSaStIT3 + AzwYCAAAAAAAAAhAGAgAAAAAAADwPxbg+hQoCAAAAAAAAAhAGAgAAAAAAADwPwAZHBUAFQAVEgAA + FuT39/8HFfgBFoihw/8HFYIDABbCq7sdFqj9FCaglqDoAxbuq+QOFEQAGfwmJo7ChPcDHBUMGTUG + CAAZGAJpZBUMFvSoFRbmxf8FFurj2AEmjsKE9wM8NgAoIDA4YmNlOWU1YjNiOTRmZmYwMjAwYjA3 + ODFkYjM0ODIyGCAwOGJjMzY0MTI0ZGEwZmZmMDIwMDBiM2NiZDZkY2M1YQAZHBUAFQAVEgAAFtz5 + 9/8HFZACFoqkw/8HFd4JACb4pd34AxwVDBk1BggAGRgIZ2VvbWV0cnkVDBb0qBUW/prCERa4r5sK + Jvil3fgDPDYAKK8OAAAAAAYAAAACAAAAAAMAAAAHAAAAMMBQ5KyMUAT7wEOCv0yxiXrAUOStNVfQ + ocBDgsYUS+dfwFDkqxwNfMDAQ4LGnd6iuMBQ5KhSmgDIwEOCxz4XksTAUOSkq0WTiMBDgsgXW2ZY + wFDkpON5t3zAQ4LKVtDHLcBQ5KHvqXCnwEOCywinbm7AUOShtwns6cBDgsjDUtCHwFDkmL1mJ3zA + Q4LK4hEBsMBQ5Jg7YChfwEOCxbB42TDAUOShKG60E8BDgsOUPubGwFDkoMp64vXAQ4K/0TvHVsBQ + 5JiBAEWgwEOCwcUxzdjAUOSXRtkCZcBDgrUzUxOjwFDkmFmTGU3AQ4K08rtz38BQ5JfqAZD6wEOC + sHL58qDAUOSXXRPXTcBDgrCTsSJMwFDklvXlysvAQ4KsV+I/JcBQ5Jd9ywb6wEOCrDjYjqLAUOSW + 6VCREsBDgqYIPOVkwFDkm+sYEW/AQ4Kk5Sc2psBQ5Ju4wyqNwEOCostxgvrAUOSgdwNsnMBDgqG5 + +YtywFDkoElLo23AQ4KfyjVC2MBQ5JvsWjDOwEOCoMQwRhnAUOSbpXf0LcBDgp3HJcPfwFDkn+ho + M8bAQ4Kc0+C9RcBQ5J9GgcSRwEOClfdNqdfAUOSkDLoipsBDgpTngzF4wFDkpRi+POfAQ4KgRlwE + 5MBQ5Kl2Gw9QwEOCn04OgMzAUOSp+PfOAsBDgqTecTn/wFDkp4mxxQrAQ4KlaNq07cBQ5Kg+eArU + wEOCrRck37PAUOSqzuCjQ8BDgqyGBWgfwFDkq1vOXPDAQ4KyhSLqEMBQ5KqfD/sgwEOCsq8UVSLA + UOSqxTsIFMBDgrROUMXrwFDkqhIiQXPAQ4K1cj00PsBQ5KpoHfaLwEOCuOgTejDAUOSrJbMX8MBD + gri7ndBgwFDkq2IY+czAQ4K7Kg0ZxMBQ5KuauH2KwEOCvXEPNtXAUOSj2SMcZcBDgr9A8w9XwFDk + pDyKysrAQ4LDQTLQN8BQ5KT1F26ywEOCwxZqpZDAUOSkxHAG+cBDgsEhnd95wFDkrIxQBPvAQ4K/ + TLGJegAAAAXAUOSpb2USqcBDgrZT5IOjwFDkourmk0fAQ4K326QAJcBQ5KMubdGVwEOCupMOZR7A + UOSpsuxQ98BDgrkLTuibwFDkqW9lEqnAQ4K2U+SDowAAAAXAUOSf16E8JcBDgrbmsXphwFDkmU/H + vnDAQ4K4aj84+8BQ5Jm55Wl8wEOCvLy0UNXAUOSgQb7nMcBDgrs5JpI7wFDkn9ehPCXAQ4K25rF6 + YQAAAAXAUOSm84nP+MBDgqV+qioLwFDkoWWrVYTAQ4KmuTzNEMBQ5KKP4mCzwEOCs3eRMRXAUOSo + Hiw68cBDgrI8/o4QwFDkpvOJz/jAQ4KlfqoqCwAAAAXAUOShec1LeMBDgq5Gz8gqwFDkmJUiO5TA + Q4KwUkLC88BQ5Jj6osjtwEOCtHudL1DAUOSh303Y0cBDgrJvU3TywFDkoXnNS3jAQ4KuRs/IKgAA + AAXAUOSgxJul48BDgqbnX/YKwFDkl+rYUI/AQ4Ko6Zi1bsBQ5Jg0qiu4wEOCq/1JbFvAUOShDtjg + 18BDgqn7EKz2wFDkoMSbpePAQ4Km51/2CgAAAAfAUOSkaQB0msBDgqCLJWKQwFDkpEkgBILAQ4Kf + ORXLQ8BQ5KLLcYL6wEOCn5BTn7rAUOSiu4FK7sBDgp7ojfNzwFDkoMwoYh/AQ4KfWcz68MBQ5KD7 + +QpCwEOCoVOiPoTAUOSkaQB0msBDgqCLJWKQAAAAAAMAAAACAAAAGsBQ5L0O6afPwEOCrlDgwyTA + UOS9R/SLWMBDgrCXDCCgwFDkvNjOYs/AQ4KwsQ1TpsBQ5L16SXI6wEOCtyZyWpDAUOS8FjDD7cBD + grd6VTC0wFDku+gNmvPAQ4K1oTcczcBQ5Lks3NfdwEOCtkZ4ilXAUOS5dJXUEsBDgrkmJts2wFDk + tet0V8HAQ4K5+zjw4sBQ5LWZqmCRwEOCtrYKEqjAUOS3tk+yxsBDgrY2iFJJwFDkt0+NBg3AQ4Ky + GcMfpcBQ5LbLAsgxwEOCsjjM0CjAUOS2j98FtMBDgq/Zdv87wFDkt28CFlvAQ4KvpXSZL8BQ5Ldi + 2DxtwEOCro1GpQDAUOS3C5pn9sBDgq6e5Fw2wFDkttPRo8zAQ4KuU2UB4sBQ5LW6zPAIwEOCrNg6 + vxnAUOSybTqV/sBDgqxdwXw3wFDkso7IhT/AQ4KqLI7URMBQ5LyvSFeIwEOCq6U02E/AUOS8jU8I + fMBDgq3VkMCtwFDkuCXhOxnAQ4KtMfzSTsBQ5LhOJScBwEOCr3Cbc47AUOS9Dumnz8BDgq5Q4MMk + AAAABcBQ5LtEDkzKwEOCs7MgU13AUOS7A3atBsBDgrFD2kpkwFDkuM+/xlTAQ4Kx0MgEEMBQ5LkQ + V2YYwEOCtEAODQnAUOS7RA5MysBDgrOzIFNdGE0AAAAAAwAAAAEAAAAEwFEAK9SaIKjAQ3d8KG+K + 0sBRACuSVQG6wEN3fPlP4pbAUQArdc+P9sBDd3xNWHhnwFEAK9SaIKjAQ3d8KG+K0gAZHBUAFQAV + KAAAFuz79/8HFdwEFuitw/8HFb4pACaKqo+DBBwVCBk1BggEGSgEYmJveAR4bWluFQwW9KgVFrCc + SBaq1z0miqqPgwQmsNX4ggQcGAS0AIfCGAQC0InCFgAoBLQAh8IYBALQicIAGSwVBBUEFQIAFQAV + BBUSAAAWyID4/wcVkAIWptfD/wcV7gEAJoCMzYMEHBUIGTUGCAQZKARiYm94BHhtYXgVDBb0qBUW + qKtIFqjlPSaAjM2DBCbarLaDBBwYBKAAh8IYBPTPicIWACgEoACHwhgE9M+JwgAZLBUEFQQVAgAV + ABUEFRIAABbYgvj/BxWQAhaU2cP/BxXuAQAmmLqLhAQcFQgZNQYIBBkoBGJib3gEeW1pbhUMFvSo + FRb61kkWkoI/Jpi6i4QEJoKS9IMEHBgElJwYwhgEPRgcwhYAKASUnBjCGAQ9GBzCABksFQQVBBUC + ABUAFQQVEgAAFuiE+P8HFZACFoLbw/8HFe4BACaovMqEBBwVCBk1BggEGSgEYmJveAR5bWF4FQwW + 9KgVFpDWSRbQgj8mqLzKhAQmlJSzhAQcGARwnBjCGAT6FxzCFgAoBHCcGMIYBPoXHMIAGSwVBBUE + FQIAFQAVBBUSAAAW+Ib4/wcVkAIW8NzD/wcV7gEAJqSX8oQEHBUCGTUGCAQZGAd2ZXJzaW9uFQwW + 9KgVFsgFFvwGJqSX8oQEJuSW8oQEHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUC + ABUAFQQVEgAAFoiJ+P8HFewBFt7ew/8HFe4BACagnvKEBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAhwcm9wZXJ0eRUMFvSoFRbYBhaMCCagnvKEBCbgnfKEBBwYABgAFgAoABgAABksFQQV + BBUCABUAFQQVEgAAFvSK+P8HFewBFszgw/8HFV4AJrCn8oQEHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50B2RhdGFzZXQVDBb0qBUW1nwW6lomsKfyhAQm7KXyhAQcNgAoDU9wZW5TdHJlZXRN + YXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABbgjPj/BxX+ARaq4cP/ + BxXCBQAm1oDzhAQcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW9KgV + FobCugMWzuBnJtaA84QEPDYAKAx3OTk4NjE4MTM5QDIYDDAwMTAzODhmYTg5YgAZHBUAFQAVEgAA + Ft6O+P8HFZACFuzmw/8HFcAEACasrduFBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1 + cGRhdGVfdGltZRUMFvSoFRaEkgYWmpoCJqyt24UEJqTh2oUEHDYAKBgyMDI0LTExLTIyVDEzOjIy + OjI0LjAwMFoYGDIwMTItMDQtMDdUMjA6NDQ6MDMuMDAwWgAZLBUEFQQVAgAVABUEFRIAABbukPj/ + BxX+ARas68P/BxW+BwAm4uLehQQcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlk + ZW5jZRUMFvSoFRao7yMWjuEhJuLi3oUEJr773IUEHBgIAAAAAAAA8D8YCAAAAAAQ6eM/FtxcKAgA + AAAAAADwPxgIAAAAABDp4z8AGSwVBBUEFQIAFQAVBBUSAAAW7JL4/wcVkAIW6vLD/wcVkAMAJprd + /oUEHBUCGTUGCAQZGAVsZXZlbBUMFvSoFRa4ChagCyaa3f6FBCbM3P6FBBwYBAIAAAAYBP////8W + yKcVKAQCAAAAGAT/////ABksFQQVBBUCABUAFQQVEgAAFvyU+P8HFfQBFvr1w/8HFZICACaS6v6F + BBwVDBk1BggEGRgHc3VidHlwZRUMFvSoFRaGPBb8MyaS6v6FBCbs5/6FBBw2oIgVKA50cmFuc3Bv + cnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEgAAFvCW+P8HFf4BFoz4w/8HFeAD + ACbaoP+FBBwVDBk1BggEGRgFY2xhc3MVDBb0qBUW1j0W7jUm2qD/hQQm6Jv/hQQcNsiKFSgJd2Fy + ZWhvdXNlGA9hbGxvdG1lbnRfaG91c2UAGSwVBBUEFQIAFQAVBBUSAAAW7pj4/wcV/gEW7PvD/wcV + vgMAJpzT/4UEHBUKGTUGCAQZGAZoZWlnaHQVDBb0qBUWtiQWzh8mnNP/hQQm1tH/hQQcGAgAAAAA + AAA6QBgIAAAAAAAA8D8W1JkVKAgAAAAAAAA6QBgIAAAAAAAA8D8AGSwVBBUEFQIAFQAVBBUSAAAW + 7Jr4/wcV/AEWqv/D/wcVogMAJuzXgIYEHBUMGTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwW9KgVFuqW + AhaylwEm7NeAhgQmpPH/hQQcNvCcFSgTw5NwdGljYSBXb2xmIENlbnRlchgMMzAgdml2aWVuZGFz + ABksFQQVBBUCABUAFQQVEgAAFuic+P8HFf4BFsyCxP8HFdwGACbWiIGGBBwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFvioFRakKxaKISbWiIGGBDw28KgVKAJlcxgCZW4AGRwV + ABUAFRIAABbmnvj/BxX+ARaoicT/BxWSAQAm4KmBhgQcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQV2YWx1ZRUMFvioFRbWMxaGJCbgqYGGBDw28KgVKAtOYXRpb24gQmFuaxgNQmFuY28g + TmFjacOzbgAZHBUAFQAVEgAAFuSg+P8HFf4BFrqKxP8HFeIBACbQzoGGBBwVDBklBgQZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFvyoFRbQMxamJCbQzoGGBCbmzYGGBBw2yqgV + KAhvZmZpY2lhbBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEgAAFuKi+P8HFf4BFpyMxP8HFbAC + ACaM8oGGBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBb8qBUW + hjMWxCMmjPKBhgQ8NvSoFSgCZXMYAmVuABkcFQAVABUSAAAW4KT4/wcV/gEWzI7E/wcVkgEAJtCV + goYEHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvyoFRb+PRaeLCbQ + lYKGBDw2yqgVKAVUb3BzeRgiQW50aWd1byBIb3NwaXRhbCBSZWdpb25hbCBkZSBBbGxlbgAZHBUA + FQAVEgAAFt6m+P8HFf4BFt6PxP8HFYQFACbuwYKGBBwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBb8qBUW2jIWrCMm7sGChgQ8NvyoFQAZHBUA + FQAVEgAAFtyo+P8HFf4BFuKUxP8HFYIBACaa5YKGBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQEc2lkZRUMFvyoFRbWMhaoIyaa5YKGBDw2/KgVABkcFQAVABUSAAAW2qr4/wcV/gEW + 5JXE/wcVggEAJsKIg4YEHBUAGTUGCAAZGAloYXNfcGFydHMVDBb0qBUW+NkCFqIKJsKIg4YEPBgB + ARgBABYAKAEBGAEAABkcFQAVABUSAAAW2Kz4/wcV8AEW5pbE/wcVggEAJuSSg4YEHBUAGTUGCAAZ + GA5pc191bmRlcmdyb3VuZBUMFvSoFRb02QIWlgcm5JKDhgQ8GAEAGAEAFgAoAQAYAQAAGRwVABUA + FRIAABbIrvj/BxXsARbol8T/BxWCAQAmgpuDhgQcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBb0qBUW + zBQWqBMmgpuDhgQm+pmDhgQcGAQPAAAAGAQBAAAAFvSiFSgEDwAAABgEAQAAAAAZLBUEFQQVAgAV + ABUEFRIAABa0sPj/BxX6ARbqmMT/BxWSAgAmoq2DhgQcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5k + ZXJncm91bmQVDBb0qBUW0gQW9AUmoq2DhgQ8NvSoFQAZHBUAFQAVEgAAFq6y+P8HFewBFvyaxP8H + FYIBACaWs4OGBBwVChk1BggAGRgKbWluX2hlaWdodBUMFvSoFRbSBBb0BSaWs4OGBDw29KgVABkc + FQAVABUSAAAWmrT4/wcV7AEW/pvE/wcVggEAJoq5g4YEHBUCGTUGCAAZGAltaW5fZmxvb3IVDBb0 + qBUW0gQW9AUmirmDhgQ8NvSoFQAZHBUAFQAVEgAAFoa2+P8HFewBFoCdxP8HFYIBACbawIOGBBwV + DBk1BggEGRgMZmFjYWRlX2NvbG9yFQwW9KgVFsgIFpQJJtrAg4YEJv6+g4YEHDbKqBUoByNGRkZG + RkYYByMwMDAwRkYAGSwVBBUEFQIAFQAVBBUSAAAW8rf4/wcV8AEWgp7E/wcV1gEAJobJg4YEHBUM + GTUGCAQZGA9mYWNhZGVfbWF0ZXJpYWwVDBb0qBUWlAYWyAcmhsmDhgQmksiDhgQcNuaoFSgFZ2xh + c3MYBWJyaWNrABksFQQVBBUCABUAFQQVEgAAFuK5+P8HFewBFtifxP8HFdgBACbaz4OGBBwVDBk1 + BggAGRgNcm9vZl9tYXRlcmlhbBUMFvSoFRagBRbCBibaz4OGBDwYCnJvb2ZfdGlsZXMYCnJvb2Zf + dGlsZXMW8KgVKApyb29mX3RpbGVzGApyb29mX3RpbGVzABkcFQAVABUSAAAWzrv4/wcV7AEWsKHE + /wcV0gEAJrbXg4YEHBUMGTUGCAQZGApyb29mX3NoYXBlFQwW9KgVFoILFvILJrbXg4YEJpzWg4YE + HDakphUoCHNraWxsaW9uGARmbGF0ABksFQQVBBUCABUAFQQVEgAAFrq9+P8HFfABFoKjxP8HFc4B + ACaO4oOGBBwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBb0qBUWgAkW+gcmjuKDhgQ8GAgAAAAA + ALBzQBgIAAAAAAAAAAAWvqgVKAgAAAAAALBzQBgIAAAAAAAAAAAAGRwVABUAFRIAABaqv/j/BxXu + ARbQpMT/BxWiAQAmiOqDhgQcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBb0qBUWhAcW7gYm + iOqDhgQ8GAZhY3Jvc3MYBmFjcm9zcxbeqBUoBmFjcm9zcxgGYWNyb3NzABkcFQAVABUSAAAWmMH4 + /wcV7gEW8qXE/wcVmgEAJvbwg4YEHBUMGTUGCAAZGApyb29mX2NvbG9yFQwW9KgVFogHFpwHJvbw + g4YEPDbeqBUoByNEQjg3NzYYByMwMDAwMDAAGRwVABUAFRIAABaGw/j/BxXuARaMp8T/BxW6AQAm + 9PiDhgQcFQoZNQYIBBkYC3Jvb2ZfaGVpZ2h0FQwW9KgVFoAKFuIKJvT4g4YEJpL4g4YEHBgIAAAA + AAAAEEAYCAAAAAAAAPA/FramFSgIAAAAAAAAEEAYCAAAAAAAAPA/ABksFQQVBBUCABUAFQQVEgAA + FvTE+P8HFfABFsaoxP8HFeIBABbY4NcdFvSoFSaOwoT3AxbmwP8OFEYAGfwmJvSChIYEHBUMGTUG + CAAZGAJpZBUMFuSHFRaqnfYFFrK/2wEm9IKEhgQ8NgAoIDA4YmNlOWJkYjY1NTFmZmYwMjAwNTVi + ZjYyNWUwNjI3GCAwOGJiMmM5MjkyNjU4ZmZmMDIwMDNhZWFjOWE0NDBjNgAZHBUAFQAVEgAAFuTG + +P8HFZACFqiqxP8HFd4JACamwt+HBBwVDBk1BggAGRgIZ2VvbWV0cnkVDBbkhxUWzLn7EBbO/PYJ + JqbC34cEPDYAKPEFAAAAAAYAAAAIAAAAAAMAAAABAAAABcBSPAoy9EkTwEJG2+IThe/AUjwKutmF + QsBCRt3l+cR9wFI8CYR4oCXAQkbeuV5a/8BSPAj8KAQrwEJG3LV4HHHAUjwKMvRJE8BCRtviE4Xv + AAAAAAMAAAABAAAABcBSPAtJdL4YwEJG378X2GTAUjwL0Vn6R8BCRuHCJ1ddwFI8CpqNtWDAQkbi + lmKtdMBSPAoSqHkwwEJG4JJ8bubAUjwLSXS+GMBCRt+/F9hkAAAAAAMAAAABAAAABcBSPAyarZXQ + wEJG2kVbU+TAUjwNIpLR/8BCRtxJQZJywFI8C+vGjRjAQkbdHKYo9MBSPAtj4VDowEJG2xi/6mbA + UjwMmq2V0MBCRtpFW1PkAAAAAAMAAAABAAAABcBSPA22NohSwEJG3mcpBAXAUjwOPhvEgsBCRuBq + OIL+wFI8DQdPf5rAQkbhPnPZFsBSPAx/akNrwEJG3zqNmojAUjwNtjaIUsBCRt5nKQQFAAAAAAMA + AAABAAAABcBSPA7Rv3rVwEJG2KijIdnAUjwPWhAWzsBCRtqsiWBmwFI8DiND0efAQkbbf+326cBS + PA2bXpW4wEJG2XwHuFvAUjwO0b961cBCRtiooyHZAAAAAAMAAAABAAAABcBSPA/izBKTwEJG3P2c + eHHAUjwQarFOwsBCRt8Bgrb/wFI8DzRQaaXAQkbf1OdNgsBSPA6r/82rwEJG3dEBDvTAUjwP4swS + k8BCRtz9nHhxAAAAAAMAAAABAAAABcBSPBD2yEjawEJG11W8yvfAUjwRfq2FCcBCRtlZowmFwFI8 + EEfhQCHAQkbaLQegB8BSPA+//APywEJG2CkhYXrAUjwQ9shI2sBCRtdVvMr3AAAAAAMAAAABAAAA + BcBSPBH5/YeAwEJG2wtT8RnAUjwSgk4jesBCRt0OY3ASwFI8EUuB3pLAQkbd4cgGlMBSPBDDnKJj + wEJG2964h5vAUjwR+f2HgMBCRtsLU/EZGE0AAAAAAwAAAAEAAAAEwFDtYQ/kE+HAQuMPTFEmE8BQ + 7WD6LS5EwELjEM1BH/nAUO1gi6oR1cBC4w/+DrtswFDtYQ/kE+HAQuMPTFEmEwAZHBUAFQAVJgAA + FvTI+P8HFb4EFoa0xP8HFbYnACbmgfWRBBwVCBk1BggEGSgEYmJveAR4bWluFQwW5IcVFq7bUxaa + o0cm5oH1kQQm9L7WkQQcGARuAIfCGARD9JHCFgAoBG4Ah8IYBEP0kcIAGSwVBBUEFQIAFQAVBBUS + AAAWss34/wcVkAIWvNvE/wcV7gEAJvKVvJIEHBUIGTUGCAQZKARiYm94BHhtYXgVDBbkhxUWvsZT + FuqTRybylbySBCaO4p2SBBwYBGYAh8IYBDf0kcIWACgEZgCHwhgEN/SRwgAZLBUEFQQVAgAVABUE + FRIAABbCz/j/BxWQAhaq3cT/BxXuAQAm+PXkkgQcFQgZNQYIABkoBGJib3gEeW1pbhUMFuSHFRao + pFQWttszJvj15JIEPBgEHXAPwhgEBLAawhYAKAQdcA/CGAQEsBrCABkcFQAVABUSAAAW0tH4/wcV + kAIWmN/E/wcV7gEAJq7RmJMEHBUIGTUGCAAZKARiYm94BHltYXgVDBbkhxUWqKRUFtTeMyau0ZiT + BDwYBANwD8IYBO6vGsIWACgEA3APwhgE7q8awgAZHBUAFQAVEgAAFuLT+P8HFZACFobhxP8HFe4B + ACbCsMyTBBwVAhk1BggEGRgHdmVyc2lvbhUMFuSHFRbIBRb8BibCsMyTBCaCsMyTBBwYBAAAAAAY + BAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABby1fj/BxXsARb04sT/BxXuAQAm + vrfMkwQcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbkhxUW2AYWjAgm + vrfMkwQm/rbMkwQcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABbe1/j/BxXsARbi5MT/BxVe + ACbOwMyTBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwW5IcVFoaZBBas + 1QImzsDMkwQmir/MkwQcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZ + LBUEFQQVAgAVABUEFRIAABbK2fj/BxX+ARbA5cT/BxXCBQAmtpTPkwQcFQwZJQYAGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW5IcVFsSWigMW0NSLASa2lM+TBDw2ACgMdzk5OTA2 + ODU0M0AxGAwwMDAwYzY4ZGZhOWYAGRwVABUAFRIAABbI2/j/BxWQAhaC68T/BxWYBAAm5o7clAQc + FQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbkhxUWqNIZFrKFBybm + jtyUBCaG6dqUBBw2ACgYMjAyNC0xMi0wNVQwMDoxODoxMC4wMDBaGBgyMDExLTExLTE1VDE4OjM4 + OjU3LjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAW2N34/wcVggIWmu/E/wcVvgcAJozz45QEHBUKGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbkhxUWiNUdFt66GiaM8+OUBCa4 + 7uGUBBwYCAAAAAAAAPA/GAgAAABAHOvePxbG6wcoCAAAAAAAAPA/GAgAAABAHOvePwAZLBUEFQQV + AgAVABUEFRIAABba3/j/BxWQAhbY9sT/BxWYAwAm3qn8lAQcFQIZNQYIBBkYBWxldmVsFQwW5IcV + FrQGFugHJt6p/JQEJpap/JQEHBgEAQAAABgE/////xbAhxUoBAEAAAAYBP////8AGSwVBBUEFQIA + FQAVBBUSAAAW6uH4/wcV7AEW8PnE/wcVggIAJpyz/JQEHBUMGTUGCAQZGAdzdWJ0eXBlFQwW5IcV + FsArFsQnJpyz/JQEJv6w/JQEHDbG6hQoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwV + BBUEFQIAFQAVBBUSAAAW1uP4/wcV/gEW8vvE/wcVvgMAJq7c/JQEHBUMGTUGCAQZGAVjbGFzcxUM + FuSHFRaWLRbkKCau3PyUBCbC2PyUBBw20usUKAl3YXJlaG91c2UYCmFwYXJ0bWVudHMAGSwVBBUE + FQIAFQAVBBUSAAAW1OX4/wcV/gEWsP/E/wcVkAMAJpSC/ZQEHBUKGTUGCAQZGAZoZWlnaHQVDBbk + hxUWmAcWoggmlIL9lAQmpoH9lAQcGAgAAAAAACByQBgIAAAAAAAAAEAWvIcVKAgAAAAAACByQBgI + AAAAAAAAAEAAGSwVBBUEFQIAFQAVBBUSAAAW0uf4/wcV8AEWwILF/wcVggIAJsqx/ZQEHBUMGTUG + CAQZKAVuYW1lcwdwcmltYXJ5FQwW5IcVFt5nFpY/Jsqx/ZQEJsiJ/ZQEHDbOgxUoGGVzY3VlbGEg + cHJpbWFyaWEgbnJvIDIxMRgUNSBDb21pc2FyaWEgUXVpcmlodWUAGSwVBBUEFQIAFQAVBBUSAAAW + wun4/wcV/gEWwoTF/wcVjgYAJt7I/ZQEHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUD + a2V5FQwW6ocVFrgWFsgTJt7I/ZQEPDbehxUoAmVzGAJlbgAZHBUAFQAVEgAAFsDr+P8HFfwBFtCK + xf8HFZoBACam3P2UBBwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW6ocV + Fq4aFrAVJqbc/ZQEPDbehxUoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEgAAFrzt + +P8HFf4BFuqLxf8HFY4CACbA8v2UBBwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQH + dmFyaWFudBUMFvCHFRbmGRbyFCbA8v2UBCbW8f2UBBw22ocVKAhvZmZpY2lhbBgJYWx0ZXJuYXRl + ABksFQQVBBUCABUAFQQVEgAAFrrv+P8HFf4BFviNxf8HFeQBACbIhv6UBBwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbwhxUWuBkWrhQmyIb+lAQ8NuSHFSgCZXMY + AmVuABkcFQAVABUSAAAWuPH4/wcV/gEW3I/F/wcVmgEAJqid/pQEHBUMGSUGBBlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvCHFRaMHBbEFiaonf6UBCb2mv6UBBw22ocVKAhMdWNh + aW9saRgdQmFuY28gZGUgbGEgTmFjacOzbiBBcmdlbnRpbmEAGSwVBBUEFQIAFQAVBBUSAAAWtvP4 + /wcV/gEW9pDF/wcVnAMAJrqx/pQEHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdi + ZXR3ZWVuBGxpc3QHZWxlbWVudBUMFvCHFRb2GBaEFCa6sf6UBDw28IcVABkcFQAVABUSAAAWtPX4 + /wcV/gEWkpTF/wcVggEAJr7F/pQEHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARz + aWRlFQwW8IcVFvIYFoQUJr7F/pQEPDbwhxUAGRwVABUAFRIAABay9/j/BxX+ARaUlcX/BxWCAQAm + wtn+lAQcFQAZNQYIABkYCWhhc19wYXJ0cxUMFuSHFRbi1QIWlgcmwtn+lAQ8GAEAGAEAFgAoAQAY + AQAAGRwVABUAFRIAABaw+fj/BxXsARaWlsX/BxWCAQAm2OD+lAQcFQAZNQYIABkYDmlzX3VuZGVy + Z3JvdW5kFQwW5IcVFuLVAhaWBybY4P6UBDwYAQAYAQAWACgBABgBAAAZHBUAFQAVEgAAFpz7+P8H + FewBFpiXxf8HFYIBACa+6P6UBBwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFuSHFRacBxbQCCa+6P6U + BCbu5/6UBBwYBAMAAAAYBAEAAAAWkIcVKAQDAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEgAAFoj9 + +P8HFfABFpqYxf8HFeIBACa+8P6UBBwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUM + FuSHFRbSBBb0BSa+8P6UBDw25IcVABkcFQAVABUSAAAW+P74/wcV7AEW/JnF/wcVggEAJrL2/pQE + HBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW5IcVFtIEFvQFJrL2/pQEPDbkhxUAGRwVABUAFRIAABbk + gPn/BxXsARb+msX/BxWCAQAmpvz+lAQcFQIZNQYIABkYCW1pbl9mbG9vchUMFuSHFRbSBBb0BSam + /P6UBDw25IcVABkcFQAVABUSAAAW0IL5/wcV7AEWgJzF/wcVggEAJpqC/5QEHBUMGTUGCAAZGAxm + YWNhZGVfY29sb3IVDBbkhxUW8gQWlAYmmoL/lAQ8GAcjRkZBNTAwGAcjRkZBNTAwFuKHFSgHI0ZG + QTUwMBgHI0ZGQTUwMAAZHBUAFQAVEgAAFryE+f8HFewBFoKdxf8HFZ4BACauiP+UBBwVDBk1BggA + GRgPZmFjYWRlX21hdGVyaWFsFQwW5IcVFtIEFvQFJq6I/5QEPDbkhxUAGRwVABUAFRIAABaohvn/ + BxXsARagnsX/BxWCAQAmoo7/lAQcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbkhxUW0gQW9AUm + oo7/lAQ8NuSHFQAZHBUAFQAVEgAAFpSI+f8HFewBFqKfxf8HFYIBACaWlP+UBBwVDBk1BggAGRgK + cm9vZl9zaGFwZRUMFuSHFRbwBBaSBiaWlP+UBDwYBmdhYmxlZBgGZ2FibGVkFuKHFSgGZ2FibGVk + GAZnYWJsZWQAGRwVABUAFRIAABaAivn/BxXsARakoMX/BxWaAQAmqJr/lAQcFQoZNQYIABkYDnJv + b2ZfZGlyZWN0aW9uFQwW5IcVFtIEFvQFJqia/5QEPDbkhxUAGRwVABUAFRIAABbsi/n/BxXsARa+ + ocX/BxWCAQAmnKD/lAQcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbkhxUW0gQW9AUmnKD/ + lAQ8NuSHFQAZHBUAFQAVEgAAFtiN+f8HFewBFsCixf8HFYIBACaQpv+UBBwVDBk1BggAGRgKcm9v + Zl9jb2xvchUMFuSHFRbKBRbcBiaQpv+UBDw23IcVKAcjODZBNkIzGAcjMDAwMDAwABkcFQAVABUS + AAAWxI/5/wcV7AEWwqPF/wcV1gEAJuys/5QEHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFuSHFRbS + BBb0BSbsrP+UBDw25IcVABkcFQAVABUSAAAWsJH5/wcV7AEWmKXF/wcVggEAFuCLkB0W5IcVJvSC + hIYEFuyv+w4USAAZ/CYm4LL/lAQcFQwZNQYIABkYAmlkFQwWhKgTFuCltwUWjpjLASbgsv+UBDw2 + ACggMDhiYjJkZDdiNmRiNWZmZjAyMDAyZWUxYzRiNjIyNGIYIDA4YmIyZDgzNjAwMDBmZmYwMjAw + MTIxYzZiMmYzZTE0ABkcFQAVABUQAAAWnJP5/wcV8gEWmqbF/wcV1ggAJu7KypYEHBUMGTUGCAAZ + GAhnZW9tZXRyeRUMFoSoExaa/PgPFp6Oywkm7srKlgQ8NgAozQYAAAAAAwAAAAUAAAAZwFIUz544 + ZMvAQfspPDlsMsBSFNcWZ0qSwEH7N0a+KnPAUhTRKHwgDMBB+z+LMEpLwFIUzfEkmurAQfs5fqbP + DMBSFMzUWYkIwEH7OwtuyQvAUhTN8Y/6tMBB+z0jdv2NwFIUzFpLpfHAQfs/W1+iJ8BSFMsBhhH9 + wEH7PNIYZijAUhTKl2hm8sBB+z1lvBx7wFIUy+bzv4DAQfs/3WWhRcBSFMp7ubTCwEH7Qdc65NjA + UhTD9s/VlsBB+zWQ24T2wFIUxZZ3pirAQfszTgslzsBSFMlzEJjUwEH7OpKjBVPAUhTMLdX8IMBB + +zbGZap/wFIUyvYy96TAQfs0fAiPG8BSFMkV84dMwEH7MOjWF8/AUhTJjDsMRsBB+zBGGOkFwFIU + yp4eY5jAQfsuyGpnfcBSFMfXLyZewEH7KZDzAevAUhTMfRu0kcBB+yMVrr3uwFIUzqrzXjHAQfsn + LkIyqsBSFM20vrkOwEH7KIYxBwnAUhTOvJEVZ8BB+yp19U+jwFIUz544ZMvAQfspPDlsMgAAAAnA + UhTS16jI4sBB+zUJzQhcwFIU0oKD01/AQfs1fz3NwcBSFNNF+DHVwEH7NvBXFZHAUhTRo8wig8BB + +zk01PPjwFIU0D4F9Q3AQfs2kLXFScBSFM/L8C37wEH7Ny9BNivAUhTRmiaHU8BB+zqXq4LQwFIU + 1AMh83DAQfs3QAgtzMBSFNLXqMjiwEH7NQnNCFwAAAAFwFIU0c1SLcrAQfszXSSeRcBSFNFiySL0 + wEH7M/GfFC3AUhTRw0Ey0MBB+zSnp3lWwFIU0i3KPabAQfs0Ey0DbsBSFNHNUi3KwEH7M10knkUA + AAAHwFIUzfhF91vAQfssKHz2zMBSFMuodP6wwEH7L0jC53HAUhTOI3mBzMBB+zQWiAHCwFIUz/f6 + eAHAQfsxnTD9z8BSFNDhmeNrwEH7M2ItG8LAUhTRXOnl4sBB+zK7Pi8QwFIUzfhF91vAQfssKHz2 + zAAAAAXAUhTMLCh898BB+ygDVEhXwFIUysxBjJLAQfsp3h/baMBSFMumXB+8wEH7K4aWh5bAUhTN + BkMQIMBB+ymryvSFwFIUzCwofPfAQfsoA1RIVxhNAAAAAAMAAAABAAAABMBR9DzIUe2QwEIkdQGc + qnDAUfQ84huZxcBCJHQT/gHjwFH0PaZ/16HAQiR1QNTh3sBR9DzIUe2QwEIkdQGcqnAAGRwVABUA + FSQAABaOlfn/BxWgBBbwrsX/BxWuJQAmjNmVoAQcFQgZNQYIABkoBGJib3gEeG1pbhUMFoSoExbg + pE0W3oItJozZlaAEPBgEB3CPwhgEB9iQwhYAKAQHcI/CGAQH2JDCABkcFQAVABUQAAAWrpn5/wcV + 8gEWntTF/wcV1gEAJurbwqAEHBUIGTUGCAAZKARiYm94BHhtYXgVDBaEqBMW3qRNFqb8LCbq28Kg + BDwYBPpvj8IYBPvXkMIWACgE+m+PwhgE+9eQwgAZHBUAFQAVEAAAFqCb+f8HFfIBFvTVxf8HFdYB + ACaQ2O+gBBwVCBk1BggAGSgEYmJveAR5bWluFQwWhKgTFt6kTRa4wC8mkNjvoAQ8GAQTcA/CGAQK + QBLCFgAoBBNwD8IYBApAEsIAGRwVABUAFRAAABaSnfn/BxXyARbK18X/BxXWAQAmyJifoQQcFQgZ + NQYIABkoBGJib3gEeW1heBUMFoSoExbgpE0W0MMvJsiYn6EEPBgE+G8PwhgE+D8SwhYAKAT4bw/C + GAT4PxLCABkcFQAVABUQAAAWhJ/5/wcV8gEWoNnF/wcV1gEAJtjczqEEHBUCGTUGCAQZGAd2ZXJz + aW9uFQwWhKgTFvwEFp4GJtjczqEEJpjczqEEHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABks + FQQVBBUCABUAFQQVEAAAFvag+f8HFdIBFvbaxf8HFdYBACb24s6hBBwVDBklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFoSoExb+BRagByb24s6hBCa24s6hBBwYABgAFgAoABgA + ABksFQQVBBUCABUAFQQVEAAAFsii+f8HFdIBFszcxf8HFVYAJprrzqEEHBUMGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaEqBMWjOQEFtLyAiaa686hBCbW6c6hBBw2ACgNT3Bl + blN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFpqk+f8H + FeIBFqLdxf8HFfYEACao3NGhBBwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRf + aWQVDBaEqBMWiPXXAhbOro4BJqjc0aEEPDYAKAx3OTg5NDAyOTkxQDEYDDAwMDBlYjE2NGJkMAAZ + HBUAFQAVEAAAFvyl+f8HFfIBFpjixf8HFdYDACb2uuCiBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAt1cGRhdGVfdGltZRUMFoSoExaU1RMWrNUFJva64KIEJvaK4KIEHDYAKBgyMDI0LTEw + LTIxVDE1OjM4OjExLjAwMFoYGDIwMTEtMDItMDRUMDY6MTM6MDUuMDAwWgAZLBUEFQQVAgAVABUE + FRAAABbup/n/BxXiARbu5cX/BxXWBgAm/PnmogQcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQKY29uZmlkZW5jZRUMFoSoExa+/xMW8s8QJvz55qIEJqLg5aIEHBgIat5xio7k7j8YCM3MzMzM + zOQ/Fqi2DCgIat5xio7k7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFtCp+f8HFfIBFsTs + xf8HFfYCACaUsPaiBBwVAhk1BggAGRgFbGV2ZWwVDBaEqBMW3gUWzAYmlLD2ogQ8GAQBAAAAGAQB + AAAAFuynEygEAQAAABgEAQAAAAAZHBUAFQAVEAAAFsKr+f8HFdYBFrrvxf8HFcYBACb0uPaiBBwV + DBk1BggEGRgHc3VidHlwZRUMFoSoExaYExbUEib0uPaiBCbgtvaiBBw2vKMTKA50cmFuc3BvcnRh + dGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFpit+f8HFeIBFoDxxf8HFaADACaG + zPaiBBwVDBk1BggEGRgFY2xhc3MVDBaEqBMW6BEWthEmhsz2ogQmtMn2ogQcNoKkEygNdHJhaW5f + c3RhdGlvbhgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABb6rvn/BxXgARag9MX/BxXMAgAm + 6tr2ogQcFQoZNQYIABkYBmhlaWdodBUMFoSoExaQBBagBSbq2vaiBDw2hKgTABkcFQAVABUQAAAW + 2rD5/wcV0gEW7PbF/wcVdgAmiuD2ogQcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBaEqBMWljMW + xCUmiuD2ogQ8NqymEygPWmFwYXRlcmlhIFBhc29zGAZBYmNkaW4AGRwVABUAFRAAABassvn/BxXi + ARbi98X/BxXcBgAmzoX3ogQcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBaI + qBMW8gsW6AsmzoX3ogQ8NoCoEygCZXMYAmVuABkcFQAVABUQAAAWjrT5/wcV3gEWvv7F/wcVfgAm + tpH3ogQcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFoioExboDRbODCa2 + kfeiBDw2gKgTKApTdGF0ZSBCYW5rGAxCYW5jbyBFc3RhZG8AGRwVABUAFRAAABbstfn/BxXiARa8 + /8X/BxWiAQAmhJ73ogQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQV + DBaKqBMW4A0WoAwmhJ73ogQ8NoCoEygIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFs63 + +f8HFeIBFt6Axv8HFZgBACakqveiBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQI + bGFuZ3VhZ2UVDBaKqBMW/gwW9AsmpKr3ogQ8NoaoEygCZXMYAmVuABkcFQAVABUQAAAWsLn5/wcV + 4gEW9oHG/wcVfgAmmLb3ogQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVl + FQwWiqgTFq4PFpoNJpi296IEPDaAqBMoIkNlbnRybyBDb211bml0YXJpbyBkZSBTYWx1ZCBNZW50 + YWwYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRAAABaSu/n/BxXiARb0gsb/BxXs + AQAmssP3ogQcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdl + bGVtZW50FQwWiqgTFuoMFuILJrLD96IEPDaKqBMAGRwVABUAFRAAABb0vPn/BxXiARbghMb/BxV2 + ACaUz/eiBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFoqoExbmDBbk + CyaUz/eiBDw2iqgTABkcFQAVABUQAAAW1r75/wcV4gEW1oXG/wcVdgAm+Nr3ogQcFQAZNQYIABkY + CWhhc19wYXJ0cxUMFoSoExaiuQIWsAYm+Nr3ogQ8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABa4 + wPn/BxXSARbMhsb/BxV2ACao4feiBBwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaEqBMWorkC + FrAGJqjh96IEPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWisL5/wcV0gEWwofG/wcVdgAmyOj3 + ogQcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBaEqBMWrgYW0AcmyOj3ogQm2Of3ogQcGAQJAAAAGAQB + AAAAFtKnEygECQAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbcw/n/BxXUARa4iMb/BxW2AQAm + qO/3ogQcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaEqBMWkAQWoAUmqO/3ogQ8 + NoSoEwAZHBUAFQAVEAAAFrDF+f8HFdIBFu6Jxv8HFXYAJsj096IEHBUKGTUGCAAZGAptaW5faGVp + Z2h0FQwWhKgTFpAEFqAFJsj096IEPDaEqBMAGRwVABUAFRAAABaCx/n/BxXSARbkisb/BxV2ACbo + +feiBBwVAhk1BggAGRgJbWluX2Zsb29yFQwWhKgTFpAEFqAFJuj596IEPDaEqBMAGRwVABUAFRAA + ABbUyPn/BxXSARbai8b/BxV2ACaI//eiBBwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWhKgTFpAE + FqAFJoj/96IEPDaEqBMAGRwVABUAFRAAABamyvn/BxXSARbQjMb/BxV2ACaohPiiBBwVDBk1BggA + GRgPZmFjYWRlX21hdGVyaWFsFQwWhKgTFpAEFqAFJqiE+KIEPDaEqBMAGRwVABUAFRAAABb4y/n/ + BxXSARbGjcb/BxV2ACbIifiiBBwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFoSoExaQBBagBSbI + ifiiBDw2hKgTABkcFQAVABUQAAAWys35/wcV0gEWvI7G/wcVdgAm6I74ogQcFQwZNQYIABkYCnJv + b2Zfc2hhcGUVDBaEqBMWkAQWoAUm6I74ogQ8NoSoEwAZHBUAFQAVEAAAFpzP+f8HFdIBFrKPxv8H + FXYAJoiU+KIEHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFoSoExaQBBagBSaIlPiiBDw2hKgT + ABkcFQAVABUQAAAW7tD5/wcV0gEWqJDG/wcVdgAmqJn4ogQcFQwZNQYIABkYEHJvb2Zfb3JpZW50 + YXRpb24VDBaEqBMWkAQWoAUmqJn4ogQ8NoSoEwAZHBUAFQAVEAAAFsDS+f8HFdIBFp6Rxv8HFXYA + Jsie+KIEHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWhKgTFpAEFqAFJsie+KIEPDaEqBMAGRwVABUA + FRAAABaS1Pn/BxXSARaUksb/BxV2ACboo/iiBBwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBaEqBMW + kAQWoAUm6KP4ogQ8NoSoEwAZHBUAFQAVEAAAFuTV+f8HFdIBFoqTxv8HFXYAFrLT8BoWhKgTJuCy + /5QEFqj2+A0USgAZ/CYmiKn4ogQcFQwZNQYIABkYAmlkFQwWxL4TFtzPvQUW5IjLASaIqfiiBDw2 + ACggMDhiYjJkZGRiNmE2OGZmZjAyMDA3ZTI1YzE3MzNkYzIYIDA4YmIyZDg5MDAwYzBmZmYwMjAw + MTdiM2JlMDFmN2FjABkcFQAVABUQAAAWttf5/wcV8gEWgJTG/wcV1ggAJuyxw6QEHBUMGTUGCAAZ + GAhnZW9tZXRyeRUMFsS+Exbq/YIQFpiJzgkm7LHDpAQ8NgAozQQAAAAAAwAAAAUAAAAPwFHu+kVA + e/HAQczu6ICHesBR7v1qjuoTwEHM5F65ybvAUe8AJ20sU8BBzOaIX7VywFHu/8fL3AzAQcznyNGV + icBR7wConGvcwEHM6HnRfTbAUe8BLz+IrMBBzOa3WZ4BwFHvBuhRjZHAQczrO0zdKMBR7wZfKjID + wEHM7QYoOC3AUe8I49RQT8BBzO8DWHoVwFHvBiJY8FzAQcz4QBgeBMBR7wTPBzmwwEHM9zOoo/nA + Ue8Eh7mdRcBBzPgiu+yrwFHvAnROhnbAQcz2gCR9jsBR7wK6WgOCwEHM9ZVC8sTAUe76RUB78cBB + zO7ogId6AAAABcBR7wXIlt0nwEHM7jQloXrAUe8EuaMkXcBBzPHoD0hywFHvBXqTRBXAQczyegV/ + nMBR7waJ8lypwEHM7sYb2KTAUe8FyJbdJ8BBzO40JaF6AAAABcBR7wCjk+5fwEHM6fra/RHAUe7/ + iU0bPMBBzO3UhFEzwFHvAGFOz3HAQczud0F//cBR7wF7laKUwEHM6p5u63DAUe8Ao5PuX8BBzOn6 + 2v0RAAAABcBR7wM000ZkwEHM7Amo9i7AUe8BfhnhU8BBzPICEHt4wFHvAmU1Df/AQczysWLj+8BR + 7wQcWdLawEHM7Lj7XrHAUe8DNNNGZMBBzOwJqPYuAAAABcBR7v5YYBNmwEHM6BsG7IPAUe79NUpk + qMBBzOwVZ3BSwFHu/iFuDtHAQczsyBTXKMBR7v9Eg72PwEHM6M20U1nAUe7+WGATZsBBzOgbBuyD + GE0AAAAAAwAAAAEAAAAEwFHwJJXWyQPAQe7R06UJRsBR8CUk+b0xwEHu0eWpbNvAUfAlEqhx3cBB + 7tNnVZ5vwFHwJJXWyQPAQe7R06UJRgAZHBUAFQAVJAAAFqjZ+f8HFaAEFtacxv8HFa4lACaa6Kiu + BBwVCBk1BggEGSgEYmJveAR4bWluFQwWxL4TFoK/RhaEjTwmmuiorgQmhLuRrgQcGAQFcI/CGAQN + S5HCFgAoBAVwj8IYBA1LkcIAGSwVBBUEFQIAFQAVBBUQAAAWyN35/wcV8gEWhMLG/wcV1gEAJrz6 + 5K4EHBUIGTUGCAQZKARiYm94BHhtYXgVDBbEvhMW0shGFuqQPCa8+uSuBCaIyM2uBBwYBOlvj8IY + BP9KkcIWACgE6W+PwhgE/0qRwgAZLBUEFQQVAgAVABUEFRAAABa63/n/BxXyARbaw8b/BxXWAQAm + 7rWsrwQcFQgZNQYIBBkoBGJib3gEeW1pbhUMFsS+ExbwyFcWtL1JJu61rK8EJvLYia8EHBgEbkwN + whgEENgQwhYAKARuTA3CGAQQ2BDCABksFQQVBBUCABUAFQQVEAAAFqzh+f8HFfIBFrDFxv8HFdYB + ACb+/vWvBBwVCBk1BggEGSgEYmJveAR5bWF4FQwWxL4TFtLbVxb+yEkm/v71rwQmppbTrwQcGARk + TA3CGAT21xDCFgAoBGRMDcIYBPbXEMIAGSwVBBUEFQIAFQAVBBUQAAAWnuP5/wcV8gEWhsfG/wcV + 1gEAJuTfnLAEHBUCGTUGCAQZGAd2ZXJzaW9uFQwWxL4TFv4EFqAGJuTfnLAEJqTfnLAEHBgEAAAA + ABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFpDl+f8HFdIBFtzIxv8HFdYB + ACaE5pywBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFsS+Exb+BRag + ByaE5pywBCbE5ZywBBwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFuLm+f8HFdIBFrLKxv8H + FVYAJqjunLAEHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbEvhMWiO8E + FuDnAiao7pywBCbk7JywBBw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdz + ABksFQQVBBUCABUAFQQVEAAAFrTo+f8HFeIBFojLxv8HFfYEACbE1J+wBBwVDBklBgAZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbEvhMWsJ/eAha0+o4BJsTUn7AEPDYAKAx3OTc5 + NDE5NzM0QDEYDDAwMDBjOTdlYmVhMwAZHBUAFQAVEAAAFpbq+f8HFfIBFv7Pxv8HFdYDACaI9q6x + BBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFsS+ExaYvxIW0vkE + Joj2rrEEJvjOrrEEHDYAKBgyMDI0LTExLTIyVDAwOjIyOjU4LjAwMFoYGDIwMTAtMDMtMDZUMTY6 + NTU6MTYuMDAwWgAZLBUEFQQVAgAVABUEFRAAABaI7Pn/BxXiARbU08b/BxXWBgAmouS0sQQcFQoZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsS+ExaArhUWzoASJqLktLEE + JsrIs7EEHBgIyXa+nxov7z8YCM3MzMzMzOQ/FtrpCygIyXa+nxov7z8YCM3MzMzMzOQ/ABksFQQV + BBUCABUAFQQVEAAAFurt+f8HFfIBFqraxv8HFfYCACaYycWxBBwVAhk1BggAGRgFbGV2ZWwVDBbE + vhMW2AQW6AUmmMnFsQQ8GAQBAAAAGAQBAAAAFry+EygEAQAAABgEAQAAAAAZHBUAFQAVEAAAFtzv + +f8HFdIBFqDdxv8HFZYBACao0cWxBBwVDBk1BggEGRgHc3VidHlwZRUMFsS+ExbYGhaSGSao0cWx + BCaAz8WxBBw2jrITKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EAAAFq7x+f8HFeIBFrbexv8HFbwDACbC68WxBBwVDBk1BggEGRgFY2xhc3MVDBbEvhMWtBkW/hcm + wuvFsQQmkujFsQQcNoKzEygJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAA + FpDz+f8HFeIBFvLhxv8HFfgCACaQgMaxBBwVChk1BggAGRgGaGVpZ2h0FQwWxL4TFvgEFogGJpCA + xrEEPBgIAAAAAAAAIEAYCAAAAAAAAAhAFry+EygIAAAAAAAAIEAYCAAAAAAAAAhAABkcFQAVABUQ + AAAW8vT5/wcV1gEW6uTG/wcVtgEAJtCdxrEEHBUMGTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwWxL4T + FqA7FuwmJtCdxrEEJpiGxrEEHDbAvBMoKHNlcnZpY2lvcyBhZG1pbmlzdHJhdGl2b3MgY29uY2Vj + aW9uYXJpb3MYB0FjdWVudGEAGSwVBBUEFQIAFQAVBBUQAAAWyPb5/wcV4gEWoObG/wcVzgQAJoSt + xrEEHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWxr4TFtQOFvoNJoStxrEE + PDbCvhMoAmVzGAJlbgAZHBUAFQAVEAAAFqr4+f8HFeIBFu7qxv8HFX4AJv66xrEEHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbGvhMW2BAWoA4m/rrGsQQ8NsK+EygKU3Rh + dGUgQmFuaxgMQmFuY28gRXN0YWRvABkcFQAVABUQAAAWjPr5/wcV4gEW7OvG/wcVogEAJp7JxrEE + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWzL4TFpASFpAPJp7J + xrEEPDa6vhMoCG9mZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRAAABbu+/n/BxXiARaO7cb/BxX8 + AQAmrtjGsQQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWzL4T + FsgQFqQOJq7YxrEEPDbIvhMoAmVzGAJlbgAZHBUAFQAVEAAAFtD9+f8HFeIBForvxv8HFX4AJtLm + xrEEHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFsy+ExbwFBbKECbS + 5saxBDw2ur4TKBtFeCBIb3NwaXRhbCBkZSBWaWxsYSBBbGVncmUYGUJhbmNvIGRlbCBFc3RhZG8g + ZGUgQ2hpbGUAGRwVABUAFRAAABay//n/BxXiARaI8Mb/BxWmBAAmnPfGsQQcFQoZJQYAGXgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWzL4TFrIQFo4OJpz3 + xrEEPDbMvhMAGRwVABUAFRAAABaUgfr/BxXiARau9Mb/BxV2ACaqhcexBBwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFsy+ExasEBaIDiaqhcexBDw2zL4TABkcFQAVABUQ + AAAW9oL6/wcV4gEWpPXG/wcVdgAmspPHsQQcFQAZNQYIABkYCWhhc19wYXJ0cxUMFsS+ExaKvAIW + ugYmspPHsQQ8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABbYhPr/BxXSARaa9sb/BxV2ACbsmcex + BBwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBbEvhMWirwCFrAGJuyZx7EEPBgBABgBABYAKAEA + GAEAABkcFQAVABUQAAAWqob6/wcV0gEWkPfG/wcVdgAmnKDHsQQcFQIZNQYIABkYCm51bV9mbG9v + cnMVDBbEvhMW5gYWqgcmnKDHsQQ8GAQEAAAAGAQBAAAAFpa+EygEBAAAABgEAQAAAAAZHBUAFQAV + EAAAFvyH+v8HFdgBFob4xv8HFcYBACbGp8exBBwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdy + b3VuZBUMFsS+ExaQBBagBSbGp8exBDw2xL4TABkcFQAVABUQAAAW1In6/wcV0gEWzPnG/wcVdgAm + 5qzHsQQcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbEvhMWkAQWoAUm5qzHsQQ8NsS+EwAZHBUAFQAV + EAAAFqaL+v8HFdIBFsL6xv8HFXYAJoayx7EEHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbEvhMWkAQW + oAUmhrLHsQQ8NsS+EwAZHBUAFQAVEAAAFviM+v8HFdIBFrj7xv8HFXYAJqa3x7EEHBUMGTUGCAAZ + GAxmYWNhZGVfY29sb3IVDBbEvhMWkAQWoAUmprfHsQQ8NsS+EwAZHBUAFQAVEAAAFsqO+v8HFdIB + Fq78xv8HFXYAJsa8x7EEHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbEvhMWkAQWoAUmxrzH + sQQ8NsS+EwAZHBUAFQAVEAAAFpyQ+v8HFdIBFqT9xv8HFXYAJubBx7EEHBUMGTUGCAAZGA1yb29m + X21hdGVyaWFsFQwWxL4TFpAEFqAFJubBx7EEPDbEvhMAGRwVABUAFRAAABbukfr/BxXSARaa/sb/ + BxV2ACaGx8exBBwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFsS+ExaQBBagBSaGx8exBDw2xL4TABkc + FQAVABUQAAAWwJP6/wcV0gEWkP/G/wcVdgAmpszHsQQcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9u + FQwWxL4TFpAEFqAFJqbMx7EEPDbEvhMAGRwVABUAFRAAABaSlfr/BxXSARaGgMf/BxV2ACbG0cex + BBwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFsS+ExaQBBagBSbG0cexBDw2xL4TABkcFQAV + ABUQAAAW5Jb6/wcV0gEW/IDH/wcVdgAm5tbHsQQcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbEvhMW + sAQWwAUm5tbHsQQ8GAcjRkZGRjAwGAcjRkZGRjAwFsK+EygHI0ZGRkYwMBgHI0ZGRkYwMAAZHBUA + FQAVEAAAFraY+v8HFdIBFvKBx/8HFZIBACam3MexBBwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbE + vhMWkAQWoAUmptzHsQQ8NsS+EwAZHBUAFQAVEAAAFoia+v8HFdIBFoSDx/8HFXYAFsCdjxsWxL4T + Joip+KIEFr64zw4UTAAZ/CYmxuHHsQQcFQwZNQYIABkYAmlkFQwW/LITFr6vugUW4PfLASbG4cex + BDw2ACggMDhiYjJkZGRhZWFlZWZmZjAyMDAzMGI0YzczMjFmOTMYIDA4YmIyYzM0Y2IwMWVmZmYw + MjAwMDJkZDliYjZkZGUxABkcFQAVABUQAAAW2pv6/wcV8gEW+oPH/wcV1ggAJqbZk7MEHBUMGTUG + CAAZGAhnZW9tZXRyeRUMFvyyExbsh+8PFr7TvgkmptmTswQ8NgAo1QQAAAAAAwAAAAcAAAAFwFHr + 4Bhui8/AQfw7IT4+KcBR69vf+qb7wEH8QA02SWjAUevShDFSiMBB/CsDucjkwFHr1r0QlyfAQfwm + GJh9OsBR6+AYbovPwEH8OyE+PikAAAAFwFHr20YMU8vAQfw0ALiMpMBR69m8n1gfwEH8NdTOIw7A + UevaDtSvGcBB/DaJKQkOwFHr25fWSvvAQfw0tRNypMBR69tGDFPLwEH8NAC4jKQAAAAFwFHr3dMZ + 7ejAQfw6Sn6pU8BR69xJrPI8wEH8PB6UP77AUevcm+JJNsBB/DzS7yW9wFHr3iTj5RfAQfw6/tmP + U8BR693TGe3owEH8Okp+qVMAAAAFwFHr3EKLlcvAQfw20iQkosBR69q5HpofwEH8OKY5uw3AUevb + CuiRTsBB/DlalKEMwFHr3JRVjPrAQfw3hn8KosBR69xCi5XLwEH8NtIkJKIAAAAFwFHr2KnlQTjA + Qfwt5sMYGMBR69cg46VWwEH8L7uvbhfAUevXcq2chsBB/DBvM5SCwFHr2PwamDLAQfwumx3+GMBR + 69ip5UE4wEH8LebDGBgAAAAFwFHr2h0XZ/zAQfwxwGxsOsBR69iTqmxQwEH8M5SCAqTAUevY5d/D + SsBB/DRI3OikwFHr2m7hXyvAQfwydMdSOsBR69odF2f8wEH8McBsbDoAAAAFwFHr1y5PnqTAQfwq + z7di2MBR69Wk4qL4wEH8LKPM+ULAUevV9qyaJ8BB/C1YJ99CwFHr14AZldPAQfwrhBJI2MBR69cu + T56kwEH8Ks+3YtgYTQAAAAADAAAAAQAAAATAUeXYIaXNTMBCEa2gO3QSwFHl2AkWL83AQhGuvKta + rMBR5dd+tsGCwEIRrp05FTjAUeXYIaXNTMBCEa2gO3QSABkcFQAVABUkAAAWzJ36/wcVoAQW0IzH + /wcVriUAJuSs0rwEHBUIGTUGCAAZKARiYm94BHhtaW4VDBb8shMWvtBNFoKoLSbkrNK8BDwYBN+g + jMIYBAPYkMIWACgE36CMwhgEA9iQwgAZHBUAFQAVEAAAFuyh+v8HFfIBFv6xx/8HFdYBACbm1P+8 + BBwVCBk1BggAGSgEYmJveAR4bWF4FQwW/LITFr7QTRa4oi0m5tT/vAQ8GATWoIzCGAT415DCFgAo + BNagjMIYBPjXkMIAGRwVABUAFRAAABbeo/r/BxXyARbUs8f/BxXWAQAmnvesvQQcFQgZNQYIABko + BGJib3gEeW1pbhUMFvyyExbA0E0W3oEwJp73rL0EPBgEGqAMwhgEGUASwhYAKAQaoAzCGAQZQBLC + ABkcFQAVABUQAAAW0KX6/wcV8gEWqrXH/wcV1gEAJvz43L0EHBUIGTUGCAAZKARiYm94BHltYXgV + DBb8shMWvtBNFsL+Lyb8+Ny9BDwYBAigDMIYBPE/EsIWACgECKAMwhgE8T8SwgAZHBUAFQAVEAAA + FsKn+v8HFfIBFoC3x/8HFdYBACb+94y+BBwVAhk1BggEGRgHdmVyc2lvbhUMFvyyExb+BBagBib+ + 94y+BCa+94y+BBwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABa0 + qfr/BxXSARbWuMf/BxXWAQAmnv6MvgQcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJv + cGVydHkVDBb8shMW/gUWoAcmnv6MvgQm3v2MvgQcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAA + ABaGq/r/BxXSARasusf/BxVWACbCho2+BBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdk + YXRhc2V0FQwW/LITFuilBBaozgImwoaNvgQm/oSNvgQcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2ds + ZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABbYrPr/BxXiARaCu8f/BxX2BAAmptOP + vgQcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW/LITFpax5AIWloCK + ASam04++BDw2ACgMdzk5Nzk3OTU0MkAxGAwwMDAwMDQ5YTNiOTcAGRwVABUAFRAAABa6rvr/BxXy + ARb4v8f/BxXUAwAm4pmavwQcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3Rp + bWUVDBb8shMWjIQUFsLdBSbimZq/BCa805m/BBw2ACgYMjAyNC0xMS0yOVQwNDoyMzo0Mi4wMDBa + GBgyMDEwLTAzLTA1VDEyOjUzOjAyLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWrLD6/wcV4gEWzMPH + /wcV1gYAJszNoL8EHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBb8 + shMW0ugWFqjeEybMzaC/BCb+sJ+/BBwYCLByaJHtfO8/GAjNzMzMzMzkPxb6nwooCLByaJHtfO8/ + GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABaOsvr/BxXyARaiysf/BxXyAgAm5o+zvwQcFQIZ + NQYIBBkYBWxldmVsFQwW/LITFsIFFuQGJuaPs78EJqaPs78EHBgEAQAAABgEAQAAABbmshMoBAEA + AAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWgLT6/wcV0gEWlM3H/wcVtgEAJqSYs78EHBUMGTUG + CAQZGAdzdWJ0eXBlFQwW/LITFv4mFp4jJqSYs78EJoqWs78EHDa+mRMoDnRyYW5zcG9ydGF0aW9u + GAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW0rX6/wcV4gEWys7H/wcV1AMAJpy9s78E + HBUMGTUGCAQZGAVjbGFzcxUMFvyyExbKJxbWIyacvbO/BCaoubO/BBw20poTKAl3YXJlaG91c2UY + CmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWtLf6/wcV4gEWntLH/wcV7AIAJv7cs78EHBUK + GTUGCAAZGAZoZWlnaHQVDBb8shMWqgQWugUm/tyzvwQ8GAgAAAAAAAA5QBgIAAAAAAAAOUAW+rIT + KAgAAAAAAAA5QBgIAAAAAAAAOUAAGRwVABUAFRAAABaWufr/BxXSARaK1cf/BxWWAQAmuOKzvwQc + FQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBb8shMWpGcWykMmuOKzvwQ8NsSvEygIZXggSG90ZWwY + DjLCsCBDb21wYcOxw61hABkcFQAVABUQAAAW6Lr6/wcV4gEWoNbH/wcVyAUAJoKmtL8EHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW/LITFvYSFsIQJoKmtL8EPBgCZGUYAmRl + FvqyEygCZGUYAmRlABkcFQAVABUQAAAWyrz6/wcV4gEW6NvH/wcVfgAmxLa0vwQcFQwZJQYAGUgF + bmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFvyyExbeFRawESbEtrS/BDwYCEZyZWloYXVz + GAhGcmVpaGF1cxb6shMoCEZyZWloYXVzGAhGcmVpaGF1cwAZHBUAFQAVEAAAFqy++v8HFeIBFubc + x/8HFZYBACb0x7S/BBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUM + FoCzExb4FhbEEib0x7S/BDw29LITKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAWjsD6 + /wcV4gEW/N3H/wcV/gEAJrjatL8EHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhs + YW5ndWFnZRUMFoCzExbgFRa4ESa42rS/BDw2gLMTABkcFQAVABUQAAAW8MH6/wcV4gEW+t/H/wcV + dgAm8Ou0vwQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWgLMTFqYZ + Fv4TJvDrtL8EPDb0shMoIkdvYmVybmFjacOzbiBQcm92aW5jaWFsIGRlIExpbmFyZXMYGUJhbmNv + IGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRAAABbSw/r/BxXiARbw4Mf/BxWCBQAm7v+0vwQc + FQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW + gLMTFuQVFr4RJu7/tL8EPDaAsxMAGRwVABUAFRAAABa0xfr/BxXiARby5cf/BxV2ACaskbW/BBwV + DBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFoCzExbgFRa4ESaskbW/BDw2 + gLMTABkcFQAVABUQAAAWlsf6/wcV4gEW6ObH/wcVdgAm5KK1vwQcFQAZNQYIABkYCWhhc19wYXJ0 + cxUMFvyyExbQugIWxAYm5KK1vwQ8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABb4yPr/BxXSARbe + 58f/BxV2ACaoqbW/BBwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBb8shMW0LoCFrAGJqiptb8E + PBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWysr6/wcV0gEW1OjH/wcVdgAmsLC1vwQcFQIZNQYI + BBkYCm51bV9mbG9vcnMVDBb8shMW5AcWhgkmsLC1vwQm2K+1vwQcGAQFAAAAGAQBAAAAFtKvEygE + BQAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABaczPr/BxXYARbK6cf/BxW2AQAm3ri1vwQcFQIZ + NQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBb8shMWkAQWoAUm3ri1vwQ8NvyyEwAZHBUA + FQAVEAAAFvTN+v8HFdIBFoDrx/8HFXYAJv69tb8EHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW/LIT + FpAEFqAFJv69tb8EPDb8shMAGRwVABUAFRAAABbGz/r/BxXSARb268f/BxV2ACaew7W/BBwVAhk1 + BggAGRgJbWluX2Zsb29yFQwW/LITFpAEFqAFJp7Dtb8EPDb8shMAGRwVABUAFRAAABaY0fr/BxXS + ARbs7Mf/BxV2ACa+yLW/BBwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwW/LITFpAEFqAFJr7Itb8E + PDb8shMAGRwVABUAFRAAABbq0vr/BxXSARbi7cf/BxV2ACbezbW/BBwVDBk1BggAGRgPZmFjYWRl + X21hdGVyaWFsFQwW/LITFpAEFqAFJt7Ntb8EPDb8shMAGRwVABUAFRAAABa81Pr/BxXSARbY7sf/ + BxV2ACb+0rW/BBwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFvyyExaQBBagBSb+0rW/BDw2/LIT + ABkcFQAVABUQAAAWjtb6/wcV0gEWzu/H/wcVdgAmnti1vwQcFQwZNQYIABkYCnJvb2Zfc2hhcGUV + DBb8shMWkAQWoAUmnti1vwQ8NvyyEwAZHBUAFQAVEAAAFuDX+v8HFdIBFsTwx/8HFXYAJr7dtb8E + HBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFvyyExaQBBagBSa+3bW/BDw2/LITABkcFQAVABUQ + AAAWstn6/wcV0gEWuvHH/wcVdgAm3uK1vwQcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBb8 + shMWkAQWoAUm3uK1vwQ8NvyyEwAZHBUAFQAVEAAAFoTb+v8HFdIBFrDyx/8HFXYAJv7ntb8EHBUM + GTUGCAAZGApyb29mX2NvbG9yFQwW/LITFpAEFqAFJv7ntb8EPDb8shMAGRwVABUAFRAAABbW3Pr/ + BxXSARam88f/BxV2ACae7bW/BBwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBb8shMWkAQWoAUmnu21 + vwQ8NvyyEwAZHBUAFQAVEAAAFqje+v8HFdIBFpz0x/8HFXYAFp7M+xoW/LITJsbhx7EEFviQ7g0U + TgAZ/CYmvvK1vwQcFQwZNQYIABkYAmlkFQwWsL4TFpDKvQUW2LHKASa+8rW/BDw2ACggMDhiYjJk + ZGQ2ZGQ3NGZmZjAyMDBkYTFmNGY4MzdkMWUYIDA4YmIyY2U0ODE0ZTFmZmYwMjAwNTBlZjE0YzAw + YTRiABkcFQAVABUQAAAW+t/6/wcV8gEWkvXH/wcV1ggAJpakgMEEHBUMGTUGCAAZGAhnZW9tZXRy + eRUMFrC+Exaw7ocQFuLvvwkmlqSAwQQ8NgAonQQAAAAAAwAAAAUAAAALwFHfjL3pBDvAQcSSEryb + JsBR345ImB9GwEHEnvUjLSzAUd+JcMIJ+8BBxKB9uWlDwFHfiUDxYdjAQcSe7m0whcBR34hfShJz + wEHEnzW6zPDAUd+IgoWA3sBBxKBcK3oBwFHfhH5/YeDAQcShonyXKsBR34RMKnr+wEHEn/43qOTA + Ud+AaATMGMBBxKE5oQt+wFHffxw/0afAQcSWZFrzbMBR34y96QQ7wEHEkhK8myYAAAAFwFHfhZE5 + eMjAQcSXcnfsocBR34TM7lq8wEHEl51AF0fAUd+FVT72tsBBxJ4NnKC1wFHfhhn1dIzAQcSd4f22 + esBR34WROXjIwEHEl3J37KEAAAAGwFHfgsVBvhDAQcSajowfXsBR34JJGvwFwEHEmq2Vz+DAUd+C + gHhgZMBBxJz1bqyGwFHfgqajbVjAQcSeicNiwcBR34Miyi9kwEHEnmq5sj7AUd+CxUG+EMBBxJqO + jB9eAAAABcBR34h96GMrwEHEmRycF/nAUd+H31zyScBBxJlGjYMLwFHfiEEXIYXAQcSdDpkf98BR + 34jfNzKcwEHEnOSntOXAUd+IfehjK8BBxJkcnBf5AAAABcBR34sYYfaVwEHEmIql4NDAUd+KY5uw + y8BBxJiy6cy4wFHfirXRB8XAQcSchQZknsBR34tql02PwEHEnFzCeLbAUd+LGGH2lcBBxJiKpeDQ + GE0AAAAAAwAAAAEAAAAEwFHVG6eeshbAQcKnHElmVcBR1RvH0D9PwEHCpkb7mKvAUdUcesF84MBB + wqdxew/twFHVG6eeshbAQcKnHElmVQAZHBUAFQAVJAAAFuzh+v8HFaAEFuj9x/8HFa4lACbuwNPK + BBwVCBk1BggEGSgEYmJveAR4bWluFQwWsL4TFoCRQRa6jzgm7sDTygQm+JPAygQcGAStCI7CGAQO + cI/CFgAoBK0IjsIYBA5wj8IAGSwVBBUEFQIAFQAVBBUQAAAWjOb6/wcV8gEWlqPI/wcV1gEAJpjU + i8sEHBUIGTUGCAQZKARiYm94BHhtYXgVDBawvhMW2JZBFrqTOCaY1IvLBCayo/jKBBwYBJMIjsIY + BPxvj8IWACgEkwiOwhgE/G+PwgAZLBUEFQQVAgAVABUEFRAAABb+5/r/BxXyARbspMj/BxXWAQAm + 7LawywQcFQgZNQYIABkoBGJib3gEeW1pbhUMFrC+ExaQ/k0WpNEuJuy2sMsEPBgEDtsNwhgEDHAP + whYAKAQO2w3CGAQMcA/CABkcFQAVABUQAAAW8On6/wcV8gEWwqbI/wcV1gEAJpCI38sEHBUIGTUG + CAAZKARiYm94BHltYXgVDBawvhMWkP5NFvjRLiaQiN/LBDwYBNvaDcIYBPNvD8IWACgE29oNwhgE + 828PwgAZHBUAFQAVEAAAFuLr+v8HFfIBFpioyP8HFdYBACbI2o3MBBwVAhk1BggEGRgHdmVyc2lv + bhUMFrC+Exb+BBagBibI2o3MBCaI2o3MBBwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUE + FQQVAgAVABUEFRAAABbU7fr/BxXSARbuqcj/BxXWAQAm6OCNzAQcFQwZJQYEGUgHc291cmNlcwRs + aXN0B2VsZW1lbnQIcHJvcGVydHkVDBawvhMW/gUWoAcm6OCNzAQmqOCNzAQcGAAYABYAKAAYAAAZ + LBUEFQQVAgAVABUEFRAAABam7/r/BxXSARbEq8j/BxVWACaM6Y3MBBwVDBklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWsL4TFtyLAxbG7gEmjOmNzAQmyOeNzAQcNgAoDU9wZW5T + dHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABb48Pr/BxXi + ARaarMj/BxX2BAAmjtaPzAQcFQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lk + FQwWsL4TFuiz+QIWrJl9Jo7Wj8wEPDYAKAx3OTkzNTE4OTg1QDEYDDAwMDIwZGRiNDA1MgAZHBUA + FQAVEAAAFtry+v8HFfIBFpCxyP8HFdQDACbmlY3NBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudAt1cGRhdGVfdGltZRUMFrC+ExbQwwwWlMsDJuaVjc0EJrrvjM0EHDYAKBgyMDI0LTExLTI5 + VDIyOjIyOjAyLjAwMFoYGDIwMTAtMDMtMTJUMjA6NTk6MTAuMDAwWgAZLBUEFQQVAgAVABUEFRAA + ABbM9Pr/BxXiARbktMj/BxXWBgAmzNmRzQQcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQK + Y29uZmlkZW5jZRUMFrC+Exao/hoWxMEYJszZkc0EJs66kM0EHBgIzF1LyAc97z8YCM3MzMzMzOQ/ + Fq6zBigIzF1LyAc97z8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFq72+v8HFfIBFrq7yP8H + FewCACaS/KjNBBwVAhk1BggAGRgFbGV2ZWwVDBawvhMWzgQW0AUmkvyozQQ8GAQBAAAAGAQBAAAA + Fqa+EygEAQAAABgEAQAAAAAZHBUAFQAVEAAAFqD4+v8HFdIBFqa+yP8HFZYBACb8g6nNBBwVDBk1 + BggEGRgHc3VidHlwZRUMFrC+ExasHBauGib8g6nNBCbiganNBBw2tKQTKA50cmFuc3BvcnRhdGlv + bhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFvL5+v8HFeIBFry/yP8HFbIDACaKn6nN + BBwVDBk1BggEGRgFY2xhc3MVDBawvhMW+hsW6Bkmip+pzQQmkJypzQQcNvakEygJd2FyZWhvdXNl + GAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFtT7+v8HFeABFu7CyP8HFYIDACb4tanNBBwV + Chk1BggAGRgGaGVpZ2h0FQwWsL4TFroEFsoFJvi1qc0EPBgIAAAAAAAACEAYCAAAAAAAAAhAFqy+ + EygIAAAAAAAACEAYCAAAAAAAAAhAABkcFQAVABUQAAAWtP36/wcV0gEW8MXI/wcVlgEAJsK7qc0E + HBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWsL4TFrIkFtIeJsK7qc0EPDamvRMoC3NlZGUgc29j + aWFsGAdBbCBQYXNvABkcFQAVABUQAAAWhv/6/wcV4gEWhsfI/wcV6AUAJpTaqc0EHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWsr4TFuYKFrQLJpTaqc0EPDauvhMoAmVzGAJl + bgAZHBUAFQAVEAAAFuiA+/8HFeIBFu7MyP8HFX4AJsjlqc0EHBUMGSUGABlIBW5hbWVzBmNvbW1v + bglrZXlfdmFsdWUFdmFsdWUVDBayvhMWhAwW/AsmyOWpzQQ8Nq6+EygKU3RhdGUgQmFuaxgMQmFu + Y28gRXN0YWRvABkcFQAVABUQAAAWyoL7/wcV4gEW7M3I/wcVogEAJsTxqc0EHBUMGSUGABlYBW5h + bWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWtr4TFs4MFpoMJsTxqc0EPDasvhMoCG9m + ZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRAAABashPv/BxXiARaOz8j/BxW4AQAm3v2pzQQcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWtr4TFuwLFuILJt79qc0E + PDayvhMoAmVzGAJlbgAZHBUAFQAVEAAAFo6G+/8HFeIBFsbQyP8HFX4AJsCJqs0EHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFra+ExakDhaaDSbAiarNBDw2rL4TKCRD + ZW50cm8gQ29tdW5pdGFyaW8gZGUgU2FsdWQgRmFtaWxpYXIYGUJhbmNvIGRlbCBFc3RhZG8gZGUg + Q2hpbGUAGRwVABUAFRAAABbwh/v/BxXiARbE0cj/BxXsAgAm2paqzQQcFQoZJQYAGXgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWtr4TFtgLFtILJtqWqs0E + PDa2vhMAGRwVABUAFRAAABbSifv/BxXiARaw1Mj/BxV2ACasoqrNBBwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFra+ExbUCxbQCyasoqrNBDw2tr4TABkcFQAVABUQAAAW + tIv7/wcV4gEWptXI/wcVdgAm/K2qzQQcFQAZNQYIABkYCWhhc19wYXJ0cxUMFrC+ExaGvAIWsAYm + /K2qzQQ8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaWjfv/BxXSARac1sj/BxV2ACastKrNBBwV + ABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBawvhMWhrwCFrAGJqy0qs0EPBgBABgBABYAKAEAGAEA + ABkcFQAVABUQAAAW6I77/wcV0gEWktfI/wcVdgAm3LqqzQQcFQIZNQYIABkYCm51bV9mbG9vcnMV + DBawvhMWlgUWpgYm3LqqzQQ8GAQIAAAAGAQBAAAAFqC+EygECAAAABgEAQAAAAAZHBUAFQAVEAAA + FrqQ+/8HFdIBFojYyP8HFcYBACaCwarNBBwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3Vu + ZBUMFrC+ExaQBBagBSaCwarNBDw2sL4TABkcFQAVABUQAAAWjJL7/wcV0gEWztnI/wcVdgAmosaq + zQQcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBawvhMWkAQWoAUmosaqzQQ8NrC+EwAZHBUAFQAVEAAA + Ft6T+/8HFdIBFsTayP8HFXYAJsLLqs0EHBUCGTUGCAAZGAltaW5fZmxvb3IVDBawvhMWkAQWoAUm + wsuqzQQ8NrC+EwAZHBUAFQAVEAAAFrCV+/8HFdIBFrrbyP8HFXYAJuLQqs0EHBUMGTUGCAAZGAxm + YWNhZGVfY29sb3IVDBawvhMWkAQWoAUm4tCqzQQ8NrC+EwAZHBUAFQAVEAAAFoKX+/8HFdIBFrDc + yP8HFXYAJoLWqs0EHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBawvhMWkAQWoAUmgtaqzQQ8 + NrC+EwAZHBUAFQAVEAAAFtSY+/8HFdIBFqbdyP8HFXYAJqLbqs0EHBUMGTUGCAAZGA1yb29mX21h + dGVyaWFsFQwWsL4TFpAEFqAFJqLbqs0EPDawvhMAGRwVABUAFRAAABammvv/BxXSARac3sj/BxV2 + ACbC4KrNBBwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFrC+ExaQBBagBSbC4KrNBDw2sL4TABkcFQAV + ABUQAAAW+Jv7/wcV0gEWkt/I/wcVdgAm4uWqzQQcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW + sL4TFpAEFqAFJuLlqs0EPDawvhMAGRwVABUAFRAAABbKnfv/BxXSARaI4Mj/BxV2ACaC66rNBBwV + DBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFrC+ExaQBBagBSaC66rNBDw2sL4TABkcFQAVABUQ + AAAWnJ/7/wcV0gEW/uDI/wcVdgAmovCqzQQcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBawvhMWkAQW + oAUmovCqzQQ8NrC+EwAZHBUAFQAVEAAAFu6g+/8HFdIBFvThyP8HFXYAJsL1qs0EHBUKGTUGCAAZ + GAtyb29mX2hlaWdodBUMFrC+ExaQBBagBSbC9arNBDw2sL4TABkcFQAVABUQAAAWwKL7/wcV0gEW + 6uLI/wcVdgAWls6OGxawvhMmvvK1vwQWpIj1DRRQABn8Jibi+qrNBBwVDBk1BggAGRgCaWQVDBaw + qhMWkPq3BRaQ78UBJuL6qs0EPDYAKCAwOGJiMmRkOWI2ZDkyZmZmMDIwMDUwZGZiYzgzN2NhNxgg + MDhiYjJjMzIxMDAwYWZmZjAyMDAyMTA0YWUyMGU4MjIAGRwVABUAFRAAABaSpPv/BxXyARbg48j/ + BxXWCAAm8unwzgQcFQwZNQYIABkYCGdlb21ldHJ5FQwWsKoTFpr5ohAWqNPfCSby6fDOBDw2ACjq + AwAAAAAGAAAABQAAAAADAAAAAQAAAAXAUev1Zx/JysBBukXnat3EwFHr99HItRDAQbpUFFRK28BR + 6+z3Dr+2wEG6UNu6plrAUevqamyFZMBBukMKQMuiwFHr9WcfycrAQbpF52rdxAAAAAADAAAAAQAA + AAbAUev7YTTOPsBBuitXnJ8IwFHr/NCgluTAQbo026nfYsBR6/V9Wp6ywEG6NsxE55HAUevyzyp1 + H8BBujDtB9W3wFHr8oBQHHjAQbotofm6bMBR6/thNM4+wEG6K1ecnwgAAAAAAwAAAAEAAAAFwFHr + 51cnLkLAQbpBCN7L08BR6+mU7w/uwEG6TxDfS1XAUevi5uqFRMBBulDJRi+PwFHr4L9deIHAQbpB + G1NCncBR6+dXJy5CwEG6QQjey9MAAAAAAwAAAAEAAAAFwFHr56S/Z4nAQbos9tkP0cBR6+izsyBT + wEG6PBfeQxfAUevgLWdBWMBBuj0Yj0L/wFHr324koMnAQbou2ggessBR6+ekv2eJwEG6LPbZD9EA + AAAAAwAAAAEAAAAFwFHr8OuQBnPAQborfIWMnMBR6/LWS9GQwEG6PH8MT5rAUevqHT+r58BBuj1+ + D9BYwFHr6KhgBfrAQbosRdkoJcBR6/DrkAZzwEG6K3yFjJwYTQAAAAADAAAAAQAAAATAUeAb2pp1 + r8BBqi3vdr6fwFHgG6uGf+7AQaovKlgh9cBR4BspQ2MQwEGqLvYG1Q/AUeAb2pp1r8BBqi3vdr6f + ABkcFQAVABUkAAAWhKb7/wcVoAQWtuzI/wcVriUAJtLo4NgEHBUIGTUGCAQZKARiYm94BHhtaW4V + DBawqhMW0vg6FvLKMybS6ODYBCaavdDYBBwYBCcIjsIYBAFwj8IWACgEJwiOwhgEAXCPwgAZLBUE + FQQVAgAVABUEFRAAABakqvv/BxXyARbkkcn/BxXWAQAmhrWU2QQcFQgZNQYIBBkoBGJib3gEeG1h + eBUMFrCqExa0/DoWwMwzJoa1lNkEJoyIhNkEHBgEHwiOwhgE9W+PwhYAKAQfCI7CGAT1b4/CABks + FQQVBBUCABUAFQQVEAAAFpas+/8HFfIBFrqTyf8HFdYBACa6m8jZBBwVCBk1BggEGSgEYmJveAR5 + bWluFQwWsKoTFoS7PBbc2DQmupvI2QQmzNS32QQcGAQQoAzCGAQaCA7CFgAoBBCgDMIYBBoIDsIA + GSwVBBUEFQIAFQAVBBUQAAAWiK77/wcV8gEWkJXJ/wcV1gEAJtL1/NkEHBUIGTUGCAQZKARiYm94 + BHltYXgVDBawqhMWzL08FobbNCbS9fzZBCaorezZBBwYBP6fDMIYBPkHDsIWACgE/p8MwhgE+QcO + wgAZLBUEFQQVAgAVABUEFRAAABb6r/v/BxXyARbmlsn/BxXWAQAm7oih2gQcFQIZNQYIBBkYB3Zl + cnNpb24VDBawqhMW/gQWoAYm7oih2gQmroih2gQcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAA + GSwVBBUEFQIAFQAVBBUQAAAW7LH7/wcV0gEWvJjJ/wcV1gEAJo6PodoEHBUMGSUGBBlIB3NvdXJj + ZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWsKoTFv4FFqAHJo6PodoEJs6OodoEHBgAGAAWACgA + GAAAGSwVBBUEFQIAFQAVBBUQAAAWvrP7/wcV0gEWkprJ/wcVVgAmspeh2gQcFQwZJQYEGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFrCqExbG2gQWuuwCJrKXodoEJu6VodoEHDYAKA1P + cGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWkLX7 + /wcV4gEW6JrJ/wcV9gQAJqiCpNoEHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29y + ZF9pZBUMFrCqExaIu+ECFoTEhgEmqIKk2gQ8NgAoDHc5OTc5NTU0MjRAMhgMMDAwMGMzYjAyOTQy + ABkcFQAVABUQAAAW8rb7/wcV8gEW3p/J/wcV1gMAJoibq9sEHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWsKoTFrzBFxbqmAYmiJur2wQmrMaq2wQcNgAoGDIwMjQt + MTEtMjlUMDU6NDQ6MDIuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUA + FQQVEAAAFuS4+/8HFeIBFrSjyf8HFdYGACbk+7HbBBwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudApjb25maWRlbmNlFQwWsKoTFuzvFhai1BMm5Pux2wQmlt+w2wQcGAjwFkhQ/BjvPxgIzczM + zMzM5D8W1sMKKAjwFkhQ/BjvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWxrr7/wcV8gEW + iqrJ/wcV9AIAJrizxNsEHBUCGTUGCAAZGAVsZXZlbBUMFrCqExaUBxbcBya4s8TbBDwYBAIAAAAY + BP////8WgKoTKAQCAAAAGAT/////ABkcFQAVABUQAAAWuLz7/wcV2AEW/qzJ/wcV1gEAJrq9xNsE + HBUMGTUGCAQZGAdzdWJ0eXBlFQwWsKoTFugxFpIqJrq9xNsEJpS7xNsEHDaIihMoDnRyYW5zcG9y + dGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWkL77/wcV4gEW1K7J/wcVtgMA + JqbpxNsEHBUMGTUGCAQZGAVjbGFzcxUMFrCqExa6MBbEKSam6cTbBCam5cTbBBw2iowTKAl3YXJl + aG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAW8r/7/wcV4gEWirLJ/wcV+gIAJv6Q + xdsEHBUKGTUGCAQZGAZoZWlnaHQVDBawqhMW/BIWxhIm/pDF2wQm6o7F2wQcGAgAAAAAAABMQBgI + AAAAAAAABEAWhp8TKAgAAAAAAABMQBgIAAAAAAAABEAAGSwVBBUEFQIAFQAVBBUQAAAW1MH7/wcV + 1gEWhLXJ/wcV9gEAJrChxdsEHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWsKoTFtbWARbwfiaw + ocXbBDw2kqITKAdwYXJyw7NuGBwxcmEgQ29tcGHDscOtYSAiQm9tYmEtVGFsY2EiABkcFQAVABUQ + AAAWqsP7/wcV4gEW+rbJ/wcV3AUAJvygxtsEHBUMGSUGBBlIBW5hbWVzBmNvbW1vbglrZXlfdmFs + dWUDa2V5FQwWuqoTFqQeFogYJvygxtsEJqCgxtsEHDaYqhMoAmZyGAJlbgAZLBUEFQQVAgAVABUE + FRAAABaMxfv/BxXiARbWvMn/BxWWAQAmqLjG2wQcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92 + YWx1ZQV2YWx1ZRUMFrqqExbaJxaIHCaouMbbBDw2mKoTKBJUaGUgQ2hpbG90ZSBNYXJrZXQYCUF1 + dG9saXN0bwAZHBUAFQAVEAAAFu7G+/8HFeIBFuy9yf8HFboCACaw1MbbBBwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFrqqExakJxawGSaw1MbbBDw2iqoTKAhvZmZp + Y2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAW0Mj7/wcV4gEWpsDJ/wcVugEAJuDtxtsEHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFrqqExb8IhaqGCbg7cbbBDw2 + sqoTKAJlcxgCZW4AGRwVABUAFRAAABayyvv/BxXiARbgwcn/BxV+ACaKhsfbBBwVDBklBgAZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBa6qhMW5CoWmB0miobH2wQ8NoqqEygqU2Vy + dmljaW8gZGUgQXRlbmNpw7NuIFByaW1hcmlhIGRlIFVyZ2VuY2lhGAMxMDAAGRwVABUAFRAAABaU + zPv/BxXiARbewsn/BxWoAgAmoqPH2wQcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWuqoTFtIiFpAYJqKjx9sEPDa6qhMAGRwVABUAFRAAABb2 + zfv/BxXiARaGxcn/BxV2ACayu8fbBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQE + c2lkZRUMFrqqExbMIhaOGCayu8fbBDw2uqoTABkcFQAVABUQAAAW2M/7/wcV4gEW/MXJ/wcVdgAm + wNPH2wQcFQAZNQYIABkYCWhhc19wYXJ0cxUMFrCqExbGuQIWugYmwNPH2wQ8GAEBGAEAFgAoAQEY + AQAAGRwVABUAFRAAABa60fv/BxXSARbyxsn/BxV2ACb62cfbBBwVABk1BggAGRgOaXNfdW5kZXJn + cm91bmQVDBawqhMWxrkCFrAGJvrZx9sEPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWjNP7/wcV + 0gEW6MfJ/wcVdgAm0uHH2wQcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBawqhMWxBEWrhEm0uHH2wQm + quDH2wQcGAQOAAAAGAQBAAAAFs6eEygEDgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbe1Pv/ + BxXcARbeyMn/BxXWAQAm2PHH2wQcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaw + qhMWkAQWoAUm2PHH2wQ8NrCqEwAZHBUAFQAVEAAAFrrW+/8HFdIBFrTKyf8HFXYAJvj2x9sEHBUK + GTUGCAAZGAptaW5faGVpZ2h0FQwWsKoTFpAEFqAFJvj2x9sEPDawqhMAGRwVABUAFRAAABaM2Pv/ + BxXSARaqy8n/BxV2ACaY/MfbBBwVAhk1BggAGRgJbWluX2Zsb29yFQwWsKoTFpAEFqAFJpj8x9sE + PDawqhMAGRwVABUAFRAAABbe2fv/BxXSARagzMn/BxV2ACa4gcjbBBwVDBk1BggAGRgMZmFjYWRl + X2NvbG9yFQwWsKoTFpAEFqAFJriByNsEPDawqhMAGRwVABUAFRAAABaw2/v/BxXSARaWzcn/BxV2 + ACbYhsjbBBwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwWsKoTFpAEFqAFJtiGyNsEPDawqhMA + GRwVABUAFRAAABaC3fv/BxXSARaMzsn/BxV2ACb4i8jbBBwVDBk1BggAGRgNcm9vZl9tYXRlcmlh + bBUMFrCqExaQBBagBSb4i8jbBDw2sKoTABkcFQAVABUQAAAW1N77/wcV0gEWgs/J/wcVdgAmmJHI + 2wQcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBawqhMWkAQWoAUmmJHI2wQ8NrCqEwAZHBUAFQAVEAAA + Fqbg+/8HFdIBFvjPyf8HFXYAJriWyNsEHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFrCqExaQ + BBagBSa4lsjbBDw2sKoTABkcFQAVABUQAAAW+OH7/wcV0gEW7tDJ/wcVdgAm2JvI2wQcFQwZNQYI + ABkYEHJvb2Zfb3JpZW50YXRpb24VDBawqhMWkAQWoAUm2JvI2wQ8NrCqEwAZHBUAFQAVEAAAFsrj + +/8HFdIBFuTRyf8HFXYAJvigyNsEHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWsKoTFpAEFqAFJvig + yNsEPDawqhMAGRwVABUAFRAAABac5fv/BxXSARba0sn/BxV2ACaYpsjbBBwVChk1BggAGRgLcm9v + Zl9oZWlnaHQVDBawqhMWkAQWoAUmmKbI2wQ8NrCqEwAZHBUAFQAVEAAAFu7m+/8HFdIBFtDTyf8H + FXYAFpq46BoWsKoTJuL6qs0EFtawnQ4UUgAZ/CYmuKvI2wQcFQwZNQYIABkYAmlkFQwWiMMTFvDy + vgUWxqXMASa4q8jbBDw2ACggMDhiYjJkZGI2ZWI4ZGZmZjAyMDA2ZjRlYzRiYTBiNWUYIDA4YmIy + YzAwOTAwODBmZmYwMjAwZjk0ZWEwYTBkNjQ4ABkcFQAVABUQAAAWwOj7/wcV8gEWxtTJ/wcV1ggA + Jv7QlN0EHBUMGTUGCAAZGAhnZW9tZXRyeRUMFojDExbyxOcPFqCZswkm/tCU3QQ8NgAo4wEAAAAA + BgAAAAIAAAAAAwAAAAEAAAAHwFIActp9j3jAQTE6+dER1sBSAHI3wGCuwEExP6D/v2jAUgBryDqW + 1cBBMT07yrFqwFIAaxqVrXzAQTFCNFf2YcBSAGihqglTwEExQUifrALAUgBp8neBQcBBMTepunkN + wFIActp9j3jAQTE6+dER1gAAAAADAAAAAQAAAAXAUgBomG/N7sBBMTe0ojOcwFIAZ1eSjg3AQTFB + HdeBXMBSAGUAoDjwwEExQESTrcfAUgBmQX140sBBMTbbXmAIwFIAaJhvze7AQTE3tKIznBhNAAAA + AAMAAAABAAAABMBRyppWS+5LwEGj9qRuIPHAUcqaMAYQrcBBo/f6+j6SwFHKmZTJKy/AQaP3zFPV + BMBRyppWS+5LwEGj9qRuIPEAGRwVABUAFSQAABay6vv/BxWgBBac3cn/BxWuJQAmnurH5gQcFQgZ + NQYIABkoBGJib3gEeG1pbhUMFojDExbwkE4WkIctJp7qx+YEPBgEgaCMwhgEMY2QwhYAKASBoIzC + GAQxjZDCABkcFQAVABUQAAAW0u77/wcV8gEWyoLK/wcV1gEAJq7x9OYEHBUIGTUGCAAZKARiYm94 + BHhtYXgVDBaIwxMW8JBOFuqDLSau8fTmBDwYBHegjMIYBC2NkMIWACgEd6CMwhgELY2QwgAZHBUA + FQAVEAAAFsTw+/8HFfIBFqCEyv8HFdYBACaY9aHnBBwVCBk1BggAGSgEYmJveAR5bWluFQwWiMMT + FvCQTha69TAmmPWh5wQ8GAR5BgfCGATqbQ/CFgAoBHkGB8IYBOptD8IAGRwVABUAFRAAABa28vv/ + BxXyARb2hcr/BxXWAQAm0urS5wQcFQgZNQYIABkoBGJib3gEeW1heBUMFojDExbwkE4W9vowJtLq + 0ucEPBgEagYHwhgE0m0PwhYAKARqBgfCGATSbQ/CABkcFQAVABUQAAAWqPT7/wcV8gEWzIfK/wcV + 1gEAJojmg+gEHBUCGTUGCAQZGAd2ZXJzaW9uFQwWiMMTFv4EFqAGJojmg+gEJsjlg+gEHBgEAAAA + ABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFpr2+/8HFdIBFqKJyv8HFdYB + ACao7IPoBBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFojDExb+BRag + Byao7IPoBCbo64PoBBwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFuz3+/8HFdIBFviKyv8H + FVYAJsz0g+gEHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaIwxMWouME + FpaPAybM9IPoBCaI84PoBBw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdz + ABksFQQVBBUCABUAFQQVEAAAFr75+/8HFeIBFs6Lyv8HFfYEACaegofoBBwVDBklBgAZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaIwxMW1N7cAhbouooBJp6Ch+gEPDYAKAx3OTk3 + NjA5MjcxQDEYDDAwMDA3MGJiYjA0NgAZHBUAFQAVEAAAFqD7+/8HFfIBFsSQyv8HFdQDACaui5Lp + BBwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFojDExacrBYWqq0H + Jq6LkukEJoa9kekEHDYAKBgyMDI0LTEwLTMwVDEzOjI2OjQ1LjAwMFoYGDIwMDAtMDEtMDFUMDA6 + MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABaS/fv/BxXoARaYlMr/BxXWBgAm6oOa6QQcFQoZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFojDExas/xMW2MsQJuqDmukE + JrDqmOkEHBgINKK0N/jC7j8YCM3MzMzMzOQ/Fo7JDCgINKK0N/jC7j8YCM3MzMzMzOQ/ABksFQQV + BBUCABUAFQQVEAAAFvr++/8HFfIBFu6ayv8HFfYCACaItqnpBBwVAhk1BggAGRgFbGV2ZWwVDBaI + wxMW2AUW1AYmiLap6QQ8GAQBAAAAGAQBAAAAFvDCEygEAQAAABgEAQAAAAAZHBUAFQAVEAAAFuyA + /P8HFdYBFuSdyv8HFcYBACaCv6npBBwVDBk1BggEGRgHc3VidHlwZRUMFojDExawYxbsXCaCv6np + BCbcvKnpBBw21PQRKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EAAAFsKC/P8HFeIBFqqfyv8HFdADACaenarpBBwVDBk1BggEGRgFY2xhc3MVDBaIwxMWxmIWnFwm + np2q6QQmyJmq6QQcNpj2ESgJd2FyZWhvdXNlGAVjYWJpbgAZLBUEFQQVAgAVABUEFRAAABakhPz/ + BxXiARb6osr/BxXeAgAm5PWq6QQcFQoZNQYIABkYBmhlaWdodBUMFojDExbEBBbUBSbk9arpBDwY + CAAAAAAAAC5AGAgAAAAAAAAcQBaEwxMoCAAAAAAAAC5AGAgAAAAAAAAcQAAZHBUAFQAVEAAAFoaG + /P8HFdQBFtilyv8HFZYBACa4+6rpBBwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFojDExagbBaG + SSa4+6rpBDw2sr8TKARZb2xpGBYzIENvbWlzYXLDrWEgUGljaGlsZW11ABkcFQAVABUQAAAW2of8 + /wcV4gEW7qbK/wcVxgUAJr7Eq+kEHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5 + FQwWisMTFqgVFt4RJr7Eq+kEPDaAwxMoAmVzGAJlbgAZHBUAFQAVEAAAFryJ/P8HFeIBFrSsyv8H + FX4AJpzWq+kEHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBaKwxMWoBkW + yBMmnNar6QQ8NoDDEygVUGFuYWRlcsOtYSBkb24gbWFudWVsGA5Eb25kZSBDb2NodWVsbwAZHBUA + FQAVEAAAFp6L/P8HFeIBFrKtyv8HFbwBACbk6avpBBwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHdmFyaWFudBUMFozDExbeGRb4Eybk6avpBDw2+sITKAhvZmZpY2lhbBgJYWx0ZXJu + YXRlABkcFQAVABUQAAAWgI38/wcV4gEW7q7K/wcV/gEAJtz9q+kEHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFozDExb6FxbwEibc/avpBDw2jMMTABkcFQAVABUQ + AAAW4o78/wcV4gEW7LDK/wcVdgAmzJCs6QQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50BXZhbHVlFQwWjMMTFrwbFugVJsyQrOkEPDb6whMoFEdyYW4gSG90ZWwgUGljaGlsZW11GBlC + YW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlABkcFQAVABUQAAAWxJD8/wcV4gEW4rHK/wcV1gMAJrSm + rOkEHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVu + dBUMFozDExb8FxbmEia0pqzpBDw2jMMTABkcFQAVABUQAAAWppL8/wcV4gEWuLXK/wcVdgAmmrms + 6QQcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaMwxMW+hcW8BImmrms + 6QQ8NozDEwAZHBUAFQAVEAAAFoiU/P8HFeIBFq62yv8HFXYAJorMrOkEHBUAGTUGCAAZGAloYXNf + cGFydHMVDBaIwxMW0LwCFtIGJorMrOkEPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAW6pX8/wcV + 0gEWpLfK/wcVdgAm3NKs6QQcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWiMMTFtK8AhawBibc + 0qzpBDwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFryX/P8HFdIBFpq4yv8HFXYAJozZrOkEHBUC + GTUGCAAZGApudW1fZmxvb3JzFQwWiMMTFsAKFsYIJozZrOkEPBgEBAAAABgEAQAAABaAwhMoBAQA + AAAYBAEAAAAAGRwVABUAFRAAABaOmfz/BxXaARaQucr/BxXGAQAm0uGs6QQcFQIZNQYIABkYFm51 + bV9mbG9vcnNfdW5kZXJncm91bmQVDBaIwxMWkAQWoAUm0uGs6QQ8NojDEwAZHBUAFQAVEAAAFuia + /P8HFdIBFta6yv8HFXYAJvLmrOkEHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWiMMTFpAEFqAFJvLm + rOkEPDaIwxMAGRwVABUAFRAAABa6nPz/BxXSARbMu8r/BxV2ACaS7KzpBBwVAhk1BggAGRgJbWlu + X2Zsb29yFQwWiMMTFpAEFqAFJpLsrOkEPDaIwxMAGRwVABUAFRAAABaMnvz/BxXSARbCvMr/BxV2 + ACay8azpBBwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWiMMTFpAEFqAFJrLxrOkEPDaIwxMAGRwV + ABUAFRAAABben/z/BxXSARa4vcr/BxV2ACbS9qzpBBwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFs + FQwWiMMTFroEFsoFJtL2rOkEPBgMY2VtZW50X2Jsb2NrGAxjZW1lbnRfYmxvY2sWhsMTKAxjZW1l + bnRfYmxvY2sYDGNlbWVudF9ibG9jawAZHBUAFQAVEAAAFrCh/P8HFdIBFq6+yv8HFaYBACac/Kzp + BBwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFojDExaQBBagBSac/KzpBDw2iMMTABkcFQAVABUQ + AAAWgqP8/wcV0gEW1L/K/wcVdgAmvIGt6QQcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaIwxMWkAQW + oAUmvIGt6QQ8NojDEwAZHBUAFQAVEAAAFtSk/P8HFdIBFsrAyv8HFXYAJtyGrekEHBUKGTUGCAAZ + GA5yb29mX2RpcmVjdGlvbhUMFojDExaQBBagBSbchq3pBDw2iMMTABkcFQAVABUQAAAWpqb8/wcV + 0gEWwMHK/wcVdgAm/Iut6QQcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBaIwxMWkAQWoAUm + /Iut6QQ8NojDEwAZHBUAFQAVEAAAFvin/P8HFdIBFrbCyv8HFXYAJpyRrekEHBUMGTUGCAAZGApy + b29mX2NvbG9yFQwWiMMTFpAEFqAFJpyRrekEPDaIwxMAGRwVABUAFRAAABbKqfz/BxXSARasw8r/ + BxV2ACa8lq3pBBwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBaIwxMWkAQWoAUmvJat6QQ8NojDEwAZ + HBUAFQAVEAAAFpyr/P8HFdIBFqLEyv8HFXYAFpyN9BoWiMMTJriryNsEFqTw5A0UVAAZ/CYm3Jut + 6QQcFQwZNQYIABkYAmlkFQwW7KATFoCjtQUW1uvGASbcm63pBDw2ACggMDhiYjJjZWRiM2QyNmZm + ZjAyMDA4MmQxOTVmNDEzN2EYIDA4YmIyYzMwMDAzMmRmZmYwMjAwOGRlOGFhNDY3NzQ4ABkcFQAV + ABUQAAAW7qz8/wcV8gEWmMXK/wcV1ggAJrKH9OoEHBUMGTUGCAAZGAhnZW9tZXRyeRUMFuygExa+ + +soQFrrT8gkmsof06gQ8NgAorQsAAAAAAwAAAAUAAABAwFHeGhs0OO3AQYfizBKSqsBR3hobNDjt + wEGH4uU9BhvAUd4WINO1HsBBh+Ljj4bxwFHeFiDTtR7AQYfi059O5cBR3hXu6i4HwEGH4tR2DnrA + Ud4V7uouB8BBh+Ljj4bxwFHeEEd14FfAQYfi313JCcBR3gbADaGpwEGH4vKo/2jAUd4GwA2hqcBB + h+LaVUuMwFHeBoBMwXrAQYfi2lVLjMBR3gaATMF6wEGH4ss70xXAUd4FjDD7S8BBh+LLO9MVwFHe + BYvFm4DAQYfZ39rGi8BR3gSy7Se2wEGH2d8EBvbAUd4EtJqm4MBBh9ZoVwFvwFHeBK5QCgTAQYfW + aFcBb8BR3gSt5Ko5wEGHzDNJ2WjAUd4EuTfEksBBh8wzSdlowFHeBLmjJF3AQYfLF8Dm5cBR3gWL + xZuAwEGHyxiXpnrAUd4Fiu7b68BBh7xi8j2gwFHeBer7i/3AQYe8YvI9oMBR3gXq+4v9wEGHvEMR + zYjAUd4Ga79ru8BBh7xDEc2IwFHeBnNMJ/fAQYe3Y678AcBR3gZ/4WGvwEGHt2Ou/AHAUd4Ggzxg + A8BBh6+vhZQpwFHeB9im9aPAQYevsTMTU8BR3gfav9SXwEGHrkN0ydbAUd4JbJBME8BBh65KKsZ9 + wFHeCWz7q93AQYetXMT89cBR3gmRDdndwEGHrV2bvIrAUd4Jrf6rbMBBh5fbU3hNwFHeC2qXTY/A + QYeX3de3DMBR3gtql02PwEGHl/wKp/rAUd4N2d1WiMBBh5gGG6L0wFHeDdlx9r3AQYeYRdyDI8BR + 3g4hKvLzwEGHmEazQrjAUd4OIm0SUsBBh5dnkDISwFHeEh57FUrAQYeXeFcps8BR3hH09QoDwEGH + ssQNCqrAUd4SGQc4A8BBh7LEDQqqwFHeEkL4oxTAQYeXeFcps8BR3hQScRvMwEGHl3/j5e7AUd4U + Etx7lsBBh5cwMs2zwFHeEm9uTOXAQYeXJ89R4sBR3hJx8oujwEGHlbNbC7/AUd4TNj2pr8BBh5W2 + tgoTwFHeEzjB6G3AQYeUTgA+E8BR3hQYUFjewEGHlFIx+/zAUd4UHO12kcBBh5Hi6/MDwFHeFVap + WgHAQYeR6MswFcBR3hVZmPiKwEGHkFHyOxvAUd4WpclSxcBBh5BX0XgtwFHeFqkkURjAQYeOjczc + vcBR3hqz4Gy9wEGHjqHu0rHAUd4abdTvscBBh7TqV/gPwFHeGl8m1wTAQYe06YE4esBR3hom8rMQ + wEGH2YlzsanAUd4aHU0X4cBBh9mJc7GpwFHeGhufmLfAQYfgmgkrIsBR3hqbIVkWwEGH4Jkya43A + Ud4anGN4dcBBh+LLO9MVwFHeGhs0OO3AQYfizBKSqgAAAAXAUd4WIT8U6cBBh+ChleddwFHeFiKB + NEjAQYfZiyEw0sBR3hXxAwz7wEGH2YshMNLAUd4V71WN0cBBh+CibKbywFHeFiE/FOnAQYfgoZXn + XQAAAAnAUd4R3KFWJsBBh+EMHvI0wFHeEd5O1VDAQYfZhhizVcBR3hHKmD8nwEGH2YYYs1XAUd4R + yizfXMBBh9nvyv6WwFHeEbiPKCfAQYfZ78r+lsBR3hG4jygnwEGH2fguemfAUd4RpUPxx8BBh9n3 + V7rSwFHeEaVD8cfAQYfhDB7yNMBR3hHcoVYmwEGH4Qwe8jQAAAAGwFHeDaeIb6bAQYfhFIJuBMBR + 3g2niG+mwEGH4P0Feb3AUd4Npx0P28BBh9nqwoEZwFHeDV9kE6bAQYfZ6sKBGcBR3g1fz3NwwEGH + 4RSCbgTAUd4Np4hvpsBBh+EUgm4EAAAABcBR3g6pe47twEGHuBm3YSvAUd4QJ5VwP8BBh7gflp49 + wFHeEClC72nAQYe3NmKSnMBR3g6qva5MwEGHtzCDVYrAUd4OqXuO7cBBh7gZt2ErGE0AAAAAAwAA + AAEAAAAEwFHOmAFy08fAQW4aujgJtsBRzpgVvnl0wEFuGdLfxwPAUc6YtZIJnsBBbhrlKdXDwFHO + mAFy08fAQW4aujgJtgAZHBUAFQAVJgAAFuCu/P8HFb4EFu7Nyv8HFbYnACbs2ub0BBwVCBk1BggA + GSgEYmJveAR4bWluFQwW7KATFoCITRacjyom7Nrm9AQ8GAQHCI7CGAQGcI/CFgAoBAcIjsIYBAZw + j8IAGRwVABUAFRAAABaes/z/BxXyARak9cr/BxXWAQAmiOqQ9QQcFQgZNQYIABkoBGJib3gEeG1h + eBUMFuygExb+h00W9pkqJojqkPUEPBgE9weOwhgE82+PwhYAKAT3B47CGATzb4/CABkcFQAVABUQ + AAAWkLX8/wcV8gEW+vbK/wcV1gEAJv6Du/UEHBUIGTUGCAAZKARiYm94BHltaW4VDBbsoBMWgIhN + FqaJLSb+g7v1BDwYBAs4C8IYBEagDMIWACgECzgLwhgERqAMwgAZHBUAFQAVEAAAFoK3/P8HFfIB + FtD4yv8HFdYBACakjej1BBwVCBk1BggAGSgEYmJveAR5bWF4FQwW7KATFoCITRbSki0mpI3o9QQ8 + GATvNwvCGAT4nwzCFgAoBO83C8IYBPifDMIAGRwVABUAFRAAABb0uPz/BxXyARam+sr/BxXWAQAm + tqCV9gQcFQIZNQYIBBkYB3ZlcnNpb24VDBbsoBMW/AQWngYmtqCV9gQm9p+V9gQcGAQAAAAAGAQA + AAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW5rr8/wcV0gEW/PvK/wcV1gEAJtSm + lfYEHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW7KATFv4FFqAHJtSm + lfYEJpSmlfYEHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWuLz8/wcV0gEW0v3K/wcVVgAm + +K6V9gQcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFuygExbErAQWtvgC + JviulfYEJrStlfYEHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwV + BBUEFQIAFQAVBBUQAAAWir78/wcV4gEWqP7K/wcV9gQAJuqlmPYEHBUMGSUGABlIB3NvdXJjZXME + bGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFuygExbmq+ICFrKyfybqpZj2BDw2ACgMdzk5Mjk2Nzg5 + NUAxGAwwMDAwNGEwODUzYjMAGRwVABUAFRAAABbsv/z/BxXyARaeg8v/BxXUAwAmoJ+Y9wQcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbsoBMWvqwUFqyDByagn5j3 + BCac2Jf3BBw2ACgYMjAyNC0xMS0xN1QxNzo0MjoxNi4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAw + LjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAW3sH8/wcV5AEW8obL/wcV1gYAJtL3n/cEHBUKGSUGBBlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbsoBMW8LYWFqanEybS95/3BCbI2573 + BBwYCIts5/up8e4/GAjNzMzMzMzkPxa+qwooCIts5/up8e4/GAjNzMzMzMzkPwAZLBUEFQQVAgAV + ABUEFRAAABbCw/z/BxXyARbIjcv/BxX0AgAm7oKy9wQcFQIZNQYIABkYBWxldmVsFQwW7KATFtoE + FuoFJu6CsvcEPBgEAQAAABgEAQAAABbkoBMoBAEAAAAYBAEAAAAAGRwVABUAFRAAABa0xfz/BxXS + ARa8kMv/BxW2AQAm/Iqy9wQcFQwZNQYIBBkYB3N1YnR5cGUVDBbsoBMWhmgWpF4m/Iqy9wQm2Iiy + 9wQcNvDJESgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABaG + x/z/BxXiARbykcv/BxWyAwAm7Oqy9wQcFQwZNQYIBBkYBWNsYXNzFQwW7KATFqBnFoJeJuzqsvcE + JvzmsvcEHDamyxEoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABboyPz/ + BxXiARaklcv/BxXeAgAm/sSz9wQcFQoZNQYIABkYBmhlaWdodBUMFuygExbKBRaGBib+xLP3BDwY + CAAAAAAAACxAGAgAAAAAAAAIQBbaoBMoCAAAAAAAACxAGAgAAAAAAAAIQAAZHBUAFQAVEAAAFsrK + /P8HFdYBFoKYy/8HFbYBACaEy7P3BBwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFuygExbweBac + TiaEy7P3BDw2wpwTKBByZXTDqW4gZW4gcnVpbmFzGCQxIHkgMiBKdXpnYWRvIFBvbGljw61hIExv + Y2FsIEN1cmljw7MAGRwVABUAFRAAABagzPz/BxXiARa4mcv/BxWcBgAmoJm09wQcFQwZJQYAGUgF + bmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbyoBMW+hcW0hMmoJm09wQ8NuSgEygCZXMYAmVu + ABkcFQAVABUQAAAWgs78/wcV4AEW1J/L/wcVhgEAJvKstPcEHBUMGSUGABlIBW5hbWVzBmNvbW1v + bglrZXlfdmFsdWUFdmFsdWUVDBbyoBMW2hwWohUm8qy09wQ8NuSgEygKU3RhdGUgQmFuaxgMQmFu + Y28gRXN0YWRvABkcFQAVABUQAAAW4s/8/wcV4gEW2qDL/wcV9gEAJpTCtPcEHBUMGSUGABlYBW5h + bWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW9qATFpQdFtgVJpTCtPcEPDbeoBMoCG9m + ZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRAAABbE0fz/BxXiARbQosv/BxWAAgAm7Ne09wQcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW9qATFoIbFpQUJuzXtPcE + PDbyoBMoAmVzGAJlbgAZHBUAFQAVEAAAFqbT/P8HFeIBFtCky/8HFX4AJoDstPcEHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFvagExayIBbYFyaA7LT3BDw23qATKBpT + YWwgeSBQaW1pZW50YSBjb2xhY2nDs25lcxgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUA + FQAVEAAAFojV/P8HFeIBFs6ly/8HFewDACbYg7X3BBwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBb2oBMW8hoW+BMm2IO19wQ8NvagEwAZHBUA + FQAVEAAAFurW/P8HFeIBFrqpy/8HFXYAJtCXtfcEHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudARzaWRlFQwW9qATFuoaFvITJtCXtfcEPDb2oBMAGRwVABUAFRAAABbM2Pz/BxXiARaw + qsv/BxV2ACbCq7X3BBwVABk1BggAGRgJaGFzX3BhcnRzFQwW7KATFq64AhawBibCq7X3BDwYAQAY + AQAWACgBABgBAAAZHBUAFQAVEAAAFq7a/P8HFdIBFqary/8HFXYAJvKxtfcEHBUAGTUGCAAZGA5p + c191bmRlcmdyb3VuZBUMFuygExauuAIWsAYm8rG19wQ8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAA + ABaA3Pz/BxXSARacrMv/BxV2ACaiuLX3BBwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFuygExbaCha8 + CSaiuLX3BDwYBA0AAAAYBAEAAAAW9J8TKAQNAAAAGAQBAAAAABkcFQAVABUQAAAW0t38/wcV2gEW + kq3L/wcVxgEAJt7BtfcEHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW7KATFpAE + FqAFJt7BtfcEPDbsoBMAGRwVABUAFRAAABas3/z/BxXSARbYrsv/BxV2ACb+xrX3BBwVChk1BggA + GRgKbWluX2hlaWdodBUMFuygExaQBBagBSb+xrX3BDw27KATABkcFQAVABUQAAAW/uD8/wcV0gEW + zq/L/wcVdgAmnsy19wQcFQIZNQYIABkYCW1pbl9mbG9vchUMFuygExaQBBagBSaezLX3BDw27KAT + ABkcFQAVABUQAAAW0OL8/wcV0gEWxLDL/wcVdgAmvtG19wQcFQwZNQYIABkYDGZhY2FkZV9jb2xv + chUMFuygExbQBBbgBSa+0bX3BDw26KATKAcjNzc4ODk5GAcjMDAwMEZGABkcFQAVABUQAAAWouT8 + /wcV1AEWurHL/wcVkgEAJp7XtfcEHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbsoBMWkAQW + oAUmnte19wQ8NuygEwAZHBUAFQAVEAAAFvbl/P8HFdIBFsyyy/8HFXYAJr7ctfcEHBUMGTUGCAAZ + GA1yb29mX21hdGVyaWFsFQwW7KATFpAEFqAFJr7ctfcEPDbsoBMAGRwVABUAFRAAABbI5/z/BxXS + ARbCs8v/BxV2ACbe4bX3BBwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFuygExaQBBagBSbe4bX3BDw2 + 7KATABkcFQAVABUQAAAWmun8/wcV0gEWuLTL/wcVdgAm/ua19wQcFQoZNQYIABkYDnJvb2ZfZGly + ZWN0aW9uFQwW7KATFpAEFqAFJv7mtfcEPDbsoBMAGRwVABUAFRAAABbs6vz/BxXSARautcv/BxV2 + ACae7LX3BBwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFuygExaQBBagBSae7LX3BDw27KAT + ABkcFQAVABUQAAAWvuz8/wcV0gEWpLbL/wcVdgAmvvG19wQcFQwZNQYIABkYCnJvb2ZfY29sb3IV + DBbsoBMWkAQWoAUmvvG19wQ8NuygEwAZHBUAFQAVEAAAFpDu/P8HFdIBFpq3y/8HFXYAJt72tfcE + HBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFuygExaQBBagBSbe9rX3BDw27KATABkcFQAVABUQAAAW + 4u/8/wcV0gEWkLjL/wcVdgAW5sLPGxbsoBMm3Jut6QQWouCIDhRWABn8Jib++7X3BBwVDBk1BggA + GRgCaWQVDBbEpRMW3su2BRbs78gBJv77tfcEPDYAKCAwOGJiMmNlZGI2ZGFlZmZmMDIwMGQ2NzFh + Y2MxYmVjZRggMDhiYjJjMDZjODA5OGZmZjAyMDBlMjkxMzc4M2ZmNmYAGRwVABUAFRAAABa08fz/ + BxXyARaGucv/BxXWCAAm6uv++AQcFQwZNQYIABkYCGdlb21ldHJ5FQwWxKUTFrCughAW2KnMCSbq + 6/74BDw2ACjnDQAAAAAGAAAABgAAAAADAAAAAQAAABTAUc3tcRyizsBBU+XuBgJ5wFHN7RA5MyfA + QVPlYEGJN8BRzezPoZNjwEFT5Ke05U/AUc3stTUAk8BBU+PW1I2LwFHN7MROeQrAQVPjA2/3CcBR + zez7QH2fwEFT4kJ/11HAUc3tVCvRP8BBU+GoJiRXwFHN7cZBmFHAQVPhQqWW/sBRze5Fw1iwwEFT + 4R6TaP7AUc3u0JgzaMBBU+FDfFaTwFHN70t81hTAQVPhtLteD8BRze+nV8g+wEFT4mQNxpLAUc3v + 2ayvIMBBU+M8etqSwFHN79vFjhTAQVPkJAFnCMBRze+tomUawEFT5P7yucbAUc3vVLcResBBU+Wy + duAxwFHN7ubTCFDAQVPmIt8oGcBRze5o/scbwEFT5lRdT2bAUc3t58+HksBBU+ZB6NicwFHN7XEc + os7AQVPl7gYCeQAAAAADAAAAAQAAABTAUc3wTka08MBBU+RoysS1wFHN8Gkep4vAQVPjotIngMBR + zfCq+GavwEFT4vYD/bzAUc3xC3B2i8BBU+J3WPzxwFHN8X+fHJDAQVPiM2Ze2sBRzfH7Wn7SwEFT + 4jKPn0XAUc3ybJmGTsBBU+JyUH90wFHN8stkFwHAQVPi6W7EA8BRzfMOFJW5wEFT440CsmLAUc3z + LYmmB8BBU+RKl9PHwFHN8ybTqWDAQVPlDuLx0sBRzfL58p/FwEFT5cXCFpDAUc3yq+8Gs8BBU+Za + PIx4wFHN8kUsWfvAQVPmvuZaPcBRzfHQJvRhwEFT5ugBBbnAUc3xWXQPnMBBU+bRWtEHwFHN8Oni + h0nAQVPmeUY8+8BRzfCSOVMIwEFT5enURJDAUc3wXB4OCMBBU+Uy9R/SwFHN8E5GtPDAQVPkaMrE + tQAAAAADAAAAAQAAABTAUc3wLY+FRMBBU99PhlARwFHN8FaqMMHAQVPfhTY1RsBRzfBzmwJPwEFT + 381akUbAUc3wgXJbZ8BBU+AhPWdqwFHN8H4XXRTAQVPgd6R8TMBRzfBqzCa1wEFT4MgsVBzAUc3w + SGd33sBBU+EJmrN1wFHN8BkCL4XAQVPhOJScBMBRze/ie4q7wEFT4UsJEs7AUc3vq4mGJsBBU+E+ + c9kWwFHN73oLXtnAQVPhE6uub8BRze9US7GvwEFT4NFmj4HAUc3vPhDcx8BBU+B9g7lewFHN7znf + Ht/AQVPgIhQm/sBRze9IjTeMwEFT38n/kvPAUc3vaAJH2cBBU99/Vvg0wFHN75TjUXTAQVPfSacS + /8BRze/HODhWwEFT3zB8n47AUc3v/BFd9sBBU98yKh63wFHN8C2PhUTAQVPfT4ZQEQAAAAADAAAA + AQAAABTAUc3uLrHEM8BBU+CvAeCrwFHN7e7w5APAQVPgmTJrjcBRze23KB/awEFT4GKrxsPAUc3t + jg10XcBBU+APn7A0wFHN7XfSn3XAQVPfq8yiBcBRze13Zz+qwEFT30Bs15rAUc3tjMtU/sBBU97b + wwnVwFHN7bUPQObAQVPeh+AzssBRze3sbKVFwEFT3k+sD77AUc3uK8IlqsBBU945BdsLwFHN7mdR + R/HAQVPeQ+2VmsBRze6d1+y7wEFT3m0IQRfAUc3uyeI2wcBBU96vTWAFwFHN7uepx+XAQVPfBAb1 + vsBRze7z06HTwEFT32R/BZrAUc3u7R2lLMBBU9/GpJSfwFHN7tTJ8VDAQVPgIGan1cBRze6oVEeA + wEFT4G5qQObAUc3ubt4ELcBBU+Cf6Gg0wFHN7i6xxDPAQVPgrwHgqwAAAAADAAAAAQAAABTAUc3o + qGAF+sBBU9+ocaOxwFHN6NYXzyrAQVPemytqEcBRzek3Zp6bwEFT3bYpHFnAUc3pwdAZiMBBU90U + Qq0kwFHN6mT4qB3AQVPcxxXTp8BRzesExjhewEFT3NSBzPTAUc3rmawOEMBBU900Ix07wFHN7BT8 + EIfAQVPd2+jJg8BRzexptaZAwEFT3ro1GpTAUc3sj3VTacBBU9+6D1rnwFHN7ILgGbHAQVPgwJ+X + 4MBRzexEYVjgwEFT4bI3H1HAUc3r2q8Nn8BBU+J4L7yGwFHN61Cw8nzAQVPi/Ln6YsBRzeqqLWWU + wEFT4zQXXsHAUc3qAfxZgsBBU+MMqjJuwFHN6WtpBKbAQVPii3ry5cBRzej4ER41wEFT4b7MWQrA + Uc3otB6AHsBBU+C+8hi3wFHN6KhgBfrAQVPfqHGjsQAAAAADAAAAAQAAAAXAUc38gcY+PcBBU+VN + zRJtwFHN+9fnswLAQVPp+gQ9fMBRzfNcg46VwEFT5rdZngHAUc30Bs15m8BBU+IKS7NdwFHN/IHG + Pj3AQVPlTc0SbRhNAAAAAAMAAAABAAAABMBRxBGqwJ2GwEFcm40ccwDAUcQR23oF58BBXJyGvkjD + wFHEEVZA/SPAQVyczaX7ssBRxBGqwJ2GwEFcm40ccwAAGRwVABUAFSQAABam8/z/BxWgBBbcwcv/ + BxWuJQAmwpXLggUcFQgZNQYIABkoBGJib3gEeG1pbhUMFsSlExbgmk0WvuIrJsKVy4IFPBgEBQiO + whgE/G+PwhYAKAQFCI7CGAT8b4/CABkcFQAVABUQAAAWxvf8/wcV8gEWiufL/wcV1gEAJoD49oIF + HBUIGTUGCAAZKARiYm94BHhtYXgVDBbEpRMW4JpNFpDeKyaA+PaCBTwYBNMHjsIYBOpvj8IWACgE + 0weOwhgE6m+PwgAZHBUAFQAVEAAAFrj5/P8HFfIBFuDoy/8HFdYBACaQ1qKDBRwVCBk1BggAGSgE + YmJveAR5bWluFQwWxKUTFuCaTRbosy8mkNaigwU8GAQJ0AnCGAQO7AvCFgAoBAnQCcIYBA7sC8IA + GRwVABUAFRAAABaq+/z/BxXyARa26sv/BxXWAQAm+InSgwUcFQgZNQYIABkoBGJib3gEeW1heBUM + FsSlExbgmk0W7rgvJviJ0oMFPBgE7c8JwhgE9usLwhYAKATtzwnCGAT26wvCABkcFQAVABUQAAAW + nP38/wcV8gEWjOzL/wcV1gEAJqbDgYQFHBUCGTUGCAQZGAd2ZXJzaW9uFQwWxKUTFv4EFqAGJqbD + gYQFJubCgYQFHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFo7/ + /P8HFdIBFuLty/8HFdYBACbGyYGEBRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9w + ZXJ0eRUMFsSlExb+BRagBybGyYGEBSaGyYGEBRwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAA + FuCA/f8HFdIBFrjvy/8HFVYAJurRgYQFHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2Rh + dGFzZXQVDBbEpRMW8N4EFojjAibq0YGEBSam0IGEBRw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xl + IE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFrKC/f8HFeIBFo7wy/8HFfYEACaus4SE + BRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbEpRMW9oXcAhb03osB + Jq6zhIQFPDYAKAx3OTk3MzIxMTYwQDIYDDAwMDEwZTBiYzIxMwAZHBUAFQAVEAAAFpSE/f8HFfIB + FoT1y/8HFdYDACaO0pCFBRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGlt + ZRUMFsSlExaE8BQWxNgGJo7SkIUFJqKSkIUFHDYAKBgyMDI0LTExLTA4VDAwOjA3OjE4LjAwMFoY + GDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABaGhv3/BxXkARba+Mv/ + BxXWBgAmkoaYhQUcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsSl + ExaKvBUW1JQSJpKGmIUFJubqloUFHBgIO3DOiNLe7j8YCM3MzMzMzOQ/FsK6CygIO3DOiNLe7j8Y + CM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFuqH/f8HFfIBFrD/y/8HFfYCACa6/6iFBRwVAhk1 + BggAGRgFbGV2ZWwVDBbEpRMW+AUWiAcmuv+ohQU8GAQBAAAAGAT/////FqqlEygEAQAAABgE//// + /wAZHBUAFQAVEAAAFtyJ/f8HFdYBFqaCzP8HFdYBACbaiKmFBRwVDBk1BggEGRgHc3VidHlwZRUM + FsSlExbsLBasJybaiKmFBSbChqmFBRw21IMTKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFs + ABksFQQVBBUCABUAFQQVEAAAFrKL/f8HFeIBFvyDzP8HFeQDACaUsqmFBRwVDBk1BggEGRgFY2xh + c3MVDBbEpRMWtC0W1icmlLKphQUm7q2phQUcNvaEEygJd2FyZWhvdXNlGAphcGFydG1lbnRzABks + FQQVBBUCABUAFQQVEAAAFpSN/f8HFeIBFuCHzP8HFY4DACbE1amFBRwVChk1BggAGRgGaGVpZ2h0 + FQwWxKUTFpIFFqIGJsTVqYUFPBgIAAAAAAAAMkAYCAAAAAAAABRAFrqlEygIAAAAAAAAMkAYCAAA + AAAAABRAABkcFQAVABUQAAAW9o79/wcV1gEW7orM/wcV1gEAJubbqYUFHBUMGTUGCAAZKAVuYW1l + cwdwcmltYXJ5FQwWxKUTFrR9FsxLJubbqYUFPDbcoBMoBHNlZGUYETMgQ29taXNhcsOtYSBUZW5v + ABkcFQAVABUQAAAWzJD9/wcV4gEWxIzM/wcVwAQAJrKnqoUFHBUMGSUGABlIBW5hbWVzBmNvbW1v + bglrZXlfdmFsdWUDa2V5FQwWyKUTFtAVFsoSJrKnqoUFPDa+pRMoAmVzGAJlbgAZHBUAFQAVEAAA + Fq6S/f8HFeIBFoSRzP8HFY4BACb8uaqFBRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVl + BXZhbHVlFQwWyKUTFtgZFsgUJvy5qoUFPDa+pRMoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZ + HBUAFQAVEAAAFpCU/f8HFeIBFpKSzP8HFZYCACbEzqqFBRwVDBklBgAZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQHdmFyaWFudBUMFtSlExauHBa+FSbEzqqFBTw2rqUTKAhvZmZpY2lhbBgJYWx0 + ZXJuYXRlABkcFQAVABUQAAAW8pX9/wcV4gEWqJTM/wcVvAIAJoLkqoUFHBUMGSUGABlYBW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFtSlExaIGRbmEyaC5KqFBTw2zKUTKAJlcxgC + ZW4AGRwVABUAFRAAABbUl/3/BxXiARbklsz/BxWGAQAm6PeqhQUcFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW1KUTFs4hFt4ZJuj3qoUFPDaupRMoKFNlcnZpY2lvIGRl + IFVyZ2VuY2lhIGRlIEFsdGEgUmVzb2x1Y2nDs24YH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJz + aW9uZXMAGRwVABUAFRAAABa2mf3/BxXiARbql8z/BxXMBQAmxpGrhQUcFQoZJQYAGXgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW1KUTFuIYFswTJsaRq4UF + PDbUpRMAGRwVABUAFRAAABaYm/3/BxXiARa2ncz/BxV2ACaSpauFBRwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFtSlExbYGBa4EyaSpauFBTw21KUTABkcFQAVABUQAAAW + +pz9/wcV4gEWrJ7M/wcVdgAmyrirhQUcFQAZNQYIABkYCWhhc19wYXJ0cxUMFsSlExb4uAIWrgYm + yrirhQU8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABbcnv3/BxXSARain8z/BxV2ACb4vquFBRwV + ABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBbEpRMW+LgCFq4GJvi+q4UFPBgBABgBABYAKAEAGAEA + ABkcFQAVABUQAAAWrqD9/wcV0gEWmKDM/wcVdgAmpsWrhQUcFQIZNQYIABkYCm51bV9mbG9vcnMV + DBbEpRMW8j8W+g8mpsWrhQU8GAQFAAAAGAQBAAAAFtqYEygEBQAAABgEAQAAAAAZHBUAFQAVEAAA + FoCi/f8HFd4BFo6hzP8HFdYBACag1auFBRwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3Vu + ZBUMFsSlExaQBBagBSag1auFBTw2xKUTABkcFQAVABUQAAAW3qP9/wcV0gEW5KLM/wcVdgAmwNqr + hQUcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbEpRMWkAQWoAUmwNqrhQU8NsSlEwAZHBUAFQAVEAAA + FrCl/f8HFdIBFtqjzP8HFXYAJuDfq4UFHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbEpRMWkAQWoAUm + 4N+rhQU8NsSlEwAZHBUAFQAVEAAAFoKn/f8HFdIBFtCkzP8HFXYAJoDlq4UFHBUMGTUGCAAZGAxm + YWNhZGVfY29sb3IVDBbEpRMWkAQWoAUmgOWrhQU8NsSlEwAZHBUAFQAVEAAAFtSo/f8HFdIBFsal + zP8HFXYAJqDqq4UFHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbEpRMWsgQWwgUmoOqrhQU8 + GAhjb25jcmV0ZRgIY29uY3JldGUWwqUTKAhjb25jcmV0ZRgIY29uY3JldGUAGRwVABUAFRAAABam + qv3/BxXSARa8psz/BxWWAQAm4u+rhQUcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbEpRMWkAQW + oAUm4u+rhQU8NsSlEwAZHBUAFQAVEAAAFvir/f8HFdIBFtKnzP8HFXYAJoL1q4UFHBUMGTUGCAAZ + GApyb29mX3NoYXBlFQwWxKUTFq4EFr4FJoL1q4UFPBgGZ2FibGVkGAZnYWJsZWQWwqUTKAZnYWJs + ZWQYBmdhYmxlZAAZHBUAFQAVEAAAFsqt/f8HFdIBFsiozP8HFY4BACbA+quFBRwVChk1BggAGRgO + cm9vZl9kaXJlY3Rpb24VDBbEpRMWkAQWoAUmwPqrhQU8NsSlEwAZHBUAFQAVEAAAFpyv/f8HFdIB + FtapzP8HFXYAJuD/q4UFHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWxKUTFpAEFqAFJuD/ + q4UFPDbEpRMAGRwVABUAFRAAABbusP3/BxXSARbMqsz/BxV2ACaAhayFBRwVDBk1BggAGRgKcm9v + Zl9jb2xvchUMFsSlExaQBBagBSaAhayFBTw2xKUTABkcFQAVABUQAAAWwLL9/wcV0gEWwqvM/wcV + dgAmoIqshQUcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWxKUTFpAEFqAFJqCKrIUFPDbEpRMAGRwV + ABUAFRAAABaStP3/BxXSARa4rMz/BxV2ABaU+4EbFsSlEyb++7X3BBbCk/YNFFgAGfwmJsCPrIUF + HBUMGTUGCAAZGAJpZBUMFuCuExbQl7kFFuKpyQEmwI+shQU8NgAoIDA4YmIyY2VkYjVkOWVmZmYw + MjAwZGFhMmZhYTNiN2NhGCAwOGJiMmMwMGQzMjE2ZmZmMDIwMDlhMjhjMTE2YzA4ZQAZHBUAFQAV + EAAAFuS1/f8HFfIBFq6tzP8HFdYIACaiufWGBRwVDBk1BggAGRgIZ2VvbWV0cnkVDBbgrhMWju7f + EBbUmN4JJqK59YYFPDYAKNsFAAAAAAYAAAACAAAAAAMAAAADAAAAFMBRv3q2FCOjwEFJjv1eZRDA + Ub95zOAYA8BBSY9unWyNwFG/ebproTnAQUmPBpigdcBRv3f7TsBXwEFJj94u9ODAUb936bEJIsBB + SY96W+axwFG/duCcjWrAQUmQDFId2sBRv3blOascwEFJkC3gDRvAUb9zFMqSYMBBSZH7P6bfwFG/ + cmhnyGbAQUmOHxIT/8BRv3RM2PanwEFJjTyUBQXAUb90hePaMMBBSY6HFuAWwFG/dabgqfnAQUmO + Br5gIsBRv3XdZ07EwEFJja3TDILAUb930V1VRsBBSY30SelYwFG/d/hfIc/AQUmMGKeWssBRv3ck + jyuCwEFJjS16jI7AUb92quyoNMBBSYxPLjt9wFG/d7uN4CjAQUmKLsKLKsBRv3lR+3VXwEFJh7cZ + BmHAUb96thQjo8BBSY79XmUQAAAABcBRv3k6foEPwEFJi/3PpBjAUb95ArW85sBBSYq7sETXwFG/ + eF5LDvLAQUmLk0aZQsBRv3hFi/tLwEFJjK+mS1nAUb95On6BD8BBSYv9z6QYAAAABcBRv3l+3H7x + wEFJjYnA3oLAUb95UZAVjMBBSYyEB2EdwFG/eDiLYcjAQUmNTIQ9EcBRv3gjJ0x1wEFJjkF2wtXA + Ub95ftx+8cBBSY2JwN6CAAAAAAMAAAABAAAADcBRv3WVQvLEwEFJhfZOplbAUb92jE5XfMBBSYcT + hRgCwFG/dxwrr7HAQUmICvvchcBRv3ZxCwUXwEFJibKbyR/AUb93BK67asBBSYpUgjhUwFG/dlfg + kabAQUmMAFPi1sBRv3XxiUS4wEFJi4/rmu7AUb91tfoicMBBSYu8YUS+wFG/dWcfycrAQUmMiQ/e + msBRv3QwvuStwEFJi0RsQJvAUb90fKmeysBBSYp+c6NmwFG/dAX2ugbAQUmKAyOg78BRv3WVQvLE + wEFJhfZOplYYTQAAAAADAAAAAQAAAATAUbVmfTRwKcBBXQPqbS84wFG1ZrkNskfAQV0E7FLZyMBR + tWYLIJ7wwEFdBVpf1/HAUbVmfTRwKcBBXQPqbS84ABkcFQAVABUmAAAW1rf9/wcVvgQWhLbM/wcV + ticAJvbR05AFHBUIGTUGCAAZKARiYm94BHhtaW4VDBbgrhMW0L9NFu7VKyb20dOQBTwYBB6gjMIY + BAZwj8IWACgEHqCMwhgEBnCPwgAZHBUAFQAVEAAAFpS8/f8HFfIBFrrdzP8HFdYBACbkp/+QBRwV + CBk1BggAGSgEYmJveAR4bWF4FQwW4K4TFsy/TRbS3Csm5Kf/kAU8GAQWoIzCGAT6b4/CFgAoBBag + jMIYBPpvj8IAGRwVABUAFRAAABaGvv3/BxXyARaQ38z/BxXWAQAmtoSrkQUcFQgZNQYIABkoBGJi + b3gEeW1pbhUMFuCuExbQv00WnOMtJraEq5EFPBgEEGgIwhgEzZ8MwhYAKAQQaAjCGATNnwzCABkc + FQAVABUQAAAW+L/9/wcV8gEW5uDM/wcV1gEAJtLn2JEFHBUIGTUGCAAZKARiYm94BHltYXgVDBbg + rhMWzr9NFuDoLSbS59iRBTwYBPpnCMIYBLWfDMIWACgE+mcIwhgEtZ8MwgAZHBUAFQAVEAAAFurB + /f8HFfIBFrzizP8HFdYBACby0IaSBRwVAhk1BggEGRgHdmVyc2lvbhUMFuCuExb+BBagBiby0IaS + BSay0IaSBRwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbcw/3/ + BxXSARaS5Mz/BxXWAQAmkteGkgUcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVy + dHkVDBbgrhMW/AUWngcmkteGkgUm0taGkgUcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABau + xf3/BxXSARbo5cz/BxVWACa034aSBRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRh + c2V0FQwW4K4TFtDCBBb84wImtN+GkgUm8N2GkgUcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBP + cGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABaAx/3/BxXiARa+5sz/BxX2BAAm7MGJkgUc + FQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW4K4TFvDs3gIW2MaAASbs + wYmSBTw2ACgMdzk5NzI4MzAwOEAxGAwwMDAwYjE1MTgzZjQAGRwVABUAFRAAABbiyP3/BxXyARa0 + 68z/BxXWAwAm8IiLkwUcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUV + DBbgrhMW8MsYFrDeCCbwiIuTBSbEiIqTBRw2ACgYMjAyNC0xMC0yMlQxODowOTo0Ni4wMDBaGBgy + MDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAW1Mr9/wcV5gEWiu/M/wcV + 1gYAJv6DlJMFHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbgrhMW + qLMVFqicEib+g5STBSb05pKTBRwYCPvL7snDQu8/GAjNzMzMzMzkPxbapgsoCPvL7snDQu8/GAjN + zMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABa6zP3/BxXyARbg9cz/BxX2AgAmnIOlkwUcFQIZNQYI + ABkYBWxldmVsFQwW4K4TFowGFtQGJpyDpZMFPBgEAQAAABgEAQAAABbErhMoBAEAAAAYBAEAAAAA + GRwVABUAFRAAABaszv3/BxXWARbW+Mz/BxWWAQAmloylkwUcFQwZNQYIBBkYB3N1YnR5cGUVDBbg + rhMW2l8Wtk4mloylkwUm8ImlkwUcNpSIEigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZ + LBUEFQQVAgAVABUEFRAAABaC0P3/BxXiARbs+cz/BxXOAwAmvNylkwUcFQwZNQYIBBkYBWNsYXNz + FQwW4K4TFuRmFqRTJrzcpZMFJqbYpZMFHDbQiRIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUE + FQQVAgAVABUEFRAAABbk0f3/BxXiARa6/cz/BxX4AgAmyqumkwUcFQoZNQYIABkYBmhlaWdodBUM + FuCuExaQBBagBSbKq6aTBTw24K4TABkcFQAVABUQAAAWxtP9/wcV0gEWsoDN/wcVdgAm6rCmkwUc + FQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBbgrhMW+HQW4kkm6rCmkwU8NoarEygJw5FhbSDDkWFt + GCcxIHkgMiBKdXpnYWRvIGRlIExldHJhcyBkZSBTYW4gRmVybmFuZG8AGRwVABUAFRAAABaY1f3/ + BxXiARaogc3/BxXSBgAmzPqmkwUcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkV + DBbirhMWrhUW6hEmzPqmkwU8NsquEygCZXMYAmVuABkcFQAVABUQAAAW+tb9/wcV4gEW+ofN/wcV + hgEAJraMp5MFHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbirhMWphwW + ohYmtoynkwU8NsquEygRU3VwZXJtZXJjYWRvIGVsIDkYFTFzdCAmIDJuZCBDaXZpbCBDb3VydAAZ + HBUAFQAVEAAAFtzY/f8HFeIBFoCJzf8HFZICACbYoqeTBRwVDBklBgAZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQHdmFyaWFudBUMFuKuExa6GBbWEibYoqeTBTw21q4TKAhvZmZpY2lhbBgJYWx0 + ZXJuYXRlABkcFQAVABUQAAAWvtr9/wcV4gEWkovN/wcVugEAJq61p5MFHBUMGSUGABlYBW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFuKuExamFxb2ESautaeTBTw24q4TABkcFQAV + ABUQAAAWoNz9/wcV4gEWzIzN/wcVdgAmpMenkwUcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdl + bGVtZW50BXZhbHVlFQwW4q4TFoQbFs4UJqTHp5MFPDbWrhMoJVRlc29yZXLDrWEgUHJvdmluY2lh + bCBkZSBTYW4gRmVybmFuZG8YH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJzaW9uZXMAGRwVABUA + FRAAABaC3v3/BxXiARbCjc3/BxXAAwAm8tunkwUcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdl + bGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW4q4TFqgXFvgRJvLbp5MFPDbirhMAGRwVABUA + FRAAABbk3/3/BxXiARaCkc3/BxV2ACbq7aeTBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQEc2lkZRUMFuKuExamFxb2ESbq7aeTBTw24q4TABkcFQAVABUQAAAWxuH9/wcV4gEW+JHN + /wcVdgAm4P+nkwUcFQAZNQYIABkYCWhhc19wYXJ0cxUMFuCuExaMugIWkAcm4P+nkwU8GAEBGAEA + FgAoAQEYAQAAGRwVABUAFRAAABao4/3/BxXUARbuks3/BxV2ACbwhqiTBRwVABk1BggAGRgOaXNf + dW5kZXJncm91bmQVDBbgrhMWjLoCFrAGJvCGqJMFPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAW + /OT9/wcV0gEW5JPN/wcVdgAmmI6okwUcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbgrhMW2AkW2Aom + mI6okwUmoI2okwUcGAQKAAAAGAQBAAAAFrarEygECgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAA + ABbO5v3/BxXYARbalM3/BxXWAQAm+JeokwUcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91 + bmQVDBbgrhMWkAQWoAUm+JeokwU8NuCuEwAZHBUAFQAVEAAAFqbo/f8HFdIBFrCWzf8HFXYAJpid + qJMFHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW4K4TFpAEFqAFJpidqJMFPDbgrhMAGRwVABUAFRAA + ABb46f3/BxXSARaml83/BxV2ACa4oqiTBRwVAhk1BggAGRgJbWluX2Zsb29yFQwW4K4TFpAEFqAF + JriiqJMFPDbgrhMAGRwVABUAFRAAABbK6/3/BxXSARacmM3/BxV2ACbYp6iTBRwVDBk1BggAGRgM + ZmFjYWRlX2NvbG9yFQwW4K4TFpAEFqAFJtinqJMFPDbgrhMAGRwVABUAFRAAABac7f3/BxXSARaS + mc3/BxV2ACb4rKiTBRwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFsFQwW4K4TFq4EFr4FJvisqJMF + PBgFYnJpY2sYBWJyaWNrFt6uEygFYnJpY2sYBWJyaWNrABkcFQAVABUQAAAW7u79/wcV0gEWiJrN + /wcVigEAJrayqJMFHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW4K4TFpAEFqAFJrayqJMFPDbg + rhMAGRwVABUAFRAAABbA8P3/BxXSARaSm83/BxV2ACbWt6iTBRwVDBk1BggAGRgKcm9vZl9zaGFw + ZRUMFuCuExa6BBbKBSbWt6iTBTwYBGZsYXQYBGZsYXQW3K4TKARmbGF0GARmbGF0ABkcFQAVABUQ + AAAWkvL9/wcV0gEWiJzN/wcVhgEAJqC9qJMFHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFuCu + ExaQBBagBSagvaiTBTw24K4TABkcFQAVABUQAAAW5PP9/wcV0gEWjp3N/wcVdgAmwMKokwUcFQwZ + NQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbgrhMWkAQWoAUmwMKokwU8NuCuEwAZHBUAFQAVEAAA + Frb1/f8HFdIBFoSezf8HFXYAJuDHqJMFHBUMGTUGCAAZGApyb29mX2NvbG9yFQwW4K4TFrIEFsIF + JuDHqJMFPBgHI0ZGMDAwMBgHI0ZGMDAwMBberhMoByNGRjAwMDAYByNGRjAwMDAAGRwVABUAFRAA + ABaI9/3/BxXSARb6ns3/BxWSAQAmos2okwUcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW4K4TFpAE + FqAFJqLNqJMFPDbgrhMAGRwVABUAFRAAABba+P3/BxXSARaMoM3/BxV2ABbM2ukbFuCuEybAj6yF + BRaCw/wNFFoAGfwmJsLSqJMFHBUMGTUGCAAZGAJpZBUMFvy3ExbA47sFFtLAywEmwtKokwU8NgAo + IDA4YmIyYzM5NzZkYjZmZmYwMjAwNDg3YzY5ODhlM2U4GCAwOGJiMmMwMDAwMDAxZmZmMDIwMDhl + YTUyYWEyZTk0MwAZHBUAFQAVEAAAFqz6/f8HFfIBFoKhzf8HFdYIACaUk/SUBRwVDBk1BggAGRgI + Z2VvbWV0cnkVDBb8txMWtL3xDxbAn8AJJpST9JQFPDYAKKUEAAAAAAMAAAADAAAAF8BRxZDg+NO8 + wEE4MG8zlILAUcWSZIaSVsBBOEDRgWd0wFHFjPQESTvAQThCL0945MBRxYzFCmCswEE4QDL19pLA + UcWDQj8/scBBOEKWfYVnwFHFgbmpA5rAQTgx+XdPw8BRxYf6NOTkwEE4MGem2EbAUcWIDsI6o8BB + ODFF8ylYwFHFiuiRTnHAQTgwjj1FBcBRxYtEbECbwEE4NHLOU7bAUcWJjUd7wMBBODThiRx0wFHF + ic612xnAQTg3o9s7+8BRxYvdg9Q1wEE4Nx9Q/h/AUcWL+0tlWcBBODhj9JwfwFHFj4fH3/7AQTg3 + f8kN+8BRxY7CpgJewEE4LyZeOJrAUcWOXLoVOsBBOCrWbV9/wFHFjaJ/8inAQTgjjM0CfcBRxY7N + Il0iwEE4IuXeFcrAUcWPiJ6fk8BBOCrWbV9/wFHFkzmYqALAQTgp6QeV9sBRxZPCwAORwEE4L7am + 8JrAUcWQ4PjTvMBBODBvM5SCAAAABcBRxZCKkb7awEE4PFvQ4S/AUcWOKmUuWMBBODzx+NZAwFHF + jlvjVaXAQTg/FOjFUcBRxZC8D+YnwEE4Pn7A0D/AUcWQipG+2sBBODxb0OEvAAAABcBRxYiQXNn2 + wEE4NW2gFovAUcWEo9OvP8BBODZl7ZqjwFHFhVkFVNTAQTg+K7S5scBRxYlFjn+KwEE4PTKQdgTA + UcWIkFzZ9sBBODVtoBaLGE0AAAAAAwAAAAEAAAAEwFHD5taAUzrAQTWupNDqGMBRw+cRGAhgwEE1 + rUcxEOPAUcPnXBdfNMBBNa4tHXenwFHD5taAUzrAQTWupNDqGAAZHBUAFQAVJAAAFp78/f8HFaAE + Ftipzf8HFa4lACbUsrSeBRwVCBk1BggAGSgEYmJveAR4bWluFQwW/LcTFsDkTRb60iwm1LK0ngU8 + GAQECI7CGAQEcI/CFgAoBAQIjsIYBARwj8IAGRwVABUAFRAAABa+gP7/BxXyARaGz83/BxXWAQAm + zoXhngUcFQgZNQYIABkoBGJib3gEeG1heBUMFvy3ExbA5E0W6s4sJs6F4Z4FPBgE+geOwhgE+2+P + whYAKAT6B47CGAT7b4/CABkcFQAVABUQAAAWsIL+/wcV8gEW3NDN/wcV1gEAJrjUjZ8FHBUIGTUG + CAAZKARiYm94BHltaW4VDBb8txMWvuRNFsq/Lya41I2fBTwYBBIAB8IYBBDQCcIWACgEEgAHwhgE + ENAJwgAZHBUAFQAVEAAAFqKE/v8HFfIBFrLSzf8HFdYBACaClL2fBRwVCBk1BggAGSgEYmJveAR5 + bWF4FQwW/LcTFr7kTRaqwy8mgpS9nwU8GATy/wbCGAT0zwnCFgAoBPL/BsIYBPTPCcIAGRwVABUA + FRAAABaUhv7/BxXyARaI1M3/BxXWAQAm7NfsnwUcFQIZNQYIBBkYB3ZlcnNpb24VDBb8txMW/gQW + oAYm7NfsnwUmrNfsnwUcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQ + AAAWhoj+/wcV0gEW3tXN/wcV1gEAJoze7J8FHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CHByb3BlcnR5FQwW/LcTFv4FFqAHJoze7J8FJszd7J8FHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAV + BBUQAAAW2In+/wcV0gEWtNfN/wcVVgAmsObsnwUcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQHZGF0YXNldBUMFvy3Exa48QQWtOUCJrDm7J8FJuzk7J8FHDYAKA1PcGVuU3RyZWV0TWFwGBVH + b29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWqov+/wcV4gEWitjN/wcV9gQA + JqDK758FHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFvy3ExaY0toC + Ftz/jgEmoMrvnwU8NgAoDHc5OTU0MTEyNzZAMRgMMDAwMTI1OWU1Y2RiABkcFQAVABUQAAAWjI3+ + /wcV8gEWgN3N/wcV1gMAJvT1/qAFHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0 + ZV90aW1lFQwW/LcTFuT+FBbQpAcm9PX+oAUm/Mn+oAUcNgAoGDIwMjQtMTEtMTJUMDI6MTk6MTUu + MDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFv6O/v8HFeIB + Ftbgzf8HFdYGACbeiYehBRwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNl + FQwW/LcTFvjJFBa4ihEm3omHoQUmzO6FoQUcGAhnRGlv8IXvPxgIzczMzMzM5D8W1qsMKAhnRGlv + 8IXvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW4JD+/wcV8gEWrOfN/wcV9gIAJoT5lqEF + HBUCGTUGCAAZGAVsZXZlbBUMFvy3ExagBhaYByaE+ZahBTwYBAEAAAAYBP////8W3rcTKAQBAAAA + GAT/////ABkcFQAVABUQAAAW0pL+/wcV1gEWourN/wcVxgEAJryCl6EFHBUMGTUGCAQZGAdzdWJ0 + eXBlFQwW/LcTFu4hFtYeJryCl6EFJpyAl6EFHDaoqhMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3Vs + dHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWqJT+/wcV4gEW6OvN/wcVzgMAJsyil6EFHBUMGTUGCAQZ + GAVjbGFzcxUMFvy3ExbSIBbEHSbMopehBSbynpehBRw23KsTKAl3YXJlaG91c2UYCmFwYXJ0bWVu + dHMAGSwVBBUEFQIAFQAVBBUQAAAWipb+/wcV4gEWtu/N/wcV3gIAJra8l6EFHBUKGTUGCAAZGAZo + ZWlnaHQVDBb8txMWqgQWugUmtryXoQU8GAgAAAAAAAA+QBgIAAAAAAAAPkAW+rcTKAgAAAAAAAA+ + QBgIAAAAAAAAPkAAGRwVABUAFRAAABbsl/7/BxXSARaU8s3/BxWWAQAm8MGXoQUcFQwZNQYIABko + BW5hbWVzB3ByaW1hcnkVDBb8txMWgmMWkEAm8MGXoQU8NvC0EygSb2ZpY2luYSBwYXJyb3F1aWFs + GBI1IENvbWlzYXLDrWEgUGV1bW8AGRwVABUAFRAAABa+mf7/BxXiARaq883/BxW6BQAmgIKYoQUc + FQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBaAuBMWphIWhhAmgIKYoQU8Nvi3 + EygCZXMYAmVuABkcFQAVABUQAAAWoJv+/wcV4gEW5PjN/wcVfgAmhpKYoQUcFQwZJQYAGUgFbmFt + ZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFoC4ExbCFRaQESaGkpihBTw2+LcTKApTdGF0ZSBC + YW5rGAxCYW5jbyBFc3RhZG8AGRwVABUAFRAAABaCnf7/BxXiARbi+c3/BxWiAQAmlqOYoQUcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBaAuBMWyBUW3hAmlqOYoQU8 + NvS3EygIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFuSe/v8HFeIBFoT7zf8HFboBACb0 + s5ihBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBaAuBMW0BQW + rhAm9LOYoQU8Nvy3EygCZXMYAmVuABkcFQAVABUQAAAWxqD+/wcV4gEWvvzN/wcVfgAmosSYoQUc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWgLgTFuIWFugRJqLEmKEF + PDb0txMoD1NhbnRhbmRlciBHcm91cBgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAV + EAAAFqii/v8HFeIBFrz9zf8HFeoBACaK1pihBRwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBaAuBMWuhQWoBAmitaYoQU8NoC4EwAZHBUAFQAV + EAAAFoqk/v8HFeIBFqb/zf8HFXYAJqrmmKEFHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudARzaWRlFQwWgLgTFrgUFpwQJqrmmKEFPDaAuBMAGRwVABUAFRAAABbspf7/BxXiARacgM7/ + BxV2ACbG9pihBRwVABk1BggAGRgJaGFzX3BhcnRzFQwW/LcTFqC7AhawBibG9pihBTwYAQAYAQAW + ACgBABgBAAAZHBUAFQAVEAAAFs6n/v8HFdIBFpKBzv8HFXYAJvb8mKEFHBUAGTUGCAAZGA5pc191 + bmRlcmdyb3VuZBUMFvy3ExaguwIWsAYm9vyYoQU8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABag + qf7/BxXSARaIgs7/BxV2ACaOhJmhBRwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFvy3ExagBhbCByaO + hJmhBSamg5mhBRwYBAgAAAAYBAEAAAAW4LcTKAQIAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAA + FvKq/v8HFdQBFv6Czv8HFcYBACboipmhBRwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3Vu + ZBUMFvy3ExaQBBagBSboipmhBTw2/LcTABkcFQAVABUQAAAWxqz+/wcV0gEWxITO/wcVdgAmiJCZ + oQUcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBb8txMWkAQWoAUmiJCZoQU8Nvy3EwAZHBUAFQAVEAAA + Fpiu/v8HFdIBFrqFzv8HFXYAJqiVmaEFHBUCGTUGCAAZGAltaW5fZmxvb3IVDBb8txMWkAQWoAUm + qJWZoQU8Nvy3EwAZHBUAFQAVEAAAFuqv/v8HFdIBFrCGzv8HFXYAJsiamaEFHBUMGTUGCAAZGAxm + YWNhZGVfY29sb3IVDBb8txMWkAQWoAUmyJqZoQU8Nvy3EwAZHBUAFQAVEAAAFryx/v8HFdIBFqaH + zv8HFXYAJuifmaEFHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBb8txMWkAQWoAUm6J+ZoQU8 + Nvy3EwAZHBUAFQAVEAAAFo6z/v8HFdIBFpyIzv8HFXYAJoilmaEFHBUMGTUGCAAZGA1yb29mX21h + dGVyaWFsFQwW/LcTFpAEFqAFJoilmaEFPDb8txMAGRwVABUAFRAAABbgtP7/BxXSARaSic7/BxV2 + ACaoqpmhBRwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFvy3ExauBBa+BSaoqpmhBTwYBmdhYmxlZBgG + Z2FibGVkFvq3EygGZ2FibGVkGAZnYWJsZWQAGRwVABUAFRAAABaytv7/BxXSARaIis7/BxWOAQAm + 5q+ZoQUcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW/LcTFpAEFqAFJuavmaEFPDb8txMAGRwV + ABUAFRAAABaEuP7/BxXSARaWi87/BxV2ACaGtZmhBRwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlv + bhUMFvy3ExaQBBagBSaGtZmhBTw2/LcTABkcFQAVABUQAAAW1rn+/wcV0gEWjIzO/wcVdgAmprqZ + oQUcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBb8txMWkAQWoAUmprqZoQU8Nvy3EwAZHBUAFQAVEAAA + Fqi7/v8HFdIBFoKNzv8HFXYAJsa/maEFHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFvy3ExaQBBag + BSbGv5mhBTw2/LcTABkcFQAVABUQAAAW+rz+/wcV0gEW+I3O/wcVdgAWprb1Ghb8txMmwtKokwUW + pPLwDRRcABn8JibmxJmhBRwVDBk1BggAGRgCaWQVDBbwpxMWkKC3BRaY8scBJubEmaEFPDYAKCAw + OGJiMmMxZDlkMjZlZmZmMDIwMGJkZTQ0NTlhYTZkMRggMDhiYjJjMDA0MDMyM2ZmZjAyMDA4YjAz + MmY5M2RkMjcAGRwVABUAFRAAABbMvv7/BxXyARbujs7/BxXWCAAm/rbhogUcFQwZNQYIABkYCGdl + b21ldHJ5FQwW8KcTFrjuhxAW+PjOCSb+tuGiBTw2ACitCQAAAAADAAAABQAAADPAUbagLMYxqMBB + NJXVv7qWwFG2nsrGYlDAQTSWmF1Zd8BRtp6tajD2wEE0lgZnIk7AUbab9ZRsM8BBNJeE7GNrwFG2 + nXIAzlzAQTSe44V19sBRtp1ESQUtwEE0nvyv6WfAUbafg75mAsBBNKokK1hzwFG2mzycaIHAQTSs + faHsTsBRtpkn7zJSwEE0oizmEhjAUbaXyN8Bg8BBNKLs/3I8wFG2mdUou+HAQTStFXdgisBRtpWz + xmuKwEE0r1n1PtzAUbaTrjKt0sBBNKVSNIA6wFG2kYmVP5jAQTSmfoRqXcBRtpDUY5oDwEE0ovtC + Kx7AUbaSnZF138BBNKIAcGhIwFG2kZwJtmLAQTSdAS0mqsBRtpXon5EqwEE0mqUyVBDAUbaVeeTI + bMBBNJh/viZBwFG2lEKtI7rAQTSZKt7Q28BRtpLf1pTNwEE0kkrwvxrAUbaSRlOhaMBBNJKe05U+ + wFG2k6mVkCDAQTSZgUXlvcBRtpJIASCRwEE0mkMMxQrAUbaQ5ZXxbsBBNJNkzDJzwFG2kC5LbObA + QTSTyXYAN8BRtpH2ookswEE0nJ/eVznAUbaPmI7Xn8BBNJ3s5XEJwFG2jN/iU0fAQTSQbnes4MBR + to8zeaoQwEE0jydP0CLAUbaP7vXsgcBBNJLKcn95wFG2kMfOYEvAQTSSU1Q668BRto9plO8QwEE0 + i4k1nkfAUbaS8DIso8BBNImZcVWuwFG2k09oHSDAQTSLcOHqa8BRtpR5M8iEwEE0is1N/AzAUbaV + IjuUK8BBNI4UKllwwFG2k/w2RuTAQTSOtToJEMBRtpRUtjq6wEE0kGvzbiHAUbaVt4zJp8BBNI+p + Vc8/wFG2lQ2uPmzAQTSMXkez9MBRtpoNyD+fwEE0iZ9QksDAUbaaWNw6KMBBNIsSF1m5wFG2nIrl + obDAQTSJ3WPzxcBRtp0W/JvHwEE0jJP3mSnAUbacwdemRcBBNIzC8YG4wFG2nXs7CcHAQTSQWX73 + V8BRtp+HhMQfwEE0jznERuzAUbaf7JnxrsBBNJEukQ0DwFG2n04OgMzAQTSRhc7hesBRtqAsxjGo + wEE0ldW/upYAAAAFwFG2me+VTrHAQTSShNJiOMBRtpiPQv6CwEE0k0QVAsfAUbaY45E0cMBBNJTq + B3A3wFG2mkPjhJ/AQTSUKsTPqMBRtpnvlU6xwEE0koTSYjgAAAAFwFG2mTNCTKzAQTSOthDIpcBR + tphGR+LuwEE0jzWSiQTAUbaYnYW3ZcBBNJDt+W0/wFG2mYqAISPAQTSQbnes4MBRtpkzQkyswEE0 + jrYQyKUAAAAFwFG2l6lp8TXAQTSavzOHFsBRtpabTPgAwEE0m1LXPWnAUbaX99jqEsBBNKIacZtO + wFG2mQX140fAQTShhs3k+8BRtpepafE1wEE0mr8zhxYAAAAHwFG2lKbrkbTAQTSR3Qy18cBRtpWv + KU3XwEE0lsuI/+7AUbaYTCcf/8BBNJVN2n5mwFG2l/ufSC/AQTSTzae+IMBRtpXXAdn1wEE0lQaM + 4fvAUbaVHuCV18BBNJGZGhfZwFG2lKbrkbTAQTSR3Qy18RhNAAAAAAMAAAABAAAABMBRsIqTTeg6 + wEEuNPdHfwPAUbCKjNU0l8BBLjYrEL27wFGwiga7+QrAQS42I08in8BRsIqTTeg6wEEuNPdHfwMA + GRwVABUAFSQAABa+wP7/BxWgBBbEl87/BxWuJQAm9q+wrAUcFQgZNQYIABkoBGJib3gEeG1pbhUM + FvCnExaOpE0W8OkqJvavsKwFPBgEAFWNwhgEBbyOwhYAKAQAVY3CGAQFvI7CABkcFQAVABUQAAAW + 3sT+/wcV8gEW8rzO/wcV1gEAJuaZ26wFHBUIGTUGCAAZKARiYm94BHhtYXgVDBbwpxMWkKRNFqrj + KibmmdusBTwYBPlUjcIYBPq7jsIWACgE+VSNwhgE+ruOwgAZHBUAFQAVEAAAFtDG/v8HFfIBFsi+ + zv8HFdYBACaQ/YWtBRwVCBk1BggAGSgEYmJveAR5bWluFQwW8KcTFo6kTRbK+SwmkP2FrQU8GAQH + AAfCGAQo0AnCFgAoBAcAB8IYBCjQCcIAGRwVABUAFRAAABbCyP7/BxXyARaewM7/BxXWAQAm2vay + rQUcFQgZNQYIABkoBGJib3gEeW1heBUMFvCnExaQpE0WxvksJtr2sq0FPBgE8P8GwhgE9s8JwhYA + KATw/wbCGAT2zwnCABkcFQAVABUQAAAWtMr+/wcV8gEW9MHO/wcV1gEAJuDw360FHBUCGTUGCAQZ + GAd2ZXJzaW9uFQwW8KcTFv4EFqAGJuDw360FJqDw360FHBgEAAAAABgEAAAAABYAKAQAAAAAGAQA + AAAAABksFQQVBBUCABUAFQQVEAAAFqbM/v8HFdIBFsrDzv8HFdYBACaA99+tBRwVDBklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFvCnExb+BRagByaA99+tBSbA9t+tBRwYABgA + FgAoABgAABksFQQVBBUCABUAFQQVEAAAFvjN/v8HFdIBFqDFzv8HFVYAJqT/360FHBUMGSUGBBlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbwpxMW7OkEFvDxAiak/9+tBSbg/d+tBRw2 + ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAA + FsrP/v8HFeIBFvbFzv8HFfYEACbQ7+KtBRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAly + ZWNvcmRfaWQVDBbwpxMWkMTeAhai5ogBJtDv4q0FPDYAKAx3OTk5OTMyMTk1QDEYDDAwMDA4YzIw + YTVmNAAZHBUAFQAVEAAAFqzR/v8HFfIBFuzKzv8HFdYDACbk/+uuBRwVDBklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFvCnExa6yhEWpqcGJuT/664FJvLV664FHDYAKBgy + MDI0LTExLTEyVDAxOjQ5OjI0LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQV + AgAVABUEFRAAABae0/7/BxXiARbCzs7/BxXWBgAmwJnzrgUcFQoZJQYEGUgHc291cmNlcwRsaXN0 + B2VsZW1lbnQKY29uZmlkZW5jZRUMFvCnExaClBYW3OwSJsCZ864FJpj98a4FHBgIIEHxY8xd7z8Y + CM3MzMzMzOQ/FpqPCygIIEHxY8xd7z8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFoDV/v8H + FfIBFpjVzv8HFfYCACbE6oSvBRwVAhk1BggEGRgFbGV2ZWwVDBbwpxMWigcWrAgmxOqErwUm9OmE + rwUcGAQFAAAAGAT/////FoqmEygEBQAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABby1v7/BxXU + ARaO2M7/BxXmAQAmoPSErwUcFQwZNQYIBBkYB3N1YnR5cGUVDBbwpxMWtjMWxC0moPSErwUmoPKE + rwUcNrr3EigLcmVzaWRlbnRpYWwYDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABbG2P7/ + BxXiARb02c7/BxXgAwAmxqOFrwUcFQwZNQYIBBkYBWNsYXNzFQwW8KcTFoI8FvIyJsajha8FJuSf + ha8FHDae+BIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABao2v7/BxXi + ARbU3c7/BxXmAgAm1tKFrwUcFQoZNQYIABkYBmhlaWdodBUMFvCnExbeBBbeBSbW0oWvBTwYCAAA + AAAAABhAGAgAAAAAAAAQQBbqpxMoCAAAAAAAABhAGAgAAAAAAAAQQAAZHBUAFQAVEAAAForc/v8H + FdQBFrrgzv8HFZYBACa02IWvBRwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFvCnExa+PRaWLSa0 + 2IWvBTw29qUTKB9wbGFudGEgZW1ib3RlbGxhZG9yYSBFbCBSZWZ1Z2lvGAFBABkcFQAVABUQAAAW + 3t3+/wcV4gEW0OHO/wcVoAUAJsqFhq8FHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUD + a2V5FQwW8KcTFsgOFuoNJsqFhq8FPDbwpxMAGRwVABUAFRAAABbA3/7/BxXeARbw5s7/BxV2ACa0 + k4avBRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW8KcTFqAQFoQOJrST + hq8FPDbwpxMAGRwVABUAFRAAABae4f7/BxXgARbm587/BxV2ACa4oYavBRwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFvanExbsERa2Dya4oYavBTw26KcTKAhvZmZp + Y2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAW/uL+/wcV4AEW3OjO/wcV2gEAJu6whq8FHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFvanExa+EBa0DibusIavBTw2 + 9qcTABkcFQAVABUQAAAW3uT+/wcV4AEWturO/wcVdgAmor+GrwUcFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW9qcTFpQUFpwQJqK/hq8FPDbopxMoH0NlbnRybyBkZSBT + YWx1ZCBGYW1pbGlhciBNYWxsb2EYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRAA + ABa+5v7/BxXgARas687/BxXYAwAmvs+GrwUcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW9qcTFsQQFrgOJr7Phq8FPDb2pxMAGRwVABUAFRAA + ABae6P7/BxXgARaE787/BxV2ACb23YavBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQEc2lkZRUMFvanExa+EBa0Dib23YavBTw29qcTABkcFQAVABUQAAAW/un+/wcV4AEW+u/O/wcV + dgAmquyGrwUcFQAZNQYIABkYCWhhc19wYXJ0cxUMFvCnExaeuQIWsAYmquyGrwU8GAEAGAEAFgAo + AQAYAQAAGRwVABUAFRAAABbe6/7/BxXSARbw8M7/BxV2ACba8oavBRwVABk1BggAGRgOaXNfdW5k + ZXJncm91bmQVDBbwpxMWnrkCFrAGJtryhq8FPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWsO3+ + /wcV0gEW5vHO/wcVdgAmivmGrwUcFQIZNQYIABkYCm51bV9mbG9vcnMVDBbwpxMWugYW7gYmivmG + rwU8GAQFAAAAGAQBAAAAFsanEygEBQAAABgEAQAAAAAZHBUAFQAVEAAAFoLv/v8HFdYBFtzyzv8H + FbYBACb4/4avBRwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFvCnExaQBBagBSb4 + /4avBTw28KcTABkcFQAVABUQAAAW2PD+/wcV0gEWkvTO/wcVdgAmmIWHrwUcFQoZNQYIABkYCm1p + bl9oZWlnaHQVDBbwpxMWkAQWoAUmmIWHrwU8NvCnEwAZHBUAFQAVEAAAFqry/v8HFdIBFoj1zv8H + FXYAJriKh68FHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbwpxMWkAQWoAUmuIqHrwU8NvCnEwAZHBUA + FQAVEAAAFvzz/v8HFdIBFv71zv8HFXYAJtiPh68FHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbw + pxMWkAQWoAUm2I+HrwU8NvCnEwAZHBUAFQAVEAAAFs71/v8HFdIBFvT2zv8HFXYAJviUh68FHBUM + GTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbwpxMWkAQWoAUm+JSHrwU8NvCnEwAZHBUAFQAVEAAA + FqD3/v8HFdIBFur3zv8HFXYAJpiah68FHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW8KcTFpAE + FqAFJpiah68FPDbwpxMAGRwVABUAFRAAABby+P7/BxXSARbg+M7/BxV2ACa4n4evBRwVDBk1BggA + GRgKcm9vZl9zaGFwZRUMFvCnExaQBBagBSa4n4evBTw28KcTABkcFQAVABUQAAAWxPr+/wcV0gEW + 1vnO/wcVdgAm2KSHrwUcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW8KcTFpAEFqAFJtikh68F + PDbwpxMAGRwVABUAFRAAABaW/P7/BxXSARbM+s7/BxV2ACb4qYevBRwVDBk1BggAGRgQcm9vZl9v + cmllbnRhdGlvbhUMFvCnExaQBBagBSb4qYevBTw28KcTABkcFQAVABUQAAAW6P3+/wcV0gEWwvvO + /wcVdgAmmK+HrwUcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbwpxMWkAQWoAUmmK+HrwU8NvCnEwAZ + HBUAFQAVEAAAFrr//v8HFdIBFrj8zv8HFXYAJri0h68FHBUKGTUGCAAZGAtyb29mX2hlaWdodBUM + FvCnExaQBBagBSa4tIevBTw28KcTABkcFQAVABUQAAAWjIH//wcV0gEWrv3O/wcVdgAW5IuHGxbw + pxMm5sSZoQUW8vTtDRReABn8JibYuYevBRwVDBk1BggAGRgCaWQVDBbogBMW8KGsBRau0cABJti5 + h68FPDYAKCAwOGJiMmMxZGI2Y2I1ZmZmMDIwMGI5NzE0YWUzMTE3ZhggMDhiYjJjMDM2MDI1ZWZm + ZjAyMDBkOWExMmI1M2I4ZWEAGRwVABUAFRAAABbegv//BxXyARak/s7/BxXWCAAmhovIsAUcFQwZ + NQYIABkYCGdlb21ldHJ5FQwW6IATFuyb3hAWhoeeCiaGi8iwBTw2ACi/AwAAAAAGAAAAAgAAAAAD + AAAAAQAAAAXAUa9NU2/pncBBEgh3ncZPwFGvUc6UTSnAQRISXCMWhcBRr07z7nnGwEESFefI0ZbA + Ua9KeF62b8BBEgwDQ4FfwFGvTVNv6Z3AQRIId53GTwAAAAADAAAABAAAAAXAUa9aKGqCVcBBEeCP + +DAowFGvXgtOEdzAQRHpJBtoO8BRr1UEPlMiwEER9FkC0JXAUa9RIVrDm8BBEevE35iBwFGvWihq + glXAQRHgj/gwKAAAAAXAUa9Z1BxMZ8BBEeQp4KQawFGvWGh24d/AQRHl7S9C5MBRr1px0P20wEER + 6mtDRPnAUa9b3QsIcsBBEein9KYwwFGvWdQcTGfAQRHkKeCkGgAAAAXAUa9XGpkIesBBEeeCWriz + wFGvVhsqJ/LAQRHov3Gad8BRr1g+8NaXwEER7XkUvtTAUa9ZPssW6sBBEew7/d0QwFGvVxqZCHrA + QRHnglq4swAAAAXAUa9U3NEmz8BBEepiCQmUwFGvUz7W1WTAQRHsY2sJY8BRr1Vea8YiwEER8RL9 + MsbAUa9W/GYXjMBBEe8QxHNiwFGvVNzRJs/AQRHqYgkJlBhNAAAAAAMAAAABAAAABMBRq77ggUe1 + wEERMmXbQRXAUau/DR17k8BBETOym244wFGrvdwulEbAQRE0I62bV8BRq77ggUe1wEERMmXbQRUA + GRwVABUAFSYAABbQhP//BxW+BBb6hs//BxW2JwAmjJLmugUcFQgZNQYIABkoBGJib3gEeG1pbhUM + FuiAExbwh0wWot4mJoyS5roFPBgESaCMwhgEBAiOwhYAKARJoIzCGAQECI7CABkcFQAVABUQAAAW + jon//wcV8gEWsK7P/wcV1gEAJq7wjLsFHBUIGTUGCAAZKARiYm94BHhtYXgVDBbogBMW8IdMFrri + Jiau8Iy7BTwYBDmgjMIYBPYHjsIWACgEOaCMwhgE9geOwgAZHBUAFQAVEAAAFoCL//8HFfIBFoaw + z/8HFdYBACaQg8O7BRwVCBk1BggEGSgEYmJveAR5bWluFQwW6IATFqKzOha05jImkIPDuwUm6NKz + uwUcGAQetAfCGATLzwnCFgAoBB60B8IYBMvPCcIAGSwVBBUEFQIAFQAVBBUQAAAW8oz//wcV8gEW + 3LHP/wcV1gEAJobx9bsFHBUIGTUGCAQZKARiYm94BHltYXgVDBbogBMWkr46FqTvMiaG8fW7BSac + uea7BRwYBAu0B8IYBLvPCcIWACgEC7QHwhgEu88JwgAZLBUEFQQVAgAVABUEFRAAABbkjv//BxXy + ARays8//BxXWAQAmgKmZvAUcFQIZNQYIBBkYB3ZlcnNpb24VDBbogBMW/gQWoAYmgKmZvAUmwKiZ + vAUcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW1pD//wcV0gEW + iLXP/wcV1gEAJqCvmbwFHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW + 6IATFv4FFqAHJqCvmbwFJuCumbwFHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWqJL//wcV + 0gEW3rbP/wcVVgAmxLeZvAUcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUM + FuiAExai1wQW8voCJsS3mbwFJoC2mbwFHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBC + dWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW+pP//wcV4gEWtLfP/wcV9gQAJvKwnLwFHBUMGSUG + ABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFuiAExaWr9YCFvymhAEm8rCcvAU8 + NgAoDHc5OTk4ODEwOTZAMRgMMDAwMDAyYzc3M2MzABkcFQAVABUQAAAW3JX//wcV8gEWqrzP/wcV + 1gMAJoq9ob0FHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW6IAT + FtqLGBb+nQcmir2hvQUm7tegvQUcNgAoGDIwMjQtMTEtMDdUMDE6MDU6MjMuMDAwWhgYMjAwMC0w + MS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFs6X//8HFeIBFoDAz/8HFdYGACaO + kam9BRwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW6IATFsDyFBbU + zREmjpGpvQUm7PWnvQUcGAhos+pztRXvPxgIzczMzMzM5D8WrLYLKAhos+pztRXvPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAWsJn//wcV8gEW1sbP/wcV9gIAJsDDub0FHBUCGTUGCAAZGAVs + ZXZlbBUMFuiAExb4BhbSBybAw7m9BTwYBAEAAAAYBP////8WvoATKAQBAAAAGAT/////ABkcFQAV + ABUQAAAWopv//wcV1gEWzMnP/wcV9gEAJrrNub0FHBUMGTUGCAQZGAdzdWJ0eXBlFQwW6IATFohH + Fp47JrrNub0FJpLLub0FHDbCxRIoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUE + FQIAFQAVBBUQAAAW+Jz//wcV4gEWwsvP/wcVsAMAJrSLur0FHBUMGTUGCAQZGAVjbGFzcxUMFuiA + Exb+ShbcPia0i7q9BSawhrq9BRw2kscSKA53YXlzaWRlX3NocmluZRgKYXBhcnRtZW50cwAZLBUE + FQQVAgAVABUEFRAAABbanv//BxXiARbyzs//BxWmAwAm/MW6vQUcFQoZNQYIBBkYBmhlaWdodBUM + FuiAExbSBhbMByb8xbq9BSaMxbq9BRwYCAAAAAAAgElAGAgAAAAAAADgPxaMgBMoCAAAAAAAgElA + GAgAAAAAAADgPwAZLBUEFQQVAgAVABUEFRAAABa8oP//BxXWARaY0s//BxX2AQAm2My6vQUcFQwZ + NQYIABkoBW5hbWVzB3ByaW1hcnkVDBbogBMW7qYBFrZkJtjMur0FPDaa+xIoBGRvbW8YFTEgQ29t + aXNhcsOtYSBSYW5jYWd1YQAZHBUAFQAVEAAAFpKi//8HFeIBFo7Uz/8HFZAFACaOsbu9BRwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFuiAExaCHBaCFiaOsbu9BTwYAmVzGAJl + cxbkgBMoAmVzGAJlcwAZHBUAFQAVEAAAFvSj//8HFeIBFp7Zz/8HFYYBACaQx7u9BRwVDBklBgAZ + SAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW6IATFqQhFrYXJpDHu70FPDbkgBMoIUls + dXN0cmUgTXVuaWNpcGFsaWRhZCBkZSBHcmFuZXJvcxgZQ29tZXJjaWFsIE5ldW1hbXVuZG8gTHRk + LgAZHBUAFQAVEAAAFtal//8HFeIBFqTaz/8HFd4CACbC37u9BRwVDBklBgQZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFuyAExbEIRbsFybC37u9BSbG3ru9BRw20oATKAVzaG9y + dBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAAFrin//8HFeIBFoLdz/8HFe4BACay9ru9BRwV + DBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbsgBMWtiAW6BYmsva7 + vQU8NuyAEwAZHBUAFQAVEAAAFpqp//8HFeIBFvDez/8HFXYAJuCQvL0FHBUMGSUGBBlYBW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFuyAExbYJRbCGibgkLy9BSaajby9BRw20oATKBBT + dGFyYnVja3MgQ29mZmVlGB9CYW5jbyBkZSBDcsOpZGl0byBlIEludmVyc2lvbmVzABksFQQVBBUC + ABUAFQQVEAAAFvyq//8HFeIBFubfz/8HFZ4EACbcp7y9BRwVChklBgAZeAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBbsgBMWuiAW5BYm3Ke8vQU8NuyAEwAZ + HBUAFQAVEAAAFt6s//8HFeIBFoTkz/8HFXYAJsC+vL0FHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudARzaWRlFQwW7IATFrYgFugWJsC+vL0FPDbsgBMAGRwVABUAFRAAABbArv//BxXi + ARb65M//BxV2ACao1by9BRwVABk1BggAGRgJaGFzX3BhcnRzFQwW6IATFq60AhbMBiao1by9BTwY + AQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFqKw//8HFdIBFvDlz/8HFXYAJvTbvL0FHBUAGTUGCAAZ + GA5pc191bmRlcmdyb3VuZBUMFuiAExautAIWsAYm9Nu8vQU8GAEAGAEAFgAoAQAYAQAAGRwVABUA + FRAAABb0sf//BxXSARbm5s//BxV2ACa847y9BRwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFuiAExaS + EhbWEia847y9BSak4ry9BRwYBBUAAAAYBAEAAAAWwvESKAQVAAAAGAQBAAAAABksFQQVBBUCABUA + FQQVEAAAFsaz//8HFd4BFtznz/8HFfYBACb69Ly9BRwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRl + cmdyb3VuZBUMFuiAExa2BBbGBSb69Ly9BTwYBAMAAAAYBAEAAAAW5IATKAQDAAAAGAQBAAAAABkc + FQAVABUQAAAWpLX//wcV0gEW0unP/wcVlgEAJsD6vL0FHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwW + 6IATFqoEFroFJsD6vL0FPBgIAAAAAAAAEEAYCAAAAAAAABBAFuaAEygIAAAAAAAAEEAYCAAAAAAA + ABBAABkcFQAVABUQAAAW9rb//wcV0gEW6OrP/wcVlgEAJrqAvb0FHBUCGTUGCAQZGAltaW5fZmxv + b3IVDBbogBMW2gQW/AUmuoC9vQUm+v+8vQUcGAQBAAAAGAQBAAAAFuSAEygEAQAAABgEAQAAAAAZ + LBUEFQQVAgAVABUEFRAAABbIuP//BxXSARb+68//BxWGAQAm9oW9vQUcFQwZNQYIABkYDGZhY2Fk + ZV9jb2xvchUMFuiAExa6BRasBib2hb29BTw23IATKAcjRkZGRkZGGAcjODA4MDAwABkcFQAVABUQ + AAAWmrr//wcV1AEWhO3P/wcVygEAJoKNvb0FHBUMGTUGCAQZGA9mYWNhZGVfbWF0ZXJpYWwVDBbo + gBMWlAUWtgYmgo29vQUmooy9vQUcNuCAEygEd29vZBgIY29uY3JldGUAGSwVBBUEFQIAFQAVBBUQ + AAAW7rv//wcV0gEWzu7P/wcVrgEAJtiSvb0FHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW6IAT + FuYFFsoGJtiSvb0FPDbagBMoBHdvb2QYCGNvbmNyZXRlABkcFQAVABUQAAAWwL3//wcV1gEW/O/P + /wcV1gEAJpiavb0FHBUMGTUGCAQZGApyb29mX3NoYXBlFQwW6IATFp4GFsAHJpiavb0FJqKZvb0F + HDa0/xIoCXB5cmFtaWRhbBgEZmxhdAAZLBUEFQQVAgAVABUEFRAAABaWv///BxXUARbS8c//BxW4 + AQAm4qC9vQUcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW6IATFpAEFqAFJuKgvb0FPDbogBMA + GRwVABUAFRAAABbqwP//BxXSARaK88//BxV2ACbgpr29BRwVDBk1BggEGRgQcm9vZl9vcmllbnRh + dGlvbhUMFuiAExbCBRbkBibgpr29BSaCpr29BRw2ooATKAVhbG9uZxgGYWNyb3NzABksFQQVBBUC + ABUAFQQVEAAAFrzC//8HFdQBFoD0z/8HFbgBACbmrL29BRwVDBk1BggAGRgKcm9vZl9jb2xvchUM + FuiAExa4BRbIBibmrL29BTw23IATKAcjRkZGRkZGGAcjMDAwMDgwABkcFQAVABUQAAAWkMT//wcV + 1gEWuPXP/wcVygEAJq6zvb0FHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFuiAExaQBBagBSaus729 + BTw26IATABkcFQAVABUQAAAW5sX//wcV0gEWgvfP/wcVdgAW+KypGxbogBMm2LmHrwUW9v61DhRg + ABn8JibOuL29BRwVDBk1BggAGRgCaWQVDBbguBMWzv+7BRbYuMkBJs64vb0FPDYAKCAwOGJiMmNl + YmI0NmNiZmZmMDIwMDBlYmNkYTUyNGU0NhggMDhiYjJjMGEwMTYzNGZmZjAyMDBiODk5NDAxY2Q3 + YmYAGRwVABUAFRAAABa4x///BxXyARb498//BxXWCAAmpvGGvwUcFQwZNQYIABkYCGdlb21ldHJ5 + FQwW4LgTFoithhAWkubICSam8Ya/BTw2ACjFAgAAAAADAAAAAwAAAAfAUbB4QcWdLsBA7aGqCVNm + wFGwcn95XOPAQO2g8XyvfsBRsHNyUwOzwEDtjALYIZXAUbB7VDQ0u8BA7Yz+gKP/wFGwejntYZjA + QO2lTSwCvcBRsHgaw9ClwEDtpQk5ZKbAUbB4QcWdLsBA7aGqCVNmAAAABcBRsHlxBSXawEDtj8eI + wC7AUbB0sKwE1sBA7Y86mwaBwFGwdJT9UqfAQO2R0Hd8OMBRsHlVVnOqwEDtkl479XrAUbB5cQUl + 2sBA7Y/HiMAuAAAAB8BRsHkj2ExdwEDtldx1tzzAUbB0bfuGHsBA7ZVMLP89wFGwdGZuyeLAQO2V + 9aAqrcBRsHV87z7owEDtlhZXWlrAUbB1QqI8AMBA7ZtcEXjOwFGweOJp7QTAQO2bysxBjcBRsHkj + 2ExdwEDtldx1tzwYTQAAAAADAAAAAQAAAATAUbJUAJJCW8BA5Lm1fJbywFGyVBody2/AQOS6uMEm + kMBRslOKV7XowEDkuuBCYlLAUbJUAJJCW8BA5Lm1fJbyABkcFQAVABUkAAAWqsn//wcVoAQWzoDQ + /wcVriUAJrDf4MgFHBUIGTUGCAQZKARiYm94BHhtaW4VDBbguBMWztc9FsaNNSaw3+DIBSa418/I + BRwYBAjSicIYBOkHjsIWACgECNKJwhgE6QeOwgAZLBUEFQQVAgAVABUEFRAAABbKzf//BxXyARb8 + pdD/BxXWAQAmpOiVyQUcFQgZNQYIBBkoBGJib3gEeG1heBUMFuC4ExbQ0T0W+IY1JqTolckFJv7k + hMkFHBgE/9GJwhgE2AeOwhYAKAT/0YnCGATYB47CABksFQQVBBUCABUAFQQVEAAAFrzP//8HFfIB + FtKn0P8HFdYBACb267nJBRwVCBk1BggAGSgEYmJveAR5bWluFQwW4LgTFs7nTRaWhC4m9uu5yQU8 + GAQFAAfCGAT1PxLCFgAoBAUAB8IYBPU/EsIAGRwVABUAFRAAABau0f//BxXyARaoqdD/BxXWAQAm + jPDnyQUcFQgZNQYIABkoBGJib3gEeW1heBUMFuC4ExbQ500WkIkuJozw58kFPBgE6P8GwhgE5j8S + whYAKATo/wbCGATmPxLCABkcFQAVABUQAAAWoNP//wcV8gEW/qrQ/wcV1gEAJtz5lcoFHBUCGTUG + CAQZGAd2ZXJzaW9uFQwW4LgTFv4EFqAGJtz5lcoFJpz5lcoFHBgEAAAAABgEAAAAABYAKAQAAAAA + GAQAAAAAABksFQQVBBUCABUAFQQVEAAAFpLV//8HFdIBFtSs0P8HFdYBACb8/5XKBRwVDBklBgQZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFuC4Exb+BRagByb8/5XKBSa8/5XKBRwY + ABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFuTW//8HFdIBFqqu0P8HFVYAJqCIlsoFHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbguBMWhtkEFrKAAyagiJbKBSbchpbK + BRw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQV + EAAAFrbY//8HFeIBFoCv0P8HFfYEACaOh5nKBRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVu + dAlyZWNvcmRfaWQVDBbguBMWiNPoAhbUtYMBJo6HmcoFPDYAKAx3OTk5MjcwMTA5QDEYDDAwMDE4 + ZjgzZGNhOQAZHBUAFQAVEAAAFpja//8HFfIBFvaz0P8HFdYDACb+jJ3LBRwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFuC4ExaSvxcW+rgHJv6MncsFJuK8nMsFHDYA + KBgyMDI0LTA5LTE1VDIwOjA5OjM0LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUE + FQQVAgAVABUEFRAAABaK3P//BxXiARbMt9D/BxXWBgAmvM2lywUcFQoZJQYEGUgHc291cmNlcwRs + aXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFuC4Exb0uRkW8IgWJrzNpcsFJtz1o8sFHBgIAAAAAAAA + 8D8YCAAAAGAgQeM/Foy2CSgIAAAAAAAA8D8YCAAAAGAgQeM/ABksFQQVBBUCABUAFQQVEAAAFuzd + //8HFfIBFqK+0P8HFfQCACaM/7nLBRwVAhk1BggEGRgFbGV2ZWwVDBbguBMWwgUW5AYmjP+5ywUm + zP65ywUcGAQBAAAAGAQBAAAAFsa4EygEAQAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbe3/// + BxXUARaWwdD/BxW2AQAm2Ie6ywUcFQwZNQYIBBkYB3N1YnR5cGUVDBbguBMWhloW+ksm2Ie6ywUm + sIW6ywUcNqDlEigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAA + ABay4f//BxXiARbMwtD/BxXMAwAm+NW6ywUcFQwZNQYIBBkYBWNsYXNzFQwW4LgTFuhdFt5OJvjV + ussFJqrRussFHDaA5hIoDndheXNpZGVfc2hyaW5lGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQV + EAAAFpTj//8HFeIBFpjG0P8HFYYDACaIoLvLBRwVChk1BggAGRgGaGVpZ2h0FQwW4LgTFpAEFqAF + Joigu8sFPDbguBMAGRwVABUAFRAAABb25P//BxXSARaeydD/BxV2ACbYxLvLBRwVDBk1BggEGSgF + bmFtZXMHcHJpbWFyeRUMFuC4Exb8TRb2MCbYxLvLBSaopbvLBRw21LUTKBB0ZWF0cm8gbXVuaWNp + cGFsGAM1MTYAGSwVBBUEFQIAFQAVBBUQAAAWyOb//wcV4AEWlMrQ/wcV7AQAJp7Wu8sFHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW5LgTFswPFuQOJp7Wu8sFPDbcuBMoAmVz + GAJlbgAZHBUAFQAVEAAAFqjo//8HFeABFoDP0P8HFYYBACaC5bvLBRwVDBklBgAZSAVuYW1lcwZj + b21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW5LgTFowSFsoPJoLlu8sFPDbcuBMoClN0YXRlIEJhbmsY + DEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFojq//8HFeABFobQ0P8HFc4BACaa9bvLBRwVDBklBgQZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFui4ExbmERa2Dyaa9bvLBSbM9LvL + BRwYCG9mZmljaWFsGAhvZmZpY2lhbBbauBMoCG9mZmljaWFsGAhvZmZpY2lhbAAZLBUEFQQVAgAV + ABUEFRAAABbo6///BxXgARbU0dD/BxXWAQAmgoS8ywUcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50CGxhbmd1YWdlFQwW6LgTFsQRFoIPJoKEvMsFPDbguBMoAmVzGAJlbgAZHBUAFQAV + EAAAFsjt//8HFeABFqrT0P8HFYYBACbSlLzLBRwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQFdmFsdWUVDBbouBMW7hIWxBAm0pS8ywUmhJO8ywUcNtq4EygKRUROSS0xMjktSxgZQmFu + Y28gZGVsIEVzdGFkbyBkZSBDaGlsZQAZLBUEFQQVAgAVABUEFRAAABao7///BxXgARaw1ND/BxXq + AgAmyKO8ywUcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdl + bGVtZW50FQwW6LgTFpoRFuIOJsijvMsFPDbouBMAGRwVABUAFRAAABaI8f//BxXgARaa19D/BxV2 + ACaqsrzLBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFui4ExaWERba + DiaqsrzLBTw26LgTABkcFQAVABUQAAAW6PL//wcV4AEWkNjQ/wcVdgAmhMG8ywUcFQAZNQYIABkY + CWhhc19wYXJ0cxUMFuC4ExasuwIWsAYmhMG8ywU8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABbI + 9P//BxXSARaG2dD/BxV2ACa0x7zLBRwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBbguBMWrLsC + FrAGJrTHvMsFPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWmvb//wcV0gEW/NnQ/wcVdgAmzM68 + ywUcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbguBMWigcWrAgmzM68ywUm5M28ywUcGAQIAAAAGAQB + AAAAFvK3EygECAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbs9///BxXYARby2tD/BxXWAQAm + kNa8ywUcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbguBMWkAQWoAUmkNa8ywU8 + NuC4EwAZHBUAFQAVEAAAFsT5//8HFdIBFsjc0P8HFXYAJrDbvMsFHBUKGTUGCAAZGAptaW5faGVp + Z2h0FQwW4LgTFpAEFqAFJrDbvMsFPDbguBMAGRwVABUAFRAAABaW+///BxXSARa+3dD/BxV2ACbQ + 4LzLBRwVAhk1BggAGRgJbWluX2Zsb29yFQwW4LgTFpAEFqAFJtDgvMsFPDbguBMAGRwVABUAFRAA + ABbo/P//BxXSARa03tD/BxV2ACbw5bzLBRwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwW4LgTFpAE + FqAFJvDlvMsFPDbguBMAGRwVABUAFRAAABa6/v//BxXSARaq39D/BxV2ACaQ67zLBRwVDBk1BggA + GRgPZmFjYWRlX21hdGVyaWFsFQwW4LgTFpAEFqAFJpDrvMsFPDbguBMAGRwVABUAFRAAABaMgICA + CBXSARag4ND/BxV2ACaw8LzLBRwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFuC4ExaQBBagBSaw + 8LzLBTw24LgTABkcFQAVABUQAAAW3oGAgAgV0gEWluHQ/wcVdgAm0PW8ywUcFQwZNQYIABkYCnJv + b2Zfc2hhcGUVDBbguBMWrAQWvAUm0PW8ywU8GARmbGF0GARmbGF0Ft64EygEZmxhdBgEZmxhdAAZ + HBUAFQAVEAAAFrCDgIAIFdIBFozi0P8HFYYBACaM+7zLBRwVChk1BggAGRgOcm9vZl9kaXJlY3Rp + b24VDBbguBMWkAQWoAUmjPu8ywU8NuC4EwAZHBUAFQAVEAAAFoKFgIAIFdIBFpLj0P8HFXYAJqyA + vcsFHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW4LgTFpAEFqAFJqyAvcsFPDbguBMAGRwV + ABUAFRAAABbUhoCACBXSARaI5ND/BxV2ACbMhb3LBRwVDBk1BggAGRgKcm9vZl9jb2xvchUMFuC4 + ExaQBBagBSbMhb3LBTw24LgTABkcFQAVABUQAAAWpoiAgAgV0gEW/uTQ/wcVdgAm7Iq9ywUcFQoZ + NQYIABkYC3Jvb2ZfaGVpZ2h0FQwW4LgTFpAEFqAFJuyKvcsFPDbguBMAGRwVABUAFRAAABb4iYCA + CBXSARb05dD/BxV2ABasioAbFuC4EybOuL29BRa+1/8NFGIAGfwmJoyQvcsFHBUMGTUGCAAZGAJp + ZBUMFpjxEhaw76cFFu6vxwEmjJC9ywU8NgAoIDA4YmMzNmRkYjE4ZTNmZmYwMjAwYmE4NzI2ZTZi + YTc5GCAwOGJiMmMxMDQwOTZlZmZmMDIwMGJjNjcxYjQyZDI3NwAZHBUAFQAVEAAAFsqLgIAIFfIB + Furm0P8HFdYIACb6v4TNBRwVDBk1BggAGRgIZ2VvbWV0cnkVDBaY8RIW5vChEBaUmfYJJvq/hM0F + PDYAKL0MAAAAAAMAAAAJAAAAOcBRZcUavEPpwEG81BnIKCLAUWXFcY64lcBBvNSydFvywFFlxXcC + ldzAQbzW9ht6sMBRZcW/JvHcwEG81v9VthXAUWXFuNxVAMBBvNi25dq7wFFlxP8NkbnAQbzYsC/e + FMBRZcTewcHXwEG84S9aYJ/AUWW+oZDe4MBBvODvmYBvwFFlvpwdAZnAQbziU0bO8cBRZbz9S/CZ + wEG84kJ/11HAUWW9A5aNdsBBvOCndSRvwFFlu7uX8SPAQbzgmt/qt8BRZbu3ZjM7wEG84cgGlG/A + UWW6uaTR3MBBvOG99Zl1wFFlur3Wj8TAQbzgp3Ukb8BRZbfR/mT1wEG84IoY8xbAUWW3zqNmosBB + vOFslwIQwFFlts+f5eTAQbzhYoYHFsBRZbbS+uQ3wEG84Ihrc+zAUWWzYOr8Y8BBvOBlMAWBwFFl + s1Usgj/AQbzjcH1AncBRZbJ0W/JvwEG842gZxM3AUWWyb1N08sBBvOTJQtSRwFFlsJhOP//AQbzk + ts5dx8BRZbCeLX0RwEG84xrs61DAUWWvMhyyvsBBvOMMqjJuwFFlry1/lQzAQbzkT6BRRMBRZa2F + 36hywEG85D7ZWaPAUWWtiaYGj8BBvONUzo5uwFFlrPiGjvvAQbzjT8YQ8cBRZaz9I6ytwEG84hHY + b5jAUWWsNejwGcBBvOIJdPPIwFFlrG2xtEPAQbzTXeCF58BRZa1YJ99CwEG802cawUzAUWWtToJE + EsBBvNXt3b6NwFFlrs5JpI/AQbzV/Pc3BMBRZa7f51vEwEG80UoKD03AUWWwSrYGuMBBvNFYTMgw + wFFlsFYJIRHAQbzOXp1EScBRZbEKZAcRwEG8zmVTQPDAUWWxF9AAXsBBvMrUpQhjwFFlsjaz8TTA + QbzK4GOChsBRZbIqihdGwEG8zhCZqzfAUWWzywinbsBBvM4hYKLYwFFls8HObAnAQbzQc0p6eMBR + ZbwF1SwXwEG80MctUJvAUWW8DPaIiMBBvM7wk3tywFFlvaG2no3AQbzPAIOzfsBRZb2wZLc6wEG8 + yyYDn8jAUWXAHz9gaMBBvMs+V1OkwFFlwApGqt/AQbzQvsnUy8BRZcFqLZtEwEG80M0Mja3AUWXB + W3+Cl8BBvNSnjKFkwFFlwJ7BIMfAQbzUn//lKMBRZcCXNGSMwEG81pj+aSfAUWXDpC8e0cBBvNZK + +tAVwFFlxRq8Q+nAQbzUGcgoIgAAAAXAUWW9QhVORsBBvNf2zHqXwFFlu2y9mHzAQbzX8O09hsBR + Zbtj7rziwEG833ig+47AUWW9ObHSdsBBvN99qXkLwFFlvUIVTkbAQbzX9sx6lwAAAAXAUWW4oZyd + WsBBvNfeeMa7wFFlt4JNTLrAQbzX1T6LVsBRZbdsEnfSwEG83w/Fb+HAUWW4i80oPMBBvN8YKOuy + wFFluKGcnVrAQbzX3njGuwAAAAXAUWW0gr6LwcBBvNe0h1upwFFls2eg+QnAQbzXrPqfbsBRZbNU + VcKqwEG83vM//h3AUWW0b961LcBBvN76zLpYwFFltIK+i8HAQbzXtIdbqQAAAAXAUWWwpAy6I8BB + vNeuqB6YwFFlr8M8KlPAQbzXq00gRMBRZa+5lo8jwEG83kqjkkHAUWWwmfu/KcBBvN5N/pCUwFFl + sKQMuiPAQbzXrqgemAAAAAXAUWW0j1PFesBBvNNoyEB2wFFls3+JTRvAQbzTZ/GA4cBRZbN+so2G + wEG81nGRPNTAUWW0jn0F5cBBvNZyZ/xpwFFltI9TxXrAQbzTaMhAdgAAAAXAUWW4oMXdxcBBvNPP + 9kz5wFFlt5D7ZWfAQbzTzx+NZMBRZbeQJKXSwEG81tfoicLAUWW4n+8eMMBBvNbYv0lXwFFluKDF + 3cXAQbzTz/ZM+QAAAAXAUWW80a0GXsBBvNO19RnzwFFlu8Hijf/AQbzTtR5aXsBRZbvBC85qwEG8 + 1r6+FlHAUWW80NZGycBBvNa/lNXlwFFlvNGtBl7AQbzTtfUZ8wAAAAXAUWWwjPslpsBBvNQCSzPb + wFFlr+OH+jXAQbzUAJ20scBRZa/gmFuswEG81i51XlHAUWWwiguHHcBBvNYwIt17wFFlsIz7JabA + QbzUAksz2xhNAAAAAAMAAAABAAAABMBRF4x27d/PwEFRRjx3KfDAUReM19o0HMBBUUduxvAMwFEX + jEtSwDrAQVFHJ4rABMBRF4x27d/PwEFRRjx3KfAAGRwVABUAFSQAABa8jYCACBWgBBbA79D/BxWu + JQAmmvGQ1wUcFQgZNQYIBBkoBGJib3gEeG1pbhUMFpjxEhbK40MWyKc5JprxkNcFJo7Z+tYFHBgE + SwGHwhgE2J+MwhYAKARLAYfCGATYn4zCABksFQQVBBUCABUAFQQVEAAAFtyRgIAIFfIBFu6U0f8H + FdYBACaumcrXBRwVCBk1BggEGSgEYmJveAR4bWF4FQwWmPESFrDkQxbCpjkmrpnK1wUm1oC01wUc + GARDAYfCGATSn4zCFgAoBEMBh8IYBNKfjMIAGSwVBBUEFQIAFQAVBBUQAAAWzpOAgAgV8gEWxJbR + /wcV1gEAJpin7dcFHBUIGTUGCAAZKARiYm94BHltaW4VDBaY8RIWrslLFr6zLSaYp+3XBTwYBAwA + B8IYBFk+EsIWACgEDAAHwhgEWT4SwgAZHBUAFQAVEAAAFsCVgIAIFfIBFpqY0f8HFdYBACbW2prY + BRwVCBk1BggAGSgEYmJveAR5bWF4FQwWmPESFrDJSxaumC0m1tqa2AU8GATi/wbCGARHPhLCFgAo + BOL/BsIYBEc+EsIAGRwVABUAFRAAABayl4CACBXyARbwmdH/BxXWAQAmxPPH2AUcFQIZNQYIBBkY + B3ZlcnNpb24VDBaY8RIW/gQWoAYmxPPH2AUmhPPH2AUcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAA + AAAAGSwVBBUEFQIAFQAVBBUQAAAWpJmAgAgV0gEWxpvR/wcV1gEAJuT5x9gFHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWmPESFv4FFqAHJuT5x9gFJqT5x9gFHBgAGAAW + ACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW9pqAgAgV0gEWnJ3R/wcVVgAmiILI2AUcFQwZJQYEGUgH + c291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFpjxEhbCjgQWrrYCJoiCyNgFJsSAyNgFHDYA + KA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW + yJyAgAgV4gEW8p3R/wcV9gQAJvK2ytgFHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJl + Y29yZF9pZBUMFpjxEhbi4tACFvaZhwEm8rbK2AU8NgAoC3c5NjY1MjY5OEAxGAwwMDAwNWFmMGMx + MDkAGRwVABUAFRAAABaqnoCACBXyARbootH/BxXOAwAmwPjR2QUcFQwZJQYEGUgHc291cmNlcwRs + aXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBaY8RIWgqARFuLmBCbA+NHZBSbo0NHZBRw2ACgYMjAy + NC0xMS0yNlQyMDo0MjowNi4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIA + FQAVBBUQAAAWnKCAgAgV4gEWtqbR/wcV1gYAJqzJ2NkFHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdl + bGVtZW50CmNvbmZpZGVuY2UVDBaY8RIWoNciFrKyICasydjZBSbKt9bZBRwYCAAAAAAAAPA/GAgA + AABgF7fdPxacGCgIAAAAAAAA8D8YCAAAAGAXt90/ABksFQQVBBUCABUAFQQVEAAAFv6hgIAIFfIB + Foyt0f8HFeACACbE6vbZBRwVAhk1BggEGRgFbGV2ZWwVDBaY8RIW0AUW8gYmxOr22QUm/On22QUc + GAQBAAAAGAT/////FoDxEigEAQAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABbwo4CACBXUARbs + r9H/BxXGAQAmlvP22QUcFQwZNQYIBBkYB3N1YnR5cGUVDBaY8RIWgBIWxBEmlvP22QUm7vD22QUc + NrTsEigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABbEpYCA + CBXeARaysdH/BxXKAwAm0IX32QUcFQwZNQYIBBkYBWNsYXNzFQwWmPESFvoSFvgRJtCF99kFJrKC + 99kFHDbg7BIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABaip4CACBXi + ARb8tNH/BxX6AgAmqpT32QUcFQoZNQYIABkYBmhlaWdodBUMFpjxEhbEBBbUBSaqlPfZBTwYCAAA + AAAAAERAGAgAAAAAAAAsQBaU8RIoCAAAAAAAAERAGAgAAAAAAAAsQAAZHBUAFQAVEAAAFoSpgIAI + FdIBFva30f8HFbYBACb+mffZBRwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFpjxEhbuNxbqKSb+ + mffZBTw2pO8SKBF2aWxsYSBDYXByaWNvcm5pbxgcNy0wMDkgRG9jdG9yIFJvYmVydG8gT3JkZW5l + cwAZHBUAFQAVEAAAFtaqgIAIFeIBFqy50f8HFYwGACa4xPfZBRwVDBklBgQZSAVuYW1lcwZjb21t + b24Ja2V5X3ZhbHVlA2tleRUMFpzxEhb+DRbYDSa4xPfZBSbow/fZBRw2kPESKAJlcxgCZW4AGSwV + BBUEFQIAFQAVBBUQAAAWuKyAgAgV4AEWuL/R/wcVjgEAJsDR99kFHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUFdmFsdWUVDBac8RIWuBAW7A4mwNH32QU8NpDxEigSU2FuIFJhZmFlbCBB + aXJwb3J0GA5BcmdlbnRpbmUgTWFpbAAZHBUAFQAVEAAAFpiugIAIFeABFsbA0f8HFaACACao4ffZ + BRwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFqTxEhbsDxauDiao + 4ffZBSas4PfZBRw2jvESKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAAFvivgIAI + FeABFubC0f8HFawBACba7vfZBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFu + Z3VhZ2UVDBak8RIWlg8Wyg0m2u732QU8NpzxEigCZXMYAmVuABkcFQAVABUQAAAW2LGAgAgV4AEW + ksTR/wcVhgEAJtb+99kFHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUM + FqTxEhbiERbiDybW/vfZBSak/PfZBRw2jvESKANER1IYA0JOQQAZLBUEFQQVAgAVABUEFRAAABa4 + s4CACBXgARaYxdH/BxXAAQAmhoz42QUcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWpPESFuoOFqYNJoaM+NkFPDak8RIAGRwVABUAFRAAABaY + tYCACBXgARbYxtH/BxV2ACasmfjZBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQE + c2lkZRUMFqTxEhbmDhaiDSasmfjZBTw2pPESABkcFQAVABUQAAAW+LaAgAgV4AEWzsfR/wcVdgAm + zqb42QUcFQAZNQYIABkYCWhhc19wYXJ0cxUMFpjxEha0sgIWsAYmzqb42QU8GAEAGAEAFgAoAQAY + AQAAGRwVABUAFRAAABbYuICACBXSARbEyNH/BxV2ACb+rPjZBRwVABk1BggAGRgOaXNfdW5kZXJn + cm91bmQVDBaY8RIWtLICFrAGJv6s+NkFPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWqrqAgAgV + 0gEWusnR/wcVdgAmrrP42QUcFQIZNQYIABkYCm51bV9mbG9vcnMVDBaY8RIW2AQW6AUmrrP42QU8 + GAQDAAAAGAQBAAAAFpDxEigEAwAAABgEAQAAAAAZHBUAFQAVEAAAFvy7gIAIFdIBFrDK0f8HFaYB + ACaWufjZBRwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFpjxEhaQBBagBSaWufjZ + BTw2mPESABkcFQAVABUQAAAWzr2AgAgV0gEW1svR/wcVdgAmtr742QUcFQoZNQYIABkYCm1pbl9o + ZWlnaHQVDBaY8RIWkAQWoAUmtr742QU8NpjxEgAZHBUAFQAVEAAAFqC/gIAIFdIBFszM0f8HFXYA + JtbD+NkFHBUCGTUGCAAZGAltaW5fZmxvb3IVDBaY8RIWkAQWoAUm1sP42QU8NpjxEgAZHBUAFQAV + EAAAFvLAgIAIFdIBFsLN0f8HFXYAJvbI+NkFHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBaY8RIW + kAQWoAUm9sj42QU8NpjxEgAZHBUAFQAVEAAAFsTCgIAIFdIBFrjO0f8HFXYAJpbO+NkFHBUMGTUG + CAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBaY8RIWkAQWoAUmls742QU8NpjxEgAZHBUAFQAVEAAAFpbE + gIAIFdIBFq7P0f8HFXYAJrbT+NkFHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWmPESFpAEFqAF + JrbT+NkFPDaY8RIAGRwVABUAFRAAABboxYCACBXSARak0NH/BxV2ACbW2PjZBRwVDBk1BggAGRgK + cm9vZl9zaGFwZRUMFpjxEhaQBBagBSbW2PjZBTw2mPESABkcFQAVABUQAAAWuseAgAgV0gEWmtHR + /wcVdgAm9t342QUcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWmPESFpAEFqAFJvbd+NkFPDaY + 8RIAGRwVABUAFRAAABaMyYCACBXSARaQ0tH/BxV2ACaW4/jZBRwVDBk1BggAGRgQcm9vZl9vcmll + bnRhdGlvbhUMFpjxEhaQBBagBSaW4/jZBTw2mPESABkcFQAVABUQAAAW3sqAgAgV0gEWhtPR/wcV + dgAmtuj42QUcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBaY8RIWkAQWoAUmtuj42QU8NpjxEgAZHBUA + FQAVEAAAFrDMgIAIFdIBFvzT0f8HFXYAJtbt+NkFHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFpjx + EhaQBBagBSbW7fjZBTw2mPESABkcFQAVABUQAAAWgs6AgAgV0gEW8tTR/wcVdgAWhpn4GhaY8RIm + jJC9ywUW6uK7DhRkABn8Jib28vjZBRwVDBk1BggAGRgCaWQVDBaIrxMW8KK5BRb888cBJvby+NkF + PDYAKCAwOGJjMzZkZDc2ZDE1ZmZmMDIwMDgwZWZmZTFhMDY5YRggMDhiYjI5OTIwYTY4NmZmZjAy + MDA1MzgyNGI1MjMzNDkAGRwVABUAFRAAABbUz4CACBXyARbo1dH/BxXWCAAm8ubA2wUcFQwZNQYI + ABkYCGdlb21ldHJ5FQwWiK8TFvjNhRAWzL/LCSby5sDbBTw2ACjDAQAAAAAGAAAAAgAAAAADAAAA + AQAAAAXAUeFxg3hBCMBA07LfKmQ5wFHhcdaqFIDAQNOx+INdJsBR4XJEP32ewEDTsmcWX1HAUeFx + 8Q2rm8BA07NNvWiXwFHhcYN4QQjAQNOy3ypkOQAAAAADAAAAAQAAAAXAUeFxWCN8KcBA07F41/AN + wFHhcQTxpvXAQNOyX370b8BR4XBZcOv3wEDTsbJxP4/AUeFwrKLDssBA07DLyj74wFHhcVgjfCnA + QNOxeNfwDRhNAAAAAAMAAAABAAAABMBQ8mwYj/aPwEFtBqlJI5jAUPJsLx1jWcBBbQe94LNtwFDy + a7FwWULAQW0H2bt6AsBQ8mwYj/aPwEFtBqlJI5gAGRwVABUAFSQAABbG0YCACBWgBBa+3tH/BxWu + JQAmvqaM5QUcFQgZNQYIABkoBGJib3gEeG1pbhUMFoivExbwwE0W7tMoJr6mjOUFPBgEBgCHwhgE + 5DKgwhYAKAQGAIfCGATkMqDCABkcFQAVABUQAAAW5tWAgAgV8gEW7IPS/wcV1gEAJqz6tOUFHBUI + GTUGCAAZKARiYm94BHhtYXgVDBaIrxMW8MBNFqzVKCas+rTlBTwYBP//hsIYBNsyoMIWACgE//+G + whgE2zKgwgAZHBUAFQAVEAAAFtjXgIAIFfIBFsKF0v8HFdYBACbYz93lBRwVCBk1BggAGSgEYmJv + eAR5bWluFQwWiK8TFvDATRb01ysm2M/d5QU8GARETdLBGAS+nwzCFgAoBERN0sEYBL6fDMIAGRwV + ABUAFRAAABbK2YCACBXyARaYh9L/BxXWAQAmzKeJ5gUcFQgZNQYIABkoBGJib3gEeW1heBUMFoiv + ExbwwE0W0NorJsynieYFPBgEJk3SwRgEr58MwhYAKAQmTdLBGASvnwzCABkcFQAVABUQAAAWvNuA + gAgV8gEW7ojS/wcV1gEAJtyCteYFHBUCGTUGCAQZGAd2ZXJzaW9uFQwWiK8TFv4EFqAGJtyCteYF + JpyCteYFHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFq7dgIAI + FdIBFsSK0v8HFdYBACb8iLXmBRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0 + eRUMFoivExb+BRagByb8iLXmBSa8iLXmBRwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFoDf + gIAIFdIBFpqM0v8HFVYAJqCRteYFHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFz + ZXQVDBaIrxMW9NwEFtLcAiagkbXmBSbcj7XmBRw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9w + ZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFtLggIAIFeIBFvCM0v8HFfYEACau7LfmBRwV + DBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaIrxMWvtfXAhaG4IoBJq7s + t+YFPDYAKAx3OTk2NTAyOTY2QDMYDDAwMDE4YzY1YzQyNgAZHBUAFQAVEAAAFrTigIAIFfIBFuaR + 0v8HFdQDACas+cLnBRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUM + FoivExa20RIW4pkGJqz5wucFJrTMwucFHDYAKBgyMDI0LTExLTI1VDIxOjU1OjU4LjAwMFoYGDIw + MDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABam5ICACBXiARa6ldL/BxXW + BgAm4vPK5wUcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFoivExaq + whsWupIYJuLzyucFJpbmyOcFHBgIAAAAAAAA8D8YCAAAAKAPeuA/FsiBBygIAAAAAAAA8D8YCAAA + AKAPeuA/ABksFQQVBBUCABUAFQQVEAAAFojmgIAIFfIBFpCc0v8HFfACACaY+eDnBRwVAhk1BggE + GRgFbGV2ZWwVDBaIrxMW1AUW9gYmmPng5wUm0Pjg5wUcGAQBAAAAGAT/////FvKuEygEAQAAABgE + /////wAZLBUEFQQVAgAVABUEFRAAABb654CACBXUARaAn9L/BxXWAQAm7IHh5wUcFQwZNQYIBBkY + B3N1YnR5cGUVDBaIrxMWvBoWuBgm7IHh5wUmxv/g5wUcNqynEygOdHJhbnNwb3J0YXRpb24YDGFn + cmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABbO6YCACBXiARbWoNL/BxXcAwAmoJzh5wUcFQwZ + NQYIBBkYBWNsYXNzFQwWiK8TFvYaFsgYJqCc4ecFJv6X4ecFHDaeqBMoCXdhcmVob3VzZRgKYXBh + cnRtZW50cwAZLBUEFQQVAgAVABUEFRAAABaw64CACBXiARaypNL/BxW6AwAmxrDh5wUcFQoZNQYI + ABkYBmhlaWdodBUMFoivExbUBBbSBSbGsOHnBTwYCAAAAAAAABhAGAgAAAAAAAAUQBaCrxMoCAAA + AAAAABhAGAgAAAAAAAAUQAAZHBUAFQAVEAAAFpLtgIAIFdQBFuyn0v8HFZYBACaYtuHnBRwVDBk1 + BggAGSgFbmFtZXMHcHJpbWFyeRUMFoivExaiVhaIPSaYtuHnBTw2pqwTKApwYWJlbGxvbmVzGARB + Q0hTABkcFQAVABUQAAAW5u6AgAgV4gEWgqnS/wcVigUAJqDz4ecFHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUDa2V5FQwWkK8TFu4SFvYQJqDz4ecFPDaArxMoAmVzGAJlbgAZHBUAFQAV + EAAAFsjwgIAIFeIBFoyu0v8HFZYBACaWhOLnBRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3Zh + bHVlBXZhbHVlFQwWkK8TFuQWFs4SJpaE4ucFPDaArxMoC05hdGlvbiBCYW5rGA1CYW5jbyBOYWNp + w7NuABkcFQAVABUQAAAWqvKAgAgV4gEWoq/S/wcV4gIAJuCX4ucFHBUMGSUGBBlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWoK8TFuwVFqYSJuCX4ucFJuSW4ucFHDb2rhMoBXNo + b3J0GAlhbHRlcm5hdGUAGSwVBBUEFQIAFQAVBBUQAAAWjPSAgAgV4gEWhLLS/wcVoAIAJoqp4ucF + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFqCvExacFRa0ESaK + qeLnBTw2lK8TKAJlcxgCZW4AGRwVABUAFRAAABbu9YCACBXiARaktNL/BxWOAQAmxL3i5wUcFQwZ + JQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWoK8TFuwYFrYUJsS94ucFJr66 + 4ucFHDb2rhMoB1VuaW1hcmMYA0JOQQAZLBUEFQQVAgAVABUEFRAAABbQ94CACBXiARaytdL/BxXU + AwAm9M7i5wUcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdl + bGVtZW50FQwWoK8TFuAUFowRJvTO4ucFPDagrxMAGRwVABUAFRAAABay+YCACBXiARaGudL/BxV2 + ACaA4OLnBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFqCvExbUFBb8 + ECaA4OLnBTw2oK8TABkcFQAVABUQAAAWlPuAgAgV4gEW/LnS/wcVdgAm/PDi5wUcFQAZNQYIABkY + CWhhc19wYXJ0cxUMFoivExaSugIWsAYm/PDi5wU8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABb2 + /ICACBXSARbyutL/BxV2ACas9+LnBRwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaIrxMWkroC + FrAGJqz34ucFPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWyP6AgAgV0gEW6LvS/wcVdgAm3P3i + 5wUcFQIZNQYIABkYCm51bV9mbG9vcnMVDBaIrxMWnAYWkAcm3P3i5wU8GAQPAAAAGAQBAAAAFuiu + EygEDwAAABgEAQAAAAAZHBUAFQAVEAAAFpqAgYAIFdgBFt680v8HFcYBACbshOPnBRwVAhk1BggA + GRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFoivExaQBBagBSbshOPnBTw2iK8TABkcFQAVABUQ + AAAW8oGBgAgV0gEWpL7S/wcVdgAmjIrj5wUcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBaIrxMWkAQW + oAUmjIrj5wU8NoivEwAZHBUAFQAVEAAAFsSDgYAIFdIBFpq/0v8HFXYAJqyP4+cFHBUCGTUGCAAZ + GAltaW5fZmxvb3IVDBaIrxMWkAQWoAUmrI/j5wU8NoivEwAZHBUAFQAVEAAAFpaFgYAIFdIBFpDA + 0v8HFXYAJsyU4+cFHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBaIrxMWkAQWoAUmzJTj5wU8Noiv + EwAZHBUAFQAVEAAAFuiGgYAIFdIBFobB0v8HFXYAJuyZ4+cFHBUMGTUGCAAZGA9mYWNhZGVfbWF0 + ZXJpYWwVDBaIrxMWqgQWugUm7Jnj5wU8GAR3b29kGAR3b29kFoavEygEd29vZBgEd29vZAAZHBUA + FQAVEAAAFrqIgYAIFdIBFvzB0v8HFYYBACamn+PnBRwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUM + FoivExaQBBagBSamn+PnBTw2iK8TABkcFQAVABUQAAAWjIqBgAgV0gEWgsPS/wcVdgAmxqTj5wUc + FQwZNQYIABkYCnJvb2Zfc2hhcGUVDBaIrxMWkAQWoAUmxqTj5wU8NoivEwAZHBUAFQAVEAAAFt6L + gYAIFdIBFvjD0v8HFXYAJuap4+cFHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFoivExaQBBag + BSbmqePnBTw2iK8TABkcFQAVABUQAAAWsI2BgAgV0gEW7sTS/wcVdgAmhq/j5wUcFQwZNQYIABkY + EHJvb2Zfb3JpZW50YXRpb24VDBaIrxMWkAQWoAUmhq/j5wU8NoivEwAZHBUAFQAVEAAAFoKPgYAI + FdIBFuTF0v8HFXYAJqa04+cFHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWiK8TFpAEFqAFJqa04+cF + PDaIrxMAGRwVABUAFRAAABbUkIGACBXSARbaxtL/BxV2ACbGuePnBRwVChk1BggAGRgLcm9vZl9o + ZWlnaHQVDBaIrxMWkAQWoAUmxrnj5wU8NoivEwAZHBUAFQAVEAAAFqaSgYAIFdIBFtDH0v8HFXYA + FrachxsWiK8TJvby+NkFFvDL6g0UZgAZ/CYm5r7j5wUcFQwZNQYIABkYAmlkFQwW7L4TFoDbvQUW + lNrHASbmvuPnBTw2ACggMDhiYjJjNTQ5ZWQyM2ZmZjAyMDA1NWI4YzE0ZWIzODkYIDA4YmIyYzA4 + MDAzMjVmZmYwMjAwMTg4OWZlM2Y3NmFhABkcFQAVABUQAAAW+JOBgAgV8gEWxsjS/wcV1ggAJvqY + q+kFHBUMGTUGCAAZGAhnZW9tZXRyeRUMFuy+ExbU/YcQFqL0xwkm+pir6QU8NgAoiQwAAAAAAwAA + AAwAAAAmwFHMB8rPnIvAQNcEg/M/J8BRzActGus+wEDXDSWCcIjAUcwEMBBpBMBA1wwyPWnuwFHM + AKEPr6DAQNcZzFngRsBRy/tEQ/yvwEDXGI5sPu3AUcv6t8GizcBA1xN5WYgywFHL+jwGQIzAQNcT + Zg5R0sBRy/n4fwI/wEDXFlxi12bAUcv4wvTctsBA1xX/RcXdwFHL+JCf9dTAQNcYHgP3BsBRy+Zk + uOc9wEDXExtltxTAUcvnI/uHy8BA1wy+VGQFwFHL7Z8/y8jAQNcLInLxj8BRy+5ZDo8PwEDXBUg+ + XTPAUcvtgyW5zsBA1wUsj6sDwFHL7hWHUMLAQNb/wsNej8BRy+1sf4UbwEDW9bRMo0fAUcvpP8oa + a8BA1vK0veJOwFHL6smideHAQNbsYObKpcBRy+sut6NwwEDW7Dv93RDAUcvreB4ez8BA1utIuNZ2 + wFHL7bAGw2nAQNbrB0p3HcBRy+6AEFuYwEDW8qJJa4TAUcvxEpHS/MBA1vMuYGWbwFHL9JDLlL7A + QNbkJoWlx8BRy/XGVbpHwEDW5P4b+jLAUcv2yLQ5WMBA1uMERraewFHL+ZNp1LDAQNbnOV+dH8BR + y/3njGu0wEDW6hMusO3AUcwCCO68C8BA1utbLU1AwFHL/yKKboPAQNb2utzgQMBRy/u6i4GpwEDW + 9dDSFQvAUcv7nnFvr8BA1vdZaFEiwFHMBTLaR+DAQNb6Wc3RsMBRzASPsblLwEDXAm5vSWTAUcwG + FBY3esBA1wKv3ai9wFHMBhQWN3rAQNcEE4r3P8BRzAfKz5yLwEDXBIPzPycAAAAFwFHMAQ1GOaDA + QNcG9BAHtcBRy/6PvXfFwEDXBmIZ0IzAUcv+O29B18BA1wpe/pMYwFHMALj4A7LAQNcK8PTKQsBR + zAENRjmgwEDXBvQQB7UAAAAFwFHL+mIxTYDAQNcJnTezy8BRy/kUvtPmwEDXCUh+HhPAUcv4gsic + vMBA1w99S4U6wFHL+dA7FlfAQNcP0gUa8sBRy/piMU2AwEDXCZ03s8sAAAAFwFHL9eNGi9bAQNcK + txMnJMBRy/Dxb0OFwEDXCYJfwTHAUcvwvJYd5MBA1wva/5V3wFHL9a5tZjXAQNcNEIm6/8BRy/Xj + RovWwEDXCrcTJyQAAAAFwFHL6+iGZrfAQNcOPockTMBRy+gEzBebwEDXDx6A9IfAUcvn1+sOAMBA + 1xDEc2H3wFHL65Q4MMnAQNcRdkoJOcBRy+vohma3wEDXDj6HJEwAAAAFwFHL+4EVPlbAQNb87SYI + qMBRy/ozosS8wEDW/JeVs1vAUcv5oayNksBA1wLMYxqCwFHL+u8fByzAQNcDIRywOsBRy/uBFT5W + wEDW/O0mCKgAAAAFwFHL9hPt847AQNb+czgGAcBRy/ZGrjo7wEDW/KGmrlXAUcvyRZe5xsBA1vts + 80hiwFHL8hLXcxnAQNb9P1tfosBRy/YT7fOOwEDW/nM4BgEAAAAFwFHL+TPIhGnAQNbz/Lx+ocBR + y/TI/7iywEDW8YAKfFvAUcv0FRAyfcBA1vO7Th9IwFHL+R0iT7bAQNb1AnX8BsBRy/kzyIRpwEDW + 8/y8fqEAAAAFwFHL/kKQnkjAQNbvANQ7VsBRy/0NcdiKwEDW89Oh0yTAUcv9gTUexsBA1vQkKar0 + wFHL/rXohLnAQNbvUVwTJsBRy/5CkJ5IwEDW7wDUO1YAAAAFwFHL+oBkPm7AQNbsQrPZt8BRy/lL + sNh6wEDW8RWBcYXAUcv5v3QetsBA1vFmCUlVwFHL+vQnhKnAQNbskzuxh8BRy/qAZD5uwEDW7EKz + 2bcAAAAFwFHL95SME5/AQNbqlF3wdsBRy/ZfbU3hwEDW72criETAUcv20zCUHcBA1u+3s2AUwFHL + +Afj+hDAQNbq5OXIRsBRy/eUjBOfwEDW6pRd8HYAAAAFwFHL9SF/rInAQNbo/YT7fcBRy/PsYObL + wEDW7dBSk0vAUcv0YCQtBsBA1u4g2msbwFHL9ZVC8sTAQNbpTgzTTcBRy/Uhf6yJwEDW6P2E+30Y + TQAAAAADAAAAAQAAAATAUcsJAUpZQcBA06nLkRYpwFHLCRz6dXTAQNOq3rwd78BRywihu8evwEDT + qwFtYD3AUcsJAUpZQcBA06nLkRYpABkcFQAVABUkAAAW6pWBgAgVoAQWnNHS/wcVriUAJsKshfMF + HBUIGTUGCAQZKARiYm94BHhtaW4VDBbsvhMWurQ/FsyYNibCrIXzBSacjfPyBRwYBAMIjsIYBE5o + j8IWACgEAwiOwhgETmiPwgAZLBUEFQQVAgAVABUEFRAAABaKmoGACBXyARbK9tL/BxXWAQAmkMu7 + 8wUcFQgZNQYIBBkoBGJib3gEeG1heBUMFuy+ExbQvD8Wzpw2JpDLu/MFJuilqfMFHBgE9QeOwhgE + QmiPwhYAKAT1B47CGARCaI/CABksFQQVBBUCABUAFQQVEAAAFvybgYAIFfIBFqD40v8HFdYBACa2 + wt/zBRwVCBk1BggAGSgEYmJveAR5bWluFQwW7L4TFvz/TRbmqywmtsLf8wU8GAQGmAXCGAQSAAfC + FgAoBAaYBcIYBBIAB8IAGRwVABUAFRAAABbunYGACBXyARb2+dL/BxXWAQAmnO6L9AUcFQgZNQYI + ABkoBGJib3gEeW1heBUMFuy+ExaAgE4W3KcsJpzui/QFPBgE1ZcFwhgE9f8GwhYAKATVlwXCGAT1 + /wbCABkcFQAVABUQAAAW4J+BgAgV8gEWzPvS/wcV1gEAJriWuPQFHBUCGTUGCAQZGAd2ZXJzaW9u + FQwW7L4TFv4EFqAGJriWuPQFJviVuPQFHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQV + BBUCABUAFQQVEAAAFtKhgYAIFdIBFqL90v8HFdYBACbYnLj0BRwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAhwcm9wZXJ0eRUMFuy+Exb+BRagBybYnLj0BSaYnLj0BRwYABgAFgAoABgAABks + FQQVBBUCABUAFQQVEAAAFqSjgYAIFdIBFvj+0v8HFVYAJvykuPQFHBUMGSUGBBlIB3NvdXJjZXME + bGlzdAdlbGVtZW50B2RhdGFzZXQVDBbsvhMWuusEFsbxAib8pLj0BSa4o7j0BRw2ACgNT3BlblN0 + cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFvakgYAIFeIB + Fs7/0v8HFfYEACb+lLv0BRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQV + DBbsvhMWqOHfAhaqkooBJv6Uu/QFPDYAKAx3OTk3MzE1NDk3QDEYDDAwMDA0Mjg4OGNhNwAZHBUA + FQAVEAAAFtimgYAIFfIBFsSE0/8HFc4DACbE4cX1BRwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudAt1cGRhdGVfdGltZRUMFuy+ExbMzBUW7L4GJsThxfUFJqinxfUFHDYAKBgyMDI0LTExLTMw + VDE2OjUyOjM5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAA + ABbKqIGACBXiARaSiNP/BxXWBgAmqITN9QUcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQK + Y29uZmlkZW5jZRUMFuy+Exa+5hUWkrUSJqiEzfUFJpTmy/UFHBgIB/AWSFD87j8YCM3MzMzMzOQ/ + FqrDCygIB/AWSFD87j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFqyqgYAIFfIBFuiO0/8H + FfYCACamm971BRwVAhk1BggAGRgFbGV2ZWwVDBbsvhMWhAUWlAYmppve9QU8GAQDAAAAGAQBAAAA + Ft6+EygEAwAAABgEAQAAAAAZHBUAFQAVEAAAFp6sgYAIFdQBFt6R0/8HFaYBACbio971BRwVDBk1 + BggEGRgHc3VidHlwZRUMFuy+ExbwHhbGHCbio971BSa6od71BRw2nK8TKA50cmFuc3BvcnRhdGlv + bhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFvKtgYAIFeIBFoST0/8HFbIDACbIwd71 + BRwVDBk1BggEGRgFY2xhc3MVDBbsvhMW6h4WihwmyMHe9QUmgL7e9QUcNvSvEygJd2FyZWhvdXNl + GAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFtSvgYAIFeIBFraW0/8HFeICACaK2t71BRwV + Chk1BggAGRgGaGVpZ2h0FQwW7L4TFqoEFroFJora3vUFPBgIAAAAAAAAIEAYCAAAAAAAACBAFuq+ + EygIAAAAAAAAIEAYCAAAAAAAACBAABkcFQAVABUQAAAWtrGBgAgV0gEWmJnT/wcVlgEAJsTf3vUF + HBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwW7L4TFsg3FuIoJsTf3vUFPDaYvRMoEmJvdGlsbGVy + aWEgZWwgQXJhbxgQQVBSIExhcyBNZXJjZWRlcwAZHBUAFQAVEAAAFoizgYAIFeABFq6a0/8HFa4F + ACamiN/1BRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFvC+ExbYDRaoDSam + iN/1BTw26L4TKAJlcxgCZW4AGRwVABUAFRAAABbotIGACBXgARbcn9P/BxV+ACbOld/1BRwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW8L4TFtgPFsINJs6V3/UFPDbovhMo + ClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFsi2gYAIFeABFtqg0/8HFaIBACaQ + o9/1BRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFvS+ExagEBbO + DSaQo9/1BTw25L4TKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAWqLiBgAgV4AEW/KHT + /wcV2gEAJt6w3/UFHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUM + FvS+ExaQDxakDSbesN/1BTw27L4TKAJlcxgCZW4AGRwVABUAFRAAABaIuoGACBXgARbWo9P/BxV+ + ACaCvt/1BRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBb0vhMWoBIW + 9g4mgr7f9QU8NuS+EygQQ2FzYSBMYSBQYWphcmVyYRgZQmFuY28gZGVsIEVzdGFkbyBkZSBDaGls + ZQAZHBUAFQAVEAAAFui7gYAIFeABFtSk0/8HFYADACb4zN/1BRwVChklBgAZeAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBb0vhMW5A4Wjg0m+Mzf9QU8NvS+ + EwAZHBUAFQAVEAAAFsi9gYAIFeABFtSn0/8HFXYAJoba3/UFHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudARzaWRlFQwW9L4TFuAOFogNJoba3/UFPDb0vhMAGRwVABUAFRAAABaov4GA + CBXgARbKqNP/BxV2ACaO59/1BRwVABk1BggAGRgJaGFzX3BhcnRzFQwW7L4TFo68AhawBiaO59/1 + BTwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFojBgYAIFdIBFsCp0/8HFXYAJr7t3/UFHBUAGTUG + CAAZGA5pc191bmRlcmdyb3VuZBUMFuy+ExaOvAIWsAYmvu3f9QU8GAEAGAEAFgAoAQAYAQAAGRwV + ABUAFRAAABbawoGACBXSARa2qtP/BxV2ACbO9N/1BRwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFuy+ + ExbiBxaECSbO9N/1BSbu89/1BRwYBAUAAAAYBAEAAAAWtr0TKAQFAAAAGAQBAAAAABksFQQVBBUC + ABUAFQQVEAAAFqzEgYAIFdgBFqyr0/8HFdYBACby/N/1BRwVAhk1BggAGRgWbnVtX2Zsb29yc191 + bmRlcmdyb3VuZBUMFuy+ExaQBBagBSby/N/1BTw27L4TABkcFQAVABUQAAAWhMaBgAgV0gEWgq3T + /wcVdgAmkoLg9QUcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbsvhMWkAQWoAUmkoLg9QU8Nuy+EwAZ + HBUAFQAVEAAAFtbHgYAIFdIBFvit0/8HFXYAJrKH4PUFHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbs + vhMWkAQWoAUmsofg9QU8Nuy+EwAZHBUAFQAVEAAAFqjJgYAIFdIBFu6u0/8HFXYAJtKM4PUFHBUM + GTUGCAAZGAxmYWNhZGVfY29sb3IVDBbsvhMWkAQWoAUm0ozg9QU8Nuy+EwAZHBUAFQAVEAAAFvrK + gYAIFdIBFuSv0/8HFXYAJvKR4PUFHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbsvhMWqgQW + ugUm8pHg9QU8GAR3b29kGAR3b29kFuq+EygEd29vZBgEd29vZAAZHBUAFQAVEAAAFszMgYAIFdIB + Ftqw0/8HFYYBACasl+D1BRwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFuy+Exa2BBbGBSasl+D1 + BTwYCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMW6r4TKApyb29mX3RpbGVzGApyb29mX3RpbGVzABkc + FQAVABUQAAAWns6BgAgV0gEW4LHT/wcVngEAJvKc4PUFHBUMGTUGCAAZGApyb29mX3NoYXBlFQwW + 7L4TFtAEFuAFJvKc4PUFPDbovhMoCHNraWxsaW9uGAZoaXBwZWQAGRwVABUAFRAAABbwz4GACBXU + ARb+stP/BxWSAQAm0qLg9QUcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwW7L4TFpAEFqAFJtKi + 4PUFPDbsvhMAGRwVABUAFRAAABbE0YGACBXSARaQtNP/BxV2ACbyp+D1BRwVDBk1BggAGRgQcm9v + Zl9vcmllbnRhdGlvbhUMFuy+ExaQBBagBSbyp+D1BTw27L4TABkcFQAVABUQAAAWltOBgAgV0gEW + hrXT/wcVdgAmkq3g9QUcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbsvhMWkAQWoAUmkq3g9QU8Nuy+ + EwAZHBUAFQAVEAAAFujUgYAIFdIBFvy10/8HFXYAJrKy4PUFHBUKGTUGCAAZGAtyb29mX2hlaWdo + dBUMFuy+ExaQBBagBSaysuD1BTw27L4TABkcFQAVABUQAAAWutaBgAgV0gEW8rbT/wcVdgAWhO73 + GhbsvhMm5r7j5wUW7Pj8DRRoABn8JibSt+D1BRwVDBk1BggAGRgCaWQVDBbI+RQWup3yBRaogNUB + JtK34PUFPDYAKCAwOGJiMmM1NWIzZDQ4ZmZmMDIwMDhlOWU3YTVkMjczZBggMDhiYjJjMDg2NTkz + NGZmZjAyMDBkOTA1YjhiNzE4ZjEAGRwVABUAFRIAABaM2IGACBWQAhbot9P/BxXeCQAm+re19wUc + FQwZNQYIABkYCGdlb21ldHJ5FQwWyPkUFoLGkxEWlOmMCib6t7X3BTw2ACiFBgAAAAADAAAABwAA + AA/AUdqMEfGaDMBAqGMn7YTTwFHaiu7b607AQKhjVGMupMBR2oqAISKPwECoW23k3+nAUdqNDgV8 + QcBAqFeV6QrxwFHaiUHIIWzAQKhQiK6Py8BR2pTs9w7AwECoPvk6EyHAUdqc9W6shsBAqE3i4eII + wFHamuQcdKvAQKhQ/8zUWsBR2ptU8BxdwECoUsMbcyPAUdqSXdCVr8BAqF3HW3PEwFHakpsNNyDA + QKhiJzyE7MBR2pGDtgKGwECoYlIEr5LAUdqQiA2AG8BAqGJ4mxxRwFHajP2p5GrAQKhjAwSXPsBR + 2owR8ZoMwECoYyfthNMAAAAGwFHajrRjSXvAQKhZbVmfr8BR2oxtYSxrwECoXPxaWRLAUdqMhbTg + R8BAqF7xJx8pwFHaj34iRM7AQKheis/SO8BR2pCZP9eGwECoXM/kr0LAUdqOtGNJe8BAqFltWZ+v + AAAABcBR2pF91sV0wECoSO6GWvjAUdqOY3AR4cBAqE2tMfzSwFHakaie8BvAQKhTpnBBscBR2pTD + cQN4wECoTubt4EPAUdqRfdbFdMBAqEjuhlr4AAAABcBR2pdrVpAwwECoROyZGu/AUdqTcWFsLMBA + qErvEZszwFHalTFVDKLAQKhOKwY+CMBR2pkrSjCmwECoSCiNvcPAUdqXa1aQMMBAqETsmRrvAAAA + BcBR2pgHXcJTwECoS+xnnMfAUdqXHwB2SMBAqE1URqkywFHamUYiI0DAQKhRNlN5JMBR2pouFA+B + wECoT850bLnAUdqYB13CU8BAqEvsZ5zHAAAABcBR2pHaHRdowECoVOHZpEzAUdqRH+L0VsBAqFYU + 34sVwFHak5hjOLTAQKhaSErybcBR2pRTCLuQwECoWRVFC6PAUdqR2h0XaMBAqFTh2aRMAAAABcBR + 2pVKFCBIwECoURj3R8vAUdqUBrKhqMBAqFMVUModwFHalfPyq4TAQKhWgezUqsBR2pc3VCokwECo + VIZqEe3AUdqVShQgSMBAqFEY90fLGE0AAAAAAwAAAAEAAAAEwFHGaUNTSOvAQLwhB5DJ8MBRxmlf + poWPwEC8IiMF5+TAUcZo4hMubcBAvCJGR1wMwFHGaUNTSOvAQLwhB5DJ8AAZHBUAFQAVJgAAFpza + gYAIFb4EFsbB0/8HFbYnACbMl9KBBhwVCBk1BggEGSgEYmJveAR4bWluFQwWyPkUFvq2PxbYvzYm + zJfSgQYmjqHCgQYcGAQECI7CGAQJcI/CFgAoBAQIjsIYBAlwj8IAGSwVBBUEFQIAFQAVBBUSAAAW + 2t6BgAgVkAIW/OjT/wcV7gEAJozZiIIGHBUIGTUGCAQZKARiYm94BHhtYXgVDBbI+RQWkrk/FtjD + NiaM2YiCBibm4PiBBhwYBPwHjsIYBPpvj8IWACgE/AeOwhgE+m+PwgAZLBUEFQQVAgAVABUEFRIA + ABbq4IGACBWQAhbq6tP/BxXuAQAmvqSvggYcFQgZNQYIABkoBGJib3gEeW1pbhUMFsj5FBa461MW + /L4uJr6kr4IGPBgECDAEwhgEDUwGwhYAKAQIMATCGAQNTAbCABkcFQAVABUSAAAW+uKBgAgVkAIW + 2OzT/wcV7gEAJrrj3YIGHBUIGTUGCAAZKARiYm94BHltYXgVDBbI+RQWuutTFrLALia6492CBjwY + BMgvBMIYBPZLBsIWACgEyC8EwhgE9ksGwgAZHBUAFQAVEgAAForlgYAIFZACFsbu0/8HFe4BACas + pIyDBhwVAhk1BggEGRgHdmVyc2lvbhUMFsj5FBbIBRb8BiaspIyDBibso4yDBhwYBAAAAAAYBAAA + AAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaa54GACBXsARa08NP/BxXuAQAmqKuM + gwYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbI+RQW2AYWjAgmqKuM + gwYm6KqMgwYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABaG6YGACBXsARai8tP/BxVeACa4 + tIyDBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWyPkUFsicBRbyqwMm + uLSMgwYm9LKMgwYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUE + FQQVAgAVABUEFRIAABby6oGACBX+ARaA89P/BxXCBQAm5t6PgwYcFQwZJQYAGUgHc291cmNlcwRs + aXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWyPkUFvyT+wIWkr6KASbm3o+DBjw2ACgMdzk4NDQ1NjY1 + MUAyGAwwMDAwMGI4MjBhNTEAGRwVABUAFRIAABbw7IGACBWQAhbC+NP/BxWOBAAm4KCchAYcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbI+RQW+IojFtLWCybgoJyE + Bib4nJqEBhw2ACgYMjAyNC0xMS0xMlQyMDoyNzo1NC4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAw + LjAwMFoAGSwVBBUEFQIAFQAVBBUSAAAWgO+BgAgVhgIW0PzT/wcVvgcAJoqPp4QGHBUKGSUGBBlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbI+RQW6LUXFu78EyaKj6eEBibK86WE + BhwYCNBE2PD0Su8/GAjNzMzMzMzkPxbqmwwoCNBE2PD0Su8/GAjNzMzMzMzkPwAZLBUEFQQVAgAV + ABUEFRIAABaG8YGACBWOAhaOhNT/BxWiAwAmuPC5hAYcFQIZNQYIABkYBWxldmVsFQwWyPkUFpQG + FqIHJrjwuYQGPBgEAQAAABgE/////xaw+RQoBAEAAAAYBP////8AGRwVABUAFRIAABaU84GACBXu + ARawh9T/BxXSAQAm9Pm5hAYcFQwZNQYIBBkYB3N1YnR5cGUVDBbI+RQWxEQW9Dgm9Pm5hAYm2ve5 + hAYcNrrCFCgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRIAABaC + 9YGACBX+ARaCidT/BxXSAwAmxLS6hAYcFQwZNQYIBBkYBWNsYXNzFQwWyPkUFqRNFqw/JsS0uoQG + Js6wuoQGHDbywxQoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRIAABaA94GA + CBX+ARbUjNT/BxXSAwAm+u+6hAYcFQoZNQYIABkYBmhlaWdodBUMFsj5FBacMBawDSb677qEBjwY + CAAAAAAAADNAGAgAAAAAAAAIQBay9BQoCAAAAAAAADNAGAgAAAAAAAAIQAAZHBUAFQAVEgAAFv74 + gYAIFfIBFqaQ1P8HFeIBACaq/bqEBhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFsj5FBa6iQEW + xlcmqv26hAY8NrD1FCgUY2FwaWxsYSBKb3PDqSBPYnJlcm8YAzEyQQAZHBUAFQAVEgAAFvD6gYAI + Ff4BFoiS1P8HFeYFACbw1LuEBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUM + Fsz5FBaGGBbOFCbw1LuEBjw2xPkUKAJlcxgCZW4AGRwVABUAFRIAABbu/IGACBX+ARbul9T/BxWS + AQAmvum7hAYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFsz5FBaoHBaS + Fia+6buEBjw2xPkUKBFDb25ncmVzbyBOYWNpb25hbBgOQmFuY28gZGUgQ2hpbGUAGRwVABUAFRIA + ABbs/oGACBX+ARaAmdT/BxX8AQAm0P+7hAYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50B3ZhcmlhbnQVDBbM+RQW0hwWuhYm0P+7hAY8Nrz5FCgIb2ZmaWNpYWwYCWFsdGVybmF0ZQAZ + HBUAFQAVEgAAFuqAgoAIFf4BFvya1P8HFYoCACaKlryEBhwVDBklBgAZWAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbM+RQWihsWkBUmipa8hAY8Nsz5FAAZHBUAFQAVEgAAFuiC + goAIFf4BFoad1P8HFYIBACaaq7yEBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQF + dmFsdWUVDBbM+RQW3h4Wihgmmqu8hAY8Nrz5FCgbRWRpZmljaW8gVGVjbm9sw7NnaWNvIENPUkZP + GB9CYW5jbyBkZSBDcsOpZGl0byBlIEludmVyc2lvbmVzABkcFQAVABUSAAAW5oSCgAgV/gEWiJ7U + /wcVnAQAJqTDvIQGHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxp + c3QHZWxlbWVudBUMFsz5FBaOGxaSFSakw7yEBjw2zPkUABkcFQAVABUSAAAW5IaCgAgV/gEWpKLU + /wcVggEAJrbYvIQGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWzPkU + FoobFpAVJrbYvIQGPDbM+RQAGRwVABUAFRIAABbiiIKACBX+ARamo9T/BxWCAQAmxu28hAYcFQAZ + NQYIABkYCWhhc19wYXJ0cxUMFsj5FBb+0wIWoAcmxu28hAY8GAEBGAEAFgAoAQEYAQAAGRwVABUA + FRIAABbgioKACBXsARaopNT/BxWCAQAm5vS8hAYcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwW + yPkUFv7TAhaWBybm9LyEBjwYAQAYAQAWACgBABgBAAAZHBUAFQAVEgAAFsyMgoAIFewBFqql1P8H + FYIBACb8+7yEBhwVAhk1BggAGRgKbnVtX2Zsb29ycxUMFsj5FBb0OBbgFib8+7yEBjwYBBgAAAAY + BAEAAAAWwu8UKAQYAAAAGAQBAAAAABkcFQAVABUSAAAWuI6CgAgV+gEWrKbU/wcVggIAJtySvYQG + HBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWyPkUFtIEFvQFJtySvYQGPDbI+RQA + GRwVABUAFRIAABaykIKACBXsARauqNT/BxWCAQAm0Ji9hAYcFQoZNQYIABkYCm1pbl9oZWlnaHQV + DBbI+RQW0gQW9AUm0Ji9hAY8Nsj5FAAZHBUAFQAVEgAAFp6SgoAIFewBFrCp1P8HFYIBACbEnr2E + BhwVAhk1BggAGRgJbWluX2Zsb29yFQwWyPkUFtIEFvQFJsSevYQGPDbI+RQAGRwVABUAFRIAABaK + lIKACBXsARayqtT/BxWCAQAmuKS9hAYcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFsj5FBbSBBb0 + BSa4pL2EBjw2yPkUABkcFQAVABUSAAAW9pWCgAgV7AEWtKvU/wcVggEAJqyqvYQGHBUMGTUGCAAZ + GA9mYWNhZGVfbWF0ZXJpYWwVDBbI+RQW0gQW9AUmrKq9hAY8Nsj5FAAZHBUAFQAVEgAAFuKXgoAI + FewBFras1P8HFYIBACagsL2EBhwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFsj5FBbSBBb0BSag + sL2EBjw2yPkUABkcFQAVABUSAAAWzpmCgAgV7AEWuK3U/wcVggEAJpS2vYQGHBUMGTUGCAAZGApy + b29mX3NoYXBlFQwWyPkUFu4UFqIHJpS2vYQGPDaC+BQoBmdhYmxlZBgEZmxhdAAZHBUAFQAVEgAA + FrqbgoAIFe4BFrqu1P8HFboBACa2vb2EBhwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbI+RQW + 0gQW9AUmtr29hAY8Nsj5FAAZHBUAFQAVEgAAFqidgoAIFewBFvSv1P8HFYIBACaqw72EBhwVDBk1 + BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFsj5FBbSBBb0BSaqw72EBjw2yPkUABkcFQAVABUSAAAW + lJ+CgAgV7AEW9rDU/wcVggEAJp7JvYQGHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWyPkUFtIEFvQF + Jp7JvYQGPDbI+RQAGRwVABUAFRIAABaAoYKACBXsARb4sdT/BxWCAQAmks+9hAYcFQoZNQYIABkY + C3Jvb2ZfaGVpZ2h0FQwWyPkUFtIEFvQFJpLPvYQGPDbI+RQAGRwVABUAFRIAABbsooKACBXsARb6 + stT/BxWCAQAW4t7xHBbI+RQm0rfg9QUWtJ3dDhRqABn8JiaG1b2EBhwVDBk1BggAGRgCaWQVDBbU + jhUW6pT4BRaW7NQBJobVvYQGPDYAKCAwOGJiMmM1NWI2ZGFjZmZmMDIwMDc5NGQxMzQ1ZDIxYhgg + MDhiYjJjMDkyMDA0Y2ZmZjAyMDA2YTUyYTQxZTRhYzIAGRwVABUAFRIAABbYpIKACBWQAhb8s9T/ + BxXeCQAmnMGShgYcFQwZNQYIABkYCGdlb21ldHJ5FQwW1I4VFtbQuBEW0KKnCiacwZKGBjw2ACij + BQAAAAAGAAAAAgAAAAADAAAAAQAAABTAUeSVceysZsBAh2AaHAr5wFHklZ329mzAQIdgkhEPHMBR + 5JWwa202wECHYRujynXAUeSVqAfxZsBAh2GnusSNwFHklYU34sXAQIdiKBNEgMBR5JVLwZ9ywECH + Yo9BUQPAUeSVAYRkfsBAh2LSXS+GwFHklK7jrbrAQIdi6rDjYsBR5JRYfJjYwECHYtMz7xvAUeSU + C7sfJcBAh2KNk9HZwFHkk9ECvHPAQIdiIIaIRcBR5JOvCW1nwECHYZl4C6rAUeSTqZWQIMBAh2EH + gdSBwFHkk8F95DHAQIdgeb1bQMBR5JPz0ssUwECHYAKfFrHAUeSUOyBnf8BAh1+tDsFkwFHklI9u + nW3AQIdfhMrVfMBR5JTjUXOQwECHX4uA0iLAUeSVMcBsbMBAh1++rHiZwFHklXHsrGbAQIdgGhwK + +QAAAAADAAAAAQAAABTAUeSUdQIKnMBAh26KIVaSwFHklKCg9NjAQIdvAhZatcBR5JSzFWuiwECH + b4upFg7AUeSUqrHv0sBAh3AXwBAmwFHklIfh4THAQIdwmO9Pr8BR5JROa53ewECHcP9GnJ3AUeSU + BJnCtMBAh3FCYnsfwFHkk7GNrCbAQIdxWrYu/MBR5JNbJpdDwECHcUM5OrTAUeSTDmUdkcBAh3D9 + mR1zwFHkktOsut/AQIdwkIvT3sBR5JKxs2vTwECHcAl9V0TAUeSSrKruVsBAh293hyAawFHkksST + QmjAQIdu6plmbsBR5JL26ClKwECHbnKkYkrAUeSTPjXFtcBAh24dFAz9wFHkk5IYm9jAQIdt9NAh + FcBR5JPl+3H8wECHbfuGHbzAUeSUNGpq2MBAh24viIPIwFHklHUCCpzAQIduiiFWkhhNAAAAAAMA + AAABAAAABMBRyBQor41JwECu0vlPAl/AUcgT+IdrcsBArtQ8U9TxwFHIE3Z1eWjAQK7UBbbg9cBR + yBQor41JwECu0vlPAl8AGRwVABUAFSgAABbopoKACBXcBBbavdT/BxW+KQAmxunNkAYcFQgZNQYI + BBkoBGJib3gEeG1pbhUMFtSOFRbal0QWoMs6JsbpzZAGJuzjuZAGHBgEBtuNwhgEZDOPwhYAKAQG + 243CGARkM4/CABksFQQVBBUCABUAFQQVEgAAFsSrgoAIFZACFpjn1P8HFe4BACaSt4iRBhwVCBk1 + BggEGSgEYmJveAR4bWF4FQwW1I4VFoqbRBaizjomkreIkQYmjK/0kAYcGAT12o3CGARSM4/CFgAo + BPXajcIYBFIzj8IAGSwVBBUEFQIAFQAVBBUSAAAW1K2CgAgVkAIWhunU/wcV7gEAJvrRvpEGHBUI + GTUGCAQZKARiYm94BHltaW4VDBbUjhUWotQ8FsayNSb60b6RBiau/a6RBhwYBAUwBMIYBAsAB8IW + ACgEBTAEwhgECwAHwgAZLBUEFQQVAgAVABUEFRIAABbkr4KACBWQAhb06tT/BxXuAQAmgob0kQYc + FQgZNQYIBBkoBGJib3gEeW1heBUMFtSOFRbq1TwWrLU1JoKG9JEGJvSv5JEGHBgEsC8EwhgE8/8G + whYAKASwLwTCGATz/wbCABksFQQVBBUCABUAFQQVEgAAFvSxgoAIFZACFuLs1P8HFe4BACbg5ZmS + BhwVAhk1BggEGRgHdmVyc2lvbhUMFtSOFRbIBRb8Bibg5ZmSBiag5ZmSBhwYBAAAAAAYBAAAAAAW + ACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaEtIKACBXsARbQ7tT/BxXuAQAm3OyZkgYc + FQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbUjhUW2AYWjAgm3OyZkgYm + nOyZkgYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABbwtYKACBXsARa+8NT/BxVeACbs9ZmS + BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwW1I4VFuCjBRaktAMm7PWZ + kgYmqPSZkgYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQV + AgAVABUEFRIAABbct4KACBX+ARac8dT/BxXCBQAmzKidkgYcFQwZJQYAGUgHc291cmNlcwRsaXN0 + B2VsZW1lbnQJcmVjb3JkX2lkFQwW1I4VFpiahAMW2vCKASbMqJ2SBjw2ACgMdzk5ODc3NTk5M0Ax + GAwwMDAyNDI3MWYyYWIAGRwVABUAFRIAABbauYKACBWQAhbe9tT/BxWOBAAm3oyqkwYcFQwZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUVDBbUjhUWkPUlFsq7CibejKqTBiam + maiTBhw2ACgYMjAyNC0xMS0yOVQyMzo1Njo1MC4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAw + MFoAGSwVBBUEFQIAFQAVBBUSAAAW6ruCgAgVhgIW7PrU/wcVvgcAJrTws5MGHBUKGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbUjhUWjL0ZFviGFia08LOTBibw1LKTBhwY + CEjhehSuR+8/GAjNzMzMzMzkPxa+jQsoCEjhehSuR+8/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUE + FRIAABbwvYKACBWQAhaqgtX/BxWgAwAmsNzIkwYcFQIZNQYIBBkYBWxldmVsFQwW1I4VFt4GFpII + JrDcyJMGJujbyJMGHBgEAgAAABgEAQAAABaqjhUoBAIAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUS + AAAWgMCCgAgV7gEWyoXV/wcV4gEAJp7myJMGHBUMGTUGCAQZGAdzdWJ0eXBlFQwW1I4VFt50Fphg + Jp7myJMGJvrjyJMGHDb08hMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIA + FQAVBBUSAAAW7sGCgAgV/gEWrIfV/wcVzAMAJtrIyZMGHBUMGTUGCAQZGAVjbGFzcxUMFtSOFRbA + gQEW4mgm2sjJkwYmksTJkwYcNu70EygJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUA + FQQVEgAAFuzDgoAIFf4BFviK1f8HFcIDACbQrsqTBhwVChk1BggEGRgGaGVpZ2h0FQwW1I4VFsoL + Fs4LJtCuypMGJvSsypMGHBgIAAAAAABASkAYCAAAAAAAAABAFuiMFSgIAAAAAABASkAYCAAAAAAA + AABAABksFQQVBBUCABUAFQQVEgAAFurFgoAIFfQBFrqO1f8HFaICACaGh8uTBhwVDBk1BggEGSgF + bmFtZXMHcHJpbWFyeRUMFtSOFRa20wEWwnQmhofLkwYmwrjKkwYcNsKFFSgNw4FyZWEgQm9kZWdh + cxgCMTgAGSwVBBUEFQIAFQAVBBUSAAAW3seCgAgV/gEW3JDV/wcVhAUAJoSty5MGHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW1I4VFuAgFvgZJoSty5MGPDbUjhUAGRwVABUA + FRIAABbcyYKACBX+ARbgldX/BxWCAQAm/MbLkwYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92 + YWx1ZQV2YWx1ZRUMFtSOFRayJhbyGyb8xsuTBjw21I4VABkcFQAVABUSAAAW2suCgAgV/gEW4pbV + /wcVggEAJtjjy5MGHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW + 2I4VFrwnFoYdJtjjy5MGJu7iy5MGHDbIjhUoCG9mZmljaWFsGAlhbHRlcm5hdGUAGSwVBBUEFQIA + FQAVBBUSAAAW2M2CgAgV/gEW5JfV/wcV6gEAJvT/y5MGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudAhsYW5ndWFnZRUMFtiOFRbEJhaQHCb0/8uTBjw22I4VABkcFQAVABUSAAAW1s+C + gAgV/gEWzpnV/wcVggEAJsqezJMGHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2 + YWx1ZRUMFtiOFRb4KRbqHibKnsyTBiaEnMyTBhw2yI4VKBBVTkNPU09MIFF1aWxwdcOpGB9CYW5j + byBkZSBDcsOpZGl0byBlIEludmVyc2lvbmVzABksFQQVBBUCABUAFQQVEgAAFtTRgoAIFf4BFtCa + 1f8HFcgDACbuusyTBhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRs + aXN0B2VsZW1lbnQVDBbYjhUWyCYWkBwm7rrMkwY8NtiOFQAZHBUAFQAVEgAAFtLTgoAIFf4BFpie + 1f8HFYIBACb+1syTBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFtiO + FRbEJhaQHCb+1syTBjw22I4VABkcFQAVABUSAAAW0NWCgAgV/gEWmp/V/wcVggEAJo7zzJMGHBUA + GTUGCAAZGAloYXNfcGFydHMVDBbUjhUWztYCFpQHJo7zzJMGPBgBABgBABYAKAEAGAEAABkcFQAV + ABUSAAAWzteCgAgV7AEWnKDV/wcVggEAJqL6zJMGHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUM + FtSOFRbO1gIWlAcmovrMkwY8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABa62YKACBXsARaeodX/ + BxWCAQAmwILNkwYcFQIZNQYIBBkYCm51bV9mbG9vcnMVDBbUjhUWhGMWsFEmwILNkwYmtoHNkwYc + GAQcAAAAGAQBAAAAFsKyFCgEHAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABam24KACBX8ARag + otX/BxWCAgAm5tLNkwYcFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbUjhUW4gQW + hAYm5tLNkwY8GAQDAAAAGAQDAAAAFtKOFSgEAwAAABgEAwAAAAAZHBUAFQAVEgAAFqLdgoAIFewB + FqKk1f8HFZIBACbq2M2TBhwVChk1BggAGRgKbWluX2hlaWdodBUMFtSOFRbSBBb0BSbq2M2TBjw2 + 1I4VABkcFQAVABUSAAAWjt+CgAgV7AEWtKXV/wcVggEAJt7ezZMGHBUCGTUGCAAZGAltaW5fZmxv + b3IVDBbUjhUW0gQW9AUm3t7NkwY8NtSOFQAZHBUAFQAVEgAAFvrggoAIFewBFram1f8HFYIBACbS + 5M2TBhwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwW1I4VFtIEFvQFJtLkzZMGPDbUjhUAGRwVABUA + FRIAABbm4oKACBXsARa4p9X/BxWCAQAmxurNkwYcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUM + FtSOFRbSBBb0BSbG6s2TBjw21I4VABkcFQAVABUSAAAW0uSCgAgV7AEWuqjV/wcVggEAJrrwzZMG + HBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW1I4VFtIEFvQFJrrwzZMGPDbUjhUAGRwVABUAFRIA + ABa+5oKACBXsARa8qdX/BxWCAQAmrvbNkwYcFQwZNQYIABkYCnJvb2Zfc2hhcGUVDBbUjhUWvu8B + Fs4eJq72zZMGPDbo+BQoCHNraWxsaW9uGARmbGF0ABkcFQAVABUSAAAWquiCgAgV9gEWvqrV/wcV + /gEAJvyUzpMGHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFtSOFRbSBBb0BSb8lM6TBjw21I4V + ABkcFQAVABUSAAAWoOqCgAgV7AEWvKzV/wcVggEAJvCazpMGHBUMGTUGCAAZGBByb29mX29yaWVu + dGF0aW9uFQwW1I4VFtIEFvQFJvCazpMGPDbUjhUAGRwVABUAFRIAABaM7IKACBXsARa+rdX/BxWC + AQAm5KDOkwYcFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbUjhUW0gQW9AUm5KDOkwY8NtSOFQAZHBUA + FQAVEgAAFvjtgoAIFewBFsCu1f8HFYIBACbYps6TBhwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbU + jhUW0gQW9AUm2KbOkwY8NtSOFQAZHBUAFQAVEgAAFuTvgoAIFewBFsKv1f8HFYIBABaY1YkdFtSO + FSaG1b2EBhbG15APFGwAGfwmJsyszpMGHBUMGTUGCAAZGAJpZBUMFsyzExaAxroFFoD1xAEmzKzO + kwY8NgAoIDA4YmIyYzU3YjZkMzFmZmYwMjAwMWI5NGU2YjM2ZDFmGCAwOGJiMmMwYjIwMTA5ZmZm + MDIwMDVjMmY1YmM2MmVkYwAZHBUAFQAVEAAAFtDxgoAIFfIBFsSw1f8HFdYIACbMoZOVBhwVDBk1 + BggAGRgIZ2VvbWV0cnkVDBbMsxMWxs7IEBbQ2/wJJsyhk5UGPDYAKKULAAAAAAMAAAAHAAAANsBR + s3dG89pYwEDRl6MfVFnAUbN3Vg1Sz8BA0ZlnRLK3wFGzd6BKjcPAQNGiJVlV3cBRs3XmoYopwEDR + ok50AVrAUbN1tmWCO8BA0ZyUH90VwFGzc9QNMu7AQNGcv77HUcBRs3PZ7HAAwEDRnYMzJcfAUbNx + hKeaDcBA0Z21iAypwFGzccseduTAQNGmz+MBwsBRs3dqL0jDwEDRplcXPgrAUbN3dEBDvcBA0aev + BhJpwFGzdS4U5kHAQNGn3Sk7Y8BRs3VQeZUXwEDRrJonXhPAUbN3hrS6h8BA0axtsbRDwFGzd5tC + EEbAQNGvUmiCoMBRs2qJCtYdwEDRsFMZgojAUbNqwT76EcBA0bhJiAlOwFGzYEsu0nvAQNG5Fw1i + v8BRs2BB9JcWwEDRt8DMDYrAUbNfBbR058BA0bfZH8FmwFGzXwCr92rAQNG3JZua/MBRs1xvAT+b + wEDRt1ZDArTAUbNcWZ0qSMBA0bQvRxVowFGzXod00+fAQNG0Bixp68BRs15A/fcRwEDRqaqI1SbA + UbNZq20AtMBA0aoAGSpzwFGzWZOErKPAQNGmfNbrNMBRs1xEORT1wEDRpkmrRL3AUbNcBAzU+8BA + 0Zzy6m3IwFGzWo3rD67AQNGdDpkf98BRs1qxJn4ZwEDRogV45cXAUbNYwjj1FMBA0aIrOJLvwFGz + WJcFaqPAQNGcK0RRacBRs1oEw7QfwEDRnA3oIA/AUbNZ+QU5/MBA0ZpztCzDwFGzXmFJxvPAQNGa + F23az8BRs163sNvVwEDRpYVgJrHAUbNlEdKQW8BA0aT//ylAwFGzZLxCOw7AQNGZyJOCKMBRs2d+ + /7pgwEDRmY6x3wvAUbNnd95d78BA0Zii+ZSswFGzaq7Kg0bAQNGYWtU4rMBRs2rWow9kwEDRnTiK + iwnAUbNtU1URqsBA0Zz/f6eAwFGzbTPgAV3AQNGZLjnPL8BRs2+BLLtKwEDRmPlgqY7AUbNvjBR1 + 2cBA0ZpIFUKHwFGzce5Z5U/AQNGaD+Eek8BRs3Hl9ml+wEDRmQr+YMTAUbNzO2D/HsBA0Zjr9LBB + wFGzc0XdWePAQNGaLGaQWMBRs3WHADniwEDRmfa2qyLAUbN1dCBjTcBA0ZfN538AwFGzd0bz2ljA + QNGXox9UWQAAAAnAUbNwxWT5f8BA0aioKlYVwFGzbIfoly7AQNGpC/1kRMBRs2x7vr1AwEDRp5k2 + nUvAUbNqFomvQcBA0afRasE/wFGzakZaV2TAQNGteiEuTsBRs2x+Qvv+wEDRrUYeyELAUbNseGO+ + 7MBA0aySmqHXwFGzcOMsiqPAQNGsK2yVVcBRs3DFZPl/wEDRqKgqVhUAAAAFwFGzbvZX4JLAQNGf + 4Nt3isBRs2qz0wDDwEDRoEPXxiXAUbNq1+Uuw8BA0aSNEqKawFGzbxpqDpLAQNGkKT+Ua8BRs272 + V+CSwEDRn+Dbd4oAAAAFwFGzaFzgq6fAQNGoTmhC38BRs2C9r/lXwEDRqO6hMuvAUbNhJ82kY8BA + 0bbxmTTwwFGzaMdptn3AQNG2UWBE5MBRs2hc4KunwEDRqE5oQt8AAAAFwFGzaAU3d2bAQNGb2eW6 + BMBRs2Y+Inp+wEDRnAw6oObAUbNmTNCTK8BA0Z14S2s4wFGzaBPlkBLAQNGdRfaEVsBRs2gFN3dm + wEDRm9nlugQAAAAFwFGzaCgHhgbAQNGgq9ySPcBRs2cEhnd+wEDRoMk4w5bAUbNnKxzkPMBA0aTz + ae+IwFGzaE6d8sXAQNGk1g2+L8BRs2goB4YGwEDRoKvckj0AAAAFwFGzc8DB/I/AQNGomeedM8BR + s3IKc/dJwEDRqL7QisfAUbNyJvlpDcBA0ayDgSlgwFGzc92yzh7AQNGsXpg7zMBRs3PAwfyPwEDR + qJnnnTMYTQAAAAADAAAAAQAAAATAUauby0HpMMBA3oAYu7PEwFGrm+AcgOTAQN5/MYCC5cBRq5x8 + 4iAawEDegEV1dD/AUauby0HpMMBA3oAYu7PEABkcFQAVABUmAAAWwvOCgAgVvgQWmrnV/wcVticA + JsDrm58GHBUIGTUGCAQZKARiYm94BHhtaW4VDBbMsxMWjtE1FrLfLybA65ufBiac/Y+fBhwYBAdU + jcIYBAkIjsIWACgEB1SNwhgECQiOwgAZLBUEFQQVAgAVABUEFRAAABaA+IKACBXyARbQ4NX/BxXW + AQAmuMjLnwYcFQgZNQYIBBkoBGJib3gEeG1heBUMFsyzExbuzTUWrN0vJrjIy58GJs7cv58GHBgE + +FONwhgE+weOwhYAKAT4U43CGAT7B47CABksFQQVBBUCABUAFQQVEAAAFvL5goAIFfIBFqbi1f8H + FdYBACagtv2fBhwVCBk1BggEGSgEYmJveAR5bWluFQwWzLMTFt6gOhae8jEmoLb9nwYm+rnvnwYc + GAQLTAbCGAQyAAfCFgAoBAtMBsIYBDIAB8IAGSwVBBUEFQIAFQAVBBUQAAAW5PuCgAgV8gEW/OPV + /wcV1gEAJqypr6AGHBUIGTUGCAQZKARiYm94BHltYXgVDBbMsxMW7qI6FqLyMSasqa+gBiaYrKGg + BhwYBLRLBsIYBP3/BsIWACgEtEsGwhgE/f8GwgAZLBUEFQQVAgAVABUEFRAAABbW/YKACBXyARbS + 5dX/BxXWAQAm+p7ToAYcFQIZNQYIBBkYB3ZlcnNpb24VDBbMsxMW/gQWoAYm+p7ToAYmup7ToAYc + GAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWyP+CgAgV0gEWqOfV + /wcV1gEAJpql06AGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWzLMT + Fv4FFqAHJpql06AGJtqk06AGHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWmoGDgAgV0gEW + /ujV/wcVVgAmvq3ToAYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFsyz + Exak5AQWlPoCJr6t06AGJvqr06AGHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWls + ZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW7IKDgAgV4gEW1OnV/wcV9gQAJo6m1qAGHBUMGSUGABlI + B3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsyzExby5+MCFoKUggEmjqbWoAY8NgAo + DHc5ODcxNzI1NzNAMRgMMDAwMTUzYjEyMmU1ABkcFQAVABUQAAAWzoSDgAgV8gEWyu7V/wcV1gMA + Jur22KEGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWzLMTFur2 + FRaUrgYm6vbYoQYmkLrYoQYcNgAoGDIwMjQtMTEtMjVUMDI6NDg6NDQuMDAwWhgYMjAwMC0wMS0w + MVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFsCGg4AIFeIBFqDy1f8HFdYGACbUhOCh + BhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWzLMTFuqcFxbY/xMm + 1ITgoQYmpOjeoQYcGAhtxf6ye/LuPxgIzczMzMzM5D8WwrMKKAhtxf6ye/LuPxgIzczMzMzM5D8A + GSwVBBUEFQIAFQAVBBUQAAAWooiDgAgV8gEW9vjV/wcV9gIAJsTo8qEGHBUCGTUGCAQZGAVsZXZl + bBUMFsyzExbMBhbuBybE6PKhBib85/KhBhwYBAIAAAAYBAEAAAAWlrMTKAQCAAAAGAQBAAAAABks + FQQVBBUCABUAFQQVEAAAFpSKg4AIFdYBFuz71f8HFfYBACaS8vKhBhwVDBk1BggEGRgHc3VidHlw + ZRUMFsyzExbOSBbyPCaS8vKhBibq7/KhBhw2tvQSKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1 + cmFsABksFQQVBBUCABUAFQQVEAAAFuqLg4AIFeIBFuL91f8HFa4DACb+sPOhBhwVDBk1BggEGRgF + Y2xhc3MVDBbMsxMW6kgWgD4m/rDzoQYm3KzzoQYcNpr2EigJd2FyZWhvdXNlGAphcGFydG1lbnRz + ABksFQQVBBUCABUAFQQVEAAAFsyNg4AIFeIBFpCB1v8HFYIDACbc6vOhBhwVChk1BggAGRgGaGVp + Z2h0FQwWzLMTFpAEFqAFJtzq86EGPDbMsxMAGRwVABUAFRAAABauj4OACBXSARaShNb/BxV2ACb8 + 7/OhBhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFsyzExbEgwEWmFYm/O/zoQY8Ns6uEygIWm9v + dmVuaXIYJDEgeSAyIEp1emdhZG8gZGUgTGV0cmFzIGRlIFRhbGFnYW50ZQAZHBUAFQAVEAAAFoCR + g4AIFeIBFoiF1v8HFdIEACaUxvShBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tl + eRUMFsyzExbMGRbsFCaUxvShBjwYAmVzGAJlcxbKsxMoAmVzGAJlcwAZHBUAFQAVEAAAFuKSg4AI + FeIBFtqJ1v8HFX4AJoDb9KEGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUV + DBbMsxMW3B0WjBYmgNv0oQY8GApwcmluY2lwaXRvGApwcmluY2lwaXRvFsqzEygKcHJpbmNpcGl0 + bxgKcHJpbmNpcGl0bwAZHBUAFQAVEAAAFsSUg4AIFeIBFtiK1v8HFZ4BACaM8fShBhwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFsyzExaEHhaOFiaM8fShBjw2xrMT + KAVzaG9ydBgIb2ZmaWNpYWwAGRwVABUAFRAAABamloOACBXiARb2i9b/BxWQAQAmmof1oQYcFQwZ + JQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWzLMTFsIdFugVJpqH9aEG + PDbMsxMAGRwVABUAFRAAABaImIOACBXiARaGjdb/BxV2ACaCnfWhBhwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbMsxMWsB4WzBYmgp31oQY8NsazEygPU2FudGFuZGVy + IEdyb3VwGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlABkcFQAVABUQAAAW6pmDgAgV4gEW/I3W + /wcVxgEAJs6z9aEGHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxp + c3QHZWxlbWVudBUMFsyzExbCHRboFSbOs/WhBjw2zLMTABkcFQAVABUQAAAWzJuDgAgV4gEWwo/W + /wcVdgAmtsn1oQYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbMsxMW + wh0W6BUmtsn1oQY8NsyzEwAZHBUAFQAVEAAAFq6dg4AIFeIBFriQ1v8HFXYAJp7f9aEGHBUAGTUG + CAAZGAloYXNfcGFydHMVDBbMsxMW2roCFsQGJp7f9aEGPBgBARgBABYAKAEBGAEAABkcFQAVABUQ + AAAWkJ+DgAgV0gEWrpHW/wcVdgAm4uX1oQYcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWzLMT + Ftq6AhawBibi5fWhBjwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFuKgg4AIFdIBFqSS1v8HFXYA + JpLs9aEGHBUCGTUGCAAZGApudW1fZmxvb3JzFQwWzLMTFvAGFoAIJpLs9aEGPBgEBgAAABgEAQAA + ABaksxMoBAYAAAAYBAEAAAAAGRwVABUAFRAAABa0ooOACBXUARaak9b/BxXmAQAmkvT1oQYcFQIZ + NQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbMsxMWkAQWoAUmkvT1oQY8NsyzEwAZHBUA + FQAVEAAAFoikg4AIFdIBFoCV1v8HFXYAJrL59aEGHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWzLMT + FpAEFqAFJrL59aEGPDbMsxMAGRwVABUAFRAAABbapYOACBXSARb2ldb/BxV2ACbS/vWhBhwVAhk1 + BggAGRgJbWluX2Zsb29yFQwWzLMTFpAEFqAFJtL+9aEGPDbMsxMAGRwVABUAFRAAABasp4OACBXS + ARbsltb/BxV2ACbyg/ahBhwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWzLMTFpAEFqAFJvKD9qEG + PDbMsxMAGRwVABUAFRAAABb+qIOACBXSARbil9b/BxV2ACaSifahBhwVDBk1BggAGRgPZmFjYWRl + X21hdGVyaWFsFQwWzLMTFpAEFqAFJpKJ9qEGPDbMsxMAGRwVABUAFRAAABbQqoOACBXSARbYmNb/ + BxV2ACayjvahBhwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFsyzExaQBBagBSayjvahBjw2zLMT + ABkcFQAVABUQAAAWoqyDgAgV0gEWzpnW/wcVdgAm0pP2oQYcFQwZNQYIABkYCnJvb2Zfc2hhcGUV + DBbMsxMWkAQWoAUm0pP2oQY8NsyzEwAZHBUAFQAVEAAAFvStg4AIFdIBFsSa1v8HFXYAJvKY9qEG + HBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFsyzExaQBBagBSbymPahBjw2zLMTABkcFQAVABUQ + AAAWxq+DgAgV0gEWupvW/wcVdgAmkp72oQYcFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbM + sxMWkAQWoAUmkp72oQY8NsyzEwAZHBUAFQAVEAAAFpixg4AIFdIBFrCc1v8HFXYAJrKj9qEGHBUM + GTUGCAAZGApyb29mX2NvbG9yFQwWzLMTFpAEFqAFJrKj9qEGPDbMsxMAGRwVABUAFRAAABbqsoOA + CBXSARamndb/BxV2ACbSqPahBhwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBbMsxMWkAQWoAUm0qj2 + oQY8NsyzEwAZHBUAFQAVEAAAFry0g4AIFdIBFpye1v8HFXYAFsL3gRsWzLMTJsyszpMGFqaBqA4U + bgAZ/CYm8q32oQYcFQwZNQYIABkYAmlkFQwW7IITFoDrrAUWtrG/ASbyrfahBjw2ACggMDhiYjJj + NTdiNmE3MWZmZjAyMDA2MzJkYTg5ZGNhNmIYIDA4YmIyYzU0MDA0NWFmZmYwMjAwMDdjMDhkMTVk + ODhmABkcFQAVABUQAAAWjraDgAgV8gEWkp/W/wcV1ggAJqjftaMGHBUMGTUGCAAZGAhnZW9tZXRy + eRUMFuyCExaSu/IQFuyoogomqN+1owY8NgAowQYAAAAAAwAAAAYAAAAZwFGrLc2YpKfAQMrg1m8M + /sBRqz9AHE/CwEDK2f4Nt3nAUas9P/xvUsBAysnrcPzCwFGrOp32H6zAQMrK085IzsBRqzndBf/0 + wEDKxWuve4PAUatAsMo3x8BAysLHkEzqwFGrQWROXjLAQMrHzmBKw8BRq0SelYHdwEDKxo3uaqzA + UatEw+nPPMBAyseduOMLwFGrRdIGyHHAQMrHKEgdpsBRq0Wnqf2VwEDKxWrYu+7AUatPM69Z9cBA + ysG7INLewFGrT1WoqQHAQMrCmW0j8MBRq0/pTF9UwEDKwmZBfXnAUatQoW2jcsBAysdptnz/wFGr + T7Cs25bAQMrH4auBI8BRq1AM8y2KwEDKynaxN0XAUatRRkOxMMBAysn9DrP4wFGrU5fCKQXAQMra + n/QmrsBRq1KNa43uwEDK2tFyTfvAUatSm65G0MBAyttuUD+zwFGrPSnBmmrAQMrjuyXbXMBRqzyC + Z03twEDK33zSuXbAUasucMEzPMBAyuUtFeLAwFGrLc2YpKfAQMrg1m8M/gAAAAXAUatD96aVK8BA + ytFZ+kdZwFGrQzmmE/vAQMrRo8wig8BRq0QUl2a5wEDK18EclWLAUatE0wNHs8BAytd3Sro4wFGr + Q/emlSvAQMrRWfpHWQAAAAXAUatFyGEtQsBAyseziFgpwFGrRSYPXkLAQMrH8nJ4w8BRq0X6thQk + wEDKzeGfwqnAUatGnQfjI8BAys2itaIOwFGrRchhLULAQMrHs4hYKQAAAAXAUatHMlkYoMBAytCy + NJsSwFGrRlkVRQzAQMrRBu4wy8BRq0c6UTSmwEDK11GLDQ/AUatIFABoBcBAytb9qDbrwFGrRzJZ + GKDAQMrQsjSbEgAAAAXAUatCHG+iT8BAytMXaakRwFGrQWX73VzAQMrTXeCF58BRq0I/P7DwwEDK + 2W6bvw7AUatC9UgWGcBAytknTiKjwFGrQhxvok/AQMrTF2mpEQAAAAXAUatCMdO3o8BAysqbmiTa + wFGrQWvbGm3AQMrK7CH8qsBRq0IhDMACwEDKz71CFU7AUatC5pn9bcBAys9suj1+wFGrQjHTt6PA + QMrKm5ok2hhNAAAAAAMAAAABAAAABMBRq6iitrOSwEDSjbiGNgjAUaupFCkhjMBA0oz+f1bYwFGr + qaTHGj/AQNKN9UVsasBRq6iitrOSwEDSjbiGNggAGRwVABUAFSYAABaAuIOACBW+BBbop9b/BxW2 + JwAm+I3jrQYcFQgZNQYIBBkoBGJib3gEeG1pbhUMFuyCExaWkjQWkIcuJviN460GJpSI2K0GHBgE + BVSNwhgEBAiOwhYAKAQFVI3CGAQECI7CABksFQQVBBUCABUAFQQVEAAAFr68g4AIFfIBFp7P1v8H + FdYBACaUk5GuBhwVCBk1BggEGSgEYmJveAR4bWF4FQwW7IITFoDnMxaani4mlJORrgYmpI+GrgYc + GATfU43CGAT7B47CFgAoBN9TjcIYBPsHjsIAGSwVBBUEFQIAFQAVBBUQAAAWsL6DgAgV8gEW9NDW + /wcV1gEAJpK5wq4GHBUIGTUGCAQZKARiYm94BHltaW4VDBbsghMWgrU4Fq6LMSaSucKuBia+rbSu + BhwYBAWYBcIYBB2mBsIWACgEBZgFwhgEHaYGwgAZLBUEFQQVAgAVABUEFRAAABaiwIOACBXyARbK + 0tb/BxXWAQAmlsTzrgYcFQgZNQYIBBkoBGJib3gEeW1heBUMFuyCExaatTgWzI0xJpbE864GJuy4 + 5a4GHBgE5pcFwhgE86UGwhYAKATmlwXCGATzpQbCABksFQQVBBUCABUAFQQVEAAAFpTCg4AIFfIB + FqDU1v8HFdYBACb4xpavBhwVAhk1BggEGRgHdmVyc2lvbhUMFuyCExb+BBagBib4xpavBia4xpav + BhwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABaGxIOACBXSARb2 + 1db/BxXWAQAmmM2WrwYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbs + ghMW/gUWoAcmmM2WrwYm2MyWrwYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABbYxYOACBXS + ARbM19b/BxVWACa81ZavBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwW + 7IITFsDXBBaAmwMmvNWWrwYm+NOWrwYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1 + aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABaqx4OACBXiARai2Nb/BxX2BAAm+O6ZrwYcFQwZJQYA + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwW7IITFtb11gIWsO56Jvjuma8GPDYA + KAx3OTk1MTAzMDQwQDEYDDAwMDA0MDQ2ODE5YwAZHBUAFQAVEAAAFozJg4AIFfIBFpjd1v8HFdYD + ACbOwZWwBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFuyCExaK + phgWiMoIJs7BlbAGJqjdlLAGHDYAKBgyMDI0LTExLTMwVDE0OjExOjE5LjAwMFoYGDIwMDAtMDEt + MDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABb+yoOACBXoARbu4Nb/BxXWBgAmpMGe + sAYcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFuyCExbYxhQWiqER + JqTBnrAGJrCnnbAGHBgIMnctIR/07j8YCM3MzMzMzOQ/FrzRCygIMnctIR/07j8YCM3MzMzMzOQ/ + ABksFQQVBBUCABUAFQQVEAAAFubMg4AIFfIBFsTn1v8HFfYCACaIya6wBhwVAhk1BggEGRgFbGV2 + ZWwVDBbsghMWpggWyAkmiMmusAYmusiusAYcGAQCAAAAGAT/////FoiCEygEAgAAABgE/////wAZ + LBUEFQQVAgAVABUEFRAAABbYzoOACBXgARa66tb/BxX2AQAmgNSusAYcFQwZNQYIBBkYB3N1YnR5 + cGUVDBbsghMWinkWmGkmgNSusAYmgtKusAYcNqytESgLcmVzaWRlbnRpYWwYDGFncmljdWx0dXJh + bAAZLBUEFQQVAgAVABUEFRAAABa40IOACBXiARaw7Nb/BxWqAwAmtL6vsAYcFQwZNQYIBBkYBWNs + YXNzFQwW7IITFsB6Fu5qJrS+r7AGJpq7r7AGHDa4rxEoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZ + LBUEFQQVAgAVABUEFRAAABaa0oOACBXiARba79b/BxXyAgAmiKawsAYcFQoZNQYIABkYBmhlaWdo + dBUMFuyCExb2BxbaBiaIprCwBjwYCAAAAAAAAERAGAgAAAAAAAAkQBa6ghMoCAAAAAAAAERAGAgA + AAAAAAAkQAAZHBUAFQAVEAAAFvzTg4AIFdgBFszy1v8HFdYBACbirLCwBhwVDBk1BggAGSgFbmFt + ZXMHcHJpbWFyeRUMFuyCExb0sQEWkHEm4qywsAY8NpT8EigOw5NwdGltYSBEZW50YWwYJDEgeSAy + IEp1emdhZG8gZGUgTGV0cmFzIFNhbiBCZXJuYXJkbwAZHBUAFQAVEAAAFtTVg4AIFeIBFqL01v8H + FeIEACbynbGwBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFuyCExb4HxbG + GCbynbGwBjw26IITKAJ6aBgCZW4AGRwVABUAFRAAABa214OACBXiARaE+db/BxV+ACa4trGwBhwV + DBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwW7IITFuYlFsAaJri2sbAGPDbo + ghMoBuemj+mahhgiRmlyc3QgRmlyZSBDb21wYW55IG9mIFNhbiBCZXJuYXJkbwAZHBUAFQAVEAAA + FpjZg4AIFeIBFoL61v8HFcYBACb40LGwBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQHdmFyaWFudBUMFvCCExb+Jha2Gyb40LGwBjw23oITKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkc + FQAVABUQAAAW+tqDgAgV4gEWyPvW/wcVgAIAJq7ssbAGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudAhsYW5ndWFnZRUMFvCCExaaJRaaGiau7LGwBjw28IITABkcFQAVABUQAAAW3NyD + gAgV4gEWyP3W/wcVdgAmqImysAYcFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZh + bHVlFQwW8IITFoApFoQdJqiJsrAGJsiGsrAGHDbeghMoD1NhbnRhbmRlciBHcm91cBgUQmFuY28g + ZGVsIERlc2Fycm9sbG8AGSwVBBUEFQIAFQAVBBUQAAAWvt6DgAgV4gEWvv7W/wcViAUAJsyjsrAG + HBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUM + FvCCExacJRaKGibMo7KwBjw28IITABkcFQAVABUQAAAWoOCDgAgV4gEWxoPX/wcVdgAm1r2ysAYc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbwghMWmiUWmhom1r2ysAY8 + NvCCEwAZHBUAFQAVEAAAFoLig4AIFeIBFryE1/8HFXYAJvDXsrAGHBUAGTUGCAAZGAloYXNfcGFy + dHMVDBbsghMWzrQCFrwGJvDXsrAGPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAW5OODgAgV0gEW + soXX/wcVdgAmrN6ysAYcFQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwW7IITFs60AhawBias3rKw + BjwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFrblg4AIFdIBFqiG1/8HFXYAJobmsrAGHBUCGTUG + CAQZGApudW1fZmxvb3JzFQwW7IITFrgOFugOJobmsrAGJtzksrAGHBgEEgAAABgEAQAAABbG/xIo + BBIAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAWiOeDgAgV3gEWnofX/wcV5gEAJsTzsrAGHBUC + GTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW7IITFpAEFqAFJsTzsrAGPDbsghMAGRwV + ABUAFRAAABbm6IOACBXSARaEidf/BxV2ACbk+LKwBhwVChk1BggAGRgKbWluX2hlaWdodBUMFuyC + ExaQBBagBSbk+LKwBjw27IITABkcFQAVABUQAAAWuOqDgAgV0gEW+onX/wcVdgAmhP6ysAYcFQIZ + NQYIABkYCW1pbl9mbG9vchUMFuyCExaQBBagBSaE/rKwBjw27IITABkcFQAVABUQAAAWiuyDgAgV + 0gEW8IrX/wcVdgAmpIOzsAYcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFuyCExaQBBagBSakg7Ow + Bjw27IITABkcFQAVABUQAAAW3O2DgAgV0gEW5ovX/wcVdgAmxIizsAYcFQwZNQYIABkYD2ZhY2Fk + ZV9tYXRlcmlhbBUMFuyCExaQBBagBSbEiLOwBjw27IITABkcFQAVABUQAAAWru+DgAgV0gEW3IzX + /wcVdgAm5I2zsAYcFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBbsghMWkAQWoAUm5I2zsAY8NuyC + EwAZHBUAFQAVEAAAFoDxg4AIFdIBFtKN1/8HFXYAJoSTs7AGHBUMGTUGCAAZGApyb29mX3NoYXBl + FQwW7IITFpAEFqAFJoSTs7AGPDbsghMAGRwVABUAFRAAABbS8oOACBXSARbIjtf/BxV2ACakmLOw + BhwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbsghMWkAQWoAUmpJizsAY8NuyCEwAZHBUAFQAV + EAAAFqT0g4AIFdIBFr6P1/8HFXYAJsSds7AGHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW + 7IITFpAEFqAFJsSds7AGPDbsghMAGRwVABUAFRAAABb29YOACBXSARa0kNf/BxV2ACbkorOwBhwV + DBk1BggAGRgKcm9vZl9jb2xvchUMFuyCExaQBBagBSbkorOwBjw27IITABkcFQAVABUQAAAWyPeD + gAgV0gEWqpHX/wcVdgAmhKizsAYcFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwW7IITFpAEFqAFJoSo + s7AGPDbsghMAGRwVABUAFRAAABaa+YOACBXSARagktf/BxV2ABbCrosbFuyCEybyrfahBhay/7wO + FHAAGfwmJqSts7AGHBUMGTUGCAAZGAJpZBUMFsD7EhbO4qoFFtL3vAEmpK2zsAY8NgAoIDA4YmIy + YzU1NWJkYjZmZmYwMjAwZWNlZmQ5NTdhZTZmGCAwOGJiMmM1NDAwMDI1ZmZmMDIwMDZjZmU1NTFh + ZjY2MQAZHBUAFQAVEAAAFuz6g4AIFfIBFpaT1/8HFdYIACb2pPCxBhwVDBk1BggAGRgIZ2VvbWV0 + cnkVDBbA+xIW7OGOERaurqoKJvak8LEGPDYAKNQFAAAAAAYAAAAHAAAAAAMAAAABAAAACcBRqsKr + 4Zq6wEDEcGhH5/bAUarBj4Hoo8BAxHEL29ZVwFGqwXtf8q/AQMRwqbZHT8BRqsCLdepowEDEcTQf + wj3AUaq/W1+iJ8BAxGt9/VvhwFGqwFSD5dPAQMRq7otjdsBRqsBNzekswEDEas3UM8nAUarBYPNf + 38BAxGovSMLnwFGqwqvhmrrAQMRwaEfn9gAAAAADAAAAAQAAAAXAUaq/sca3CcBAxHzzcKWFwFGq + vY+th43AQMRx6v7m+8BRqr9oy5t0wEDEcOzSJdLAUarBiuTK8MBAxHv0bSTHwFGqv7HGtwnAQMR8 + 83ClhQAAAAADAAAAAQAAAAXAUarFXkOCNsBAxHX1T6LWwFGqxfq2FCTAQMR45O4rwsBRqsM137Xe + wEDEen8iHw/AUarCmW0j8MBAxHePg5YiwFGqxV5DgjbAQMR19U+i1gAAAAADAAAAAQAAAAXAUarG + ViWmg8BAxHlvV6awwFGqxDOhFzzAQMRuZuXoJ8BRqsYMvyskwEDEbWi5Jv7AUarIL0O6asBAxHhw + VCXywFGqxlYlpoPAQMR5b1emsAAAAAADAAAAAQAAAAXAUarCmQHEJcBAxGmF1Zd3wFGqwHZ9NN/A + QMRefWPY7cBRqsKDMk8IwEDEXWOIZZXAUarEpbbeTsBAxGhr+iQewFGqwpkBxCXAQMRphdWXdwAA + AAADAAAAAQAAAAXAUaq/FBIFvMBAxF69+3iywFGqv8oaauXAQMRiJzyE7MBRqryyN/YRwEDEY/FB + IFzAUaq7/JrwssBAxGCIABQiwFGqvxQSBbzAQMRevft4sgAAAAADAAAAAQAAAAXAUaq7UeWl4sBA + xG4fmEu8wFGquS9hFpvAQMRjFyaNM8BRqrsIfyqDwEDEYhj5zAnAUaq9KwO5ycBAxG0ha4qTwFGq + u1HlpeLAQMRuH5hLvBhNAAAAAAMAAAABAAAABMBRqpZHg+TtwEDC9C5CN+7AUaqWT4cSQcBAwvMg + JGGcwFGqlrdOT/vAQML0N5BNU8BRqpZHg+TtwEDC9C5CN+4AGRwVABUAFSYAABbe/IOACBW+BBbs + m9f/BxW2JwAmyIChvAYcFQgZNQYIBBkoBGJib3gEeG1pbhUMFsD7EhaY2CsWorwoJsiAobwGJqTT + mrwGHBgEA1SNwhgEw62NwhYAKAQDVI3CGATDrY3CABksFQQVBBUCABUAFQQVEAAAFpyBhIAIFfIB + FqLD1/8HFdYBACaEvMm8BhwVCBk1BggEGSgEYmJveAR4bWF4FQwWwPsSFpjXKxa8uygmhLzJvAYm + xo/DvAYcGATjU43CGAS9rY3CFgAoBONTjcIYBL2tjcIAGSwVBBUEFQIAFQAVBBUQAAAWjoOEgAgV + 8gEW+MTX/wcV1gEAJoiQ87wGHBUIGTUGCAQZKARiYm94BHltaW4VDBbA+xIWgN4tFpSiKiaIkPO8 + BiaCy+u8BhwYBAbyBcIYBDFMBsIWACgEBvIFwhgEMUwGwgAZLBUEFQQVAgAVABUEFRAAABaAhYSA + CBXyARbOxtf/BxXWAQAmtrOdvQYcFQgZNQYIBBkoBGJib3gEeW1heBUMFsD7Ehak3y0WqqMqJraz + nb0GJpbtlb0GHBgEv/EFwhgE+UsGwhYAKAS/8QXCGAT5SwbCABksFQQVBBUCABUAFQQVEAAAFvKG + hIAIFfIBFqTI1/8HFdYBACaAkcC9BhwVAhk1BggEGRgHdmVyc2lvbhUMFsD7Ehb+BBagBiaAkcC9 + BibAkMC9BhwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbkiISA + CBXSARb6ydf/BxXWAQAmoJfAvQYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVy + dHkVDBbA+xIW/gUWoAcmoJfAvQYm4JbAvQYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABa2 + ioSACBXSARbQy9f/BxVWACbEn8C9BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRh + c2V0FQwWwPsSFqbdBBaupAMmxJ/AvQYmgJ7AvQYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBP + cGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRAAABaIjISACBXiARamzNf/BxX2BAAmrsLDvQYc + FQwZJQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWwPsSFqrr1AIWjOV3Jq7C + w70GPDYAKAx3OTkyOTI2Mzg1QDEYDDAwMDAyY2NkY2ZhZQAZHBUAFQAVEAAAFuqNhIAIFfIBFpzR + 1/8HFdYDACaEvby+BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUM + FsD7EhbQtxsWuOYJJoS9vL4GJrqnu74GHDYAKBgyMDI0LTExLTMwVDAxOjUzOjUxLjAwMFoYGDIw + MDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRAAABbcj4SACBXqARby1Nf/BxXW + BgAm9qHGvgYcFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsD7Ehac + 7BMW3sMQJvahxr4GJvKNxb4GHBgIYOXQItv57j8YCM3MzMzMzOQ/FsD0CygIYOXQItv57j8YCM3M + zMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFsaRhIAIFfIBFsjb1/8HFfYCACaY0tW+BhwVAhk1BggE + GRgFbGV2ZWwVDBbA+xIWuAgW2gkmmNLVvgYm0NHVvgYcGAQBAAAAGAT/////Fqr6EigEAQAAABgE + /////wAZLBUEFQQVAgAVABUEFRAAABa4k4SACBXcARa+3tf/BxX2AQAmut3VvgYcFQwZNQYIBBkY + B3N1YnR5cGUVDBbA+xIWsJ4BFqiFASa63dW+Biaq29W+Bhw20uQQKA50cmFuc3BvcnRhdGlvbhgF + Y2l2aWMAGSwVBBUEFQIAFQAVBBUQAAAWlJWEgAgV4gEWtODX/wcV/gIAJu7k1r4GHBUMGTUGCAQZ + GAVjbGFzcxUMFsD7EhbQogEW9osBJu7k1r4GJtLg1r4GHDbU6RAoCXdhcmVob3VzZRgKYXBhcnRt + ZW50cwAZLBUEFQQVAgAVABUEFRAAABb2loSACBXiARay49f/BxWkAwAm4u3XvgYcFQoZNQYIBBkY + BmhlaWdodBUMFsD7EhaYCRa6CSbi7de+BibI7Ne+BhwYCAAAAAAAAFFAGAgAAAAAAAAAQBba+hIo + CAAAAAAAAFFAGAgAAAAAAAAAQAAZLBUEFQQVAgAVABUEFRAAABbYmISACBXYARbW5tf/BxW2AgAm + gvbXvgYcFQwZNQYIABkoBW5hbWVzB3ByaW1hcnkVDBbA+xIWhOICFtjTASaC9te+Bjw22O4SKBvD + gXJlYSBNYXRlcmlhbGVzIGNvbXB1ZXN0b3MYIjEgSnV6Z2FkbyBkZSBQb2xpY8OtYSBMb2NhbCBN + YWlww7oAGRwVABUAFRAAABawmoSACBXiARaM6df/BxXEBAAm2snZvgYcFQwZJQYAGUgFbmFtZXMG + Y29tbW9uCWtleV92YWx1ZQNrZXkVDBbG+xIWgDsWsCgm2snZvgY8Nrr7EigCZXMYAmVuABkcFQAV + ABUQAAAWkpyEgAgV4gEW0O3X/wcVjgEAJory2b4GHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlf + dmFsdWUFdmFsdWUVDBbG+xIW7kYW3ikmivLZvgY8Nrr7EigOU2FudGFuZGVyIEJhbmsYD0JhbmNv + IFNhbnRhbmRlcgAZHBUAFQAVEAAAFvSdhIAIFeIBFt7u1/8HFeYCACbom9q+BhwVDBklBgAZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFtD7EhakTBaWLCbom9q+Bjw2gvsSKAVz + aG9ydBgJYWx0ZXJuYXRlABkcFQAVABUQAAAW1p+EgAgV4gEWxPHX/wcV2AIAJv7H2r4GHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFtD7EhaCRRbkKCb+x9q+Bjw2 + zPsSKAJlcxgCZW4AGRwVABUAFRAAABa4oYSACBXiARac9Nf/BxV+ACbi8Nq+BhwVDBklBgAZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbQ+xIWqlkWzjYm4vDavgY8NoL7EigoU2Vy + dmljaW8gZGUgVXJnZW5jaWEgZGUgQWx0YSBSZXNvbHVjacOzbhgfQmFuY28gZGUgQ3LDqWRpdG8g + ZSBJbnZlcnNpb25lcwAZHBUAFQAVEAAAFpqjhIAIFeIBFpr11/8HFYYIACawp9u+BhwVChklBgAZ + eAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBbQ+xIW+EQW + 2CgmsKfbvgY8NtD7EgAZHBUAFQAVEAAAFvykhIAIFeIBFqD91/8HFXYAJojQ274GHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW0PsSFupEFtQoJojQ274GPDbQ+xIAGRwV + ABUAFRAAABbepoSACBXiARaW/tf/BxV2ACbc+Nu+BhwVABk1BggAGRgJaGFzX3BhcnRzFQwWwPsS + FtizAha6Bibc+Nu+BjwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFsCohIAIFdIBFoz/1/8HFXYA + Jpb/274GHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFsD7EhbYswIWsAYmlv/bvgY8GAEAGAEA + FgAoAQAYAQAAGRwVABUAFRAAABaSqoSACBXSARaCgNj/BxV2ACbmhty+BhwVAhk1BggEGRgKbnVt + X2Zsb29ycxUMFsD7EhamEha4Eibmhty+BibGhdy+BhwYBBQAAAAYBAEAAAAW9vQSKAQUAAAAGAQB + AAAAABksFQQVBBUCABUAFQQVEAAAFuSrhIAIFeABFviA2P8HFfYBACb+l9y+BhwVAhk1BggAGRgW + bnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFsD7Eha2BBbGBSb+l9y+BjwYBAIAAAAYBAEAAAAWvPsS + KAQCAAAAGAQBAAAAABkcFQAVABUQAAAWxK2EgAgV0gEW7oLY/wcVlgEAJsSd3L4GHBUKGTUGCAAZ + GAptaW5faGVpZ2h0FQwWwPsSFpAEFqAFJsSd3L4GPDbA+xIAGRwVABUAFRAAABaWr4SACBXSARaE + hNj/BxV2ACbkoty+BhwVAhk1BggAGRgJbWluX2Zsb29yFQwWwPsSFpAEFqAFJuSi3L4GPDbA+xIA + GRwVABUAFRAAABbosISACBXSARb6hNj/BxV2ACaEqNy+BhwVDBk1BggAGRgMZmFjYWRlX2NvbG9y + FQwWwPsSFqIFFvoFJoSo3L4GPDa0+xIoByNGRkZGRkYYByMwMEZGMDAAGRwVABUAFRAAABa6soSA + CBXUARbwhdj/BxWSAQAm/q3cvgYcFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFsD7EhaQBBag + BSb+rdy+Bjw2wPsSABkcFQAVABUQAAAWjrSEgAgV0gEWgofY/wcVdgAmnrPcvgYcFQwZNQYIABkY + DXJvb2ZfbWF0ZXJpYWwVDBbA+xIWkAQWoAUmnrPcvgY8NsD7EgAZHBUAFQAVEAAAFuC1hIAIFdIB + FviH2P8HFXYAJr643L4GHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWwPsSFq4EFr4FJr643L4GPBgG + aGlwcGVkGAZoaXBwZWQWvvsSKAZoaXBwZWQYBmhpcHBlZAAZHBUAFQAVEAAAFrK3hIAIFdIBFu6I + 2P8HFY4BACb8vdy+BhwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbA+xIWkAQWoAUm/L3cvgY8 + NsD7EgAZHBUAFQAVEAAAFoS5hIAIFdIBFvyJ2P8HFXYAJpzD3L4GHBUMGTUGCAAZGBByb29mX29y + aWVudGF0aW9uFQwWwPsSFpAEFqAFJpzD3L4GPDbA+xIAGRwVABUAFRAAABbWuoSACBXSARbyitj/ + BxV2ACa8yNy+BhwVDBk1BggAGRgKcm9vZl9jb2xvchUMFsD7EhbIBBbOBSa8yNy+BjwYByM2Mzc5 + NzIYByM2Mzc5NzIWvPsSKAcjNjM3OTcyGAcjNjM3OTcyABkcFQAVABUQAAAWqLyEgAgV1AEW6IvY + /wcVkgEAJorO3L4GHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFsD7EhaQBBagBSaKzty+Bjw2wPsS + ABkcFQAVABUQAAAW/L2EgAgV0gEW+ozY/wcVdgAWzvyDGxbA+xImpK2zsAYWhqapDhRyABn8Jiaq + 09y+BhwVDBk1BggAGRgCaWQVDBas5xIWgI2lBRacr7sBJqrT3L4GPDYAKCAwOGJiMmM1NTczZGI2 + ZmZmMDIwMDY5MzcyNzUwMWUxMxggMDhiYjJjNTQwNGEwOWZmZjAyMDA3YjVhMzZmOTQ0YWMAGRwV + ABUAFRAAABbOv4SACBXyARbwjdj/BxXWCAAmxoKYwAYcFQwZNQYIABkYCGdlb21ldHJ5FQwWrOcS + Fv7ZtREW0JjZCibGgpjABjw2ACjDAQAAAAAGAAAAAgAAAAADAAAAAQAAAAXAUa3aS6XwwMBAtBPv + oQ0rwFGt2oKX9VXAQLQXPTNnNsBRrdeBW7UywEC0F8ec4iPAUa3XSmmwnsBAtBR64UeuwFGt2kul + 8MDAQLQT76ENKwAAAAADAAAAAQAAAAXAUa3dhe0Ua8BAtBIZ3feXwFGt3vaa/HDAQLQkc3zPXsBR + rd0FKTStwEC0JN+zWV7AUa3blHtMp8BAtBKGFIGXwFGt3YXtFGvAQLQSGd33lxhNAAAAAAMAAAAB + AAAABMBRq/LkIyqnwEC9m3RlLKvAUavyPTQ99cBAvZh9OeeCwFGr84AqXMvAQL2ZulDJRsBRq/Lk + IyqnwEC9m3RlLKsAGRwVABUAFSgAABbAwYSACBXcBBbGltj/BxW+KQAmxr73ygYcFQgZNQYIBBko + BGJib3gEeG1pbhUMFqznEhaEoysWyowoJsa+98oGJpab8coGHBgEBVSNwhgEHq6NwhYAKAQFVI3C + GAQero3CABksFQQVBBUCABUAFQQVEAAAFpzGhIAIFfIBFoTA2P8HFdYBACb8y5/LBhwVCBk1BggE + GSgEYmJveAR4bWF4FQwWrOcSFoSkKxa2jSgm/MufywYm4KeZywYcGAS9U43CGAT8rY3CFgAoBL1T + jcIYBPytjcIAGSwVBBUEFQIAFQAVBBUQAAAWjsiEgAgV8gEW2sHY/wcV1gEAJv6AycsGHBUIGTUG + CAQZKARiYm94BHltaW4VDBas5xIWmrguFqDRKib+gMnLBiaWtcHLBhwYBAeYBcIYBLP3BcIWACgE + B5gFwhgEs/cFwgAZLBUEFQQVAgAVABUEFRAAABaAyoSACBXyARaww9j/BxXWAQAmytLzywYcFQgZ + NQYIBBkoBGJib3gEeW1heBUMFqznEhbauC4WzNEqJsrS88sGJraG7MsGHBgEz5YFwhgEjvcFwhYA + KATPlgXCGASO9wXCABksFQQVBBUCABUAFQQVEAAAFvLLhIAIFfIBFobF2P8HFdYBACbC2JbMBhwV + Ahk1BggEGRgHdmVyc2lvbhUMFqznEhb+BBagBibC2JbMBiaC2JbMBhwYBAAAAAAYBAAAAAAWACgE + AAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbkzYSACBXSARbcxtj/BxXWAQAm4t6WzAYcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBas5xIW/gUWoAcm4t6WzAYmot6W + zAYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABa2z4SACBXSARayyNj/BxVWACaG55bMBhwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWrOcSFtLPBBaWjgMmhueWzAYm + wuWWzAYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAV + ABUEFRAAABaI0YSACBXiARaIydj/BxX2BAAm2POZzAYcFQwZJQYAGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQJcmVjb3JkX2lkFQwWrOcSFpDeywIW4NV9JtjzmcwGPDYAKAx3OTkzOTE1NTI3QDEYDDAw + MDA1NzBjNGFmYQAZHBUAFQAVEAAAFurShIAIFfIBFv7N2P8HFdQDACaOi5nNBhwVDBklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFqznEhaigR0WxOAJJo6Lmc0GJrjJl80G + HDYAKBgyMDI0LTExLTMwVDIzOjM3OjQ5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZ + LBUEFQQVAgAVABUEFRAAABbc1ISACBXuARbS0dj/BxXWBgAmhsCizQYcFQoZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFqznEhaEiBIWstAOJobAos0GJvypoc0GHBgIswxx + rIvb7j8YCM3MzMzMzOQ/FpbwDCgIswxxrIvb7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAA + FsrWhIAIFfIBFqjY2P8HFfYCACaO+6/NBhwVAhk1BggEGRgFbGV2ZWwVDBas5xIWxgoWtgsmjvuv + zQYmrvqvzQYcGAQFAAAAGAT/////FublEigEBQAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABa8 + 2ISACBXcARae29j/BxX2AQAm9IewzQYcFQwZNQYIBBkYB3N1YnR5cGUVDBas5xIWhpABFs51JvSH + sM0GJuSFsM0GHDaktBEoDnRyYW5zcG9ydGF0aW9uGAVjaXZpYwAZLBUEFQQVAgAVABUEFRAAABaY + 2oSACBXiARaU3dj/BxX8AgAmnICxzQYcFQwZNQYIBBkYBWNsYXNzFQwWrOcSFoqZARawfSacgLHN + Biay+7DNBhw2jLkRKAl3YXJlaG91c2UYD2FsbG90bWVudF9ob3VzZQAZLBUEFQQVAgAVABUEFRAA + ABb624SACBXiARaQ4Nj/BxW0AwAm4vixzQYcFQoZNQYIABkYBmhlaWdodBUMFqznEhbqBhaQBybi + +LHNBjwYCAAAAAAAgEdAGAgAAAAAAAAIQBaO5xIoCAAAAAAAgEdAGAgAAAAAAAAIQAAZHBUAFQAV + EAAAFtzdhIAIFdgBFsTj2P8HFdYBACby/7HNBhwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFqzn + Ehaq9AMWzJsCJvL/sc0GPDau1BIoDHNlZGUgdmVjaW5hbBgcMSBGaXNjYWzDrWEgTWlsaXRhciBT + YW50aWFnbwAZHBUAFQAVEAAAFrTfhIAIFeIBFprl2P8HFcIEACa+m7TNBhwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFq7nEhbKSxawMCa+m7TNBjw2lucSKAJlcxgCZGUAGRwV + ABUAFRAAABaW4YSACBXiARbc6dj/BxWWAQAm7su0zQYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQV2YWx1ZRUMFq7nEhaUXRb6Mybuy7TNBjw2lucSKBRTYW50aWFnbyBCdXMgU3RhdGlv + bhgoQXVkaXRvcml1bSBEb24gQm9zY28gKFNhbnRpYWdvIGRlIENoaWxlKQAZHBUAFQAVEAAAFvji + hIAIFeIBFvLq2P8HFdQDACbkgLXNBhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQH + dmFyaWFudBUMFrrnEhboWhbOMibkgLXNBibo/7TNBhw24uYSKAVzaG9ydBgJYWx0ZXJuYXRlABks + FQQVBBUCABUAFQQVEAAAFtrkhIAIFeIBFsbu2P8HFa4CACa2srXNBhwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBa65xIWvlkWnDEmtrK1zQY8NrrnEgAZHBUAFQAV + EAAAFrzmhIAIFeIBFvTw2P8HFXYAJqDttc0GHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAV2YWx1ZRUMFrrnEhaEahbYOyag7bXNBibS47XNBhw24uYSKA1WRFJJREVJIFVTQUNIGB9C + YW5jbyBCaWxiYW8gVml6Y2F5YSBBcmdlbnRhcmlhABksFQQVBBUCABUAFQQVEAAAFp7ohIAIFeIB + Furx2P8HFdwGACaqn7bNBhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2Vl + bgRsaXN0B2VsZW1lbnQVDBa65xIWzFkWljEmqp+2zQY8NrrnEgAZHBUAFQAVEAAAFoDqhIAIFeIB + Fsb42P8HFXYAJsDQts0GHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW + uucSFr5ZFpwxJsDQts0GPDa65xIAGRwVABUAFRAAABbi64SACBXiARa8+dj/BxV2ACbcgbfNBhwV + ABk1BggAGRgJaGFzX3BhcnRzFQwWrOcSFpaxAhb0BibcgbfNBjwYAQEYAQAWACgBARgBAAAZHBUA + FQAVEAAAFsTthIAIFdYBFrL62P8HFXYAJtCIt80GHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUM + FqznEhaWsQIWsAYm0Ii3zQY8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABaa74SACBXSARao+9j/ + BxV2ACaIkLfNBhwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFqznEhaYKRaKJCaIkLfNBiaAj7fNBhwY + BB4AAAAYBAEAAAAWrtASKAQeAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFuzwhIAIFeIBFp78 + 2P8HFfYBACaKs7fNBhwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFqznEhaiBBay + BSaKs7fNBjwYBAEAAAAYBAEAAAAWqucSKAQBAAAAGAQBAAAAABkcFQAVABUQAAAWzvKEgAgV0gEW + lP7Y/wcVhgEAJry4t80GHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWrOcSFpAEFqAFJry4t80GPDas + 5xIAGRwVABUAFRAAABag9ISACBXSARaa/9j/BxV2ACbcvbfNBhwVAhk1BggAGRgJbWluX2Zsb29y + FQwWrOcSFpwPFrIHJty9t80GPBgEAQAAABgEAQAAABaC5RIoBAEAAAAYBAEAAAAAGRwVABUAFRAA + ABby9YSACBXWARaQgNn/BxWWAQAmjsW3zQYcFQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFqznEhaU + BxbOBiaOxbfNBjw2jucSKAcjRkYwMDAwGAcjMDA4MDAwABkcFQAVABUQAAAWyPeEgAgV1AEWpoHZ + /wcVkgEAJtzLt80GHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBas5xIWvgYW4AYm3Mu3zQY8 + NpbnEigFZ2xhc3MYBWJyaWNrABkcFQAVABUQAAAWnPmEgAgV1AEWuILZ/wcVugEAJrzSt80GHBUM + GTUGCAAZGA1yb29mX21hdGVyaWFsFQwWrOcSFpAEFqAFJrzSt80GPDas5xIAGRwVABUAFRAAABbw + +oSACBXSARbyg9n/BxV2ACbc17fNBhwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFqznEhbiIxakCibc + 17fNBjw2ouQSKAZnYWJsZWQYBGZsYXQAGRwVABUAFRAAABbC/ISACBXYARbohNn/BxXOAQAmgOK3 + zQYcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWrOcSFpAEFqAFJoDit80GPDas5xIAGRwVABUA + FRAAABaa/oSACBXSARa2htn/BxV2ACag57fNBhwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUM + FqznEhbOBBbGBSag57fNBjwYBWFsb25nGAVhbG9uZxam5xIoBWFsb25nGAVhbG9uZwAZHBUAFQAV + EAAAFuz/hIAIFdIBFqyH2f8HFYoBACbm7LfNBhwVDBk1BggAGRgKcm9vZl9jb2xvchUMFqznEhaa + BhaQBibm7LfNBjw2mOcSKAcjRkYwMDAwGAcjNzc4ODk5ABkcFQAVABUQAAAWvoGFgAgV1AEWtojZ + /wcVkgEAJvbyt80GHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFqznEhaQBBagBSb28rfNBjw2rOcS + ABkcFQAVABUQAAAWkoOFgAgV0gEWyInZ/wcVdgAW2PWeGxas5xImqtPcvgYW7KTbDhR0ABn8JiaW + +LfNBhwVDBk1BggAGRgCaWQVDBas8RIWgPWnBRaU170BJpb4t80GPDYAKCAwOGJiMmM1N2FlZDc1 + ZmZmMDIwMGI2YTM5MmIwMTEzZRggMDhiYjJjNTQ0MTA2OWZmZjAyMDAxODg4Y2I2ZTgwNTMAGRwV + ABUAFRAAABbkhIWACBXyARa+itn/BxXWCAAmqs/1zgYcFQwZNQYIABkYCGdlb21ldHJ5FQwWrPES + FuTXhhEW4OevCiaqz/XOBjw2ACjDAQAAAAAGAAAAAgAAAAADAAAAAQAAAAXAUayr+ReucsBAs8w5 + KRZ6wFGsqjafzz7AQLPMfRu0kcBRrKldx1t0wECzvNXexEbAUayrH9Pa3sBAs7yR7CYuwFGsq/kX + rnLAQLPMOSkWegAAAAADAAAAAQAAAAXAUaypHnHbD8BAs8yYymbBwFGsp2e4df7AQLPM4pxB68BR + rKZ4pS1MwECzvVSJxRDAUayoL16SXcBAs70Ljql8wFGsqR5x2w/AQLPMmMpmwRhNAAAAAAMAAAAB + AAAABMBRorg6M4/cwEDajkq4RfTAUaK4dsLDRcBA2o1Mn8NmwFGiuRvAftPAQNqO4OntqsBRorg6 + M4/cwEDajkq4RfQAGRwVABUAFSYAABbWhoWACBW8BBaUk9n/BxW2JwAmuqOt2QYcFQgZNQYIBBko + BGJib3gEeG1pbhUMFqzxEhagoy4WvrYqJrqjrdkGJoq3pdkGHBgEYPqMwhgEnmqNwhYAKARg+ozC + GASeao3CABksFQQVBBUCABUAFQQVEAAAFpKLhYAIFfIBFsq62f8HFdYBACag3NfZBhwVCBk1BggE + GSgEYmJveAR4bWF4FQwWrPESFuCmLhbmuComoNzX2QYmyO3P2QYcGARV+ozCGAR8ao3CFgAoBFX6 + jMIYBHxqjcIAGSwVBBUEFQIAFQAVBBUQAAAWhI2FgAgV8gEWoLzZ/wcV1gEAJriiidoGHBUIGTUG + CAQZKARiYm94BHltaW4VDBas8RIWsqo6FsbGMSa4oonaBiaupvrZBhwYBAqYBcIYBAQAB8IWACgE + CpgFwhgEBAAHwgAZLBUEFQQVAgAVABUEFRAAABb2joWACBXyARb2vdn/BxXWAQAmoO262gYcFQgZ + NQYIBBkoBGJib3gEeW1heBUMFqzxEhbCsDoWkMsxJqDtutoGJvTsq9oGHBgE0ZcFwhgE6P8GwhYA + KATRlwXCGATo/wbCABksFQQVBBUCABUAFQQVEAAAFuiQhYAIFfIBFsy/2f8HFdYBACbEuN3aBhwV + Ahk1BggEGRgHdmVyc2lvbhUMFqzxEhb+BBagBibEuN3aBiaEuN3aBhwYBAAAAAAYBAAAAAAWACgE + AAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABbakoWACBXSARaiwdn/BxXWAQAm5L7d2gYcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBas8RIW/gUWoAcm5L7d2gYmpL7d + 2gYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABaslIWACBXSARb4wtn/BxVWACaIx93aBhwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWrPESFrDZBBaKlAMmiMfd2gYm + xMXd2gYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAV + ABUEFRAAABb+lYWACBXiARbOw9n/BxX2BAAmztng2gYcFQwZJQYAGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQJcmVjb3JkX2lkFQwWrPESFtKG0wIWsI18Js7Z4NoGPDYAKAx3OTg0MTQxNzU0QDEYDDAw + MDBmYTY2YzY4ZgAZHBUAFQAVEAAAFuCXhYAIFfIBFsTI2f8HFdYDACa8qd7bBhwVDBklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFqzxEhbKvR4WhIkKJryp3tsGJv7m3NsG + HDYAKBgyMDI0LTExLTI3VDIyOjA0OjQ5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZ + LBUEFQQVAgAVABUEFRAAABbSmYWACBXuARaazNn/BxXWBgAmooro2wYcFQoZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFqzxEhbamxQWqPQQJqKK6NsGJoLw5tsGHBgInDOi + tDf47j8YCM3MzMzMzOQ/FvzdCygInDOitDf47j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAA + FsCbhYAIFfIBFvDS2f8HFfYCACb65PfbBhwVAhk1BggEGRgFbGV2ZWwVDBas8RIWtgcW2Agm+uT3 + 2wYmquT32wYcGAQDAAAAGAT/////FuDwEigEAwAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABay + nYWACBXYARbm1dn/BxX2AQAmqO/32wYcFQwZNQYIBBkYB3N1YnR5cGUVDBas8RIWtGoWtlkmqO/3 + 2wYmgu332wYcNpLIESgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUE + FRAAABaKn4WACBXiARbc19n/BxWWAwAm1Mr42wYcFQwZNQYIBBkYBWNsYXNzFQwWrPESFrJuFqRe + JtTK+NsGJrjG+NsGHDaAzBEoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAVABUEFRAA + ABbsoIWACBXiARby2tn/BxWCAwAmtKX52wYcFQoZNQYIBBkYBmhlaWdodBUMFqzxEhaWBRa4Bia0 + pfnbBibcpPnbBhwYCAAAAAAAABRAGAgAAAAAAAAQQBag8RIoCAAAAAAAABRAGAgAAAAAAAAQQAAZ + LBUEFQQVAgAVABUEFRAAABbOooWACBXSARb03dn/BxW2AQAmlKv52wYcFQwZNQYIABkoBW5hbWVz + B3ByaW1hcnkVDBas8RIW4twCFsbOASaUq/nbBjw2+uMSKBhyZXN0YXVyYW50IEVsIE11bmRpYWxp + dG8YCyJEb24gQ2hhbXkiABkcFQAVABUQAAAWoKSFgAgV4gEWqt/Z/wcVsgQAJtr5+tsGHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWrPESFqw1FtwkJtr5+tsGPDao8RIoAmVz + GAJlbgAZHBUAFQAVEAAAFoKmhYAIFeIBFtzj2f8HFYYBACa2nvvbBhwVDBklBgAZSAVuYW1lcwZj + b21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWrPESFug/Fs4nJrae+9sGPDao8RIoH011c2V1bSBvZiBN + ZW1vcnkgJiBIdW1hbiBSaWdodHMYBUVrb25vABkcFQAVABUQAAAW5KeFgAgV4gEW4uTZ/wcVhgIA + JoDH+9sGHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwWsvESFsBA + FtAoJoDH+9sGJoTG+9sGHDaG8RIoBXNob3J0GAlhbHRlcm5hdGUAGSwVBBUEFQIAFQAVBBUQAAAW + xqmFgAgV4gEW6ObZ/wcVlAIAJtTu+9sGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVu + dAhsYW5ndWFnZRUMFrLxEhakPxaiJybU7vvbBjw2svESABkcFQAVABUQAAAWqKuFgAgV4gEW/OjZ + /wcVdgAm9pX82wYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWsvES + FtxIFpAvJvaV/NsGPDaG8RIoAlZGGB9CYW5jbyBCaWxiYW8gVml6Y2F5YSBBcmdlbnRhcmlhABkc + FQAVABUQAAAWiq2FgAgV4gEW8unZ/wcV0gQAJobF/NsGHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFrLxEhaoPxakJyaGxfzbBjw2svESABkc + FQAVABUQAAAW7K6FgAgV4gEWxO7Z/wcVdgAmquz82wYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50BHNpZGUVDBay8RIWpD8Woicmquz82wY8NrLxEgAZHBUAFQAVEAAAFs6whYAIFeIB + Frrv2f8HFXYAJsyT/dsGHBUAGTUGCAAZGAloYXNfcGFydHMVDBas8RIWtrICFswGJsyT/dsGPBgB + ARgBABYAKAEBGAEAABkcFQAVABUQAAAWsLKFgAgV0gEWsPDZ/wcVdgAmmJr92wYcFQAZNQYIABkY + DmlzX3VuZGVyZ3JvdW5kFQwWrPESFrayAhawBiaYmv3bBjwYAQAYAQAWACgBABgBAAAZHBUAFQAV + EAAAFoK0hYAIFdIBFqbx2f8HFXYAJtih/dsGHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWrPESFo4P + Ft4PJtih/dsGJsig/dsGHBgEGAAAABgEAQAAABb26RIoBBgAAAAYBAEAAAAAGSwVBBUEFQIAFQAV + BBUQAAAW1LWFgAgV3gEWnPLZ/wcV9gEAJqaw/dsGHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVy + Z3JvdW5kFQwWrPESFqAEFrAFJqaw/dsGPBgEAQAAABgEAQAAABaq8RIoBAEAAAAYBAEAAAAAGRwV + ABUAFRAAABayt4WACBXSARaS9Nn/BxWGAQAm1rX92wYcFQoZNQYIABkYCm1pbl9oZWlnaHQVDBas + 8RIWkAQWoAUm1rX92wY8NqzxEgAZHBUAFQAVEAAAFoS5hYAIFdIBFpj12f8HFXYAJva6/dsGHBUC + GTUGCAAZGAltaW5fZmxvb3IVDBas8RIWkAQWoAUm9rr92wY8NqzxEgAZHBUAFQAVEAAAFta6hYAI + FdIBFo722f8HFXYAJpbA/dsGHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBas8RIWkAQWoAUmlsD9 + 2wY8NqzxEgAZHBUAFQAVEAAAFqi8hYAIFdIBFoT32f8HFXYAJrbF/dsGHBUMGTUGCAAZGA9mYWNh + ZGVfbWF0ZXJpYWwVDBas8RIWvAQWzAUmtsX92wY8GAxjZW1lbnRfYmxvY2sYDGNlbWVudF9ibG9j + axaq8RIoDGNlbWVudF9ibG9jaxgMY2VtZW50X2Jsb2NrABkcFQAVABUQAAAW+r2FgAgV1AEW+vfZ + /wcVpgEAJoLL/dsGHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWrPESFpAEFqAFJoLL/dsGPDas + 8RIAGRwVABUAFRAAABbOv4WACBXSARag+dn/BxV2ACai0P3bBhwVDBk1BggAGRgKcm9vZl9zaGFw + ZRUMFqzxEhaQBBagBSai0P3bBjw2rPESABkcFQAVABUQAAAWoMGFgAgV0gEWlvrZ/wcVdgAmwtX9 + 2wYcFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWrPESFpAEFqAFJsLV/dsGPDas8RIAGRwVABUA + FRAAABbywoWACBXSARaM+9n/BxV2ACbi2v3bBhwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUM + FqzxEhaQBBagBSbi2v3bBjw2rPESABkcFQAVABUQAAAWxMSFgAgV0gEWgvzZ/wcVdgAmguD92wYc + FQwZNQYIABkYCnJvb2ZfY29sb3IVDBas8RIWkAQWoAUmguD92wY8NqzxEgAZHBUAFQAVEAAAFpbG + hYAIFdIBFvj82f8HFXYAJqLl/dsGHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFqzxEhaQBBagBSai + 5f3bBjw2rPESABkcFQAVABUQAAAW6MeFgAgV0gEW7v3Z/wcVdgAWlNaXGxas8RImlvi3zQYWrPLF + DhR2ABn8JibC6v3bBhwVDBk1BggAGRgCaWQVDBbA9hIW0K6pBRb2jbwBJsLq/dsGPDYAKCAwOGJi + MmM1Nzc2Y2RjZmZmMDIwMGNkMzc4MzgyZjE2MRggMDhiYjJjNTA5MjQwMGZmZjAyMDAwNWQ1ZWQ4 + MjYyMjgAGRwVABUAFRAAABa6yYWACBXyARbk/tn/BxXWCAAmuPi53QYcFQwZNQYIABkYCGdlb21l + dHJ5FQwWwPYSFpa9ghEW/J2wCia4+LndBjw2ACiNBgAAAAADAAAABQAAABvAUaUCqSesFsBAx7h8 + s6/FwFGlAcpv+zvAQMe4RH+L0cBRpQKHmbzVwEDHsBNYolnAUaUDdJQmk8BAx7BOEQULwFGlA1+b + cQrAQMexNZeRgsBRpQUmRQ4nwEDHsaetWJPAUaUFXg3SUcBAx69CeEqUwFGlB65KKsbAQMev18mA + EcBRpQeA/cFhwEDHsc5DxVLAUaUKJYhPxcBAx7J3tvDCwFGlCkE3AfXAQMexSbmHdsBRpQu+eiOz + wEDHsala173AUaULA2lBDMBAx7m7eBCzwFGlCfb5xwHAQMe5eFwyMMBRpQl2oUcNwEDHvv+Er/7A + UaUHC/hbx8BAx75kVD1vwFGlBy2GSwjAQMe88zr1n8BRpQgV45cUwEDHvS3zWFLAUaUIbYzLVcBA + x7lijL0SwFGlBfa6BiHAQMe4xAFMMMBRpQXJAjzxwEDHur6tT1nAUaUDyAuc7MBAx7o+VM9lwFGl + A+SRDrHAQMe5AhStNsBRpQNprGwEwEDHuOMK/LPAUaUDkfBX7MBAx7ckxNtnwFGlAsxjGoLAQMe2 + 80a0GcBRpQKpJ6wWwEDHuHyzr8UAAAAFwFGlCjAEqorAQMe0KxVXgMBRpQmYLzZOwEDHtABNLNnA + UaUJQ+EAYMBAx7c9707YwFGlCdu2dJzAQMe3aLd5fsBRpQowBKqKwEDHtCsVV4AAAAAFwFGlCDrM + hKjAQMezJIUah8BRpQexpSkawEDHsv7FbV3AUaUHONllYsBAx7e4aJG6wFGlB8JsILvAQMe33v7+ + eMBRpQg6zISowEDHsySFGocAAAAFwFGlBbaNxifAQMe0hACrIcBRpQUwwWjrwEDHtGJyu9/AUaUE + +I1E+MBAx7bTZkQCwFGlBX7FAf3AQMe29PQzQ8BRpQW2jcYnwEDHtIQAqyEAAAAFwFGlBD5TIebA + QMeyy5nG5sBRpQOqr2uTwEDHsqNV2v7AUaUDaNWsb8BAx7VEGgtEwFGlA/x5YsLAQMe1bF33LMBR + pQQ+UyHmwEDHssuZxuYYTQAAAAADAAAAAQAAAATAUZiUi8SRtcBAy22S4KsSwFGYlGF2u2DAQMtu + pakqj8BRmJPmARqJwEDLbnBoX73AUZiUi8SRtcBAy22S4KsSABkcFQAVABUmAAAWrMuFgAgVvgQW + uofa/wcVticAJqCs9OcGHBUIGTUGCAQZKARiYm94BHhtaW4VDBbA9hIWvoYxFsjpLCagrPTnBia0 + lurnBhwYBAigjMIYBBpUjcIWACgECKCMwhgEGlSNwgAZLBUEFQQVAgAVABUEFRAAABbqz4WACBXy + ARbwrtr/BxXWAQAmuJOh6AYcFQgZNQYIBBkoBGJib3gEeG1heBUMFsD2Eha8gzEWlucsJriToegG + Jvz/lugGHBgE+p+MwhgE/FONwhYAKAT6n4zCGAT8U43CABksFQQVBBUCABUAFQQVEAAAFtzRhYAI + FfIBFsaw2v8HFdYBACby2M7oBhwVCBk1BggEGSgEYmJveAR5bWluFQwWwPYSFtbQMhaIuy0m8tjO + 6AYmkufD6AYcGASGCAbCGAQu/gbCFgAoBIYIBsIYBC7+BsIAGSwVBBUEFQIAFQAVBBUQAAAWztOF + gAgV8gEWnLLa/wcV1gEAJpiR/OgGHBUIGTUGCAQZKARiYm94BHltYXgVDBbA9hIWps0yFvq4LSaY + kfzoBiaaovHoBhwYBF4IBsIYBBn+BsIWACgEXggGwhgEGf4GwgAZLBUEFQQVAgAVABUEFRAAABbA + 1YWACBXyARbys9r/BxXWAQAm1Nue6QYcFQIZNQYIBBkYB3ZlcnNpb24VDBbA9hIW/gQWoAYm1Nue + 6QYmlNue6QYcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWsteF + gAgV0gEWyLXa/wcV1gEAJvThnukGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3Bl + cnR5FQwWwPYSFvwFFp4HJvThnukGJrThnukGHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW + hNmFgAgV0gEWnrfa/wcVVgAmluqe6QYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0 + YXNldBUMFsD2Ehae2wQWlooDJpbqnukGJtLonukGHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUg + T3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW1tqFgAgV4gEW9Lfa/wcV9gQAJujyoekG + HBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsD2Ehakz84CFtL5fybo + 8qHpBjw2ACgMdzk5MzcyNDA2NkAxGAwwMDAxM2Y5MThmODkAGRwVABUAFRAAABa43IWACBXyARbq + vNr/BxXWAwAmrPmi6gYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUV + DBbA9hIWmPEaFvywCCas+aLqBia67KHqBhw2ACgYMjAyNC0xMS0yN1QxOTo0MjowNC4wMDBaGBgy + MDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWqt6FgAgV5gEWwMDa/wcV + 1gYAJq6wq+oGHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbA9hIW + sscSFoKYDyausKvqBia2narqBhwYCF8pyxDHuu4/GAjNzMzMzMzkPxb62QwoCF8pyxDHuu4/GAjN + zMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABaQ4IWACBXyARaWx9r/BxX2AgAmgLa56gYcFQIZNQYI + BBkYBWxldmVsFQwWwPYSFvIGFpQIJoC2ueoGJri1ueoGHBgEAQAAABgE/////xb09RIoBAEAAAAY + BP////8AGSwVBBUEFQIAFQAVBBUQAAAWguKFgAgV1gEWjMra/wcV9gEAJti/ueoGHBUMGTUGCAQZ + GAdzdWJ0eXBlFQwWwPYSFrZmFsJWJti/ueoGJsy9ueoGHDbW2xEoB3NlcnZpY2UYDGFncmljdWx0 + dXJhbAAZLBUEFQQVAgAVABUEFRAAABbY44WACBXiARaCzNr/BxX8AgAm0pi66gYcFQwZNQYIBBkY + BWNsYXNzFQwWwPYSFqhlFs5YJtKYuuoGJo6UuuoGHDam3xEoCnVuaXZlcnNpdHkYD2FsbG90bWVu + dF9ob3VzZQAZLBUEFQQVAgAVABUEFRAAABa65YWACBXiARb+ztr/BxWSAwAm3Oy66gYcFQoZNQYI + ABkYBmhlaWdodBUMFsD2EhaoEha4Cibc7LrqBjwYCAAAAAAAwEVAGAgAAAAAAAAIQBaI9RIoCAAA + AAAAwEVAGAgAAAAAAAAIQAAZHBUAFQAVEAAAFpznhYAIFdwBFpDS2v8HFZYCACaU97rqBhwVDBk1 + BggAGSgFbmFtZXMHcHJpbWFyeRUMFsD2Eha61gIW/MgBJpT3uuoGPDbI6RIoB3RvcnJlIDQYCDQg + UHVudG9zABkcFQAVABUQAAAW+OiFgAgV4gEWptTa/wcVhAQAJpDAvOoGHBUMGSUGABlIBW5hbWVz + BmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWwvYSFoI6FqwnJpDAvOoGPDa49hIoAnpoGAJlbgAZHBUA + FQAVEAAAFtrqhYAIFeIBFqrY2v8HFY4BACa857zqBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5 + X3ZhbHVlBXZhbHVlFQwWwvYSFoRGFqwpJrznvOoGPDa49hIoBuaXp+mTuhgrMWEgQ29tcGHDscOt + YSBkZSBCb21iZXJvcyBNZXRyb3BvbGl0YW5vIFN1cgAZHBUAFQAVEAAAFrzshYAIFeIBFrjZ2v8H + FZYDACbokL3qBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFsb2 + EhbERxb+KSbokL3qBjw2oPYSKAVzaG9ydBgJYWx0ZXJuYXRlABkcFQAVABUQAAAWnu6FgAgV4gEW + ztza/wcVtgIAJua6veoGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFn + ZRUMFsb2Ehb4QxagJybmur3qBjw2xvYSABkcFQAVABUQAAAWgPCFgAgV4gEWhN/a/wcVdgAmhuK9 + 6gYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWxvYSFpJMFowuJobi + veoGPDag9hIoA1VERBgfQmFuY28gZGUgQ3LDqWRpdG8gZSBJbnZlcnNpb25lcwAZHBUAFQAVEAAA + FuLxhYAIFeIBFvrf2v8HFYYFACaSkL7qBhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBbG9hIW/kMWpicmkpC+6gY8Nsb2EgAZHBUAFQAVEAAA + FsTzhYAIFeIBFoDl2v8HFXYAJri3vuoGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVu + dARzaWRlFQwWxvYSFvhDFqAnJri3vuoGPDbG9hIAGRwVABUAFRAAABam9YWACBXiARb25dr/BxV2 + ACbY3r7qBhwVABk1BggAGRgJaGFzX3BhcnRzFQwWwPYSFoizAhbMBibY3r7qBjwYAQEYAQAWACgB + ARgBAAAZHBUAFQAVEAAAFoj3hYAIFdIBFuzm2v8HFXYAJqTlvuoGHBUAGTUGCAAZGA5pc191bmRl + cmdyb3VuZBUMFsD2EhaIswIWsAYmpOW+6gY8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABba+IWA + CBXSARbi59r/BxV2ACb+7L7qBhwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFsD2EhauFRbiFSb+7L7q + BibU677qBhwYBBIAAAAYBAEAAAAW1uMSKAQSAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFqz6 + hYAIFd4BFtjo2v8HFfYBACa2gb/qBhwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUM + FsD2EhaiBBayBSa2gb/qBjwYBAIAAAAYBAIAAAAWvvYSKAQCAAAAGAQCAAAAABkcFQAVABUQAAAW + ivyFgAgV0gEWzura/wcVhgEAJuiGv+oGHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWwPYSFpAEFqAF + JuiGv+oGPDbA9hIAGRwVABUAFRAAABbc/YWACBXSARbU69r/BxV2ACaIjL/qBhwVAhk1BggAGRgJ + bWluX2Zsb29yFQwWwPYSFpAEFqAFJoiMv+oGPDbA9hIAGRwVABUAFRAAABau/4WACBXSARbK7Nr/ + BxV2ACaokb/qBhwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWwPYSFvYFFsQGJqiRv+oGPDaw9hIo + ByNGRkZGRkYYByM2NzAwMjAAGRwVABUAFRAAABaAgYaACBXWARbA7dr/BxWuAQAm7Je/6gYcFQwZ + NQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFsD2EhbGCxbgBibsl7/qBjw25vUSKAhjb25jcmV0ZRgF + YnJpY2sAGRwVABUAFRAAABbWgoaACBXWARbu7tr/BxWqAQAmzJ6/6gYcFQwZNQYIABkYDXJvb2Zf + bWF0ZXJpYWwVDBbA9hIWvg0WnAYmzJ6/6gY8GApyb29mX3RpbGVzGApyb29mX3RpbGVzFvD1EigK + cm9vZl90aWxlcxgKcm9vZl90aWxlcwAZHBUAFQAVEAAAFqyEhoAIFdQBFpjw2v8HFZ4BACbopL/q + BhwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFsD2EhawDBa4BibopL/qBjw24PUSKAZoaXBwZWQYBmdh + YmxlZAAZHBUAFQAVEAAAFoCGhoAIFdQBFrbx2v8HFY4BACagq7/qBhwVChk1BggAGRgOcm9vZl9k + aXJlY3Rpb24VDBbA9hIWkAQWoAUmoKu/6gY8NsD2EgAZHBUAFQAVEAAAFtSHhoAIFdIBFsTy2v8H + FXYAJsCwv+oGHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWwPYSFsYFFu4FJsCwv+oGPDaw + 9hIoBWFsb25nGAZhY3Jvc3MAGRwVABUAFRAAABamiYaACBXUARa689r/BxWMAQAmrra/6gYcFQwZ + NQYIABkYCnJvb2ZfY29sb3IVDBbA9hIWrgUWlAYmrra/6gY8Nrb2EigHIzc3ODg5ORgHIzAwMDAw + MAAZHBUAFQAVEAAAFvqKhoAIFdQBFsb02v8HFa4BACbCvL/qBhwVChk1BggAGRgLcm9vZl9oZWln + aHQVDBbA9hIW1goWkgcmwry/6gY8GAgAAAAAAAAIQBgIXI/C9Shc5z8W4vUSKAgAAAAAAAAIQBgI + XI/C9Shc5z8AGRwVABUAFRAAABbOjIaACBXUARb09dr/BxWWAQAW4umBGxbA9hImwur92wYWktnB + DhR4ABn8JibUw7/qBhwVDBk1BggAGRgCaWQVDBbYjBMWsM2vBRaOvr0BJtTDv+oGPDYAKCAwOGJi + MmM1NzM0YmI1ZmZmMDIwMGQzYjM5NDJiYjg2NhggMDhiYjJjNTA4MDAwMWZmZjAyMDA0ZGZmMWUx + NWFlZDYAGRwVABUAFRAAABaijoaACBXyARaK99r/BxXWCAAm4oH96wYcFQwZNQYIABkYCGdlb21l + dHJ5FQwW2IwTFu6Q+RAWuL+LCibigf3rBjw2ACjAAgAAAAAGAAAAAwAAAAADAAAAAQAAAAfAUaps + V6yPQMBAvD3iuZ4cwFGqa+COSrHAQLxHhdCO+cBRqmkk8ifQwEC8RyfcvdzAUappdDfgQcBAvEC7 + sfJWwFGqaS4sYzXAQLxAsne28cBRqmlWBO9TwEC8PXuLkZnAUapsV6yPQMBAvD3iuZ4cAAAAAAMA + AAABAAAABcBRqnF7bV6owEC8Pnw8kYHAUapxXGOuJcBAvEPojRy0wFGqbynu5tPAQLxDneSB9cBR + qm9tdiUgwEC8Pkg6K3XAUapxe21eqMBAvD58PJGBAAAAAAMAAAABAAAABcBRqnRu0kWzwEC8Psbl + LD/AUap0S5bXR8BAvEglMr9wwFGqcVl0D5zAQLxH5/Yd/8BRqnGhmGucwEC8PnqPElfAUap0btJF + s8BAvD7G5Sw/GE0AAAAAAwAAAAEAAAAEwFGj+TA+/QrAQMggH+EQBMBRo/kTpJVpwEDIHv69fmbA + UaP50VRyVMBAyB/zNKLhwFGj+TA+/QrAQMggH+EQBAAZHBUAFQAVJgAAFpSQhoAIFbwEFuD/2v8H + FbYnACb+4o72BhwVCBk1BggEGSgEYmJveAR4bWluFQwW2IwTFr7kKxasxygm/uKO9gYmmsGI9gYc + GATk+ozCGAQeVI3CFgAoBOT6jMIYBB5UjcIAGSwVBBUEFQIAFQAVBBUQAAAW0JSGgAgV8gEWlqfb + /wcV1gEAJtiqt/YGHBUIGTUGCAQZKARiYm94BHhtYXgVDBbYjBMWiOUrFvTHKCbYqrf2BibGiLH2 + BhwYBN/6jMIYBP1TjcIWACgE3/qMwhgE/VONwgAZLBUEFQQVAgAVABUEFRAAABbCloaACBXyARbs + qNv/BxXWAQAmvPni9gYcFQgZNQYIBBkoBGJib3gEeW1pbhUMFtiMExaGgTAWtv8rJrz54vYGJrrQ + 2fYGHBgEitsFwhgEMEwGwhYAKASK2wXCGAQwTAbCABksFQQVBBUCABUAFQQVEAAAFrSYhoAIFfIB + FsKq2/8HFdYBACaM+Y73BhwVCBk1BggEGSgEYmJveAR5bWF4FQwW2IwTFoaBMBbQ/ysmjPmO9wYm + 8M+F9wYcGAQa2wXCGAT4SwbCFgAoBBrbBcIYBPhLBsIAGSwVBBUEFQIAFQAVBBUQAAAWppqGgAgV + 8gEWmKzb/wcV1gEAJoDQsfcGHBUCGTUGCAQZGAd2ZXJzaW9uFQwW2IwTFv4EFqAGJoDQsfcGJsDP + sfcGHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFpichoAIFdIB + Fu6t2/8HFdYBACag1rH3BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUM + FtiMExb+BRagByag1rH3Bibg1bH3BhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFuqdhoAI + FdIBFsSv2/8HFVYAJsTesfcGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQV + DBbYjBMW6t4EFpyhAybE3rH3BiaA3bH3Bhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4g + QnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFryfhoAIFeIBFpqw2/8HFfYEACac/rT3BhwVDBkl + BgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbYjBMWmsHQAhbogHkmnP609wY8 + NgAoDHc5OTAxNjQ3ODhAMRgMMDAwMGY5MTNiZjE4ABkcFQAVABUQAAAWnqGGgAgV8gEWkLXb/wcV + 1gMAJqLir/gGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW2IwT + FoyDIRaAigwmouKv+AYmhP+t+AYcNgAoGDIwMjQtMTEtMjlUMTc6MjU6MDIuMDAwWhgYMjAwMC0w + MS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFpCjhoAIFfABFua42/8HFdYGACbe + mLv4BhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW2IwTFuqYEhaq + 5Q4m3pi7+AYmhIm6+AYcGAjnjCjtDb7uPxgIzczMzMzM5D8WnJQNKAjnjCjtDb7uPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAWgKWGgAgV8gEWvL/b/wcV9gIAJv7uyPgGHBUCGTUGCAQZGAVs + ZXZlbBUMFtiMExbECBbMCSb+7sj4Biau7sj4BhwYBAIAAAAYBP////8W4osTKAQCAAAAGAT///// + ABksFQQVBBUCABUAFQQVEAAAFvKmhoAIFdoBFrLC2/8HFdYBACag+sj4BhwVDBk1BggEGRgHc3Vi + dHlwZRUMFtiMExaawwEWkqQBJqD6yPgGJvr3yPgGHDa+jRAoDnRyYW5zcG9ydGF0aW9uGAxhZ3Jp + Y3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWzKiGgAgV4gEWiMTb/wcVsAMAJqShyvgGHBUMGTUG + CAQZGAVjbGFzcxUMFtiMExaY5gEW4LoBJqShyvgGJoycyvgGHDb0khAoCXdhcmVob3VzZRgPYWxs + b3RtZW50X2hvdXNlABksFQQVBBUCABUAFQQVEAAAFq6qhoAIFeIBFrjH2/8HFaYDACbc2Mv4BhwV + Chk1BggEGRgGaGVpZ2h0FQwW2IwTFrgTFvYRJtzYy/gGJuzWy/gGHBgIAAAAAADAWUAYCAAAAAAA + APA/FuSCEygIAAAAAADAWUAYCAAAAAAAAPA/ABksFQQVBBUCABUAFQQVEAAAFpCshoAIFdgBFt7K + 2/8HFZYCACaqhM34BhwVDBk1BggEGSgFbmFtZXMHcHJpbWFyeRUMFtiMExb0ogMWotsBJqqEzfgG + JuLoy/gGHDay/BIoEsOTcHRpY2EgTmV3R2xhc3NlcxgfMSBKdXpnYWRvIGRlIEZhbWlsaWEgU2Fu + IE1pZ3VlbAAZLBUEFQQVAgAVABUEFRAAABborYaACBXiARb0zNv/BxWGBQAmhMTN+AYcFQwZJQYA + GUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbcjBMWzD8W1ikmhMTN+AY8NsCMEygCZXMY + AmVuABkcFQAVABUQAAAWyq+GgAgV4gEW+tHb/wcVngEAJtrtzfgGHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUFdmFsdWUVDBbcjBMW4E4Wri4m2u3N+AY8NsCMEygRWWluLUhlIFJlc3Rh + dXRhbnQYFUFjYWRlbXkgb2YgUGhpbG9zb3BoeQAZHBUAFQAVEAAAFqyxhoAIFeIBFpjT2/8HFcgD + ACaEnc74BhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFuCMExbK + SxbcKyaEnc74BiaInM74Bhw2oIwTKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAA + Fo6zhoAIFeIBFuDW2/8HFbwCACbkx874BhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQIbGFuZ3VhZ2UVDBbgjBMWrEoWqCom5MfO+AY8NuCMEwAZHBUAFQAVEAAAFvC0hoAIFeIBFpzZ + 2/8HFXYAJozyzvgGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFuCM + Exb+Vha4NCaM8s74Bjw2oIwTKA9Uw7puZWwgVW5pdmVyc28YGjR0YSBDb21pc2Fyw61hIGRlIFNh + bnRpYWdvABkcFQAVABUQAAAW0raGgAgV4gEWktrb/wcVygQAJsSmz/gGHBUKGSUGABl4BW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFuCMExa2Sha2KibEps/4 + Bjw24IwTABkcFQAVABUQAAAWtLiGgAgV4gEW3N7b/wcVdgAm+tDP+AYcFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbgjBMWrEoWqCom+tDP+AY8NuCMEwAZHBUAFQAVEAAA + Fpa6hoAIFeIBFtLf2/8HFXYAJqL7z/gGHBUAGTUGCAAZGAloYXNfcGFydHMVDBbYjBMW7LUCFsIG + JqL7z/gGPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAW+LuGgAgV0gEWyODb/wcVdgAm5IHQ+AYc + FQAZNQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwW2IwTFuy1AhawBibkgdD4BjwYAQAYAQAWACgBABgB + AAAZHBUAFQAVEAAAFsq9hoAIFdIBFr7h2/8HFXYAJqqJ0PgGHBUCGTUGCAQZGApudW1fZmxvb3Jz + FQwW2IwTFogwFs4qJqqJ0PgGJpSI0PgGHBgEJAAAABgEAQAAABai4hIoBCQAAAAYBAEAAAAAGSwV + BBUEFQIAFQAVBBUQAAAWnL+GgAgV4gEWtOLb/wcV9gEAJuKy0PgGHBUCGTUGCAAZGBZudW1fZmxv + b3JzX3VuZGVyZ3JvdW5kFQwW2IwTFsYEFtYFJuKy0PgGPBgEAgAAABgEAQAAABbSjBMoBAIAAAAY + BAEAAAAAGRwVABUAFRAAABb+wIaACBXSARaq5Nv/BxWWAQAmuLjQ+AYcFQoZNQYIABkYCm1pbl9o + ZWlnaHQVDBbYjBMWkAQWoAUmuLjQ+AY8NtiMEwAZHBUAFQAVEAAAFtDChoAIFdIBFsDl2/8HFXYA + Jti90PgGHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbYjBMWkAQWoAUm2L3Q+AY8NtiMEwAZHBUAFQAV + EAAAFqLEhoAIFdIBFrbm2/8HFXYAJvjC0PgGHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbYjBMW + zgQW3gUm+MLQ+AY8GAcjRkZGRkZGGAcjRkZGRkZGFtSMEygHI0ZGRkZGRhgHI0ZGRkZGRgAZHBUA + FQAVEAAAFvTFhoAIFdIBFqzn2/8HFa4BACbWyND4BhwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFs + FQwW2IwTFtAEFuAFJtbI0PgGPDbUjBMoCGNvbmNyZXRlGAVicmljawAZHBUAFQAVEAAAFsbHhoAI + FdQBFtro2/8HFZABACa2ztD4BhwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFtiMExa2BBbGBSa2 + ztD4BjwYCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMW1owTKApyb29mX3RpbGVzGApyb29mX3RpbGVz + ABkcFQAVABUQAAAWmsmGgAgV0gEW6unb/wcVngEAJtzU0PgGHBUMGTUGCAQZGApyb29mX3NoYXBl + FQwW2IwTFrYFFtgGJtzU0PgGJvzT0PgGHDa+jBMoBmhpcHBlZBgGZ2FibGVkABksFQQVBBUCABUA + FQQVEAAAFuzKhoAIFdIBFojr2/8HFb4BACbU2tD4BhwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24V + DBbYjBMWkAQWoAUm1NrQ+AY8NtiMEwAZHBUAFQAVEAAAFr7MhoAIFdIBFsbs2/8HFXYAJvTf0PgG + HBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwW2IwTFv4EFuQFJvTf0PgGPBgFYWxvbmcYBWFs + b25nFs6MEygFYWxvbmcYBWFsb25nABkcFQAVABUQAAAWkM6GgAgV0gEWvO3b/wcVngEAJtjl0PgG + HBUMGTUGCAAZGApyb29mX2NvbG9yFQwW2IwTFpIFFuwFJtjl0PgGPDbOjBMoByNGRkZGRkYYByM4 + QjQ1MTMAGRwVABUAFRAAABbiz4aACBXUARba7tv/BxWuAQAmxOvQ+AYcFQoZNQYIABkYC3Jvb2Zf + aGVpZ2h0FQwW2IwTFpAEFqAFJsTr0PgGPDbYjBMAGRwVABUAFRAAABa20YaACBXSARaI8Nv/BxV2 + ABaKt/kaFtiMEybUw7/qBhaQrZEOFHoAGfwmJuTw0PgGHBUMGTUGCAAZGAJpZBUMFrDQEhaM0p4F + FpDEugEm5PDQ+AY8NgAoIDA4YmIyYzU1NmVkYjZmZmYwMjAwYzBmYTYzNzE0NDZkGCAwOGJiMmM1 + MDgwOTAwZmZmMDIwMDZjZTNkOGY2MjdkNwAZHBUAFQAVEAAAFojThoAIFfIBFv7w2/8HFdYIACb0 + tIv6BhwVDBk1BggAGRgIZ2VvbWV0cnkVDBaw0BIWotXzERaUytkKJvS0i/oGPAAZHBUAFQAVKAAA + FvrUhoAIFdoEFtT52/8HFb4pACakieuEBxwVCBk1BggEGSgEYmJveAR4bWluFQwWsNASFvapKhau + mCcmpInrhAcmiP/khAccGASeBY3CGAQ1VI3CFgAoBJ4FjcIYBDVUjcIAGSwVBBUEFQIAFQAVBBUQ + AAAW1NmGgAgV8gEWkqPc/wcV1gEAJoCikoUHHBUIGTUGCAQZKARiYm94BHhtYXgVDBaw0BIWrqoq + FsahJyaAopKFBya2l4yFBxwYBJUFjcIYBPxTjcIWACgElQWNwhgE/FONwgAZLBUEFQQVAgAVABUE + FRAAABbG24aACBXyARbopNz/BxXWAQAmiO+6hQccFQgZNQYIBBkoBGJib3gEeW1pbhUMFrDQEhac + +SwWlpspJojvuoUHJvy4s4UHHBgEBpgFwhgEYPIFwhYAKAQGmAXCGARg8gXCABksFQQVBBUCABUA + FQQVEAAAFrjdhoAIFfIBFr6m3P8HFdYBACbuieSFBxwVCBk1BggEGSgEYmJveAR5bWF4FQwWsNAS + Ft74LBbomikm7onkhQcmktTchQccGASelwXCGAT88QXCFgAoBJ6XBcIYBPzxBcIAGSwVBBUEFQIA + FQAVBBUQAAAWqt+GgAgV8gEWlKjc/wcV1gEAJrrvhYYHHBUCGTUGCAQZGAd2ZXJzaW9uFQwWsNAS + Fv4EFqAGJrrvhYYHJvruhYYHHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUA + FQQVEAAAFpzhhoAIFdIBFuqp3P8HFdYBACba9YWGBxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudAhwcm9wZXJ0eRUMFrDQEhb+BRagByba9YWGByaa9YWGBxwYABgAFgAoABgAABksFQQVBBUC + ABUAFQQVEAAAFu7ihoAIFdIBFsCr3P8HFVYAJv79hYYHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdl + bGVtZW50B2RhdGFzZXQVDBaw0BIW3MUEFo6eAyb+/YWGBya6/IWGBxw2ACgNT3BlblN0cmVldE1h + cBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFsDkhoAIFeIBFpas3P8H + FfYEACbImomGBxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBaw0BIW + zvjHAhaOnHAmyJqJhgc8NgAoDHc5OTQ5NjE4MzhAMRgMMDAwNmRiOWQzYWZjABkcFQAVABUQAAAW + ouaGgAgV8gEWjLHc/wcV1gMAJpy+gIcHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3Vw + ZGF0ZV90aW1lFQwWsNASFu7fPhbirxUmnL6Ahwcm1rb5hgccNgAoGDIwMjQtMTEtMzBUMTg6NTE6 + NTYuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFpTohoAI + FfABFuK03P8HFdYGACaU+o+HBxwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRl + bmNlFQwWsNASFsy0ERbshA4mlPqPhwcmuOaOhwccGAhsCfmgZ7PuPxgIzczMzMzM5D8W4oQNKAhs + CfmgZ7PuPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWhOqGgAgV8gEWuLvc/wcV9gIAJpTs + nIcHHBUCGTUGCAQZGAVsZXZlbBUMFrDQEhaEEhbwECaU7JyHByak65yHBxwYBAUAAAAYBPz///8W + 4MwSKAQFAAAAGAT8////ABksFQQVBBUCABUAFQQVEAAAFvbrhoAIFeABFq6+3P8HFfYBACa6/pyH + BxwVDBk1BggEGRgHc3VidHlwZRUMFrDQEha8nAIWxOQBJrr+nIcHJpT8nIcHHDaUiA8oDnRyYW5z + cG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW1u2GgAgV4gEWpMDc/wcV + tAMAJvjmnocHHBUMGTUGCAQZGAVjbGFzcxUMFrDQEhbWiQMWwJsCJvjmnocHJtjgnocHHDb8lQ8o + CXdhcmVob3VzZRgPYWxsb3RtZW50X2hvdXNlABksFQQVBBUCABUAFQQVEAAAFrjvhoAIFeIBFtjD + 3P8HFbIDACaY/KCHBxwVChk1BggAGRgGaGVpZ2h0FQwWsNASFoQhFpYRJpj8oIcHPBgIAAAAAADA + ckAYCAAAAAAAAPA/FqTNEigIAAAAAADAckAYCAAAAAAAAPA/ABkcFQAVABUQAAAWmvGGgAgV4AEW + isfc/wcV9gIAJrCIpYcHHBUMGTUGCAQZKAVuYW1lcwdwcmltYXJ5FQwWsNASFqClCxbGswUmsIil + hwcmro2hhwccNpKVEigUw5F1w7FvYSBWaWRhIFRvcnJlIDIYHTEgQ29taXNhcsOtYSBTYW50aWFn + byBDZW50cmFsABksFQQVBBUCABUAFQQVEAAAFvryhoAIFeIBFoDK3P8HFe4FACaywqaHBxwVDBkl + BgQZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFqbREhaspAEW8F8mssKmhwcm9MCmhwcc + NpjPEigCemgYAmFyABksFQQVBBUCABUAFQQVEAAAFtz0hoAIFeIBFu7P3P8HFa4BACbkoKeHBxwV + DBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWptESFu78ARbWhgEm5KCnhwc8 + NpjPEigX7Lmg66CIIOyInOuzteydjCDqtZDtmowYD0FETiBSYWRpbyBDaGlsZQAZHBUAFQAVEAAA + Fr72hoAIFeIBFpzR3P8HFc4FACa2qKiHBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQHdmFyaWFudBUMFqDREhaAyQEWpGgmtqiohwcmuqeohwccNr7NEigFc2hvcnQYCWFsdGVybmF0 + ZQAZLBUEFQQVAgAVABUEFRAAABag+IaACBXiARbq1tz/BxXkAgAm3o+phwccFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWoNESFvTIARayZibej6mHBzw29NASKAJw + dBgCZW4AGRwVABUAFRAAABaC+oaACBXiARbO2dz/BxWeAQAm8JiqhwccFQwZJQYEGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWoNESFqSLAhaWjQEm8JiqhwcmkPaphwccNr7NEigC + VU4YBEFDSFMAGSwVBBUEFQIAFQAVBBUQAAAW5PuGgAgV4gEW7Nrc/wcV/AQAJqaDq4cHHBUKGSUG + ABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFqDREha+ + xwEWumUmpoOrhwc8NqDREgAZHBUAFQAVEAAAFsb9hoAIFeIBFujf3P8HFXYAJuDoq4cHHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWoNESFvDGARawZSbg6KuHBzw2oNES + ABkcFQAVABUQAAAWqP+GgAgV4gEW3uDc/wcVdgAmkM6shwccFQAZNQYIABkYCWhhc19wYXJ0cxUM + FrDQEhaorgIW5AomkM6shwc8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABaKgYeACBXcARbU4dz/ + BxV2ACb02KyHBxwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaw0BIWpK4CFq4GJvTYrIcHPBgB + ABgBABYAKAEAGAEAABkcFQAVABUQAAAW5oKHgAgV0gEWyuLc/wcVdgAm1uCshwccFQIZNQYIBBkY + Cm51bV9mbG9vcnMVDBaw0BIWnt4BFvC2ASbW4KyHByai36yHBxwYBEAAAAAYBAEAAAAWgq0RKARA + AAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFriEh4AIFeIBFsDj3P8HFfYBACaSlq6HBxwVAhk1 + BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFrDQEhaqBxaWCCaSlq6HBzwYBAcAAAAYBAEA + AAAWgNASKAQHAAAAGAQBAAAAABkcFQAVABUQAAAWmoaHgAgV2AEWtuXc/wcV1gEAJqierocHHBUK + GTUGCAAZGAptaW5faGVpZ2h0FQwWsNASFtQEFuQFJqierocHPBgIAAAAAAAAO0AYCAAAAAAAAAAA + FqrQEigIAAAAAAAAO0AYCAAAAAAAAAAAABkcFQAVABUQAAAW8oeHgAgV0gEWjOfc/wcVtgEAJoyk + rocHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBaw0BIWogQWsgUmjKSuhwc8GAQBAAAAGAQBAAAAFq7Q + EigEAQAAABgEAQAAAAAZHBUAFQAVEAAAFsSJh4AIFdIBFsLo3P8HFYYBACa+qa6HBxwVDBk1BggA + GRgMZmFjYWRlX2NvbG9yFQwWsNASFuIGFqoHJr6procHPDaa0BIoByNGRkZGRkYYByM0ODU5NkIA + GRwVABUAFRAAABaWi4eACBXYARbI6dz/BxXmAQAm6LCuhwccFQwZNQYIABkYD2ZhY2FkZV9tYXRl + cmlhbBUMFrDQEhayEBaYCybosK6HBzw2ss8SKAdwbGFzdGVyGAVicmljawAZHBUAFQAVEAAAFu6M + h4AIFdwBFq7r3P8HFYwCACaAvK6HBxwVDBk1BggAGRgNcm9vZl9tYXRlcmlhbBUMFrDQEhaEBRaI + BiaAvK6HBzw2qNASKApyb29mX3RpbGVzGAVnbGFzcwAZHBUAFQAVEAAAFsqOh4AIFdQBFrrt3P8H + FZQBACb+w66HBxwVDBk1BggEGRgKcm9vZl9zaGFwZRUMFrDQEha+KRbaJCb+w66HByaIwq6HBxw2 + pLgSKAhza2lsbGlvbhgEZG9tZQAZLBUEFQQVAgAVABUEFRAAABaekIeACBXeARbO7tz/BxWUAgAm + 4uauhwccFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWsNASFqoEFroFJuLmrocHPBgIAAAAAAAA + WUAYCAAAAAAAAFlAFq7QEigIAAAAAAAAWUAYCAAAAAAAAFlAABkcFQAVABUQAAAW/JGHgAgV0gEW + 4vDc/wcVlgEAJpzsrocHHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWsNASFrIbFpYHJpzs + rocHPDb+zRIoBWFsb25nGAZhY3Jvc3MAGRwVABUAFRAAABbOk4eACBXWARb48dz/BxW4AQAmsvOu + hwccFQwZNQYIABkYCnJvb2ZfY29sb3IVDBaw0BIWpgUWtgYmsvOuhwc8NqbQEigHI0ZGRkZGRhgH + Izc3ODg5OQAZHBUAFQAVEAAAFqSVh4AIFdQBFrDz3P8HFeYBACbo+a6HBxwVChk1BggAGRgLcm9v + Zl9oZWlnaHQVDBaw0BIWwAUWrAYm6Pmuhwc8GAgAAAAAAAAuQBgImpmZmZmZ2T8WoNASKAgAAAAA + AAAuQBgImpmZmZmZ2T8AGRwVABUAFRAAABb4loeACBXWARaW9dz/BxXWAQAW6NGBHBaw0BIm5PDQ + +AYWsI/eDhR8ABn8JiaUgK+HBxwVDBk1BggAGRgCaWQVDBbMmhMW/sGzBRaG3MEBJpSAr4cHPDYA + KCAwOGJiMmM1Y2RhN2I2ZmZmMDIwMGVkYzVhY2UxMTRmNhggMDhiYjJjNDI0MDA5YWZmZjAyMDAy + ZDExOGY3ZWYzNjAAGRwVABUAFRAAABbOmIeACBXyARbs9tz/BxXWCAAmmtzwiAccFQwZNQYIABkY + CGdlb21ldHJ5FQwWzJoTFvTC5RAWhvGTCiaa3PCIBzw2ACjjAgAAAAAGAAAAAgAAAAADAAAAAQAA + AAnAUbDdQfp2U8BAsNuxbB42wFGwz2HSgu/AQLDrzGxUvcBRsLrDtczWwECwukGvzbnAUbDITrjK + t8BAsKqI1SY4wFGw06YE4efAQLDFyaNMocBRsNKhIiQXwECwxvlONRfAUbDY7xn+r8BAsNYfW+Xa + wFGw2kmNEczAQLDUjLSuycBRsN1B+nZTwECw27FsHjYAAAAAAwAAAAEAAAALwFGw3XRPXTXAQLDh + PnPZFsBRsOPkq+ajwECw8PFvQ4XAUbDlFMIu5MBAsO+WJXDTwFGw68OdeSLAQLD/xvUcd8BRsOpe + rgtBwECxAVfu1F/AUbDyNhLhhMBAsROq169/wFGw5Qgs9SzAQLElYAvZUsBRsNl2k9sUwECxCSpL + LSXAUbDaEO2ODcBAsQh6IgUOwFGw0DHcGx7AQLDwaLNHwcBRsN10T101wECw4T5z2RYYTQAAAAAD + AAAAAQAAAATAUaLCONMXCcBAtSVqSKGrwFGiwfgqSVXAQLUkOKbaJsBRosLOUhXCwEC1JRFPuifA + UaLCONMXCcBAtSVqSKGrABkcFQAVABUmAAAWwJqHgAgVvgQWwv/c/wcVticAJsSPkZMHHBUIGTUG + CAQZKARiYm94BHhtaW4VDBbMmhMWyPY1FtjyLibEj5GTByagzYSTBxwYBIOgjMIYBAYIjsIWACgE + g6CMwhgEBgiOwgAZLBUEFQQVAgAVABUEFRAAABb+noeACBXyARb4pt3/BxXWAQAmiP2/kwccFQgZ + NQYIBBkoBGJib3gEeG1heBUMFsyaExbIoDUWvuEuJoj9v5MHJvi/s5MHHBgEcKCMwhgE/QeOwhYA + KARwoIzCGAT9B47CABksFQQVBBUCABUAFQQVEAAAFvCgh4AIFfIBFs6o3f8HFdYBACbStvKTBxwV + CBk1BggEGSgEYmJveAR5bWluFQwWzJoTFuigPBbyvjMm0rbykwcmtqHikwccGAQl5ATCGATySwbC + FgAoBCXkBMIYBPJLBsIAGSwVBBUEFQIAFQAVBBUQAAAW4qKHgAgV8gEWpKrd/wcV1gEAJv75pZQH + HBUIGTUGCAQZKARiYm94BHltYXgVDBbMmhMWkKc8FrzCMyb++aWUByao4JWUBxwYBBnkBMIYBOVL + BsIWACgEGeQEwhgE5UsGwgAZLBUEFQQVAgAVABUEFRAAABbUpIeACBXyARb6q93/BxXWAQAmpKPJ + lAccFQIZNQYIBBkYB3ZlcnNpb24VDBbMmhMW/gQWoAYmpKPJlAcm5KLJlAccGAQAAAAAGAQAAAAA + FgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWxqaHgAgV0gEW0K3d/wcV1gEAJsSpyZQH + HBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWzJoTFv4FFqAHJsSpyZQH + JoSpyZQHHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAWmKiHgAgV0gEWpq/d/wcVVgAm6LHJ + lAccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFsyaExbE3gQWkI4DJuix + yZQHJqSwyZQHHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUE + FQIAFQAVBBUQAAAW6qmHgAgV4gEW/K/d/wcV9gQAJrS+zJQHHBUMGSUGABlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50CXJlY29yZF9pZBUMFsyaExbsrNkCFqCWgAEmtL7MlAc8NgAoDHc5OTQwMDMxMDNA + MhgMMDAwMThhNTM2NGE2ABkcFQAVABUQAAAWzKuHgAgV8gEW8rTd/wcV1gMAJuKzzpUHHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWzJoTFry/IBbgkgom4rPOlQcm + 1NTMlQccNgAoGDIwMjQtMTEtMzBUMDM6NTc6NDkuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4w + MDBaABksFQQVBBUCABUAFQQVEAAAFr6th4AIFewBFsi43f8HFdYGACbAgdiVBxwVChklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWzJoTFq7UFBa2pREmwIHYlQcmtOfWlQcc + GAgdWmQ730/vPxgIzczMzMzM5D8WlN4LKAgdWmQ730/vPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAV + BBUQAAAWqq+HgAgV8gEWnr/d/wcV9gIAJrqN6JUHHBUCGTUGCAQZGAVsZXZlbBUMFsyaExa6CRbC + Cia6jeiVBybqjOiVBxwYBAMAAAAYBP////8WxpkTKAQDAAAAGAT/////ABksFQQVBBUCABUAFQQV + EAAAFpyxh4AIFd4BFpTC3f8HFeYBACbSmeiVBxwVDBk1BggEGRgHc3VidHlwZRUMFsyaExa0fBb+ + ZSbSmeiVByasl+iVBxw2uI4SKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUC + ABUAFQQVEAAAFvqyh4AIFeIBFvrD3f8HFcQDACbOgumVBxwVDBk1BggEGRgFY2xhc3MVDBbMmhMW + +owBFs5zJs6C6ZUHJqr96JUHHDbmkhIoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQVAgAV + ABUEFRAAABbctIeACBXiARa+x93/BxWMAwAmrPLplQccFQoZNQYIBBkYBmhlaWdodBUMFsyaExbY + BxaSCCas8umVByb48OmVBxwYCAAAAAAAgFFAGAgAAAAAAAAAQBakmhMoCAAAAAAAgFFAGAgAAAAA + AAAAQAAZLBUEFQQVAgAVABUEFRAAABa+toeACBXWARbKyt3/BxX2AQAmivnplQccFQwZNQYIABko + BW5hbWVzB3ByaW1hcnkVDBbMmhMW4PMCFtLYASaK+emVBzw2nIwTKArDk3B0aWNhIEpDGA4jMDE1 + MSBNZWNhbmljYQAZHBUAFQAVEAAAFpS4h4AIFeIBFsDM3f8HFf4EACbc0euVBxwVDBklBgAZSAVu + YW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFtyaExaaOBamJibc0euVBzw2sJoTKAJmchgCYXIA + GRwVABUAFRAAABb2uYeACBXiARa+0d3/BxWuAQAmgvjrlQccFQwZJQYAGUgFbmFtZXMGY29tbW9u + CWtleV92YWx1ZQV2YWx1ZRUMFtyaExaqRxbKLCaC+OuVBzw2sJoTKCDYs9mB2KfYsdipINiv2YjZ + hNipINmB2YTYs9i32YrZhhgWQW1iYXNzYWRlIGRlIFBhbGVzdGluZQAZHBUAFQAVEAAAFti7h4AI + FeIBFuzS3f8HFeIEACbIpeyVBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFy + aWFudBUMFuaaExbsQRb2KCbIpeyVBybMpOyVBxw2jpoTKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQV + BBUCABUAFQQVEAAAFrq9h4AIFeIBFs7X3f8HFbACACbCzeyVBxwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbmmhMWnEEW9icmws3slQc8NtiaEygCZXMYAmVuABkc + FQAVABUQAAAWnL+HgAgV4gEW/tnd/wcVhgEAJrj17JUHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudAV2YWx1ZRUMFuaaExaoVBaeNCa49eyVBzw2jpoTKANXT00YA0FWTwAZHBUAFQAV + EAAAFv7Ah4AIFeIBFoTb3f8HFagEACbWqe2VBxwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBbmmhMW1kAWticm1qntlQc8NuaaEwAZHBUAFQAV + EAAAFuDCh4AIFeIBFqzf3f8HFXYAJozR7ZUHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudARzaWRlFQwW5poTFshAFrYnJozR7ZUHPDbmmhMAGRwVABUAFRAAABbCxIeACBXiARai4N3/ + BxV2ACbC+O2VBxwVABk1BggAGRgJaGFzX3BhcnRzFQwWzJoTFsq3AhbYBibC+O2VBzwYAQEYAQAW + ACgBARgBAAAZHBUAFQAVEAAAFqTGh4AIFdQBFpjh3f8HFXYAJpr/7ZUHHBUAGTUGCAAZGA5pc191 + bmRlcmdyb3VuZBUMFsyaExbKtwIWsAYmmv/tlQc8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABb4 + x4eACBXSARaO4t3/BxV2ACbahu6VBxwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFsyaExa4LBaKJSba + hu6VBybKhe6VBxwYBBwAAAAYBAEAAAAWzoMTKAQcAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAA + FsrJh4AIFd4BFoTj3f8HFeYBACbUqu6VBxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3Vu + ZBUMFsyaExaOBBaeBSbUqu6VBzw2zJoTABkcFQAVABUQAAAWqMuHgAgV0gEW6uTd/wcVdgAm8q/u + lQccFQoZNQYIABkYCm1pbl9oZWlnaHQVDBbMmhMWjgQWngUm8q/ulQc8NsyaEwAZHBUAFQAVEAAA + FvrMh4AIFdIBFuDl3f8HFXYAJpC17pUHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbMmhMWjgQWngUm + kLXulQc8NsyaEwAZHBUAFQAVEAAAFszOh4AIFdIBFtbm3f8HFXYAJq667pUHHBUMGTUGCAAZGAxm + YWNhZGVfY29sb3IVDBbMmhMW5AQW9AUmrrrulQc8NsaaEygHI0ZGRkZGRhgHIzdCM0YwMAAZHBUA + FQAVEAAAFp7Qh4AIFdQBFszn3f8HFa4BACaiwO6VBxwVDBk1BggAGRgPZmFjYWRlX21hdGVyaWFs + FQwWzJoTFsgEFtgFJqLA7pUHPBgFZ2xhc3MYBWdsYXNzFsiaEygFZ2xhc3MYBWdsYXNzABkcFQAV + ABUQAAAW8tGHgAgV0gEW+ujd/wcVngEAJvrF7pUHHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwW + zJoTFo4EFp4FJvrF7pUHPDbMmhMAGRwVABUAFRAAABbE04eACBXSARaY6t3/BxV2ACb4y+6VBxwV + DBk1BggEGRgKcm9vZl9zaGFwZRUMFsyaExbuBRaQByb4y+6VByaYy+6VBxw2qpoTKAZoaXBwZWQY + BmdhYmxlZAAZLBUEFQQVAgAVABUEFRAAABaW1YeACBXWARaO693/BxWmAQAmqNLulQccFQoZNQYI + ABkYDnJvb2ZfZGlyZWN0aW9uFQwWzJoTFo4EFp4FJqjS7pUHPDbMmhMAGRwVABUAFRAAABbs1oeA + CBXSARa07N3/BxV2ACbG1+6VBxwVDBk1BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFsyaExaOBBae + BSbG1+6VBzw2zJoTABkcFQAVABUQAAAWvtiHgAgV0gEWqu3d/wcVdgAm5NzulQccFQwZNQYIABkY + CnJvb2ZfY29sb3IVDBbMmhMWjgQWngUm5NzulQc8NsyaEwAZHBUAFQAVEAAAFpDah4AIFdIBFqDu + 3f8HFXYAJoLi7pUHHBUKGTUGCAAZGAtyb29mX2hlaWdodBUMFsyaExa2BBbGBSaC4u6VBzwYCMP1 + KFyPwhVAGAgUrkfhehQGQBbImhMoCMP1KFyPwhVAGAgUrkfhehQGQAAZHBUAFQAVEAAAFuLbh4AI + FdIBFpbv3f8HFZYBABbAwJ4bFsyaEyaUgK+HBxa0578OFH4AGfwmJsjn7pUHHBUMGTUGCAAZGAJp + ZBUMFry1ExbAibsFFuT0xQEmyOfulQc8NgAoIDA4YmIyYzVkYjJjMDNmZmYwMjAwYmZlNGQxYWE0 + ZjdjGCAwOGJiMmM0MjJkYjIyZmZmMDIwMGFlZGQ5YjgwYjgyMgAZHBUAFQAVEAAAFrTdh4AIFfIB + Fqzw3f8HFdYIACas3LSXBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBa8tRMWjJHGEBbGpPkJJqzctJcH + PDYAKMMCAAAAAAYAAAACAAAAAAMAAAABAAAABcBRqv+oVsu/wECrdOIqLCPAUasATm743MBAq3iB + Gx2TwFGq/U0yuLrAQKt6AiSdbsBRqvynhetnwECrdmMzq//AUar/qFbLv8BAq3TiKiwjAAAAAAMA + AAABAAAADcBRqwMK4dtSwECrd/1nn0zAUasDqxrLXcBAq3uj5Uz2wFGrAxBVuJnAQKt77bcoIMBR + qwNVinYQwECrfYE1HsbAUasD/ibh7MBAq30wrUb2wFGrBKPTrz/AQKuA9jSlI8BRqwQdMJJvwECr + gTbMROjAUasEW0PzdcBAq4KiBk+lwFGrBNGLeG/AQKuCaPtsHcBRqwWKGBxWwECrhp09kwnAUasD + GY/z/sBAq4fH3/4CwFGrAJdqFHHAQKt5KbeJb8BRqwMK4dtSwECrd/1nn0wYTQAAAAADAAAAAQAA + AATAUarWufutT8BAoD6DLJu0wFGq13PYvHPAQKBC8yPm+sBRqtbE1J/twECgQvfXEw3AUarWufut + T8BAoD6DLJu0ABkcFQAVABUmAAAWpt+HgAgVvAQWgvnd/wcVticAJrS4t6EHHBUIGTUGCAQZKARi + Ym94BHhtaW4VDBa8tRMWxsUxFpLvLCa0uLehBybygK6hBxwYBAJUjcIYBAEIjsIWACgEAlSNwhgE + AQiOwgAZLBUEFQQVAgAVABUEFRAAABbi44eACBXyARa4oN7/BxXWAQAmgKfkoQccFQgZNQYIBBko + BGJib3gEeG1heBUMFry1ExbmxDEWyu4sJoCn5KEHJoTw2qEHHBgE1lONwhgE+QeOwhYAKATWU43C + GAT5B47CABksFQQVBBUCABUAFQQVEAAAFtTlh4AIFfIBFo6i3v8HFdYBACbmg5yiBxwVCBk1BggE + GSgEYmJveAR5bWluFQwWvLUTFsTYQhaewDgm5oOcogcmzt6HogccGAQJMATCGATXjAXCFgAoBAkw + BMIYBNeMBcIAGSwVBBUEFQIAFQAVBBUQAAAWxueHgAgV8gEW5KPe/wcV1gEAJuLI1KIHHBUIGTUG + CAQZKARiYm94BHltYXgVDBa8tRMWnt5CFvzEOCbiyNSiBybsnsCiBxwYBPsvBMIYBLaMBcIWACgE + +y8EwhgEtowFwgAZLBUEFQQVAgAVABUEFRAAABa46YeACBXyARa6pd7/BxXWAQAmqOT4ogccFQIZ + NQYIBBkYB3ZlcnNpb24VDBa8tRMW/gQWoAYmqOT4ogcm6OP4ogccGAQAAAAAGAQAAAAAFgAoBAAA + AAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWquuHgAgV0gEWkKfe/wcV1gEAJsjq+KIHHBUMGSUG + BBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwWvLUTFv4FFqAHJsjq+KIHJojq+KIH + HBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW/OyHgAgV0gEW5qje/wcVVgAm7PL4ogccFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFry1Exa83QQW2vUCJuzy+KIHJqjx + +KIHHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAV + BBUQAAAWzu6HgAgV4gEWvKne/wcV9gQAJoLn+6IHHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVt + ZW50CXJlY29yZF9pZBUMFry1ExbK+eUCFsCEggEmguf7ogc8NgAoDHc5NzY0MTYxNzRAMRgMMDAw + MTIyMzQ0OWRiABkcFQAVABUQAAAWsPCHgAgV8gEWsq7e/wcV1AMAJrrQ/qMHHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWvLUTFp6rGRawogcmutD+owcmwuv9owcc + NgAoGDIwMjQtMTEtMzBUMTU6NTQ6MDMuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABks + FQQVBBUCABUAFQQVEAAAFqLyh4AIFeIBFoay3v8HFdYGACacqoakBxwVChklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWvLUTFpzVFxaOuhQmnKqGpAcm8o2FpAccGAippE5A + E2HvPxgIzczMzMzM5D8WxoEKKAippE5AE2HvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW + hPSHgAgV8gEW3Lje/wcV9gIAJsbImaQHHBUCGTUGCAQZGAVsZXZlbBUMFry1ExbKBxbWCCbGyJmk + ByaAyJmkBxwYBAUAAAAYBAEAAAAW5rQTKAQFAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFvb1 + h4AIFdgBFtK73v8HFdYBACb60pmkBxwVDBk1BggEGRgHc3VidHlwZRUMFry1ExaqPhbWMyb60pmk + BybW0JmkBxw2iIwTKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EAAAFs73h4AIFeIBFqi93v8HFZgDACb4h5qkBxwVDBk1BggEGRgFY2xhc3MVDBa8tRMW+D0W7DQm + +IeapAcmrISapAccNvCNEygJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAA + FrD5h4AIFeIBFsDA3v8HFfYCACaYuZqkBxwVChk1BggAGRgGaGVpZ2h0FQwWvLUTFsQEFtQFJpi5 + mqQHPBgIAAAAAAAALkAYCAAAAAAAAAhAFri1EygIAAAAAAAALkAYCAAAAAAAAAhAABkcFQAVABUQ + AAAWkvuHgAgV0gEWtsPe/wcVtgEAJuy+mqQHHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWvLUT + FvDBARa0eSbsvpqkBzw2yK0TKAR1cGEhGAxBIERvcyBGdWVnb3MAGRwVABUAFRAAABbk/IeACBXi + ARbsxN7/BxX+AwAmoLibpAccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBa8 + tRMWmiMWshomoLibpAc8Nri1EygDeXVlGAJlbgAZHBUAFQAVEAAAFsb+h4AIFeIBFurI3v8HFYoB + ACbS0pukBxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWvLUTFsopFpAc + JtLSm6QHPDa4tRMoBuaYn+i0tRgXT3VyIExhZHkgb2YgU2Nob2Vuc3RhdHQAGRwVABUAFRAAABao + gIiACBXiARb0yd7/BxXqAQAm3u+bpAccFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B3ZhcmlhbnQVDBbKtRMWxioWih0m3u+bpAcm4u6bpAccNqK1EygFc2hvcnQYCWFsdGVybmF0ZQAZ + LBUEFQQVAgAVABUEFRAAABaKgoiACBXiARbey97/BxWaAgAm7IucpAccFQwZJQYAGVgFbmFtZXMF + cnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWyrUTFswpFoAcJuyLnKQHPDbGtRMoAmVzGAJl + bgAZHBUAFQAVEAAAFuyDiIAIFeIBFvjN3v8HFX4AJuynnKQHHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudAV2YWx1ZRUMFsq1Exa0MxbeIibsp5ykBzw2orUTKAZUb3R0dXMYA0JDSQAZ + HBUAFQAVEAAAFs6FiIAIFeIBFvbO3v8HFcwEACbKypykBxwVChklBgAZeAVuYW1lcwVydWxlcwRs + aXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBbKtRMWvikW+BsmysqcpAc8Nsq1EwAZ + HBUAFQAVEAAAFrCHiIAIFeIBFsLT3v8HFXYAJsLmnKQHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxp + c3QHZWxlbWVudARzaWRlFQwWyrUTFrQpFugbJsLmnKQHPDbKtRMAGRwVABUAFRAAABaSiYiACBXi + ARa41N7/BxV2ACaqgp2kBxwVABk1BggAGRgJaGFzX3BhcnRzFQwWvLUTFvi6AhbMBiaqgp2kBzwY + AQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFvSKiIAIFdIBFq7V3v8HFXYAJvaInaQHHBUAGTUGCAAZ + GA5pc191bmRlcmdyb3VuZBUMFry1Exb4ugIWsAYm9oidpAc8GAEAGAEAFgAoAQAYAQAAGRwVABUA + FRAAABbGjIiACBXSARak1t7/BxV2ACaekJ2kBxwVAhk1BggEGRgKbnVtX2Zsb29ycxUMFry1Exbu + CxbYDCaekJ2kByamj52kBxwYBAoAAAAYBAEAAAAW3LITKAQKAAAAGAQBAAAAABksFQQVBBUCABUA + FQQVEAAAFpiOiIAIFdoBFprX3v8HFfYBACb+m52kBxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRl + cmdyb3VuZBUMFry1ExaQBBagBSb+m52kBzw2vLUTABkcFQAVABUQAAAW8o+IgAgV0gEWkNne/wcV + dgAmnqGdpAccFQoZNQYIABkYCm1pbl9oZWlnaHQVDBa8tRMWkAQWoAUmnqGdpAc8Nry1EwAZHBUA + FQAVEAAAFsSRiIAIFdIBFoba3v8HFXYAJr6mnaQHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBa8tRMW + kAQWoAUmvqadpAc8Nry1EwAZHBUAFQAVEAAAFpaTiIAIFdIBFvza3v8HFXYAJt6rnaQHHBUMGTUG + CAAZGAxmYWNhZGVfY29sb3IVDBa8tRMWkAQWoAUm3qudpAc8Nry1EwAZHBUAFQAVEAAAFuiUiIAI + FdIBFvLb3v8HFXYAJv6wnaQHHBUMGTUGCAAZGA9mYWNhZGVfbWF0ZXJpYWwVDBa8tRMWkAQWoAUm + /rCdpAc8Nry1EwAZHBUAFQAVEAAAFrqWiIAIFdIBFujc3v8HFXYAJp62naQHHBUMGTUGCAAZGA1y + b29mX21hdGVyaWFsFQwWvLUTFpAEFqAFJp62naQHPDa8tRMAGRwVABUAFRAAABaMmIiACBXSARbe + 3d7/BxV2ACa+u52kBxwVDBk1BggAGRgKcm9vZl9zaGFwZRUMFry1ExaqBBa6BSa+u52kBzwYBGZs + YXQYBGZsYXQWurUTKARmbGF0GARmbGF0ABkcFQAVABUQAAAW3pmIgAgV0gEW1N7e/wcVhgEAJvjA + naQHHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlvbhUMFry1ExaQBBagBSb4wJ2kBzw2vLUTABkcFQAV + ABUQAAAWsJuIgAgV0gEW2t/e/wcVdgAmmMadpAccFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24V + DBa8tRMWkAQWoAUmmMadpAc8Nry1EwAZHBUAFQAVEAAAFoKdiIAIFdIBFtDg3v8HFXYAJrjLnaQH + HBUMGTUGCAAZGApyb29mX2NvbG9yFQwWvLUTFrAEFsAFJrjLnaQHPBgHIzAwMDAwMBgHIzAwMDAw + MBa6tRMoByMwMDAwMDAYByMwMDAwMDAAGRwVABUAFRAAABbUnoiACBXSARbG4d7/BxWSAQAm+NCd + pAccFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWvLUTFpAEFqAFJvjQnaQHPDa8tRMAGRwVABUAFRAA + ABamoIiACBXSARbY4t7/BxV2ABaa348bFry1EybI5+6VBxbQ7q4OFIABABn8JiaY1p2kBxwVDBk1 + BggAGRgCaWQVDBaM1xIW/MOgBRbE0b0BJpjWnaQHPDYAKCAwOGJiMmM1ZGIzMGNkZmZmMDIwMDk4 + NmMwOTg1MmEzMRggMDhiYjJjNDA5MDQ5YmZmZjAyMDBhYzZmNzRkYmIzM2UAGRwVABUAFRAAABb4 + oYiACBXyARbO497/BxXWCAAm3KfbpQccFQwZNQYIABkYCGdlb21ldHJ5FQwWjNcSFsbL+hAW4KS+ + Cibcp9ulBzw2ACiXBQAAAAAGAAAABgAAAAADAAAAAQAAAAXAUal6oLAOUMBAsuB71jo0wFGpe65h + p7vAQLLsNh6f/sBRqXnfv+6YwECy7Knh5jrAUal40g5VLcBAsuDvmYBvwFGpeqCwDlDAQLLge9Y6 + NAAAAAADAAAAAQAAAAnAUal+teiEucBAst7OVxCIwFGpgABrX8rAQLLvsqril8BRqXWXW9G4wECy + 8em8x5zAUal0T8iVMMBAsuEnzaRjwFGpdggveWrAQLLgydnTRsBRqXcUnvN2wECy7ocxuAnAUal+ + Fa+UrsBAsu0JgzaBwFGpfQZQfBnAQLLfKcai58BRqX616IS5wECy3s5XEIgAAAAAAwAAAAEAAAAF + wFGpgFPi1iTAQLLx4IKMN8BRqYERd/eIwECy/Es/mXPAUal/P3tAEsBAsvynhetnwFGpfoHmHq3A + QLLyPMjeK8BRqYBT4tYkwECy8eCCjDcAAAAAAwAAAAEAAAAFwFGpfC0MqIXAQLLy7BtGrcBRqXzq + ocnqwECy/VevE37AUal7GKUSdMBAsv2z9WVywFGpelsP8Q/AQLLzSGGYocBRqXwtDKiFwECy8uwb + Rq0AAAAAAwAAAAEAAAAFwFGpdyGfjPnAQLL0S5bXR8BRqXffNK5dwECy/rcqpBjAUal2DTf258BA + sv8TcPYMwFGpdU+i1YLAQLL0qLPo0MBRqXchn4z5wECy9EuW10cAAAAAAwAAAAEAAAAHwFGpcThR + gCXAQLL1r0QlysBRqXIp6QeWwECzApu7ssnAUamBcEKIO8BAsv+Afj+hwFGpgbGw55TAQLMDA8B+ + 4cBRqXCEzVm7wECzBoH6QKPAUalvUcdy8cBAsvYRabTQwFGpcThRgCXAQLL1r0QlyhhNAAAAAAMA + AAABAAAABMBRnu+PXupswECtxO+STwfAUZ7vLeiytsBArcYPvH7uwFGe7q/rzebAQK3Fl7RyecBR + nu+PXupswECtxO+STwcAGRwVABUAFSYAABbqo4iACBW+BBak7N7/BxW2JwAm3tylsAccFQgZNQYI + BBkoBGJib3gEeG1pbhUMFozXEha+/zMW2LUuJt7cpbAHJrzMmbAHHBgECKCMwhgEJlGPwhYAKAQI + oIzCGAQmUY/CABksFQQVBBUCABUAFQQVEAAAFqioiIAIFfIBFtqT3/8HFdYBACaekdSwBxwVCBk1 + BggEGSgEYmJveAR4bWF4FQwWjNcSFsr8MxamtC4mnpHUsAcmlILIsAccGAT4n4zCGAQfUY/CFgAo + BPifjMIYBB9Rj8IAGSwVBBUEFQIAFQAVBBUQAAAWmqqIgAgV8gEWsJXf/wcV1gEAJrq29rAHHBUI + GTUGCAAZKARiYm94BHltaW4VDBaM1xIWgOFKFuyuKCa6tvawBzwYBKIeBMIYBGWYBcIWACgEoh4E + whgEZZgFwgAZHBUAFQAVEAAAFoysiIAIFfIBFoaX3/8HFdYBACaCsK+xBxwVCBk1BggEGSgEYmJv + eAR5bWF4FQwWjNcSFpyUOxaS/zImgrCvsQcmpuWesQccGAQxHgTCGAT8lwXCFgAoBDEeBMIYBPyX + BcIAGSwVBBUEFQIAFQAVBBUQAAAW/q2IgAgV8gEW3Jjf/wcV1gEAJvjk0bEHHBUCGTUGCAQZGAd2 + ZXJzaW9uFQwWjNcSFv4EFqAGJvjk0bEHJrjk0bEHHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAA + ABksFQQVBBUCABUAFQQVEAAAFvCviIAIFdIBFrKa3/8HFdYBACaY69GxBxwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFozXEhb+BRagByaY69GxBybY6tGxBxwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVEAAAFsKxiIAIFdIBFoic3/8HFVYAJrzz0bEHHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaM1xIWtNYEFvD7Aia889GxByb48dGxBxw2ACgN + T3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFpSz + iIAIFeIBFt6c3/8HFfYEACbo7dSxBxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNv + cmRfaWQVDBaM1xIW7ofSAhbQs38m6O3UsQc8NgAoDHc5OTkyNzAyNjJAMRgMMDAwMTRjNDlmZTVm + ABkcFQAVABUQAAAW9rSIgAgV8gEW1KHf/wcV1AMAJry71bIHHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWjNcSFpqUHBaOrggmvLvVsgcmuKHUsgccNgAoGDIwMjQt + MTEtMzBUMTU6NTQ6MDMuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUA + FQQVEAAAFui2iIAIFeoBFqil3/8HFdYGACbC592yBxwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudApjb25maWRlbmNlFQwWjNcSFqiYFRbO+REmwufdsgcmxs/csgccGAicM6K0N/juPxgIzczM + zMzM5D8W7vEKKAicM6K0N/juPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW0riIgAgV8gEW + /qvf/wcV9AIAJuTJ7rIHHBUCGTUGCAQZGAVsZXZlbBUMFozXEhaECBamCSbkye6yByaUye6yBxwY + BAIAAAAYBP////8WqtYSKAQCAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFsS6iIAIFdwBFvKu + 3/8HFfYBACbc1O6yBxwVDBk1BggEGRgHc3VidHlwZRUMFozXEhawXRbKSCbc1O6yBya60u6yBxw2 + 1pYSKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFqC8iIAI + FeIBFuiw3/8HFaIDACaAn++yBxwVDBk1BggEGRgFY2xhc3MVDBaM1xIWrmEW2EwmgJ/vsgcmhJvv + sgccNu6ZEigJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFoK+iIAIFeIB + Foq03/8HFaIDACbc5++yBxwVChk1BggAGRgGaGVpZ2h0FQwWjNcSFsIUFpIKJtzn77IHPBgIAAAA + AADAUkAYCClcj8L1KARAFqjVEigIAAAAAADAUkAYCClcj8L1KARAABkcFQAVABUQAAAW5L+IgAgV + 2AEWrLff/wcVlgIAJu7x77IHHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWjNcSFvbCAhbCwgEm + 7vHvsgc8NuTIEigGxaBrb2RhGAkxMDAgQXV0b3MAGRwVABUAFRAAABa8wYiACBXiARbCud//BxXY + AwAmsLTxsgccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBai1xIWqDQWkCQm + sLTxsgc8Nu7WEigCemgYAmFyABkcFQAVABUQAAAWnsOIgAgV4gEWmr3f/wcVjgEAJsDY8bIHHBUM + GSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBai1xIWiEUWiCsmwNjxsgc8Nu7W + EigJ5a6d6ams5Y6CGBVBbWJhc3NhZGUgZCdBbGxlbWFnbmUAGRwVABUAFRAAABaAxYiACBXiARao + vt//BxWuAgAmxITysgccFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQV + DBag1xIWwjwW1CYmxITysgcmyIPysgccNt7WEigFc2hvcnQYCWFsdGVybmF0ZQAZLBUEFQQVAgAV + ABUEFRAAABbixoiACBXiARbWwN//BxW4AgAmnKrysgccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50CGxhbmd1YWdlFQwWoNcSFuQ7FtolJpyq8rIHPDaW1xIoAmVzGAJkZQAZHBUAFQAV + EAAAFsTIiIAIFeIBFo7D3/8HFYYBACaa1vKyBxwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2Vs + ZW1lbnQFdmFsdWUVDBag1xIWjEUWlCwmmtbysgcm9s/ysgccNt7WEigQU3RhcmJ1Y2tzIENvZmZl + ZRgfQmFuY28gQmlsYmFvIFZpemNheWEgQXJnZW50YXJpYQAZLBUEFQQVAgAVABUEFRAAABamyoiA + CBXiARaUxN//BxXqBQAmivzysgccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2Jl + dHdlZW4EbGlzdAdlbGVtZW50FQwWoNcSFrg7FrwlJor88rIHPDag1xIAGRwVABUAFRAAABaIzIiA + CBXiARb+yd//BxV2ACbGofOyBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lk + ZRUMFqDXEhaoOxayJSbGofOyBzw2oNcSABkcFQAVABUQAAAW6s2IgAgV4gEW9Mrf/wcVdgAm+Mbz + sgccFQAZNQYIABkYCWhhc19wYXJ0cxUMFozXEhaSrwIWzAYm+Mbzsgc8GAEBGAEAFgAoAQEYAQAA + GRwVABUAFRAAABbMz4iACBXSARbqy9//BxV2ACbEzfOyBxwVABk1BggAGRgOaXNfdW5kZXJncm91 + bmQVDBaM1xIWkq8CFrAGJsTN87IHPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWntGIgAgV0gEW + 4Mzf/wcVdgAm9NPzsgccFQIZNQYIABkYCm51bV9mbG9vcnMVDBaM1xIWhkYWqh0m9NPzsgc8GAQh + AAAAGAQBAAAAFrTKEigEIQAAABgEAQAAAAAZHBUAFQAVEAAAFvDSiIAIFeABFtbN3/8HFfYBACae + 8fOyBxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFozXEha8BBbMBSae8fOyBzwY + BAYAAAAYBAUAAAAWhtcSKAQGAAAAGAQFAAAAABkcFQAVABUQAAAW0NSIgAgV0gEWzM/f/wcVlgEA + Jur287IHHBUKGTUGCAAZGAptaW5faGVpZ2h0FQwWjNcSFpAEFqAFJur287IHPDaM1xIAGRwVABUA + FRAAABai1oiACBXSARbi0N//BxV2ACaK/POyBxwVAhk1BggAGRgJbWluX2Zsb29yFQwWjNcSFpAE + FqAFJor887IHPDaM1xIAGRwVABUAFRAAABb014iACBXSARbY0d//BxV2ACaqgfSyBxwVDBk1BggA + GRgMZmFjYWRlX2NvbG9yFQwWjNcSFu4EFv4FJqqB9LIHPDaG1xIoByNGRkZGRkYYByNGRkMwQ0IA + GRwVABUAFRAAABbG2YiACBXUARbO0t//BxWuAQAmqIf0sgccFQwZNQYIABkYD2ZhY2FkZV9tYXRl + cmlhbBUMFozXEhbcBhbEBiaoh/SyBzw27tYSKAVnbGFzcxgFYnJpY2sAGRwVABUAFRAAABaa24iA + CBXWARb809//BxWeAQAm7I30sgccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBaM1xIWkAQWoAUm + 7I30sgc8NozXEgAZHBUAFQAVEAAAFvDciIAIFdIBFprV3/8HFXYAJoyT9LIHHBUMGTUGCAAZGApy + b29mX3NoYXBlFQwWjNcSFpoNFsYIJoyT9LIHPDas1hIoB3NhbHRib3gYBGZsYXQAGRwVABUAFRAA + ABbC3oiACBXYARaQ1t//BxW+AQAm0pv0sgccFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWjNcS + FpAEFqAFJtKb9LIHPDaM1xIAGRwVABUAFRAAABaa4IiACBXSARbO19//BxV2ACbyoPSyBxwVDBk1 + BggAGRgQcm9vZl9vcmllbnRhdGlvbhUMFozXEhaQBBagBSbyoPSyBzw2jNcSABkcFQAVABUQAAAW + 7OGIgAgV0gEWxNjf/wcVdgAmkqb0sgccFQwZNQYIABkYCnJvb2ZfY29sb3IVDBaM1xIWsAQWwAUm + kqb0sgc8GAcjRkYwMDAwGAcjRkYwMDAwForXEigHI0ZGMDAwMBgHI0ZGMDAwMAAZHBUAFQAVEAAA + Fr7jiIAIFdIBFrrZ3/8HFZIBACbSq/SyBxwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBaM1xIWwgQW + 0gUm0qv0sgc8GAgAAAAAAAD0PxgImpmZmZmZ6T8WiNcSKAgAAAAAAAD0PxgImpmZmZmZ6T8AGRwV + ABUAFRAAABaQ5YiACBXUARbM2t//BxWWAQAWrsGeGxaM1xImmNadpAcWjNvWDhSCAQAZ/CYmpLH0 + sgccFQwZNQYIABkYAmlkFQwWhIkVFqrK9gUWtpXQASaksfSyBzw2ACggMDhiYjJjNDQ2NWI3NWZm + ZjAyMDBjOGRhNTAyMzgyNmIYIDA4YmIyYzQwMDEwNWNmZmYwMjAwZTk0YmQ2MjIwNGM5ABkcFQAV + ABUSAAAW5OaIgAgVkAIW4tvf/wcV3gkAJtrGxLQHHBUMGTUGCAAZGAhnZW9tZXRyeRUMFoSJFRas + zcoRFtjaqgom2sbEtAc8NgAokwIAAAAABgAAAAIAAAAAAwAAAAEAAAAKwFHfOPw1cCTAQISZBsyi + 28BR3y2PGePXwECEoBGC30PAUd8tMZFyhMBAhJ5nXrPqwFHfLM9r437AQIScnVoYesBR3zI65a8c + wECEmVTQO+3AUd8yXAg+k8BAhJnuUy9SwFHfM1Usgj/AQISZV1R6rMBR3zM1t3HywECEmMVeQ4LA + Ud84ROrrnMBAhJW0MctUwFHfOPw1cCTAQISZBsyi2wAAAAADAAAAAQAAAAXAUd84FK7jrsBAhJTS + invvwFHfLJyrnNHAQISbgPpmY8BR3yvxH5JswECEmEXcgyPAUd83aLd5fsBAhJGWldkbwFHfOBSu + 467AQISU0op77xhNAAAAAAMAAAABAAAABMBR2ZUSkAvQwECBTHqMGhzAUdmVJQHSF8BAgUt+8T0e + wFHZlayOmJjAQIFMmppC5MBR2ZUSkAvQwECBTHqMGhwAGRwVABUAFSgAABb06IiACBXcBBbA5d// + BxW+KQAm+sH6vgccFQgZNQYIBBkoBGJib3gEeG1pbhUMFoSJFRbIozYWuNExJvrB+r4HJrKh774H + HBgEA7yOwhgEOk6PwhYAKAQDvI7CGAQ6To/CABksFQQVBBUCABUAFQQVEgAAFtDtiIAIFZACFv6O + 4P8HFe4BACaulqy/BxwVCBk1BggEGSgEYmJveAR4bWF4FQwWhIkVFr6nNhay1DEmrpasvwcm6vKg + vwccGAT4u47CGAQqTo/CFgAoBPi7jsIYBCpOj8IAGSwVBBUEFQIAFQAVBBUSAAAW4O+IgAgVkAIW + 7JDg/wcV7gEAJv6L278HHBUIGTUGCAQZKARiYm94BHltaW4VDBaEiRUWrtgxFriALib+i9u/Byac + x9K/BxwYBGS1A8IYBGIwBMIWACgEZLUDwhgEYjAEwgAZLBUEFQQVAgAVABUEFRIAABbw8YiACBWQ + AhbakuD/BxXuAQAm/IqJwAccFQgZNQYIBBkoBGJib3gEeW1heBUMFoSJFRa+1jEW/v4tJvyKicAH + JtTHgMAHHBgEU7UDwhgE+y8EwhYAKARTtQPCGAT7LwTCABksFQQVBBUCABUAFQQVEgAAFoD0iIAI + FZACFsiU4P8HFe4BACaSx67ABxwVAhk1BggEGRgHdmVyc2lvbhUMFoSJFRbIBRb8BiaSx67ABybS + xq7ABxwYBAAAAAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaQ9oiACBXs + ARa2luD/BxXuAQAmjs6uwAccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkV + DBaEiRUW2AYWjAgmjs6uwAcmzs2uwAccGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABb894iA + CBXsARakmOD/BxVeACae167ABxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0 + FQwWhIkVFr6eBRbKuwMmnteuwAcm2tWuwAccNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVu + IEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFRIAABbo+YiACBX+ARaCmeD/BxXCBQAmpJGywAccFQwZ + JQYAGUgHc291cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWhIkVFqrakAMWoLl6JqSRssAH + PDYAKAx3OTk2NzE4OTA2QDEYDDAwMDBmZTEwZmJhMQAZHBUAFQAVEgAAFub7iIAIFZACFsSe4P8H + FY4EACbWzq/BBxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFoSJ + FRauySoWkPYMJtbOr8EHJsTKrMEHHDYAKBgyMDI0LTExLTI5VDE4OjMwOjAyLjAwMFoYGDIwMDAt + MDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRIAABb2/YiACBWKAhbSouD/BxW+BwAm + yuC6wQccFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFoSJFRbGth0W + 2IUaJsrgusEHJtTAucEHHBgI5x2n6Egu7z8YCM3MzMzMzOQ/FsS4CCgI5x2n6Egu7z8YCM3MzMzM + zOQ/ABksFQQVBBUCABUAFQQVEgAAFoCAiYAIFZACFpCq4P8HFZgDACaUx9PBBxwVAhk1BggEGRgF + bGV2ZWwVDBaEiRUWnAkWxgomlMfTwQcmrMbTwQccGAQFAAAAGAT+////FqCIFSgEBQAAABgE/v// + /wAZLBUEFQQVAgAVABUEFRIAABaQgomACBX2ARaoreD/BxXyAQAmqtPTwQccFQwZNQYIBBkYB3N1 + YnR5cGUVDBaEiRUWnrEBFtqMASaq09PBByby0NPBBxw2gLgTKA50cmFuc3BvcnRhdGlvbhgMYWdy + aWN1bHR1cmFsABksFQQVBBUCABUAFQQVEgAAFoaEiYAIFf4BFpqv4P8HFcADACbG4tTBBxwVDBk1 + BggEGRgFY2xhc3MVDBaEiRUWusgBFsacASbG4tTBBybM3dTBBxw22rwTKAl3YXJlaG91c2UYCmFw + YXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUSAAAWhIaJgAgV/gEW2rLg/wcV2gMAJpL61cEHHBUKGTUG + CAAZGAZoZWlnaHQVDBaEiRUW4AoW2ggmkvrVwQc8GAgAAAAAAAA5QBgIAAAAAAAAAEAWuogVKAgA + AAAAAAA5QBgIAAAAAAAAAEAAGRwVABUAFRIAABaCiImACBXwARa0tuD/BxXiAQAm7ILWwQccFQwZ + NQYIABkoBW5hbWVzB3ByaW1hcnkVDBaEiRUWtOAFFtLtAibsgtbBBzw2yusUKBfDgXJlYSBTYWx1 + ZCBWYWxwYXJhw61zbxgaMSBDb21pc2Fyw61hIFZpw7FhIGRlbCBNYXIAGRwVABUAFRIAABbyiYmA + CBX+ARaWuOD/BxXKBQAmvvDYwQccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkV + DBaMiRUWjlEWlDYmvvDYwQc8NvqIFSgCZXMYAmVuABkcFQAVABUSAAAW8IuJgAgV/gEW4L3g/wcV + mgEAJtKm2cEHHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBaMiRUW5GcW + 3D4m0qbZwQc8NvqIFSgKU3RhdGUgQmFuaxgMQmFuY28gRXN0YWRvABkcFQAVABUSAAAW7o2JgAgV + /gEW+r7g/wcVvAMAJqrm2cEHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJp + YW50FQwWlIkVFtBjFsY7Jqrm2cEHJq7l2cEHHDbOiBUoBXNob3J0GAlhbHRlcm5hdGUAGSwVBBUE + FQIAFQAVBBUSAAAW7I+JgAgV/gEWtsLg/wcV4AIAJvSg2sEHHBUMGSUGABlYBW5hbWVzBXJ1bGVz + BGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFpSJFRa6YhamOib0oNrBBzw2kIkVKAJlcxgCZW4AGRwV + ABUAFRIAABbqkYmACBX+ARaWxeD/BxWKAQAmyuLawQccFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50BXZhbHVlFQwWlIkVFqBtFqhCJsri2sEHJprb2sEHHDbOiBUoA1RORRgZQmFuY28g + ZGVsIEVzdGFkbyBkZSBDaGlsZQAZLBUEFQQVAgAVABUEFRIAABbok4mACBX+ARagxuD/BxWYBQAm + wp3bwQccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVt + ZW50FQwWlIkVFqhiFo46JsKd28EHPDaUiRUAGRwVABUAFRIAABbmlYmACBX+ARa4y+D/BxWCAQAm + 0NfbwQccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaUiRUWomIWljom + 0NfbwQc8NpSJFQAZHBUAFQAVEgAAFuSXiYAIFf4BFrrM4P8HFYIBACbmkdzBBxwVABk1BggAGRgJ + aGFzX3BhcnRzFQwWhIkVFvbVAhaQCCbmkdzBBzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEgAAFuKZ + iYAIFfABFrzN4P8HFYIBACb2mdzBBxwVABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBaEiRUW9tUC + FpYHJvaZ3MEHPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAW0puJgAgV7AEWvs7g/wcVggEAJqSi + 3MEHHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWhIkVFqqcARb8gQEmpKLcwQcmjKHcwQccGAQeAAAA + GAQBAAAAFviOFCgEHgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABa+nYmACBX+ARbAz+D/BxWS + AgAmiKPdwQccFQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaEiRUW9gQWmAYmiKPd + wQc8GAQCAAAAGAQBAAAAFoCJFSgEAgAAABgEAQAAAAAZHBUAFQAVEgAAFryfiYAIFewBFtLR4P8H + FZIBACagqd3BBxwVChk1BggAGRgKbWluX2hlaWdodBUMFoSJFRbSBBb0BSagqd3BBzw2hIkVABkc + FQAVABUSAAAWqKGJgAgV7AEW5NLg/wcVggEAJpSv3cEHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBaE + iRUW0gQW9AUmlK/dwQc8NoSJFQAZHBUAFQAVEgAAFpSjiYAIFewBFubT4P8HFYIBACaItd3BBxwV + DBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWhIkVFtIEFvQFJoi13cEHPDaEiRUAGRwVABUAFRIAABaA + pYmACBXsARbo1OD/BxWCAQAm/LrdwQccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFoSJFRbW + BRb4Bib8ut3BBzw2/IgVKAVtZXRhbBgMY2VtZW50X2Jsb2NrABkcFQAVABUSAAAW7KaJgAgV7gEW + 6tXg/wcV2AEAJvTB3cEHHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWhIkVFtIEFvQFJvTB3cEH + PDaEiRUAGRwVABUAFRIAABbaqImACBXsARbC1+D/BxWCAQAm3MndwQccFQwZNQYIBBkYCnJvb2Zf + c2hhcGUVDBaEiRUWpCAWuhwm3MndwQcm6MfdwQccNqL1FCgIc2tpbGxpb24YBGRvbWUAGSwVBBUE + FQIAFQAVBBUSAAAWxqqJgAgV+AEWxNjg/wcVxAIAJqLk3cEHHBUKGTUGCAAZGA5yb29mX2RpcmVj + dGlvbhUMFoSJFRbSBBb0BSai5N3BBzw2hIkVABkcFQAVABUSAAAWvqyJgAgV7AEWiNvg/wcVggEA + Jpbq3cEHHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWhIkVFtIEFvQFJpbq3cEHPDaEiRUA + GRwVABUAFRIAABaqromACBXsARaK3OD/BxWCAQAmivDdwQccFQwZNQYIABkYCnJvb2ZfY29sb3IV + DBaEiRUW0gQW9AUmivDdwQc8NoSJFQAZHBUAFQAVEgAAFpawiYAIFewBFozd4P8HFYIBACb+9d3B + BxwVChk1BggAGRgLcm9vZl9oZWlnaHQVDBaEiRUW0gQW9AUm/vXdwQc8NoSJFQAZHBUAFQAVEgAA + FoKyiYAIFewBFo7e4P8HFYIBABbIzYQdFoSJFSaksfSyBxbOyukOFIQBABn8Jiby+93BBxwVDBk1 + BggAGRgCaWQVDBaclRUWioH6BRaq1tYBJvL73cEHPDYAKCAwOGJiMmM0YzZlZGI2ZmZmMDIwMGYy + ZTg1Zjk5M2U1ZRggMDhiYjJjNDAwMDA2NGZmZjAyMDA0NjA4ZDIzYmYxY2EAGRwVABUAFRIAABbu + s4mACBWQAhaQ3+D/BxXeCQAmnNK0wwccFQwZNQYIABkYCGdlb21ldHJ5FQwWnJUVFu7bsBEW5I6i + Ciac0rTDBzw2ACjZBQAAAAADAAAABAAAAB3AUeIB2mAzRsBAY7iq1ti/wFHiAhw58mrAQGO8myZh + lMBR4gKlzK3DwEBjvIH77iPAUeICss1HRsBAY71JogqBwFHiAmPy7qDAQGO9V+TDZMBR4gJ4FOSU + wEBjvoyYKVfAUeIC4VvQCsBAY755TPL4wFHiAu3xCcPAQGO/PZgRA8BR4gKMNtqIwEBjv1AMh87A + UeICwDlAk8BAY8Js93ogwFHiAlYblYjAQGPCgEKwf8BR4gJj8u6gwEBjw1YrhcDAUeIB8kiHWMBA + Y8NrJDtJwFHiAeHs74LAQGPCbPd6IMBR4gFKF3tHwEBjwoimLE/AUeIBWnMTHcBAY8OIgGyiwFHi + AQGHv33AQGPDmHCkrsBR4gD08oXEwEBjwtkuBB/AUeH++x1CMMBAY8M3IdU9wFHh/wbbvFTAQGPD + 7te5kMBR4f5ou6s8wEBjxAwz6unAUeH+XWiQ48BAY8NZhoQTwFHh/G9Rx3PAQGPDtPYWcsBR4fxl + QMx5wEBjwxgYJLrAUeH1U2kzoMBAY8RmzL2zwFHh9MU5WpXAQGO76U+6UsBR4f03Y0OcwEBjulhW + AmvAUeH9KYvqhMBAY7mJIynRwFHiAdpgM0bAQGO4qtbYvwAAAAXAUeH5DMa34MBAY7+5vtMPwFHh + 9ycTakDAQGPAC/QqCcBR4fc8DB/JwEBjwWxGejjAUeH5Ib9tacBAY8EZOmOpwFHh+QzGt+DAQGO/ + ub7TDwAAAAXAUeH7rs0HhcBAY715crKlwFHh+utYqQ/AQGO9miniUsBR4fsjjM0CwEBjwTdtVJfA + UeH75pXLr8BAY8EV32VWwFHh+67NB4XAQGO9eXKypQAAAAXAUeIAKfFrEsBAY7u+h4+swFHh/xbL + 9GDAQGO7+hax88BR4f9yO4a/wEBjwKcknJfAUeIAhWD9ccBAY8BsbDnlwFHiACnxaxLAQGO7voeP + rBhNAAAAAAMAAAABAAAABMBRz8zkNeUowEB0jI762+LAUc/Mkp6QqsBAdI2hmHOVwFHPzCZpa8nA + QHSNRhjcJMBRz8zkNeUowEB0jI762+IAGRwVABUAFSgAABb+tYmACBXcBBbu6OD/BxW+KQAmgsTk + zQccFQgZNQYIBBkoBGJib3gEeG1pbhUMFpyVFRbc+jsWots0JoLE5M0HJoDh1s0HHBgEBWKOwhgE + 2hePwhYAKAQFYo7CGATaF4/CABksFQQVBBUCABUAFQQVEgAAFtq6iYAIFZACFqyS4f8HFe4BACaK + n5nOBxwVCBk1BggEGSgEYmJveAR4bWF4FQwWnJUVFvr6Oxae2jQmip+ZzgcmoryLzgccGAT0YY7C + GATLF4/CFgAoBPRhjsIYBMsXj8IAGSwVBBUEFQIAFQAVBBUSAAAW6ryJgAgVkAIWmpTh/wcV7gEA + Jujg1c4HHBUIGTUGCAQZKARiYm94BHltaW4VDBaclRUW8NJHFuTxPCbo4NXOBybAlsDOBxwYBArI + AsIYBD4wBMIWACgECsgCwhgEPjAEwgAZLBUEFQQVAgAVABUEFRIAABb6vomACBWQAhaIluH/BxXu + AQAmlNWSzwccFQgZNQYIBBkoBGJib3gEeW1heBUMFpyVFRac1kcWqPM8JpTVks8HJqSI/c4HHBgE + 78cCwhgE+S8EwhYAKATvxwLCGAT5LwTCABksFQQVBBUCABUAFQQVEgAAForBiYAIFZACFvaX4f8H + Fe4BACaM/LnPBxwVAhk1BggEGRgHdmVyc2lvbhUMFpyVFRbIBRb8BiaM/LnPBybM+7nPBxwYBAAA + AAAYBAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRIAABaaw4mACBXsARbkmeH/BxXu + AQAmiIO6zwccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBaclRUW1gYW + iggmiIO6zwcmyIK6zwccGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRIAABaGxYmACBXsARbSm+H/ + BxVeACaWjLrPBxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWnJUVFsCf + BRbGhwMmloy6zwcm0oq6zwccNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5n + cwAZLBUEFQQVAgAVABUEFRIAABbyxomACBX+ARawnOH/BxXCBQAmmJK9zwccFQwZJQYAGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWnJUVFv7anAMWsPt/JpiSvc8HPDYAKAx3OTk4 + NTg0MDY4QDEYDDAwMDA0ZTY5YTNiYgAZHBUAFQAVEgAAFvDIiYAIFZACFvKh4f8HFY4EACaA3L3Q + BxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFpyVFRaEnxgWlvIG + JoDcvdAHJsiNvdAHHDYAKBgyMDI0LTExLTIwVDA1OjE4OjMxLjAwMFoYGDIwMDAtMDEtMDFUMDA6 + MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRIAABaAy4mACBX+ARaApuH/BxW+BwAm4qTF0AccFQoZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFpyVFRaq1yAW/PkcJuKkxdAH + Jt7/w9AHHBgIgQTFjzF37z8YCM3MzMzMzOQ/FrazBigIgQTFjzF37z8YCM3MzMzMzOQ/ABksFQQV + BBUCABUAFQQVEgAAFv7MiYAIFZACFr6t4f8HFZADACai+uDQBxwVAhk1BggEGRgFbGV2ZWwVDBac + lRUW+AYWrAgmovrg0Acm2vng0AccGAQBAAAAGAT/////FuaUFSgEAQAAABgE/////wAZLBUEFQQV + AgAVABUEFRIAABaOz4mACBXwARbOsOH/BxWCAgAmrITh0AccFQwZNQYIBBkYB3N1YnR5cGUVDBac + lRUW/DYW+i0mrITh0AcmhoLh0AccNsjvFCgOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZ + LBUEFQQVAgAVABUEFRIAABb+0ImACBX+ARbQsuH/BxXcAwAmtLTh0AccFQwZNQYIBBkYBWNsYXNz + FQwWnJUVFqw4FowwJrS04dAHJoCw4dAHHDbm8BQoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUE + FQQVAgAVABUEFRIAABb80omACBX+ARastuH/BxXCAwAmjODh0AccFQoZNQYIABkYBmhlaWdodBUM + FpyVFRb6ChbSCCaM4OHQBzwYCAAAAAAAgEhAGAgAAAAAAAAAQBbKlBUoCAAAAAAAgEhAGAgAAAAA + AAAAQAAZHBUAFQAVEgAAFvrUiYAIFfABFu654f8HFYICACbe6OHQBxwVDBk1BggAGSgFbmFtZXMH + cHJpbWFyeRUMFpyVFRaiaRa0Ribe6OHQBzw2qJEVKAhhIEN1ZW50YRgbMWVyYSBDb21wYcOxw61h + IGRlIEJvbWJlcm9zABkcFQAVABUSAAAW6taJgAgV/gEW8Lvh/wcVvgQAJpKv4tAHHBUMGSUGABlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWnJUVFpIWFqITJpKv4tAHPDaclRUAGRwVABUA + FRIAABbo2ImACBX+ARauwOH/BxWCAQAmtMLi0AccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92 + YWx1ZQV2YWx1ZRUMFpyVFRacGRb+Eya0wuLQBzw2nJUVABkcFQAVABUSAAAW5tqJgAgV/gEWsMHh + /wcVggEAJrLW4tAHHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJpYW50FQwW + npUVFqQaFooVJrLW4tAHPDaUlRUoCG9mZmljaWFsGAlhbHRlcm5hdGUAGRwVABUAFRIAABbk3ImA + CBX+ARaywuH/BxWIAgAmvOvi0AccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxh + bmd1YWdlFQwWnpUVFqgZFpoUJrzr4tAHPDaelRUAGRwVABUAFRIAABbi3omACBX+ARa6xOH/BxWC + AQAm1v/i0AccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwWnpUVFsQb + FpgWJtb/4tAHPDaUlRUoIUNlbnRybyBkZSBTYWx1ZCBGYW1pbGlhciBRdWludGVybxgZQmFuY28g + ZGVsIEVzdGFkbyBkZSBDaGlsZQAZHBUAFQAVEgAAFuDgiYAIFf4BFrzF4f8HFYIEACbulePQBxwV + ChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBae + lRUWqhkWnBQm7pXj0Ac8Np6VFQAZHBUAFQAVEgAAFt7iiYAIFf4BFr7J4f8HFYIBACaKquPQBxwV + DBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFp6VFRaoGRaaFCaKquPQBzw2 + npUVABkcFQAVABUSAAAW3OSJgAgV/gEWwMrh/wcVggEAJqS+49AHHBUAGTUGCAAZGAloYXNfcGFy + dHMVDBaclRUWuNcCFpYHJqS+49AHPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAW2uaJgAgV7AEW + wsvh/wcVggEAJrrF49AHHBUAGTUGCAAZGA5pc191bmRlcmdyb3VuZBUMFpyVFRa41wIWlgcmusXj + 0Ac8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRIAABbG6ImACBXsARbEzOH/BxWCAQAm+s3j0AccFQIZ + NQYIBBkYCm51bV9mbG9vcnMVDBaclRUW5BoWnBkm+s3j0Acm0Mzj0AccGAQYAAAAGAQBAAAAFuyC + FSgEGAAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRIAABay6omACBX6ARbGzeH/BxWSAgAm7OXj0Acc + FQIZNQYIABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaclRUW0gQW9AUm7OXj0Ac8NpyVFQAZ + HBUAFQAVEgAAFqzsiYAIFewBFtjP4f8HFYIBACbg6+PQBxwVChk1BggAGRgKbWluX2hlaWdodBUM + FpyVFRbSBBb0BSbg6+PQBzw2nJUVABkcFQAVABUSAAAWmO6JgAgV7AEW2tDh/wcVggEAJtTx49AH + HBUCGTUGCAAZGAltaW5fZmxvb3IVDBaclRUW0gQW9AUm1PHj0Ac8NpyVFQAZHBUAFQAVEgAAFoTw + iYAIFewBFtzR4f8HFYIBACbI9+PQBxwVDBk1BggAGRgMZmFjYWRlX2NvbG9yFQwWnJUVFtIEFvQF + Jsj349AHPDaclRUAGRwVABUAFRIAABbw8YmACBXsARbe0uH/BxWCAQAmvP3j0AccFQwZNQYIABkY + D2ZhY2FkZV9tYXRlcmlhbBUMFpyVFRbSBBb0BSa8/ePQBzw2nJUVABkcFQAVABUSAAAW3POJgAgV + 7AEW4NPh/wcVggEAJrCD5NAHHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWnJUVFtIEFvQFJrCD + 5NAHPDaclRUAGRwVABUAFRIAABbI9YmACBXsARbi1OH/BxWCAQAmpInk0AccFQwZNQYIABkYCnJv + b2Zfc2hhcGUVDBaclRUWrBwW2AkmpInk0Ac8No6TFSgGaGlwcGVkGAZnYWJsZWQAGRwVABUAFRIA + ABa094mACBXuARbk1eH/BxXiAQAm/JLk0AccFQoZNQYIABkYDnJvb2ZfZGlyZWN0aW9uFQwWnJUV + FtIEFvQFJvyS5NAHPDaclRUAGRwVABUAFRIAABai+YmACBXsARbG1+H/BxWCAQAm8Jjk0AccFQwZ + NQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBaclRUW0gQW9AUm8Jjk0Ac8NpyVFQAZHBUAFQAVEgAA + Fo77iYAIFewBFsjY4f8HFYIBACbknuTQBxwVDBk1BggAGRgKcm9vZl9jb2xvchUMFpyVFRbSBBb0 + BSbknuTQBzw2nJUVABkcFQAVABUSAAAW+vyJgAgV7AEWytnh/wcVggEAJtik5NAHHBUKGTUGCAAZ + GAtyb29mX2hlaWdodBUMFpyVFRbSBBb0BSbYpOTQBzw2nJUVABkcFQAVABUSAAAW5v6JgAgV7AEW + zNrh/wcVggEAFuSolh0WnJUVJvL73cEHFtquhg8UhgEAGfwmJsyq5NAHHBUMGTUGCAAZGAJpZBUM + FrjCExau3L4FFqCqxwEmzKrk0Ac8NgAoIDA4YmIyZTI2ZWM5MjRmZmYwMjAwN2MyOGRiNTVmNTFm + GCAwOGJiMmM0MDRkOWE5ZmZmMDIwMDE0ZTZkODVhNGU2MgAZHBUAFQAVEAAAFtKAioAIFfIBFs7b + 4f8HFdYIACbs1KvSBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBa4whMWspObEBbE+9AJJuzUq9IHPDYA + KMMBAAAAAAYAAAACAAAAAAMAAAABAAAABcBRzIt0e0VvwEBmI1C42MPAUcyKLY9xqsBAZiQC5tIv + wFHMidWRdt3AQGYiNj3wncBRzIscfT9IwEBmIYQP/pzAUcyLdHtFb8BAZiNQuNjDAAAAAAMAAAAB + AAAABcBRzIrqATOrwEBmIHvDm2HAUcyIFyUOgMBAZiIFvRn1wFHMh+qZAtvAQGYhHIXtZcBRzIq9 + dRtawEBmH5KMd+PAUcyK6gEzq8BAZiB7w5thGE0AAAAAAwAAAAEAAAAEwFHLcg8d3GrAQGP50iiS + McBRy3HOHAImwEBj+LDHtC7AUctyjiXcaMBAY/mAs80HwFHLcg8d3GrAQGP50iiSMQAZHBUAFQAV + JAAAFsSCioAIFaAEFqTk4f8HFa4lACaAp4rcBxwVCBk1BggEGSgEYmJveAR4bWluFQwWuMITFqLU + OBbqpzEmgKeK3AcmsND82wccGAQOCI7CGARh847CFgAoBA4IjsIYBGHzjsIAGSwVBBUEFQIAFQAV + BBUQAAAW5IaKgAgV8gEW0oni/wcV1gEAJpzRu9wHHBUIGTUGCAQZKARiYm94BHhtYXgVDBa4whMW + qtg4FrKoMSac0bvcByaa+K3cBxwYBPIHjsIYBFTzjsIWACgE8geOwhgEVPOOwgAZLBUEFQQVAgAV + ABUEFRAAABbWiIqACBXyARaoi+L/BxXWAQAmpsD43AccFQgZNQYIBBkoBGJib3gEeW1pbhUMFrjC + Exb6rEkW4Nk9JqbA+NwHJsyg39wHHBgEC2ABwhgEDTAEwhYAKAQLYAHCGAQNMATCABksFQQVBBUC + ABUAFQQVEAAAFsiKioAIFfIBFv6M4v8HFdYBACagmrbdBxwVCBk1BggEGSgEYmJveAR5bWF4FQwW + uMITFqitSRa+2j0moJq23QcmrPqc3QccGATwXwHCGATzLwTCFgAoBPBfAcIYBPMvBMIAGSwVBBUE + FQIAFQAVBBUQAAAWuoyKgAgV8gEW1I7i/wcV1gEAJqrV2t0HHBUCGTUGCAQZGAd2ZXJzaW9uFQwW + uMITFvwEFp4GJqrV2t0HJurU2t0HHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUC + ABUAFQQVEAAAFqyOioAIFdIBFqqQ4v8HFdYBACbI29rdBxwVDBklBgQZSAdzb3VyY2VzBGxpc3QH + ZWxlbWVudAhwcm9wZXJ0eRUMFrjCExb+BRagBybI29rdByaI29rdBxwYABgAFgAoABgAABksFQQV + BBUCABUAFQQVEAAAFv6PioAIFdIBFoCS4v8HFVYAJuzj2t0HHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50B2RhdGFzZXQVDBa4whMW1u8EFvb7Aibs49rdByao4trdBxw2ACgNT3BlblN0cmVl + dE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFtCRioAIFeIBFtaS + 4v8HFfYEACae3t3dBxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBa4 + whMWsNz6AhbE/3cmnt7d3Qc8NgAoDHc5ODkyNDk5NTdAMRgMMDAwMDZkMjNkZDFjABkcFQAVABUQ + AAAWspOKgAgV8gEWzJfi/wcV1gMAJqSs1t4HHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + C3VwZGF0ZV90aW1lFQwWuMITFuDRFha22QYmpKzW3gcm4t3V3gccNgAoGDIwMjQtMTEtMjNUMTI6 + Mjc6NTUuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFqSV + ioAIFeIBFqKb4v8HFdYGACbW2d3eBxwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25m + aWRlbmNlFQwWuMITFpzsHRbmqhom1tnd3gcmmLfc3gccGAgGgZVDi2zvPxgIzczMzMzM5D8W0qEG + KAgGgZVDi2zvPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWhpeKgAgV8gEW+KHi/wcV5gIA + Js7i9t4HHBUCGTUGCAQZGAVsZXZlbBUMFrjCExb0BhaECCbO4vbeByb+4fbeBxwYBAEAAAAYBP// + //8WvsETKAQBAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFviYioAIFdYBFt6k4v8HFcYBACam + 7PbeBxwVDBk1BggEGRgHc3VidHlwZRUMFrjCExaYQhbcOCam7PbeByaC6vbeBxw20owTKA50cmFu + c3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFs6aioAIFeIBFqSm4v8H + FaIDACaSp/feBxwVDBk1BggEGRgFY2xhc3MVDBa4whMW8kQW8jsmkqf33gcm3qL33gccNpCOEygJ + d2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFrCcioAIFeIBFsap4v8HFZYD + ACbQ3vfeBxwVChk1BggAGRgGaGVpZ2h0FQwWuMITFp4GFoIHJtDe994HPBgIAAAAAAAAOUAYCAAA + AAAAAABAFqDCEygIAAAAAAAAOUAYCAAAAAAAAABAABkcFQAVABUQAAAWkp6KgAgV2AEW3Kzi/wcV + lgIAJtLl994HHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWuMITFryHARaoVybS5ffeBzw2jr0T + KANpc3QYIzNyYSBDb21wYcOxw61hIEJvbWJlcm9zIE1haXRlbmNpbGxvABkcFQAVABUQAAAW6p+K + gAgV4gEW8q7i/wcVnAUAJvq8+N4HHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5 + FQwWwMITFqgYFpQUJvq8+N4HPDauwhMoAmVzGAJlbgAZHBUAFQAVEAAAFsyhioAIFeIBFo604v8H + FYYBACaO0fjeBxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWwMITFrAd + FqgWJo7R+N4HPDauwhMoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFq6jioAI + FeIBFpS14v8HFdoBACa25/jeBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFy + aWFudBUMFszCExbWHxayFya25/jeBzw2nsITKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQ + AAAWkKWKgAgV4gEW7rbi/wcVwAIAJuj++N4HHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAhsYW5ndWFnZRUMFszCExbsGxbAFSbo/vjeBzw2wMITKAJlcxgCZW4AGRwVABUAFRAAABby + poqACBXiARauueL/BxV+ACaolPneBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQF + dmFsdWUVDBbMwhMWqCcW+hsmqJT53gc8Np7CEygqU2VydmljaW8gZGUgQXRlbmNpw7NuIFByaW1h + cmlhIGRlIFVyZ2VuY2lhGB9CYW5jbyBCaWxiYW8gVml6Y2F5YSBBcmdlbnRhcmlhABkcFQAVABUQ + AAAW1KiKgAgV4gEWrLri/wcV5AYAJqKw+d4HHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFszCExayGxaeFSaisPneBzw2zMITABkcFQAVABUQ + AAAWtqqKgAgV4gEWkMHi/wcVdgAmwMX53gccFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVt + ZW50BHNpZGUVDBbMwhMWohsWnBUmwMX53gc8NszCEwAZHBUAFQAVEAAAFpisioAIFeIBFobC4v8H + FXYAJtza+d4HHBUAGTUGCAAZGAloYXNfcGFydHMVDBa4whMWyLwCFrAGJtza+d4HPBgBABgBABYA + KAEAGAEAABkcFQAVABUQAAAW+q2KgAgV0gEW/MLi/wcVdgAmjOH53gccFQAZNQYIABkYDmlzX3Vu + ZGVyZ3JvdW5kFQwWuMITFsi8AhawBiaM4fneBzwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFsyv + ioAIFdIBFvLD4v8HFXYAJrTo+d4HHBUCGTUGCAQZGApudW1fZmxvb3JzFQwWuMITFqYNFpoOJrTo + +d4HJrzn+d4HHBgECgAAABgEAQAAABbsvRMoBAoAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAW + nrGKgAgV4AEW6MTi/wcV9gEAJtb1+d4HHBUCGTUGCAAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5k + FQwWuMITFpAEFqAFJtb1+d4HPDa4whMAGRwVABUAFRAAABb+soqACBXSARbexuL/BxV2ACb2+vne + BxwVChk1BggAGRgKbWluX2hlaWdodBUMFrjCExaQBBagBSb2+vneBzw2uMITABkcFQAVABUQAAAW + 0LSKgAgV0gEW1Mfi/wcVdgAmloD63gccFQIZNQYIABkYCW1pbl9mbG9vchUMFrjCExaQBBagBSaW + gPreBzw2uMITABkcFQAVABUQAAAWoraKgAgV0gEWysji/wcVdgAmtoX63gccFQwZNQYIABkYDGZh + Y2FkZV9jb2xvchUMFrjCExaQBBagBSa2hfreBzw2uMITABkcFQAVABUQAAAW9LeKgAgV0gEWwMni + /wcVdgAmoIv63gccFQwZNQYIBBkYD2ZhY2FkZV9tYXRlcmlhbBUMFrjCExboBBaKBiagi/reBybW + ivreBxwYBW1ldGFsGAVtZXRhbBawwhMoBW1ldGFsGAVtZXRhbAAZLBUEFQQVAgAVABUEFRAAABbG + uYqACBXSARa2yuL/BxWKAQAm4JD63gccFQwZNQYIABkYDXJvb2ZfbWF0ZXJpYWwVDBa4whMWkAQW + oAUm4JD63gc8NrjCEwAZHBUAFQAVEAAAFpi7ioAIFdIBFsDL4v8HFXYAJoCW+t4HHBUMGTUGCAAZ + GApyb29mX3NoYXBlFQwWuMITFqoFFuYFJoCW+t4HPBgGZ2FibGVkGAZnYWJsZWQWrMITKAZnYWJs + ZWQYBmdhYmxlZAAZHBUAFQAVEAAAFuq8ioAIFdQBFrbM4v8HFY4BACbmm/reBxwVChk1BggAGRgO + cm9vZl9kaXJlY3Rpb24VDBa4whMWkAQWoAUm5pv63gc8NrjCEwAZHBUAFQAVEAAAFr6+ioAIFdIB + FsTN4v8HFXYAJoah+t4HHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWuMITFpAEFqAFJoah + +t4HPDa4whMAGRwVABUAFRAAABaQwIqACBXSARa6zuL/BxV2ACaIp/reBxwVDBk1BggEGRgKcm9v + Zl9jb2xvchUMFrjCExaABRaiBiaIp/reByampvreBxw2ssITKAcjRkYwMDAwGAcjNzc4ODk5ABks + FQQVBBUCABUAFQQVEAAAFuLBioAIFdIBFrDP4v8HFZIBACbIrPreBxwVChk1BggAGRgLcm9vZl9o + ZWlnaHQVDBa4whMWkAQWoAUmyKz63gc8NrjCEwAZHBUAFQAVEAAAFrTDioAIFdIBFsLQ4v8HFXYA + FoCtmxsWuMITJsyq5NAHFpyHlg4UiAEAGfwmJuix+t4HHBUMGTUGCAAZGAJpZBUMFoyxExb867kF + FqK0yAEm6LH63gc8NgAoIDA4YmIyZTM3OWVkYjVmZmYwMjAwZDJhZThmNDcxZmFlGCAwOGJiMmM0 + ODAwZDkzZmZmMDIwMDBmN2VlYTNiMGQ3ZgAZHBUAFQAVEAAAFobFioAIFfIBFrjR4v8HFdYIACaK + 5sLgBxwVDBk1BggAGRgIZ2VvbWV0cnkVDBaMsRMWqoqBEBb2x8QJJormwuAHPDYAKO0DAAAAAAMA + AAAFAAAACcBRrlvaG2npwEBgWubWY0/AUa5d5mUkR8BAYGX5WRzSwFGuWovSMLrAQGBnuvo8csBR + rloLebDGwEBgZQU9VqPAUa5XOMv5aMBAYGZ/kNnXwFGuVucCAjnAQGBkxKW23sBRrlNVfQoXwEBg + ZqLMSEPAUa5SG1XG3MBAYGAA8ZeHwFGuW9obaenAQGBa5tZjTwAAAAXAUa5cW0qpccBAYGPVkm4s + wFGuW25QP7PAQGBkRE026sBRrludSihCwEBgZV7/adjAUa5cidkyNsBAYGTxG2CvwFGuXFtKqXHA + QGBj1ZJuLAAAAAXAUa5bPur3WsBAYF6yPP6OwFGuWVwnSEPAQGBfh08UOsBRrlm94Xd/wEBgYfkZ + W/LAUa5boKUmlsBAYGEjMIaxwFGuWz7q91rAQGBesjz+jgAAAAXAUa5YIgAFCMBAYGBQoq/DwFGu + VvRt+4bAQGBgz02wjcBRrldKabCewEBgYxFHUCHAUa5Yd5BaVsBAYGKSnE9WwFGuWCIABQjAQGBg + UKKvwwAAAAXAUa5VTM4O7MBAYGFn+eRdwFGuU+LWI47AQGBiG34KyMBRrlRLRk9wwEBgZHDC4LvA + Ua5VtamamcBAYGO8Z/q7wFGuVUzODuzAQGBhZ/nkXRhNAAAAAAMAAAABAAAABMBRrEiD3ClAwEBs + YCIVtvHAUaxIoU6GVcBAbGGbqeJ3wFGsR+Q5gXrAQGxhxbFMy8BRrEiD3ClAwEBsYCIVtvEAGRwV + ABUAFSQAABb4xoqACBWgBBaO2uL/BxWuJQAmgK6H6gccFQgZNQYIABkoBGJib3gEeG1pbhUMFoyx + ExaAyU0W2poqJoCuh+oHPBgEBVSNwhgETOWOwhYAKAQFVI3CGARM5Y7CABkcFQAVABUQAAAWmMuK + gAgV8gEWvP/i/wcV1gEAJtrIseoHHBUIGTUGCAAZKARiYm94BHhtYXgVDBaMsRMW/shNFtqcKiba + yLHqBzwYBONTjcIYBDvljsIWACgE41ONwhgEO+WOwgAZHBUAFQAVEAAAForNioAIFfIBFpKB4/8H + FdYBACa05dvqBxwVCBk1BggAGSgEYmJveAR5bWluFQwWjLETFv7ITRaslC0mtOXb6gc8GAQGYAHC + GAQLMATCFgAoBAZgAcIYBAswBMIAGRwVABUAFRAAABb8zoqACBXyARboguP/BxXWAQAm4PmI6wcc + FQgZNQYIABkoBGJib3gEeW1heBUMFoyxExb8yE0WwpYtJuD5iOsHPBgE718BwhgE8y8EwhYAKATv + XwHCGATzLwTCABkcFQAVABUQAAAW7tCKgAgV8gEWvoTj/wcV1gEAJuKQtusHHBUCGTUGCAQZGAd2 + ZXJzaW9uFQwWjLETFv4EFqAGJuKQtusHJqKQtusHHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAA + ABksFQQVBBUCABUAFQQVEAAAFuDSioAIFdIBFpSG4/8HFdYBACaCl7brBxwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFoyxExb+BRagByaCl7brBybClrbrBxwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVEAAAFrLUioAIFdIBFuqH4/8HFVYAJqaftusHHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBaMsRMWkOQEFrzYAiamn7brBybinbbrBxw2ACgN + T3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFoTW + ioAIFeIBFsCI4/8HFfYEACae9rjrBxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNv + cmRfaWQVDBaMsRMWjvz3AhaIlX0mnva46wc8NgAoDHc5OTM5OTYwOTJAMRgMMDAwMDIyM2VjMDNm + ABkcFQAVABUQAAAW5teKgAgV8gEWto3j/wcV1AMAJviotuwHHBUMGSUGBBlIB3NvdXJjZXMEbGlz + dAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWjLETFprKEBbQjgUm+Ki27Acmpou27AccNgAoGDIwMjQt + MTEtMjBUMDc6MDc6MzYuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUA + FQQVEAAAFtjZioAIFeIBFoqR4/8HFdYGACb4vbzsBxwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudApjb25maWRlbmNlFQwWjLETFojQHRaSkhom+L287Acm9pm77AccGAhYqDXNO07vPxgIzczM + zMzM5D8WnJ0GKAhYqDXNO07vPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWutuKgAgV8gEW + 4Jfj/wcV5gIAJois1ewHHBUCGTUGCAAZGAVsZXZlbBUMFoyxExbABRbQBiaIrNXsBzwYBAEAAAAY + BAEAAAAW+LATKAQBAAAAGAQBAAAAABkcFQAVABUQAAAWrN2KgAgV0gEWxprj/wcV1gEAJoC11ewH + HBUMGTUGCAQZGAdzdWJ0eXBlFQwWjLETFqAWFoIVJoC11ewHJtiy1ewHHDaarBMoDnRyYW5zcG9y + dGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW/t6KgAgV4gEWnJzj/wcVtgMA + JpjL1ewHHBUMGTUGCAQZGAVjbGFzcxUMFoyxExagFhbmFCaYy9XsBybax9XsBxw25KwTKAl3YXJl + aG91c2UYCmFwYXJ0bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAW4OCKgAgV4gEW0p/j/wcVkAMAJsDc + 1ewHHBUKGTUGCAAZGAZoZWlnaHQVDBaMsRMWkAQWoAUmwNzV7Ac8NoyxEwAZHBUAFQAVEAAAFsLi + ioAIFdIBFuKi4/8HFXYAJuDh1ewHHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWjLETFuovFvQl + JuDh1ewHPDbMrxMoEsOTcHRpY2EgQmVsbGF2aXN0YRgGQWJjZGluABkcFQAVABUQAAAWlOSKgAgV + 4gEW2KPj/wcV+gUAJtSH1uwHHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW + jLETFqgMFrAMJtSH1uwHPDaMsRMAGRwVABUAFRAAABb25YqACBXiARbSqeP/BxV2ACaElNbsBxwV + DBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWjLETFtANFqgMJoSU1uwHPDaM + sRMAGRwVABUAFRAAABbY54qACBXiARbIquP/BxV2ACasoNbsBxwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFoyxExacDhb8DCasoNbsBzwYCG9mZmljaWFsGAhvZmZp + Y2lhbBaGsRMoCG9mZmljaWFsGAhvZmZpY2lhbAAZHBUAFQAVEAAAFrrpioAIFeIBFr6r4/8HFdYB + ACaordbsBxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBaMsRMW + 0A0WugwmqK3W7Ac8NoyxEwAZHBUAFQAVEAAAFpzrioAIFeIBFpSt4/8HFXYAJuK51uwHHBUMGSUG + ABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFoyxExaODxbyDSbiudbsBzw2hrET + KBlCYW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlGB9CYW5jbyBkZSBDcsOpZGl0byBlIEludmVyc2lv + bmVzABkcFQAVABUQAAAW/uyKgAgV4gEWiq7j/wcVugMAJtTH1uwHHBUKGSUGABl4BW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFoyxExbQDRa6DCbUx9bsBzw2 + jLETABkcFQAVABUQAAAW4O6KgAgV4gEWxLHj/wcVdgAmjtTW7AccFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50BHNpZGUVDBaMsRMW0A0WugwmjtTW7Ac8NoyxEwAZHBUAFQAVEAAAFsLw + ioAIFeIBFrqy4/8HFXYAJsjg1uwHHBUAGTUGCAAZGAloYXNfcGFydHMVDBaMsRMWsroCFrAGJsjg + 1uwHPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWpPKKgAgV0gEWsLPj/wcVdgAm+ObW7AccFQAZ + NQYIABkYDmlzX3VuZGVyZ3JvdW5kFQwWjLETFrK6AhawBib45tbsBzwYAQAYAQAWACgBABgBAAAZ + HBUAFQAVEAAAFvbzioAIFdIBFqa04/8HFXYAJpju1uwHHBUCGTUGCAQZGApudW1fZmxvb3JzFQwW + jLETFuIGFoQIJpju1uwHJqjt1uwHHBgECAAAABgEAQAAABbEsBMoBAgAAAAYBAEAAAAAGSwVBBUE + FQIAFQAVBBUQAAAWyPWKgAgV1gEWnLXj/wcVxgEAJqz11uwHHBUCGTUGCAAZGBZudW1fZmxvb3Jz + X3VuZGVyZ3JvdW5kFQwWjLETFpAEFqAFJqz11uwHPDaMsRMAGRwVABUAFRAAABae94qACBXSARbi + tuP/BxV2ACbM+tbsBxwVChk1BggAGRgKbWluX2hlaWdodBUMFoyxExaQBBagBSbM+tbsBzw2jLET + ABkcFQAVABUQAAAW8PiKgAgV0gEW2Lfj/wcVdgAm7P/W7AccFQIZNQYIABkYCW1pbl9mbG9vchUM + FoyxExaQBBagBSbs/9bsBzw2jLETABkcFQAVABUQAAAWwvqKgAgV0gEWzrjj/wcVdgAmjIXX7Acc + FQwZNQYIABkYDGZhY2FkZV9jb2xvchUMFoyxExaQBBagBSaMhdfsBzw2jLETABkcFQAVABUQAAAW + lPyKgAgV0gEWxLnj/wcVdgAmrIrX7AccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFoyxExaQ + BBagBSasitfsBzw2jLETABkcFQAVABUQAAAW5v2KgAgV0gEWurrj/wcVdgAmzI/X7AccFQwZNQYI + ABkYDXJvb2ZfbWF0ZXJpYWwVDBaMsRMWkAQWoAUmzI/X7Ac8NoyxEwAZHBUAFQAVEAAAFrj/ioAI + FdIBFrC74/8HFXYAJuyU1+wHHBUMGTUGCAAZGApyb29mX3NoYXBlFQwWjLETFpAEFqAFJuyU1+wH + PDaMsRMAGRwVABUAFRAAABaKgYuACBXSARamvOP/BxV2ACaMmtfsBxwVChk1BggAGRgOcm9vZl9k + aXJlY3Rpb24VDBaMsRMWkAQWoAUmjJrX7Ac8NoyxEwAZHBUAFQAVEAAAFtyCi4AIFdIBFpy94/8H + FXYAJqyf1+wHHBUMGTUGCAAZGBByb29mX29yaWVudGF0aW9uFQwWjLETFpAEFqAFJqyf1+wHPDaM + sRMAGRwVABUAFRAAABauhIuACBXSARaSvuP/BxV2ACbMpNfsBxwVDBk1BggAGRgKcm9vZl9jb2xv + chUMFoyxExaQBBagBSbMpNfsBzw2jLETABkcFQAVABUQAAAWgIaLgAgV0gEWiL/j/wcVdgAm7KnX + 7AccFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0FQwWjLETFpAEFqAFJuyp1+wHPDaMsRMAGRwVABUAFRAA + ABbSh4uACBXSARb+v+P/BxV2ABbcjqMbFoyxEybosfreBxak/dwNFIoBABn8JiaMr9fsBxwVDBk1 + BggAGRgCaWQVDBbMwhMW/uG+BRa84skBJoyv1+wHPDYAKCAwOGJiMmUzY2RlYWIxZmZmMDIwMDIy + NzRmY2FmZjMzMRggMDhiYjJjNDg0ZDkwOWZmZjAyMDBhMDI3M2I4OGQ1MDcAGRwVABUAFRAAABak + iYuACBXyARb0wOP/BxXWCAAmyJGh7gccFQwZNQYIABkYCGdlb21ldHJ5FQwWzMITForW+w8WgIK7 + CSbIkaHuBzw2ACjtBwAAAAADAAAABQAAACnAUaWBW0nSssBAbD6kgH1pwFGlgyg+DKvAQGxCoWU/ + 9sBRpYLZzxPPwEBsQyDnAFXAUaWD9cNmHMBAbEWRA8jiwFGlhTY1RjPAQGxEG7jDK8BRpYb+IQKv + wEBsR9+Soi/AUaWFmMY1A8BAbEl/pdKNwFGlhqPzj6/AQGxLxPpwdMBRpYcO5/pQwEBsS1LkqWLA + UaWHrDFL0sBAbExqO939wFGliM4E2zHAQGxK/isTqsBRpYnkhVA2wEBsTQZDECDAUaWEpD8PCsBA + bFSS/0ulwFGlhPt844DAQGxVSrUv+MBRpYPZqVQiwEBsVuaWom7AUaWDbrTpgcBAbFX/EBX4wFGl + gv5MoZnAQGxWkQZNIcBRpYK1UYYFwEBsVghKUV3AUaWBGrIy7sBAbFhgE2YOwFGlgPBVaBHAQGxY + JVsDXMBRpX/JDftrwEBsVYz6TubAUaWBm+FydsBAbFMBLtQpwFGlgKzOKcTAQGxQ/h9VMMBRpX6t + GakewEBsU3uoFwvAUaV7KQCqSsBAbEyicAHxwFGlfItr2W3AQGxKtt13P8BRpXv7+eECwEBsSYPX + kHXAUaV53n3POcBAbExUbGjfwFGleSWFy4bAQGxK/wHTP8BRpXm2pUMbwEBsSixz/FHAUaV4jvJ2 + q8BAbEfJwy0RwFGlep3Ab8fAQGxFIXJAj8BRpXstncf9wEBsRjp29FPAUaV7XdnP68BAbEXtShrW + wFGleoO/PMHAQGxES4lrTsBRpXxCcL3YwEBsQgEsT+rAUaV6pOHMOMBAbD6bRkIEwFGlfEfkmyDA + QGw8hOuMq8BRpX0gUa8fwEBsPkW17LbAUaV+8KDnbMBAbEH8I9JtwFGlgVtJ0rLAQGw+pIB9aQAA + AAXAUaWBcYSnmsBAbESM98qnwFGlgIJxXujAQGxF6sXcGMBRpYDRS7eOwEBsRniKVVnAUaWBvxzg + 4cBAbEUmer4MwFGlgXGEp5rAQGxEjPfKpwAAAAXAUaWDG6jS88BAbEe0yneIwFGlgk/Q+KvAQGxI + 3pYi7cBRpYKN5FmxwEBsSUujbIHAUaWDWA60z8BAbEgwGnn/wFGlgxuo0vPAQGxHtMp3iAAAAAXA + UaWEeeJELcBAbEqbLsUPwFGlg6bpDXXAQGxLzjSr2cBRpYPtX+pLwEBsTFK+6bXAUaWEwFkhBMBA + bEsasIVuwFGlhHniRC3AQGxKmy7FDwAAAAXAUaWF69JLksBAbE23QvfMwFGlhXc4RcLAQGxOXIRl + VcBRpYWx8Kh0wEBsTtBHq5DAUaWGKDgtbsBAbE4ogf9JwFGlhevSS5LAQGxNt0L3zBhNAAAAAAMA + AAABAAAABMBRpbh5XgStwEBqqw/wwinAUaW4s23G0MBAaqwSP1UCwFGluAkRH9XAQGqsf2xSXMBR + pbh5XgStwEBqqw/wwikAGRwVABUAFSQAABaWi4uACBWgBBbKyeP/BxWuJQAmyJPc9wccFQgZNQYI + ABkoBGJib3gEeG1pbhUMFszCExaAj04W6rMrJsiT3PcHPBgECaCMwhgEfxqPwhYAKAQJoIzCGAR/ + Go/CABkcFQAVABUQAAAWto+LgAgV8gEW+O7j/wcV1gEAJrLHh/gHHBUIGTUGCAAZKARiYm94BHht + YXgVDBbMwhMW/o5OFuqsKyayx4f4BzwYBP2fjMIYBHQaj8IWACgE/Z+MwhgEdBqPwgAZHBUAFQAV + EAAAFqiRi4AIFfIBFs7w4/8HFdYBACac9LL4BxwVCBk1BggAGSgEYmJveAR5bWluFQwWzMITFv6O + ThbKuC4mnPSy+Ac8GATM1v7BGASQLwTCFgAoBMzW/sEYBJAvBMIAGRwVABUAFRAAABaak4uACBXy + ARak8uP/BxXWAQAm5qzh+AccFQgZNQYIABkoBGJib3gEeW1heBUMFszCExaAj04WrLUuJuas4fgH + PBgEp9b+wRgEfi8EwhYAKASn1v7BGAR+LwTCABkcFQAVABUQAAAWjJWLgAgV8gEW+vPj/wcV1gEA + JtLij/kHHBUCGTUGCAQZGAd2ZXJzaW9uFQwWzMITFv4EFqAGJtLij/kHJpLij/kHHBgEAAAAABgE + AAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFv6Wi4AIFdIBFtD14/8HFdYBACby + 6I/5BxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFszCExb+BRagByby + 6I/5Byay6I/5BxwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFtCYi4AIFdIBFqb34/8HFVYA + Jpbxj/kHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbMwhMWkM8EFs7V + AiaW8Y/5BybS74/5Bxw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABks + FQQVBBUCABUAFQQVEAAAFqKai4AIFeIBFvz34/8HFfYEACagxZL5BxwVDBklBgAZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbMwhMWjuX+AhbaznsmoMWS+Qc8NgAoDHc5OTM5NzQz + ODVAMRgMMDAwMGQxNDZmNGRkABkcFQAVABUQAAAWhJyLgAgV8gEW8vzj/wcV1gMAJpLIjvoHHBUM + GSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWzMITFvzXEhaeuAUmksiO + +gcm+pOO+gccNgAoGDIwMjQtMTAtMThUMDA6NDM6MjUuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDow + MC4wMDBaABksFQQVBBUCABUAFQQVEAAAFvadi4AIFeIBFsiA5P8HFdYGACaa7ZT6BxwVChklBgQZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWzMITFvjRHhbCnxsmmu2U+gcmmMyT + +gccGAgXt9EA3gLvPxgIzczMzMzM5D8WmrkFKAgXt9EA3gLvPxgIzczMzMzM5D8AGSwVBBUEFQIA + FQAVBBUQAAAW2J+LgAgV8gEWnofk/wcV5gIAJtrrrvoHHBUCGTUGCAAZGAVsZXZlbBUMFszCExa4 + BRakBiba6676BzwYBAEAAAAYBAEAAAAWtsITKAQBAAAAGAQBAAAAABkcFQAVABUQAAAWyqGLgAgV + 1gEWhIrk/wcVtgEAJob0rvoHHBUMGTUGCAQZGAdzdWJ0eXBlFQwWzMITFrwfFvIdJob0rvoHJv7x + rvoHHDbcpBMoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3VsdHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAW + oKOLgAgV4gEWuovk/wcVxAMAJraTr/oHHBUMGTUGCAQZGAVjbGFzcxUMFszCExbcIBbcHia2k6/6 + Bybwj6/6Bxw2tKUTKAp1bml2ZXJzaXR5GAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAFoKl + i4AIFeIBFv6O5P8HFZQDACbMrq/6BxwVChk1BggAGRgGaGVpZ2h0FQwWzMITFqoEFroFJsyur/oH + PBgIAAAAAAAALEAYCAAAAAAAACxAFsrCEygIAAAAAAAALEAYCAAAAAAAACxAABkcFQAVABUQAAAW + 5KaLgAgV0gEWkpLk/wcVlgEAJoa0r/oHHBUMGTUGCAAZKAVuYW1lcwdwcmltYXJ5FQwWzMITFtgt + FqIjJoa0r/oHPDaGwRMoEHBhc3RlbCBkZSBjaG9jbG8YDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAA + Fraoi4AIFeIBFqiT5P8HFdgFACao16/6BxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVl + A2tleRUMFszCExbSDBbGDCao16/6Bzw2zMITABkcFQAVABUQAAAWmKqLgAgV4AEWgJnk/wcVdgAm + 7uOv+gccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFszCExaADhbSDCbu + 46/6Bzw2zMITABkcFQAVABUQAAAW+KuLgAgV4AEW9pnk/wcVdgAmwPCv+gccFQwZJQYAGVgFbmFt + ZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbQwhMWkA8WtA0mwPCv+gc8NsbCEygIb2Zm + aWNpYWwYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFtiti4AIFeABFuya5P8HFbgBACb0/a/6BxwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbQwhMWlA4W5gwm9P2v+gc8 + NtDCEwAZHBUAFQAVEAAAFrivi4AIFeABFqSc5P8HFXYAJtqKsPoHHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFtDCExbeEBaKDibairD6Bzw2xsITKBhDZW50cm8gZGUg + U2FsdWQgRmFtaWxpYXIYGUJhbmNvIGRlbCBFc3RhZG8gZGUgQ2hpbGUAGRwVABUAFRAAABaYsYuA + CBXgARaaneT/BxXSAgAm5Jiw+gccFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2Jl + dHdlZW4EbGlzdAdlbGVtZW50FQwW0MITFpgOFugMJuSYsPoHPDbQwhMAGRwVABUAFRAAABb4souA + CBXgARbsn+T/BxV2ACbMpbD6BxwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lk + ZRUMFtDCExaUDhbmDCbMpbD6Bzw20MITABkcFQAVABUQAAAW2LSLgAgV4AEW4qDk/wcVdgAmsrKw + +gccFQAZNQYIABkYCWhhc19wYXJ0cxUMFszCExbKvAIWsAYmsrKw+gc8GAEAGAEAFgAoAQAYAQAA + GRwVABUAFRAAABa4touACBXSARbYoeT/BxV2ACbiuLD6BxwVABk1BggAGRgOaXNfdW5kZXJncm91 + bmQVDBbMwhMWyrwCFrAGJuK4sPoHPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWiriLgAgV0gEW + zqLk/wcVdgAmkr+w+gccFQIZNQYIABkYCm51bV9mbG9vcnMVDBbMwhMW8ggW4Acmkr+w+gc8GAQK + AAAAGAQBAAAAFubBEygECgAAABgEAQAAAAAZHBUAFQAVEAAAFty5i4AIFdgBFsSj5P8HFbYBACby + xrD6BxwVAhk1BggAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFszCExaQBBagBSbyxrD6Bzw2 + zMITABkcFQAVABUQAAAWtLuLgAgV0gEW+qTk/wcVdgAmksyw+gccFQoZNQYIABkYCm1pbl9oZWln + aHQVDBbMwhMWkAQWoAUmksyw+gc8NszCEwAZHBUAFQAVEAAAFoa9i4AIFdIBFvCl5P8HFXYAJrLR + sPoHHBUCGTUGCAAZGAltaW5fZmxvb3IVDBbMwhMWkAQWoAUmstGw+gc8NszCEwAZHBUAFQAVEAAA + Fti+i4AIFdIBFuam5P8HFXYAJtLWsPoHHBUMGTUGCAAZGAxmYWNhZGVfY29sb3IVDBbMwhMWkAQW + oAUm0taw+gc8NszCEwAZHBUAFQAVEAAAFqrAi4AIFdIBFtyn5P8HFXYAJvLbsPoHHBUMGTUGCAAZ + GA9mYWNhZGVfbWF0ZXJpYWwVDBbMwhMWkAQWoAUm8tuw+gc8NszCEwAZHBUAFQAVEAAAFvzBi4AI + FdIBFtKo5P8HFXYAJpLhsPoHHBUMGTUGCAAZGA1yb29mX21hdGVyaWFsFQwWzMITFpAEFqAFJpLh + sPoHPDbMwhMAGRwVABUAFRAAABbOw4uACBXSARbIqeT/BxV2ACay5rD6BxwVDBk1BggAGRgKcm9v + Zl9zaGFwZRUMFszCExaWBRbUBSay5rD6BzwYBGZsYXQYBGZsYXQWvsITKARmbGF0GARmbGF0ABkc + FQAVABUQAAAWoMWLgAgV1AEWvqrk/wcVhgEAJobssPoHHBUKGTUGCAAZGA5yb29mX2RpcmVjdGlv + bhUMFszCExaQBBagBSaG7LD6Bzw2zMITABkcFQAVABUQAAAW9MaLgAgV0gEWxKvk/wcVdgAmpvGw + +gccFQwZNQYIABkYEHJvb2Zfb3JpZW50YXRpb24VDBbMwhMWkAQWoAUmpvGw+gc8NszCEwAZHBUA + FQAVEAAAFsbIi4AIFdIBFrqs5P8HFXYAJsb2sPoHHBUMGTUGCAAZGApyb29mX2NvbG9yFQwWzMIT + FpAEFqAFJsb2sPoHPDbMwhMAGRwVABUAFRAAABaYyouACBXSARawreT/BxV2ACbm+7D6BxwVChk1 + BggAGRgLcm9vZl9oZWlnaHQVDBbMwhMWkAQWoAUm5vuw+gc8NszCEwAZHBUAFQAVEAAAFurLi4AI + FdIBFqau5P8HFXYAFqDqrhsWzMITJoyv1+wHFvrR2Q0UjAEAGfwmJoaBsfoHHBUMGTUGCAAZGAJp + ZBUMFtDyBhacoPgBFsLDRyaGgbH6Bzw2ACggMDhiYjJlM2RiNDA2ZWZmZjAyMDBiNDliYWI5MmI0 + MjUYIDA4YmIyZTA2YzgyODBmZmYwMjAwNjUwYjZmMjE4MTljABkcFQAVABUGAAAWvM2LgAgVXBac + r+T/BxWuAwAmyMT4+gccFQwZNQYIABkYCGdlb21ldHJ5FQwW0PIGFuqFvQUWtNeZAybIxPj6Bzw2 + ACjhAgAAAAADAAAAAgAAABDAUd9a30mnE8A/6G+P2tP3wFHfWZsRaN7AP+h8ZoLr2MBR31iOoe7T + wD/oeej6Kf3AUd9W130p98A/6HYsrQc1wFHfU/pTF9XAP+hxFsOQ5MBR31HQQcxTwD/obfnYnpLA + Ud9ST8OMssA/6GjxWyGPwFHfV0IGNM3AP+hwshnDIMBR31d1MdtEwD/obpk6zwnAUd9VU4QLk8A/ + 6Gqj4si4wFHfUnqLt1nAP+hmvaQ63cBR31MP3OzWwD/oYdGsL57AUd9VE8MrY8A/6GReTmnwwFHf + V3EAHVzAP+hocCviBsBR31kbJEi1wD/oa8Yht+HAUd9a30mnE8A/6G+P2tP3AAAABcBR31lqagEm + wD/ocoEm3A3AUd9YktOsu8A/6HE9Wf2iwFHfWEiWccfAP+hzdhlh0cBR31kgLMYywD/odLnmQDvA + Ud9ZamoBJsA/6HKBJtwNGE0AAAAAAwAAAAEAAAAEwFGzc2H8QQHAQB1OVNii8cBRs3MqS5XYwEAd + T2jMMP3AUbNyjdl7DMBAHU8NjWMGwFGzc2H8QQHAQB1OVNii8QAZHBUAFQAVDgAAFpjOi4AIFdQB + Fsqy5P8HFc4OACbYw57+BxwVCBk1BggEGSgEYmJveAR4bWluFQwW0PIGFtCLHha89hgm2MOe/gcm + /JuS/gccGASboIzCGASdHY/CFgAoBJugjMIYBJ0dj8IAGSwVBBUEFQIAFQAVBBUGAAAW7M+LgAgV + XBaYweT/BxVeACbEtrf+BxwVCBk1BggEGSgEYmJveAR4bWF4FQwW0PIGFriGHhbg8hgmxLa3/gcm + uJKr/gccGASUoIzCGASVHY/CFgAoBJSgjMIYBJUdj8IAGSwVBBUEFQIAFQAVBBUGAAAWyNCLgAgV + XBb2weT/BxVeACaYhcT+BxwVCBk1BggAGSgEYmJveAR5bWluFQwW0PIGFp7MGxbEvxImmIXE/gc8 + GAQPIP3BGATRXwHCFgAoBA8g/cEYBNFfAcIAGRwVABUAFQYAABak0YuACBVcFtTC5P8HFV4AJtzE + 1v4HHBUIGTUGCAAZKARiYm94BHltYXgVDBbQ8gYWnswbFsS9EibcxNb+BzwYBOAf/cEYBMNfAcIW + ACgE4B/9wRgEw18BwgAZHBUAFQAVBgAAFoDSi4AIFVwWssPk/wcVXgAm4ILp/gccFQIZNQYIBBkY + B3ZlcnNpb24VDBbQ8gYWjAIW1AIm4ILp/gcmoILp/gccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAA + AAAAGSwVBBUEFQIAFQAVBBUGAAAW3NKLgAgVUBaQxOT/BxVeACa0hen+BxwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFtDyBha6AhaCAya0hen+Byb0hOn+BxwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVBgAAFqzTi4AIFVAW7sTk/wcVLgAmuonp/gccFQwZJQYEGUgHc291 + cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFtDyBhbcmgEW6GUmuonp/gcm9ofp/gccNgAoDU9w + ZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAVABUEFQYAABb804uA + CBVWFpzF5P8HFfoBACbe7en+BxwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRf + aWQVDBbQ8gYW7vKGARbwuSom3u3p/gc8NgAoDHc5ODEwNTMzNjhAMRgMMDAwMmJjNDlkYzBmABkc + FQAVABUGAAAW0tSLgAgVXBaWx+T/BxW+AQAm7pqV/wccFQwZJQYEGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQLdXBkYXRlX3RpbWUVDBbQ8gYW0vULFvyvAybumpX/BybOp5T/Bxw2ACgYMjAyNC0xMS0x + MVQwMDowNDo1NC4wMDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUG + AAAWrtWLgAgVWBbUyOT/BxXOAgAmwPKY/wccFQoZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQK + Y29uZmlkZW5jZRUMFtDyBhbk8wsWrPAJJsDymP8HJsrXl/8HHBgIc9cS8kHP7j8YCM3MzMzMzOQ/ + FsT+ASgIc9cS8kHP7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVBgAAFobWi4AIFVwWosvk/wcV + lgEAJvbHof8HHBUCGTUGCAAZGAVsZXZlbBUMFtDyBhboARaeAib2x6H/BzwYBAEAAAAYBAEAAAAW + zPIGKAQBAAAAGAQBAAAAABkcFQAVABUGAAAW4taLgAgVUBa4zOT/BxVaACaqzKH/BxwVDBk1BggE + GRgHc3VidHlwZRUMFtDyBhaUDhbSDCaqzKH/ByaUyqH/Bxw25OgGKA50cmFuc3BvcnRhdGlvbhgM + YWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVBgAAFrLXi4AIFVYWks3k/wcVvgEAJuTYof8HHBUM + GTUGCAQZGAVjbGFzcxUMFtDyBhaIDRaUDCbk2KH/Bybm1qH/Bxw2kOkGKA10cmFpbl9zdGF0aW9u + GAZjaHVyY2gAGSwVBBUEFQIAFQAVBBUGAAAWiNiLgAgVVhbQzuT/BxWaAQAm+uKh/wccFQoZNQYI + ABkYBmhlaWdodBUMFtDyBhbGARb8ASb64qH/Bzw20PIGABkcFQAVABUGAAAW3tiLgAgVUBbqz+T/ + BxU6ACb25KH/BxwVDBk1BggAGSgFbmFtZXMHcHJpbWFyeRUMFtDyBhaSExaYDib25KH/Bzw2kPIG + KAxTYW50YSBFbWlsaWEYETggUXVlYnJhZGFzIEhvdXNlABkcFQAVABUGAAAWrtmLgAgVVhak0OT/ + BxWCAgAm3vOh/wccFQwZJQYEGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbS8gYWhAUW + iAUm3vOh/wcmjvOh/wccNszyBigCZXMYAmVuABksFQQVBBUCABUAFQQVBgAAFoTai4AIFVQWptLk + /wcVQgAmlvih/wccFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQV2YWx1ZRUMFtLyBhbQ + BRagBSaW+KH/Bzw2zPIGKApTdGF0ZSBCYW5rGAxCYW5jbyBFc3RhZG8AGRwVABUAFQYAABbY2ouA + CBVWFujS5P8HFWYAJoT+of8HHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2YXJp + YW50FQwW1PIGFrgFFpoFJoT+of8HJrb9of8HHBgIb2ZmaWNpYWwYCG9mZmljaWFsFs7yBigIb2Zm + aWNpYWwYCG9mZmljaWFsABksFQQVBBUCABUAFQQVBgAAFq7bi4AIFVYWztPk/wcVWgAm0IKi/wcc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW1PIGFowFFtwEJtCC + ov8HPDbQ8gYoAmVzGAJlbgAZHBUAFQAVBgAAFoTci4AIFVYWqNTk/wcVQgAm3Iii/wccFQwZJQYE + GVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW1PIGFpwGFv4FJtyIov8HJqyHov8H + HDbO8gYoGkJhbmsgb2YgdGhlIFN0YXRlIG9mIENoaWxlGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENo + aWxlABksFQQVBBUCABUAFQQVBgAAFtrci4AIFVYW6tTk/wcVoAEAJqqNov8HHBUKGSUGABl4BW5h + bWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFtTyBhb2BBbGBCaq + jaL/Bzw21PIGABkcFQAVABUGAAAWsN2LgAgVVhaK1uT/BxU6ACbwkaL/BxwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFtTyBhb0BBbEBCbwkaL/Bzw21PIGABkcFQAVABUG + AAAWht6LgAgVVhbE1uT/BxU6ACa0lqL/BxwVABk1BggAGRgJaGFzX3BhcnRzFQwW0PIGFvZvFrIC + JrSWov8HPBgBABgBABYAKAEAGAEAABkcFQAVABUGAAAW3N6LgAgVUBb+1uT/BxU6ACbmmKL/BxwV + ABk1BggAGRgOaXNfdW5kZXJncm91bmQVDBbQ8gYW9m8WsgIm5pii/wc8GAEAGAEAFgAoAQAYAQAA + GRwVABUAFQYAABas34uACBVQFrjX5P8HFToAJuCbov8HHBUCGTUGCAQZGApudW1fZmxvb3JzFQwW + 0PIGFqQCFuwCJuCbov8HJpibov8HHBgEAwAAABgEAQAAABbK8gYoBAMAAAAYBAEAAAAAGSwVBBUE + FQIAFQAVBBUGAAAW/N+LgAgVUBby1+T/BxVKACaEnqL/BxwVAhk1BggAGRgWbnVtX2Zsb29yc191 + bmRlcmdyb3VuZBUMFtDyBhbGARb8ASaEnqL/Bzw20PIGABkcFQAVABUGAAAWzOCLgAgVUBa82OT/ + BxU6ACaAoKL/BxwVChk1BggAGRgKbWluX2hlaWdodBUMFtDyBhbGARb8ASaAoKL/Bzw20PIGABkc + FQAVABUGAAAWnOGLgAgVUBb22OT/BxU6ACb8oaL/BxwVAhk1BggAGRgJbWluX2Zsb29yFQwW0PIG + FsYBFvwBJvyhov8HPDbQ8gYAGRwVABUAFQYAABbs4YuACBVQFrDZ5P8HFToAJvijov8HHBUMGTUG + CAAZGAxmYWNhZGVfY29sb3IVDBbQ8gYWxgEW/AEm+KOi/wc8NtDyBgAZHBUAFQAVBgAAFrzii4AI + FVAW6tnk/wcVOgAm9KWi/wccFQwZNQYIABkYD2ZhY2FkZV9tYXRlcmlhbBUMFtDyBhbGARb8ASb0 + paL/Bzw20PIGABkcFQAVABUGAAAWjOOLgAgVUBak2uT/BxU6ACbwp6L/BxwVDBk1BggAGRgNcm9v + Zl9tYXRlcmlhbBUMFtDyBhbGARb8ASbwp6L/Bzw20PIGABkcFQAVABUGAAAW3OOLgAgVUBbe2uT/ + BxU6ACa4qqL/BxwVDBk1BggEGRgKcm9vZl9zaGFwZRUMFtDyBhaWAhbeAia4qqL/BybsqaL/BxwY + BmdhYmxlZBgGZ2FibGVkFsLyBigGZ2FibGVkGAZnYWJsZWQAGSwVBBUEFQIAFQAVBBUGAAAWrOSL + gAgVUBaY2+T/BxVSACbKrKL/BxwVChk1BggAGRgOcm9vZl9kaXJlY3Rpb24VDBbQ8gYWxgEW/AEm + yqyi/wc8NtDyBgAZHBUAFQAVBgAAFvzki4AIFVAW6tvk/wcVOgAmxq6i/wccFQwZNQYIABkYEHJv + b2Zfb3JpZW50YXRpb24VDBbQ8gYWxgEW/AEmxq6i/wc8NtDyBgAZHBUAFQAVBgAAFszli4AIFVAW + pNzk/wcVOgAmwrCi/wccFQwZNQYIABkYCnJvb2ZfY29sb3IVDBbQ8gYWxgEW/AEmwrCi/wc8NtDy + BgAZHBUAFQAVBgAAFpzmi4AIFVAW3tzk/wcVOgAmvrKi/wccFQoZNQYIABkYC3Jvb2ZfaGVpZ2h0 + FQwW0PIGFsYBFvwBJr6yov8HPDbQ8gYAGRwVABUAFQYAABbs5ouACBVQFpjd5P8HFToAFuyWywkW + 0PIGJoaBsfoHFrSz8QQUjgEAGVwYA2dlbxi5AnsidmVyc2lvbiI6IjEuMS4wIiwicHJpbWFyeV9j + b2x1bW4iOiJnZW9tZXRyeSIsImNvbHVtbnMiOnsiZ2VvbWV0cnkiOnsiZW5jb2RpbmciOiJXS0Ii + LCJnZW9tZXRyeV90eXBlcyI6WyJQb2x5Z29uIiwiTXVsdGlQb2x5Z29uIl0sImJib3giOlstMTc5 + Ljk5OTk5NjYsLTgzLjY1MDAxMzksLTIuODIyOTgyNCwtMC4wMDMxMzc3MTExMDA1NTMxOV0sImNv + dmVyaW5nIjp7ImJib3giOnsieG1pbiI6WyJiYm94IiwieG1pbiJdLCJ5bWluIjpbImJib3giLCJ5 + bWluIl0sInhtYXgiOlsiYmJveCIsInhtYXgiXSwieW1heCI6WyJiYm94IiwieW1heCJdfX19fX0A + GBxvcmcuYXBhY2hlLnNwYXJrLmxlZ2FjeUlOVDk2GAAAGBhvcmcuYXBhY2hlLnNwYXJrLnZlcnNp + b24YBTMuNC4xABgpb3JnLmFwYWNoZS5zcGFyay5zcWwucGFycXVldC5yb3cubWV0YWRhdGEY7hd7 + InR5cGUiOiJzdHJ1Y3QiLCJmaWVsZHMiOlt7Im5hbWUiOiJpZCIsInR5cGUiOiJzdHJpbmciLCJu + dWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJnZW9tZXRyeSIsInR5cGUiOiJi + aW5hcnkiLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJiYm94IiwidHlw + ZSI6eyJ0eXBlIjoic3RydWN0IiwiZmllbGRzIjpbeyJuYW1lIjoieG1pbiIsInR5cGUiOiJmbG9h + dCIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InhtYXgiLCJ0eXBlIjoi + ZmxvYXQiLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJ5bWluIiwidHlw + ZSI6ImZsb2F0IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoieW1heCIs + InR5cGUiOiJmbG9hdCIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319XX0sIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InZlcnNpb24iLCJ0eXBlIjoiaW50ZWdlciIs + Im51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InNvdXJjZXMiLCJ0eXBlIjp7 + InR5cGUiOiJhcnJheSIsImVsZW1lbnRUeXBlIjp7InR5cGUiOiJzdHJ1Y3QiLCJmaWVsZHMiOlt7 + Im5hbWUiOiJwcm9wZXJ0eSIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRh + dGEiOnt9fSx7Im5hbWUiOiJkYXRhc2V0IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVl + LCJtZXRhZGF0YSI6e319LHsibmFtZSI6InJlY29yZF9pZCIsInR5cGUiOiJzdHJpbmciLCJudWxs + YWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJ1cGRhdGVfdGltZSIsInR5cGUiOiJz + dHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJjb25maWRlbmNl + IiwidHlwZSI6ImRvdWJsZSIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319XX0sImNvbnRh + aW5zTnVsbCI6dHJ1ZX0sIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Imxl + dmVsIiwidHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5h + bWUiOiJzdWJ0eXBlIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6 + e319LHsibmFtZSI6ImNsYXNzIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRh + ZGF0YSI6e319LHsibmFtZSI6ImhlaWdodCIsInR5cGUiOiJkb3VibGUiLCJudWxsYWJsZSI6dHJ1 + ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJuYW1lcyIsInR5cGUiOnsidHlwZSI6InN0cnVjdCIs + ImZpZWxkcyI6W3sibmFtZSI6InByaW1hcnkiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRy + dWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiY29tbW9uIiwidHlwZSI6eyJ0eXBlIjoibWFwIiwi + a2V5VHlwZSI6InN0cmluZyIsInZhbHVlVHlwZSI6InN0cmluZyIsInZhbHVlQ29udGFpbnNOdWxs + Ijp0cnVlfSwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoicnVsZXMiLCJ0 + eXBlIjp7InR5cGUiOiJhcnJheSIsImVsZW1lbnRUeXBlIjp7InR5cGUiOiJzdHJ1Y3QiLCJmaWVs + ZHMiOlt7Im5hbWUiOiJ2YXJpYW50IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJt + ZXRhZGF0YSI6e319LHsibmFtZSI6Imxhbmd1YWdlIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InZhbHVlIiwidHlwZSI6InN0cmluZyIsIm51 + bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6ImJldHdlZW4iLCJ0eXBlIjp7InR5 + cGUiOiJhcnJheSIsImVsZW1lbnRUeXBlIjoiZG91YmxlIiwiY29udGFpbnNOdWxsIjp0cnVlfSwi + bnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoic2lkZSIsInR5cGUiOiJzdHJp + bmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fV19LCJjb250YWluc051bGwiOnRydWV9 + LCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fV19LCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRh + dGEiOnt9fSx7Im5hbWUiOiJoYXNfcGFydHMiLCJ0eXBlIjoiYm9vbGVhbiIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6ImlzX3VuZGVyZ3JvdW5kIiwidHlwZSI6ImJvb2xl + YW4iLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJudW1fZmxvb3JzIiwi + dHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJu + dW1fZmxvb3JzX3VuZGVyZ3JvdW5kIiwidHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6dHJ1ZSwi + bWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJtaW5faGVpZ2h0IiwidHlwZSI6ImRvdWJsZSIsIm51bGxh + YmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Im1pbl9mbG9vciIsInR5cGUiOiJpbnRl + Z2VyIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiZmFjYWRlX2NvbG9y + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + ImZhY2FkZV9tYXRlcmlhbCIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRh + dGEiOnt9fSx7Im5hbWUiOiJyb29mX21hdGVyaWFsIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InJvb2Zfc2hhcGUiLCJ0eXBlIjoic3RyaW5n + IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoicm9vZl9kaXJlY3Rpb24i + LCJ0eXBlIjoiZG91YmxlIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoi + cm9vZl9vcmllbnRhdGlvbiIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRh + dGEiOnt9fSx7Im5hbWUiOiJyb29mX2NvbG9yIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InJvb2ZfaGVpZ2h0IiwidHlwZSI6ImRvdWJsZSIs + Im51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319XX0AGB9vcmcuYXBhY2hlLnNwYXJrLmxlZ2Fj + eURhdGVUaW1lGAAAGFpwYXJxdWV0LW1yIHZlcnNpb24gMS4xMi4zLWRhdGFicmlja3MtMDAwMiAo + YnVpbGQgMjQ4NGE5NWRiZTE2YTAwMjNlM2ViMjljMjAxZjk5ZmY5ZWE3NzFlZSkZ/CYcAAAcAAAc + AAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAc + AAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAcAAAAFY4FAFBB + UjE= + headers: + Accept-Ranges: + - bytes + Content-Length: + - '364061' + Content-Range: + - bytes 1073838558-1074202618/1074202619 + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:51 GMT + Etag: + - '"0x8DD1F961B620B78"' + Last-Modified: + - Wed, 18 Dec 2024 18:59:32 GMT + Server: + - Windows-Azure-Blob/1.0 Microsoft-HTTPAPI/2.0 + x-ms-acl: + - user::rw-,group::r--,other::--- + x-ms-blob-type: + - BlockBlob + x-ms-client-request-id: + - 611881cc-c153-11ef-9896-c9ef2e2fb316 + x-ms-copy-completion-time: + - Wed, 18 Dec 2024 18:59:31 GMT + x-ms-copy-id: + - 9095c449-d3ff-4970-bdb1-5880129928f7 + x-ms-copy-progress: + - 1074202619/1074202619 + x-ms-copy-source: + - https://overturemapswestus2.blob.core.windows.net:443/release/_$azuretmpfolder$/06834b8a-d222-4de1-981a-d1968e73a843part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet?ss=bfqt&api-version=2019-02-02&st=2024-03-07T02%3a47%3a36Z&se=2025-03-01T10%3a47%3a36Z&sv=2022-11-02&srt=sco&spr=https&sp=rwdlacupyx + x-ms-copy-status: + - success + x-ms-creation-time: + - Wed, 18 Dec 2024 18:55:51 GMT + x-ms-group: + - $superuser + x-ms-lease-state: + - available + x-ms-lease-status: + - unlocked + x-ms-meta-hdi_permission: + - '{"owner":"root","group":"supergroup","permissions":"rw-r--r--"}' + x-ms-owner: + - $superuser + x-ms-permissions: + - rw-r----- + x-ms-request-id: + - 475b0f91-e01e-005a-6860-558037000000 + x-ms-resource-type: + - file + x-ms-server-encrypted: + - 'true' + x-ms-version: + - '2025-01-05' + status: + code: 206 + message: Partial Content +version: 1 diff --git a/tests/cassettes/test_stac/test_create_item[s3---overturemaps-us-west-2-release-2024-12-18.0-theme=buildings-type=building-part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet].yaml b/tests/cassettes/test_stac/test_create_item[s3---overturemaps-us-west-2-release-2024-12-18.0-theme=buildings-type=building-part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet].yaml new file mode 100644 index 0000000..c4dcf73 --- /dev/null +++ b/tests/cassettes/test_stac/test_create_item[s3---overturemaps-us-west-2-release-2024-12-18.0-theme=buildings-type=building-part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet].yaml @@ -0,0 +1,1293 @@ +interactions: +- request: + body: null + headers: + Accept-Encoding: + - identity + User-Agent: + - aiobotocore/2.16.0 md/Botocore#1.35.81 ua/2.0 os/linux#6.8.0-51-generic md/arch#x86_64 + lang/python#3.13.0 md/pyimpl#CPython cfg/retry-mode#legacy botocore/1.35.81 + amz-sdk-invocation-id: + - e804c185-e237-476b-8a55-edcfcf8a20c8 + amz-sdk-request: + - attempt=1 + method: HEAD + uri: https://overturemaps-us-west-2.s3.amazonaws.com/release/2024-12-18.0/theme%3Dbuildings/type%3Dbuilding/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet + response: + body: + string: '' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '957501415' + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:52 GMT + Etag: + - '"1a1396245ec4c12e540285e78c525214-183"' + Last-Modified: + - Wed, 18 Dec 2024 18:26:35 GMT + Server: + - AmazonS3 + x-amz-id-2: + - Yl8KJgzSbz77dYSvSJcTu4w5U+lgQ2q1Mz8UByH40PjsrhoDJ4yFQsb3ALp+PUUUJ7bwK5Plar4= + x-amz-meta-mtime: + - '1734455862' + x-amz-request-id: + - G5JAM11E7MJ6S448 + x-amz-server-side-encryption: + - AES256 + x-amz-storage-class: + - INTELLIGENT_TIERING + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept-Encoding: + - identity + User-Agent: + - aiobotocore/2.16.0 md/Botocore#1.35.81 ua/2.0 os/linux#6.8.0-51-generic md/arch#x86_64 + lang/python#3.13.0 md/pyimpl#CPython cfg/retry-mode#legacy botocore/1.35.81 + amz-sdk-invocation-id: + - 510ac353-6a17-4fb6-a022-f5b2d21b3c26 + amz-sdk-request: + - attempt=1 + method: HEAD + uri: https://overturemaps-us-west-2.s3.amazonaws.com/release/2024-12-18.0/theme%3Dbuildings/type%3Dbuilding/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet + response: + body: + string: '' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '957501415' + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:52 GMT + Etag: + - '"1a1396245ec4c12e540285e78c525214-183"' + Last-Modified: + - Wed, 18 Dec 2024 18:26:35 GMT + Server: + - AmazonS3 + x-amz-id-2: + - I7QnWxFh+D3OJasznJTdZ0UMfPSpQwAydqRtWjbMfwkV9nU4DHnLyrczg8lEGgB3QaYbUpmvtjA= + x-amz-meta-mtime: + - '1734455862' + x-amz-request-id: + - G5J3FW5W5KBX8F1S + x-amz-server-side-encryption: + - AES256 + x-amz-storage-class: + - INTELLIGENT_TIERING + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept-Encoding: + - identity + If-Match: + - '"1a1396245ec4c12e540285e78c525214-183"' + Range: + - bytes=957435879-957501414 + User-Agent: + - aiobotocore/2.16.0 md/Botocore#1.35.81 ua/2.0 os/linux#6.8.0-51-generic md/arch#x86_64 + lang/python#3.13.0 md/pyimpl#CPython cfg/retry-mode#legacy botocore/1.35.81 + amz-sdk-invocation-id: + - 1d5135ce-9e81-402d-97c1-4fa2eb49df56 + amz-sdk-request: + - attempt=1 + method: GET + uri: https://overturemaps-us-west-2.s3.amazonaws.com/release/2024-12-18.0/theme%3Dbuildings/type%3Dbuilding/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet + response: + body: + string: !!binary | + b25lcxgEQUNIUwAZHBUAFQAVEAAAFpyG5JAHFeIBFtTYvJAHFYoFACbYquLnBRwVDBklBgAZSAVu + YW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFpCvExbyEhb0ECbYquLnBTw2gK8TKAJlcxgCZW4A + GRwVABUAFRAAABb+h+SQBxXiARbe3byQBxWWAQAmzLvi5wUcFQwZJQYAGUgFbmFtZXMGY29tbW9u + CWtleV92YWx1ZQV2YWx1ZRUMFpCvExboFhbUEibMu+LnBTw2gK8TKAtOYXRpb24gQmFuaxgNQmFu + Y28gTmFjacOzbgAZHBUAFQAVEAAAFuCJ5JAHFeIBFvTevJAHFeICACacz+LnBRwVDBklBgQZWAVu + YW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFqCvExbuFRaeEiacz+LnBSagzuLnBRw2 + 9q4TKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAAFsKL5JAHFeIBFtbhvJAHFaAC + ACa+4OLnBRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBagrxMW + oBUWvBEmvuDi5wU8NpSvEygCZXMYAmVuABkcFQAVABUQAAAWpI3kkAcV4gEW9uO8kAcVjgEAJoD1 + 4ucFHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFqCvExbwGBa4FCaA + 9eLnBSb68eLnBRw29q4TKAdVbmltYXJjGANCTkEAGSwVBBUEFQIAFQAVBBUQAAAWho/kkAcV4gEW + hOW8kAcV1AMAJrKG4+cFHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVu + BGxpc3QHZWxlbWVudBUMFqCvExbkFBaIESayhuPnBTw2oK8TABkcFQAVABUQAAAW6JDkkAcV4gEW + 2Oi8kAcVdgAmupfj5wUcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBag + rxMW2BQWghEmupfj5wU8NqCvEwAZHBUAFQAVEAAAFsqS5JAHFeIBFs7pvJAHFXYAJryo4+cFHBUA + GTUIBgAZGAloYXNfcGFydHMVDBaIrxMWkroCFrAGJryo4+cFPBgBABgBABYAKAEAGAEAABkcFQAV + ABUQAAAWrJTkkAcV0gEWxOq8kAcVdgAm7K7j5wUcFQAZNQgGABkYDmlzX3VuZGVyZ3JvdW5kFQwW + iK8TFpK6AhawBibsruPnBTwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFv6V5JAHFdIBFrrrvJAH + FXYAJpy14+cFHBUCGTUIBgAZGApudW1fZmxvb3JzFQwWiK8TFpoGFo4HJpy14+cFPBgEDwAAABgE + AQAAABborhMoBA8AAAAYBAEAAAAAGRwVABUAFRAAABbQl+SQBxXYARaw7LyQBxXGAQAmqrzj5wUc + FQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBaIrxMWkAQWoAUmqrzj5wU8NoivEwAZ + HBUAFQAVEAAAFqiZ5JAHFdIBFvbtvJAHFXYAJsrB4+cFHBUKGTUIBgAZGAptaW5faGVpZ2h0FQwW + iK8TFpAEFqAFJsrB4+cFPDaIrxMAGRwVABUAFRAAABb6muSQBxXSARbs7ryQBxV2ACbqxuPnBRwV + Ahk1CAYAGRgJbWluX2Zsb29yFQwWiK8TFpAEFqAFJurG4+cFPDaIrxMAGRwVABUAFRAAABbMnOSQ + BxXSARbi77yQBxV2ACaKzOPnBRwVDBk1CAYAGRgMZmFjYWRlX2NvbG9yFQwWiK8TFpAEFqAFJorM + 4+cFPDaIrxMAGRwVABUAFRAAABaenuSQBxXSARbY8LyQBxV2ACaq0ePnBRwVDBk1CAYAGRgPZmFj + YWRlX21hdGVyaWFsFQwWiK8TFqoEFroFJqrR4+cFPBgEd29vZBgEd29vZBaGrxMoBHdvb2QYBHdv + b2QAGRwVABUAFRAAABbwn+SQBxXSARbO8byQBxWGAQAm5Nbj5wUcFQwZNQgGABkYDXJvb2ZfbWF0 + ZXJpYWwVDBaIrxMWkAQWoAUm5Nbj5wU8NoivEwAZHBUAFQAVEAAAFsKh5JAHFdIBFtTyvJAHFXYA + JoTc4+cFHBUMGTUIBgAZGApyb29mX3NoYXBlFQwWiK8TFpAEFqAFJoTc4+cFPDaIrxMAGRwVABUA + FRAAABaUo+SQBxXSARbK87yQBxV2ACak4ePnBRwVChk1CAYAGRgOcm9vZl9kaXJlY3Rpb24VDBaI + rxMWkAQWoAUmpOHj5wU8NoivEwAZHBUAFQAVEAAAFuak5JAHFdIBFsD0vJAHFXYAJsTm4+cFHBUM + GTUIBgAZGBByb29mX29yaWVudGF0aW9uFQwWiK8TFpAEFqAFJsTm4+cFPDaIrxMAGRwVABUAFRAA + ABa4puSQBxXSARa29byQBxV2ACbk6+PnBRwVDBk1CAYAGRgKcm9vZl9jb2xvchUMFoivExaQBBag + BSbk6+PnBTw2iK8TABkcFQAVABUQAAAWiqjkkAcV0gEWrPa8kAcVdgAmhPHj5wUcFQoZNQgGABkY + C3Jvb2ZfaGVpZ2h0FQwWiK8TFpAEFqAFJoTx4+cFPDaIrxMAGRwVABUAFRAAABbcqeSQBxXSARai + 97yQBxV2ABbynYcbFoivEyb+p/nZBRamzuoNFGYAGfwmJqT24+cFHBUMGTUIBgAZGAJpZBUMFrC+ + ExaQyr0FFp7VxwEmpPbj5wU8NgAoIDA4YmIyYzU0OWVkMjNmZmYwMjAwNTViOGMxNGViMzg5GCAw + OGJiMmMwODAwMzI1ZmZmMDIwMDE4ODlmZTNmNzZhYQAZHBUAFQAVEAAAFq6r5JAHFfIBFpj4vJAH + FdYIACbCy6vpBRwVDBk1CAYAGRgIZ2VvbWV0cnkVDBawvhMW3M2HEBaC1ccJJsLLq+kFPDYAKIkM + AAAAAAMAAAAMAAAAJsBRzAfKz5yLwEDXBIPzPyfAUcwHLRrrPsBA1w0lgnCIwFHMBDAQaQTAQNcM + Mj1p7sBRzAChD6+gwEDXGcxZ4EbAUcv7REP8r8BA1xiObD7twFHL+rfBos3AQNcTeVmIMsBRy/o8 + BkCMwEDXE2YOUdLAUcv5+H8CP8BA1xZcYtdmwFHL+ML03LbAQNcV/0XF3cBRy/iQn/XUwEDXGB4D + 9wbAUcvmZLjnPcBA1xMbZbcUwFHL5yP7h8vAQNcMvlRkBcBRy+2fP8vIwEDXCyJy8Y/AUcvuWQ6P + D8BA1wVIPl0zwFHL7YMluc7AQNcFLI+rA8BRy+4Vh1DCwEDW/8LDXo/AUcvtbH+FG8BA1vW0TKNH + wFHL6T/KGmvAQNbytL3iTsBRy+rJonXhwEDW7GDmyqXAUcvrLrejcMBA1uw7/d0QwFHL63geHs/A + QNbrSLjWdsBRy+2wBsNpwEDW6wdKdx3AUcvugBBbmMBA1vKiSWuEwFHL8RKR0vzAQNbzLmBlm8BR + y/SQy5S+wEDW5CaFpcfAUcv1xlW6R8BA1uT+G/oywFHL9si0OVjAQNbjBEa2nsBRy/mTadSwwEDW + 5zlfnR/AUcv954xrtMBA1uoTLrDtwFHMAgjuvAvAQNbrWy1NQMBRy/8iim6DwEDW9rrc4EDAUcv7 + uouBqcBA1vXQ0hULwFHL+55xb6/AQNb3WWhRIsBRzAUy2kfgwEDW+lnN0bDAUcwEj7G5S8BA1wJu + b0lkwFHMBhQWN3rAQNcCr92ovcBRzAYUFjd6wEDXBBOK9z/AUcwHys+ci8BA1wSD8z8nAAAABcBR + zAENRjmgwEDXBvQQB7XAUcv+j713xcBA1wZiGdCMwFHL/jtvQdfAQNcKXv6TGMBRzAC4+AOywEDX + CvD0ykLAUcwBDUY5oMBA1wb0EAe1AAAABcBRy/piMU2AwEDXCZ03s8vAUcv5FL7T5sBA1wlIfh4T + wFHL+ILInLzAQNcPfUuFOsBRy/nQOxZXwEDXD9IFGvLAUcv6YjFNgMBA1wmdN7PLAAAABcBRy/Xj + RovWwEDXCrcTJyTAUcvw8W9DhcBA1wmCX8ExwFHL8LyWHeTAQNcL2v+Vd8BRy/WubWY1wEDXDRCJ + uv/AUcv140aL1sBA1wq3EyckAAAABcBRy+vohma3wEDXDj6HJEzAUcvoBMwXm8BA1w8egPSHwFHL + 59frDgDAQNcQxHNh98BRy+uUODDJwEDXEXZKCTnAUcvr6IZmt8BA1w4+hyRMAAAABcBRy/uBFT5W + wEDW/O0mCKjAUcv6M6LEvMBA1vyXlbNbwFHL+aGsjZLAQNcCzGMagsBRy/rvHwcswEDXAyEcsDrA + Ucv7gRU+VsBA1vztJgioAAAABcBRy/YT7fOOwEDW/nM4BgHAUcv2Rq46O8BA1vyhpq5VwFHL8kWX + ucbAQNb7bPNIYsBRy/IS13MZwEDW/T9bX6LAUcv2E+3zjsBA1v5zOAYBAAAABcBRy/kzyIRpwEDW + 8/y8fqHAUcv0yP+4ssBA1vGACnxbwFHL9BUQMn3AQNbzu04fSMBRy/kdIk+2wEDW9QJ1/AbAUcv5 + M8iEacBA1vP8vH6hAAAABcBRy/5CkJ5IwEDW7wDUO1bAUcv9DXHYisBA1vPTodMkwFHL/YE1HsbA + QNb0JCmq9MBRy/616IS5wEDW71FcEybAUcv+QpCeSMBA1u8A1DtWAAAABcBRy/qAZD5uwEDW7EKz + 2bfAUcv5S7DYesBA1vEVgXGFwFHL+b90HrbAQNbxZglJVcBRy/r0J4SpwEDW7JM7sYfAUcv6gGQ+ + bsBA1uxCs9m3AAAABcBRy/eUjBOfwEDW6pRd8HbAUcv2X21N4cBA1u9nK4hEwFHL9tMwlB3AQNbv + t7NgFMBRy/gH4/oQwEDW6uTlyEbAUcv3lIwTn8BA1uqUXfB2AAAABcBRy/Uhf6yJwEDW6P2E+33A + Ucvz7GDmy8BA1u3QUpNLwFHL9GAkLQbAQNbuINprG8BRy/WVQvLEwEDW6U4M003AUcv1IX+sicBA + 1uj9hPt9GE0AAAAAAwAAAAEAAAAEwFHLCQFKWUHAQNOpy5EWKcBRywkc+nV0wEDTqt68He/AUcsI + obvHr8BA06sBbWA9wFHLCQFKWUHAQNOpy5EWKQAZHBUAFQAVJAAAFqCt5JAHFaAEFu6AvZAHFa4l + ACaEv4XzBRwVCBk1CAYEGSgEYmJveAR4bWluFQwWsL4TFrCyPxaylzYmhL+F8wUmxKDz8gUcGAQD + CI7CGAROaI/CFgAoBAMIjsIYBE5oj8IAGSwVBBUEFQIAFQAVBBUQAAAWwLHkkAcV8gEWnKa9kAcV + 1gEAJsLcu/MFHBUIGTUIBgQZKARiYm94BHhtYXgVDBawvhMW1ro/FtybNibC3LvzBSb2t6nzBRwY + BPUHjsIYBEJoj8IWACgE9QeOwhgEQmiPwgAZLBUEFQQVAgAVABUEFRAAABays+SQBxXyARbyp72Q + BxXWAQAm0tPf8wUcFQgZNQgGABkoBGJib3gEeW1pbhUMFrC+ExaO/k0W3qosJtLT3/MFPBgEBpgF + whgEEgAHwhYAKAQGmAXCGAQSAAfCABkcFQAVABUQAAAWpLXkkAcV8gEWyKm9kAcV1gEAJrD+i/QF + HBUIGTUIBgAZKARiYm94BHltYXgVDBawvhMWkP5NFrKmLCaw/ov0BTwYBNWXBcIYBPX/BsIWACgE + 1ZcFwhgE9f8GwgAZHBUAFQAVEAAAFpa35JAHFfIBFp6rvZAHFdYBACaipbj0BRwVAhklCAQZGAd2 + ZXJzaW9uFQwWsL4TFv4DFqAFJqKluPQFJuKkuPQFHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAA + ABksFQQVBBUCABUAFQQVEAAAFoi55JAHFdIBFvSsvZAHFdYBACbCqrj0BRwVDBklBgQZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFrC+Exb+BRagBybCqrj0BSaCqrj0BRwYABgAFgAo + ABgAABksFQQVBBUCABUAFQQVEAAAFtq65JAHFdIBFsquvZAHFVYAJuayuPQFHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBawvhMWuusEFsjuAibmsrj0BSaisbj0BRw2ACgN + T3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFqy8 + 5JAHFeIBFqCvvZAHFfYEACbqn7v0BRwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNv + cmRfaWQVDBawvhMWhNnfAhaAj4oBJuqfu/QFPDYAKAx3OTk3MzE1NDk3QDEYDDAwMDA0Mjg4OGNh + NwAZHBUAFQAVEAAAFo6+5JAHFfIBFpa0vZAHFc4DACaE6cX1BRwVDBklBgQZSAdzb3VyY2VzBGxp + c3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFrC+Exb8yxUW1L4GJoTpxfUFJuquxfUFHDYAKBgyMDI0 + LTExLTMwVDE2OjUyOjM5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZLBUEFQQVAgAV + ABUEFRAAABaAwOSQBxXiARbkt72QBxXWBgAm0ovN9QUcFQoZJQYEGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQKY29uZmlkZW5jZRUMFrC+Exai5hUWprQSJtKLzfUFJr7ty/UFHBgIB/AWSFD87j8YCM3M + zMzMzOQ/FoLDCygIB/AWSFD87j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAAFuLB5JAHFfIB + Frq+vZAHFfYCACbkod71BRwVAhk1CAYAGRgFbGV2ZWwVDBawvhMWhAUWlAYm5KHe9QU8GAQDAAAA + GAQBAAAAFqK+EygEAwAAABgEAQAAAAAZHBUAFQAVEAAAFtTD5JAHFdQBFrDBvZAHFaYBACagqt71 + BRwVDBk1CAYEGRgHc3VidHlwZRUMFrC+ExbyHhbUHCagqt71BSb4p971BRw24K4TKA50cmFuc3Bv + cnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFqjF5JAHFeIBFtbCvZAHFbID + ACaUyN71BRwVDBk1CAYEGRgFY2xhc3MVDBawvhMW6B4WjhwmlMje9QUmzMTe9QUcNrivEygJd2Fy + ZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAAForH5JAHFeIBFojGvZAHFeICACba + 4N71BRwVChk1CAYAGRgGaGVpZ2h0FQwWsL4TFqoEFroFJtrg3vUFPBgIAAAAAAAAIEAYCAAAAAAA + ACBAFq6+EygIAAAAAAAAIEAYCAAAAAAAACBAABkcFQAVABUQAAAW7MjkkAcV0gEW6si9kAcVlgEA + JpTm3vUFHBUMGTUIBgAZKAVuYW1lcwdwcmltYXJ5FQwWsL4TFso3FugoJpTm3vUFPDbcvBMoEmJv + dGlsbGVyaWEgZWwgQXJhbxgQQVBSIExhcyBNZXJjZWRlcwAZHBUAFQAVEAAAFr7K5JAHFeABFoDK + vZAHFa4FACb8jt/1BRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFrS+Exba + DRauDSb8jt/1BTw2rL4TKAJlcxgCZW4AGRwVABUAFRAAABaezOSQBxXgARauz72QBxV+ACaqnN/1 + BRwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWtL4TFtoPFsINJqqc3/UF + PDasvhMoClN0YXRlIEJhbmsYDEJhbmNvIEVzdGFkbwAZHBUAFQAVEAAAFv7N5JAHFeABFqzQvZAH + FaIBACbsqd/1BRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFri+ + ExaiEBbQDSbsqd/1BTw2qL4TKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABkcFQAVABUQAAAW3s/kkAcV + 4AEWztG9kAcV2gEAJry33/UFHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5n + dWFnZRUMFri+ExaSDxamDSa8t9/1BTw2sL4TKAJlcxgCZW4AGRwVABUAFRAAABa+0eSQBxXgARao + 072QBxV+ACbixN/1BRwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBa4 + vhMWpBIW8g4m4sTf9QU8Nqi+EygQQ2FzYSBMYSBQYWphcmVyYRgZQmFuY28gZGVsIEVzdGFkbyBk + ZSBDaGlsZQAZHBUAFQAVEAAAFp7T5JAHFeABFqbUvZAHFYADACbU09/1BRwVChklBgAZeAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2VlbgRsaXN0B2VsZW1lbnQVDBa4vhMW5g4WjA0m1NPf + 9QU8Nri+EwAZHBUAFQAVEAAAFv7U5JAHFeABFqbXvZAHFXYAJuDg3/UFHBUMGSUGABlYBW5hbWVz + BXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwWuL4TFuIOFoYNJuDg3/UFPDa4vhMAGRwVABUAFRAA + ABbe1uSQBxXgARac2L2QBxV2ACbm7d/1BRwVABk1CAYAGRgJaGFzX3BhcnRzFQwWsL4TFoa8Ahaw + Bibm7d/1BTwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFr7Y5JAHFdIBFpLZvZAHFXYAJpb03/UF + HBUAGTUIBgAZGA5pc191bmRlcmdyb3VuZBUMFrC+ExaGvAIWsAYmlvTf9QU8GAEAGAEAFgAoAQAY + AQAAGRwVABUAFRAAABaQ2uSQBxXSARaI2r2QBxV2ACam+9/1BRwVAhk1CAYEGRgKbnVtX2Zsb29y + cxUMFrC+ExbkBxaGCSam+9/1BSbG+t/1BRwYBAUAAAAYBAEAAAAW+rwTKAQFAAAAGAQBAAAAABks + FQQVBBUCABUAFQQVEAAAFuLb5JAHFdgBFv7avZAHFdYBACbMg+D1BRwVAhk1CAYAGRgWbnVtX2Zs + b29yc191bmRlcmdyb3VuZBUMFrC+ExaQBBagBSbMg+D1BTw2sL4TABkcFQAVABUQAAAWut3kkAcV + 0gEW1Ny9kAcVdgAm7Ijg9QUcFQoZNQgGABkYCm1pbl9oZWlnaHQVDBawvhMWkAQWoAUm7Ijg9QU8 + NrC+EwAZHBUAFQAVEAAAFozf5JAHFdIBFsrdvZAHFXYAJoyO4PUFHBUCGTUIBgAZGAltaW5fZmxv + b3IVDBawvhMWkAQWoAUmjI7g9QU8NrC+EwAZHBUAFQAVEAAAFt7g5JAHFdIBFsDevZAHFXYAJqyT + 4PUFHBUMGTUIBgAZGAxmYWNhZGVfY29sb3IVDBawvhMWkAQWoAUmrJPg9QU8NrC+EwAZHBUAFQAV + EAAAFrDi5JAHFdIBFrbfvZAHFXYAJsyY4PUFHBUMGTUIBgAZGA9mYWNhZGVfbWF0ZXJpYWwVDBaw + vhMWqgQWugUmzJjg9QU8GAR3b29kGAR3b29kFq6+EygEd29vZBgEd29vZAAZHBUAFQAVEAAAFoLk + 5JAHFdIBFqzgvZAHFYYBACaGnuD1BRwVDBk1CAYAGRgNcm9vZl9tYXRlcmlhbBUMFrC+Exa2BBbG + BSaGnuD1BTwYCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMWrr4TKApyb29mX3RpbGVzGApyb29mX3Rp + bGVzABkcFQAVABUQAAAW1OXkkAcV0gEWsuG9kAcVngEAJsyj4PUFHBUMGTUIBgAZGApyb29mX3No + YXBlFQwWsL4TFtAEFuAFJsyj4PUFPDasvhMoCHNraWxsaW9uGAZoaXBwZWQAGRwVABUAFRAAABam + 5+SQBxXUARbQ4r2QBxWSAQAmrKng9QUcFQoZNQgGABkYDnJvb2ZfZGlyZWN0aW9uFQwWsL4TFpAE + FqAFJqyp4PUFPDawvhMAGRwVABUAFRAAABb66OSQBxXSARbi472QBxV2ACbMruD1BRwVDBk1CAYA + GRgQcm9vZl9vcmllbnRhdGlvbhUMFrC+ExaQBBagBSbMruD1BTw2sL4TABkcFQAVABUQAAAWzOrk + kAcV0gEW2OS9kAcVdgAm7LPg9QUcFQwZNQgGABkYCnJvb2ZfY29sb3IVDBawvhMWkAQWoAUm7LPg + 9QU8NrC+EwAZHBUAFQAVEAAAFp7s5JAHFdIBFs7lvZAHFXYAJoy54PUFHBUKGTUIBgAZGAtyb29m + X2hlaWdodBUMFrC+ExaQBBagBSaMueD1BTw2sL4TABkcFQAVABUQAAAW8O3kkAcV0gEWxOa9kAcV + dgAWrpv3GhawvhMmpPbj5wUWiMj8DRRoABn8JiasvuD1BRwVDBk1CAYAGRgCaWQVDBbI+RQWup3y + BRaogNUBJqy+4PUFPDYAKCAwOGJiMmM1NWIzZDQ4ZmZmMDIwMDhlOWU3YTVkMjczZBggMDhiYjJj + MDg2NTkzNGZmZjAyMDBkOTA1YjhiNzE4ZjEAGRwVABUAFRIAABbC7+SQBxWQAha6572QBxXeCQAm + 1L619wUcFQwZNQgGABkYCGdlb21ldHJ5FQwWyPkUFoLGkxEWlOmMCibUvrX3BTw2ACiFBgAAAAAD + AAAABwAAAA/AUdqMEfGaDMBAqGMn7YTTwFHaiu7b607AQKhjVGMupMBR2oqAISKPwECoW23k3+nA + UdqNDgV8QcBAqFeV6QrxwFHaiUHIIWzAQKhQiK6Py8BR2pTs9w7AwECoPvk6EyHAUdqc9W6shsBA + qE3i4eIIwFHamuQcdKvAQKhQ/8zUWsBR2ptU8BxdwECoUsMbcyPAUdqSXdCVr8BAqF3HW3PEwFHa + kpsNNyDAQKhiJzyE7MBR2pGDtgKGwECoYlIEr5LAUdqQiA2AG8BAqGJ4mxxRwFHajP2p5GrAQKhj + AwSXPsBR2owR8ZoMwECoYyfthNMAAAAGwFHajrRjSXvAQKhZbVmfr8BR2oxtYSxrwECoXPxaWRLA + UdqMhbTgR8BAqF7xJx8pwFHaj34iRM7AQKheis/SO8BR2pCZP9eGwECoXM/kr0LAUdqOtGNJe8BA + qFltWZ+vAAAABcBR2pF91sV0wECoSO6GWvjAUdqOY3AR4cBAqE2tMfzSwFHakaie8BvAQKhTpnBB + scBR2pTDcQN4wECoTubt4EPAUdqRfdbFdMBAqEjuhlr4AAAABcBR2pdrVpAwwECoROyZGu/AUdqT + cWFsLMBAqErvEZszwFHalTFVDKLAQKhOKwY+CMBR2pkrSjCmwECoSCiNvcPAUdqXa1aQMMBAqETs + mRrvAAAABcBR2pgHXcJTwECoS+xnnMfAUdqXHwB2SMBAqE1URqkywFHamUYiI0DAQKhRNlN5JMBR + 2pouFA+BwECoT850bLnAUdqYB13CU8BAqEvsZ5zHAAAABcBR2pHaHRdowECoVOHZpEzAUdqRH+L0 + VsBAqFYU34sVwFHak5hjOLTAQKhaSErybcBR2pRTCLuQwECoWRVFC6PAUdqR2h0XaMBAqFTh2aRM + AAAABcBR2pVKFCBIwECoURj3R8vAUdqUBrKhqMBAqFMVUModwFHalfPyq4TAQKhWgezUqsBR2pc3 + VCokwECoVIZqEe3AUdqVShQgSMBAqFEY90fLGE0AAAAAAwAAAAEAAAAEwFHGaUNTSOvAQLwhB5DJ + 8MBRxmlfpoWPwEC8IiMF5+TAUcZo4hMubcBAvCJGR1wMwFHGaUNTSOvAQLwhB5DJ8AAZHBUAFQAV + JgAAFtLx5JAHFb4EFpjxvZAHFbYnACamntKBBhwVCBk1CAYEGSgEYmJveAR4bWluFQwWyPkUFvq2 + PxbYvzYmpp7SgQYm6KfCgQYcGAQECI7CGAQJcI/CFgAoBAQIjsIYBAlwj8IAGSwVBBUEFQIAFQAV + BBUSAAAWkPbkkAcVkAIWzpi+kAcV7gEAJubfiIIGHBUIGTUIBgQZKARiYm94BHhtYXgVDBbI+RQW + lrk/FtzDNibm34iCBibA5/iBBhwYBPwHjsIYBPpvj8IWACgE/AeOwhgE+m+PwgAZLBUEFQQVAgAV + ABUEFRIAABag+OSQBxWQAha8mr6QBxXuAQAmnKuvggYcFQgZNQgGABkoBGJib3gEeW1pbhUMFsj5 + FBa661MW/r4uJpyrr4IGPBgECDAEwhgEDUwGwhYAKAQIMATCGAQNTAbCABkcFQAVABUSAAAWsPrk + kAcVkAIWqpy+kAcV7gEAJprq3YIGHBUIGTUIBgAZKARiYm94BHltYXgVDBbI+RQWuutTFrTALiaa + 6t2CBjwYBMgvBMIYBPZLBsIWACgEyC8EwhgE9ksGwgAZHBUAFQAVEgAAFsD85JAHFZACFpievpAH + Fe4BACaOq4yDBhwVAhklCAQZGAd2ZXJzaW9uFQwWyPkUFrgEFuwFJo6rjIMGJs6qjIMGHBgEAAAA + ABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEgAAFtD+5JAHFewBFoagvpAHFe4B + ACb6sIyDBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFsj5FBbYBhaM + CCb6sIyDBia6sIyDBhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEgAAFryA5ZAHFewBFvShvpAH + FV4AJoq6jIMGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbI+RQWyJwF + FvKrAyaKuoyDBibGuIyDBhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdz + ABksFQQVBBUCABUAFQQVEgAAFqiC5ZAHFf4BFtKivpAHFcIFACa45I+DBhwVDBklBgAZSAdzb3Vy + Y2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbI+RQW/JP7AhaSvooBJrjkj4MGPDYAKAx3OTg0 + NDU2NjUxQDIYDDAwMDAwYjgyMGE1MQAZHBUAFQAVEgAAFqaE5ZAHFZACFpSovpAHFY4EACayppyE + BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFsj5FBb4iiMW0tYL + JrKmnIQGJsqimoQGHDYAKBgyMDI0LTExLTEyVDIwOjI3OjU0LjAwMFoYGDIwMDAtMDEtMDFUMDA6 + MDA6MDAuMDAwWgAZLBUEFQQVAgAVABUEFRIAABa2huWQBxWGAhairL6QBxW+BwAm3JSnhAYcFQoZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsj5FBbotRcW7vwTJtyUp4QG + Jpz5pYQGHBgI0ETY8PRK7z8YCM3MzMzMzOQ/FuqbDCgI0ETY8PRK7z8YCM3MzMzMzOQ/ABksFQQV + BBUCABUAFQQVEgAAFryI5ZAHFY4CFuCzvpAHFaIDACaK9rmEBhwVAhk1CAYAGRgFbGV2ZWwVDBbI + +RQWlAYWogcmiva5hAY8GAQBAAAAGAT/////FrD5FCgEAQAAABgE/////wAZHBUAFQAVEgAAFsqK + 5ZAHFe4BFoK3vpAHFdIBACbG/7mEBhwVDBk1CAYEGRgHc3VidHlwZRUMFsj5FBbERBb0OCbG/7mE + Bias/bmEBhw2usIUKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EgAAFriM5ZAHFf4BFtS4vpAHFdIDACaWurqEBhwVDBk1CAYEGRgFY2xhc3MVDBbI+RQWpE0WrD8m + lrq6hAYmoLa6hAYcNvLDFCgJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEgAA + FraO5ZAHFf4BFqa8vpAHFdIDACbM9bqEBhwVChk1CAYAGRgGaGVpZ2h0FQwWyPkUFpwwFrANJsz1 + uoQGPBgIAAAAAAAAM0AYCAAAAAAAAAhAFrL0FCgIAAAAAAAAM0AYCAAAAAAAAAhAABkcFQAVABUS + AAAWtJDlkAcV8gEW+L++kAcV4gEAJvyCu4QGHBUMGTUIBgAZKAVuYW1lcwdwcmltYXJ5FQwWyPkU + FrqJARbGVyb8gruEBjw2sPUUKBRjYXBpbGxhIEpvc8OpIE9icmVybxgDMTJBABkcFQAVABUSAAAW + ppLlkAcV/gEW2sG+kAcV5gUAJsLau4QGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUD + a2V5FQwWzPkUFoYYFs4UJsLau4QGPDbE+RQoAmVzGAJlbgAZHBUAFQAVEgAAFqSU5ZAHFf4BFsDH + vpAHFZIBACaQ77uEBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWzPkU + FqgcFpIWJpDvu4QGPDbE+RQoEUNvbmdyZXNvIE5hY2lvbmFsGA5CYW5jbyBkZSBDaGlsZQAZHBUA + FQAVEgAAFqKW5ZAHFf4BFtLIvpAHFfwBACaihbyEBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQHdmFyaWFudBUMFsz5FBbSHBa6FiaihbyEBjw2vPkUKAhvZmZpY2lhbBgJYWx0ZXJu + YXRlABkcFQAVABUSAAAWoJjlkAcV/gEWzsq+kAcVigIAJtybvIQGHBUMGSUGABlYBW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFsz5FBaKGxaQFSbcm7yEBjw2zPkUABkcFQAVABUS + AAAWnprlkAcV/gEW2My+kAcVggEAJuywvIQGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAV2YWx1ZRUMFsz5FBbeHhaKGCbssLyEBjw2vPkUKBtFZGlmaWNpbyBUZWNub2zDs2dpY28g + Q09SRk8YH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJzaW9uZXMAGRwVABUAFRIAABacnOWQBxX+ + ARbazb6QBxWcBAAm9si8hAYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdl + ZW4EbGlzdAdlbGVtZW50FQwWzPkUFo4bFpIVJvbIvIQGPDbM+RQAGRwVABUAFRIAABaanuWQBxX+ + ARb20b6QBxWCAQAmiN68hAYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUV + DBbM+RQWihsWkBUmiN68hAY8Nsz5FAAZHBUAFQAVEgAAFpig5ZAHFf4BFvjSvpAHFYIBACaY87yE + BhwVABk1CAYAGRgJaGFzX3BhcnRzFQwWyPkUFv7TAhagByaY87yEBjwYAQEYAQAWACgBARgBAAAZ + HBUAFQAVEgAAFpai5ZAHFewBFvrTvpAHFYIBACa4+ryEBhwVABk1CAYAGRgOaXNfdW5kZXJncm91 + bmQVDBbI+RQW/tMCFpYHJrj6vIQGPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAWgqTlkAcV7AEW + /NS+kAcVggEAJs6BvYQGHBUCGTUIBgAZGApudW1fZmxvb3JzFQwWyPkUFvQ4FuAWJs6BvYQGPBgE + GAAAABgEAQAAABbC7xQoBBgAAAAYBAEAAAAAGRwVABUAFRIAABbupeWQBxX6ARb+1b6QBxWCAgAm + rpi9hAYcFQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbI+RQW0gQW9AUmrpi9hAY8 + Nsj5FAAZHBUAFQAVEgAAFuin5ZAHFewBFoDYvpAHFYIBACainr2EBhwVChk1CAYAGRgKbWluX2hl + aWdodBUMFsj5FBbSBBb0BSainr2EBjw2yPkUABkcFQAVABUSAAAW1KnlkAcV7AEWgtm+kAcVggEA + JpakvYQGHBUCGTUIBgAZGAltaW5fZmxvb3IVDBbI+RQW0gQW9AUmlqS9hAY8Nsj5FAAZHBUAFQAV + EgAAFsCr5ZAHFewBFoTavpAHFYIBACaKqr2EBhwVDBk1CAYAGRgMZmFjYWRlX2NvbG9yFQwWyPkU + FtIEFvQFJoqqvYQGPDbI+RQAGRwVABUAFRIAABasreWQBxXsARaG276QBxWCAQAm/q+9hAYcFQwZ + NQgGABkYD2ZhY2FkZV9tYXRlcmlhbBUMFsj5FBbSBBb0BSb+r72EBjw2yPkUABkcFQAVABUSAAAW + mK/lkAcV7AEWiNy+kAcVggEAJvK1vYQGHBUMGTUIBgAZGA1yb29mX21hdGVyaWFsFQwWyPkUFtIE + FvQFJvK1vYQGPDbI+RQAGRwVABUAFRIAABaEseWQBxXsARaK3b6QBxWCAQAm5ru9hAYcFQwZNQgG + ABkYCnJvb2Zfc2hhcGUVDBbI+RQW7hQWogcm5ru9hAY8NoL4FCgGZ2FibGVkGARmbGF0ABkcFQAV + ABUSAAAW8LLlkAcV7gEWjN6+kAcVugEAJojDvYQGHBUKGTUIBgAZGA5yb29mX2RpcmVjdGlvbhUM + Fsj5FBbSBBb0BSaIw72EBjw2yPkUABkcFQAVABUSAAAW3rTlkAcV7AEWxt++kAcVggEAJvzIvYQG + HBUMGTUIBgAZGBByb29mX29yaWVudGF0aW9uFQwWyPkUFtIEFvQFJvzIvYQGPDbI+RQAGRwVABUA + FRIAABbKtuWQBxXsARbI4L6QBxWCAQAm8M69hAYcFQwZNQgGABkYCnJvb2ZfY29sb3IVDBbI+RQW + 0gQW9AUm8M69hAY8Nsj5FAAZHBUAFQAVEgAAFra45ZAHFewBFsrhvpAHFYIBACbk1L2EBhwVChk1 + CAYAGRgLcm9vZl9oZWlnaHQVDBbI+RQW0gQW9AUm5NS9hAY8Nsj5FAAZHBUAFQAVEgAAFqK65ZAH + FewBFszivpAHFYIBABbY3fEcFsj5FCasvuD1BRasnN0OFGoAGfwmJtjavYQGHBUMGTUIBgAZGAJp + ZBUMFtSOFRbqlPgFFpbs1AEm2Nq9hAY8NgAoIDA4YmIyYzU1YjZkYWNmZmYwMjAwNzk0ZDEzNDVk + MjFiGCAwOGJiMmMwOTIwMDRjZmZmMDIwMDZhNTJhNDFlNGFjMgAZHBUAFQAVEgAAFo685ZAHFZAC + Fs7jvpAHFd4JACbuxpKGBhwVDBk1CAYAGRgIZ2VvbWV0cnkVDBbUjhUW1tC4ERbQoqcKJu7GkoYG + PDYAKKMFAAAAAAYAAAACAAAAAAMAAAABAAAAFMBR5JVx7KxmwECHYBocCvnAUeSVnfb2bMBAh2CS + EQ8cwFHklbBrbTbAQIdhG6PKdcBR5JWoB/FmwECHYae6xI3AUeSVhTfixcBAh2IoE0SAwFHklUvB + n3LAQIdij0FRA8BR5JUBhGR+wECHYtJdL4bAUeSUruOtusBAh2LqsONiwFHklFh8mNjAQIdi0zPv + G8BR5JQLux8lwECHYo2T0dnAUeST0QK8c8BAh2IghohFwFHkk68JbWfAQIdhmXgLqsBR5JOplZAg + wECHYQeB1IHAUeSTwX3kMcBAh2B5vVtAwFHkk/PSyxTAQIdgAp8WscBR5JQ7IGd/wECHX60OwWTA + UeSUj26dbcBAh1+EytV8wFHklONRc5DAQIdfi4DSIsBR5JUxwGxswECHX76seJnAUeSVceysZsBA + h2AaHAr5AAAAAAMAAAABAAAAFMBR5JR1AgqcwECHboohVpLAUeSUoKD02MBAh28CFlq1wFHklLMV + a6LAQIdvi6kWDsBR5JSqse/SwECHcBfAECbAUeSUh+HhMcBAh3CY70+vwFHklE5rnd7AQIdw/0ac + ncBR5JQEmcK0wECHcUJiex/AUeSTsY2sJsBAh3Fati78wFHkk1sml0PAQIdxQzk6tMBR5JMOZR2R + wECHcP2ZHXPAUeSS06y638BAh3CQi9PewFHkkrGza9PAQIdwCX1XRMBR5JKsqu5WwECHb3eHIBrA + UeSSxJNCaMBAh27qmWZuwFHkkvboKUrAQIducqRiSsBR5JM+NcW1wECHbh0UDP3AUeSTkhib2MBA + h2300CEVwFHkk+X7cfzAQIdt+4YdvMBR5JQ0amrYwECHbi+Ig8jAUeSUdQIKnMBAh26KIVaSGE0A + AAAAAwAAAAEAAAAEwFHIFCivjUnAQK7S+U8CX8BRyBP4h2tywECu1DxT1PHAUcgTdnV5aMBArtQF + tuD1wFHIFCivjUnAQK7S+U8CXwAZHBUAFQAVKAAAFp6+5ZAHFdwEFqztvpAHFb4pACaY782QBhwV + CBk1CAYEGSgEYmJveAR4bWluFQwW1I4VFtqXRBagyzommO/NkAYmvum5kAYcGAQG243CGARkM4/C + FgAoBAbbjcIYBGQzj8IAGSwVBBUEFQIAFQAVBBUSAAAW+sLlkAcVkAIW6pa/kAcV7gEAJuS8iJEG + HBUIGTUIBgQZKARiYm94BHhtYXgVDBbUjhUWhptEFp7OOibkvIiRBibetPSQBhwYBPXajcIYBFIz + j8IWACgE9dqNwhgEUjOPwgAZLBUEFQQVAgAVABUEFRIAABaKxeWQBxWQAhbYmL+QBxXuAQAmyNe+ + kQYcFQgZNQgGBBkoBGJib3gEeW1pbhUMFtSOFRai1DwWyLI1JsjXvpEGJvyCr5EGHBgEBTAEwhgE + CwAHwhYAKAQFMATCGAQLAAfCABksFQQVBBUCABUAFQQVEgAAFprH5ZAHFZACFsaav5AHFe4BACbS + i/SRBhwVCBk1CAYEGSgEYmJveAR5bWF4FQwW1I4VFurVPBastTUm0ov0kQYmxLXkkQYcGASwLwTC + GATz/wbCFgAoBLAvBMIYBPP/BsIAGSwVBBUEFQIAFQAVBBUSAAAWqsnlkAcVkAIWtJy/kAcV7gEA + JrDrmZIGHBUCGSUIBBkYB3ZlcnNpb24VDBbUjhUWuAQW7AUmsOuZkgYm8OqZkgYcGAQAAAAAGAQA + AAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUSAAAWusvlkAcV7AEWop6/kAcV7gEAJpzx + mZIGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW1I4VFtgGFowIJpzx + mZIGJtzwmZIGHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUSAAAWps3lkAcV7AEWkKC/kAcVXgAm + rPqZkgYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUMFtSOFRbgowUWpLQD + Jqz6mZIGJuj4mZIGHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBCdWlsZGluZ3MAGSwV + BBUEFQIAFQAVBBUSAAAWks/lkAcV/gEW7qC/kAcVwgUAJoytnZIGHBUMGSUGABlIB3NvdXJjZXME + bGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFtSOFRaYmoQDFtrwigEmjK2dkgY8NgAoDHc5OTg3NzU5 + OTNAMRgMMDAwMjQyNzFmMmFiABkcFQAVABUSAAAWkNHlkAcVkAIWsKa/kAcVjgQAJp6RqpMGHBUM + GSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW1I4VFpD1JRbKuwomnpGq + kwYm5p2okwYcNgAoGDIwMjQtMTEtMjlUMjM6NTY6NTAuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDow + MC4wMDBaABksFQQVBBUCABUAFQQVEgAAFqDT5ZAHFYYCFr6qv5AHFb4HACb09LOTBhwVChklBgQZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW1I4VFoy9GRb4hhYm9PSzkwYmsNmy + kwYcGAhI4XoUrkfvPxgIzczMzMzM5D8Wvo0LKAhI4XoUrkfvPxgIzczMzMzM5D8AGSwVBBUEFQIA + FQAVBBUSAAAWptXlkAcVkAIW/LG/kAcVoAMAJvDgyJMGHBUCGTUIBgQZGAVsZXZlbBUMFtSOFRbe + BhaSCCbw4MiTBiao4MiTBhwYBAIAAAAYBAEAAAAWqo4VKAQCAAAAGAQBAAAAABksFQQVBBUCABUA + FQQVEgAAFrbX5ZAHFe4BFpy1v5AHFeIBACbe6siTBhwVDBk1CAYEGRgHc3VidHlwZRUMFtSOFRbe + dBaYYCbe6siTBia66MiTBhw29PITKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQV + BBUCABUAFQQVEgAAFqTZ5ZAHFf4BFv62v5AHFcwDACaazcmTBhwVDBk1CAYEGRgFY2xhc3MVDBbU + jhUWwIEBFuJoJprNyZMGJtLIyZMGHDbu9BMoCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQV + AgAVABUEFRIAABai2+WQBxX+ARbKur+QBxXCAwAmkLPKkwYcFQoZNQgGBBkYBmhlaWdodBUMFtSO + FRbKCxbOCyaQs8qTBia0scqTBhwYCAAAAAAAQEpAGAgAAAAAAAAAQBbojBUoCAAAAAAAQEpAGAgA + AAAAAAAAQAAZLBUEFQQVAgAVABUEFRIAABag3eWQBxX0ARaMvr+QBxWiAgAmxovLkwYcFQwZNQgG + BBkoBW5hbWVzB3ByaW1hcnkVDBbUjhUWttMBFsJ0JsaLy5MGJoK9ypMGHDbChRUoDcOBcmVhIEJv + ZGVnYXMYAjE4ABksFQQVBBUCABUAFQQVEgAAFpTf5ZAHFf4BFq7Av5AHFYQFACbEscuTBhwVDBkl + BgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFtSOFRbgIBb4GSbEscuTBjw21I4VABkc + FQAVABUSAAAWkuHlkAcV/gEWssW/kAcVggEAJrzLy5MGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglr + ZXlfdmFsdWUFdmFsdWUVDBbUjhUWsiYW8hsmvMvLkwY8NtSOFQAZHBUAFQAVEgAAFpDj5ZAHFf4B + FrTGv5AHFYIBACaY6MuTBhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFu + dBUMFtiOFRa8JxaGHSaY6MuTBiau58uTBhw2yI4VKAhvZmZpY2lhbBgJYWx0ZXJuYXRlABksFQQV + BBUCABUAFQQVEgAAFo7l5ZAHFf4BFrbHv5AHFeoBACa0hMyTBhwVDBklBgAZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbYjhUWxCYWkBwmtITMkwY8NtiOFQAZHBUAFQAVEgAA + Fozn5ZAHFf4BFqDJv5AHFYIBACaKo8yTBhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1l + bnQFdmFsdWUVDBbYjhUW+CkW6h4miqPMkwYmxKDMkwYcNsiOFSgQVU5DT1NPTCBRdWlscHXDqRgf + QmFuY28gZGUgQ3LDqWRpdG8gZSBJbnZlcnNpb25lcwAZLBUEFQQVAgAVABUEFRIAABaK6eWQBxX+ + ARaiyr+QBxXIAwAmrr/MkwYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdl + ZW4EbGlzdAdlbGVtZW50FQwW2I4VFsgmFpAcJq6/zJMGPDbYjhUAGRwVABUAFRIAABaI6+WQBxX+ + ARbqzb+QBxWCAQAmvtvMkwYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUV + DBbYjhUWxCYWkBwmvtvMkwY8NtiOFQAZHBUAFQAVEgAAFobt5ZAHFf4BFuzOv5AHFYIBACbO98yT + BhwVABk1CAYAGRgJaGFzX3BhcnRzFQwW1I4VFs7WAhaUBybO98yTBjwYAQAYAQAWACgBABgBAAAZ + HBUAFQAVEgAAFoTv5ZAHFewBFu7Pv5AHFYIBACbi/syTBhwVABk1CAYAGRgOaXNfdW5kZXJncm91 + bmQVDBbUjhUWztYCFpQHJuL+zJMGPBgBABgBABYAKAEAGAEAABkcFQAVABUSAAAW8PDlkAcV7AEW + 8NC/kAcVggEAJoCHzZMGHBUCGTUIBgQZGApudW1fZmxvb3JzFQwW1I4VFoRjFrBRJoCHzZMGJvaF + zZMGHBgEHAAAABgEAQAAABbCshQoBBwAAAAYBAEAAAAAGSwVBBUEFQIAFQAVBBUSAAAW3PLlkAcV + /AEW8tG/kAcVggIAJqbXzZMGHBUCGTUIBgAZGBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwW1I4V + FuIEFoQGJqbXzZMGPBgEAwAAABgEAwAAABbSjhUoBAMAAAAYBAMAAAAAGRwVABUAFRIAABbY9OWQ + BxXsARb007+QBxWSAQAmqt3NkwYcFQoZNQgGABkYCm1pbl9oZWlnaHQVDBbUjhUW0gQW9AUmqt3N + kwY8NtSOFQAZHBUAFQAVEgAAFsT25ZAHFewBFobVv5AHFYIBACae482TBhwVAhk1CAYAGRgJbWlu + X2Zsb29yFQwW1I4VFtIEFvQFJp7jzZMGPDbUjhUAGRwVABUAFRIAABaw+OWQBxXsARaI1r+QBxWC + AQAmkunNkwYcFQwZNQgGABkYDGZhY2FkZV9jb2xvchUMFtSOFRbSBBb0BSaS6c2TBjw21I4VABkc + FQAVABUSAAAWnPrlkAcV7AEWite/kAcVggEAJobvzZMGHBUMGTUIBgAZGA9mYWNhZGVfbWF0ZXJp + YWwVDBbUjhUW0gQW9AUmhu/NkwY8NtSOFQAZHBUAFQAVEgAAFoj85ZAHFewBFozYv5AHFYIBACb6 + 9M2TBhwVDBk1CAYAGRgNcm9vZl9tYXRlcmlhbBUMFtSOFRbSBBb0BSb69M2TBjw21I4VABkcFQAV + ABUSAAAW9P3lkAcV7AEWjtm/kAcVggEAJu76zZMGHBUMGTUIBgAZGApyb29mX3NoYXBlFQwW1I4V + Fr7vARbOHibu+s2TBjw26PgUKAhza2lsbGlvbhgEZmxhdAAZHBUAFQAVEgAAFuD/5ZAHFfYBFpDa + v5AHFf4BACa8mc6TBhwVChk1CAYAGRgOcm9vZl9kaXJlY3Rpb24VDBbUjhUW0gQW9AUmvJnOkwY8 + NtSOFQAZHBUAFQAVEgAAFtaB5pAHFewBFo7cv5AHFYIBACawn86TBhwVDBk1CAYAGRgQcm9vZl9v + cmllbnRhdGlvbhUMFtSOFRbSBBb0BSawn86TBjw21I4VABkcFQAVABUSAAAWwoPmkAcV7AEWkN2/ + kAcVggEAJqSlzpMGHBUMGTUIBgAZGApyb29mX2NvbG9yFQwW1I4VFtIEFvQFJqSlzpMGPDbUjhUA + GRwVABUAFRIAABauheaQBxXsARaS3r+QBxWCAQAmmKvOkwYcFQoZNQgGABkYC3Jvb2ZfaGVpZ2h0 + FQwW1I4VFtIEFvQFJpirzpMGPDbUjhUAGRwVABUAFRIAABaah+aQBxXsARaU37+QBxWCAQAWhNSJ + HRbUjhUm2Nq9hAYWtNaQDxRsABn8JiaMsc6TBhwVDBk1CAYAGRgCaWQVDBbMsxMWgMa6BRaA9cQB + JoyxzpMGPDYAKCAwOGJiMmM1N2I2ZDMxZmZmMDIwMDFiOTRlNmIzNmQxZhggMDhiYjJjMGIyMDEw + OWZmZjAyMDA1YzJmNWJjNjJlZGMAGRwVABUAFRAAABaGieaQBxXyARaW4L+QBxXWCAAmjKaTlQYc + FQwZNQgGABkYCGdlb21ldHJ5FQwWzLMTFsbOyBAW0Nv8CSaMppOVBjw2ACilCwAAAAADAAAABwAA + ADbAUbN3RvPaWMBA0ZejH1RZwFGzd1YNUs/AQNGZZ0Syt8BRs3egSo3DwEDRoiVZVd3AUbN15qGK + KcBA0aJOdAFawFGzdbZlgjvAQNGclB/dFcBRs3PUDTLuwEDRnL++x1HAUbNz2exwAMBA0Z2DMyXH + wFGzcYSnmg3AQNGdtYgMqcBRs3HLHnbkwEDRps/jAcLAUbN3ai9Iw8BA0aZXFz4KwFGzd3RAQ73A + QNGnrwYSacBRs3UuFOZBwEDRp90pO2PAUbN1UHmVF8BA0ayaJ14TwFGzd4a0uofAQNGsbbG0Q8BR + s3ebQhBGwEDRr1JogqDAUbNqiQrWHcBA0bBTGYKIwFGzasE++hHAQNG4SYgJTsBRs2BLLtJ7wEDR + uRcNYr/AUbNgQfSXFsBA0bfAzA2KwFGzXwW0dOfAQNG32R/BZsBRs18Aq/dqwEDRtyWbmvzAUbNc + bwE/m8BA0bdWQwK0wFGzXFmdKkjAQNG0L0cVaMBRs16HdNPnwEDRtAYsaevAUbNeQP33EcBA0amq + iNUmwFGzWattALTAQNGqABkqc8BRs1mThKyjwEDRpnzW6zTAUbNcRDkU9cBA0aZJq0S9wFGzXAQM + 1PvAQNGc8uptyMBRs1qN6w+uwEDRnQ6ZH/fAUbNasSZ+GcBA0aIFeOXFwFGzWMI49RTAQNGiKziS + 78BRs1iXBWqjwEDRnCtEUWnAUbNaBMO0H8BA0ZwN6CAPwFGzWfkFOfzAQNGac7Qsw8BRs15hScbz + wEDRmhdt2s/AUbNet7Db1cBA0aWFYCaxwFGzZRHSkFvAQNGk//8pQMBRs2S8QjsOwEDRmciTgijA + UbNnfv+6YMBA0ZmOsd8LwFGzZ3feXe/AQNGYovmUrMBRs2quyoNGwEDRmFrVOKzAUbNq1qMPZMBA + 0Z04iosJwFGzbVNVEarAQNGc/3+ngMBRs20z4AFdwEDRmS45zy/AUbNvgSy7SsBA0Zj5YKmOwFGz + b4wUddnAQNGaSBVCh8BRs3HuWeVPwEDRmg/hHpPAUbNx5fZpfsBA0ZkK/mDEwFGzcztg/x7AQNGY + 6/SwQcBRs3NF3VnjwEDRmixmkFjAUbN1hwA54sBA0Zn2tqsiwFGzdXQgY03AQNGXzed/AMBRs3dG + 89pYwEDRl6MfVFkAAAAJwFGzcMVk+X/AQNGoqCpWFcBRs2yH6JcuwEDRqQv9ZETAUbNse769QMBA + 0aeZNp1LwFGzahaJr0HAQNGn0WrBP8BRs2pGWldkwEDRrXohLk7AUbNsfkL7/sBA0a1GHshCwFGz + bHhjvuzAQNGskpqh18BRs3DjLIqjwEDRrCtslVXAUbNwxWT5f8BA0aioKlYVAAAABcBRs272V+CS + wEDRn+Dbd4rAUbNqs9MAw8BA0aBD18YlwFGzatflLsPAQNGkjRKimsBRs28aag6SwEDRpCk/lGvA + UbNu9lfgksBA0Z/g23eKAAAABcBRs2hc4KunwEDRqE5oQt/AUbNgva/5V8BA0ajuoTLrwFGzYSfN + pGPAQNG28Zk08MBRs2jHabZ9wEDRtlFgROTAUbNoXOCrp8BA0ahOaELfAAAABcBRs2gFN3dmwEDR + m9nlugTAUbNmPiJ6fsBA0ZwMOqDmwFGzZkzQkyvAQNGdeEtrOMBRs2gT5ZASwEDRnUX2hFbAUbNo + BTd3ZsBA0ZvZ5boEAAAABcBRs2goB4YGwEDRoKvckj3AUbNnBIZ3fsBA0aDJOMOWwFGzZysc5DzA + QNGk82nviMBRs2hOnfLFwEDRpNYNvi/AUbNoKAeGBsBA0aCr3JI9AAAABcBRs3PAwfyPwEDRqJnn + nTPAUbNyCnP3ScBA0ai+0IrHwFGzcib5aQ3AQNGsg4EpYMBRs3Pdss4ewEDRrF6YO8zAUbNzwMH8 + j8BA0aiZ550zGE0AAAAAAwAAAAEAAAAEwFGrm8tB6TDAQN6AGLuzxMBRq5vgHIDkwEDefzGAguXA + UaucfOIgGsBA3oBFdXQ/wFGrm8tB6TDAQN6AGLuzxAAZHBUAFQAVJgAAFviK5pAHFb4EFuzov5AH + FbYnACaA8JufBhwVCBk1CAYEGSgEYmJveAR4bWluFQwWzLMTFo7RNRay3y8mgPCbnwYm3IGQnwYc + GAQHVI3CGAQJCI7CFgAoBAdUjcIYBAkIjsIAGSwVBBUEFQIAFQAVBBUQAAAWto/mkAcV8gEWopDA + kAcV1gEAJvjMy58GHBUIGTUIBgQZKARiYm94BHhtYXgVDBbMsxMW7M01FqrdLyb4zMufBiaO4b+f + BhwYBPhTjcIYBPsHjsIWACgE+FONwhgE+weOwgAZLBUEFQQVAgAVABUEFRAAABaokeaQBxXyARb4 + kcCQBxXWAQAm3rr9nwYcFQgZNQgGBBkoBGJib3gEeW1pbhUMFsyzExbeoDoWoPIxJt66/Z8GJri+ + 758GHBgEC0wGwhgEMgAHwhYAKAQLTAbCGAQyAAfCABksFQQVBBUCABUAFQQVEAAAFpqT5pAHFfIB + Fs6TwJAHFdYBACbsra+gBhwVCBk1CAYEGSgEYmJveAR5bWF4FQwWzLMTFu6iOhai8jEm7K2voAYm + 2LChoAYcGAS0SwbCGAT9/wbCFgAoBLRLBsIYBP3/BsIAGSwVBBUEFQIAFQAVBBUQAAAWjJXmkAcV + 8gEWpJXAkAcV1gEAJrqj06AGHBUCGSUIBBkYB3ZlcnNpb24VDBbMsxMW/gMWoAUmuqPToAYm+qLT + oAYcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAW/pbmkAcV0gEW + +pbAkAcV1gEAJtqo06AGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3BlcnR5FQwW + zLMTFv4FFqAHJtqo06AGJpqo06AGHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW0JjmkAcV + 0gEW0JjAkAcVVgAm/rDToAYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0YXNldBUM + FsyzExak5AQWlPoCJv6w06AGJrqv06AGHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUgT3BlbiBC + dWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWoprmkAcV4gEWppnAkAcV9gQAJs6p1qAGHBUMGSUG + ABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsyzExby5+MCFoKUggEmzqnWoAY8 + NgAoDHc5ODcxNzI1NzNAMRgMMDAwMTUzYjEyMmU1ABkcFQAVABUQAAAWhJzmkAcV8gEWnJ7AkAcV + 1gMAJqr62KEGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWzLMT + Fur2FRaUrgYmqvrYoQYm0L3YoQYcNgAoGDIwMjQtMTEtMjVUMDI6NDg6NDQuMDAwWhgYMjAwMC0w + MS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFvad5pAHFeIBFvKhwJAHFdYGACaU + iOChBhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWzLMTFuqcFxbY + /xMmlIjgoQYm5OveoQYcGAhtxf6ye/LuPxgIzczMzMzM5D8WwrMKKAhtxf6ye/LuPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAW2J/mkAcV8gEWyKjAkAcV9gIAJoTs8qEGHBUCGTUIBgQZGAVs + ZXZlbBUMFsyzExbMBhbuByaE7PKhBia86/KhBhwYBAIAAAAYBAEAAAAWlrMTKAQCAAAAGAQBAAAA + ABksFQQVBBUCABUAFQQVEAAAFsqh5pAHFdYBFr6rwJAHFfYBACbS9fKhBhwVDBk1CAYEGRgHc3Vi + dHlwZRUMFsyzExbOSBbyPCbS9fKhBiaq8/KhBhw2tvQSKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1 + bHR1cmFsABksFQQVBBUCABUAFQQVEAAAFqCj5pAHFeIBFrStwJAHFa4DACa+tPOhBhwVDBk1CAYE + GRgFY2xhc3MVDBbMsxMW6kgWgD4mvrTzoQYmnLDzoQYcNpr2EigJd2FyZWhvdXNlGAphcGFydG1l + bnRzABksFQQVBBUCABUAFQQVEAAAFoKl5pAHFeIBFuKwwJAHFYIDACac7vOhBhwVChk1CAYAGRgG + aGVpZ2h0FQwWzLMTFpAEFqAFJpzu86EGPDbMsxMAGRwVABUAFRAAABbkpuaQBxXSARbks8CQBxV2 + ACa88/OhBhwVDBk1CAYAGSgFbmFtZXMHcHJpbWFyeRUMFsyzExbEgwEWmFYmvPPzoQY8Ns6uEygI + Wm9vdmVuaXIYJDEgeSAyIEp1emdhZG8gZGUgTGV0cmFzIGRlIFRhbGFnYW50ZQAZHBUAFQAVEAAA + Frao5pAHFeIBFtq0wJAHFdIEACbUyfShBhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVl + A2tleRUMFsyzExbMGRbsFCbUyfShBjwYAmVzGAJlcxbKsxMoAmVzGAJlcwAZHBUAFQAVEAAAFpiq + 5pAHFeIBFqy5wJAHFX4AJsDe9KEGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFs + dWUVDBbMsxMW3B0WjBYmwN70oQY8GApwcmluY2lwaXRvGApwcmluY2lwaXRvFsqzEygKcHJpbmNp + cGl0bxgKcHJpbmNpcGl0bwAZHBUAFQAVEAAAFvqr5pAHFeIBFqq6wJAHFZ4BACbM9PShBhwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFsyzExaEHhaOFibM9PShBjw2 + xrMTKAVzaG9ydBgIb2ZmaWNpYWwAGRwVABUAFRAAABbcreaQBxXiARbIu8CQBxWQAQAm2or1oQYc + FQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50CGxhbmd1YWdlFQwWzLMTFsIdFugVJtqK + 9aEGPDbMsxMAGRwVABUAFRAAABa+r+aQBxXiARbYvMCQBxV2ACbCoPWhBhwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbMsxMWsB4WzBYmwqD1oQY8NsazEygPU2FudGFu + ZGVyIEdyb3VwGBlCYW5jbyBkZWwgRXN0YWRvIGRlIENoaWxlABkcFQAVABUQAAAWoLHmkAcV4gEW + zr3AkAcVxgEAJo639aEGHBUKGSUGABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVu + BGxpc3QHZWxlbWVudBUMFsyzExbCHRboFSaOt/WhBjw2zLMTABkcFQAVABUQAAAWgrPmkAcV4gEW + lL/AkAcVdgAm9sz1oQYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbM + sxMWwh0W6BUm9sz1oQY8NsyzEwAZHBUAFQAVEAAAFuS05pAHFeIBForAwJAHFXYAJt7i9aEGHBUA + GTUIBgAZGAloYXNfcGFydHMVDBbMsxMW2roCFsQGJt7i9aEGPBgBARgBABYAKAEBGAEAABkcFQAV + ABUQAAAWxrbmkAcV0gEWgMHAkAcVdgAmoun1oQYcFQAZNQgGABkYDmlzX3VuZGVyZ3JvdW5kFQwW + zLMTFtq6AhawBiai6fWhBjwYAQAYAQAWACgBABgBAAAZHBUAFQAVEAAAFpi45pAHFdIBFvbBwJAH + FXYAJtLv9aEGHBUCGTUIBgAZGApudW1fZmxvb3JzFQwWzLMTFvAGFoAIJtLv9aEGPBgEBgAAABgE + AQAAABaksxMoBAYAAAAYBAEAAAAAGRwVABUAFRAAABbqueaQBxXUARbswsCQBxXmAQAm0vf1oQYc + FQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbMsxMWkAQWoAUm0vf1oQY8NsyzEwAZ + HBUAFQAVEAAAFr675pAHFdIBFtLEwJAHFXYAJvL89aEGHBUKGTUIBgAZGAptaW5faGVpZ2h0FQwW + zLMTFpAEFqAFJvL89aEGPDbMsxMAGRwVABUAFRAAABaQveaQBxXSARbIxcCQBxV2ACaSgvahBhwV + Ahk1CAYAGRgJbWluX2Zsb29yFQwWzLMTFpAEFqAFJpKC9qEGPDbMsxMAGRwVABUAFRAAABbivuaQ + BxXSARa+xsCQBxV2ACayh/ahBhwVDBk1CAYAGRgMZmFjYWRlX2NvbG9yFQwWzLMTFpAEFqAFJrKH + 9qEGPDbMsxMAGRwVABUAFRAAABa0wOaQBxXSARa0x8CQBxV2ACbSjPahBhwVDBk1CAYAGRgPZmFj + YWRlX21hdGVyaWFsFQwWzLMTFpAEFqAFJtKM9qEGPDbMsxMAGRwVABUAFRAAABaGwuaQBxXSARaq + yMCQBxV2ACbykfahBhwVDBk1CAYAGRgNcm9vZl9tYXRlcmlhbBUMFsyzExaQBBagBSbykfahBjw2 + zLMTABkcFQAVABUQAAAW2MPmkAcV0gEWoMnAkAcVdgAmkpf2oQYcFQwZNQgGABkYCnJvb2Zfc2hh + cGUVDBbMsxMWkAQWoAUmkpf2oQY8NsyzEwAZHBUAFQAVEAAAFqrF5pAHFdIBFpbKwJAHFXYAJrKc + 9qEGHBUKGTUIBgAZGA5yb29mX2RpcmVjdGlvbhUMFsyzExaQBBagBSaynPahBjw2zLMTABkcFQAV + ABUQAAAW/MbmkAcV0gEWjMvAkAcVdgAm0qH2oQYcFQwZNQgGABkYEHJvb2Zfb3JpZW50YXRpb24V + DBbMsxMWkAQWoAUm0qH2oQY8NsyzEwAZHBUAFQAVEAAAFs7I5pAHFdIBFoLMwJAHFXYAJvKm9qEG + HBUMGTUIBgAZGApyb29mX2NvbG9yFQwWzLMTFpAEFqAFJvKm9qEGPDbMsxMAGRwVABUAFRAAABag + yuaQBxXSARb4zMCQBxV2ACaSrPahBhwVChk1CAYAGRgLcm9vZl9oZWlnaHQVDBbMsxMWkAQWoAUm + kqz2oQY8NsyzEwAZHBUAFQAVEAAAFvLL5pAHFdIBFu7NwJAHFXYAFsD2gRsWzLMTJoyxzpMGFqaA + qA4UbgAZ/CYmsrH2oQYcFQwZNQgGABkYAmlkFQwW7IITFoDrrAUWtrG/ASaysfahBjw2ACggMDhi + YjJjNTdiNmE3MWZmZjAyMDA2MzJkYTg5ZGNhNmIYIDA4YmIyYzU0MDA0NWFmZmYwMjAwMDdjMDhk + MTVkODhmABkcFQAVABUQAAAWxM3mkAcV8gEW5M7AkAcV1ggAJujitaMGHBUMGTUIBgAZGAhnZW9t + ZXRyeRUMFuyCExaSu/IQFuyoogom6OK1owY8NgAowQYAAAAAAwAAAAYAAAAZwFGrLc2YpKfAQMrg + 1m8M/sBRqz9AHE/CwEDK2f4Nt3nAUas9P/xvUsBAysnrcPzCwFGrOp32H6zAQMrK085IzsBRqznd + Bf/0wEDKxWuve4PAUatAsMo3x8BAysLHkEzqwFGrQWROXjLAQMrHzmBKw8BRq0SelYHdwEDKxo3u + aqzAUatEw+nPPMBAyseduOMLwFGrRdIGyHHAQMrHKEgdpsBRq0Wnqf2VwEDKxWrYu+7AUatPM69Z + 9cBAysG7INLewFGrT1WoqQHAQMrCmW0j8MBRq0/pTF9UwEDKwmZBfXnAUatQoW2jcsBAysdptnz/ + wFGrT7Cs25bAQMrH4auBI8BRq1AM8y2KwEDKynaxN0XAUatRRkOxMMBAysn9DrP4wFGrU5fCKQXA + QMran/QmrsBRq1KNa43uwEDK2tFyTfvAUatSm65G0MBAyttuUD+zwFGrPSnBmmrAQMrjuyXbXMBR + qzyCZ03twEDK33zSuXbAUasucMEzPMBAyuUtFeLAwFGrLc2YpKfAQMrg1m8M/gAAAAXAUatD96aV + K8BAytFZ+kdZwFGrQzmmE/vAQMrRo8wig8BRq0QUl2a5wEDK18EclWLAUatE0wNHs8BAytd3Sro4 + wFGrQ/emlSvAQMrRWfpHWQAAAAXAUatFyGEtQsBAyseziFgpwFGrRSYPXkLAQMrH8nJ4w8BRq0X6 + thQkwEDKzeGfwqnAUatGnQfjI8BAys2itaIOwFGrRchhLULAQMrHs4hYKQAAAAXAUatHMlkYoMBA + ytCyNJsSwFGrRlkVRQzAQMrRBu4wy8BRq0c6UTSmwEDK11GLDQ/AUatIFABoBcBAytb9qDbrwFGr + RzJZGKDAQMrQsjSbEgAAAAXAUatCHG+iT8BAytMXaakRwFGrQWX73VzAQMrTXeCF58BRq0I/P7Dw + wEDK2W6bvw7AUatC9UgWGcBAytknTiKjwFGrQhxvok/AQMrTF2mpEQAAAAXAUatCMdO3o8BAysqb + miTawFGrQWvbGm3AQMrK7CH8qsBRq0IhDMACwEDKz71CFU7AUatC5pn9bcBAys9suj1+wFGrQjHT + t6PAQMrKm5ok2hhNAAAAAAMAAAABAAAABMBRq6iitrOSwEDSjbiGNgjAUaupFCkhjMBA0oz+f1bY + wFGrqaTHGj/AQNKN9UVsasBRq6iitrOSwEDSjbiGNggAGRwVABUAFSYAABa2z+aQBxW+BBa618CQ + BxW2JwAmuJHjrQYcFQgZNQgGBBkoBGJib3gEeG1pbhUMFuyCExaWkjQWkIcuJriR460GJtSL2K0G + HBgEBVSNwhgEBAiOwhYAKAQFVI3CGAQECI7CABksFQQVBBUCABUAFQQVEAAAFvTT5pAHFfIBFvD+ + wJAHFdYBACbUlpGuBhwVCBk1CAYEGSgEYmJveAR4bWF4FQwW7IITFoLnMxacni4m1JaRrgYm5JKG + rgYcGATfU43CGAT7B47CFgAoBN9TjcIYBPsHjsIAGSwVBBUEFQIAFQAVBBUQAAAW5tXmkAcV8gEW + xoDBkAcV1gEAJtS8wq4GHBUIGTUIBgQZKARiYm94BHltaW4VDBbsghMW/rQ4FqqLMSbUvMKuBiaA + sbSuBhwYBAWYBcIYBB2mBsIWACgEBZgFwhgEHaYGwgAZLBUEFQQVAgAVABUEFRAAABbY1+aQBxXy + ARacgsGQBxXWAQAm1MfzrgYcFQgZNQgGBBkoBGJib3gEeW1heBUMFuyCExaatTgWzI0xJtTH864G + Jqq85a4GHBgE5pcFwhgE86UGwhYAKATmlwXCGATzpQbCABksFQQVBBUCABUAFQQVEAAAFsrZ5pAH + FfIBFvKDwZAHFdYBACa2ypavBhwVAhklCAQZGAd2ZXJzaW9uFQwW7IITFv4DFqAFJrbKlq8GJvbJ + lq8GHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFrzb5pAHFdIB + FsiFwZAHFdYBACbWz5avBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUM + FuyCExb+BRagBybWz5avBiaWz5avBhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFo7d5pAH + FdIBFp6HwZAHFVYAJvrXlq8GHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQV + DBbsghMWwNcEFoCbAyb615avBia21pavBhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4g + QnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFuDe5pAHFeIBFvSHwZAHFfYEACa28ZmvBhwVDBkl + BgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbsghMW1vXWAhaw7nomtvGZrwY8 + NgAoDHc5OTUxMDMwNDBAMRgMMDAwMDQwNDY4MTljABkcFQAVABUQAAAWwuDmkAcV8gEW6ozBkAcV + 1gMAJozElbAGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW7IIT + FoqmGBaIyggmjMSVsAYm5t+UsAYcNgAoGDIwMjQtMTEtMzBUMTQ6MTE6MTkuMDAwWhgYMjAwMC0w + MS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFrTi5pAHFegBFsCQwZAHFdYGACbi + w56wBhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW7IITFtjGFBaK + oREm4sOesAYm7qmdsAYcGAgydy0hH/TuPxgIzczMzMzM5D8WvNELKAgydy0hH/TuPxgIzczMzMzM + 5D8AGSwVBBUEFQIAFQAVBBUQAAAWnOTmkAcV8gEWlpfBkAcV9gIAJsbLrrAGHBUCGTUIBgQZGAVs + ZXZlbBUMFuyCExamCBbICSbGy66wBib4yq6wBhwYBAIAAAAYBP////8WiIITKAQCAAAAGAT///// + ABksFQQVBBUCABUAFQQVEAAAFo7m5pAHFeABFoyawZAHFfYBACa+1q6wBhwVDBk1CAYEGRgHc3Vi + dHlwZRUMFuyCExaKeRaYaSa+1q6wBibA1K6wBhw2rK0RKAtyZXNpZGVudGlhbBgMYWdyaWN1bHR1 + cmFsABksFQQVBBUCABUAFQQVEAAAFu7n5pAHFeIBFoKcwZAHFaoDACbywK+wBhwVDBk1CAYEGRgF + Y2xhc3MVDBbsghMWwHoW7mom8sCvsAYm2L2vsAYcNrivESgJd2FyZWhvdXNlGAphcGFydG1lbnRz + ABksFQQVBBUCABUAFQQVEAAAFtDp5pAHFeIBFqyfwZAHFfICACbGqLCwBhwVChk1CAYAGRgGaGVp + Z2h0FQwW7IITFvYHFtoGJsaosLAGPBgIAAAAAAAAREAYCAAAAAAAACRAFrqCEygIAAAAAAAAREAY + CAAAAAAAACRAABkcFQAVABUQAAAWsuvmkAcV2AEWnqLBkAcV1gEAJqCvsLAGHBUMGTUIBgAZKAVu + YW1lcwdwcmltYXJ5FQwW7IITFvSxARaQcSagr7CwBjw2lPwSKA7Dk3B0aW1hIERlbnRhbBgkMSB5 + IDIgSnV6Z2FkbyBkZSBMZXRyYXMgU2FuIEJlcm5hcmRvABkcFQAVABUQAAAWiu3mkAcV4gEW9KPB + kAcV4gQAJrCgsbAGHBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwW7IITFvgf + FsYYJrCgsbAGPDboghMoAnpoGAJlbgAZHBUAFQAVEAAAFuzu5pAHFeIBFtaowZAHFX4AJva4sbAG + HBUMGSUGABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBbsghMW5iUWwBom9rixsAY8 + NuiCEygG56aP6ZqGGCJGaXJzdCBGaXJlIENvbXBhbnkgb2YgU2FuIEJlcm5hcmRvABkcFQAVABUQ + AAAWzvDmkAcV4gEW1KnBkAcVxgEAJrbTsbAGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAd2YXJpYW50FQwW8IITFv4mFrYbJrbTsbAGPDbeghMoCG9mZmljaWFsGAlhbHRlcm5hdGUA + GRwVABUAFRAAABaw8uaQBxXiARaaq8GQBxWAAgAm7O6xsAYcFQwZJQYAGVgFbmFtZXMFcnVsZXME + bGlzdAdlbGVtZW50CGxhbmd1YWdlFQwW8IITFpolFpoaJuzusbAGPDbwghMAGRwVABUAFRAAABaS + 9OaQBxXiARaarcGQBxV2ACbmi7KwBhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQF + dmFsdWUVDBbwghMWgCkWhB0m5ouysAYmhomysAYcNt6CEygPU2FudGFuZGVyIEdyb3VwGBRCYW5j + byBkZWwgRGVzYXJyb2xsbwAZLBUEFQQVAgAVABUEFRAAABb09eaQBxXiARaQrsGQBxWIBQAmiqay + sAYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50 + FQwW8IITFpwlFooaJoqmsrAGPDbwghMAGRwVABUAFRAAABbW9+aQBxXiARaYs8GQBxV2ACaUwLKw + BhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFvCCExaaJRaaGiaUwLKw + Bjw28IITABkcFQAVABUQAAAWuPnmkAcV4gEWjrTBkAcVdgAmrtqysAYcFQAZNQgGABkYCWhhc19w + YXJ0cxUMFuyCExbOtAIWvAYmrtqysAY8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABaa++aQBxXS + ARaEtcGQBxV2ACbq4LKwBhwVABk1CAYAGRgOaXNfdW5kZXJncm91bmQVDBbsghMWzrQCFrAGJurg + srAGPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAW7PzmkAcV0gEW+rXBkAcVdgAmxOiysAYcFQIZ + NQgGBBkYCm51bV9mbG9vcnMVDBbsghMWuA4W6A4mxOiysAYmmueysAYcGAQSAAAAGAQBAAAAFsb/ + EigEEgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABa+/uaQBxXeARbwtsGQBxXmAQAmgvaysAYc + FQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbsghMWkAQWoAUmgvaysAY8NuyCEwAZ + HBUAFQAVEAAAFpyA55AHFdIBFta4wZAHFXYAJqL7srAGHBUKGTUIBgAZGAptaW5faGVpZ2h0FQwW + 7IITFpAEFqAFJqL7srAGPDbsghMAGRwVABUAFRAAABbugeeQBxXSARbMucGQBxV2ACbCgLOwBhwV + Ahk1CAYAGRgJbWluX2Zsb29yFQwW7IITFpAEFqAFJsKAs7AGPDbsghMAGRwVABUAFRAAABbAg+eQ + BxXSARbCusGQBxV2ACbihbOwBhwVDBk1CAYAGRgMZmFjYWRlX2NvbG9yFQwW7IITFpAEFqAFJuKF + s7AGPDbsghMAGRwVABUAFRAAABaSheeQBxXSARa4u8GQBxV2ACaCi7OwBhwVDBk1CAYAGRgPZmFj + YWRlX21hdGVyaWFsFQwW7IITFpAEFqAFJoKLs7AGPDbsghMAGRwVABUAFRAAABbkhueQBxXSARau + vMGQBxV2ACaikLOwBhwVDBk1CAYAGRgNcm9vZl9tYXRlcmlhbBUMFuyCExaQBBagBSaikLOwBjw2 + 7IITABkcFQAVABUQAAAWtojnkAcV0gEWpL3BkAcVdgAmwpWzsAYcFQwZNQgGABkYCnJvb2Zfc2hh + cGUVDBbsghMWkAQWoAUmwpWzsAY8NuyCEwAZHBUAFQAVEAAAFoiK55AHFdIBFpq+wZAHFXYAJuKa + s7AGHBUKGTUIBgAZGA5yb29mX2RpcmVjdGlvbhUMFuyCExaQBBagBSbimrOwBjw27IITABkcFQAV + ABUQAAAW2ovnkAcV0gEWkL/BkAcVdgAmgqCzsAYcFQwZNQgGABkYEHJvb2Zfb3JpZW50YXRpb24V + DBbsghMWkAQWoAUmgqCzsAY8NuyCEwAZHBUAFQAVEAAAFqyN55AHFdIBFobAwZAHFXYAJqKls7AG + HBUMGTUIBgAZGApyb29mX2NvbG9yFQwW7IITFpAEFqAFJqKls7AGPDbsghMAGRwVABUAFRAAABb+ + jueQBxXSARb8wMGQBxV2ACbCqrOwBhwVChk1CAYAGRgLcm9vZl9oZWlnaHQVDBbsghMWkAQWoAUm + wqqzsAY8NuyCEwAZHBUAFQAVEAAAFtCQ55AHFdIBFvLBwZAHFXYAFsCtixsW7IITJrKx9qEGFrD+ + vA4UcAAZ/CYm4q+zsAYcFQwZNQgGABkYAmlkFQwWwPsSFs7iqgUW0ve8ASbir7OwBjw2ACggMDhi + YjJjNTU1YmRiNmZmZjAyMDBlY2VmZDk1N2FlNmYYIDA4YmIyYzU0MDAwMjVmZmYwMjAwNmNmZTU1 + MWFmNjYxABkcFQAVABUQAAAWopLnkAcV8gEW6MLBkAcV1ggAJrSn8LEGHBUMGTUIBgAZGAhnZW9t + ZXRyeRUMFsD7Ehbs4Y4RFq6uqgomtKfwsQY8NgAo1AUAAAAABgAAAAcAAAAAAwAAAAEAAAAJwFGq + wqvhmrrAQMRwaEfn9sBRqsGPgeijwEDEcQvb1lXAUarBe1/yr8BAxHCptkdPwFGqwIt16mjAQMRx + NB/CPcBRqr9bX6InwEDEa339W+HAUarAVIPl08BAxGrui2N2wFGqwE3N6SzAQMRqzdQzycBRqsFg + 81/fwEDEai9IwufAUarCq+GausBAxHBoR+f2AAAAAAMAAAABAAAABcBRqr+xxrcJwEDEfPNwpYXA + Uaq9j62HjcBAxHHq/ub7wFGqv2jLm3TAQMRw7NIl0sBRqsGK5MrwwEDEe/RtJMfAUaq/sca3CcBA + xHzzcKWFAAAAAAMAAAABAAAABcBRqsVeQ4I2wEDEdfVPotbAUarF+rYUJMBAxHjk7ivCwFGqwzXf + td7AQMR6fyIfD8BRqsKZbSPwwEDEd4+DliLAUarFXkOCNsBAxHX1T6LWAAAAAAMAAAABAAAABcBR + qsZWJaaDwEDEeW9XprDAUarEM6EXPMBAxG5m5egnwFGqxgy/KyTAQMRtaLkm/sBRqsgvQ7pqwEDE + eHBUJfLAUarGViWmg8BAxHlvV6awAAAAAAMAAAABAAAABcBRqsKZAcQlwEDEaYXVl3fAUarAdn00 + 38BAxF59Y9jtwFGqwoMyTwjAQMRdY4hllcBRqsSltt5OwEDEaGv6JB7AUarCmQHEJcBAxGmF1Zd3 + AAAAAAMAAAABAAAABcBRqr8UEgW8wEDEXr37eLLAUaq/yhpq5cBAxGInPITswFGqvLI39hHAQMRj + 8UEgXMBRqrv8mvCywEDEYIgAFCLAUaq/FBIFvMBAxF69+3iyAAAAAAMAAAABAAAABcBRqrtR5aXi + wEDEbh+YS7zAUaq5L2EWm8BAxGMXJo0zwFGquwh/KoPAQMRiGPnMCcBRqr0rA7nJwEDEbSFripPA + Uaq7UeWl4sBAxG4fmEu8GE0AAAAAAwAAAAEAAAAEwFGqlkeD5O3AQML0LkI37sBRqpZPhxJBwEDC + 8yAkYZzAUaqWt05P+8BAwvQ3kE1TwFGqlkeD5O3AQML0LkI37gAZHBUAFQAVJgAAFpSU55AHFb4E + Fr7LwZAHFbYnACaGg6G8BhwVCBk1CAYEGSgEYmJveAR4bWluFQwWwPsSFpbYKxagvCgmhoOhvAYm + 4tWavAYcGAQDVI3CGATDrY3CFgAoBANUjcIYBMOtjcIAGSwVBBUEFQIAFQAVBBUQAAAW0pjnkAcV + 8gEW9PLBkAcV1gEAJsC+ybwGHBUIGTUIBgQZKARiYm94BHhtYXgVDBbA+xIWmNcrFry7KCbAvsm8 + BiaCksO8BhwYBONTjcIYBL2tjcIWACgE41ONwhgEva2NwgAZLBUEFQQVAgAVABUEFRAAABbEmueQ + BxXyARbK9MGQBxXWAQAmxJLzvAYcFQgZNQgGBBkoBGJib3gEeW1pbhUMFsD7Ehb83S0WkKIqJsSS + 87wGJr7N67wGHBgEBvIFwhgEMUwGwhYAKAQG8gXCGAQxTAbCABksFQQVBBUCABUAFQQVEAAAFrac + 55AHFfIBFqD2wZAHFdYBACbutZ29BhwVCBk1CAYEGSgEYmJveAR5bWF4FQwWwPsSFqjfLRauoyom + 7rWdvQYmzu+VvQYcGAS/8QXCGAT5SwbCFgAoBL/xBcIYBPlLBsIAGSwVBBUEFQIAFQAVBBUQAAAW + qJ7nkAcV8gEW9vfBkAcV1gEAJryTwL0GHBUCGSUIBBkYB3ZlcnNpb24VDBbA+xIW/gMWoAUmvJPA + vQYm/JLAvQYcGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQAAAWmqDn + kAcV0gEWzPnBkAcV1gEAJtyYwL0GHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CHByb3Bl + cnR5FQwWwPsSFv4FFqAHJtyYwL0GJpyYwL0GHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAVBBUQAAAW + 7KHnkAcV0gEWovvBkAcVVgAmgKHAvQYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQHZGF0 + YXNldBUMFsD7Eham3QQWrqQDJoChwL0GJryfwL0GHDYAKA1PcGVuU3RyZWV0TWFwGBVHb29nbGUg + T3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAWvqPnkAcV4gEW+PvBkAcV9gQAJurDw70G + HBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsD7Ehaq69QCFozldybq + w8O9Bjw2ACgMdzk5MjkyNjM4NUAxGAwwMDAwMmNjZGNmYWUAGRwVABUAFRAAABagpeeQBxXyARbu + gMKQBxXWAwAmwL68vgYcFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRlX3RpbWUV + DBbA+xIW0LcbFrjmCSbAvry+Bib2qLu+Bhw2ACgYMjAyNC0xMS0zMFQwMTo1Mzo1MS4wMDBaGBgy + MDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWkqfnkAcV6gEWxITCkAcV + 1gYAJrKjxr4GHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UVDBbA+xIW + nOwTFt7DECayo8a+Biauj8W+BhwYCGDl0CLb+e4/GAjNzMzMzMzkPxbA9AsoCGDl0CLb+e4/GAjN + zMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABb8qOeQBxXyARaai8KQBxX2AgAm1NPVvgYcFQIZNQgG + BBkYBWxldmVsFQwWwPsSFrgIFtoJJtTT1b4GJozT1b4GHBgEAQAAABgE/////xaq+hIoBAEAAAAY + BP////8AGSwVBBUEFQIAFQAVBBUQAAAW7qrnkAcV3AEWkI7CkAcV9gEAJvbe1b4GHBUMGTUIBgQZ + GAdzdWJ0eXBlFQwWwPsSFrCeARaohQEm9t7VvgYm5tzVvgYcNtLkECgOdHJhbnNwb3J0YXRpb24Y + BWNpdmljABksFQQVBBUCABUAFQQVEAAAFsqs55AHFeIBFoaQwpAHFf4CACaq5ta+BhwVDBk1CAYE + GRgFY2xhc3MVDBbA+xIW0KIBFvaLASaq5ta+BiaO4ta+Bhw21OkQKAl3YXJlaG91c2UYCmFwYXJ0 + bWVudHMAGSwVBBUEFQIAFQAVBBUQAAAWrK7nkAcV4gEWhJPCkAcVpAMAJp7v174GHBUKGTUIBgQZ + GAZoZWlnaHQVDBbA+xIWmAkWugkmnu/XvgYmhO7XvgYcGAgAAAAAAABRQBgIAAAAAAAAAEAW2voS + KAgAAAAAAABRQBgIAAAAAAAAAEAAGSwVBBUEFQIAFQAVBBUQAAAWjrDnkAcV2AEWqJbCkAcVtgIA + Jr73174GHBUMGTUIBgAZKAVuYW1lcwdwcmltYXJ5FQwWwPsSFoTiAhbY0wEmvvfXvgY8NtjuEigb + w4FyZWEgTWF0ZXJpYWxlcyBjb21wdWVzdG9zGCIxIEp1emdhZG8gZGUgUG9saWPDrWEgTG9jYWwg + TWFpcMO6ABkcFQAVABUQAAAW5rHnkAcV4gEW3pjCkAcVxAQAJpbL2b4GHBUMGSUGABlIBW5hbWVz + BmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWxvsSFoA7FrAoJpbL2b4GPDa6+xIoAmVzGAJlbgAZHBUA + FQAVEAAAFsiz55AHFeIBFqKdwpAHFY4BACbG89m+BhwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5 + X3ZhbHVlBXZhbHVlFQwWxvsSFu5GFt4pJsbz2b4GPDa6+xIoDlNhbnRhbmRlciBCYW5rGA9CYW5j + byBTYW50YW5kZXIAGRwVABUAFRAAABaqteeQBxXiARawnsKQBxXmAgAmpJ3avgYcFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbQ+xIWpEwWliwmpJ3avgY8NoL7EigF + c2hvcnQYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFoy355AHFeIBFpahwpAHFdgCACa6ydq+BhwVDBkl + BgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBbQ+xIWgkUW5CgmusnavgY8 + Nsz7EigCZXMYAmVuABkcFQAVABUQAAAW7rjnkAcV4gEW7qPCkAcVfgAmnvLavgYcFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BXZhbHVlFQwW0PsSFqpZFs42Jp7y2r4GPDaC+xIoKFNl + cnZpY2lvIGRlIFVyZ2VuY2lhIGRlIEFsdGEgUmVzb2x1Y2nDs24YH0JhbmNvIGRlIENyw6lkaXRv + IGUgSW52ZXJzaW9uZXMAGRwVABUAFRAAABbQuueQBxXiARbspMKQBxWGCAAm7KjbvgYcFQoZJQYA + GXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwW0PsSFvhE + FtgoJuyo274GPDbQ+xIAGRwVABUAFRAAABayvOeQBxXiARbyrMKQBxV2ACbE0du+BhwVDBklBgAZ + WAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQEc2lkZRUMFtD7EhbqRBbUKCbE0du+Bjw20PsSABkc + FQAVABUQAAAWlL7nkAcV4gEW6K3CkAcVdgAmmPrbvgYcFQAZNQgGABkYCWhhc19wYXJ0cxUMFsD7 + EhbYswIWugYmmPrbvgY8GAEBGAEAFgAoAQEYAQAAGRwVABUAFRAAABb2v+eQBxXSARbersKQBxV2 + ACbSgNy+BhwVABk1CAYAGRgOaXNfdW5kZXJncm91bmQVDBbA+xIW2LMCFrAGJtKA3L4GPBgBABgB + ABYAKAEAGAEAABkcFQAVABUQAAAWyMHnkAcV0gEW1K/CkAcVdgAmoojcvgYcFQIZNQgGBBkYCm51 + bV9mbG9vcnMVDBbA+xIWphIWuBImoojcvgYmgofcvgYcGAQUAAAAGAQBAAAAFvb0EigEFAAAABgE + AQAAAAAZLBUEFQQVAgAVABUEFRAAABaaw+eQBxXgARbKsMKQBxX2AQAmupncvgYcFQIZNQgGABkY + Fm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbA+xIWtgQWxgUmupncvgY8GAQCAAAAGAQBAAAAFrz7 + EigEAgAAABgEAQAAAAAZHBUAFQAVEAAAFvrE55AHFdIBFsCywpAHFZYBACaAn9y+BhwVChk1CAYA + GRgKbWluX2hlaWdodBUMFsD7EhaQBBagBSaAn9y+Bjw2wPsSABkcFQAVABUQAAAWzMbnkAcV0gEW + 1rPCkAcVdgAmoKTcvgYcFQIZNQgGABkYCW1pbl9mbG9vchUMFsD7EhaQBBagBSagpNy+Bjw2wPsS + ABkcFQAVABUQAAAWnsjnkAcV0gEWzLTCkAcVdgAmwKncvgYcFQwZNQgGABkYDGZhY2FkZV9jb2xv + chUMFsD7EhaiBRb6BSbAqdy+Bjw2tPsSKAcjRkZGRkZGGAcjMDBGRjAwABkcFQAVABUQAAAW8Mnn + kAcV1AEWwrXCkAcVkgEAJrqv3L4GHBUMGTUIBgAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbA+xIWkAQW + oAUmuq/cvgY8NsD7EgAZHBUAFQAVEAAAFsTL55AHFdIBFtS2wpAHFXYAJtq03L4GHBUMGTUIBgAZ + GA1yb29mX21hdGVyaWFsFQwWwPsSFpAEFqAFJtq03L4GPDbA+xIAGRwVABUAFRAAABaWzeeQBxXS + ARbKt8KQBxV2ACb6udy+BhwVDBk1CAYAGRgKcm9vZl9zaGFwZRUMFsD7EhauBBa+BSb6udy+BjwY + BmhpcHBlZBgGaGlwcGVkFr77EigGaGlwcGVkGAZoaXBwZWQAGRwVABUAFRAAABbozueQBxXSARbA + uMKQBxWOAQAmuL/cvgYcFQoZNQgGABkYDnJvb2ZfZGlyZWN0aW9uFQwWwPsSFpAEFqAFJri/3L4G + PDbA+xIAGRwVABUAFRAAABa60OeQBxXSARbOucKQBxV2ACbYxNy+BhwVDBk1CAYAGRgQcm9vZl9v + cmllbnRhdGlvbhUMFsD7EhaQBBagBSbYxNy+Bjw2wPsSABkcFQAVABUQAAAWjNLnkAcV0gEWxLrC + kAcVdgAm+MncvgYcFQwZNQgGABkYCnJvb2ZfY29sb3IVDBbA+xIWyAQWzgUm+MncvgY8GAcjNjM3 + OTcyGAcjNjM3OTcyFrz7EigHIzYzNzk3MhgHIzYzNzk3MgAZHBUAFQAVEAAAFt7T55AHFdQBFrq7 + wpAHFZIBACbGz9y+BhwVChk1CAYAGRgLcm9vZl9oZWlnaHQVDBbA+xIWkAQWoAUmxs/cvgY8NsD7 + EgAZHBUAFQAVEAAAFrLV55AHFdIBFsy8wpAHFXYAFsz7gxsWwPsSJuKvs7AGFoSlqQ4UcgAZ/CYm + 5tTcvgYcFQwZNQgGABkYAmlkFQwWrOcSFoCNpQUWnK+7ASbm1Ny+Bjw2ACggMDhiYjJjNTU3M2Ri + NmZmZjAyMDA2OTM3Mjc1MDFlMTMYIDA4YmIyYzU0MDRhMDlmZmYwMjAwN2I1YTM2Zjk0NGFjABkc + FQAVABUQAAAWhNfnkAcV8gEWwr3CkAcV1ggAJoKEmMAGHBUMGTUIBgAZGAhnZW9tZXRyeRUMFqzn + Ehb+2bURFtCY2QomgoSYwAY8NgAowwEAAAAABgAAAAIAAAAAAwAAAAEAAAAFwFGt2kul8MDAQLQT + 76ENK8BRrdqCl/VVwEC0Fz0zZzbAUa3XgVu1MsBAtBfHnOIjwFGt10ppsJ7AQLQUeuFHrsBRrdpL + pfDAwEC0E++hDSsAAAAAAwAAAAEAAAAFwFGt3YXtFGvAQLQSGd33l8BRrd72mvxwwEC0JHN8z17A + Ua3dBSk0rcBAtCTfs1lewFGt25R7TKfAQLQShhSBl8BRrd2F7RRrwEC0Ehnd95cYTQAAAAADAAAA + AQAAAATAUavy5CMqp8BAvZt0ZSyrwFGr8j00PfXAQL2YfTnngsBRq/OAKlzLwEC9mbpQyUbAUavy + 5CMqp8BAvZt0ZSyrABkcFQAVABUoAAAW9tjnkAcV3AQWmMbCkAcVvikAJoLA98oGHBUIGTUIBgQZ + KARiYm94BHhtaW4VDBas5xIWhKMrFsqMKCaCwPfKBibSnPHKBhwYBAVUjcIYBB6ujcIWACgEBVSN + whgEHq6NwgAZLBUEFQQVAgAVABUEFRAAABbS3eeQBxXyARbW78KQBxXWAQAmuM2fywYcFQgZNQgG + BBkoBGJib3gEeG1heBUMFqznEhaCpCsWtI0oJrjNn8sGJpypmcsGHBgEvVONwhgE/K2NwhYAKAS9 + U43CGAT8rY3CABksFQQVBBUCABUAFQQVEAAAFsTf55AHFfIBFqzxwpAHFdYBACa4gsnLBhwVCBk1 + CAYEGSgEYmJveAR5bWluFQwWrOcSFpy4Lhai0SomuILJywYm0LbBywYcGAQHmAXCGASz9wXCFgAo + BAeYBcIYBLP3BcIAGSwVBBUEFQIAFQAVBBUQAAAWtuHnkAcV8gEWgvPCkAcV1gEAJobU88sGHBUI + GTUIBgQZKARiYm94BHltYXgVDBas5xIW3LguFs7RKiaG1PPLBibyh+zLBhwYBM+WBcIYBI73BcIW + ACgEz5YFwhgEjvcFwgAZLBUEFQQVAgAVABUEFRAAABao4+eQBxXyARbY9MKQBxXWAQAmgNqWzAYc + FQIZJQgEGRgHdmVyc2lvbhUMFqznEhb+AxagBSaA2pbMBibA2ZbMBhwYBAAAAAAYBAAAAAAWACgE + AAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFRAAABaa5eeQBxXSARau9sKQBxXWAQAmoN+WzAYcFQwZ + JQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBas5xIW/gUWoAcmoN+WzAYm4N6W + zAYcGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFRAAABbs5ueQBxXSARaE+MKQBxVWACbE55bMBhwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWrOcSFtLPBBaWjgMmxOeWzAYm + gOaWzAYcNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZLBUEFQQVAgAV + ABUEFRAAABa+6OeQBxXiARba+MKQBxX2BAAmlvSZzAYcFQwZJQYAGUgHc291cmNlcwRsaXN0B2Vs + ZW1lbnQJcmVjb3JkX2lkFQwWrOcSFpDeywIW4NV9Jpb0mcwGPDYAKAx3OTkzOTE1NTI3QDEYDDAw + MDA1NzBjNGFmYQAZHBUAFQAVEAAAFqDq55AHFfIBFtD9wpAHFdQDACbMi5nNBhwVDBklBgQZSAdz + b3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFqznEhaigR0WxOAJJsyLmc0GJvbJl80G + HDYAKBgyMDI0LTExLTMwVDIzOjM3OjQ5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6MDAuMDAwWgAZ + LBUEFQQVAgAVABUEFRAAABaS7OeQBxXuARakgcOQBxXWBgAmxMCizQYcFQoZJQYEGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFqznEhaEiBIWstAOJsTAos0GJrqqoc0GHBgIswxx + rIvb7j8YCM3MzMzMzOQ/FpbwDCgIswxxrIvb7j8YCM3MzMzMzOQ/ABksFQQVBBUCABUAFQQVEAAA + FoDu55AHFfIBFvqHw5AHFfYCACbM+6/NBhwVAhk1CAYEGRgFbGV2ZWwVDBas5xIWxgoWtgsmzPuv + zQYm7PqvzQYcGAQFAAAAGAT/////FublEigEBQAAABgE/////wAZLBUEFQQVAgAVABUEFRAAABby + 7+eQBxXcARbwisOQBxX2AQAmsoiwzQYcFQwZNQgGBBkYB3N1YnR5cGUVDBas5xIWhpABFs51JrKI + sM0GJqKGsM0GHDaktBEoDnRyYW5zcG9ydGF0aW9uGAVjaXZpYwAZLBUEFQQVAgAVABUEFRAAABbO + 8eeQBxXiARbmjMOQBxX8AgAm2oCxzQYcFQwZNQgGBBkYBWNsYXNzFQwWrOcSFoqZARawfSbagLHN + Bibw+7DNBhw2jLkRKAl3YXJlaG91c2UYD2FsbG90bWVudF9ob3VzZQAZLBUEFQQVAgAVABUEFRAA + ABaw8+eQBxXiARbij8OQBxW0AwAmoPmxzQYcFQoZNQgGABkYBmhlaWdodBUMFqznEhbqBhaQByag + +bHNBjwYCAAAAAAAgEdAGAgAAAAAAAAIQBaO5xIoCAAAAAAAgEdAGAgAAAAAAAAIQAAZHBUAFQAV + EAAAFpL155AHFdgBFpaTw5AHFdYBACawgLLNBhwVDBk1CAYAGSgFbmFtZXMHcHJpbWFyeRUMFqzn + Ehaq9AMWzJsCJrCAss0GPDau1BIoDHNlZGUgdmVjaW5hbBgcMSBGaXNjYWzDrWEgTWlsaXRhciBT + YW50aWFnbwAZHBUAFQAVEAAAFur255AHFeIBFuyUw5AHFcIEACb8m7TNBhwVDBklBgAZSAVuYW1l + cwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFq7nEhbKSxawMCb8m7TNBjw2lucSKAJlcxgCZGUAGRwV + ABUAFRAAABbM+OeQBxXiARaumcOQBxWWAQAmrMy0zQYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtl + eV92YWx1ZQV2YWx1ZRUMFq7nEhaUXRb6MyaszLTNBjw2lucSKBRTYW50aWFnbyBCdXMgU3RhdGlv + bhgoQXVkaXRvcml1bSBEb24gQm9zY28gKFNhbnRpYWdvIGRlIENoaWxlKQAZHBUAFQAVEAAAFq76 + 55AHFeIBFsSaw5AHFdQDACaigbXNBhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQH + dmFyaWFudBUMFrrnEhboWhbOMiaigbXNBiamgLXNBhw24uYSKAVzaG9ydBgJYWx0ZXJuYXRlABks + FQQVBBUCABUAFQQVEAAAFpD855AHFeIBFpiew5AHFa4CACb0srXNBhwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBa65xIWvlkWnDEm9LK1zQY8NrrnEgAZHBUAFQAV + EAAAFvL955AHFeIBFsagw5AHFXYAJt7ttc0GHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxl + bWVudAV2YWx1ZRUMFrrnEhaEahbYOybe7bXNBiaQ5LXNBhw24uYSKA1WRFJJREVJIFVTQUNIGB9C + YW5jbyBCaWxiYW8gVml6Y2F5YSBBcmdlbnRhcmlhABksFQQVBBUCABUAFQQVEAAAFtT/55AHFeIB + Fryhw5AHFdwGACbon7bNBhwVChklBgAZeAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHYmV0d2Vl + bgRsaXN0B2VsZW1lbnQVDBa65xIWzFkWljEm6J+2zQY8NrrnEgAZHBUAFQAVEAAAFraB6JAHFeIB + Fpiow5AHFXYAJv7Qts0GHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudARzaWRlFQwW + uucSFr5ZFpwxJv7Qts0GPDa65xIAGRwVABUAFRAAABaYg+iQBxXiARaOqcOQBxV2ACaagrfNBhwV + ABk1CAYAGRgJaGFzX3BhcnRzFQwWrOcSFpaxAhb0BiaagrfNBjwYAQEYAQAWACgBARgBAAAZHBUA + FQAVEAAAFvqE6JAHFdYBFoSqw5AHFXYAJo6Jt80GHBUAGTUIBgAZGA5pc191bmRlcmdyb3VuZBUM + FqznEhaWsQIWsAYmjom3zQY8GAEAGAEAFgAoAQAYAQAAGRwVABUAFRAAABbQhuiQBxXSARb6qsOQ + BxV2ACbGkLfNBhwVAhk1CAYEGRgKbnVtX2Zsb29ycxUMFqznEhaYKRaKJCbGkLfNBia+j7fNBhwY + BB4AAAAYBAEAAAAWrtASKAQeAAAAGAQBAAAAABksFQQVBBUCABUAFQQVEAAAFqKI6JAHFeIBFvCr + w5AHFfYBACbIs7fNBhwVAhk1CAYAGRgWbnVtX2Zsb29yc191bmRlcmdyb3VuZBUMFqznEhaiBBay + BSbIs7fNBjwYBAEAAAAYBAEAAAAWqucSKAQBAAAAGAQBAAAAABkcFQAVABUQAAAWhIrokAcV0gEW + 5q3DkAcVhgEAJvq4t80GHBUKGTUIBgAZGAptaW5faGVpZ2h0FQwWrOcSFpAEFqAFJvq4t80GPDas + 5xIAGRwVABUAFRAAABbWi+iQBxXSARbsrsOQBxV2ACaavrfNBhwVAhk1CAYAGRgJbWluX2Zsb29y + FQwWrOcSFpwPFrIHJpq+t80GPBgEAQAAABgEAQAAABaC5RIoBAEAAAAYBAEAAAAAGRwVABUAFRAA + ABaojeiQBxXWARbir8OQBxWWAQAmzMW3zQYcFQwZNQgGABkYDGZhY2FkZV9jb2xvchUMFqznEhaU + BxbOBibMxbfNBjw2jucSKAcjRkYwMDAwGAcjMDA4MDAwABkcFQAVABUQAAAW/o7okAcV1AEW+LDD + kAcVkgEAJprMt80GHBUMGTUIBgAZGA9mYWNhZGVfbWF0ZXJpYWwVDBas5xIWvgYW4AYmmsy3zQY8 + NpbnEigFZ2xhc3MYBWJyaWNrABkcFQAVABUQAAAW0pDokAcV1AEWirLDkAcVugEAJvrSt80GHBUM + GTUIBgAZGA1yb29mX21hdGVyaWFsFQwWrOcSFpAEFqAFJvrSt80GPDas5xIAGRwVABUAFRAAABam + kuiQBxXSARbEs8OQBxV2ACaa2LfNBhwVDBk1CAYAGRgKcm9vZl9zaGFwZRUMFqznEhbiIxakCiaa + 2LfNBjw2ouQSKAZnYWJsZWQYBGZsYXQAGRwVABUAFRAAABb4k+iQBxXYARa6tMOQBxXOAQAmvuK3 + zQYcFQoZNQgGABkYDnJvb2ZfZGlyZWN0aW9uFQwWrOcSFpAEFqAFJr7it80GPDas5xIAGRwVABUA + FRAAABbQleiQBxXSARaItsOQBxV2ACbe57fNBhwVDBk1CAYAGRgQcm9vZl9vcmllbnRhdGlvbhUM + FqznEhbOBBbGBSbe57fNBjwYBWFsb25nGAVhbG9uZxam5xIoBWFsb25nGAVhbG9uZwAZHBUAFQAV + EAAAFqKX6JAHFdIBFv62w5AHFYoBACak7bfNBhwVDBk1CAYAGRgKcm9vZl9jb2xvchUMFqznEhaa + BhaQBiak7bfNBjw2mOcSKAcjRkYwMDAwGAcjNzc4ODk5ABkcFQAVABUQAAAW9JjokAcV1AEWiLjD + kAcVkgEAJrTzt80GHBUKGTUIBgAZGAtyb29mX2hlaWdodBUMFqznEhaQBBagBSa087fNBjw2rOcS + ABkcFQAVABUQAAAWyJrokAcV0gEWmrnDkAcVdgAW2vSeGxas5xIm5tTcvgYW7qPbDhR0ABn8JibU + +LfNBhwVDBk1CAYAGRgCaWQVDBas8RIWgPWnBRaU170BJtT4t80GPDYAKCAwOGJiMmM1N2FlZDc1 + ZmZmMDIwMGI2YTM5MmIwMTEzZRggMDhiYjJjNTQ0MTA2OWZmZjAyMDAxODg4Y2I2ZTgwNTMAGRwV + ABUAFRAAABaanOiQBxXyARaQusOQBxXWCAAm6M/1zgYcFQwZNQgGABkYCGdlb21ldHJ5FQwWrPES + FuTXhhEW4OevCiboz/XOBjw2ACjDAQAAAAAGAAAAAgAAAAADAAAAAQAAAAXAUayr+ReucsBAs8w5 + KRZ6wFGsqjafzz7AQLPMfRu0kcBRrKldx1t0wECzvNXexEbAUayrH9Pa3sBAs7yR7CYuwFGsq/kX + rnLAQLPMOSkWegAAAAADAAAAAQAAAAXAUaypHnHbD8BAs8yYymbBwFGsp2e4df7AQLPM4pxB68BR + rKZ4pS1MwECzvVSJxRDAUayoL16SXcBAs70Ljql8wFGsqR5x2w/AQLPMmMpmwRhNAAAAAAMAAAAB + AAAABMBRorg6M4/cwEDajkq4RfTAUaK4dsLDRcBA2o1Mn8NmwFGiuRvAftPAQNqO4OntqsBRorg6 + M4/cwEDajkq4RfQAGRwVABUAFSYAABaMnuiQBxW8BBbmwsOQBxW2JwAm+KOt2QYcFQgZNQgGBBko + BGJib3gEeG1pbhUMFqzxEhagoy4WvrYqJvijrdkGJsi3pdkGHBgEYPqMwhgEnmqNwhYAKARg+ozC + GASeao3CABksFQQVBBUCABUAFQQVEAAAFsii6JAHFfIBFpzqw5AHFdYBACbe3NfZBhwVCBk1CAYE + GSgEYmJveAR4bWF4FQwWrPESFuCmLhbmuCom3tzX2QYmhu7P2QYcGARV+ozCGAR8ao3CFgAoBFX6 + jMIYBHxqjcIAGSwVBBUEFQIAFQAVBBUQAAAWuqTokAcV8gEW8uvDkAcV1gEAJvaiidoGHBUIGTUI + BgQZKARiYm94BHltaW4VDBas8RIWtKo6FsjGMSb2oonaBibspvrZBhwYBAqYBcIYBAQAB8IWACgE + CpgFwhgEBAAHwgAZLBUEFQQVAgAVABUEFRAAABaspuiQBxXyARbI7cOQBxXWAQAm4O262gYcFQgZ + NQgGBBkoBGJib3gEeW1heBUMFqzxEhbGsDoWlMsxJuDtutoGJrTtq9oGHBgE0ZcFwhgE6P8GwhYA + KATRlwXCGATo/wbCABksFQQVBBUCABUAFQQVEAAAFp6o6JAHFfIBFp7vw5AHFdYBACaIud3aBhwV + AhklCAQZGAd2ZXJzaW9uFQwWrPESFv4DFqAFJoi53doGJsi43doGHBgEAAAAABgEAAAAABYAKAQA + AAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFpCq6JAHFdIBFvTww5AHFdYBACaovt3aBhwVDBkl + BgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFqzxEhb+BRagByaovt3aBibovd3a + BhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFuKr6JAHFdIBFsryw5AHFVYAJszG3doGHBUM + GSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBas8RIWsNkEFoqUAybMxt3aBiaI + xd3aBhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVpbGRpbmdzABksFQQVBBUCABUA + FQQVEAAAFrSt6JAHFeIBFqDzw5AHFfYEACaS2eDaBhwVDBklBgAZSAdzb3VyY2VzBGxpc3QHZWxl + bWVudAlyZWNvcmRfaWQVDBas8RIW0obTAhawjXwmktng2gY8NgAoDHc5ODQxNDE3NTRAMRgMMDAw + MGZhNjZjNjhmABkcFQAVABUQAAAWlq/okAcV8gEWlvjDkAcV1gMAJoCp3tsGHBUMGSUGBBlIB3Nv + dXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwWrPESFsq9HhaEiQomgKne2wYmwubc2wYc + NgAoGDIwMjQtMTEtMjdUMjI6MDQ6NDkuMDAwWhgYMjAwMC0wMS0wMVQwMDowMDowMC4wMDBaABks + FQQVBBUCABUAFQQVEAAAFoix6JAHFe4BFuz7w5AHFdYGACbmiejbBhwVChklBgQZSAdzb3VyY2Vz + BGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWrPESFtqbFBao9BAm5ono2wYmxu/m2wYcGAicM6K0 + N/juPxgIzczMzMzM5D8W/N0LKAicM6K0N/juPxgIzczMzMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAW + 9rLokAcV8gEWwoLEkAcV9gIAJr7k99sGHBUCGTUIBgQZGAVsZXZlbBUMFqzxEha2BxbYCCa+5Pfb + Bibu4/fbBhwYBAMAAAAYBP////8W4PASKAQDAAAAGAT/////ABksFQQVBBUCABUAFQQVEAAAFui0 + 6JAHFdgBFriFxJAHFfYBACbs7vfbBhwVDBk1CAYEGRgHc3VidHlwZRUMFqzxEha0aha2WSbs7vfb + BibG7PfbBhw2ksgRKA50cmFuc3BvcnRhdGlvbhgMYWdyaWN1bHR1cmFsABksFQQVBBUCABUAFQQV + EAAAFsC26JAHFeIBFq6HxJAHFZYDACaYyvjbBhwVDBk1CAYEGRgFY2xhc3MVDBas8RIWsm4WpF4m + mMr42wYm/MX42wYcNoDMESgJd2FyZWhvdXNlGAphcGFydG1lbnRzABksFQQVBBUCABUAFQQVEAAA + FqK46JAHFeIBFsSKxJAHFYIDACb4pPnbBhwVChk1CAYEGRgGaGVpZ2h0FQwWrPESFpYFFrgGJvik + +dsGJqCk+dsGHBgIAAAAAAAAFEAYCAAAAAAAABBAFqDxEigIAAAAAAAAFEAYCAAAAAAAABBAABks + FQQVBBUCABUAFQQVEAAAFoS66JAHFdIBFsaNxJAHFbYBACbYqvnbBhwVDBk1CAYAGSgFbmFtZXMH + cHJpbWFyeRUMFqzxEhbi3AIWxs4BJtiq+dsGPDb64xIoGHJlc3RhdXJhbnQgRWwgTXVuZGlhbGl0 + bxgLIkRvbiBDaGFteSIAGRwVABUAFRAAABbWu+iQBxXiARb8jsSQBxWyBAAmnvn62wYcFQwZJQYA + GUgFbmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBas8RIWrDUW3CQmnvn62wY8NqjxEigCZXMY + AmVuABkcFQAVABUQAAAWuL3okAcV4gEWrpPEkAcVhgEAJvqd+9sGHBUMGSUGABlIBW5hbWVzBmNv + bW1vbglrZXlfdmFsdWUFdmFsdWUVDBas8RIW6D8Wzicm+p372wY8NqjxEigfTXVzZXVtIG9mIE1l + bW9yeSAmIEh1bWFuIFJpZ2h0cxgFRWtvbm8AGRwVABUAFRAAABaav+iQBxXiARa0lMSQBxWGAgAm + xMb72wYcFQwZJQYEGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBay8RIWwEAW + 0CgmxMb72wYmyMX72wYcNobxEigFc2hvcnQYCWFsdGVybmF0ZQAZLBUEFQQVAgAVABUEFRAAABb8 + wOiQBxXiARa6lsSQBxWUAgAmmO772wYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + CGxhbmd1YWdlFQwWsvESFqQ/FqInJpju+9sGPDay8RIAGRwVABUAFRAAABbewuiQBxXiARbOmMSQ + BxV2ACa6lfzbBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBay8RIW + 3EgWkC8mupX82wY8NobxEigCVkYYH0JhbmNvIEJpbGJhbyBWaXpjYXlhIEFyZ2VudGFyaWEAGRwV + ABUAFRAAABbAxOiQBxXiARbEmcSQBxXSBAAmysT82wYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlz + dAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWsvESFqg/FqQnJsrE/NsGPDay8RIAGRwV + ABUAFRAAABaixuiQBxXiARaWnsSQBxV2ACbu6/zbBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0 + B2VsZW1lbnQEc2lkZRUMFrLxEhakPxaiJybu6/zbBjw2svESABkcFQAVABUQAAAWhMjokAcV4gEW + jJ/EkAcVdgAmkJP92wYcFQAZNQgGABkYCWhhc19wYXJ0cxUMFqzxEha2sgIWzAYmkJP92wY8GAEB + GAEAFgAoAQEYAQAAGRwVABUAFRAAABbmyeiQBxXSARaCoMSQBxV2ACbcmf3bBhwVABk1CAYAGRgO + aXNfdW5kZXJncm91bmQVDBas8RIWtrICFrAGJtyZ/dsGPBgBABgBABYAKAEAGAEAABkcFQAVABUQ + AAAWuMvokAcV0gEW+KDEkAcVdgAmnKH92wYcFQIZNQgGBBkYCm51bV9mbG9vcnMVDBas8RIWjg8W + 3g8mnKH92wYmjKD92wYcGAQYAAAAGAQBAAAAFvbpEigEGAAAABgEAQAAAAAZLBUEFQQVAgAVABUE + FRAAABaKzeiQBxXeARbuocSQBxX2AQAm6q/92wYcFQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJn + cm91bmQVDBas8RIWoAQWsAUm6q/92wY8GAQBAAAAGAQBAAAAFqrxEigEAQAAABgEAQAAAAAZHBUA + FQAVEAAAFujO6JAHFdIBFuSjxJAHFYYBACaatf3bBhwVChk1CAYAGRgKbWluX2hlaWdodBUMFqzx + EhaQBBagBSaatf3bBjw2rPESABkcFQAVABUQAAAWutDokAcV0gEW6qTEkAcVdgAmurr92wYcFQIZ + NQgGABkYCW1pbl9mbG9vchUMFqzxEhaQBBagBSa6uv3bBjw2rPESABkcFQAVABUQAAAWjNLokAcV + 0gEW4KXEkAcVdgAm2r/92wYcFQwZNQgGABkYDGZhY2FkZV9jb2xvchUMFqzxEhaQBBagBSbav/3b + Bjw2rPESABkcFQAVABUQAAAW3tPokAcV0gEW1qbEkAcVdgAm+sT92wYcFQwZNQgGABkYD2ZhY2Fk + ZV9tYXRlcmlhbBUMFqzxEha8BBbMBSb6xP3bBjwYDGNlbWVudF9ibG9jaxgMY2VtZW50X2Jsb2Nr + FqrxEigMY2VtZW50X2Jsb2NrGAxjZW1lbnRfYmxvY2sAGRwVABUAFRAAABaw1eiQBxXUARbMp8SQ + BxWmAQAmxsr92wYcFQwZNQgGABkYDXJvb2ZfbWF0ZXJpYWwVDBas8RIWkAQWoAUmxsr92wY8Nqzx + EgAZHBUAFQAVEAAAFoTX6JAHFdIBFvKoxJAHFXYAJubP/dsGHBUMGTUIBgAZGApyb29mX3NoYXBl + FQwWrPESFpAEFqAFJubP/dsGPDas8RIAGRwVABUAFRAAABbW2OiQBxXSARboqcSQBxV2ACaG1f3b + BhwVChk1CAYAGRgOcm9vZl9kaXJlY3Rpb24VDBas8RIWkAQWoAUmhtX92wY8NqzxEgAZHBUAFQAV + EAAAFqja6JAHFdIBFt6qxJAHFXYAJqba/dsGHBUMGTUIBgAZGBByb29mX29yaWVudGF0aW9uFQwW + rPESFpAEFqAFJqba/dsGPDas8RIAGRwVABUAFRAAABb62+iQBxXSARbUq8SQBxV2ACbG3/3bBhwV + DBk1CAYAGRgKcm9vZl9jb2xvchUMFqzxEhaQBBagBSbG3/3bBjw2rPESABkcFQAVABUQAAAWzN3o + kAcV0gEWyqzEkAcVdgAm5uT92wYcFQoZNQgGABkYC3Jvb2ZfaGVpZ2h0FQwWrPESFpAEFqAFJubk + /dsGPDas8RIAGRwVABUAFRAAABae3+iQBxXSARbArcSQBxV2ABaa1ZcbFqzxEibU+LfNBhay8cUO + FHYAGfwmJobq/dsGHBUMGTUIBgAZGAJpZBUMFsD2EhbQrqkFFvaNvAEmhur92wY8NgAoIDA4YmIy + YzU3NzZjZGNmZmYwMjAwY2QzNzgzODJmMTYxGCAwOGJiMmM1MDkyNDAwZmZmMDIwMDA1ZDVlZDgy + NjIyOAAZHBUAFQAVEAAAFvDg6JAHFfIBFrauxJAHFdYIACb897ndBhwVDBk1CAYAGRgIZ2VvbWV0 + cnkVDBbA9hIWlr2CERb8nbAKJvz3ud0GPDYAKI0GAAAAAAMAAAAFAAAAG8BRpQKpJ6wWwEDHuHyz + r8XAUaUBym/7O8BAx7hEf4vRwFGlAoeZvNXAQMewE1iiWcBRpQN0lCaTwEDHsE4RBQvAUaUDX5tx + CsBAx7E1l5GCwFGlBSZFDifAQMexp61Yk8BRpQVeDdJRwEDHr0J4SpTAUaUHrkoqxsBAx6/XyYAR + wFGlB4D9wWHAQMexzkPFUsBRpQoliE/FwEDHsne28MLAUaUKQTcB9cBAx7FJuYd2wFGlC756I7PA + QMexqVrXvcBRpQsDaUEMwEDHubt4ELPAUaUJ9vnHAcBAx7l4XDIwwFGlCXahRw3AQMe+/4Sv/sBR + pQcL+FvHwEDHvmRUPW/AUaUHLYZLCMBAx7zzOvWfwFGlCBXjlxTAQMe9LfNYUsBRpQhtjMtVwEDH + uWKMvRLAUaUF9roGIcBAx7jEAUwwwFGlBckCPPHAQMe6vq1PWcBRpQPIC5zswEDHuj5Uz2XAUaUD + 5JEOscBAx7kCFK02wFGlA2msbATAQMe44wr8s8BRpQOR8FfswEDHtyTE22fAUaUCzGMagsBAx7bz + RrQZwFGlAqknrBbAQMe4fLOvxQAAAAXAUaUKMASqisBAx7QrFVeAwFGlCZgvNk7AQMe0AE0s2cBR + pQlD4QBgwEDHtz3vTtjAUaUJ27Z0nMBAx7dot3l+wFGlCjAEqorAQMe0KxVXgAAAAAXAUaUIOsyE + qMBAx7MkhRqHwFGlB7GlKRrAQMey/sVtXcBRpQc42WViwEDHt7hokbrAUaUHwmwgu8BAx7fe/v54 + wFGlCDrMhKjAQMezJIUahwAAAAXAUaUFto3GJ8BAx7SEAKshwFGlBTDBaOvAQMe0YnK738BRpQT4 + jUT4wEDHttNmRALAUaUFfsUB/cBAx7b09DNDwFGlBbaNxifAQMe0hACrIQAAAAXAUaUEPlMh5sBA + x7LLmcbmwFGlA6qva5PAQMeyo1Xa/sBRpQNo1axvwEDHtUQaC0TAUaUD/HliwsBAx7VsXfcswFGl + BD5TIebAQMeyy5nG5hhNAAAAAAMAAAABAAAABMBRmJSLxJG1wEDLbZLgqxLAUZiUYXa7YMBAy26l + qSqPwFGYk+YBGonAQMtucGhfvcBRmJSLxJG1wEDLbZLgqxIAGRwVABUAFSYAABbi4uiQBxW+BBaM + t8SQBxW2JwAm5Kv05wYcFQgZNQgGBBkoBGJib3gEeG1pbhUMFsD2Eha8hjEWxuksJuSr9OcGJviV + 6ucGHBgECKCMwhgEGlSNwhYAKAQIoIzCGAQaVI3CABksFQQVBBUCABUAFQQVEAAAFqDn6JAHFfIB + FsLexJAHFdYBACb6kqHoBhwVCBk1CAYEGSgEYmJveAR4bWF4FQwWwPYSFryDMRaW5ywm+pKh6AYm + vv+W6AYcGAT6n4zCGAT8U43CFgAoBPqfjMIYBPxTjcIAGSwVBBUEFQIAFQAVBBUQAAAWkunokAcV + 8gEWmODEkAcV1gEAJrTYzugGHBUIGTUIBgQZKARiYm94BHltaW4VDBbA9hIW0tAyFoS7LSa02M7o + BibU5sPoBhwYBIYIBsIYBC7+BsIWACgEhggGwhgELv4GwgAZLBUEFQQVAgAVABUEFRAAABaE6+iQ + BxXyARbu4cSQBxXWAQAm1pD86AYcFQgZNQgGBBkoBGJib3gEeW1heBUMFsD2EhakzTIW+LgtJtaQ + /OgGJtih8egGHBgEXggGwhgEGf4GwhYAKAReCAbCGAQZ/gbCABksFQQVBBUCABUAFQQVEAAAFvbs + 6JAHFfIBFsTjxJAHFdYBACaQ257pBhwVAhklCAQZGAd2ZXJzaW9uFQwWwPYSFv4DFqAFJpDbnukG + JtDanukGHBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFuju6JAH + FdIBFprlxJAHFdYBACaw4J7pBhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0 + eRUMFsD2Ehb8BRaeByaw4J7pBibw357pBhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFrrw + 6JAHFdIBFvDmxJAHFVYAJtLonukGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFz + ZXQVDBbA9hIWntsEFpaKAybS6J7pBiaO557pBhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9w + ZW4gQnVpbGRpbmdzABksFQQVBBUCABUAFQQVEAAAFozy6JAHFeIBFsbnxJAHFfYEACak8aHpBhwV + DBklBgAZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbA9hIWpM/OAhbS+X8mpPGh + 6QY8NgAoDHc5OTM3MjQwNjZAMRgMMDAwMTNmOTE4Zjg5ABkcFQAVABUQAAAW7vPokAcV8gEWvOzE + kAcV1gMAJuj3ouoGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW + wPYSFpjxGhb8sAgm6Pei6gYm9uqh6gYcNgAoGDIwMjQtMTEtMjdUMTk6NDI6MDQuMDAwWhgYMjAw + MC0wMS0wMVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFuD16JAHFeYBFpLwxJAHFdYG + ACbqrqvqBhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwWwPYSFrLH + EhaCmA8m6q6r6gYm8puq6gYcGAhfKcsQx7ruPxgIzczMzMzM5D8W+tkMKAhfKcsQx7ruPxgIzczM + zMzM5D8AGSwVBBUEFQIAFQAVBBUQAAAWxvfokAcV8gEW6PbEkAcV9gIAJry0ueoGHBUCGTUIBgQZ + GAVsZXZlbBUMFsD2EhbyBhaUCCa8tLnqBib0s7nqBhwYBAEAAAAYBP////8W9PUSKAQBAAAAGAT/ + ////ABksFQQVBBUCABUAFQQVEAAAFrj56JAHFdYBFt75xJAHFfYBACaUvrnqBhwVDBk1CAYEGRgH + c3VidHlwZRUMFsD2Eha2ZhbCViaUvrnqBiaIvLnqBhw21tsRKAdzZXJ2aWNlGAxhZ3JpY3VsdHVy + YWwAGSwVBBUEFQIAFQAVBBUQAAAWjvvokAcV4gEW1PvEkAcV/AIAJo6XuuoGHBUMGTUIBgQZGAVj + bGFzcxUMFsD2EhaoZRbOWCaOl7rqBibKkrrqBhw2pt8RKAp1bml2ZXJzaXR5GA9hbGxvdG1lbnRf + aG91c2UAGSwVBBUEFQIAFQAVBBUQAAAW8PzokAcV4gEW0P7EkAcVkgMAJpjruuoGHBUKGTUIBgAZ + GAZoZWlnaHQVDBbA9hIWqBIWuAommOu66gY8GAgAAAAAAMBFQBgIAAAAAAAACEAWiPUSKAgAAAAA + AMBFQBgIAAAAAAAACEAAGRwVABUAFRAAABbS/uiQBxXcARbigcWQBxWWAgAm0PW66gYcFQwZNQgG + ABkoBW5hbWVzB3ByaW1hcnkVDBbA9hIWutYCFvzIASbQ9brqBjw2yOkSKAd0b3JyZSA0GAg0IFB1 + bnRvcwAZHBUAFQAVEAAAFq6A6ZAHFeIBFviDxZAHFYQEACbMvrzqBhwVDBklBgAZSAVuYW1lcwZj + b21tb24Ja2V5X3ZhbHVlA2tleRUMFsL2EhaCOhasJybMvrzqBjw2uPYSKAJ6aBgCZW4AGRwVABUA + FRAAABaQgumQBxXiARb8h8WQBxWOAQAm+OW86gYcFQwZJQYAGUgFbmFtZXMGY29tbW9uCWtleV92 + YWx1ZQV2YWx1ZRUMFsL2EhaERhasKSb45bzqBjw2uPYSKAbml6fpk7oYKzFhIENvbXBhw7HDrWEg + ZGUgQm9tYmVyb3MgTWV0cm9wb2xpdGFubyBTdXIAGRwVABUAFRAAABbyg+mQBxXiARaKicWQBxWW + AwAmpI+96gYcFQwZJQYAGVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B3ZhcmlhbnQVDBbG9hIW + xEcW/ikmpI+96gY8NqD2EigFc2hvcnQYCWFsdGVybmF0ZQAZHBUAFQAVEAAAFtSF6ZAHFeIBFqCM + xZAHFbYCACaiub3qBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UV + DBbG9hIW+EMWoCcmorm96gY8Nsb2EgAZHBUAFQAVEAAAFraH6ZAHFeIBFtaOxZAHFXYAJsLgveoG + HBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFsb2EhaSTBaMLibC4L3q + Bjw2oPYSKANVREQYH0JhbmNvIGRlIENyw6lkaXRvIGUgSW52ZXJzaW9uZXMAGRwVABUAFRAAABaY + iemQBxXiARbMj8WQBxWGBQAmzo6+6gYcFQoZJQYAGXgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50 + B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWxvYSFv5DFqYnJs6OvuoGPDbG9hIAGRwVABUAFRAAABb6 + iumQBxXiARbSlMWQBxV2ACb0tb7qBhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQE + c2lkZRUMFsb2Ehb4QxagJyb0tb7qBjw2xvYSABkcFQAVABUQAAAW3IzpkAcV4gEWyJXFkAcVdgAm + lN2+6gYcFQAZNQgGABkYCWhhc19wYXJ0cxUMFsD2EhaIswIWzAYmlN2+6gY8GAEBGAEAFgAoAQEY + AQAAGRwVABUAFRAAABa+jumQBxXSARa+lsWQBxV2ACbg477qBhwVABk1CAYAGRgOaXNfdW5kZXJn + cm91bmQVDBbA9hIWiLMCFrAGJuDjvuoGPBgBABgBABYAKAEAGAEAABkcFQAVABUQAAAWkJDpkAcV + 0gEWtJfFkAcVdgAmuuu+6gYcFQIZNQgGBBkYCm51bV9mbG9vcnMVDBbA9hIWrhUW4hUmuuu+6gYm + kOq+6gYcGAQSAAAAGAQBAAAAFtbjEigEEgAAABgEAQAAAAAZLBUEFQQVAgAVABUEFRAAABbikemQ + BxXeARaqmMWQBxX2AQAm8v++6gYcFQIZNQgGABkYFm51bV9mbG9vcnNfdW5kZXJncm91bmQVDBbA + 9hIWogQWsgUm8v++6gY8GAQCAAAAGAQCAAAAFr72EigEAgAAABgEAgAAAAAZHBUAFQAVEAAAFsCT + 6ZAHFdIBFqCaxZAHFYYBACakhb/qBhwVChk1CAYAGRgKbWluX2hlaWdodBUMFsD2EhaQBBagBSak + hb/qBjw2wPYSABkcFQAVABUQAAAWkpXpkAcV0gEWppvFkAcVdgAmxIq/6gYcFQIZNQgGABkYCW1p + bl9mbG9vchUMFsD2EhaQBBagBSbEir/qBjw2wPYSABkcFQAVABUQAAAW5JbpkAcV0gEWnJzFkAcV + dgAm5I+/6gYcFQwZNQgGABkYDGZhY2FkZV9jb2xvchUMFsD2Ehb2BRbEBibkj7/qBjw2sPYSKAcj + RkZGRkZGGAcjNjcwMDIwABkcFQAVABUQAAAWtpjpkAcV1gEWkp3FkAcVrgEAJqiWv+oGHBUMGTUI + BgAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbA9hIWxgsW4AYmqJa/6gY8Nub1EigIY29uY3JldGUYBWJy + aWNrABkcFQAVABUQAAAWjJrpkAcV1gEWwJ7FkAcVqgEAJoidv+oGHBUMGTUIBgAZGA1yb29mX21h + dGVyaWFsFQwWwPYSFr4NFpwGJoidv+oGPBgKcm9vZl90aWxlcxgKcm9vZl90aWxlcxbw9RIoCnJv + b2ZfdGlsZXMYCnJvb2ZfdGlsZXMAGRwVABUAFRAAABbim+mQBxXUARbqn8WQBxWeAQAmpKO/6gYc + FQwZNQgGABkYCnJvb2Zfc2hhcGUVDBbA9hIWsAwWuAYmpKO/6gY8NuD1EigGaGlwcGVkGAZnYWJs + ZWQAGRwVABUAFRAAABa2nemQBxXUARaIocWQBxWOAQAm3Km/6gYcFQoZNQgGABkYDnJvb2ZfZGly + ZWN0aW9uFQwWwPYSFpAEFqAFJtypv+oGPDbA9hIAGRwVABUAFRAAABaKn+mQBxXSARaWosWQBxV2 + ACb8rr/qBhwVDBk1CAYAGRgQcm9vZl9vcmllbnRhdGlvbhUMFsD2EhbGBRbuBSb8rr/qBjw2sPYS + KAVhbG9uZxgGYWNyb3NzABkcFQAVABUQAAAW3KDpkAcV1AEWjKPFkAcVjAEAJuq0v+oGHBUMGTUI + BgAZGApyb29mX2NvbG9yFQwWwPYSFq4FFpQGJuq0v+oGPDa29hIoByM3Nzg4OTkYByMwMDAwMDAA + GRwVABUAFRAAABawoumQBxXUARaYpMWQBxWuAQAm/rq/6gYcFQoZNQgGABkYC3Jvb2ZfaGVpZ2h0 + FQwWwPYSFtYKFpIHJv66v+oGPBgIAAAAAAAACEAYCFyPwvUoXOc/FuL1EigIAAAAAAAACEAYCFyP + wvUoXOc/ABkcFQAVABUQAAAWhKTpkAcV1AEWxqXFkAcVlgEAFtrogRsWwPYSJobq/dsGForYwQ4U + eAAZ/CYmkMK/6gYcFQwZNQgGABkYAmlkFQwW2IwTFrDNrwUWjr69ASaQwr/qBjw2ACggMDhiYjJj + NTczNGJiNWZmZjAyMDBkM2IzOTQyYmI4NjYYIDA4YmIyYzUwODAwMDFmZmYwMjAwNGRmZjFlMTVh + ZWQ2ABkcFQAVABUQAAAW2KXpkAcV8gEW3KbFkAcV1ggAJp6A/esGHBUMGTUIBgAZGAhnZW9tZXRy + eRUMFtiMExbukPkQFri/iwomnoD96wY8NgAowAIAAAAABgAAAAMAAAAAAwAAAAEAAAAHwFGqbFes + j0DAQLw94rmeHMBRqmvgjkqxwEC8R4XQjvnAUappJPIn0MBAvEcn3L3cwFGqaXQ34EHAQLxAu7Hy + VsBRqmkuLGM1wEC8QLJ3tvHAUappVgTvU8BAvD17i5GZwFGqbFesj0DAQLw94rmeHAAAAAADAAAA + AQAAAAXAUapxe21eqMBAvD58PJGBwFGqcVxjriXAQLxD6I0ctMBRqm8p7ubTwEC8Q53kgfXAUapv + bXYlIMBAvD5IOit1wFGqcXttXqjAQLw+fDyRgQAAAAADAAAAAQAAAAXAUap0btJFs8BAvD7G5Sw/ + wFGqdEuW10fAQLxIJTK/cMBRqnFZdA+cwEC8R+f2Hf/AUapxoZhrnMBAvD56jxJXwFGqdG7SRbPA + QLw+xuUsPxhNAAAAAAMAAAABAAAABMBRo/kwPv0KwEDIIB/hEATAUaP5E6SVacBAyB7+vX5mwFGj + +dFUclTAQMgf8zSi4cBRo/kwPv0KwEDIIB/hEAQAGRwVABUAFSYAABbKp+mQBxW8BBayr8WQBxW2 + JwAmuuGO9gYcFQgZNQgGBBkoBGJib3gEeG1pbhUMFtiMExbA5CsWrscoJrrhjvYGJta/iPYGHBgE + 5PqMwhgEHlSNwhYAKATk+ozCGAQeVI3CABksFQQVBBUCABUAFQQVEAAAFoas6ZAHFfIBFujWxZAH + FdYBACaWqbf2BhwVCBk1CAYEGSgEYmJveAR4bWF4FQwW2IwTFoblKxbyxygmlqm39gYmhIex9gYc + GATf+ozCGAT9U43CFgAoBN/6jMIYBP1TjcIAGSwVBBUEFQIAFQAVBBUQAAAW+K3pkAcV8gEWvtjF + kAcV1gEAJvj34vYGHBUIGTUIBgQZKARiYm94BHltaW4VDBbYjBMWiIEwFrj/Kyb49+L2Bib2ztn2 + BhwYBIrbBcIYBDBMBsIWACgEitsFwhgEMEwGwgAZLBUEFQQVAgAVABUEFRAAABbqr+mQBxXyARaU + 2sWQBxXWAQAmyveO9wYcFQgZNQgGBBkoBGJib3gEeW1heBUMFtiMExaGgTAW0P8rJsr3jvcGJq7O + hfcGHBgEGtsFwhgE+EsGwhYAKAQa2wXCGAT4SwbCABksFQQVBBUCABUAFQQVEAAAFtyx6ZAHFfIB + FurbxZAHFdYBACa+zrH3BhwVAhklCAQZGAd2ZXJzaW9uFQwW2IwTFv4DFqAFJr7OsfcGJv7NsfcG + HBgEAAAAABgEAAAAABYAKAQAAAAAGAQAAAAAABksFQQVBBUCABUAFQQVEAAAFs6z6ZAHFdIBFsDd + xZAHFdYBACbe07H3BhwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAhwcm9wZXJ0eRUMFtiM + Exb+BRagBybe07H3Biae07H3BhwYABgAFgAoABgAABksFQQVBBUCABUAFQQVEAAAFqC16ZAHFdIB + FpbfxZAHFVYAJoLcsfcGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50B2RhdGFzZXQVDBbY + jBMW6t4EFpyhAyaC3LH3Bia+2rH3Bhw2ACgNT3BlblN0cmVldE1hcBgVR29vZ2xlIE9wZW4gQnVp + bGRpbmdzABksFQQVBBUCABUAFQQVEAAAFvK26ZAHFeIBFuzfxZAHFfYEACba+7T3BhwVDBklBgAZ + SAdzb3VyY2VzBGxpc3QHZWxlbWVudAlyZWNvcmRfaWQVDBbYjBMWmsHQAhbogHkm2vu09wY8NgAo + DHc5OTAxNjQ3ODhAMRgMMDAwMGY5MTNiZjE4ABkcFQAVABUQAAAW1LjpkAcV8gEW4uTFkAcV1gMA + JuDfr/gGHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50C3VwZGF0ZV90aW1lFQwW2IwTFoyD + IRaAigwm4N+v+AYmwvyt+AYcNgAoGDIwMjQtMTEtMjlUMTc6MjU6MDIuMDAwWhgYMjAwMC0wMS0w + MVQwMDowMDowMC4wMDBaABksFQQVBBUCABUAFQQVEAAAFsa66ZAHFfABFrjoxZAHFdYGACaclrv4 + BhwVChklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudApjb25maWRlbmNlFQwW2IwTFuqYEhaq5Q4m + nJa7+AYmwoa6+AYcGAjnjCjtDb7uPxgIzczMzMzM5D8WnJQNKAjnjCjtDb7uPxgIzczMzMzM5D8A + GSwVBBUEFQIAFQAVBBUQAAAWtrzpkAcV8gEWju/FkAcV9gIAJrzsyPgGHBUCGTUIBgQZGAVsZXZl + bBUMFtiMExbECBbMCSa87Mj4Bibs68j4BhwYBAIAAAAYBP////8W4osTKAQCAAAAGAT/////ABks + FQQVBBUCABUAFQQVEAAAFqi+6ZAHFdoBFoTyxZAHFdYBACbe98j4BhwVDBk1CAYEGRgHc3VidHlw + ZRUMFtiMExaawwEWkqQBJt73yPgGJrj1yPgGHDa+jRAoDnRyYW5zcG9ydGF0aW9uGAxhZ3JpY3Vs + dHVyYWwAGSwVBBUEFQIAFQAVBBUQAAAWgsDpkAcV4gEW2vPFkAcVsAMAJuKeyvgGHBUMGTUIBgQZ + GAVjbGFzcxUMFtiMExaY5gEW4LoBJuKeyvgGJsqZyvgGHDb0khAoCXdhcmVob3VzZRgPYWxsb3Rt + ZW50X2hvdXNlABksFQQVBBUCABUAFQQVEAAAFuTB6ZAHFeIBFor3xZAHFaYDACaa1sv4BhwVChk1 + CAYEGRgGaGVpZ2h0FQwW2IwTFrgTFvYRJprWy/gGJqrUy/gGHBgIAAAAAADAWUAYCAAAAAAAAPA/ + FuSCEygIAAAAAADAWUAYCAAAAAAAAPA/ABksFQQVBBUCABUAFQQVEAAAFsbD6ZAHFdgBFrD6xZAH + FZYCACbogc34BhwVDBk1CAYEGSgFbmFtZXMHcHJpbWFyeRUMFtiMExb0ogMWotsBJuiBzfgGJqDm + y/gGHDay/BIoEsOTcHRpY2EgTmV3R2xhc3NlcxgfMSBKdXpnYWRvIGRlIEZhbWlsaWEgU2FuIE1p + Z3VlbAAZLBUEFQQVAgAVABUEFRAAABaexemQBxXiARbG/MWQBxWGBQAmwsHN+AYcFQwZJQYAGUgF + bmFtZXMGY29tbW9uCWtleV92YWx1ZQNrZXkVDBbcjBMWzD8W1ikmwsHN+AY8NsCMEygCZXMYAmVu + ABkcFQAVABUQAAAWgMfpkAcV4gEWzIHGkAcVngEAJpjrzfgGHBUMGSUGABlIBW5hbWVzBmNvbW1v + bglrZXlfdmFsdWUFdmFsdWUVDBbcjBMW4E4Wri4mmOvN+AY8NsCMEygRWWluLUhlIFJlc3RhdXRh + bnQYFUFjYWRlbXkgb2YgUGhpbG9zb3BoeQAZHBUAFQAVEAAAFuLI6ZAHFeIBFuqCxpAHFcgDACbC + ms74BhwVDBklBgQZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQHdmFyaWFudBUMFuCMExbKSxbc + KybCms74BibGmc74Bhw2oIwTKAVzaG9ydBgJYWx0ZXJuYXRlABksFQQVBBUCABUAFQQVEAAAFsTK + 6ZAHFeIBFrKGxpAHFbwCACaixc74BhwVDBklBgAZWAVuYW1lcwVydWxlcwRsaXN0B2VsZW1lbnQI + bGFuZ3VhZ2UVDBbgjBMWrEoWqComosXO+AY8NuCMEwAZHBUAFQAVEAAAFqbM6ZAHFeIBFu6IxpAH + FXYAJsrvzvgGHBUMGSUGABlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAV2YWx1ZRUMFuCMExb+ + Vha4NCbK7874Bjw2oIwTKA9Uw7puZWwgVW5pdmVyc28YGjR0YSBDb21pc2Fyw61hIGRlIFNhbnRp + YWdvABkcFQAVABUQAAAWiM7pkAcV4gEW5InGkAcVygQAJoKkz/gGHBUKGSUGABl4BW5hbWVzBXJ1 + bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFuCMExa2Sha2KiaCpM/4Bjw2 + 4IwTABkcFQAVABUQAAAW6s/pkAcV4gEWro7GkAcVdgAmuM7P+AYcFQwZJQYAGVgFbmFtZXMFcnVs + ZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbgjBMWrEoWqComuM7P+AY8NuCMEwAZHBUAFQAVEAAAFszR + 6ZAHFeIBFqSPxpAHFXYAJuD4z/gGHBUAGTUIBgAZGAloYXNfcGFydHMVDBbYjBMW7LUCFsIGJuD4 + z/gGPBgBARgBABYAKAEBGAEAABkcFQAVABUQAAAWrtPpkAcV0gEWmpDGkAcVdgAmov/P+AYcFQAZ + NQgGABkYDmlzX3VuZGVyZ3JvdW5kFQwW2IwTFuy1AhawBiai/8/4BjwYAQAYAQAWACgBABgBAAAZ + HBUAFQAVEAAAFoDV6ZAHFdIBFpCRxpAHFXYAJuiG0PgGHBUCGTUIBgQZGApudW1fZmxvb3JzFQwW + 2IwTFogwFs4qJuiG0PgGJtKF0PgGHBgEJAAAABgEAQAAABai4hIoBCQAAAAYBAEAAAAAGSwVBBUE + FQIAFQAVBBUQAAAW0tbpkAcV4gEWhpLGkAcV9gEAJqCw0PgGHBUCGTUIBgAZGBZudW1fZmxvb3Jz + X3VuZGVyZ3JvdW5kFQwW2IwTFsYEFtYFJqCw0PgGPBgEAgAAABgEAQAAABbSjBMoBAIAAAAYBAEA + AAAAGRwVABUAFRAAABa02OmQBxXSARb8k8aQBxWWAQAm9rXQ+AYcFQoZNQgGABkYCm1pbl9oZWln + aHQVDBbYjBMWkAQWoAUm9rXQ+AY8NtiMEwAZHBUAFQAVEAAAFoba6ZAHFdIBFpKVxpAHFXYAJpa7 + 0PgGHBUCGTUIBgAZGAltaW5fZmxvb3IVDBbYjBMWkAQWoAUmlrvQ+AY8NtiMEwAZHBUAFQAVEAAA + Ftjb6ZAHFdIBFoiWxpAHFXYAJrbA0PgGHBUMGTUIBgAZGAxmYWNhZGVfY29sb3IVDBbYjBMWzgQW + 3gUmtsDQ+AY8GAcjRkZGRkZGGAcjRkZGRkZGFtSMEygHI0ZGRkZGRhgHI0ZGRkZGRgAZHBUAFQAV + EAAAFqrd6ZAHFdIBFv6WxpAHFa4BACaUxtD4BhwVDBk1CAYAGRgPZmFjYWRlX21hdGVyaWFsFQwW + 2IwTFtAEFuAFJpTG0PgGPDbUjBMoCGNvbmNyZXRlGAVicmljawAZHBUAFQAVEAAAFvze6ZAHFdQB + FqyYxpAHFZABACb0y9D4BhwVDBk1CAYAGRgNcm9vZl9tYXRlcmlhbBUMFtiMExa2BBbGBSb0y9D4 + BjwYCnJvb2ZfdGlsZXMYCnJvb2ZfdGlsZXMW1owTKApyb29mX3RpbGVzGApyb29mX3RpbGVzABkc + FQAVABUQAAAW0ODpkAcV0gEWvJnGkAcVngEAJprS0PgGHBUMGTUIBgQZGApyb29mX3NoYXBlFQwW + 2IwTFrYFFtgGJprS0PgGJrrR0PgGHDa+jBMoBmhpcHBlZBgGZ2FibGVkABksFQQVBBUCABUAFQQV + EAAAFqLi6ZAHFdIBFtqaxpAHFb4BACaS2ND4BhwVChk1CAYAGRgOcm9vZl9kaXJlY3Rpb24VDBbY + jBMWkAQWoAUmktjQ+AY8NtiMEwAZHBUAFQAVEAAAFvTj6ZAHFdIBFpicxpAHFXYAJrLd0PgGHBUM + GTUIBgAZGBByb29mX29yaWVudGF0aW9uFQwW2IwTFv4EFuQFJrLd0PgGPBgFYWxvbmcYBWFsb25n + Fs6MEygFYWxvbmcYBWFsb25nABkcFQAVABUQAAAWxuXpkAcV0gEWjp3GkAcVngEAJpbj0PgGHBUM + GTUIBgAZGApyb29mX2NvbG9yFQwW2IwTFpIFFuwFJpbj0PgGPDbOjBMoByNGRkZGRkYYByM4QjQ1 + MTMAGRwVABUAFRAAABaY5+mQBxXUARasnsaQBxWuAQAmgunQ+AYcFQoZNQgGABkYC3Jvb2ZfaGVp + Z2h0FQwW2IwTFpAEFqAFJoLp0PgGPDbYjBMAGRwVABUAFRAAABbs6OmQBxXSARban8aQBxV2ABaM + tvkaFtiMEyaQwr/qBhaSrJEOFHoAGfwmJqLu0PgGHBUMGTUIBgAZGAJpZBUMFsTQEhbc154FFt7F + ugEmou7Q+AY8NgAoIDA4YmIyYzU1NmVkYjZmZmYwMjAwYzBmYTYzNzE0NDZkGCAwOGJiMmM1MDgw + OTAwZmZmMDIwMDZjZTNkOGY2MjdkNwAZHBUAFQAVEAAAFr7q6ZAHFfIBFtCgxpAHFdYIACaAtIv6 + BhwVDBk1CAYAGRgIZ2VvbWV0cnkVDBbE0BIWtuXzERbm09kKJoC0i/oGPAAZHBUAFQAVKAAAFrDs + 6ZAHFdoEFqapxpAHFb4pACaCkuuEBxwVCBk1CAYEGSgEYmJveAR4bWluFQwWxNASFrSqKhbsmCcm + gpLrhAcm5oflhAccGASeBY3CGAQ1VI3CFgAoBJ4FjcIYBDVUjcIAGSwVBBUEFQIAFQAVBBUQAAAW + ivHpkAcV8gEW5NLGkAcV1gEAJpyrkoUHHBUIGTUIBgQZKARiYm94BHhtYXgVDBbE0BIW7KoqFoSi + Jyacq5KFBybSoIyFBxwYBJUFjcIYBPxTjcIWACgElQWNwhgE/FONwgAZLBUEFQQVAgAVABUEFRAA + ABb88umQBxXyARa61MaQBxXWAQAm4vi6hQccFQgZNQgGBBkoBGJib3gEeW1pbhUMFsTQEhbc+SwW + 1pspJuL4uoUHJtbCs4UHHBgEBpgFwhgEYPIFwhYAKAQGmAXCGARg8gXCABksFQQVBBUCABUAFQQV + EAAAFu706ZAHFfIBFpDWxpAHFdYBACaIlOSFBxwVCBk1CAYEGSgEYmJveAR5bWF4FQwWxNASFpr5 + LBakmykmiJTkhQcmrN7chQccGASelwXCGAT88QXCFgAoBJ6XBcIYBPzxBcIAGSwVBBUEFQIAFQAV + BBUQAAAW4PbpkAcV8gEW5tfGkAcV1gEAJpD6hYYHHBUCGSUIBBkYB3ZlcnNpb24VDBbE0BIW/gMW + oAUmkPqFhgcm0PmFhgccGAQAAAAAGAQAAAAAFgAoBAAAAAAYBAAAAAAAGSwVBBUEFQIAFQAVBBUQ + AAAW0vjpkAcV0gEWvNnGkAcV1gEAJrD/hYYHHBUMGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50 + CHByb3BlcnR5FQwWxNASFv4FFqAHJrD/hYYHJvD+hYYHHBgAGAAWACgAGAAAGSwVBBUEFQIAFQAV + BBUQAAAWpPrpkAcV0gEWktvGkAcVVgAm1IeGhgccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1l + bnQHZGF0YXNldBUMFsTQEhbgxQQWgJ4DJtSHhoYHJpCGhoYHHDYAKA1PcGVuU3RyZWV0TWFwGBVH + b29nbGUgT3BlbiBCdWlsZGluZ3MAGSwVBBUEFQIAFQAVBBUQAAAW9vvpkAcV4gEW6NvGkAcV9gQA + JpCkiYYHHBUMGSUGABlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CXJlY29yZF9pZBUMFsTQEhaY+8cC + FqidcCaQpImGBzw2ACgMdzk5NDk2MTgzOEAxGAwwMDA2ZGI5ZDNhZmMAGRwVABUAFRAAABbY/emQ + BxXyARbe4MaQBxXWAwAm/siAhwccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQLdXBkYXRl + X3RpbWUVDBbE0BIWiuA+FuyvFSb+yICHBya4wfmGBxw2ACgYMjAyNC0xMS0zMFQxODo1MTo1Ni4w + MDBaGBgyMDAwLTAxLTAxVDAwOjAwOjAwLjAwMFoAGSwVBBUEFQIAFQAVBBUQAAAWyv/pkAcV8AEW + tOTGkAcV1gYAJoCFkIcHHBUKGSUGBBlIB3NvdXJjZXMEbGlzdAdlbGVtZW50CmNvbmZpZGVuY2UV + DBbE0BIW0rQRFu6EDiaAhZCHByak8Y6HBxwYCGwJ+aBns+4/GAjNzMzMzMzkPxb0hA0oCGwJ+aBn + s+4/GAjNzMzMzMzkPwAZLBUEFQQVAgAVABUEFRAAABa6geqQBxXyARaK68aQBxX2AgAmgvechwcc + FQIZNQgGBBkYBWxldmVsFQwWxNASFoYSFvIQJoL3nIcHJpL2nIcHHBgEBQAAABgE/P///xb0zBIo + BAUAAAAYBPz///8AGSwVBBUEFQIAFQAVBBUQAAAWrIPqkAcV4AEWgO7GkAcV9gEAJqqJnYcHHBUM + GTUIBgQZGAdzdWJ0eXBlFQwWxNASFrycAhbC5AEmqomdhwcmhIedhwccNqiIDygOdHJhbnNwb3J0 + YXRpb24YDGFncmljdWx0dXJhbAAZLBUEFQQVAgAVABUEFRAAABaMheqQBxXiARb278aQBxW0AwAm + 5vGehwccFQwZNQgGBBkYBWNsYXNzFQwWxNASFtaJAxbAmwIm5vGehwcmxuuehwccNpCWDygJd2Fy + ZWhvdXNlGA9hbGxvdG1lbnRfaG91c2UAGSwVBBUEFQIAFQAVBBUQAAAW7obqkAcV4gEWqvPGkAcV + sgMAJoaHoYcHHBUKGTUIBgAZGAZoZWlnaHQVDBbE0BIWhCEWlhEmhoehhwc8GAgAAAAAAMByQBgI + AAAAAAAA8D8WuM0SKAgAAAAAAMByQBgIAAAAAAAA8D8AGRwVABUAFRAAABbQiOqQBxXgARbc9saQ + BxX2AgAmnpOlhwccFQwZNQgGBBkoBW5hbWVzB3ByaW1hcnkVDBbE0BIWoKULFsizBSaek6WHByac + mKGHBxw2ppUSKBTDkXXDsW9hIFZpZGEgVG9ycmUgMhgdMSBDb21pc2Fyw61hIFNhbnRpYWdvIENl + bnRyYWwAGSwVBBUEFQIAFQAVBBUQAAAWsIrqkAcV4gEW0vnGkAcV7gUAJqLNpocHHBUMGSUGBBlI + BW5hbWVzBmNvbW1vbglrZXlfdmFsdWUDa2V5FQwWutESFqykARbwXyaizaaHBybky6aHBxw2rM8S + KAJ6aBgCYXIAGSwVBBUEFQIAFQAVBBUQAAAWkozqkAcV4gEWwP/GkAcVrgEAJtSrp4cHHBUMGSUG + ABlIBW5hbWVzBmNvbW1vbglrZXlfdmFsdWUFdmFsdWUVDBa60RIW7vwBFtaGASbUq6eHBzw2rM8S + KBfsuaDroIgg7Iic67O17J2MIOq1kO2ajBgPQUROIFJhZGlvIENoaWxlABkcFQAVABUQAAAW9I3q + kAcV4gEW7oDHkAcVzgUAJqazqIcHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAd2 + YXJpYW50FQwWtNESFoDJARamaCams6iHByaqsqiHBxw20s0SKAVzaG9ydBgJYWx0ZXJuYXRlABks + FQQVBBUCABUAFQQVEAAAFtaP6pAHFeIBFryGx5AHFeQCACbQmqmHBxwVDBklBgAZWAVuYW1lcwVy + dWxlcwRsaXN0B2VsZW1lbnQIbGFuZ3VhZ2UVDBa00RIW9MgBFrJmJtCaqYcHPDaI0RIoAnB0GAJl + bgAZHBUAFQAVEAAAFriR6pAHFeIBFqCJx5AHFZ4BACbio6qHBxwVDBklBgQZWAVuYW1lcwVydWxl + cwRsaXN0B2VsZW1lbnQFdmFsdWUVDBa00RIWpIsCFpaNASbio6qHByaCgaqHBxw20s0SKAJVThgE + QUNIUwAZLBUEFQQVAgAVABUEFRAAABaak+qQBxXiARa+iseQBxX8BAAmmI6rhwccFQoZJQYAGXgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50B2JldHdlZW4EbGlzdAdlbGVtZW50FQwWtNESFr7HARa6 + ZSaYjquHBzw2tNESABkcFQAVABUQAAAW/JTqkAcV4gEWuo/HkAcVdgAm0vOrhwccFQwZJQYAGVgF + bmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBa00RIW8MYBFrBlJtLzq4cHPDa00RIAGRwV + ABUAFRAAABbeluqQBxXiARawkMeQBxV2ACaC2ayHBxwVABk1CAYAGRgJaGFzX3BhcnRzFQwWxNAS + Fq6uAhbmCiaC2ayHBzwYAQEYAQAWACgBARgBAAAZHBUAFQAVEAAAFsCY6pAHFdwBFqaRx5AHFXYA + JujjrIcHHBUAGTUIBgAZGA5pc191bmRlcmdyb3VuZBUMFsTQEhaqrgIWsAYm6OOshwc8GAEAGAEA + FgAoAQAYAQAAGRwVABUAFRAAABacmuqQBxXSARackseQBxV2ACbM66yHBxwVAhk1CAYEGRgKbnVt + X2Zsb29ycxUMFsTQEhae3gEW8LYBJszrrIcHJpjqrIcHHBgEQAAAABgEAQAAABaWrREoBEAAAAAY + BAEAAAAAGSwVBBUEFQIAFQAVBBUQAAAW7pvqkAcV4gEWkpPHkAcV9gEAJoihrocHHBUCGTUIBgAZ + GBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWxNASFqoHFpYIJoihrocHPBgEBwAAABgEAQAAABaU + 0BIoBAcAAAAYBAEAAAAAGRwVABUAFRAAABbQneqQBxXYARaIlceQBxXWAQAmnqmuhwccFQoZNQgG + ABkYCm1pbl9oZWlnaHQVDBbE0BIW1AQW5AUmnqmuhwc8GAgAAAAAAAA7QBgIAAAAAAAAAAAWvtAS + KAgAAAAAAAA7QBgIAAAAAAAAAAAAGRwVABUAFRAAABaon+qQBxXSARbelseQBxW2AQAmgq+uhwcc + FQIZNQgGABkYCW1pbl9mbG9vchUMFsTQEhaiBBayBSaCr66HBzwYBAEAAAAYBAEAAAAWwtASKAQB + AAAAGAQBAAAAABkcFQAVABUQAAAW+qDqkAcV0gEWlJjHkAcVhgEAJrS0rocHHBUMGTUIBgAZGAxm + YWNhZGVfY29sb3IVDBbE0BIW4gYWqgcmtLSuhwc8Nq7QEigHI0ZGRkZGRhgHIzQ4NTk2QgAZHBUA + FQAVEAAAFsyi6pAHFdgBFpqZx5AHFeYBACbeu66HBxwVDBk1CAYAGRgPZmFjYWRlX21hdGVyaWFs + FQwWxNASFrIQFpgLJt67rocHPDbGzxIoB3BsYXN0ZXIYBWJyaWNrABkcFQAVABUQAAAWpKTqkAcV + 3AEWgJvHkAcVjAIAJvbGrocHHBUMGTUIBgAZGA1yb29mX21hdGVyaWFsFQwWxNASFoQFFogGJvbG + rocHPDa80BIoCnJvb2ZfdGlsZXMYBWdsYXNzABkcFQAVABUQAAAWgKbqkAcV1AEWjJ3HkAcVlAEA + JvTOrocHHBUMGTUIBgQZGApyb29mX3NoYXBlFQwWxNASFr4pFtokJvTOrocHJv7MrocHHDa4uBIo + CHNraWxsaW9uGARkb21lABksFQQVBBUCABUAFQQVEAAAFtSn6pAHFd4BFqCex5AHFZQCACbY8a6H + BxwVChk1CAYAGRgOcm9vZl9kaXJlY3Rpb24VDBbE0BIWqgQWugUm2PGuhwc8GAgAAAAAAABZQBgI + AAAAAAAAWUAWwtASKAgAAAAAAABZQBgIAAAAAAAAWUAAGRwVABUAFRAAABayqeqQBxXSARa0oMeQ + BxWWAQAmkveuhwccFQwZNQgGABkYEHJvb2Zfb3JpZW50YXRpb24VDBbE0BIWshsWlgcmkveuhwc8 + NpLOEigFYWxvbmcYBmFjcm9zcwAZHBUAFQAVEAAAFoSr6pAHFdYBFsqhx5AHFbgBACao/q6HBxwV + DBk1CAYAGRgKcm9vZl9jb2xvchUMFsTQEhamBRa2Biao/q6HBzw2utASKAcjRkZGRkZGGAcjNzc4 + ODk5ABkcFQAVABUQAAAW2qzqkAcV1AEWgqPHkAcV5gEAJt6Er4cHHBUKGTUIBgAZGAtyb29mX2hl + aWdodBUMFsTQEhbABRasBibehK+HBzwYCAAAAAAAAC5AGAiamZmZmZnZPxa00BIoCAAAAAAAAC5A + GAiamZmZmZnZPwAZHBUAFQAVEAAAFq6u6pAHFdYBFuikx5AHFdYBABbC64EcFsTQEiai7tD4Bhbo + nN4OFHwAGfwmJoqLr4cHHBUMGTUIBgAZGAJpZBUMFsDWCxbyrKQDFqDSdSaKi6+HBzw2ACggMDhi + YjJjNWM5ZTZmMmZmZjAyMDBkMTY1MTYyNTNjOTIYIDA4YmIyYzQyNDAwOWFmZmYwMjAwMmQxMThm + N2VmMzYwABkcFQAVABUKAAAWhLDqkAcVmAEWvqbHkAcVvgUAJqrdpIgHHBUMGTUIBgAZGAhnZW9t + ZXRyeRUMFsDWCxayk48KFrTYiwYmqt2kiAc8NgAowwEAAAAABgAAAAIAAAAAAwAAAAEAAAAFwFGk + w+RbXsvAQLcBfNfB88BRpMPHao09wEC3BARxfsjAUaTBy3xqtcBAtwPFh14uwFGkwehtPEPAQLcB + Pe2hWcBRpMPkW17LwEC3AXzXwfMAAAAAAwAAAAEAAAAFwFGkw1x2IpzAQLcFWdwUaMBRpMNE+S5V + wEC3CGbWzq7AUaTBSXZrl8BAtwg8DqQIwFGkwWDzX9/AQLcFLxPpwsBRpMNcdiKcwEC3BVncFGgY + TQAAAAADAAAAAQAAAATAUaLCONMXCcBAtSVqSKGrwFGiwfgqSVXAQLUkOKbaJsBRosLOUhXCwEC1 + JRFPuifAUaLCONMXCcBAtSVqSKGrABkcFQAVABUYAAAWnLHqkAcV6gIW/KvHkAcV9hgAJvLfto4H + HBUIGTUIBgQZKARiYm94BHhtaW4VDBbA1gsW7oseFuKGGyby37aOBybetbCOBxwYBIOgjMIYBAYI + jsIWACgEg6CMwhgEBgiOwgAZLBUEFQQVAgAVABUEFQoAABaGtOqQBxWYARbyxMeQBxWOAQAm3OTR + jgccFQgZNQgGBBkoBGJib3gEeG1heBUMFsDWCxak4h0W4N0aJtzk0Y4HJsC8y44HHBgEcKCMwhgE + /QeOwhYAKARwoIzCGAT9B47CABksFQQVBBUCABUAFQQVCgAAFp616pAHFZgBFoDGx5AHFY4BACa2 + /fGOBxwVCBk1CAYEGSgEYmJveAR5bWluFQwWwNYLFvbpJhaKhCEmtv3xjgcmoJrmjgccGASB5ATC + GATySwbCFgAoBIHkBMIYBPJLBsIAGSwVBBUEFQIAFQAVBBUKAAAWtrbqkAcVmAEWjsfHkAcVjgEA + JoSHk48HHBUIGTUIBgQZKARiYm94BHltYXgVDBbA1gsWsvImFqqJISaEh5OPByaqnoePBxwYBG7k + BMIYBOVLBsIWACgEbuQEwhgE5UsGwgAZLBUEFQQVAgAVABUEFQoAABbOt+qQBxWYARacyMeQBxWO + AQAmlKiojwccFQIZJQgEGRgHdmVyc2lvbhUMFsDWCxbQAha8AyaUqKiPBybUp6iPBxwYBAAAAAAY + BAAAAAAWACgEAAAAABgEAAAAAAAZLBUEFQQVAgAVABUEFQoAABbmuOqQBxWEARaqyceQBxWOAQAm + 0KuojwccFQwZJQYEGUgHc291cmNlcwRsaXN0B2VsZW1lbnQIcHJvcGVydHkVDBbA1gsW8AMW3AQm + 0KuojwcmkKuojwccGAAYABYAKAAYAAAZLBUEFQQVAgAVABUEFQoAABbqueqQBxWEARa4yseQBxU+ + ACawsaiPBxwVDBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAdkYXRhc2V0FQwWwNYLFrz0Ahbg + 8gEmsLGojwcm7K+ojwccNgAoDU9wZW5TdHJlZXRNYXAYFUdvb2dsZSBPcGVuIEJ1aWxkaW5ncwAZ + LBUEFQQVAgAVABUEFQoAABbuuuqQBxWOARb2yseQBxWSAwAmzKKqjwccFQwZJQYAGUgHc291cmNl + cwRsaXN0B2VsZW1lbnQJcmVjb3JkX2lkFQwWwNYLFozk0gEWgpBNJsyiqo8HPDYAKAx3OTkzNjc4 + NjIyQDEYDDAwMDE4YTUzNjRhNgAZHBUAFQAVCgAAFvy76pAHFZgBFojOx5AHFa4CACbIxPiPBxwV + DBklBgQZSAdzb3VyY2VzBGxpc3QHZWxlbWVudAt1cGRhdGVfdGltZRUMFsDWCxbsghQWzLEGJsjE + +I8HJs6y948HHDYAKBgyMDI0LTExLTMwVDAzOjU3OjQ5LjAwMFoYGDIwMDAtMDEtMDFUMDA6MDA6 + MDAuMDAwWgAZLBUEFQQVAgAVABUEFQoAABaUveqQBxWUARa20MeQBxWeBAAmuvr+jwccFQoZJQYE + GUgHc291cmNlcwRsaXN0B2VsZW1lbnQKY29uZmlkZW5jZRUMFsDWCxai7w0W8KILJrr6/o8HJprk + /Y8HHBgI8BZIUPwY7z8YCM3MzMzMzOQ/Fqj8BigI8BZIUPwY7z8YCM3MzMzMzOQ/ABksFQQVBBUC + ABUAFQQVCgAAFqi+6pAHFZgBFtTUx5AHFfIBACbSh4mQBxwVAhk1CAYEGRgFbGV2ZWwVDBbA1gsW + 8gQW3gUm0oeJkAcmioeJkAccGAQBAAAAGAT/////FpTWCygEAQAAABgE/////wAZLBUEFQQVAgAV + ABUEFQoAABbAv+qQBxWKARbG1seQBxWSAQAmjo+JkAccFQwZNQgGBBkYB3N1YnR5cGUVDBbA1gsW + oE8WyEImjo+JkAcm6IyJkAccNtbuCigOdHJhbnNwb3J0YXRpb24YDGFncmljdWx0dXJhbAAZLBUE + FQQVAgAVABUEFQoAABbKwOqQBxWOARbY18eQBxWgAgAm/tOJkAccFQwZNQgGBBkYBWNsYXNzFQwW + wNYLFoBhFoRRJv7TiZAHJrDPiZAHHDbO8AooCXdhcmVob3VzZRgKYXBhcnRtZW50cwAZLBUEFQQV + AgAVABUEFQoAABbYweqQBxWOARb42ceQBxXwAQAm2qGKkAccFQoZNQgGBBkYBmhlaWdodBUMFsDW + Cxa8BRbUBSbaoYqQBya0oIqQBxwYCAAAAAAAgFFAGAgAAAAAAAAAQBag1gsoCAAAAAAAgFFAGAgA + AAAAAAAAQAAZLBUEFQQVAgAVABUEFQoAABbmwuqQBxWGARbo28eQBxWyAQAmiKaKkAccFQwZNQgG + ABkoBW5hbWVzB3ByaW1hcnkVDBbA1gsW/pkBFoZfJoimipAHPDaq0AsoDHRlamF6b2xvdW5nZRgW + MTYgQ29taXNhcsOtYSBMYSBSZWluYQAZHBUAFQAVCgAAFuzD6pAHFY4BFprdx5AHFcoDACaOhYuQ + BxwVDBklBgAZSAVuYW1lcwZjb21tb24Ja2V5X3ZhbHVlA2tleRUMFs7WCxbmGhaqEyaOhYuQBzw2 + stYLKAJmchgCYXIAGRwVABUAFQoAABb6xOqQBxWOARbk4MeQBxVqACa4mIuQBxwVDBklBgAZSAVu + YW1lcwZjb21tb24Ja2V5X3ZhbHVlBXZhbHVlFQwWztYLFswiFvQWJriYi5AHPDay1gsoINiz2YHY + p9ix2Kkg2K/ZiNmE2Kkg2YHZhNiz2LfZitmGGBZBbWJhc3NhZGUgZGUgUGFsZXN0aW5lABkcFQAV + ABUKAAAWiMbqkAcVjgEWzuHHkAcVvAIAJqiwi5AHHBUMGSUGBBlYBW5hbWVzBXJ1bGVzBGxpc3QH + ZWxlbWVudAd2YXJpYW50FQwWzNYLFvgeFrQUJqiwi5AHJqyvi5AHHDak1gsoBXNob3J0GAlhbHRl + cm5hdGUAGSwVBBUEFQIAFQAVBBUKAAAWlsfqkAcVjgEWiuTHkAcVsgEAJuDDi5AHHBUMGSUGABlY + BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAhsYW5ndWFnZRUMFszWCxaeHha2Eybgw4uQBzw2xNYL + KAJlcxgCZW4AGRwVABUAFQoAABakyOqQBxWOARa85ceQBxVaACaW14uQBxwVDBklBgAZWAVuYW1l + cwVydWxlcwRsaXN0B2VsZW1lbnQFdmFsdWUVDBbM1gsWticW4BkmlteLkAc8NqTWCygQU3RhcmJ1 + Y2tzIENvZmZlZRgDQVZPABkcFQAVABUKAAAWssnqkAcVjgEWlubHkAcV5gIAJvbwi5AHHBUKGSUG + ABl4BW5hbWVzBXJ1bGVzBGxpc3QHZWxlbWVudAdiZXR3ZWVuBGxpc3QHZWxlbWVudBUMFszWCxb2 + HRaYEyb28IuQBzw2zNYLABkcFQAVABUKAAAWwMrqkAcVjgEW/OjHkAcVUgAmjoSMkAccFQwZJQYA + GVgFbmFtZXMFcnVsZXMEbGlzdAdlbGVtZW50BHNpZGUVDBbM1gsW7h0WlBMmjoSMkAc8NszWCwAZ + HBUAFQAVCgAAFs7L6pAHFY4BFs7px5AHFVIAJqKXjJAHHBUAGTUIBgAZGAloYXNfcGFydHMVDBbA + 1gsWvL0BFqYEJqKXjJAHPBgBARgBABYAKAEBGAEAABkcFQAVABUKAAAW3MzqkAcVhgEWoOrHkAcV + UgAmyJuMkAccFQAZNQgGABkYDmlzX3VuZGVyZ3JvdW5kFQwWwNYLFry9ARb+AybIm4yQBzwYAQAY + AQAWACgBABgBAAAZHBUAFQAVCgAAFuLN6pAHFYQBFvLqx5AHFVIAJtagjJAHHBUCGTUIBgQZGApu + dW1fZmxvb3JzFQwWwNYLFvgjFpQdJtagjJAHJsafjJAHHBgEHAAAABgEAQAAABaqwQsoBBwAAAAY + BAEAAAAAGSwVBBUEFQIAFQAVBBUKAAAW5s7qkAcVigEWxOvHkAcVkgEAJtq8jJAHHBUCGTUIBgAZ + GBZudW1fZmxvb3JzX3VuZGVyZ3JvdW5kFQwWwNYLFsoCFqQDJtq8jJAHPDbA1gsAGRwVABUAFQoA + ABbwz+qQBxWEARbW7MeQBxVSACb+v4yQBxwVChk1CAYAGRgKbWluX2hlaWdodBUMFsDWCxbKAhak + Ayb+v4yQBzw2wNYLABkcFQAVABUKAAAW9NDqkAcVhAEWqO3HkAcVUgAmosOMkAccFQIZNQgGABkY + CW1pbl9mbG9vchUMFsDWCxbKAhakAyaiw4yQBzw2wNYLABkcFQAVABUKAAAW+NHqkAcVhAEW+u3H + kAcVUgAmxsaMkAccFQwZNQgGABkYDGZhY2FkZV9jb2xvchUMFsDWCxaiAxb8AybGxoyQBzw2utYL + KAcjRkZGRkZGGAcjN0IzRjAwABkcFQAVABUKAAAW/NLqkAcVhgEWzO7HkAcVigEAJsLKjJAHHBUM + GTUIBgAZGA9mYWNhZGVfbWF0ZXJpYWwVDBbA1gsWhAMW3gMmwsqMkAc8GAVnbGFzcxgFZ2xhc3MW + vNYLKAVnbGFzcxgFZ2xhc3MAGRwVABUAFQoAABaC1OqQBxWEARbW78eQBxV6ACagzoyQBxwVDBk1 + CAYAGRgNcm9vZl9tYXRlcmlhbBUMFsDWCxbKAhakAyagzoyQBzw2wNYLABkcFQAVABUKAAAWhtXq + kAcVhAEW0PDHkAcVUgAmpNKMkAccFQwZNQgGBBkYCnJvb2Zfc2hhcGUVDBbA1gsWogQWjgUmpNKM + kAcmxNGMkAccNp7WCygGaGlwcGVkGAZnYWJsZWQAGSwVBBUEFQIAFQAVBBUKAAAWitbqkAcViAEW + ovHHkAcVggEAJtLWjJAHHBUKGTUIBgAZGA5yb29mX2RpcmVjdGlvbhUMFsDWCxbKAhakAybS1oyQ + Bzw2wNYLABkcFQAVABUKAAAWktfqkAcVhAEWpPLHkAcVUgAm9tmMkAccFQwZNQgGABkYEHJvb2Zf + b3JpZW50YXRpb24VDBbA1gsWygIWpAMm9tmMkAc8NsDWCwAZHBUAFQAVCgAAFpbY6pAHFYQBFvby + x5AHFVIAJprdjJAHHBUMGTUIBgAZGApyb29mX2NvbG9yFQwWwNYLFsoCFqQDJprdjJAHPDbA1gsA + GRwVABUAFQoAABaa2eqQBxWEARbI88eQBxVSACa+4IyQBxwVChk1CAYAGRgLcm9vZl9oZWlnaHQV + DBbA1gsW9AIWzgMmvuCMkAc8GAjD9Shcj8IVQBgIFK5H4XoUBkAWvNYLKAjD9Shcj8IVQBgIFK5H + 4XoUBkAAGRwVABUAFQoAABae2uqQBxWEARaa9MeQBxVyABbUzLwQFsDWCyaKi6+HBxaC2d0IFH4A + GVwYA2dlbxi5AnsidmVyc2lvbiI6IjEuMS4wIiwicHJpbWFyeV9jb2x1bW4iOiJnZW9tZXRyeSIs + ImNvbHVtbnMiOnsiZ2VvbWV0cnkiOnsiZW5jb2RpbmciOiJXS0IiLCJnZW9tZXRyeV90eXBlcyI6 + WyJQb2x5Z29uIiwiTXVsdGlQb2x5Z29uIl0sImJib3giOlstMTc5Ljk5OTk5NjYsLTgzLjY1MDAx + MzksLTIuODIyOTgyNCwtMC4wMDMxMzc3MTExMDA1NTMxOV0sImNvdmVyaW5nIjp7ImJib3giOnsi + eG1pbiI6WyJiYm94IiwieG1pbiJdLCJ5bWluIjpbImJib3giLCJ5bWluIl0sInhtYXgiOlsiYmJv + eCIsInhtYXgiXSwieW1heCI6WyJiYm94IiwieW1heCJdfX19fX0AGBxvcmcuYXBhY2hlLnNwYXJr + LmxlZ2FjeUlOVDk2GAAAGBhvcmcuYXBhY2hlLnNwYXJrLnZlcnNpb24YBTMuNC4xABgpb3JnLmFw + YWNoZS5zcGFyay5zcWwucGFycXVldC5yb3cubWV0YWRhdGEY8Bd7InR5cGUiOiJzdHJ1Y3QiLCJm + aWVsZHMiOlt7Im5hbWUiOiJpZCIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0 + YWRhdGEiOnt9fSx7Im5hbWUiOiJnZW9tZXRyeSIsInR5cGUiOiJiaW5hcnkiLCJudWxsYWJsZSI6 + dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJiYm94IiwidHlwZSI6eyJ0eXBlIjoic3RydWN0 + IiwiZmllbGRzIjpbeyJuYW1lIjoieG1pbiIsInR5cGUiOiJmbG9hdCIsIm51bGxhYmxlIjp0cnVl + LCJtZXRhZGF0YSI6e319LHsibmFtZSI6InhtYXgiLCJ0eXBlIjoiZmxvYXQiLCJudWxsYWJsZSI6 + dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJ5bWluIiwidHlwZSI6ImZsb2F0IiwibnVsbGFi + bGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoieW1heCIsInR5cGUiOiJmbG9hdCIsIm51 + bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319XX0sIm51bGxhYmxlIjpmYWxzZSwibWV0YWRhdGEi + Ont9fSx7Im5hbWUiOiJ2ZXJzaW9uIiwidHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6ZmFsc2Us + Im1ldGFkYXRhIjp7fX0seyJuYW1lIjoic291cmNlcyIsInR5cGUiOnsidHlwZSI6ImFycmF5Iiwi + ZWxlbWVudFR5cGUiOnsidHlwZSI6InN0cnVjdCIsImZpZWxkcyI6W3sibmFtZSI6InByb3BlcnR5 + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + ImRhdGFzZXQiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0s + eyJuYW1lIjoicmVjb3JkX2lkIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRh + ZGF0YSI6e319LHsibmFtZSI6InVwZGF0ZV90aW1lIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxl + Ijp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6ImNvbmZpZGVuY2UiLCJ0eXBlIjoiZG91Ymxl + IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX1dfSwiY29udGFpbnNOdWxsIjp0cnVlfSwi + bnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoibGV2ZWwiLCJ0eXBlIjoiaW50 + ZWdlciIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6InN1YnR5cGUiLCJ0 + eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiY2xh + c3MiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1l + IjoiaGVpZ2h0IiwidHlwZSI6ImRvdWJsZSIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319 + LHsibmFtZSI6Im5hbWVzIiwidHlwZSI6eyJ0eXBlIjoic3RydWN0IiwiZmllbGRzIjpbeyJuYW1l + IjoicHJpbWFyeSIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9 + fSx7Im5hbWUiOiJjb21tb24iLCJ0eXBlIjp7InR5cGUiOiJtYXAiLCJrZXlUeXBlIjoic3RyaW5n + IiwidmFsdWVUeXBlIjoic3RyaW5nIiwidmFsdWVDb250YWluc051bGwiOnRydWV9LCJudWxsYWJs + ZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJydWxlcyIsInR5cGUiOnsidHlwZSI6ImFy + cmF5IiwiZWxlbWVudFR5cGUiOnsidHlwZSI6InN0cnVjdCIsImZpZWxkcyI6W3sibmFtZSI6InZh + cmlhbnQiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJu + YW1lIjoibGFuZ3VhZ2UiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRh + Ijp7fX0seyJuYW1lIjoidmFsdWUiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1l + dGFkYXRhIjp7fX0seyJuYW1lIjoiYmV0d2VlbiIsInR5cGUiOnsidHlwZSI6ImFycmF5IiwiZWxl + bWVudFR5cGUiOiJkb3VibGUiLCJjb250YWluc051bGwiOnRydWV9LCJudWxsYWJsZSI6dHJ1ZSwi + bWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJzaWRlIiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319XX0sImNvbnRhaW5zTnVsbCI6dHJ1ZX0sIm51bGxhYmxlIjp0cnVl + LCJtZXRhZGF0YSI6e319XX0sIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + Imhhc19wYXJ0cyIsInR5cGUiOiJib29sZWFuIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7 + fX0seyJuYW1lIjoiaXNfdW5kZXJncm91bmQiLCJ0eXBlIjoiYm9vbGVhbiIsIm51bGxhYmxlIjp0 + cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Im51bV9mbG9vcnMiLCJ0eXBlIjoiaW50ZWdlciIs + Im51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6Im51bV9mbG9vcnNfdW5kZXJn + cm91bmQiLCJ0eXBlIjoiaW50ZWdlciIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsi + bmFtZSI6Im1pbl9oZWlnaHQiLCJ0eXBlIjoiZG91YmxlIiwibnVsbGFibGUiOnRydWUsIm1ldGFk + YXRhIjp7fX0seyJuYW1lIjoibWluX2Zsb29yIiwidHlwZSI6ImludGVnZXIiLCJudWxsYWJsZSI6 + dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJmYWNhZGVfY29sb3IiLCJ0eXBlIjoic3RyaW5n + IiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7fX0seyJuYW1lIjoiZmFjYWRlX21hdGVyaWFs + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + InJvb2ZfbWF0ZXJpYWwiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRh + Ijp7fX0seyJuYW1lIjoicm9vZl9zaGFwZSIsInR5cGUiOiJzdHJpbmciLCJudWxsYWJsZSI6dHJ1 + ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJyb29mX2RpcmVjdGlvbiIsInR5cGUiOiJkb3VibGUi + LCJudWxsYWJsZSI6dHJ1ZSwibWV0YWRhdGEiOnt9fSx7Im5hbWUiOiJyb29mX29yaWVudGF0aW9u + IiwidHlwZSI6InN0cmluZyIsIm51bGxhYmxlIjp0cnVlLCJtZXRhZGF0YSI6e319LHsibmFtZSI6 + InJvb2ZfY29sb3IiLCJ0eXBlIjoic3RyaW5nIiwibnVsbGFibGUiOnRydWUsIm1ldGFkYXRhIjp7 + fX0seyJuYW1lIjoicm9vZl9oZWlnaHQiLCJ0eXBlIjoiZG91YmxlIiwibnVsbGFibGUiOnRydWUs + Im1ldGFkYXRhIjp7fX1dfQAYH29yZy5hcGFjaGUuc3BhcmsubGVnYWN5RGF0ZVRpbWUYAAAYWnBh + cnF1ZXQtbXIgdmVyc2lvbiAxLjEyLjMtZGF0YWJyaWNrcy0wMDAyIChidWlsZCAyNDg0YTk1ZGJl + MTZhMDAyM2UzZWIyOWMyMDFmOTlmZjllYTc3MWVlKRn8JhwAABwAABwAABwAABwAABwAABwAABwA + ABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwA + ABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAABwAAAAO+QQAUEFSMQ== + headers: + Accept-Ranges: + - bytes + Content-Length: + - '65536' + Content-Range: + - bytes 957435879-957501414/957501415 + Content-Type: + - application/octet-stream + Date: + - Mon, 23 Dec 2024 17:28:52 GMT + Etag: + - '"1a1396245ec4c12e540285e78c525214-183"' + Last-Modified: + - Wed, 18 Dec 2024 18:26:35 GMT + Server: + - AmazonS3 + x-amz-id-2: + - 6OT2VmyYcJz9I4G4dP7qjsoOsN1djZhMBZ/zRtlQR93j7FAnUcba+uqncMZiUMnb/I/3zLNH+jo= + x-amz-meta-mtime: + - '1734455862' + x-amz-request-id: + - G5J40DH87R2FFWKV + x-amz-server-side-encryption: + - AES256 + x-amz-storage-class: + - INTELLIGENT_TIERING + status: + code: 206 + message: Partial Content +version: 1 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..a1ace31 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,2 @@ +import pytest + diff --git a/tests/data/asset.tif b/tests/data/asset.tif deleted file mode 100644 index 54c83c7596c8957b1d29d50e935317e24f116eeb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 799760 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

\n", + " \n", + "
    \n", + " \n", " \n", " \n", - " \n", "
  • \n", - " geometry\n", + " 2\n", "
      \n", " \n", " \n", " \n", - "
    • \n", - " type\n", - " \"Polygon\"\n", + "
    • \n", + " rel\n", + " \"item\"\n", "
      • \n", " \n", " \n", " \n", " \n", - "
    • \n", - " \n", - " coordinates\n", - " [] 1 items\n", - " \n", - " \n", - "
        \n", - " \n", - " \n", - "
      • \n", - " \n", - " 0\n", - " [] 5 items\n", - " \n", - " \n", - "
          \n", - " \n", - " \n", - "
        • \n", - " \n", - " 0\n", - " [] 2 items\n", - " \n", - " \n", - "
            \n", - " \n", - " \n", " \n", - "
          • \n", - " 0\n", - " -52.916275\n", + "
          • \n", + " href\n", + " \"./addresses-address-2024-12-18.0-part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000/addresses-address-2024-12-18.0-part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000.json\"\n", "
            • \n", " \n", " \n", " \n", - "
          \n", - " \n", - "
            \n", - " \n", " \n", " \n", - "
          • \n", - " 1\n", - " 72.229798\n", + "
          • \n", + " type\n", + " \"application/json\"\n", "
            • \n", " \n", " \n", " \n", "
          \n", - " \n", - "
          • \n", + "
        • \n", + " \n", " \n", " \n", "
      \n", @@ -713,39 +741,41 @@ "
        \n", " \n", " \n", - "
      • \n", - " \n", - " 1\n", - " [] 2 items\n", - " \n", - " \n", + " \n", + "
      • \n", + " 3\n", "
          \n", " \n", " \n", " \n", - "
        • \n", - " 0\n", - " -52.301599\n", + "
        • \n", + " rel\n", + " \"self\"\n", "
          • \n", " \n", " \n", " \n", - "
        \n", - " \n", - "
          \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"/home/henry/workspace/stactools-packages/overture-maps/examples/overture-maps-addresses/collection.json\"\n", + "
          • \n", + " \n", + " \n", " \n", " \n", " \n", - "
        • \n", - " 1\n", - " 74.613784\n", + "
        • \n", + " type\n", + " \"application/json\"\n", "
          • \n", " \n", " \n", " \n", "
        \n", - " \n", - "
        • \n", + "
        • \n", + " \n", " \n", " \n", "
      \n", @@ -753,112 +783,136 @@ "
        \n", " \n", " \n", - "
      • \n", - " \n", - " 2\n", - " [] 2 items\n", - " \n", - " \n", + " \n", + "
      • \n", + " 4\n", "
          \n", " \n", " \n", " \n", - "
        • \n", - " 0\n", - " -61.287624\n", + "
        • \n", + " rel\n", + " \"parent\"\n", "
          • \n", " \n", " \n", " \n", - "
        \n", + " \n", + " \n", + "
      • \n", + " href\n", + " \"/home/henry/workspace/stactools-packages/overture-maps/examples/catalog.json\"\n", + "
        • \n", + " \n", + " \n", " \n", - "
          \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/json\"\n", + "
          • \n", + " \n", + " \n", " \n", " \n", " \n", - "
        • \n", - " 1\n", - " 74.622043\n", + "
        • \n", + " title\n", + " \"Overture Maps\"\n", "
          • \n", " \n", " \n", " \n", "
        \n", - " \n", - "
        • \n", + "
        • \n", + " \n", " \n", " \n", "
      \n", " \n", - "
        \n", - " \n", + "
      • \n", + " \n", " \n", - "
    • \n", - " \n", - " 3\n", - " [] 2 items\n", - " \n", + " \n", + "
    • \n", + " stac_extensions[] 1 items\n", " \n", "
        \n", " \n", " \n", " \n", - "
      • \n", - " 0\n", - " -60.726346\n", + "
      • \n", + " 0\n", + " \"https://stac-extensions.github.io/item-assets/v1.0.0/schema.json\"\n", "
        • \n", " \n", " \n", " \n", "
      \n", " \n", - "
        \n", - " \n", + "
      • \n", + " \n", " \n", " \n", - "
    • \n", - " 1\n", - " 72.236891\n", + " \n", + "
    • \n", + " overture:theme\n", + " \"addresses\"\n", "
      • \n", " \n", + " \n", " \n", + " \n", + " \n", + "
    • \n", + " item_assets\n", + "
        \n", " \n", - "
      \n", - " \n", - "
      • \n", " \n", - " \n", - "
    \n", - " \n", + " \n", + "
  • \n", + " data\n", "
      \n", " \n", " \n", - "
    • \n", - " \n", - " 4\n", - " [] 2 items\n", - " \n", + " \n", + "
    • \n", + " title\n", + " \"Geoparquet partition\"\n", + "
      • \n", + " \n", + " \n", " \n", - "
        \n", + " \n", + " \n", + "
      • \n", + " description\n", + " \"Geoparquet partition\"\n", + "
        • \n", + " \n", + " \n", " \n", " \n", " \n", - "
      • \n", - " 0\n", - " -52.916275\n", + "
      • \n", + " type\n", + " \"application/x-parquet\"\n", "
        • \n", " \n", " \n", " \n", - "
      \n", + " \n", + "
    • \n", + " roles[] 1 items\n", " \n", "
        \n", " \n", " \n", " \n", - "
      • \n", - " 1\n", - " 72.229798\n", + "
      • \n", + " 0\n", + " \"data\"\n", "
        • \n", " \n", " \n", @@ -869,13 +923,8 @@ " \n", " \n", "
      \n", - " \n", - "
      • \n", - " \n", - " \n", - "
    \n", - " \n", - "
    • \n", + "
    • \n", + " \n", " \n", " \n", "
\n", @@ -884,105 +933,85 @@ " \n", " \n", " \n", - "
  • \n", - " \n", - " links\n", - " [] 4 items\n", - " \n", - " \n", + " \n", + "
  • \n", + " extent\n", "
      \n", " \n", " \n", " \n", "
    • \n", - " 0\n", + " spatial\n", "
        \n", " \n", " \n", - " \n", - "
      • \n", - " rel\n", - " \"root\"\n", - "
        • \n", - " \n", - " \n", + "
      • \n", + " bbox[] 1 items\n", " \n", - " \n", - " \n", - "
      • \n", - " href\n", - " \"/Users/gadomski/Code/stactools-packages/template/examples/collection.json\"\n", - "
        • \n", - " \n", - " \n", + "
          \n", " \n", " \n", - " \n", - "
        • \n", - " type\n", - " \"application/json\"\n", - "
          • \n", - " \n", - " \n", + "
        • \n", + " 0[] 4 items\n", + " \n", + "
            \n", " \n", " \n", " \n", - "
          • \n", - " title\n", - " \"Example collection\"\n", + "
          • \n", + " 0\n", + " -176.874527\n", "
            • \n", " \n", " \n", " \n", "
          \n", - "
          • \n", - " \n", - " \n", - " \n", - "
        \n", - " \n", - "
          \n", " \n", - " \n", - " \n", - "
        • \n", - " 1\n", "
            \n", " \n", " \n", " \n", - "
          • \n", - " rel\n", - " \"collection\"\n", + "
          • \n", + " 1\n", + " -53.234018\n", "
            • \n", " \n", " \n", " \n", + "
          \n", + " \n", + "
            \n", + " \n", " \n", " \n", - "
          • \n", - " href\n", - " \"../collection.json\"\n", + "
          • \n", + " 2\n", + " -45.000027\n", "
            • \n", " \n", " \n", " \n", + "
          \n", + " \n", + "
            \n", + " \n", " \n", " \n", - "
          • \n", - " type\n", - " \"application/json\"\n", + "
          • \n", + " 3\n", + " -17.522077\n", "
            • \n", " \n", " \n", " \n", + "
          \n", + " \n", + "
          • \n", " \n", - " \n", - "
        • \n", - " title\n", - " \"Example collection\"\n", - "
          • \n", - " \n", + " \n", + "
        \n", + " \n", + "
        • \n", " \n", " \n", "
      \n", @@ -990,96 +1019,126 @@ " \n", " \n", " \n", - "
    \n", - " \n", - "
      \n", - " \n", " \n", " \n", "
    • \n", - " 2\n", + " temporal\n", "
        \n", " \n", " \n", - " \n", - "
      • \n", - " rel\n", - " \"self\"\n", - "
        • \n", - " \n", + "
      • \n", + " interval[] 1 items\n", + " \n", + "
          \n", + " \n", " \n", + "
        • \n", + " 0[] 2 items\n", + " \n", + "
            \n", " \n", " \n", " \n", - "
          • \n", - " href\n", - " \"/Users/gadomski/Code/stactools-packages/template/examples/example-item/example-item.json\"\n", + "
          • \n", + " 0\n", + " \"2024-01-18T00:12:00Z\"\n", "
            • \n", " \n", " \n", " \n", + "
          \n", + " \n", + "
            \n", + " \n", " \n", " \n", - "
          • \n", - " type\n", - " \"application/json\"\n", + "
          • \n", + " 1\n", + " \"2024-01-18T00:12:00Z\"\n", "
            • \n", " \n", " \n", " \n", "
          \n", - "
          • \n", - " \n", + " \n", + "
        • \n", " \n", " \n", "
      \n", " \n", - "
        \n", + "
      • \n", + " \n", " \n", + "
    \n", + "
    • \n", + " \n", " \n", - " \n", - "
  • \n", - " 3\n", - "
      \n", " \n", + "
    \n", + "
    • \n", + " \n", + " \n", " \n", " \n", - "
  • \n", - " rel\n", - " \"parent\"\n", + " \n", + "
  • \n", + " license\n", + " \"various\"\n", "
    • \n", " \n", + " \n", " \n", + " \n", + "
  • \n", + " keywords[] 4 items\n", + " \n", + "
      \n", " \n", " \n", " \n", - "
    • \n", - " href\n", - " \"/Users/gadomski/Code/stactools-packages/template/examples/collection.json\"\n", + "
    • \n", + " 0\n", + " \"overture\"\n", "
      • \n", " \n", " \n", " \n", + "
    \n", + " \n", + "
      \n", + " \n", " \n", " \n", - "
    • \n", - " type\n", - " \"application/json\"\n", + "
    • \n", + " 1\n", + " \"geoparquet\"\n", "
      • \n", " \n", " \n", " \n", + "
    \n", + " \n", + "
      \n", + " \n", " \n", " \n", - "
    • \n", - " title\n", - " \"Example collection\"\n", + "
    • \n", + " 2\n", + " \"address\"\n", "
      • \n", " \n", " \n", " \n", "
    \n", - "
    • \n", + " \n", + "
      \n", + " \n", + " \n", + " \n", + "
    • \n", + " 3\n", + " \"addresses\"\n", + "
      • \n", " \n", " \n", " \n", @@ -1089,40 +1148,37 @@ " \n", " \n", " \n", - " \n", - "
    • \n", - " assets\n", + "
    • \n", + " providers[] 2 items\n", + " \n", "
        \n", " \n", " \n", " \n", "
      • \n", - " data\n", + " 0\n", "
          \n", " \n", " \n", " \n", - "
        • \n", - " href\n", - " \"../../tests/data/asset.tif\"\n", + "
        • \n", + " name\n", + " \"Overture Maps Foundation\"\n", "
          • \n", " \n", " \n", " \n", " \n", "
        • \n", - " \n", - " roles\n", - " [] 1 items\n", - " \n", + " roles[] 1 items\n", " \n", "
            \n", " \n", " \n", " \n", - "
          • \n", - " 0\n", - " \"data\"\n", + "
          • \n", + " 0\n", + " \"producer\"\n", "
            • \n", " \n", " \n", @@ -1132,32 +1188,18 @@ "
          • \n", " \n", " \n", - "
        \n", - "
        • \n", + " \n", + " \n", + "
      • \n", + " url\n", + " \"https://overturemaps.org/\"\n", + "
        • \n", " \n", " \n", " \n", "
      \n", "
      • \n", " \n", - " \n", - " \n", - " \n", - "
    • \n", - " \n", - " bbox\n", - " [] 4 items\n", - " \n", - " \n", - "
        \n", - " \n", - " \n", - " \n", - "
      • \n", - " 0\n", - " -61.287624\n", - "
        • \n", - " \n", " \n", " \n", "
      \n", @@ -1166,35 +1208,30 @@ " \n", " \n", " \n", - "
    • \n", - " 1\n", - " 72.229798\n", - "
      • \n", - " \n", - " \n", - " \n", - "
    \n", - " \n", + "
  • \n", + " 1\n", "
      \n", " \n", " \n", " \n", - "
    • \n", - " 2\n", - " -52.301599\n", + "
    • \n", + " name\n", + " \"Microsoft\"\n", "
      • \n", " \n", " \n", " \n", - "
    \n", + " \n", + "
  • \n", + " roles[] 1 items\n", " \n", "
      \n", " \n", " \n", " \n", - "
    • \n", - " 3\n", - " 74.622043\n", + "
    • \n", + " 0\n", + " \"host\"\n", "
      • \n", " \n", " \n", @@ -1202,90 +1239,38 @@ "
    \n", " \n", "
    • \n", - " \n", " \n", - " \n", - "
  • \n", - " \n", - " stac_extensions\n", - " [] 1 items\n", - " \n", - " \n", - "
      \n", " \n", " \n", " \n", - "
    • \n", - " 0\n", - " \"https://stac-extensions.github.io/projection/v1.1.0/schema.json\"\n", + "
    • \n", + " url\n", + " \"https://microsoft.com\"\n", "
      • \n", " \n", " \n", " \n", "
    \n", + "
    • \n", + " \n", + " \n", + " \n", + " \n", " \n", "
    • \n", " \n", " \n", - " \n", - " \n", - "
  • \n", - " collection\n", - " \"example-collection\"\n", - "
    • \n", - " \n", - " \n", - " \n", " \n", " \n", "" ], "text/plain": [ - "" + "" ] }, "metadata": {}, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is the custom attribute: foo\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "\n", - "from IPython.display import display\n", - "from pystac import Collection\n", - "\n", - "import stactools.overture_maps.stac\n", - "\n", - "root = Path().cwd().parent\n", - "collection = Collection.from_file(str(root / \"examples\" / \"collection.json\"))\n", - "display(collection)\n", - "item = next(collection.get_items())\n", - "display(item)\n", - "print(f\"This is the custom attribute: {item.properties['custom_attribute']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating items and collections\n", - "\n", - "Items can be created from an href to a single tif file.\n", - "Items are added to collections using the standard pystac interface." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ { "data": { "text/html": [ @@ -1294,16 +1279,32 @@ "\n", "
    \n", "
    \n", @@ -1311,78 +1312,1352 @@ " \n", " \n", " \n", - "
  • \n", - " type\n", - " \"Collection\"\n", + "
  • \n", + " type\n", + " \"Feature\"\n", "
    • \n", " \n", " \n", " \n", " \n", " \n", - "
  • \n", - " id\n", - " \"example-collection\"\n", + "
  • \n", + " stac_version\n", + " \"1.0.0\"\n", "
    • \n", " \n", " \n", " \n", " \n", - " \n", - "
  • \n", - " stac_version\n", - " \"1.0.0\"\n", - "
    • \n", - " \n", - " \n", + "
  • \n", + " stac_extensions[] 2 items\n", + " \n", + "
      \n", + " \n", " \n", " \n", - " \n", - "
    • \n", - " description\n", - " \"An example collection\"\n", + "
    • \n", + " 0\n", + " \"https://stac-extensions.github.io/version/v1.2.0/schema.json\"\n", "
      • \n", " \n", - " \n", " \n", - " \n", - "
    • \n", - " \n", - " links\n", - " [] 1 items\n", - " \n", " \n", - "
        \n", + "
      \n", " \n", - " \n", - " \n", - "
    • \n", - " 0\n", "
        \n", " \n", " \n", " \n", - "
      • \n", - " rel\n", - " \"item\"\n", + "
      • \n", + " 1\n", + " \"https://stac-extensions.github.io/table/v1.2.0/schema.json\"\n", "
        • \n", " \n", " \n", " \n", - " \n", + "
      \n", + " \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " id\n", + " \"addresses-address-2024-12-18.0-part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000\"\n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " geometry\n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " type\n", + " \"Polygon\"\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " coordinates[] 1 items\n", + " \n", + "
          \n", + " \n", + " \n", + "
        • \n", + " 0[] 5 items\n", + " \n", + "
            \n", + " \n", + " \n", + "
          • \n", + " 0[] 2 items\n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 0\n", + " -176.874527\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 1\n", + " -53.234018\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
            • \n", + " \n", + " \n", + "
          \n", + " \n", + "
            \n", + " \n", + " \n", + "
          • \n", + " 1[] 2 items\n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 0\n", + " -45.000027\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 1\n", + " -53.234018\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
            • \n", + " \n", + " \n", + "
          \n", + " \n", + "
            \n", + " \n", + " \n", + "
          • \n", + " 2[] 2 items\n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 0\n", + " -45.000027\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 1\n", + " -17.522077\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
            • \n", + " \n", + " \n", + "
          \n", + " \n", + "
            \n", + " \n", + " \n", + "
          • \n", + " 3[] 2 items\n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 0\n", + " -176.874527\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 1\n", + " -17.522077\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
            • \n", + " \n", + " \n", + "
          \n", + " \n", + "
            \n", + " \n", + " \n", + "
          • \n", + " 4[] 2 items\n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 0\n", + " -176.874527\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " 1\n", + " -53.234018\n", + "
              • \n", + " \n", + " \n", + " \n", + "
            \n", + " \n", + "
            • \n", + " \n", + " \n", + "
          \n", + " \n", + "
          • \n", + " \n", + " \n", + "
        \n", + " \n", + "
        • \n", + " \n", + " \n", + "
      \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " bbox[] 4 items\n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 0\n", + " -176.874527\n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 1\n", + " -53.234018\n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 2\n", + " -45.000027\n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 3\n", + " -17.522077\n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " properties\n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " overture:theme\n", + " \"addresses\"\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " overture:type\n", + " \"address\"\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " version\n", + " \"2024-12-18.0\"\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " table:row_count\n", + " 30847112\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " table:columns[] 12 items\n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 0\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"id\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 1\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"geometry\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"binary\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 2\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"bbox\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"struct\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 3\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"country\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 4\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"postcode\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 5\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"street\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 6\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"number\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 7\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"unit\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 8\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"address_levels\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"array\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 9\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"postal_city\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"string\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 10\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"version\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"integer\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " 11\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " name\n", + " \"sources\"\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " col_type\n", + " \"array\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + " \n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " table:primary_geometry\n", + " \"Point\"\n", + "
        • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
      • \n", + " datetime\n", + " \"2024-01-18T00:12:00Z\"\n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " links[] 4 items\n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 0\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"root\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"/home/henry/workspace/stactools-packages/overture-maps/examples/catalog.json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " title\n", + " \"Overture Maps\"\n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 1\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"collection\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"../collection.json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 2\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"self\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"/home/henry/workspace/stactools-packages/overture-maps/examples/overture-maps-addresses/addresses-address-2024-12-18.0-part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000/addresses-address-2024-12-18.0-part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000.json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 3\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"parent\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"/home/henry/workspace/stactools-packages/overture-maps/examples/overture-maps-addresses/collection.json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/json\"\n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " assets\n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " data\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=addresses/type=address/part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000.zstd.parquet\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"application/x-parquet\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " table:storage_options\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " anon\n", + " True\n", + "
            • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
          • \n", + " account_name\n", + " \"overturemapswestus2\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " roles[] 1 items\n", + " \n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " 0\n", + " \"data\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + " \n", + "
          • \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " collection\n", + " \"overture-maps-addresses\"\n", + "
      • \n", + " \n", + " \n", + " \n", + "
    \n", + "
    • \n", + "
    " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "This is the release: 2024-12-18.0\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "from IPython.display import display\n", + "from pystac import Catalog\n", + "\n", + "import stactools.overture_maps.stac\n", + "from stactools.overture_maps.metadata import StorageBackend, Theme\n", + "\n", + "root = Path().cwd().parent\n", + "catalog = Catalog.from_file(str(root / \"examples\" / \"catalog.json\"))\n", + "display(catalog)\n", + "collection = next(catalog.get_children())\n", + "display(collection)\n", + "item = next(collection.get_items())\n", + "display(item)\n", + "print(f\"This is the release: {item.properties['version']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Creating items and collections\n", + "\n", + "Items can be created from an href to a single tif file.\n", + "Items are added to collections using the standard pystac interface." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
    \n", + "
    \n", + "
      \n", + " \n", + " \n", + " \n", + "
    • \n", + " type\n", + " \"Collection\"\n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " id\n", + " \"overture-maps-addresses\"\n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " stac_version\n", + " \"1.0.0\"\n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " description\n", + " \"## Overture Maps - addresses\n", + "\n", + "This collection contains items for the addresses theme.\n", + "\n", + "_Note: This theme is currently in Alpha and we anticipate significant changes over the next several releases. We invite the Overture community to test the addresses schema and data and offer feedback via the [data](https://github.com/OvertureMaps/data/issues) and [schema](https://github.com/OvertureMaps/schema/issues) repos._\n", + "\n", + "Overture maintains nearly 394 million address point entities. Data in the address theme is derived from over 60 sources, many distributed by [OpenAddresses](https://openaddresses.io/) and [AddressForAll](https://www.addressforall.org/en/), but also includes open data from the [City of New York](https://data.cityofnewyork.us/City-Government/NYC-Address-Points/g6pj-hd8k) and the [U.S. Department of Transportation](https://www.transportation.gov/gis/national-address-database).\n", + "\n", + "For licensing information, please see the [Attribution and Licensing page](https://docs.overturemaps.org/attribution/).\n", + "\n", + "Address data can be used for a variety of purposes, which can include:\n", + "\n", + "- **Mapping**: Addresses may be displayed on the map for reference purposes.\n", + "- **Geocoding**: Addresses are a primary component of high-accuracy geocoding services (i.e. converting text for an address to a complete address with a location).\n", + "- **Conflation**: Addresses can be used to conflate to other data themes (e.g. places, buildings) where appropriate for mapping or other use cases (e.g. refining search).\n", + "- **Standardization**: Parsing an input address into address components based on an existing schema or address model.\n", + "- **Normalization**: Adhering to standard and consistent forms of address components.\n", + "- **Validation and Verification**: Confirming an address exists within a known list of addresses.\n", + "\n", + "See the official [guide](https://docs.overturemaps.org/guides/addresses/) for tips on querying and analyzing this dataset.\n", + "\n", + "## Data assets\n", + "\n", + "The features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n", + "\n", + "1. Theme\n", + "2. Type\n", + "\n", + "Each `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n", + "\n", + "Note that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n", + "\n", + "## STAC metadata\n", + "\n", + "The `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n", + "\n", + "## About Overture Maps\n", + "\n", + "Overture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n", + "\n", + "For more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n", + "\n", + "\"\n", + "
      • \n", + " \n", + " \n", + " \n", + " \n", + "
    • \n", + " links[] 2 items\n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 0\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"license\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " href\n", + " \"https://docs.overturemaps.org/attribution/#addresses\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " type\n", + " \"text/html\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
        • \n", + " title\n", + " \"various\"\n", + "
          • \n", + " \n", + " \n", + " \n", + "
        \n", + "
        • \n", + " \n", + " \n", + " \n", + "
      \n", + " \n", + "
        \n", + " \n", + " \n", + " \n", + "
      • \n", + " 1\n", + "
          \n", + " \n", + " \n", + " \n", + "
        • \n", + " rel\n", + " \"item\"\n", + "
          • \n", + " \n", + " \n", + " \n", + " \n", " \n", - "
        • \n", - " href\n", - " None\n", + "
        • \n", + " href\n", + " None\n", "
          • \n", " \n", " \n", " \n", " \n", " \n", - "
        • \n", - " type\n", - " \"application/json\"\n", + "
        • \n", + " type\n", + " \"application/json\"\n", "
          • \n", " \n", " \n", @@ -1398,58 +2673,132 @@ " \n", " \n", " \n", + "
        • \n", + " stac_extensions[] 1 items\n", + " \n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " 0\n", + " \"https://stac-extensions.github.io/item-assets/v1.0.0/schema.json\"\n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + " \n", + "
          • \n", + " \n", + " \n", + " \n", " \n", - "
        • \n", - " custom_attribute\n", - " \"foo\"\n", + "
        • \n", + " overture:theme\n", + " \"Theme.ADDRESSES\"\n", "
          • \n", " \n", " \n", " \n", " \n", " \n", - "
        • \n", - " title\n", - " \"Example collection\"\n", + "
        • \n", + " item_assets\n", + "
            \n", + " \n", + " \n", + " \n", + "
          • \n", + " data\n", + "
              \n", + " \n", + " \n", + " \n", + "
            • \n", + " title\n", + " \"Geoparquet partition\"\n", + "
              • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
            • \n", + " description\n", + " \"Geoparquet partition\"\n", + "
              • \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
            • \n", + " type\n", + " \"application/x-parquet\"\n", + "
              • \n", + " \n", + " \n", + " \n", + " \n", + "
            • \n", + " roles[] 1 items\n", + " \n", + "
                \n", + " \n", + " \n", + " \n", + "
              • \n", + " 0\n", + " \"data\"\n", "
                • \n", " \n", + " \n", + " \n", + "
              \n", + " \n", + "
              • \n", + " \n", + " \n", + "
            \n", + "
            • \n", + " \n", + " \n", + " \n", + "
          \n", + "
          • \n", + " \n", " \n", " \n", " \n", " \n", "
        • \n", - " extent\n", + " extent\n", "
            \n", " \n", " \n", " \n", "
          • \n", - " spatial\n", + " spatial\n", "
              \n", " \n", " \n", "
            • \n", - " \n", - " bbox\n", - " [] 1 items\n", - " \n", + " bbox[] 1 items\n", " \n", "
                \n", " \n", " \n", "
              • \n", - " \n", - " 0\n", - " [] 4 items\n", - " \n", + " 0[] 4 items\n", " \n", "
                  \n", " \n", " \n", " \n", - "
                • \n", - " 0\n", - " -180.0\n", + "
                • \n", + " 0\n", + " -180.0\n", "
                  • \n", " \n", " \n", @@ -1460,9 +2809,9 @@ " \n", " \n", " \n", - "
                • \n", - " 1\n", - " 90.0\n", + "
                • \n", + " 1\n", + " 90.0\n", "
                  • \n", " \n", " \n", @@ -1473,9 +2822,9 @@ " \n", " \n", " \n", - "
                • \n", - " 2\n", - " 180.0\n", + "
                • \n", + " 2\n", + " 180.0\n", "
                  • \n", " \n", " \n", @@ -1486,9 +2835,9 @@ " \n", " \n", " \n", - "
                • \n", - " 3\n", - " -90.0\n", + "
                • \n", + " 3\n", + " -90.0\n", "
                  • \n", " \n", " \n", @@ -1511,32 +2860,26 @@ " \n", " \n", "
                • \n", - " temporal\n", + " temporal\n", "
                    \n", " \n", " \n", "
                  • \n", - " \n", - " interval\n", - " [] 1 items\n", - " \n", + " interval[] 1 items\n", " \n", "
                      \n", " \n", " \n", "
                    • \n", - " \n", - " 0\n", - " [] 2 items\n", - " \n", + " 0[] 2 items\n", " \n", "
                        \n", " \n", " \n", " \n", - "
                      • \n", - " 0\n", - " \"2023-09-18T21:35:51.039996Z\"\n", + "
                      • \n", + " 0\n", + " \"2023-07-26T00:00:00Z\"\n", "
                        • \n", " \n", " \n", @@ -1547,9 +2890,9 @@ " \n", " \n", " \n", - "
                      • \n", - " 1\n", - " None\n", + "
                      • \n", + " 1\n", + " \"2024-01-18T00:12:00Z\"\n", "
                        • \n", " \n", " \n", @@ -1576,11 +2919,183 @@ " \n", " \n", " \n", - "
                      • \n", - " license\n", - " \"proprietary\"\n", + "
                      • \n", + " license\n", + " \"various\"\n", + "
                        • \n", + " \n", + " \n", + " \n", + " \n", + "
                      • \n", + " keywords[] 4 items\n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 0\n", + " \"overture\"\n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 1\n", + " \"geoparquet\"\n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 2\n", + " \"address\"\n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 3\n", + " \"addresses\"\n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                        • \n", + " \n", + " \n", + " \n", + "
                      • \n", + " providers[] 2 items\n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 0\n", + "
                            \n", + " \n", + " \n", + " \n", + "
                          • \n", + " name\n", + " \"Overture Maps Foundation\"\n", + "
                            • \n", + " \n", + " \n", + " \n", + " \n", + "
                          • \n", + " roles[] 1 items\n", + " \n", + "
                              \n", + " \n", + " \n", + " \n", + "
                            • \n", + " 0\n", + " \"producer\"\n", + "
                              • \n", + " \n", + " \n", + " \n", + "
                            \n", + " \n", + "
                            • \n", + " \n", + " \n", + " \n", + " \n", + "
                          • \n", + " url\n", + " \"https://overturemaps.org/\"\n", + "
                            • \n", + " \n", + " \n", + " \n", + "
                          \n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                          \n", + " \n", + " \n", + " \n", + "
                        • \n", + " 1\n", + "
                            \n", + " \n", + " \n", + " \n", + "
                          • \n", + " name\n", + " \"Microsoft\"\n", + "
                            • \n", + " \n", + " \n", + " \n", + " \n", + "
                          • \n", + " roles[] 1 items\n", + " \n", + "
                              \n", + " \n", + " \n", + " \n", + "
                            • \n", + " 0\n", + " \"host\"\n", + "
                              • \n", + " \n", + " \n", + " \n", + "
                            \n", + " \n", + "
                            • \n", + " \n", + " \n", + " \n", + " \n", + "
                          • \n", + " url\n", + " \"https://microsoft.com\"\n", "
                            • \n", " \n", + " \n", + " \n", + "
                          \n", + "
                          • \n", + " \n", + " \n", + " \n", + "
                        \n", + " \n", + "
                        • \n", " \n", " \n", "
                      \n", @@ -1588,7 +3103,7 @@ "
    " ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -1596,17 +3111,28 @@ } ], "source": [ - "tif_path = root / \"tests\" / \"data\" / \"asset.tif\"\n", - "item = stactools.overture_maps.stac.create_item(str(tif_path))\n", - "collection = stactools.overture_maps.stac.create_collection()\n", + "href = \"https://overturemapswestus2.blob.core.windows.net/release/2024-12-18.0/theme=addresses/type=address/part-00000-de803747-d78d-4060-b3da-da6dcd5dbab8-c000.zstd.parquet\"\n", + "item = stactools.overture_maps.stac.create_item(href)\n", + "collection = stactools.overture_maps.stac.create_collection(\n", + " theme=Theme.ADDRESSES,\n", + " storage_backend=StorageBackend.AZURE,\n", + " latest_release=\"2024-12-18.0\",\n", + ")\n", "collection.add_item(item)\n", "display(collection)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1620,10 +3146,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.2" - }, - "orig_nbformat": 4 + "version": "3.13.0" + } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/examples/overture-maps-addresses/collection.json b/examples/overture-maps-addresses/collection.json index 7298896..6174a52 100644 --- a/examples/overture-maps-addresses/collection.json +++ b/examples/overture-maps-addresses/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-addresses", "stac_version": "1.0.0", - "description": "## Overture Maps - addresses\n\nThis collection contains items for the addresses theme.\n\n_Note: This theme is currently in Alpha and we anticipate significant changes over the next several releases. We invite the Overture community to test the addresses schema and data and offer feedback via the [data](https://github.com/OvertureMaps/data/issues) and [schema](https://github.com/OvertureMaps/schema/issues) repos._\n\nOverture maintains nearly 394 million address point entities. Data in the address theme is derived from over 60 sources, many distributed by [OpenAddresses](https://openaddresses.io/) and [AddressForAll](https://www.addressforall.org/en/), but also includes open data from the [City of New York](https://data.cityofnewyork.us/City-Government/NYC-Address-Points/g6pj-hd8k) and the [U.S. Department of Transportation](https://www.transportation.gov/gis/national-address-database).\n\nFor licensing information, please see the [Attribution and Licensing page](https://docs.overturemaps.org/attribution/).\n\nAddress data can be used for a variety of purposes, which can include:\n\n- **Mapping**: Addresses may be displayed on the map for reference purposes.\n- **Geocoding**: Addresses are a primary component of high-accuracy geocoding services (i.e. converting text for an address to a complete address with a location).\n- **Conflation**: Addresses can be used to conflate to other data themes (e.g. places, buildings) where appropriate for mapping or other use cases (e.g. refining search).\n- **Standardization**: Parsing an input address into address components based on an existing schema or address model.\n- **Normalization**: Adhering to standard and consistent forms of address components.\n- **Validation and Verification**: Confirming an address exists within a known list of addresses.\n\nSee the official [guide](https://docs.overturemaps.org/guides/addresses/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - addresses\n\nThis collection contains items for the addresses theme.\n\n_Note: This theme is currently in Alpha and we anticipate significant changes over the next several releases. We invite the Overture community to test the addresses schema and data and offer feedback via the [data](https://github.com/OvertureMaps/data/issues) and [schema](https://github.com/OvertureMaps/schema/issues) repos._\n\nOverture maintains nearly 394 million address point entities. Data in the address theme is derived from over 60 sources, many distributed by [OpenAddresses](https://openaddresses.io/) and [AddressForAll](https://www.addressforall.org/en/), but also includes open data from the [City of New York](https://data.cityofnewyork.us/City-Government/NYC-Address-Points/g6pj-hd8k) and the [U.S. Department of Transportation](https://www.transportation.gov/gis/national-address-database).\n\nFor licensing information, please see the [Attribution and Licensing page](https://docs.overturemaps.org/attribution/).\n\nAddress data can be used for a variety of purposes, which can include:\n\n- **Mapping**: Addresses may be displayed on the map for reference purposes.\n- **Geocoding**: Addresses are a primary component of high-accuracy geocoding services (i.e. converting text for an address to a complete address with a location).\n- **Conflation**: Addresses can be used to conflate to other data themes (e.g. places, buildings) where appropriate for mapping or other use cases (e.g. refining search).\n- **Standardization**: Parsing an input address into address components based on an existing schema or address model.\n- **Normalization**: Adhering to standard and consistent forms of address components.\n- **Validation and Verification**: Confirming an address exists within a known list of addresses.\n\nSee the official [guide](https://docs.overturemaps.org/guides/addresses/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/examples/overture-maps-base/collection.json b/examples/overture-maps-base/collection.json index dec061e..1bf0f43 100644 --- a/examples/overture-maps-base/collection.json +++ b/examples/overture-maps-base/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-base", "stac_version": "1.0.0", - "description": "## Overture Maps - base\n\nThis collection contains items for the base theme.\n\nThe Overture Maps base theme provides the land, water, and infrastructure features that are necessary to render a complete basemap. The majority of these features come from OpenStreetMap. We classify OSM features into *type*, *subtype*, and *class* based on their tags. The land and ocean polygons are derived from the [Daylight Coastlines](https://daylightmap.org/coastlines.html). The theme includes five feature types:\n\n- **`infrastructure`**: Infrastructure features such as communication towers and lines, piers, and bridges from OpenStreetMap.\n- **`land`**: physical representations of land surfaces derived from the inverse of OSM Coastlines; translates natural tags from OpenStreetMap.\n- **`land_cover`**: derived from [ESA WorldCover](https://esa-worldcover.org/en), high-resolution optical Earth observation data.\n- **`land_use`**: classifications of the human use of a section of land; translates landuse tag from OpenStreetMap.\n- **`water`**: physical representations of inland and ocean marine surfaces; translates natural and waterway tags from OpenStreetMap.\n\nSee the official [guide](https://docs.overturemaps.org/guides/base/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - base\n\nThis collection contains items for the base theme.\n\nThe Overture Maps base theme provides the land, water, and infrastructure features that are necessary to render a complete basemap. The majority of these features come from OpenStreetMap. We classify OSM features into *type*, *subtype*, and *class* based on their tags. The land and ocean polygons are derived from the [Daylight Coastlines](https://daylightmap.org/coastlines.html). The theme includes five feature types:\n\n- **`infrastructure`**: Infrastructure features such as communication towers and lines, piers, and bridges from OpenStreetMap.\n- **`land`**: physical representations of land surfaces derived from the inverse of OSM Coastlines; translates natural tags from OpenStreetMap.\n- **`land_cover`**: derived from [ESA WorldCover](https://esa-worldcover.org/en), high-resolution optical Earth observation data.\n- **`land_use`**: classifications of the human use of a section of land; translates landuse tag from OpenStreetMap.\n- **`water`**: physical representations of inland and ocean marine surfaces; translates natural and waterway tags from OpenStreetMap.\n\nSee the official [guide](https://docs.overturemaps.org/guides/base/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/examples/overture-maps-buildings/collection.json b/examples/overture-maps-buildings/collection.json index 41c91be..ab87b20 100644 --- a/examples/overture-maps-buildings/collection.json +++ b/examples/overture-maps-buildings/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-buildings", "stac_version": "1.0.0", - "description": "## Overture Maps - buildings\n\nThis collection contains items for the buildings theme.\n\nThe Overture Maps buildings theme describes human-made structures with roofs or interior spaces that are permanently or semi-permanently in one place (source: [OSM building definition](https://wiki.openstreetmap.org/wiki/Key:building)). The theme includes two feature types:\n\n- **`building`**: The most basic form of a building feature. The geometry is expected to be the most outer footprint—roofprint if traced from satellite/aerial imagery—of a building. Buildings have a boolean attribute `has_parts` that describe whether there are any associated building parts.\n- **`building_part`**: A single part of a building. Building parts may share the same properties as buildings. A building part is associated with a parent building via a `building_id`.\n\nSee the official [guide](https://docs.overturemaps.org/guides/buildings/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - buildings\n\nThis collection contains items for the buildings theme.\n\nThe Overture Maps buildings theme describes human-made structures with roofs or interior spaces that are permanently or semi-permanently in one place (source: [OSM building definition](https://wiki.openstreetmap.org/wiki/Key:building)). The theme includes two feature types:\n\n- **`building`**: The most basic form of a building feature. The geometry is expected to be the most outer footprint—roofprint if traced from satellite/aerial imagery—of a building. Buildings have a boolean attribute `has_parts` that describe whether there are any associated building parts.\n- **`building_part`**: A single part of a building. Building parts may share the same properties as buildings. A building part is associated with a parent building via a `building_id`.\n\nSee the official [guide](https://docs.overturemaps.org/guides/buildings/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/examples/overture-maps-divisions/collection.json b/examples/overture-maps-divisions/collection.json index 589b99a..03e0561 100644 --- a/examples/overture-maps-divisions/collection.json +++ b/examples/overture-maps-divisions/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-divisions", "stac_version": "1.0.0", - "description": "## Overture Maps - divisions\n\nThis collection contains items for the divisions theme.\n\nThe Overture divisions theme has three feature types: `division`, `division_area`, and `division_boundary`.\n\nThere are more than 5.3 million point, line, and polygon representations of human settlements, such as countries, regions, states, cities, and even neighborhoods. The theme is derived from a conflation of [OpenStreetMap](https://www.openstreetmap.org/) data and [geoBoundaries](https://www.geoboundaries.org/) data and is available under an [ODbL](https://opendatacommons.org/licenses/odbl/) license. (See the [attribution page](https://docs.overturemaps.org/attribution/) for more information.)\n\nDivisions data can be used for many purposes, which can include, but are not limited to:\n- reverse-geocoding\n- cartographic styling and map rendering\n- place labels\n- choropleth rendering\n- containment checks (e.g. point-in-polygon analysis)\n- choosing a geometry based on your use case\n\nSee the official [guide](https://docs.overturemaps.org/guides/divisions/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - divisions\n\nThis collection contains items for the divisions theme.\n\nThe Overture divisions theme has three feature types: `division`, `division_area`, and `division_boundary`.\n\nThere are more than 5.3 million point, line, and polygon representations of human settlements, such as countries, regions, states, cities, and even neighborhoods. The theme is derived from a conflation of [OpenStreetMap](https://www.openstreetmap.org/) data and [geoBoundaries](https://www.geoboundaries.org/) data and is available under an [ODbL](https://opendatacommons.org/licenses/odbl/) license. (See the [attribution page](https://docs.overturemaps.org/attribution/) for more information.)\n\nDivisions data can be used for many purposes, which can include, but are not limited to:\n- reverse-geocoding\n- cartographic styling and map rendering\n- place labels\n- choropleth rendering\n- containment checks (e.g. point-in-polygon analysis)\n- choosing a geometry based on your use case\n\nSee the official [guide](https://docs.overturemaps.org/guides/divisions/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/examples/overture-maps-places/collection.json b/examples/overture-maps-places/collection.json index abfdc83..c732300 100644 --- a/examples/overture-maps-places/collection.json +++ b/examples/overture-maps-places/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-places", "stac_version": "1.0.0", - "description": "## Overture Maps - places\n\nThis collection contains items for the places theme.\n\nThe Overture places theme has one feature type, called `place`, and contains more than 53 million point representations of real-world entities: schools, businesses, hospitals, religious organizations, landmarks, mountain peaks, and much more. The theme is derived from a conflation of Meta and Microsoft data and is available under a [CDLA Permissive 2.0](https://cdla.dev/permissive-2-0/) license.\n\nSee the official [guide](https://docs.overturemaps.org/guides/places/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - places\n\nThis collection contains items for the places theme.\n\nThe Overture places theme has one feature type, called `place`, and contains more than 53 million point representations of real-world entities: schools, businesses, hospitals, religious organizations, landmarks, mountain peaks, and much more. The theme is derived from a conflation of Meta and Microsoft data and is available under a [CDLA Permissive 2.0](https://cdla.dev/permissive-2-0/) license.\n\nSee the official [guide](https://docs.overturemaps.org/guides/places/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/examples/overture-maps-transportation/collection.json b/examples/overture-maps-transportation/collection.json index 5b10cb2..892585e 100644 --- a/examples/overture-maps-transportation/collection.json +++ b/examples/overture-maps-transportation/collection.json @@ -2,7 +2,7 @@ "type": "Collection", "id": "overture-maps-transportation", "stac_version": "1.0.0", - "description": "## Overture Maps - transportation\n\nThis collection contains items for the transportation theme.\n\nimport DocCardList from '@theme/DocCardList';\n\nThe Overture transportation theme is the collection of LineString and Point features that describe the infrastructure and conventions of how people and objects travel around the world. The dataset contains two features types: `connector` and `segment`. The three subtypes within `segment` -- `road`, `rail`, and `water` -- contain familiar categories of transportation data: highways, footways, cycleways, railways, ferry routes, and public transportation. \n\nMost of the data in the transportation theme is sourced from OpenStreetMap. In the `2024-09-18.0` [release](/release), we began adding data from TomTom to improve coverage in key areas. \n\nYou might use the Overture transportation data for:\n\n- **mapping:** rendering a map of connected roads and paths.\n- **routing:** calculating optimal routes from place to place.\n- **navigation:** generating granular instructions on the maneuvers needed to\n follow a route.\n- **analytics:** transportation-related analysis including traffic safety\n analysis and disaster planning.\n- **geocoding:** getting the coordinates of street intersections (geocodes) or\n the street intersection near specific coordinates (reverse geocodes).\n\nThis guide is an overview of the transportation data. To dig into the details of the schema, see the [schema concepts for transportation](/schema/concepts/by-theme/transportation) and the reference documentation for the [segment](/schema/reference/transportation/segment) and [connector](/schema/reference/transportation/connector) feature types.\n\nSee the official [guide](https://docs.overturemaps.org/guides/transportation/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `overture:release` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", + "description": "## Overture Maps - transportation\n\nThis collection contains items for the transportation theme.\n\nimport DocCardList from '@theme/DocCardList';\n\nThe Overture transportation theme is the collection of LineString and Point features that describe the infrastructure and conventions of how people and objects travel around the world. The dataset contains two features types: `connector` and `segment`. The three subtypes within `segment` -- `road`, `rail`, and `water` -- contain familiar categories of transportation data: highways, footways, cycleways, railways, ferry routes, and public transportation. \n\nMost of the data in the transportation theme is sourced from OpenStreetMap. In the `2024-09-18.0` [release](/release), we began adding data from TomTom to improve coverage in key areas. \n\nYou might use the Overture transportation data for:\n\n- **mapping:** rendering a map of connected roads and paths.\n- **routing:** calculating optimal routes from place to place.\n- **navigation:** generating granular instructions on the maneuvers needed to\n follow a route.\n- **analytics:** transportation-related analysis including traffic safety\n analysis and disaster planning.\n- **geocoding:** getting the coordinates of street intersections (geocodes) or\n the street intersection near specific coordinates (reverse geocodes).\n\nThis guide is an overview of the transportation data. To dig into the details of the schema, see the [schema concepts for transportation](/schema/concepts/by-theme/transportation) and the reference documentation for the [segment](/schema/reference/transportation/segment) and [connector](/schema/reference/transportation/connector) feature types.\n\nSee the official [guide](https://docs.overturemaps.org/guides/transportation/) for tips on querying and analyzing this dataset.\n\n## Data assets\n\nThe features are provided as a set of [geoparquet](https://github.com/opengeospatial/geoparquet) datasets. The data are partitioned by\n\n1. Theme\n2. Type\n\nEach `(Theme, Type)` pair will have one or more geoparquet files, depending on the density of the of the features in that area.\n\nNote that older items in this dataset (version 2024.02.15-alpha.0 and earlier) are **not** spatially partitioned. We recommend using data with a release of 2023-03-12-alpha.0 or newer. The release is part of the URL for each parquet file and is captured in the STAC metadata for each item (see below).\n\n## STAC metadata\n\nThe `overture:type` property can be used to filter items to a specific feature type, and the `version` property can be used to filter items to a specific release.\n\n## About Overture Maps\n\nOverture is a collaborative open-data initiative led by software developers, data experts,cartographic engineers, and product managers from dozens of Overture Maps Foundation member companies. Since our launch in December 2022, Overture members have been working toward a shared vision: to create reliable, user-friendly, and interoperable open map data that supports both current and future map products. We envision a world where shared, open base layers drive collaboration and innovation across industries and communities.\n\nFor more information, visit the [Overture Maps Foundation](https://overturemaps.org/).\n\n", "links": [ { "rel": "root", diff --git a/pyproject.toml b/pyproject.toml index b67b607..62202d6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,6 +38,7 @@ dev = [ "ruff==0.8.3", "ipython>=8.18.1", "pytest-recording>=0.13.2", + "jupyterlab>=4.3.4", ] docs = ["pystac~=1.10", "ipykernel~=6.29", "jinja2~=3.1"] diff --git a/src/stactools/overture_maps/metadata.py b/src/stactools/overture_maps/metadata.py index 2fc935a..2096f57 100644 --- a/src/stactools/overture_maps/metadata.py +++ b/src/stactools/overture_maps/metadata.py @@ -58,7 +58,7 @@ "metadata for each item (see below).\n\n" "## STAC metadata\n\n" "The `overture:type` property can be used to filter items to a specific feature " - "type, and the `overture:release` property can be used to filter items to a " + "type, and the `version` property can be used to filter items to a " "specific release.\n\n" "## About Overture Maps\n\n" "Overture is a collaborative open-data initiative led by software developers, data " diff --git a/uv.lock b/uv.lock index 1b21009..8a743a1 100644 --- a/uv.lock +++ b/uv.lock @@ -241,6 +241,52 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321 }, ] +[[package]] +name = "argon2-cffi" +version = "23.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/fa/57ec2c6d16ecd2ba0cf15f3c7d1c3c2e7b5fcb83555ff56d7ab10888ec8f/argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08", size = 42798 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/6a/e8a041599e78b6b3752da48000b14c8d1e8a04ded09c88c714ba047f34f5/argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea", size = 15124 }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/e9/184b8ccce6683b0aa2fbb7ba5683ea4b9c5763f1356347f1312c32e3c66e/argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3", size = 1779911 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/13/838ce2620025e9666aa8f686431f67a29052241692a3dd1ae9d3692a89d3/argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367", size = 29658 }, + { url = "https://files.pythonhosted.org/packages/b3/02/f7f7bb6b6af6031edb11037639c697b912e1dea2db94d436e681aea2f495/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d", size = 80583 }, + { url = "https://files.pythonhosted.org/packages/ec/f7/378254e6dd7ae6f31fe40c8649eea7d4832a42243acaf0f1fff9083b2bed/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae", size = 86168 }, + { url = "https://files.pythonhosted.org/packages/74/f6/4a34a37a98311ed73bb80efe422fed95f2ac25a4cacc5ae1d7ae6a144505/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c", size = 82709 }, + { url = "https://files.pythonhosted.org/packages/74/2b/73d767bfdaab25484f7e7901379d5f8793cccbb86c6e0cbc4c1b96f63896/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86", size = 83613 }, + { url = "https://files.pythonhosted.org/packages/4f/fd/37f86deef67ff57c76f137a67181949c2d408077e2e3dd70c6c42912c9bf/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f", size = 84583 }, + { url = "https://files.pythonhosted.org/packages/6f/52/5a60085a3dae8fded8327a4f564223029f5f54b0cb0455a31131b5363a01/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e", size = 88475 }, + { url = "https://files.pythonhosted.org/packages/8b/95/143cd64feb24a15fa4b189a3e1e7efbaeeb00f39a51e99b26fc62fbacabd/argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082", size = 27698 }, + { url = "https://files.pythonhosted.org/packages/37/2c/e34e47c7dee97ba6f01a6203e0383e15b60fb85d78ac9a15cd066f6fe28b/argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f", size = 30817 }, + { url = "https://files.pythonhosted.org/packages/5a/e4/bf8034d25edaa495da3c8a3405627d2e35758e44ff6eaa7948092646fdcc/argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93", size = 53104 }, +] + +[[package]] +name = "arrow" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419 }, +] + [[package]] name = "asttokens" version = "3.0.0" @@ -250,6 +296,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, ] +[[package]] +name = "async-lru" +version = "2.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/e2/2b4651eff771f6fd900d233e175ddc5e2be502c7eb62c0c42f975c6d36cd/async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627", size = 10019 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/9f/3c3503693386c4b0f245eaf5ca6198e3b28879ca0a40bde6b0e319793453/async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224", size = 6111 }, +] + [[package]] name = "async-timeout" version = "5.0.1" @@ -327,6 +385,39 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e2/f8/ef0f76f8c424bedd20c685409836ddfb42ac76fd8a0f21c3c3659cf7207d/azure_storage_blob-12.24.0-py3-none-any.whl", hash = "sha256:4f0bb4592ea79a2d986063696514c781c9e62be240f09f6397986e01755bc071", size = 408579 }, ] +[[package]] +name = "babel" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/74/f1bc80f23eeba13393b7222b11d95ca3af2c1e28edca18af487137eefed9/babel-2.16.0.tar.gz", hash = "sha256:d1f3554ca26605fe173f3de0c65f750f5a42f924499bf134de6423582298e316", size = 9348104 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/20/bc79bc575ba2e2a7f70e8a1155618bb1301eaa5132a8271373a6903f73f8/babel-2.16.0-py3-none-any.whl", hash = "sha256:368b5b98b37c06b7daf6696391c3240c938b37767d4584413e8438c5c435fa8b", size = 9587599 }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/ca/824b1195773ce6166d388573fc106ce56d4a805bd7427b624e063596ec58/beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051", size = 581181 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/fe/e8c672695b37eecc5cbf43e1d0638d88d66ba3a44c4d321c796f4e59167f/beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed", size = 147925 }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406 }, +] + [[package]] name = "botocore" version = "1.35.81" @@ -728,6 +819,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073 }, ] +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604 }, +] + [[package]] name = "distlib" version = "0.3.9" @@ -755,6 +855,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 }, ] +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924 }, +] + [[package]] name = "filelock" version = "3.16.1" @@ -764,6 +873,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 }, ] +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121 }, +] + [[package]] name = "frozenlist" version = "1.5.0" @@ -1036,6 +1154,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320 }, ] +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321 }, +] + [[package]] name = "jedi" version = "0.19.2" @@ -1069,6 +1199,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256 }, ] +[[package]] +name = "json5" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/3d/bbe62f3d0c05a689c711cff57b2e3ac3d3e526380adb7c781989f075115c/json5-0.10.0.tar.gz", hash = "sha256:e66941c8f0a02026943c52c2eb34ebeb2a6f819a0be05920a6f5243cd30fd559", size = 48202 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/42/797895b952b682c3dafe23b1834507ee7f02f4d6299b65aaa61425763278/json5-0.10.0-py3-none-any.whl", hash = "sha256:19b23410220a7271e8377f81ba8aacba2fdd56947fbb137ee5977cbe1f5e8dfa", size = 34049 }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595 }, +] + [[package]] name = "jsonschema" version = "4.23.0" @@ -1084,6 +1232,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462 }, ] +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + [[package]] name = "jsonschema-specifications" version = "2024.10.1" @@ -1127,6 +1287,134 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965 }, ] +[[package]] +name = "jupyter-events" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/65/5791c8a979b5646ca29ea50e42b6708908b789f7ff389d1a03c1b93a1c54/jupyter_events-0.11.0.tar.gz", hash = "sha256:c0bc56a37aac29c1fbc3bcfbddb8c8c49533f9cf11f1c4e6adadba936574ab90", size = 62039 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/8c/9b65cb2cd4ea32d885993d5542244641590530836802a2e8c7449a4c61c9/jupyter_events-0.11.0-py3-none-any.whl", hash = "sha256:36399b41ce1ca45fe8b8271067d6a140ffa54cec4028e95491c93b78a855cacf", size = 19423 }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/b4/3200b0b09c12bc3b72d943d923323c398eff382d1dcc7c0dbc8b74630e40/jupyter-lsp-2.2.5.tar.gz", hash = "sha256:793147a05ad446f809fd53ef1cd19a9f5256fd0a2d6b7ce943a982cb4f545001", size = 48741 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/e0/7bd7cff65594fd9936e2f9385701e44574fc7d721331ff676ce440b14100/jupyter_lsp-2.2.5-py3-none-any.whl", hash = "sha256:45fbddbd505f3fbfb0b6cb2f1bc5e15e83ab7c79cd6e89416b248cb3c00c11da", size = 69146 }, +] + +[[package]] +name = "jupyter-server" +version = "2.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/8c/df09d4ab646141f130f9977b32b206ba8615d1969b2eba6a2e84b7f89137/jupyter_server-2.15.0.tar.gz", hash = "sha256:9d446b8697b4f7337a1b7cdcac40778babdd93ba614b6d68ab1c0c918f1c4084", size = 725227 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/a2/89eeaf0bb954a123a909859fa507fa86f96eb61b62dc30667b60dbd5fdaf/jupyter_server-2.15.0-py3-none-any.whl", hash = "sha256:872d989becf83517012ee669f09604aa4a28097c0bd90b2f424310156c2cdae3", size = 385826 }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656 }, +] + +[[package]] +name = "jupyterlab" +version = "4.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a7/45/1052f842e066902b1d78126df7e2269b1b9408991e1344e167b2e429f9e1/jupyterlab-4.3.4.tar.gz", hash = "sha256:f0bb9b09a04766e3423cccc2fc23169aa2ffedcdf8713e9e0fb33cac0b6859d0", size = 21797583 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/48/af57263e53cfc220e522de047aa0993f53bab734fe812af1e03e33ac6d7c/jupyterlab-4.3.4-py3-none-any.whl", hash = "sha256:b754c2601c5be6adf87cb5a1d8495d653ffb945f021939f77776acaa94dae952", size = 11665373 }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884 }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700 }, +] + [[package]] name = "lxml" version = "5.3.0" @@ -1312,6 +1600,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, ] +[[package]] +name = "mistune" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ef/c8/f0173fe3bf85fd891aee2e7bcd8207dfe26c2c683d727c5a6cc3aec7b628/mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8", size = 90840 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f0/74/c95adcdf032956d9ef6c89a9b8a5152bf73915f8c633f3e3d88d06bd699c/mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205", size = 47958 }, +] + [[package]] name = "msal" version = "1.31.1" @@ -1474,6 +1771,63 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, ] +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434 }, +] + +[[package]] +name = "nbconvert" +version = "7.16.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach" }, + { name = "defusedxml" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "tinycss2" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/e8/ba521a033b21132008e520c28ceb818f9f092da5f0261e94e509401b29f9/nbconvert-7.16.4.tar.gz", hash = "sha256:86ca91ba266b0a448dc96fa6c5b9d98affabde2867b363258703536807f9f7f4", size = 854422 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/bb/bb5b6a515d1584aa2fd89965b11db6632e4bdc69495a52374bcc36e56cfa/nbconvert-7.16.4-py3-none-any.whl", hash = "sha256:05873c620fe520b6322bf8a5ad562692343fe3452abda5765c7a34b7d1aa3eb3", size = 257388 }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454 }, +] + [[package]] name = "nest-asyncio" version = "1.6.0" @@ -1492,6 +1846,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, ] +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307 }, +] + [[package]] name = "numpy" version = "2.0.2" @@ -1614,6 +1980,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/13/3e/1959d5219a9e6d200638d924cedda6a606392f7186a4ed56478252e70d55/numpy-2.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5c5cc0cbabe9452038ed984d05ac87910f89370b9242371bd9079cb4af61811e", size = 12820057 }, ] +[[package]] +name = "overrides" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832 }, +] + [[package]] name = "packaging" version = "24.2" @@ -1623,6 +1998,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, ] +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663 }, +] + [[package]] name = "parse" version = "1.20.2" @@ -1699,6 +2083,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/8f/496e10d51edd6671ebe0432e33ff800aa86775d2d147ce7d43389324a525/pre_commit-4.0.1-py2.py3-none-any.whl", hash = "sha256:efde913840816312445dc98787724647c65473daefe420785f885e8ed9a06878", size = 218713 }, ] +[[package]] +name = "prometheus-client" +version = "0.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/62/14/7d0f567991f3a9af8d1cd4f619040c93b68f09a02b6d0b6ab1b2d1ded5fe/prometheus_client-0.21.1.tar.gz", hash = "sha256:252505a722ac04b0456be05c05f75f45d760c2911ffc45f2a06bcaed9f3ae3fb", size = 78551 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/c2/ab7d37426c179ceb9aeb109a85cda8948bb269b7561a0be870cc656eefe4/prometheus_client-0.21.1-py3-none-any.whl", hash = "sha256:594b45c410d6f4f8888940fe80b5cc2521b305a1fafe1c58609ef715a001f301", size = 54682 }, +] + [[package]] name = "prompt-toolkit" version = "3.0.48" @@ -2211,6 +2604,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, ] +[[package]] +name = "python-json-logger" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e3/c4/358cd13daa1d912ef795010897a483ab2f0b41c9ea1b35235a8b2f7d15a7/python_json_logger-3.2.1.tar.gz", hash = "sha256:8eb0554ea17cb75b05d2848bc14fb02fbdbd9d6972120781b974380bfa162008", size = 16287 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/72/2f30cf26664fcfa0bd8ec5ee62ec90c03bd485e4a294d92aabc76c5203a5/python_json_logger-3.2.1-py3-none-any.whl", hash = "sha256:cdc17047eb5374bd311e748b42f99d71223f3b0e186f4206cc5d52aefe85b090", size = 14924 }, +] + [[package]] name = "pywin32" version = "308" @@ -2232,6 +2637,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/cd/0838c9a6063bff2e9bac2388ae36524c26c50288b5d7b6aebb6cdf8d375d/pywin32-308-cp39-cp39-win_amd64.whl", hash = "sha256:71b3322d949b4cc20776436a9c9ba0eeedcbc9c650daa536df63f0ff111bb920", size = 6640327 }, ] +[[package]] +name = "pywinpty" +version = "2.0.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/82/90f8750423cba4b9b6c842df227609fb60704482d7abf6dd47e2babc055a/pywinpty-2.0.14.tar.gz", hash = "sha256:18bd9529e4a5daf2d9719aa17788ba6013e594ae94c5a0c27e83df3278b0660e", size = 27769 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/09/56376af256eab8cc5f8982a3b138d387136eca27fa1a8a68660e8ed59e4b/pywinpty-2.0.14-cp310-none-win_amd64.whl", hash = "sha256:0b149c2918c7974f575ba79f5a4aad58bd859a52fa9eb1296cc22aa412aa411f", size = 1397115 }, + { url = "https://files.pythonhosted.org/packages/be/e2/af1a99c0432e4e58c9ac8e334ee191790ec9793d33559189b9d2069bdc1d/pywinpty-2.0.14-cp311-none-win_amd64.whl", hash = "sha256:cf2a43ac7065b3e0dc8510f8c1f13a75fb8fde805efa3b8cff7599a1ef497bc7", size = 1397223 }, + { url = "https://files.pythonhosted.org/packages/ad/79/759ae767a3b78d340446efd54dd1fe4f7dafa4fc7be96ed757e44bcdba54/pywinpty-2.0.14-cp312-none-win_amd64.whl", hash = "sha256:55dad362ef3e9408ade68fd173e4f9032b3ce08f68cfe7eacb2c263ea1179737", size = 1397207 }, + { url = "https://files.pythonhosted.org/packages/7d/34/b77b3c209bf2eaa6455390c8d5449241637f5957f41636a2204065d52bfa/pywinpty-2.0.14-cp313-none-win_amd64.whl", hash = "sha256:074fb988a56ec79ca90ed03a896d40707131897cefb8f76f926e3834227f2819", size = 1396698 }, + { url = "https://files.pythonhosted.org/packages/d8/ef/85e1b0ef7864fa2c579b1c1efce92c5f6fa238c8e73cf9f53deee08f8605/pywinpty-2.0.14-cp39-none-win_amd64.whl", hash = "sha256:5725fd56f73c0531ec218663bd8c8ff5acc43c78962fab28564871b5fce053fd", size = 1397396 }, +] + [[package]] name = "pyyaml" version = "6.0.2" @@ -2444,6 +2862,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, ] +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490 }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242 }, +] + [[package]] name = "rpds-py" version = "0.22.3" @@ -2593,6 +3032,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f7/af/eaec1466887348d7f6cc9d3a668b30b62a4629fb187d0268146118ba3d5e/s3fs-2024.12.0-py3-none-any.whl", hash = "sha256:d8665549f9d1de083151582437a2f10d5f3b3227c1f8e67a2b0b730db813e005", size = 30196 }, ] +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072 }, +] + +[[package]] +name = "setuptools" +version = "75.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/54/292f26c208734e9a7f067aea4a7e282c080750c4546559b58e2e45413ca0/setuptools-75.6.0.tar.gz", hash = "sha256:8199222558df7c86216af4f84c30e9b34a61d8ba19366cc914424cdbd28252f6", size = 1337429 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/21/47d163f615df1d30c094f6c8bbb353619274edccf0327b185cc2493c2c33/setuptools-75.6.0-py3-none-any.whl", hash = "sha256:ce74b49e8f7110f9bf04883b730f4765b774ef3ef28f722cce7c273d253aaf7d", size = 1224032 }, +] + [[package]] name = "shapely" version = "2.0.6" @@ -2653,6 +3110,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, ] +[[package]] +name = "soupsieve" +version = "2.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -2716,6 +3182,7 @@ dev = [ { name = "codespell" }, { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "ipython", version = "8.31.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "jupyterlab" }, { name = "mypy" }, { name = "pre-commit" }, { name = "pytest" }, @@ -2746,6 +3213,7 @@ requires-dist = [ dev = [ { name = "codespell", specifier = "~=2.3" }, { name = "ipython", specifier = ">=8.18.1" }, + { name = "jupyterlab", specifier = ">=4.3.4" }, { name = "mypy", specifier = "~=1.10" }, { name = "pre-commit", specifier = "~=4.0" }, { name = "pytest", specifier = "~=8.2" }, @@ -2760,6 +3228,32 @@ docs = [ { name = "pystac", specifier = "~=1.10" }, ] +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154 }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610 }, +] + [[package]] name = "tomli" version = "2.2.1" @@ -2826,6 +3320,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, ] +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20241206" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/60/47d92293d9bc521cd2301e423a358abfac0ad409b3a1606d8fbae1321961/types_python_dateutil-2.9.0.20241206.tar.gz", hash = "sha256:18f493414c26ffba692a72369fea7a154c502646301ebfe3d56a04b3767284cb", size = 13802 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/b3/ca41df24db5eb99b00d97f89d7674a90cb6b3134c52fb8121b6d8d30f15c/types_python_dateutil-2.9.0.20241206-py3-none-any.whl", hash = "sha256:e248a4bc70a486d3e3ec84d0dc30eec3a5f979d6e7ee4123ae043eedbb987f53", size = 14384 }, +] + [[package]] name = "typing-extensions" version = "4.12.2" @@ -2835,6 +3338,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, ] +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140 }, +] + [[package]] name = "urllib3" version = "1.26.20" @@ -2900,6 +3412,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, ] +[[package]] +name = "webcolors" +version = "24.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/29/061ec845fb58521848f3739e466efd8250b4b7b98c1b6c5bf4d40b419b7e/webcolors-24.11.1.tar.gz", hash = "sha256:ecb3d768f32202af770477b8b65f318fa4f566c22948673a977b00d589dd80f6", size = 45064 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/e8/c0e05e4684d13459f93d312077a9a2efbe04d59c393bc2b8802248c908d4/webcolors-24.11.1-py3-none-any.whl", hash = "sha256:515291393b4cdf0eb19c155749a096f779f7d909f7cceea072791cb9095b92e9", size = 14934 }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774 }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826 }, +] + [[package]] name = "wrapt" version = "1.17.0" From 38a0e8f9abc915895dfdf614fc505cd10ede9165 Mon Sep 17 00:00:00 2001 From: hrodmn Date: Tue, 24 Dec 2024 07:33:13 -0600 Subject: [PATCH 10/10] drop old test files --- ...d8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet | Bin 1150 -> 0 bytes ...46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet | Bin 123405 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet delete mode 100644 tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-35685b01-5d46-4cb5-8449-5b27bcbfe445-c000.zstd.parquet diff --git a/tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet b/tests/data/release/2024-12-18.0/theme=buildings/type=building/part-00000-2a7085d3-4cd8-40f2-adaf-0c6d59a3b7d9-c000.zstd.parquet deleted file mode 100644 index 371e40d8dd3447dd64a800d84266bbc0874b0b47..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1150 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    G9C1wS`L-(48h;bf1s7 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%0AF zU-9lvND*)Z{Xi|CKZ)R>&CocLo@hLywuEj)^lXdrncyf7ZTISKQ~_E44KT`lG<ICL8IRjDf1$U+hH;@|TZjQOgRxXJ4QnxT3hBA+zu-f}5^1%9Z-O7mQV@;qOL zHc$|tu1wTSc#0g3xo_g41~4bdz^&SrMjqWSZL@*|t3EwCYhD|9(9D03SB;1Ys!$c- z!ut-JX+tF-!TjRljN_xe`X=TWSK_-F-VpUO{73x`ki}oRF;>{bZys1vvs=NSzl|hOHg-X~XBb@oxC-Dg_0jqS?zq6HR|uFE?2TmCemrko23Pf|nQc}ivU_Id zipmhZrdY+J0UUeJ0Xd(+D~x*2&fA>->ffSk{S4lW{m%WRK9M~!f~Uj=$U64iz@GAx zEsMaZjqA_-!zCdD=oAO-R{>}+_xA>8zSHP_NWb$H@LfrZYE*2(G_4E$hJ? zMTq?kI}9kr8r_uU3{Zp{Fh$V3iD!8M!rVxo#oAB?biy(o#jsv zaAvJ*F0C&sw4N(&qe#mHS~|77dVPV_@m$VAB3i5NJXZe8iur(;+&hTuI`XtBYcihaXTaN-rz+Vj zqm6lQ#NzsJyussc{fDA8$UJN3O>j_^N}~{l63*Yj4e3I_)nY_oe_GWt^lFWtU=G_9 z(<5exx|rlZXkbXu^iJ&;y3 zSN+X9Bxjk(xLt-MOF!A|l|Ql)D_HV0VJ@jjpM@DiIyBhEHp}D$+>*G|jhnbz;lMWMYkP4mP+@B1-*BqGO=eY z^4M}p@cY$Deu$k=jc*h+B|P-U)D3e=xL=`2H5ZP1244UyrmU9WPk9BBO&E5z8N5pq zH#jQkZ(11nSeCrypQSbmv!n`{A+27YE6Z+wyW-)HeaTrxa@L8U;iOG6;gHQLLT>=| zz&PGi9hhq}80|6Oo8xR097Iqi*YR@v)~$&GOOmR_BL`D}n`FaiY3rIoB**S8Y)DDI zlJ=o#U6VCB+NP2}z7sQmu8Y7IA(F3Fz2lW`X3%Pi;kds@$SL>Ju?jBh5_8?OA-o%7 z&3D<9wA4;h=9t>^9vf0RYP4kT0v`n(O}Eg07k6;g)tUcxrTJQhg{_pds*|%{vV}C6 zZt`SEx+-d$$Nap2N`@KIpFG|ccQ2RC_Rl_;>ZpPGZ~nk>lUq7a?qki7mMPws)D)Iq z$9K(t6?HW>rWYSyt=I~e!`&(2BBOkHy@1$Plf=N6MZKr_)a-*Rp5B|cONtT`I4hW= z0U4;$n+hl(t=^{4RD6d>`haAZ92bqd6kL82&aO%@+%#675_KeVBBV^S8x!3e0HLSd zX6sMXaS$oAgW|Yn89KEae-{xrWn?ygr5NZl>kFNR(FN$VB)7Bk-ADHWx^a?*&xUCUJ%#AjJ`p`0ar;eYb zSbMfH^2*qQ$MlG~u}zs6Z;F!0D7+>c$NgR63*;VY^#xxTt`8#l!OS}F*^ama{j;5$ zCs(l=>saxbM4cZ3O+gUJ<<`b#vwd-g``L)I32LLLy-0Zg@ZsMYuci;ojcNiD#PH1s zHK)!AK#Nrp8)DatBNf)3*yIp%k?a!F)@Makfr|~M->*(IW?MMQQDyLLl*tgR`=Kq# zS=*OOc^1cg%EbyAx+*F=;$M@aUTH4VYiZEg8y?A>r-UmO)G|d-lt2C3WKyAd$+;Hw7t!jIRYU|c>UwFx^$sLI=Z%9ocLw_q8x&_yux4*$$gXu>)OvEoY`3;hDZ(kKh8Da zrA!gR1joI8-U*f=7}qe-?{R>MxnWYEqw+IAyK=*(?G0Bb;dPH8wrdAdI=6psJwRIR zB)x0&K$(b5GtXjgQ4XtL@VH3hxNlA_W#uOd6t>dYC_p5CPgK+QkygPNFI8n??w^l} zz3`*WVJkW>@=+!N7}!q_l-2w=S=9bKWiC8Fo86hBRBg4Sc#D{u4n5=A5*N<|9W+c* z17#(WX>3qdv%9G3hSL<`cYAXs%#;q0iabMTJvZYi)~5Ng2sb}jnKna}ZnhMY7{E7& ztED)E)pHvsDPS0}`o!EE6Wf%n=^5EuNhTFptPHu4qN2rhfY@LOFf_5ARRhofAwsx$ z$o}zU1B94cki}9_nqoDdA{?uGk%A51a$>b+cO|ItrJDG` z&0aPUjEx9Zg|_iHZmrQJ6l_~ueus9g=&yq*yWCA|W3tu!P(+*?;J)V90xB@_okjfz zQ}e7Q`$72TP~kv}OQ2J%5xtSK#y$iKZq8U7xBNE=!-r$dpxtR?io^heN)b1ZFrR)Cnla+pU$W z3;|bF(;Wa)!fPcOF^3@Dg4KQUKSeI9Qej+QLH%j_f*WVztuCN9^#5SIq^z*2niQo< zm_Y!(HOjml*1$nD7VLj~ zz&GFFigP)F%F=a^`qPfYFM?){UhRRLX=r+$%TvN1vxinc=n)A~{o<_O7tRSIq8Xz( zkQ;~M4@T}M%KreJ<}cIO|3Nvd6>fpuA)-BU+dgritiE(~L0Hc*)=$CGlY$9O$DlZs zARBq%M{55MA{%6gg0m-EftzTV{MBBJHb;AmtHsyzc86=m8;mtaqkq(>fduf)F^Hy2 z5=8bkg~KU;S`-v#_LgB9Ec4)X`f_)o!0VwORwQtcRexHi*3lVgRfQ-ikm+6}4%uc|d+HO>8kKm=o_K4#Qgr5LaL`4mBj$tg zhbl|LlVkAqCc7x)%c{PDr#2ZJR5>trgO+mW`>sa)5ssJJp6sf$V(cStqG|RU^RBhY z^>G1E<`X6BJ_MZMo@aPdq5v1hJtrRlziF3L9F1>|6@M;QhO~5BaW=3`ju$qO)$qC> z_Vh$Nn>t0uy#e0NP@@ZdLQ(QV)Bo`a$NTrS;7*KQepX0nOl*7vKV#7N)UcuNqQWHDkqZthY?x&b{tE#1IXbR3WmK<3T3_mqlYBnS8Bt zjIc+<0!9%~YjMfqY9iX_q)vDNP^c2s#vh>4*Nb1m(1`+eAVL3g5N~=VL^b?Dq(TqM z^3$u5uz~O5Z(xnR#mAskGbSZ*K1xTG(BqX@sH~nThqmmBahHW1w}l0cSCnIg{*=DQ z9ov~=HMpf*J_J}fraUB|F;S;rPhQv)#|vm)*PJ{sUxqc;+HjFp)rynd{E6s5rpaq< z*7!K5T~H}Z0xzq@p`H(w^_UBJ7`h|=Cdhp0`z$ypdtpw?ljN-aNas7Uo>%#JV$N+( z{LQwN!^%3fQJz*88bWf`lH^l+4wVdAQyQO}Ha5!1ZP9;><5mZ;3YCmC2Qy_~mH@ug zRgg#YUwm^ADIv}^#WEpbc5kUD@!U>a>JbSsZG}uzaTsk5&{0blhsqjFy2!h38?!Mj z(Ab6Jc$uHpy=W$j|F29rb7&1L)1tyI8A%Dp-YGGi1_!m=2p)<>Sxq_Jj!#dvR1;X_ zi#;pKST*h!y1<|f7~!2;;+*D)ECF63x`?IPJMc(cevsCQpOuI%v`3n0ZHWsGzE$=) zc)ylo%UcqJZ&m)m@pb(ys?&bbx7<7?g6+TiS@r7oUZ{ALpH{VLx&)XvBkV*q9Bea^ z>|C)CowZ5NLkQ&VqWWQ->@urPNn+K)b;A1yYE@h8Q1-L)<2hwkBc}P0E^DR4vQH}Ku#uf)b(_pf;8Md8X{M%XZPEn+b^$#PR3+QeVIbgn0JJa4J8Wfp2@ z;lP2@c(8f<{#9w-gA=FRME6YI1ST_7YSfv)faUMr$OfxLnO6t13Jph=#(ef&YJ zL?D*YI8It+w0m5JQDE-m`Vc-|CE`F)>5Hlc=)okP=%D)+fnF%yb8>^;QaJ^$L;z=G zw6a|RB>*nl!*5spPk1Ceke(J^ahHwtl9>V?xil!xJu4Y!2c{O1JAaSmCo`bXsUKWo z&53Uq3=On_kU9A>9{2Ds?%V@4a(^An>V{`^?T)A{mdXor0uhwyZ|!U;UCfVoUs)%m zrUbR7Z#E^qp`U`42je8)GWnVA?D#V_+GObY13`RgFXz_w{Ta=8>gB9}SjS}=+t(Bo zc5wmW+o;q8nH*(?&5?x+RueTKGV?a>KdNI-?-lJyg_En*d5pes5y@Ss%{Rsl=q0jq z%jL-5J>ALWV1v5Duhzg2MRFJX&==Qla;x`cLs~A?-<_<@nO1Nx+r?HTVAz+GnzaTX z^q=$&^rcOGC_b2d_OhSf9jIKWkEs)KtM`BYSAoFG2090)QXmer$U4mlsC)|+8ny(K zFXVCi9;NH8nUButRq4Eda;*-fi`{ke@)@z%(cpWd-AOOsw_4Zi{VOdtnH%p9Ms<+WN%G>>GM#zptF_KYA(c`^yvNO8dWG^|O;%pbkXw2jM;k6{!Kl94$FT{mR&7A2aqJd=Ac#fEakmg1EG!ws3E~A^l;C3qT z`1Uxa+VFbOJj~1jH!Q%AC4(l2rG5of$T$9~%9sldu^uNM;NIkM7{w@~hfTVMryNag z)hZX^TcuZy7YxKwpX)HlX@Xg~ZvASSgqxu3%*Fc8wDwP2|0<(thr~quC@VEzA|Hr@ zqMsCz)_8bdWbI8kvYv2B>XTd~bG9Mckn0wnG}=77n9gFRB?bZ+k!=|iNA~?1T+G{l zd{Pbr36!6!|8F(06egDXFwP$=hq9~0XBHlE-QtFvX}2WXm74~wXh@{Szl_U5{j8Fy z9waP~$?X}ujz*R-5qt_UX&YjxwvQpY!gS=5a=U^oQ(uycJj$Jc(Pn!ZmTQ(<&*9>w zKp1Vc`FHooW$Wbr#4cKk3CNPn>WkI>sn-+PMb~EB`T~>9`KJ1h_IN{G(n}aR;cD03tg%imKXxdf2Co!EOAj_P(+hVBJ#l4`o`9OiDEr_r-?(q3+Y9r~ovO>H!(8f^a_fy%o?V(< zRP`G8`O#U)56cjJYxLyNoD=!d-fUmUivO|2q>Q$z$lMEjX?%T5`*Oy7&bMZBYhh}g zjL0q7*!`yNV9d|>dWWpYKLde9;ae3n=K~ZBuT#nzd1-*Z%gSRxGjDM1N4?+pblf*G z1N;?DB)9XwIL5phK8M%oE5Ds0a{9IRzY8oqnj*KmTz4>rgc1h+L0aS@KPiWw$?DCL>sk z{~GKW7Raq9biXGbF#m_Dj&C)nfIsY)NDXVK;a&Mv^#dJpu86#}(VJbu)eI-hdZ+2Q z<<^Vp#Tsan)jyNlV^p55)XwQ^jM<;YU)t=`S~KXDOirvM~{VhhCeCrB?aB%)U&vLtRRBgN?5t zvh)hwqpc2s19Y2YMD^n()dw*V#UACn<5Q08bt@flKuW4KsEX^>>@v+w@@VVQym`Sm zx!sH1^o|{Ajr4kX-uPOq8~o60(f32Rn6R#RYS8$p)%SVd4^su&cW1~4?^wLtV-l6L#lEY zFoJsP+XKTxEWRxw^D+ejnkru#*;ZpBcxH^5ALQ0Y0U*psY8BIJiP8*#+%D=yqbE*s zk@ng0ib%M$*~@9Qhmh8!?>G!FaNTO1rj@ZyvMazap2qH*L^FLL5hSLmu`{Z`Po2r6h{}r3aVr_7ZKZ92p{HkJmfBzqu zkk?YW_hODpz*_VTu;br#w2%ee@$=hh2o?nRVdR>5esrhAeu z4b4<&HZtG;A#R^r|K=&wVH@9iFV}9;+VFZe|KTe}q+O=~YA571`GD4Ll2(PZrXptq zePMLHG1(+Ix9aQD`g^+=@VmPF7?~gHPc!6LFcP`--X^7JntBmeUoN* zru+aGo;CVXCMV`d5T;>Plv~dyVFOp8m!1`z6w0mV40V;*51vUZ@%qlUNbwZ|>#$W)`hGx~` zK3O+x01hO8H$8g6S0#IaQ3IA+FSjY2Bb98|$kCT&3D_O0ZEQhOjIw}+NzjJjwN9fF zeHJ(-LVy!Pv&(gB^}H>_7HQYW!k3k{cXHpNiH|WgCZb9zIwvl-{-#uS9FY#q+ z*p8DCm;r0-eV{711%kTk+&XP@ko5nMJ#QXvfBj>t8Gl6+;J z$}94TtJNQ^oMK$JV#XtQE)JJxAOAX8XU=$Lo>uDOo3y~vs5I8+G^Y8<=T*_~!L(d!27HOk>7j&@3%dB@60`O=G5Ff^BgEY zphY9o6ouc)UBz75fE=UG`<$Xb6fzl>-C%{GL#UeALalEXuLHPT;6RH&)=f@HBBg8( zV4pnxV^PFV59aIxT%Gt207Uk`rKRr_yMQw}iTX*~Rqio^NGJt7a(N0UN@n0Y@8ucQ zYr@hAUslcn3bvE1c(y4zwCNqBr=mF|n#y zSB>SR)pe8rUH7AvvrqE5eGxlI#~lf+viTMk>U;a5Tm^|44p7;WIl_Pi`@yXhmRR1J zr}qh{tXKax_8g;-Q$pg2WsE`su1qzzTjQ|rgV|HKkI}mnJQ!%EALO&N= zWJ``;HI}ha?{s+j;B}KhY7)*()iDZ)*lw=qd}?^R=_w=_Ky%x?!h z#P})JH56H}KYjH}x7)M&{4}Xg7n9BjpNuQi7q( zm}}LTSpy7Kk$<2zan2|Na$i!sAH*1>&$@hmu8Y5cw3T^NXtKOb(ixkHKFbM;{NO2@04QVa5L0rQX|h^P3#Mb3~8oFJL@aAC3Ox_>Ev_hF?MMA4M6?92~@2(H_bAr~FIlPX2PR}pSOkz?j<5#S! zD?w_efQ{;ySBNE-=)^F;)%5L+r;2L{pvYA+Tt`m|kmUNPoaf*v*gL6Ro|))Ab>khe zX1vu%POJm`uM9m+aTo-73A_~;K#2T45_ZYLO|}F-yxaVS znt?$W?v_l~6(2fZJN#96DC;Zxj*KKQ=BopiGK#ouk^9vZ2|qXXs3j9pU*cK6mLhw$ zcIe}pc$R~QRlu7HbHc=TPqY=1&9a7lnEbDQw9)dwmhTy73XguS5^zdd1js8v7f2Wc0xa+HeSQ z)1&$g;6UZP<5)L7lC#*SV>L^CYxKVra3&#|nzatG#G{i17>}p?B9ps1qgE#*UIf%f zDM&~bTs2mct1kV7elGX5pE(eq8b5PrkUnd)zwT=NRvw%7o)!hX~y?VWmG zDev0MfQst64D(xsVlm$TfF{n)wcS0?MFsV6`k>DUc!soQVey9$2ou>=dII=i zo2jI1qyW%PECs1CV9`nYE{o$bXP)AsvL_uqsW>bsl+hwJN%{~MberdviQtZ1odGjO zE{Xw*0DqoX{AKG`LmZ%=Ya4sglr%7c7@UpAvBpV?OaxXoF;UTiA+vGMW4F_S*! z>P!bNjo706!!of~4E9-$)n%?u@zz;p+B-GnH0Z&Xcch5Rv!>s1C2K3zNfzsk`nl-m zifNoR55ir8zC8p7XP5O9)Ivb2_f*IQ)+6`eRrMYvn);0N*?$r^U-!>*te&L%MjV_` zAy~<^8CH#-uwffWPrjcD@N3xK)z`oj?X|sb`@zWOolgK%x0KuZngJBZDs|CJ<$(%{ zGuYcJfrAw?djgGaDk!6)u+)1lc}W!Y!?HSSC{YwYO}F7qn)yyKvcIcwATZ`lMd*xW zfKfbfULkvtL-Ghtr8&Wovkp*N35>gvA8WSiNM;Lk)9p|%ukuX3Cnd3ALaQ|b5&)22 ze`Aka7*J!|ake6sU0|}%1k6n-)m4RcXYZcqHbHD>c;DJth2_mJaU;nWho2*+9bzKB zN$rnFY}?nL(;ngwHJB`eI0rTkIAu6?ic2D~#{ z+@M||#PFr7t=W7*S1=9!7!ffH*tNeSY@fAjn=N~=cwEPa)ffyMZwauEYi-M-!)srM zXP!>~5=db#PCveMeUDQw1@hCdBAP4+d>wq+aI2%@(hv04ZO_>&?rU-g{~?lcXv^r$ ze-&ktJ)_MbNzVAd)Al)@FQR`7Xw3!k68|cdkv^W(U{*G*djW5%k&}X#AlKnP>c|Ud zfOmDIZmvS?p{vbklPS(q+X2ie?t@tvoFS{7Pcvhm^mZhvZSeF0 zyHTIeHfv4AOCzp|R{X3kN>w96@&bP8LzcnV5=@gth&us; zt*ZByQLgDfKkIzKQy%j)aq7}_gHD|gIG@4~!Kojl zU%?0s4c(oM+>5fmtRT`;->1xVn_$tWsoXT$NOLn_g*(xOnc#{zDwo`hF>v)b5R5Od zkWm-O!`(p`VGb2^%tiA4w;Mfvi=F+-hk2KSA69v2ZQSzT>}E++nox5?1vL$KZBk*o zg`ahr&L<0!rft}Wd5Yve8d~S(omY$&8qqtbv!7MGirFpA9QXfdSxQ};AsZ>hS(o&- z=&7B$5|h*_&J0E|k>qaMWs1s93bAG)0WX5rG{sc0-V^>Gmx@Ild{=R1)nzcx z_S%~C(s?}NWih2A)XcLKgY(nv0}!{oD9r)dB$dhcZu-ig^ik?_;7L;2&EE?mYzEx9`6Gj1`P9A}Sk&W0{Mbg`iXo9z=ru&8FVsI0UT2sfGv*juT z7pVnnS5*m54{3v9u)=I`<=AY2;43a2#!Y`db&#Za0_lZVegvzgZ9h0vEvvaZtLy_Poi$GzFr+Cm&(2^F{Iio@AyVQ>jz0raDJ=mJ zPx}mpmTum4md~h2;){|Jx1OtII&NAku5BFod(e_31Y z;C}uz?0_j##&3mgX|C3mqIieK@*)_urrZ+t9@uPVrd{8fNar(v9?;TjC4Y{`y<(?` z%gkw+1&Q@0MWeCe+Igi8k~|@g{75dN97HS6d`iYeP`03!Dn;LuThZPQ^^$ zeFsUA1FSH*?Th)+Cuy?KGAnhK3m4_VP^4

    ?UD;w>jrhFD)z-< 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

    -=H%;P2fmhT9X#&%O#uKqu^@ek~#qA44I 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