diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 16085aba..5e6f6f53 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -135,10 +135,10 @@ jobs:
./tests/integration_test.sh
env:
- DB_HOSTNAME: postgres
- DB_USERNAME: opendatacube
- DB_PASSWORD: opendatacubepassword
- DB_DATABASE: opendatacube
+ ODC_DEFAULT_DB_HOSTNAME: postgres
+ ODC_DEFAULT_DB_USERNAME: opendatacube
+ ODC_DEFAULT_DB_PASSWORD: opendatacubepassword
+ ODC_DEFAULT_DB_DATABASE: opendatacube
AWS_NO_SIGN_REQUEST: true
AWS_DEFAULT_REGION: ap-southeast-2
AWS_REGION: ap-southeast-2
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c05966dd..bdecb621 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -21,7 +21,7 @@ repos:
- id: check-added-large-files
- id: check-merge-conflict
- repo: https://github.com/PyCQA/flake8
- rev: '7.2.0'
+ rev: '7.3.0'
hooks:
- id: flake8
- repo: https://github.com/psf/black
diff --git a/README.md b/README.md
index f5594c11..136ec03e 100644
--- a/README.md
+++ b/README.md
@@ -334,6 +334,6 @@ The dockerfile for the docker image used in the ochastration, which can be used
## Integration test
-The integration test for the summary products is located under [tests](./tests). Currently the test is performed on all the official summary products published by DEA. The "golden files" to test against are stored on the public accessible [S3 bucket](s3://dea-public-data-dev/stats-golden-files). The "golder files" should be achived but not deleted in the case that we decide to amend or upgrade any product. It will help with tracking the changes that we intend and alerting those that we do not.
+The integration test for the summary products is located under [tests](./tests). Currently the test is performed on all the official summary products published by DEA. The "golden files" to test against are stored on the public accessible [S3 bucket](s3://dea-public-data-dev/stats-golden-files). The "golden files" should be archived but not deleted in the case that we decide to amend or upgrade any product. It will help with tracking the changes that we intend and alerting those that we do not.
The test is meant to be regressive, i.e., the new version of `odc-stats` need to pass the test on the last version of docker image. The new version of docker image needs to pass the test on the current released version of `odc-stats`.
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index 4ba9a258..0aad6e28 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -12,10 +12,10 @@ services:
build:
context: .
environment:
- - DB_HOSTNAME=postgres
- - DB_USERNAME=opendatacube
- - DB_PASSWORD=opendatacubepassword
- - DB_DATABASE=opendatacube
+ - ODC_DEFAULT_DB_HOSTNAME=postgres
+ - ODC_DEFAULT_DB_USERNAME=opendatacube
+ - ODC_DEFAULT_DB_PASSWORD=opendatacubepassword
+ - ODC_DEFAULT_DB_DATABASE=opendatacube
- AWS_NO_SIGN_REQUEST=true
- STAC_API_URL=https://earth-search.aws.element84.com/v0/
- GDAL_HTTP_MAX_RETRY=5
diff --git a/docker/env.yaml b/docker/env.yaml
index 758d2764..6d6476a1 100644
--- a/docker/env.yaml
+++ b/docker/env.yaml
@@ -48,7 +48,7 @@ dependencies:
- dask-image
- deepdiff
- defusedxml
- - distributed<2024.11.0
+ - distributed>=2025.4
- docutils
- fiona
- Flask
@@ -120,7 +120,7 @@ dependencies:
- slicerator
- snuggs
- sortedcontainers
- - SQLAlchemy<2.0
+ - SQLAlchemy
- structlog
- tblib
- text-unidecode
diff --git a/docker/requirements.txt b/docker/requirements.txt
index dd581939..867bd4ab 100644
--- a/docker/requirements.txt
+++ b/docker/requirements.txt
@@ -1,17 +1,18 @@
--extra-index-url https://packages.dea.ga.gov.au/
-datacube-ows<1.9
-datacube[performance,s3]<1.9
-eodatasets3<1.9
+datacube-ows>=1.9
+datacube[performance,s3]>=1.9.5
+eodatasets3>1.9
hdstats==0.1.8.post1
-numexpr @ git+https://github.com/pydata/numexpr@a99412e
-odc-algo @ git+https://github.com/opendatacube/odc-algo@adb1856
+numexpr>=2.11
+odc-algo>=1.0.1
odc-apps-cloud>=0.2.2
# For testing
odc-apps-dc-tools>=0.2.12
odc-cloud>=0.2.5
-odc-dscache>=0.2.3
-odc-stac @ git+https://github.com/opendatacube/odc-stac@69bdf64
+odc-dscache>=1.9
+odc-geo>=0.5.0rc1
+odc-stac>=0.4.0
# odc-stac is in PyPI
odc-stats[ows]
diff --git a/docs/config_ndvi_ls_median.yaml b/docs/config_ndvi_ls_median.yaml
new file mode 100644
index 00000000..8d1fe4f3
--- /dev/null
+++ b/docs/config_ndvi_ls_median.yaml
@@ -0,0 +1,33 @@
+plugin: odc.stats.plugins.ls_ndvi_median.StatsNDVI # import path to plugin
+plugin_config: #variables for the plugin
+ input_bands: ["nbart_red", "nbart_nir"]
+ output_bands: 'ndvi_median'
+ mask_band: "oa_fmask"
+ contiguity_band: "nbart_contiguity"
+product: #name and key metadata of the product
+ name: ls_ndvi_median
+ short_name: ls_ndvi_median
+ version: 0.0.1
+ product_family: ndvi
+ # -- EO Dataset3 relative section --
+ naming_conventions_values: dea_c3
+ explorer_path: https://explorer.dea.ga.gov.au/
+ classifier: ard
+ maturity: final
+ collection_number: 3
+
+# -parameters for k8s
+max_processing_time: 3600
+job_queue_max_lease: 3600
+renew_safety_margin: 60
+future_poll_interval: 2
+s3_acl: public-read
+
+# Generic product attributes
+cog_opts:
+ zlevel: 9
+ overrides:
+ # If you're making an RGBA image, compress better
+ rgba:
+ compress: JPEG
+ jpeg_quality: 90
diff --git a/docs/odc-stats-explained.ipynb b/docs/odc-stats-explained.ipynb
new file mode 100644
index 00000000..c36db51f
--- /dev/null
+++ b/docs/odc-stats-explained.ipynb
@@ -0,0 +1,1643 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0c2dc7f8-8b93-4468-b648-86461e3b85d3",
+ "metadata": {},
+ "source": [
+ "# Creating an odc-stats plugin; or how I learned to stop worrying and love odc-stats\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1ae174e5-e342-4000-8438-e784202f0881",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "56fb55d4-ef2b-4cbd-8b86-135fe8eb8a74",
+ "metadata": {},
+ "source": [
+ "## Background\n",
+ "\n",
+ "**ODC-Statistician** ([Open Data Cube Statistician](https://github.com/opendatacube/odc-stats)) is a framework of tools for generating statistical summaries (usually across time) of large collections of Earth Observation imagery managed in an Open Datacube Instance. \n",
+ "\n",
+ "`odc-stats` is a powerful and flexible tool for running batch processing of tiled Earth Observation summary products across many EC2 instances on a cloud compute environment. However, for an Earth Observation scientist who is more familiar with developing workflows on a single machine (think the Sandbox), it can be confusing to transition code to odc-stats. This is partly because of a lack of documentation of odc-stats functions, which requires reading source code to understand how it works, and partly because the structure and nomenclature of odc-stats differs from the usual parlance of EO scientists working within the Sandbox ecosystem. \n",
+ "\n",
+ "**Importantly**, this notebook is not intended for developers looking for instructions on how to coordinate a large scale batch run of odc-stats. Instead, its intention is to provide guidance to EO scientists on how to translate their analysis code to odc-stats. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d4483b26-f41f-49ea-a230-c6d9ca6ed0cf",
+ "metadata": {},
+ "source": [
+ "## Description\n",
+ "\n",
+ "**The aims of this notebook are two-fold**:\n",
+ "1. Demystify the use of odc-stats by demonstrating development of a minimal odc-stats \"plugin\".\n",
+ "2. Provide example code for running odc-stats functions within a local machine, thus demonstrating how to develop and test the development of an odc-stats \"plugin\".\n",
+ "\n",
+ "**Two key things are required to use odc-stats.** A `plugin`, which is essentially a python class that contains functions for summarising satellite images within an ODC environment. And a `config` file (a .yaml file) which provides arguments to the plugin. In this notebook we will systematically build these files.\n",
+ "\n",
+ "The notebook is broken up into two main sections.\n",
+ "1. Firstly, we will develop a simple odc-stats plugin, and run it _without using odc-stats_. This can be useful for testing purposes when developing a function, and it will also help us understand the transition from 'sandbox-esque' code to odc-stats code.\n",
+ "2. In the second section, we will demonstrate running the plugin using odc-stats.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ca9185bb-316b-479d-b4a9-7150de03259f",
+ "metadata": {},
+ "source": [
+ "## Import libraries "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "6539dacf-fce1-4f51-9ab1-ad29c399cc72",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "import yaml\n",
+ "import json\n",
+ "import warnings\n",
+ "import xarray as xr\n",
+ "import rioxarray as rxr\n",
+ "import geopandas as gpd\n",
+ "from pprint import pprint\n",
+ "import matplotlib.pyplot as plt\n",
+ "from odc.geo.xr import assign_crs\n",
+ "from odc.stats.tasks import TaskReader\n",
+ "from odc.stats.model import OutputProduct\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0f63dac-4aca-4141-8633-1041e64ecabf",
+ "metadata": {},
+ "source": [
+ "## Section 1: Create a plugin, run it _without_ using odc-stats"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bcd5a6bf-fb5a-4762-9d4a-e7ceefb8b38d",
+ "metadata": {},
+ "source": [
+ "### Creating an odc-stats plugin\n",
+ "\n",
+ "To begin, let's create a python `StatsPluginInterface` class function that summarises a Landsat time series of NDVI.\n",
+ "\n",
+ "The base `StatsPluginInterface` python class is described [here](https://github.com/opendatacube/odc-stats/blob/develop/odc/stats/plugins/_base.py). To define a custom plugin, we generally need to define a few key functions:\n",
+ "\n",
+ "1. `measurements`: a function that describes the output 'measurements' of the final product (AKA 'bands'). In this example, the final product will have a measurement called 'ndvi_median'\n",
+ " \n",
+ "2. `native_transform`: this function is passed to an upstream function called [odc.algo.io.load_with_native_transform](https://github.com/opendatacube/odc-algo/blob/bd2fb6828beafed60b5f58f465df8da78cb071e2/odc/algo/io.py#L157). The role of this function is to define pre-processing steps that are applied to every satellite image. This is usually used for things like masking cloud, nodata, and contiguity masking. The 'load_with_native_transform' function sits within a higher order function called [input_data](https://github.com/opendatacube/odc-stats/blob/7f34c86bdbd481340c41b5be7e0d0873ce3b3e1c/odc/stats/plugins/_base.py#L65) (which itself is within the `StatsPluginInterface` class). For relatively standard odc-stats operations where the main tasks are loading, masking, and summarising a time series of satellite images, defining a \"native_transform\" function for masking is all that's required (and this is passed to \"input_data\"). However, for more flexibility, we can define our own custom \"input_data\" function and odc-stats will run this instead. For example, see [this plugin](https://github.com/opendatacube/odc-stats/blob/develop/odc/stats/plugins/lc_ml_treelite.py) that runs a machine learning prediction. \n",
+ "\n",
+ "3. `reduce`: This function describes how we summarise a time series to a single image. For example, by taking a temporal median. However, this function can be highly flexible. For example, we could load a machine learning model in this step to classify data. We could even load other ancillary datasets if needed.\n",
+ "\n",
+ "\n",
+ "Now, lets create a simple `StatsPlugin` class that, when provided with a series of DEA Landsat images, will mask for clouds and bad data, calculate NDVI, and then 'reduce' the time series using a temporal median."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "4b0fa3ad-bce2-43c6-8c0e-1147462bad1f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#masking functions\n",
+ "from typing import Optional, Sequence, Tuple\n",
+ "from datacube.utils.masking import mask_invalid_data\n",
+ "from odc.algo._masking import (\n",
+ " enum_to_bool,\n",
+ " mask_cleanup,\n",
+ " erase_bad\n",
+ ")\n",
+ "#odc-stats functions for registering a plugin\n",
+ "from odc.stats.plugins._registry import register, StatsPluginInterface\n",
+ "\n",
+ "class StatsNDVI(StatsPluginInterface):\n",
+ " \"\"\"\n",
+ " Define a class for summarising time \n",
+ " series of NDVI using the median.\n",
+ " \"\"\"\n",
+ " \n",
+ " NAME = \"ndvi_median\"\n",
+ " SHORT_NAME = NAME\n",
+ " VERSION = \"1.0\"\n",
+ " PRODUCT_FAMILY = \"ndvi\"\n",
+ "\n",
+ " def __init__(\n",
+ " self,\n",
+ " input_bands: Sequence[str] = None,\n",
+ " output_bands: Sequence[str] = None,\n",
+ " mask_band: Sequence[str] = None,\n",
+ " contiguity_band: Sequence[str] = None,\n",
+ " group_by: str = \"solar_day\",\n",
+ " **kwargs,\n",
+ " ):\n",
+ " \n",
+ " self.input_bands = input_bands\n",
+ " self.output_bands = output_bands\n",
+ " self.mask_band = mask_band\n",
+ " self.contiguity_band = contiguity_band\n",
+ " self.group_by = group_by\n",
+ "\n",
+ " ## These params get passed to the upstream \n",
+ " # base StatsPluginInterface class\n",
+ " super().__init__(\n",
+ " input_bands=tuple(input_bands)+(mask_band,)+(contiguity_band,),\n",
+ " **kwargs\n",
+ " )\n",
+ "\n",
+ " \n",
+ " @property\n",
+ " def measurements(self) -> Tuple[str, ...]:\n",
+ " \"\"\"\n",
+ " Here we define the output bands, in this example we\n",
+ " will pass the names of the output bands into the config file,\n",
+ " but equally we could define the outputs names within this function.\n",
+ " For example, by adding a suffix to the input bands.\n",
+ " \"\"\"\n",
+ " \n",
+ " return self.output_bands\n",
+ "\n",
+ " def native_transform(self, xx):\n",
+ " \"\"\"\n",
+ " This function is passed to an upstream function\n",
+ " called \"odc.algo.io.load_with_native_transform\".\n",
+ " The function decribed here is applied on every time\n",
+ " step of data and is usually used for things like\n",
+ " masking clouds, nodata, and contiguity masking.\n",
+ " \"\"\"\n",
+ " #grab the QA band from the Landsat data\n",
+ " mask = xx[self.mask_band]\n",
+ "\n",
+ " # create boolean arrays from the mask for cloud\n",
+ " # and cloud shadows, and nodata\n",
+ " bad = enum_to_bool(mask, (\"nodata\",))\n",
+ " non_contiguent = xx.get(self.contiguity_band, 1) == 0\n",
+ " bad = bad | non_contiguent\n",
+ " \n",
+ " cloud_mask = enum_to_bool(mask, (\"cloud\", \"shadow\"))\n",
+ " bad = cloud_mask | bad\n",
+ "\n",
+ " # drop masking bands\n",
+ " xx = xx.drop_vars([self.mask_band] + [self.contiguity_band])\n",
+ " \n",
+ " ## Mask the bad data (clouds etc)\n",
+ " xx = erase_bad(xx, bad)\n",
+ "\n",
+ " return xx\n",
+ "\n",
+ " def reduce(self, xx: xr.Dataset) -> xr.Dataset:\n",
+ " \"\"\"\n",
+ " Calculate NDVI and summarise time series with a median.\n",
+ " \"\"\"\n",
+ " # convert to float and convert nodata to NaN so NDVI\n",
+ " # isn't calculated on the nodata integer values\n",
+ " xx = mask_invalid_data(xx)\n",
+ " \n",
+ " # Calculate NDVI\n",
+ " ndvi = (xx['nbart_nir'] - xx['nbart_red']) / (xx['nbart_nir'] + xx['nbart_red'])\n",
+ "\n",
+ " # calculate temporal median NDVI. \n",
+ " # -------------------------------\n",
+ " # Note that we use 'spec' here and not 'time', this is an odc-stats thing\n",
+ " # where the dimensions are labelled as spec, x, and y.\n",
+ " # -------------------------------\n",
+ " ndvi = ndvi.median('spec').rename(self.output_bands)\n",
+ " \n",
+ " return ndvi.to_dataset()\n",
+ "\n",
+ "# now lets 'register' the function with odc-stats\n",
+ "register(\"NDVI-median\", StatsNDVI)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "66b92667-3c34-47dc-92d7-f35d8a79523b",
+ "metadata": {},
+ "source": [
+ "### Create a config\n",
+ "\n",
+ "We need to create a config to describe the input parameters for the plugin, for now, we will create a dictionary. However, when it comes time to run the function with odc-stats, this is usually stored in a .yaml file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "cc3d8a69-34fb-496f-b03f-787e2be92023",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "config = dict(\n",
+ " input_bands=[\"nbart_red\", \"nbart_nir\"],\n",
+ " output_bands = 'ndvi_median',\n",
+ " mask_band=\"oa_fmask\",\n",
+ " contiguity_band='oa_nbart_contiguity'\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d7c53942-2d51-4194-8be0-9131dacea928",
+ "metadata": {},
+ "source": [
+ "### Run the plugin code\n",
+ "\n",
+ "To test our plugin, we will load datasets in a way that's more familiar to those used to working on the Sandbox. These steps mimic the inputs that odc-stats expects, but we load them in a more 'conventional' way than odc-stats (more on this in the next section).\n",
+ "\n",
+ "Below we define an analysis area, and set up a ODC query. Then we load a list of datasets and the geobox that describes the geographical extent of the datasets."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2649cf3d-3584-4acb-bf35-5666cfb40ea1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import datacube\n",
+ "dc = datacube.Datacube(app=\"odc-stats example\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "c3b41a6d-1138-4e78-8c5e-33cd6f115e1b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Number of datasets: 23\n"
+ ]
+ }
+ ],
+ "source": [
+ "#analysis params\n",
+ "lat, lon = -34.134, 140.747\n",
+ "buffer = 0.05\n",
+ "time_range = ('2024')\n",
+ "resolution = (-30, 30)\n",
+ "\n",
+ "lat_range = (lat-buffer, lat+buffer)\n",
+ "lon_range = (lon-buffer, lon+buffer)\n",
+ "\n",
+ "#set up query object\n",
+ "query = {\n",
+ " 'x': lon_range,\n",
+ " 'y': lat_range,\n",
+ " 'time': time_range,\n",
+ " 'resolution': resolution,\n",
+ " 'output_crs':'epsg:3577',\n",
+ " 'measurements':['nbart_red','nbart_nir','oa_fmask']\n",
+ "}\n",
+ "\n",
+ "# load some data, but we'll just extract the geobox parameter\n",
+ "# because 'input_data' expects a geobox\n",
+ "gbox = dc.load(product=['ga_ls8c_ard_3'], dask_chunks={}, **query).geobox\n",
+ "\n",
+ "# load a list of datatsets to mimic odc-stats cached \".db\" files\n",
+ "dss = dc.find_datasets(product=['ga_ls8c_ard_3'], **query)\n",
+ "\n",
+ "print('Number of datasets:', len(dss))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64ba8eab-04a8-48d1-bb38-33dea1474fdd",
+ "metadata": {},
+ "source": [
+ "### Run the plugin functions\n",
+ "\n",
+ "These are evaluated 'lazily' with dask, so will evaluate quickly. Once we run `.load()` below, the functions will be executed and the result will be brought into memory."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "4ff33ab5-e8f4-47c8-9c17-2f222d00d658",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
PROJCS["GDA94 / Australian Albers",GEOGCS["GDA94",DATUM["Geocentric_Datum_of_Australia_1994",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6283"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4283"]],PROJECTION["Albers_Conic_Equal_Area"],PARAMETER["latitude_of_center",0],PARAMETER["longitude_of_center",132],PARAMETER["standard_parallel_1",-18],PARAMETER["standard_parallel_2",-36],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","3577"]]
PROJCS["GDA94 / Australian Albers",GEOGCS["GDA94",DATUM["Geocentric_Datum_of_Australia_1994",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6283"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4283"]],PROJECTION["Albers_Conic_Equal_Area"],PARAMETER["latitude_of_center",0],PARAMETER["longitude_of_center",132],PARAMETER["standard_parallel_1",-18],PARAMETER["standard_parallel_2",-36],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","3577"]]
PROJCS["GDA94 / Australian Albers",GEOGCS["GDA94",DATUM["Geocentric_Datum_of_Australia_1994",SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6283"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4283"]],PROJECTION["Albers_Conic_Equal_Area"],PARAMETER["latitude_of_center",0],PARAMETER["longitude_of_center",132],PARAMETER["standard_parallel_1",-18],PARAMETER["standard_parallel_2",-36],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","3577"]]
"
+ ],
+ "text/plain": [
+ " Size: 525kB\n",
+ "Dimensions: (y: 392, x: 331)\n",
+ "Coordinates:\n",
+ " * y (y) float64 3kB -3.747e+06 -3.747e+06 ... -3.759e+06 -3.759e+06\n",
+ " * x (x) float64 3kB 7.973e+05 7.973e+05 ... 8.072e+05 8.072e+05\n",
+ " spatial_ref int32 4B 3577\n",
+ "Data variables:\n",
+ " ndvi_median (y, x) float32 519kB dask.array"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#call the function\n",
+ "func=StatsNDVI(**config)\n",
+ "\n",
+ "# run the separate functions\n",
+ "ndvi = func.input_data(datasets=dss, geobox=gbox)\n",
+ "\n",
+ "result = func.reduce(ndvi)\n",
+ "result"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1c8edbb2-5d61-4544-b012-70557385f27d",
+ "metadata": {},
+ "source": [
+ "### Bring into memory and plot\n",
+ "\n",
+ "This will take about 20 seconds to load with the default example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "34ca5348-aba8-44a1-9a4a-022e6132734c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "result.load()\n",
+ "\n",
+ "result['ndvi_median'].plot(vmin=0, vmax=0.7, size=5, add_labels=False)\n",
+ "plt.title('Annual Median NDVI');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "60a27528-930b-4cc3-97bf-087c9e50e87e",
+ "metadata": {},
+ "source": [
+ "## Section 2: Run the plugin using odc-stats\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a6b75dfd-e39b-4a53-8e8e-aa69004ee47d",
+ "metadata": {},
+ "source": [
+ "### Saving tasks\n",
+ "Before we can run a plugin with odc-stats, we need to extract datasets. In the sandbox (or a local machine), we would ordinarily do this by running [datacube.load](https://opendatacube.readthedocs.io/en/latest/api/indexed-data/generate/datacube.Datacube.load.html) (or sometimes `dea_tools.load_ard`). However, odc-stats works instead by caching a copy of the database to disk, thus providing a list of 'tasks' for odc-stats to run. This is achieved with the function [odc-stats save-tasks](https://github.com/opendatacube/odc-stats/blob/develop/odc/stats/_cli_save_tasks.py). When run, this function will output three files:\n",
+ "1. A .csv file listing all tasks for all the years in the database e.g., `ga_ls8c_ard_3_2017--P1Y.csv`\n",
+ "2. A database cache file used by statistician when running jobs, e.g. `ga_ls8c_ard_3_2017--P1Y.db`\n",
+ "3. A GeoJSON file per year, for visualising the prospective run e.g. `ga_ls8c_ard_3_2017--P1Y.geojson`\n",
+ "\n",
+ "The [save-tasks](https://github.com/opendatacube/odc-stats/blob/develop/odc/stats/_cli_save_tasks.py) function has a number of parameters that can be passed. Below we outline an example, and then list the main parameters.\n",
+ "\n",
+ "For example:\n",
+ "\n",
+ " odc-stats save-tasks --frequency annual --grid au-extended-30 --year 2017 --input-products ga_ls8c_ard_3\n",
+ "\n",
+ "This would save tasks for all the Landsat 8 satellite imagery across Australia for the year 2017, on a 30m grid. `save-tasks` is quite flexible, so we can adjust these parameters to suit the kinds of product we're building: \n",
+ "* **--input-products**: If, for example, we wanted to cache datasets from both Landsat 8 and Landsat 9, we can update the input-products parameter to read `ga_ls8c_ard_3-ga_ls9c_ard_3`, or in the case of sentinel-2, this could be `ga_s2am_ard_3-ga_s2bm_ard_3-ga_s2cm_ard_3`. In other cases, we may want to 'fuse' datasets where products require data from bands stored in multiple products. Products can be fused to use bands from both products in the derivative products, this creates a virtual product that contains the bands from both products. Note that for datasets to be fused they must have the same `center_time` and `region_code`. This process finds the matching dataset from each product that are in the same time and place and fuses them into one product. An example of this is fc-percentiles, which uses the fractional cover bands in `ga_ls_fc_3` to calculate the percentiles, and uses the `ga_ls_wo_3` band to mask out bad data. The input-products parameter in this case looks like this: `ga_ls_fc_3+ga_ls_wo_3`.\n",
+ "\n",
+ "* **--frequency**: This determines the temporal binning of datasets. For example, for 3-month rolling we would use: `rolling-3months`. A list of supported values is [here](https://github.com/opendatacube/odc-stats/blob/7f34c86bdbd481340c41b5be7e0d0873ce3b3e1c/odc/stats/_cli_save_tasks.py#L24)\n",
+ "* **--temporal-range**: Only extract datasets for a given time range. e.g. `2020-05--P1M` for the month of May in 2020, or `2017--P1Y`, will extract one years worth of data for 2017.\n",
+ "* **--grid**: The spatial resolution and grid to use. For Australia this is `au_extended` plus a resolution, one of: `{10|20|30}`. e.g. for Sentinel-2 we would use `au_extended_10`, and for Landsat we would use `au_extended_30`.\n",
+ "* **--gqa**: Only save datasets that pass `gqa_iterative_mean_xy <= gqa` test.\n",
+ "* **--dataset-filter**: We can use this to filter based on metadata, for example: `{\"dataset_maturity\": \"final\"}`\n",
+ "* **--year**: Use this flag as a shortcut for `--temporal-range=--P1Y`, it will extract tasks for a single calendar year.\n",
+ "\n",
+ "***\n",
+ "### Running save-tasks\n",
+ "\n",
+ "Let's run save-tasks in a way that mimics the datasets loading we did in Section 1. The `!` will instruct the notebook to run this on the command line; odc-stats is built to run through a command line interface. You could also trigger this by wrapping the command in `os.system('odc-stats save-tasks ...')`.\n",
+ "\n",
+ "Note that this command will output datasets for all tiles in Australia. In the next step we will index the list of tiles so we only run one tile for testing. Equally, we could have passed to save-tasks `--tiles ` and it would only export datasets for a single tile or a list of tiles. We would need to know the index of the tile though for this to work.\n",
+ "\n",
+ "Remember, this will output three files: a `.db` file, a `.geosjson`, and a `.csv`\n",
+ "\n",
+ "This will take about 30 seconds to run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "29e408fe-8f46-4bb6-9f69-30a351083170",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "config from yaml {} None\n",
+ "[2025-06-30 23:19:17,916] {_cli_save_tasks.py:187} INFO - Config overrides: {'grid': 'au-extended-30', 'frequency': 'annual', 'input_products': 'ga_ls8c_ard_3'}\n",
+ "[2025-06-30 23:19:17,916] {_cli_save_tasks.py:190} INFO - Using config: {'grid': 'au-extended-30', 'frequency': 'annual', 'input_products': 'ga_ls8c_ard_3', 'complevel': 6}\n",
+ "Connecting to the database, streaming datasets\n",
+ "/env/lib/python3.10/site-packages/odc/dscache/tools/_index.py:63: FutureWarning: 'y' is deprecated and will be removed in a future version, please use 'Y' instead.\n",
+ " t = Period(begin, freq)\n",
+ "Training compression dictionary\n",
+ ".. done\n",
+ "Count: 10,494\n",
+ " 551.5 per second\n",
+ "Total: 19.029 sec\n",
+ "TTFB : 0.102 sec\n",
+ ".....: 25219641F1840CD41A5DB91805512BC5\n",
+ "..\n",
+ "Total of 1,465 spatial tiles\n",
+ "Total of 10,458 unique dataset IDs after filtering\n",
+ "Saving tasks to disk (1465)\n",
+ ".. done\n",
+ "Writing summary to ga_ls8c_ard_3_2024--P1Y.csv\n",
+ "Dumping GeoJSON(s)\n",
+ "..writing to ga_ls8c_ard_3_2024--P1Y-2024--P1Y.geojson\n",
+ "\u001b[0m"
+ ]
+ }
+ ],
+ "source": [
+ "!odc-stats save-tasks --frequency annual --grid au-extended-30 --temporal-range 2024--P1Y --input-products ga_ls8c_ard_3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd0d60fa-f8df-49ad-b3c3-a5a7c7895f5a",
+ "metadata": {},
+ "source": [
+ "### Find a tile to run\n",
+ "\n",
+ "Use the interactive map below to find a \"region_code\" to run (hover over a tile). Add the region_code numbers (e.g. `t = 36,17` if the region_code is 'x36y17') to the cell below the interactive map."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "9fc87a31-f778-47ae-b59b-197bcfc4193b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
Make this Notebook Trusted to load map: File -> Trust Notebook
"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gdf = gpd.read_file('ga_ls8c_ard_3_2024--P1Y-2024--P1Y.geojson')\n",
+ "\n",
+ "gdf.explore()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ff9f5fd-4de3-4d82-bdb7-c78c8ac046d2",
+ "metadata": {},
+ "source": [
+ "### Running ODC-Statistician\n",
+ "\n",
+ "First, set up a few parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "537e4888-31c7-4c54-a03e-d54eee27cbef",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "t = 54,32 # tile id to run i.e. x36y17\n",
+ "resolution = 60 # can coarsen resolution to run to speed up testing\n",
+ "results = 'results/' # where are we outputting resulting geotiffs? This could equally be an s3 path.\n",
+ "name, version = 'ls_ndvi_median', '0-0-1' # product name and version (appended to results path)\n",
+ "\n",
+ "# Dask client parameters\n",
+ "ncpus=7 #how many cpus to run on?\n",
+ "mem='60Gi' # How much memory?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5169d15f-1204-4261-8d9d-6abc073471a5",
+ "metadata": {},
+ "source": [
+ "#### Find the tile index to run\n",
+ "\n",
+ "We selected a region code, but the odc-stats \"run\" command expects a zero-based index to determine which tile to run. Below we open the cached task database and find the index of the tile we want run. We'll pass this index to odc-stats next."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "6cbf6e78-f305-42ce-9f75-a314606e6368",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Tile index = 847\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Open the task database to find our tile, we need to create the OutputProduct class\n",
+ "# to open the taskdb but it doesn't do anything.\n",
+ "op = OutputProduct(\n",
+ " name=name,\n",
+ " version=version,\n",
+ " short_name=name,\n",
+ " location=f\"s3://dummy-bucket/{name}/{version}\", #this is a fake path\n",
+ " properties={\"odc:file_format\": \"GeoTIFF\"},\n",
+ " measurements=['nbart_red'], #any measurements, doesn't matter.\n",
+ " )\n",
+ "\n",
+ "taskdb = TaskReader(f'ga_ls8c_ard_3_2024--P1Y.db', product=op)\n",
+ "\n",
+ "#select our individual task i.e. our tile\n",
+ "task = taskdb.load_task((f'2024--P1Y', t[0], t[1]))\n",
+ "\n",
+ "# Now find index of the tile we want to run\n",
+ "# We'll pass this index to odc-stats next\n",
+ "tile_index_to_run = []\n",
+ "all_tiles = list(taskdb.all_tiles)\n",
+ "for i, index in zip(all_tiles, range(0, len(all_tiles))):\n",
+ " if (i[1]==t[0]) & (i[2]==t[1]):\n",
+ " tile_index_to_run.append(index)\n",
+ " print('Tile index =', index)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b546fa85-deba-4fcd-9b65-4ec3a1ac1732",
+ "metadata": {},
+ "source": [
+ "#### Optionally view tile to check location\n",
+ "\n",
+ "The next cell will plot the tile extent on an interactive map so you can ensure its the tile you want to run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "c84262d7-8e84-4859-abbf-e1935f9ab733",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
Make this Notebook Trusted to load map: File -> Trust Notebook
"
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "gdf = gpd.GeoDataFrame(index=[0], crs='epsg:4326', geometry=[task.geobox.extent.to_crs('epsg:4326').geom])\n",
+ "gdf.explore()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3d10a354-8256-4645-b9be-4c9ea92a750f",
+ "metadata": {},
+ "source": [
+ "#### Running the plugin using odc-stats\n",
+ "\n",
+ "This is where it get's a little complicated. In order for `odc-stats` to 'see' a custom plugin, we need to put our plugin within an **installable python module** (note that [plugins](https://github.com/opendatacube/odc-stats/tree/develop/odc/stats/plugins) that are already within the odc-stats repository are available to use by default; in this case the plugin has been merged into the odc-stats repo as an example so its available by default). Similarly, we need to put our **configuration parameters into an external .yaml file**. \n",
+ "\n",
+ "This has been done (its called `config_ndvi_ls_mean.yaml`), and below we open the config yaml to view its contents:\n",
+ "\n",
+ "The important parts are:\n",
+ "* `plugin`: an import path to the installed python plugin\n",
+ "* `plugin_config`: The parameters names and values that are passed to the plugin\n",
+ "* `product`: These are key metadata fields for the product you're building\n",
+ "\n",
+ "The other parameters relate to batch runs on kubernetes, and the exported COG attributes such as compression levels etc. These fields can usually be copied over from other similar product configs, such as this example for [Landsat geomedian](https://github.com/GeoscienceAustralia/dea-config/blob/3953ea18eee702a41867458c720e7480bd785c10/prod/services/odc-stats/geomedian/ga_ls8cls9c_gm_cyear_3.yaml). "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "3c3c53f4-9d8a-4e25-9490-8b057f165b04",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'cog_opts': {'overrides': {'rgba': {'compress': 'JPEG', 'jpeg_quality': 90}},\n",
+ " 'zlevel': 9},\n",
+ " 'future_poll_interval': 2,\n",
+ " 'job_queue_max_lease': 3600,\n",
+ " 'max_processing_time': 3600,\n",
+ " 'plugin': 'odc.stats.plugins.ls_ndvi_median.StatsNDVI',\n",
+ " 'plugin_config': {'contiguity_band': 'nbart_contiguity',\n",
+ " 'input_bands': ['nbart_red', 'nbart_nir'],\n",
+ " 'mask_band': 'oa_fmask',\n",
+ " 'output_bands': 'ndvi_median'},\n",
+ " 'product': {'classifier': 'ard',\n",
+ " 'collection_number': 3,\n",
+ " 'explorer_path': 'https://explorer.dea.ga.gov.au/',\n",
+ " 'maturity': 'final',\n",
+ " 'name': 'ls_ndvi_median',\n",
+ " 'naming_conventions_values': 'dea_c3',\n",
+ " 'product_family': 'ndvi',\n",
+ " 'short_name': 'ls_ndvi_median',\n",
+ " 'version': '0.0.1'},\n",
+ " 'renew_safety_margin': 60,\n",
+ " 's3_acl': 'public-read'}\n"
+ ]
+ }
+ ],
+ "source": [
+ "yaml_path= 'config_ndvi_ls_median.yaml'\n",
+ "\n",
+ "with open(yaml_path, 'r') as file:\n",
+ " data = yaml.safe_load(file)\n",
+ "\n",
+ "pprint(data)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1e000559-1794-49d7-83fb-0373a4605770",
+ "metadata": {},
+ "source": [
+ "#### Run odc-stats\n",
+ "\n",
+ "We will use `os.system('odc-stats run ...')` to call the command 'odc-stats run' so we can pass in variables defined earlier as python objects.\n",
+ "\n",
+ "\"odc-stats run\" has a number of parameters, some of which are described here. The key information to pass in is the name of the cached database file, the location of the config file, the output location, and the tile index to run.\n",
+ "\n",
+ "* **--filedb**: The name of the .db output by save-task e.g. \"ga_ls8c_ard_3_2024--P1Y.db\"\n",
+ "* **--config**: Path to the config for plugin in yaml format\n",
+ "* **--location**: Output location prefix as a uri or local file path: `s3://bucket/path/`\n",
+ "* **--resolution**: Override output resolution, use this to speed up testing, e.g. '60'\n",
+ "* **--threads**: Number of worker threads for the dask cluster, as an integer\n",
+ "* **--memory-limit**: Limit memory used by Dask cluster, e.g. '100Gi'\n",
+ "\n",
+ "To view the progress of odc-stats, view the **dask dashboard**. Alter the email address to yours and use this link: \n",
+ "\n",
+ "https://app.sandbox.dea.ga.gov.au/user/chad.burton@ga.gov.au/proxy/8787/status"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "7d988b07-8ae9-4bb6-8d93-6b3228a1587b",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2025-06-30 23:19:52,951] {_cli_run.py:168} INFO - Config overrides: {'filedb': 'ga_ls8c_ard_3_2024--P1Y.db', 'threads': 7, 'memory_limit': '60Gi', 'output_location': 'file:///home/jovyan/results/ls_ndvi_median/0-0-1'}\n",
+ "[2025-06-30 23:19:52,952] {_cli_run.py:200} INFO - Using this config: TaskRunnerConfig(filedb='ga_ls8c_ard_3_2024--P1Y.db', aws_unsigned=True, plugin='odc.stats.plugins.ls_ndvi_median.StatsNDVI', plugin_config={'input_bands': ['nbart_red', 'nbart_nir'], 'output_bands': 'ndvi_median', 'mask_band': 'oa_fmask', 'contiguity_band': 'nbart_contiguity'}, product={'name': 'ls_ndvi_median', 'short_name': 'ls_ndvi_median', 'version': '0.0.1', 'product_family': 'ndvi', 'naming_conventions_values': 'dea_c3', 'explorer_path': 'https://explorer.dea.ga.gov.au/', 'classifier': 'ard', 'maturity': 'final', 'collection_number': 3}, threads=7, memory_limit='60Gi', output_location='file:///home/jovyan/results/ls_ndvi_median/0-0-1', s3_acl='public-read', s3_public=False, cog_opts={'compress': 'deflate', 'zlevel': 9, 'blocksize': 800, 'ovr_blocksize': 256, 'overview_resampling': 'average', 'overrides': {'rgba': {'compress': 'JPEG', 'jpeg_quality': 90}}}, overwrite=False, heartbeat_filepath=None, max_processing_time=3600, job_queue_max_lease=3600, renew_safety_margin=60, future_poll_interval=2)\n",
+ "[2025-06-30 23:19:53,091] {proc.py:55} INFO - Resolving plugin: odc.stats.plugins.ls_ndvi_median.StatsNDVI\n",
+ "[2025-06-30 23:19:53,092] {proc.py:61} INFO - Output product: OutputProduct(name='ls_ndvi_median', version='0.0.1', short_name='ls_ndvi_median', location='file:///home/jovyan/results/ls_ndvi_median/0-0-1', properties={'odc:file_format': 'GeoTIFF', 'odc:product_family': 'ndvi', 'odc:producer': 'ga.gov.au'}, measurements=('ndvi_median',), href='https://collections.dea.ga.gov.au/product/ls_ndvi_median', region_code_format='x{x:02d}y{y:02d}', cfg=None, naming_conventions_values='dea_c3', explorer_path='https://explorer.dea.ga.gov.au/', inherit_skip_properties=None, preview_image_ows_style=None, classifier='ard', maturity='final', collection_number=3, nodata=None)\n",
+ "[2025-06-30 23:19:53,093] {proc.py:64} INFO - Constructing task reader: ga_ls8c_ard_3_2024--P1Y.db\n",
+ "[2025-06-30 23:19:53,165] {proc.py:66} INFO - Will read from grid:au-extended-30 n:1,465\n",
+ "[2025-06-30 23:19:53,166] {proc.py:68} INFO - Changing resolution to -60.0, 60.0\n",
+ "[2025-06-30 23:19:53,166] {proc.py:309} INFO - Starting processing from task list\n",
+ "[2025-06-30 23:19:53,986] {proc.py:116} INFO - Started local Dask \n",
+ "[2025-06-30 23:19:53,997] {proc.py:219} INFO - Starting processing of x54/y32/2024--P1Y\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ ":6: UserWarning: Converting non-nanosecond precision datetime values to nanosecond precision. This behavior can eventually be relaxed in xarray, as it is an artifact from pandas which is now beginning to support non-nanosecond precision values. This warning is caused by passing non-nanosecond np.datetime64 or np.timedelta64 values to the DataArray or Variable constructor; it can be silenced by converting the values to nanosecond precision ahead of time.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2025-06-30 23:20:20,815] {proc.py:287} INFO - Finished processing of x54/y32/2024--P1Y\n",
+ "[2025-06-30 23:20:20,816] {_cli_run.py:242} INFO - Finished task #1: x54/y32/2024--P1Y 1d054d39-8af3-5f4e-9053-87fe65667a4f\n",
+ "[2025-06-30 23:20:20,816] {_cli_run.py:247} INFO - T:1, OK:1, S:0, E:0\n",
+ "[2025-06-30 23:20:20,816] {_cli_run.py:249} INFO - Completed processing 1 tasks, OK:1,\n",
+ " S:0, E:0\n",
+ "[2025-06-30 23:20:20,816] {_cli_run.py:254} INFO - Shutting down Dask cluster\n",
+ "[2025-06-30 23:20:20,860] {_cli_run.py:260} INFO - Calling sys.exit(0)\n",
+ "CPU times: user 8.36 ms, sys: 0 ns, total: 8.36 ms\n",
+ "Wall time: 30.8 s\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "0"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "%%time\n",
+ "os.system(\"odc-stats run \"\\\n",
+ " f\"ga_ls8c_ard_3_2024--P1Y.db \"\\\n",
+ " f\"--config={yaml_path} \"\\\n",
+ " f\"--resolution={resolution} \"\\\n",
+ " f\"--threads={ncpus} \"\\\n",
+ " f\"--memory-limit={mem} \"\\\n",
+ " f\"--location=file:///home/jovyan/{results}{name}/{version} \" +str(tile_index_to_run[0])\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c0f4565-c92b-43ae-ac91-a4b9dc0f29da",
+ "metadata": {},
+ "source": [
+ "### Plot the results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "f3e6046e-2332-4e8d-b1e2-6a1bdffbe64d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAukAAAJbCAYAAABZxgp1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5idVbX/P/ttp0+flEmvJJBQQk0QRSkKiIoVK2Ln5/XaRS8qtosgNq5IUekCCshVwQYiTQKEAFICIb1NJpk+c/p5y/79sfd+34ngFb0oeDnreeZJ5sx7znnLLmt913d9l5BSSprWtKY1rWlNa1rTmta0pr1gzHq+T6BpTWta05rWtKY1rWlNa9qe1nTSm9a0pjWtaU1rWtOa1rQXmDWd9KY1rWlNa1rTmta0pjXtBWZNJ71pTWta05rWtKY1rWlNe4FZ00lvWtOa1rSmNa1pTWta015g1nTSm9a0pjWtaU1rWtOa1rQXmDWd9KY1rWlNa1rTmta0pjXtBWZNJ71pTWta05rWtKY1rWlNe4FZ00lvWtOa1rSmNa1pTWta015g1nTSm9a0pv3N9l//9V8IIViyZMnzfSr/K7vjjjsQQnDHHXc8q+OEEFx++eXPeMwrXvEKhBDMnj37OT3HI488kiOPPDL+fcuWLf/jefwj7fLLL0cIQTqdZuvWrU/7+5FHHvm0MTF79uz43lmWRWtrK4sXL+Zd73oXt9xyyx7HfvzjH0cIwdq1a//iOZxxxhkIIXjooYfiz3/1q1/9HFxd05rWtKa9sKzppDetaU37m+3SSy8FYM2aNdx///3P89n886xQKHDJJZc87fXNmzdzxx130NLS8g8/h6lTp3Lvvfdywgkn/MO/6y9ZvV7n85///LM+/vDDD+fee+9l5cqV/OxnP+Pf/u3f2Lx5M6985St54xvfiO/7ALz3ve8FkvH15xZFEVdeeSX7778/y5Yt+99fSNOa1rSmvYCt6aQ3rWlN+5ts9erVPPLII7GT+ExO6/9Ve8tb3sIf//hH1q9fv8frl156KdOmTePwww//h59DKpXisMMOo7u7+x/+XX/JXvWqV3HNNdfwyCOPPKvj29raOOywwzjssMM4+uij+fCHP8zdd9/NmWeeyc9+9rPY4V+yZAmHHHIIV111FUEQPO1zbrnlFnbs2BE7801rWtOa9n/Zmk5605rWtL/JjFN+9tlns2LFCn7yk59QqVT2OMZQMr75zW/y7W9/mzlz5pDP51m+fDn33XffHse++93vJp/Ps2HDBo4//njy+TwzZszgk5/8JPV6PT7uL1FTnon+sXr1ak4++WRmz55NJpNh9uzZvPWtb31GisbfYscccwwzZszYA+mNoogrrriCU045Bct6+pIqpeSCCy5g//33J5PJ0N7ezhvf+EY2bdr0tOO+8Y1vMGvWLNLpNMuWLeM3v/nN0z7vma53w4YNnHrqqSxYsIBsNsu0adM48cQTeeyxx/Z4r7mH1157LWeccQY9PT20tLRw9NFH89RTTz3r+/CZz3yGzs5OTj/99Gf9nmeyL33pS+yzzz6cf/751Go1QKHpu3btesZrv+yyy0ilUrz97W//X31v05rWtKb9K1jTSW9a05r2rK1arXLttddy8MEHs2TJEt7znvdQLBa5/vrrn/H473//+9x6661897vf5eqrr6ZcLnP88cczNja2x3G+7/Oa17yGo446il/84he85z3v4Tvf+Q7nnHPO33WeW7ZsYa+99uK73/0uv/vd7zjnnHPo6+vj4IMPZnBw8O/6TADLsnj3u9/NlVdeSRiGQILunnrqqc/4ng9+8IN87GMf4+ijj+bnP/85F1xwAWvWrGHFihXs3r07Pu7LX/4yp59+Oscccww///nPOe2003j/+9//rJznnTt30tnZydlnn81vf/tbvv/97+M4Doceeugzvv8//uM/2Lp1Kz/60Y/4wQ9+wPr16znxxBPja/prVigU+PznP8/vfvc7/vCHPzyr9/wlO/HEE6lUKqxevRqAt771rWSz2adRXkZGRvjFL37BSSedRHt7+//qO5vWtKY17V/CZNOa1rSmPUu78sorJSAvuugiKaWUxWJR5vN5ecQRR+xx3ObNmyUgly5dKoMgiF9ftWqVBOS1114bv3bKKadIQF533XV7fMbxxx8v99prr/j322+/XQLy9ttvf8bvuuyyy/7ieQdBIEulkszlcvK88877q5/552aOu/766+WmTZukEELefPPNUkop3/SmN8kjjzxSSinlCSecIGfNmhW/795775WA/Na3vrXH523fvl1mMhn5mc98Rkop5cjIiEyn0/Kkk07a47h77rlHAvJlL3vZ33y9jUZDLliwQH784x9/2nUcf/zxexx/3XXXSUDee++9/+N9uOyyyyQgH3jgAVmv1+XcuXPlQQcdJKMoklJK+bKXvUzus88+e7xn1qxZ8oQTTviLn3nhhRdKQP70pz+NXzvllFOk67py9+7d8Wvf+973JCBvvfXWv+nzm9a0pjXtX9Ve9Ej6XXfdxYknnkhPTw9CCH7+85//zZ8hpeSb3/wmCxcuJJVKMWPGDM4666zn/mSb1rTn2S655BIymQwnn3wyAPl8nje96U3cfffdT+NpA5xwwgnYth3/vu+++wI8jXYihODEE0/c47V9993376anlEolTj/9dObPn4/jODiOQz6fp1wu8+STT/5dn2lszpw5HHnkkVx66aUMDQ3FyP8z2c0334wQgne84x0EQRD/TJkyhf322y+m7tx7773UarWn0ThWrFjBrFmz/uo5BUHAWWedxd57743neTiOg+d5rF+//hmv9zWvec0ev/+l5/I/med5fO1rX2P16tVcd911z/p9f25Syqe99t73vhff97nqqqvi1y677DJmzZrFUUcd9Xd/V9Oa1rSm/SvZi95JL5fL7Lfffpx//vl/92d89KMf5Uc/+hHf/OY3Wbt2LTfddBOHHHLIc3iWTWva828bNmzgrrvu4oQTTkBKyejoKKOjo7zxjW8EnlmRo7Ozc4/fU6kUoGgzEy2bzZJOp592rOEp/632tre9jfPPP5/3ve99/O53v2PVqlU88MADdHd3P+27/x5773vfy0033cS3v/1tMplMfA/+3Hbv3o2UksmTJ+O67h4/9913X0y9GRoaAmDKlClP+4xneu3P7ROf+ARf+MIXeN3rXsdNN93E/fffzwMPPMB+++33jNf7bJ/LX7OTTz6ZZcuWccYZZ8QKLX+rmcCgp6cnfu2II45g4cKFXHbZZQA8+uijPPTQQ5x66qkIIf6u72la05rWtH81c57vE3i+7bjjjuO44477i39vNBp8/vOf5+qrr2Z0dJQlS5ZwzjnnxLrFTz75JBdeeCGPP/44e+211z/prJvWtH++XXrppUgpueGGG7jhhhue9vcrrriCr33ta3sg58+lGSd+YjEp8DSO+djYGDfffDNnnnkmn/3sZ+PX6/U6w8PDz8m5vP71r+fDH/4wZ599Nu9///vJZDLPeFxXVxdCCO6+++7YEZ5o5jXjNO/atetpx+zateuvaq//+Mc/5l3vetfTMniDg4O0tbU9iyv6+0wIwTnnnMMxxxzDD37wg7/5/VJKbrrpJnK5HAcddNAef3vPe97DZz/7WVatWsU111wT1wM0rWlNa9qLxV70SPpfs1NPPZV77rmHn/zkJzz66KO86U1v4lWvelWc2r/pppuYO3cuN998M3PmzGH27Nm8733ve86cgaY17YVgYRhyxRVXMG/ePG6//fan/Xzyk5+kr6/vGRU5niszjuqjjz66x+u//OUv9/hdCIGU8mlO8Y9+9KNnXRj51yyTyfDFL36RE088kdNOO+0vHvfqV78aKSW9vb0cdNBBT/tZunQpAIcddhjpdJqrr756j/evXLnyWVFQhBBPu95f/epX9Pb2/h1X97fZ0UcfzTHHHMNXvvIVSqXS3/TeL3/5yzzxxBN89KMffVom5ZRTTsFxHC6++GKuvvpqjjrqqGdF/Wla05rWtP8r9qJH0v8n27hxI9deey07duyIU7Gf+tSn+O1vf8tll13GWWedxaZNm9i6dSvXX399rPjw8Y9/nDe+8Y3/a9WDpjXthWK/+c1v2Llz5x5ZpIm2ZMkSzj//fC655JJ/WPfHKVOmcPTRR/P1r3+d9vZ2Zs2axW233caNN964x3EtLS289KUv5dxzz6Wrq4vZs2dz5513cskllzynqPInPvEJPvGJT/yPxxx++OF84AMf4NRTT2X16tW89KUvJZfL0dfXxx//+EeWLl3KaaedRnt7O5/61Kf42te+xvve9z7e9KY3sX37dr70pS89K7rLq1/9ai6//HIWLVrEvvvuy4MPPsi5557L9OnTn6vL/R/tnHPO4cADD6S/v5999tnnaX8fHR2NpTfL5TJPPfUUP/nJT7j77rt585vfzJe//OWnvWfKlCkcf/zxXHbZZUgpm9roTWta01501nTS/wd76KGHkFKycOHCPV6v1+txejqKIur1OldeeWV83CWXXMKBBx7IU0891aTANO3/hF1yySV4nvcXZQa7uro46aSTuOGGG/aQFXyu7aqrruIjH/kIp59+OmEYcuKJJ3Lttdc+jSpxzTXX8NGPfpTPfOYzBEHA4Ycfzq233vq8dOm8+OKLOeyww7j44ou54IILiKKInp4eDj/88D1qV77yla+Qy+W44IILuOqqq1i0aBEXXXQR3/zmN//qd5x33nm4rsvXv/51SqUSy5Yt48Ybb/ybuoL+b+yAAw7grW99K9dcc80z/v2ee+5h+fLlCCHI5XJMmzaNQw45hM9//vMce+yxf/Fz3/ve9/LLX/6Sjo4OXve61/2Dzr5pTWta016YJuQzlda/SE0IwX//93/Hm8FPf/pT3v72t7NmzZqn8Wzz+TxTpkzhzDPP5KyzztqjaKparZLNZrnllls45phj/pmX0LSmNa1pTWta05rWtP8D1kTS/wc74IADCMOQ/v5+jjjiiGc85vDDDycIAjZu3Mi8efMAWLduHUCTP9m0pjWtaU1rWtOa1rS/y170SHqpVGLDhg2Acsq//e1v8/KXv5yOjg5mzpzJO97xDu655x6+9a1vccABBzA4OMgf/vAHli5dyvHHH08URRx88MHk83m++93vEkURH/7wh2lpaeGWW255nq+uaU1rWtOa1rSmNa1p/4r2onfS77jjDl7+8pc/7fVTTjmFyy+/HN/3+drXvsaVV15Jb28vnZ2dLF++nC9/+cuxMsPOnTv5yEc+wi233EIul+O4447jW9/6Fh0dHf/sy2la05rWtKY1rWlNa9r/AXvRO+lNa1rTmta0pjWtaU1r2gvNmjrpTWta05rWtKY1rWlNa9oLzJpOetOa1rSmNa1pTWta05r2ArMXpbpLFEXs3LmTQqGAEOL5Pp2mNa1pTWta05rWtH+qSSkpFov09PRgWU3M9oVoL0onfefOncyYMeP5Po2mNa1pTWta05rWtOfVtm/f/k/rTvxc26ZNm9hnn/l880tdfPj0/uf7dJ5ze1EWjo6NjdHW1sbcj38RK5VWL0pAgNWAyANpgeVD6AH6/1ZD/T901d+dmnqrCEA66linBlKA3YDIST5XWhDqrxIROGWIUuqzrFC9JoLku+2a+kwpQNoQuSBCsOv6M0KwAvV38zfpqHO0dV8lK1CfW2uDbL8kyAgsPzmu0QJuRX0vgN2QSN2zKbIFVihBQuQI9boAIhBSXVcjr87dbqjvR6jXpaW+V9oTXie5FvOatCHwIMyq60VCkAWnor4jTKkfu67fF6h/paU+w6mq4yJLH59Wx4Ye8TMNM+p7nUpy7+2G+n+YUt+H1Pc/Sj47yKlnLW2JCAXSSt5v1dW/ka2fgb4maU945pb6TstXr4eeuuYwre+3re5l5ElEJLCr+r5MsLYNEZmBBtIRhI5FrcuhURDqeUf6Glx9/yP1HVaovj+y1W0397pRgNbNEd5YiJ+zcUsh43NdnIqMx1+tTSAktGzywRZIAaEnCNOWugZXxM/YrURIS1BvE/E9FxF4JRmPgXqboHZ4EWd1AdtXtwWhxqe5L05V4lQk9XaL0FPXYtckkSsQkcSug1uOCF2BU49oFGyQEoTAzwpEBOWp4HdEEAnmfG4Vn3j0ce4tL+De5Snab+2gEdmM/+c0vKEKHf+1m6zV4I77lpLdIUiNS9yiJEoJam1CjYmMGo9hBtwSfPjUX/D2wgD73/l2osAmu9ajtrRK+vGMmtNSzWUiaF8vCVJq7ohQjydJ/H8Eeh7KPZ73+GxBfgdUJ8Ef338xw1GNioS1jW7O/u7b4rkI6hlLocZe5Kh7qMavJEwJNV8t4jFr+zC0FJySwB1Xcx4B6eEIEennZQu9BkT4WQtpQeQJGgWh5mMkiTyBn1ZrlFlfkOr6Gi3qGv02SWpAgITsoKQ0LTmXKAVhOuLlhzzO1pdXectDOzn30WOxnsyR75XYPgQpgZASaYl4XfOz6ruq3RDmJXTV6PmZy0++cxEP1XN87IGTmfO+R6n892yG75+MXVdzT9rqPnWsbTCy0MMKIEgn65FTVfcOAVII7Iak0SII9fxKj0iCrIjXcLckiVw1du26xM+JeN2IHHDLknqrpe6VI9T6rddyPz9hzdBjQVp6/bDUOAsyavybtc6pqzEiIn0/HNS8CGU8BoRej626xG5EuKWQIGdTa7fjsRfZalxLS40FtxhRb7fUGiHVPTF7W8dan/T968CyGDhpMY0WdT5m3ReB2m+ilF5Tzb4Z7DnGpfmx1TnmdunvdNT980oSaUGm38duRESuRWQJKlMd2q5axb+6VV57sBrzDuR31Gi0etQ6bbK7fOx6RJi2KU91cCpqUotIrQtCr912A4oz1dyTArL9EZGrxmi9Tc3PWgfYVTWeIpf4GYtQvWY1lD9i+YBAzV19jLQhNQoNaqz7wVcYHR2ltbX1eb1nf6+dfFKBNWsb9A+GbNg0QqFQeL5P6Tm1FyWSbiguIp1GZNOxwyMkkAJXOz1Y4IbKJwjyakIIH4R2uIRFvElZdXAkyIx6jRRY5u/aWXa0Iy0kyBYQNng+2HrBlR7YlnbinGSBEz5I48jrYyP9+ZEDwmwGDbBcVWhg19H/gcKoRKYFaV8tjFIIZAZcC1wktna6cdUCIW1drKBHh4XexLXzaYVqE0rr68IG6SbOO0xwxrXTH28Y7oTfAVeAW08CkpTerBBgRepvVgSE6txABQd2AyztMNrGeRH62WhnPXLVcwgy6tosXzvzrWqBsgV41cT5j4MJC2RaB2ZV/bdQLYJRRmLpe2HrY8OcxK4JFTjoc4lcdf8ioTZpoYM024IoJ5EOOGUBaeUk2JHAb5F4IwKvqO5FaRFQyNB5Xz+lvbvINMDyLRppob5c/+N3qg3TAaKsdiIiHSQEytGwfHCtCNkGKV/iEtDW7yBCSWWSTZAWpKvKSSntk44dVStQjowVQtAqcLUTHrUJbF/S3hdS7bKxhCDMqe9LjUWUJ9lYabC2pYm6Ib1LbRp+Xt13mVLP1ZISty4JbYt0WeJnBFG7CfwkUU5QbwOnJhHlCPIWkSNw6hLHVY6LlVP3PShEOMKlmOnktS1rufGL/84n5l7G+dtfwSu+/zB3fmIFj9wzla+89RoeGDmEKY9X2Xiyx4JFvazbNJWNx/+Ae2twyr3vwV2TITUO43tF/GDnMZx20E9xRtpIDwge/eyFXDo+mf9MHY+7Ja3GlafvuyuxI/VspA5cEHou6bExemyVsw+6kYGghfOue43aRHNQnQfeKBz/9X/XDqYKilxbIoRythBg+eqDbKEcLFs7tdICoceE3ZDx2gMg2yV+O0QVi2pKBYa1cT2ONaBg19VcEVIFXdKCXB/4bWp9i1z1zIR2xISr14oGRF2SsBDS+oSDN67OL2gVOI4KeJ0aWBWIfFg5tDfuZ/P87MCVzL6twoaghdFpNvnNFk5dO4Ipff8aIHIqmHcciKbV8LIOhTvX87DbzYW7juTzR9zOwJoCf1jSy9iZs7DNmmVBZlDiWhayzcMqgZ1K1inHBTuSRLZAumBVJI6j1ka7Dv5UdT/aNkRJENwAbzxAuhaZoYh6h4NbU39v5C2stKUCf7QTDTQ61TyyG3rN8GLfligNloRUUeL4KjBCgi2k2ktQwUGYEggH8PTe5UvsUD1nu6ECKDeIsNIRAoE7CkHGIshauKUIWQY/Z+EVI/ychZUWuA0VALmoNdOtQL6/gpg2g7CQIZiUVmuqBi/sutrfhK3ncIt6Vq1bInLX38f4O5ZT6RYqeAM6H68TeRZhSpDZVWXXzCxeGfxWdW/aNtbw81n8DgunHuH4krDTpferL2PWF1fyr2pWJgNVh2qXg0wJZJuLyFp0bKsjQptad5YgZ9E6ENIo2IRpFbR7NameTaBACy8ES/sAGT+kkbIozxakxtS4zGggwa5px14C2pexpPIrhK3GW5BRe4MJrEQIslWtN8C/LO33gQce4KbflVl7z2zeflof3zhzNl/99tDzfVrPqb2oSUjSbKyNPVHUMKMGda1bKmQUdZyfh9pkSaNN0miV+AXlYEWOcuKl0JuidqKNwxt5GiE3iIR2vBHKOTXIhHT3RJ5FhEKDdfQbZNU5SEcdZxBVt6xR5UhvBr5ypO2GRvM0Kp6gehI/q97v5wRBWhBk1L8mg2DuCRMWaRGpzVda2gkV6nusQGrkUKpj9HuC3ATnd6IDbH40kmMQL4HONhhkRjsQRODnkixDapQYhbRC5TiE6QQZl7Z2qD21sXhjCqlySxoxEurzgpRCAGudytkJUgpxLs2QRK4ksjWirs/b8sEbUVkFg6AHeamcbQFRSirEXOrMgM7MhGl1fGpE/euNCZyKIMhK7KpABILIU067CBU6HrngFaHaJdh95GSK02waBYvIFSqDo+9hqBEt86zsunasK+peRI7Az4JXlBRnqA3Tqkc0Cg5WI4qDL6EdSKemPsMt6WDQMVkVFaRKvZg7dYkUUG9TDr50ID2s7tn4TBVNRa6aD41pDYXWhRK3RBzsgTq/0lSLWjtUupTjL22otUOjRcRZGRXgqfMQUqH09Taot+nzzERMmqcW52nOCL8cO4DPveN6/mv+Xqz/00zuHpjHXl9/nJlnruRrTxxP97G9tJ21g8XnDbFpdxd20eENG15FUab53RHnc+TrH1TzrtVnbGcL+1xwWrwWALyz0MtBc7cRZiRhJpm3owtEnO2xggQlM+M9cuGQWVtZ5O3mwPQW5r5sC2v+34W844Q7+Pxbf8p5/34RYUoQejp7Y5BQ/bvKyqjvCNLqeQRphf6aDJ9ak7QzJ2FwX4vMLhsrELglNd4QUs0F9Hitq2uwaxptRo2jIKXGcDxX9fMw77N8KM6N4gwc2gGOHBVA5XZKMrv02uTrQGB7jtJ8n3/f8BTWUdtZdGEFu2LRaIexhZKRJRFBFlIjMs5WNtok9c6Q/efsYOYbH+Oge0t8/P43s/6RGfxg0xGsLU3l1HXbmPHllVi+ylTadXW+w4u9GKFutCZrcCOv7q2QKgiUQiHk6REZrx3t6yLKUyxKPRaVSRbFmVb8PIOcjbQElW6beotFo6AyTpav5rxbSa5b6vUvmpARbLQSo+3lyUkGJHJV1krqeWf5EqcqseuS1HiEV4xIjUUKtJBQa7Oot1qEniCyBaVpLqVpLn5eTbJqh60ceY3EN1rUnA89Nb/9vFpH6m3Qd2QH9emthDmX1i1RvA/YDcj3RmR3S6xAAxi+GiPpQR9738VUutS9RKjrjFx10VZDEmZd2tf68Z5lBZLx2SkaLTbeeEC1w8Yv2GT7I9rXSd6ydhf/qrbzQwdQb3OIHEFmKKTW6VBvs/ALLkNLcjrLIah2O2R31cj1NvCzgiCjMg21NvXcbA0qWRMybq1boj3WIXQWJ3LVPLX8xB9wK3KPvdBqqOPsOqSHJNl+SXok4l/VpJR86t9fxsc+0Ma0qQ7fOLOb71w8ws6dO5/vU3tO7UVJdxkfH6e1tZX5p5+Fa6WVw6MRzyg14UCpnV+dVjabr3EwzKZpYBER6cVYf9bENKF5P6jJYja6ifQNaSeUDaeapGbtmnbkPYVoSb0ZR47ajKQ9gcLhKWqLoagYWkGMFqMcVDQFRGiEvt6WOPrmnNxykpKvtStqgBQiTqub96rUuEaMtSM/MYUcpkRCCdGIsuWr+2YcdEtTfYjU4mQ2Kz+vHMaJlJbIZA7qGjF3EuqPIAmO7AZxStcsbE5NXb9TTTZPQ1kwi2GoUfdIZwciT6NoevOdmOI26Cg6AyItHUQF6rVMvzqH0Iwrof5vnn+jI4JQ4JQF0++s447UKM/ME2QtypNFjP5HJgNjqQW22i1iJ9huqM809IPUmDqpSreg0Cvxs8qhbdsQIm1FE6lMEnglyAxG+FlBeiQk9AT1Nks5NFYyLoO0IDMc0cirDT49IgnSehx4Ih5j0oaRvSPw1DWRDfFyDaa0jbN1SzfOmINdE6SGknuZGoX0SISfE4Sa4mLmEhCjcsapsPT5IJWTIyIVjNQXVcnl67RcWeCgMx7kpjsOxplRJtqcI8hFtM4cY2w4x9wrwL79QfXZ2SzVVyxhcF+H1IiiU/iLqlhbMiB1oGIlzkh5ZoRdtnDLyRwSgTqn0CN2XoIstD+pHXSZzBE/o4Jl9839jJYzfGHpr3my2kOrU+FtLY8xENrMcQRHfOPjMb0upn44CQIsQlQwY6ksh7SU4y4iTd9AOUF2PaI0zaXelqw/VpBQU+LPiyaMY9T4NWtTalD/LpNgM15PLKh3SkQg9D2Q5HpVit4KZTyHIlcFEbavUvRBBhXc5CNOXn4fD+4veNdT2/nC799IdocdOxR2PZmbbhmKh1Q5Yv5Gdh42ztc2r+bbO1/J/X+aj9XWoLOtxNtmr+bSHx6HYwINHeQYmkeQUgCMN6auPaZroO6niFRQbNZURSWCWlcyz5wKeKVIZTM05QogTAnqrcoxD9J7rulOTa2l43ME3miyRpi9wax1LVvUvFLj36Qkk+dk6WyioTMqsEUQpgRuJaFXNQpCj0WJV1TZMbuh1rUwLZRzrx3pMDNhT5Iw7dInVEoyjAgXz2Z0ryzVLsGkh+p4DzwFQsCc6VSn5Rle5JIakzQKan3veqxBZZJLeaqan5khqZ3GiFKPjVdU6xYaWPJ1hsVQiESk1jG3JHFqkkM/tZonDjQLwL+Old5yGH5OjQspVNYvdFUgGDlqnqbGQpxyiFNs0OhIUe12sUK1ngqdtRWh3oMjqYCJViumoTZaRLy3uUUd8GnQLzWSjL/I1Si6znqlh/UalVFju5qq8eT5/8HY2BgtLS3P85372+yXv/wl73vP61l37yxaCsq5OfmDfRTyFpdcPfY8n91zZy9KuosxpwoisyfizQRKhoj0gmucaz9xtoTUCJNeYEWonGeDoprXhCTmjhruYeSoyWRSzLHjF2qKQoOYn2ucyMhVSKbtQ2AnPLQgB964Pr+G/gnU+4OMoldYgdo0CTQa6QOWurZ6p3b0dTTujYNTUfx1c52Rox1Bz6TbtTdsgQjU5maFaqNyNN9Vou5n7MQ7OraJdACjv9+K1GtBOskMBDkVjFgRuOMJAgnEToVBjv28fi56I5YkGQURqrSf0N8ppNqozTOINMXGbNRBFoSv761G2Y1TYhyOmIIUgFvV1yrU/fHzE2oRUN8f6ixKrVuS2SUIMnpDCvR1Vi31HQ5YjQhCiV2LQEB+p6DWYcWbmBknQVZtdPG9CNV3hml9b4XmN0YKoXNqelGuhEhL4Gcd3Io6t+J0i65HVaFD5DjkdofYFRWtlKd5OJUIIS2qHZYa+0Jt9kEaRKTGSOTC2KKIqDUgXahT68vRcxfkrl8dz7WFbAGgesscdmychF208MYE5WlQ67D0hgSlGYJMv+IDOxoJUmi/jLnU1S61keX61KYvInBSISfMXsN1b1jGyl1zmLxPP4MPTibMR4hQEN3RQWsDBvaD8LAVlOf6pHa5eGNqzoUpPfYfzOC3qLnmt0DkqsHhjQnSu63YuUHo8aWdC0sHjSKA7KiaK05damRZoY+ponKq+h+fxK/f9E1q0uaY7A7ywmN3KJnlQF8YqHUjMPNGYNckYy+vcdnyy7llfAk3/+iIOMvkZwVeUW3kdkM5eX5O8aIrk+04KHbH1fmmxtRnh5kEZDDouzeixn2g1yop1HEGSXcqaswaAELVyAiCjMQuCVLDgloXpIbAKwk1NxvEwbhVljgVVcPghwJvzOYnfzyMw+99iiv3gnlH+mx5tUXY1cDtTVGdElHYZFHr0mPdljQiG2fmdGY497B1vB23q0a4M0ujUGVLrZNXnnIf9371YMpT7JhCFwfo9cSJtutqfmcG1Bhzy5LxWRZOFSpTVBbLZDHt2oQ1MAVhQ+BUI+oa8VRZSPUdfi7ZK0QIQu8RflaQGk5qUgwNKfKIs6+l6YL0EDEHHQl2IHXdkVo7nJqMaw1CVyAtNf6DlCA7GFLttCdkOoXKLApB6GmwZGJmytHjWIMiEqi8ZCFOOaTc4ylnW69j7ngdhEAGAXLNOrLDU5DONOxaxNgcT6H7u0qkdgvaHheELSkGl2YIMpDbbeEVJfV2tfeYDKVb1nVQdR18pwS5XZG+VsGfvriMrRfBgg/963DUG686mHqLlTwnS5IaDcn0VdQ6FqHqfSzB+Nws2X6BW/QJsjZ2PWJ0gUt2txpbub5Q10nYKptSk3EACGo8BhlIjUU4NUFlssCuqHsqIjXm4vqtEDwN3tQ6BE5V7VepwX9NjDYIAk7/5Bv54ic7Ygcd4Kz/6GLpkVv5+OOPs2TJkufxDJ87e1E76ZELGF5loBZQ43AZxzxGi+3kOIOgBlnl6BsnTkTK2TK/wwRH0Eocc5mMqbj4Z2Ia2RRmGYTYBAPSUc6oKQj1xlBoDNopdpRjW28TeOMydqztWpJ2twKJkALRABxIDxIjT04NnTUQushJIeGG7hDpQr/IFfF5h2mF6LpFlY4NU4pfFzkJN9GuK9QJiAtjpKXO1a7ueW+tAKQufpQWVKeoe+SWlBMlQqi3gynGNTQNWyPzgmRjtkSC3hsnGxLHxBSlGiqOXTMPRb0vM6D+Hxl6kQfSUAQmoOlh5ulOj+JyK4QjyEmkJSnPjHCKNvUpAak+RwUOGqWf9ZsqzmBZBT5RwjG26+p+G+fQrat/0yNqIa63CoqzdcGvLclvsYg8RT/J7ZJUJgvGFkhyOwSD+3p4Ywq5zgwGVLschfhY6EI9haRnB6DeYpEaCxmd6+CWIDMUghDY9YjIEbgVdWytXV1jVAhZcKpyyp0F83jyjDYO/mgXnakST4xOYbCYo3BjCy3H3ssCNpO+cwoDlTzF2ycpSlJRXWdhK3hFRcNxapFGiS3qbRaNFqhMUYhhahhqnYLqJEjvPcq0lnGeKk5m3tsf5vg1Y5z/m1dBSmJPruL9KRfPHyuAUIJVsePsS60D0kM6wMpCmFapsZjWobMfjc4Qu6yCC1NULiJwR8AeUePLqSUIaq1N4BdABCpr4VSUs96+Bvpfn8UWES0CXOFQkQ26hcUCN4PUdCwrNAG/4IrllzLbLbOuNJnUuFSFp5HmTudVrUDkCEYWWXrdUuimKaK0wgRBE6GaS4buYKg66RFJZYqIawesQM3PeO3QmSY/r9A7IZVjDyK+Zr8lIjViJehdVn9XGmRJrQmBC9ldUJkM3qjNPU/N41UPrKHNfZD0aA+NI/sYev8KRo5o0GhNkxoGvwBBySVt+8y5cYD3HvpGxs9PEfZmiVoDbEuSsX0eG+2h/0CbXK/KvmFBdVpEatBSmcMJ1FunqtbDwBFYfkRmQCikVygKXHaX+l5zbOQkNLbyZEfNf0/dv3xvxNg8K3a+gwzke5VjCkkmzgA3YQrqHRJvLClKV6CNzlJJlUXJDCnHOz2s518jUvQVX63fTk3GhfLVDrWxmOJtp66QbMeSVCZZMXihKGw6+1bfcx0dWeggLWfPDK+AnUe0YB+2VBXVSr3Gesn+2GixyPVmcEdryJRNkHXwc+rY8hQRBznRhL0SS2VovSLUWnTglFfrUJAFaTn03Bax/rKD4rXlhW7De7sUtifZycyuKkQKaCjNUutQYUuFRquHiCT1Nodahx5Lrk3L1pBSj41bkpSn2njjEreishW1DhFn6+yqGqNOFcZnWYrm2DA+ic6s6Kx0akyBbtJW2R5DgUFAtVP81Wt6IdoPvz2NSML739G6x+tzZ7l88J2tfPqjh/Kb28rP09k9t/aiprss+PRZ2Ol07DQbqorVIOYKQuKgOSXioirj9MUFihpRNQi3FAqhhmQBnMgli+kZE9Kdhl5h+eiJnfwoKkmyKBp0yqTbJ6ZFTXo6NSZjh3Hid4cp5WSbdHnkCc0hJKY6mLQ5oNGaPSkuYcrQAKS+d0qVwTj4IlKbTVyU1kgoODFNKEqQ6shJ0PFIO1SGU2pQYpXON1zrJANgAiJ1rhPuiXHWg4QuYwIiQ1UAkqKwKHnm8XggoefElBKSMSAdo0IjY5qLFYhY8cdwN6UgrrKvt0ukJ7ErFmFKL6Y1wZwbRhFhyPABHTG9wQoU8hGkk+DM8hVNpd6qOLBnf+qHfPyRN/P4YddQlz4ve+StpF2fyrVTqXYpRC63W+IVVdrZzyWZBnN9hmIlAuUcTOSeiwi88RCrEVHtdqm3Kg59tVshzbmdgsnfXYl1+zRa3Do7yy30rpukONBjgkZHhExFWDmfaMwjvctmxldVYdiUe1sZbWR4bNN0Co95MWXMKyoHxPJ1Sj+tkMSPfuBG1lWn8MCnD2LnSzy6V/Qxr2WInYepdNKRj1X5wf0vRTQsiKCwwVYBYJg858pUSdQW0PKoS2lOhDtqketTVJ32NRaVqcp5CXJqHvltEXbFIkpJ3HE1vo06khUQK6aIMOE2S0vdP1sXeRpuf72NOCh83ym/4anKZN7VdQ+HpRwiIipRg5RwqMuAcwYPYp9sL7XI5bzz36DWJCAzPCHLMIHqUu0UVCfrAsWamieZ3cphzPYrNRJDszDnYBwpy5+QAYpU5scpKzUYQyEza5VyoJLsDjrlLh31Xa5e94Is5HYqKl1qRAcIUTIHI1cF3I32UKXZsiEHz9/Cq7sf4cd7TWP4Vwt5yZRN/Gr9PohNOd594m1sr7Vz138vo+OJkN6XCzIzilRLKbq7iuzf1cvmQyps/NZy0kMCt6jVmyIozw4RLT65PynI2yvpoLcsGdofuh/UQVVeOc+FxSOMb2xDCuh6SGVFKpMsMgORqgFIiT3WAyvQHHcvWXfsmlobTPai3kF8Tm45Kc6FxHFKjeramUDG98pkYbP9IX7O0lQz9R5vXBWCCqkcXJNNSY1L3FKk12NJkLV0dlXE+5yf1+MgSvYOA/7UuvX6bNZWQ0GL4l9jhpTZb8z4iOmfRgnGS9a+iXusuW8GGPNKOmvgCNyqmvveWICftxnZy2ba1194xaSjpyyn7Yp7Adh89gra10qdFYwoTbNBQn5nqBSqUkIXhiqUW4FSCmn38zbVLisWRwhTmgqk6U0i0GCIDUY5zKzjUqgsEZEG3LKm6F8FaUFaEKbV65bJmtgqeA78Go//8F+L7lIsFlkwr53vnz2Jk47PP+3vQ8MhC5Zv4Wc33sJRRx31PJzhc2sveiTdhtihMsiTWWiUs0q8eJkFyyZB3YMsatHRNAkRgDD86SxJ6lovZFYApthDVUpOoNeE2nnSfGYMCqyLHWMFmIreYzV6FWkUXmrH3Ux0UxTojUvNGVWot13TDreO8A29xXBBgwwx9y1yFLIk7QRZjKk8oToOiGXm7LqMswKKL5tE6gZpF6GiLJuAwGqoY6vdIkZuhFTnYWmlB1DHGj6ttLUTbCQpUTQMADtI7q+0EvTQHBvzu01RsC62DVMJPQWhnC+E3lDdCc8GVUlvMiZKJkuhX4Yn7Y5BaU5E69xRSms6MDfJagg+95r/5us3n0R6QKGk5b18nB0uUcbFqkPbkyWG9ivEqU2nvGeQFTlQ7bJi+c319SmEkcWyB9/C6FCemdMG2bm6B2uOcgpUIZGkUbBo3eQTpi2KM2z8rMkYSOotglq7Oja3S1JvTZD8IC3w8xaRYytJvqqkrqlNs34xTPj4U7z6iRHOf2w/5JYs3qggldYoqwVCWthVi8hzVMF1q2T9FQeS2pKC5SuBMaxvz2H+SRv400NzsWuCRpvArgrshoife+chu/nF7v15bPM0Oj5WpL65nQWtA9y1cQHez3w+tvcfuHrHIaTbagSb1OJtUsLj8yLsrhpfXPYr3lkYBGCedyobj7qM++oBH/j+R7jkxB+w6PVFalLyyh9/hi++4ae8NrcTWwg+tO0Y7rt9H0JPBRCRC9KRpHYL3CpYDUllqsDdQczPjlxBaKBbvYakRpOA9eKfHIdTgYGTCpw14+f0hgUWuD6v/crHY17qr3VgbgPUkzGrsnIiqb/Qxd5Gck0EytkKU+p8jNylkMqZN3O5bUPE8GIrDvpNvYw3lnBew1RC4zLBpikI98aS/5trDFMK6XPKUJqmvt+pqaxOajShDHpj6j3emE2tC4JQ8MD62TywcRZtN5U5YdoafGkTVFxyY3DH0gxQo/13u+hrm0xqWOCXWpE9DdKuz5aPzKftjztp/bFyVqtdIqYNZnbaiB12TJ2LakkWreMxhehGrnaoI0H50Q68GmR3w8giCKb6FP7k0WixcKqSELWuOnVFKfPzau0w0o9RGmROO+UpSNWV45Qaldh1ofjJtgo84xod7Tg7ZWIP2MhBuhU1Zgxn3awHjRZFFfMzYkI9gvodLFUHEUjCtJnPKmtqJGHVG0AYmdtIZQ8sfW9MMGBkXTH1P5I9gjrQmSUNjkxU8gK1T6aHdT2CrqkyxcrSg9S4pJEXGjxQznql26I4zSMzJGndHLH7oyuYfN4Ly1E3DjpAYUviO/h5C7ek5ltmoIHVCIlcC7doMzY3RXYgwBsPGNonTXmKFSuapUbVPA1TCpgxwX+ka16kflbxvC8Tjxu3pLKCTtXseYJGm5pnpnbL7IdOVQXP9sDzcdf+d3bul2Yzf7bL647LPePfOztsPvfv7Xz6Yyew+pHKv3yTpn/ts38OzGwwE7nChsPsal6iUWYJ8lpFJK354XrhNVzUmEeqkXXzWVagUHjF99ZOYV19hvm7cWzDFOqpGLRLJK/HzuoELrVKk+kK/XTyflunVk3Rm/pOGWsquzr1bgUyXpxNsaDdMIusRg21pnPkaBTbNai0jJFCKQxHUqXfI0coOTF9/jHHfUJQMrGQ1c8nqilJwdmElLx2VtySDpBsja7r5yM0imB4y7ZWkvDG1XN0qgZdIFZAMbxe8wwsXx2XGkmcDynUptZoU45ipCvlQ53OjxyNcKQUUmb0gQFSwxajW9p46B3fIfIkX3/91bziVQ9x8cYjEL6IiwPd3S7Sgr7Dc2x8SxtbXleg0Zqk1iO9qVmBpl20aEfIV+f1u4F9kE8WKD7Vzl6z+ti2aRLZXTDrCysnZADUJhhkLBU4mXFZU/e+PEPiFWF8QUSt3aIyWX1ntUspDhgnwK5Lyj0qHT3/2E2Ejz/FW9bu4ryHXoH9eI7UsAr2UiMqSEUqmS/Lh3pXRGa3wBsROLs86rPqbPzuYWz78grmfeJeSkf0400rE7SGNNojapNUKt+uqeeRf9VGLCHxsj6RFLTMHOPgli2cvPdqZn+6RNry6c6Uee28x0iNCNqeErFDmBq2uPzQy2IHHeCMg3/Ng40GbVYduwH/77IPUZOSsrRZdPgm3l4YpiQDdgQ+926dHdOuhK/OJ9snsDUCXesU8XO3QpWdsusyLgBUNDMZB77SUfKGXhHW/G4B71n7Tg7yqkyzC9z8hXO57cvfjsdp7EzpsSUiPdeEmsdeUYKUVKZqekqUoOMm+2JkNM05mvk3PlsVwpp1MPIS9NktT5iPhqZnOM1mrdNro1lDQB3faDccdoldNbS7BDl2i8m8tRsQZlW2hYoN4y61VR18sftPXH/XYXRMKvK9D17E5zY9yqufGKHvyUmEk3yluNXToK2rRO+fplL4Vh+rH5zP6OE1xe8eVueQaJsnQbVRULLrKmtUni5ptCp1J6+YrBuNgqIEejs8Gu1qLah2KPpGo0VQniJo2Roqp3a/IqlRNadTwypIdapKBlJpXWvaQheUp6o55BWlovFFas5k+yBVjGi0iGTv0A59qB10IFFRcUQCuJisiqElZQVYKnNqgrCJ/RrMuhLZav2auMabTHLsTE9YZ42qjOVrBFefk11LKFF2XUktRjpwKWyTeONSO6EJku6WleKTiJIiSXNfzedGrlI8sQIY+sCKp2/iLwBbf8WBRI56nu1ry9h1SevmOu2Pl7DqAUHWpTI1zc6XpIg8qHQ77DokHcueRp7ee0YjvPFI9VuxoN6inGlLy2UCcWbQG1fPwBuX5HfIWIvfqMCZbE6QgXprsm+Z/dUbT2oo/lVs586dfPuiEc75Ytf/KBv5kfe2MTQScs011/wTz+4fYy9qusvcL5yF46QTHrFByhvJZmj4eqZxTayEIJJ/TYQ6UU0gdtL13bXqCT3CKHaYRdCkkEE71rGTzB5V2pA4buY8IVk4JzZhMtxHEamNJrs72aBVAYp2oCfIOyXSjzJByPXGazbxUDumVqSq8KXQSI1RcNHXbNKahvpi6BVG5tEEGqYBlHFGTRGVqVQP3eRvTllv6Jr6EqdOg8Q5tnRa0C0niJ9xMsw9tAISZQOpG4lkk3ttAgKjaGE2J7+g9NANHQrU+dp1YpkrpzwBfdL/+i3QmOQzY+Ygdd+hdms33jGDvHbGY/yubzGlukd5TQdBPgJHku6zQcDUexpUJruUp4i4QYWf0/dlvxJBwyaV9qmOZrBHHLK9guAl4zQaDs66LJnduurfUg6AW5akRyPqLVactYhcmPrNPdGpTecup2WTUMovObXBm3S/n4dGq0TOqDH3bQ+z44wV1PaqkdqYJtsHpema7hApukh6MEFzK1O0skYEtS6lCpLfkTy3sUUR8z52n3pGt09j2+9nAZAZVJtMzzdWMuXeViIEnhVQCxVHef/Cdr5z1yvjArP83ZPYdN18EFCeJvFGBY9/5ML4+hb/8DTWvP/71KVPRigv/sR1r2Lg0tkMHCRpXWsxum/Aptf8kLr0SQmXhVd9CKsh4uCt3qHkM71R5ag0WtR9zvVJjYILTX9Tc2QijcrIjqJRS6MiE+ixZtYVp7JnfYxxtDxd/yFCVUTsliIiTzA+SyHisXILyVqSHlb0KEM98Cc4YoYjbDTSTVCcGtFom1a9Mpkokz2cKPsmQnUtYUYVh8ZqVSmIPElhk4jnfJBVqkemCVKYgkpPhNVRJwosqNrMvT7k51dcwLKrPs4f33EujzTaeGm6yts2Hc/jO6dirc0hBTQmBThtdeac/AgLVqf43R3LCDMRuS02fotylieCMGatSI2CV44obK4g73+UbV9aoeVR1Zrkt0DLJkURqnWra2+0S7J9gsL2iN5jI7qnj1Csplk6pY/1I12smLqZO248EHecWO3KPLvUmKTaIdQSq5+jydTmd4bU2i3qLSIuTs/3Sqqdak3N7ZYakFHZmSCV0F3M+m1UkYySTmZIBdtWCOmhiDCtGlOZvarRMmFtN1x7Y9GEInyZjAlDtYhpisaJ1/UZpv7BK6tgJLIVb9pkp420r11Ta4MBwwz9wgBOpmbJKxGj0Y2c0CIJEj+vaq7aLr+XF4Lt/tgK0kOS1vUVRBRRm5yh3mqTHgnj7Mf4TBUMm+L+SINPSH3/3KRI2y1BZjhiXMt9GhniIEdM54x0QbOqq5iQ6dXjwqnKWAUqdAX1VhHX3ZnCdylAjNVYc/G/Dt3lfW9vZXQ84rofTv2rx/74hnG+cPYQT20okk6n/wln94+xFzXdhShxmiNXDWCDvJiFNKYZGMdbO4ex4ose+LFut5/8TTqoZhxh8rpZkEJDd4nUZxtKS4zcO8lnmi6ckeFAaufWcBonqpnE/G4rcTqdqnLuUmPaOUctpKGX0FXi4iUXVViq6SzxZA71Yu4ni3pki1gve4/UqE7VuxVFd5nYgCnIJSl1hFJIUQiQRrY0N9IEPxN5+EYuzKDsRsYx9JLFygrUBmwCHHO8XUs2IqVuIPFDESuwOFVFG7KiPb/fpKFVWl7EzrhfUJxdodHEMC0hEpqTngRqRjvfGXE49pC1XPan5bz6HauxRMQDI7PYr7OX1f0z+dFbz+PHQ8uZ5BVZOTSXl3Wt556j5rH71/PiazOUq9CBRtFDRoJKxcGq2KQHBIvesI4IQSO02Zptp3FfO+khdc1+Vj3XoC7I72jg51IUZ8GczykHffPZK5RjNgzpAe00ZpQsYnkaIJSzHrkQtIYseNvDABQOH6Da16Y2/kKiRR9mEmfUqeq5VdXjsQb5bWqjrbcL8r0R5akW7Y9Z9P/bCtyKpP3l9xJe10mj7FGZZZHZ7rDtyysUPUZYzLk/TcqtsvaMJey4pcRVmy7mFw8fyNx0P1efcShCr+EiFPzitHPZEkgerPfwhlyRJ99/IT8rt/JgeQ6H59cpSoW08HOC/CbF6/7D8d9m4ZWfIchFbHrDxQR5VfRbmhXR/oSFN67njX7GbilZVkwGRgX5WlZSJsXWQiq0UArliJh5mh6RcYF2HKhaQgUAIgm6/VDoDqwq+C3OsGOn2tSImAA+svVzTKmgK9R85vSIjANRP6f157UEnEHcQ0/ESkhG4cX8xMGxg6I+uEbWVHDeu3/IB+9+l6IzScCSNFoFbjlBVk3hmkH98CJSaZ/KUBaRirBve5C8lWbWIdv53tBhvKb1YT60/RX0lVoId2RxfKh1q8U4GFEb8FA9DxF4Q7aiGkZQmh3hjVqkB5Ni0DANbW/bjnXUdtrv6WT4cBBLikSPF+J51miFarfi8qaG1drhFwSNAvS/ucrhM7eyZbyDzmtzjP5skG4G+fXFh+ClE9rcpIcixmdZBDlVzN/xZMTYHIUIm3qm1JjqM+FnNRXRh9SAGgf5XRF2TSJtFYAZHfVsv4w7T5txoup/JFFarbsmkyIiqEzWzl49oS8avjsCrKoZuMS5ddPvQUzYIw2IZQAKQ2sx5xJ6etzoztZWqLIS0tIou6+ff10SZlQ2b48aILNf6Rqe0IWoTWj9ejWWax1C0w8F679/KAs+fD/Pt7VuCij1OIzPyyqZw5FQ19JY1FsUsGGytqGnnk/oC+rtxB3K3bKugdHBb73VUih5UauG+TqLnNIZnpYJczHOCqv9XdpqPBj5U9NvwNS2paqKembXlVLcv4qtWbOGq28s8sgfZj6r49/2+gLfvXiU8/5zOqd/dfCvv+EFai9uJ10jO4a2gFAt4A0KMrH9ukGqY4uSvzmVJI04kYcnogTRMm3DYwTYoCmmYHICdcVqoCQFdbGo4SjaNe3XW8nnArE+dvy9GnU12rpxgapIdJUjTU8BHW3bIlZ+ia9BJAtnvS2RenTKZlNONHK9cRkXpUQOsSSjiMBP6e8xfNkJSHtkJ46OcSyCHHGxpXSIO4oaGospzjXKFEZyMsxoSlE5uZ+xKo6mKCGMYyHiTSd2qi3lAEtLc3sNQmE2JwuEDuCsulrkTAGpO67S12EapKE+GRqRDS85Yg0//sXLiSYHlEKPWZlhKoHL3tmdjLVniKTgibEp3FmezxcX3cyD5Tk8uXsyYaek0t1AWJKXLtzAnU8tIP9oityTHpEHrS/ppzVdZXNxFsP1DH1jLTh2RBhZqnDNg9zuiNQ4VDstKt0WpSkprFDRLQCcnqlKz93VCGMxolGwGF4sCAoh7phayaUj6VnWh31OFwCLVnv8ZkMWZ9Ahpfmm5v4CmuYA4/s3yK31cMqqUNAEn41W9QyK07U2u8lOhFB823KmX9jAvn01229Yit0dkb65lR1nrCDfK9k3fzP/tebl3PKj7/LfxaV8Ze4BQMQjdOEdHeK/b5j+jZ3c+tpvMc9R/PTZTpEj17yWO/b5BW/IFTkivZJJtvrbV26YpZ6XVDSFNY1ujVRZ7HPBaYjuiCgdYfmCIKU3vEbiCDU0CGXXVdt2Nf+lnkOJFJqQMt6sHUNNsVR2K+6nMCGLa/uS7G69hrgwvMRQNlSDozAXqS7IoSBKSbK9ivc9ugCNtGvqUVqQ7/XxQ5uRhTZSCFq3RNQLFqnxiNRoSOTqhjpa8jLI2GpMpxInzYAWZk0x/7c1GHHZB/6Lg1Mu7s4Ujbk1xLCHO2YpZ8NkCzV6WG9TNMB6h4RQUOvN49QE6QEHu7WViIirFv6EN378k1zzmoM5+7AbeWjX8QqpDyC/xaI8U5KZrRamku8R5iLsmq0cRkeqmpByiupiSWMoQ31GxIn7PcLagxoMvX8FGzdXmccQ87oGWb+3oBbkyexWiHqQ1xxqT6n/hFnVqdV5NEf/W0bZZ1WDQ/5zJR1nl9jud2LzG36xdyfrv3cYuBE7XybI7lDZJCSUplukxjQHvZqs2YNL1fyJe0dogMXPWmRqIZVJai5b2ilrFARTHi3S99IC+Z1KScRuyBgAcqoyLi4NNf9c7REiccwnFHLuoUoVJsGXqcWJ90eZ/N2ovLRujij1WHHdRLzmCrUeywnfgXa2qx2KJhb3oggTsMkANkYlSYRq3PgF5awWtpq5J2lZZ7PuRwez8H0P8HzY2DuXx45xmAavL1LzJmXpRoKSfG9ImFaNruyGJHItGi0irjcyGXppqzEWaDotKH+jMlndt0aBuFFRkFP3JcxAFCTZLFOMauq5DI2t0aJkeO2apNYhEKEKvqUD3r+QAMpnPnYI7397K/PneH/9YMCyBOd8sYs3va+P931siM7Ozn/wGf5j7EXNSbfqSfGK4pdrlCFQjnfLZkmuV2/GxpEzyK5eTI2Si1siacGtkW5QG5wpSp1YqT+xwU6YSgpRrXriuBvetbQVwms4hWYRNCiE4RcapYV48bVV0ZLUzrDZhI3z7NSkQsItsHwt+6f5hrF6jHYsvHGVujfoqJAKWbLryiluFFRKLfT0Rm/UQSqS1JhUBVO+7uCqg5sYzdEOcuzgGxqP1FQYvZk5leSe2TW9CE3g77vjxCoK5n4b9YVYQccBP6PT/ZpiEGSIz8uMhchKnpP6AD1mtFayeT4mhY5IzskgUqYo1huFOx9ezNHHPUi6o8pDu6dz4+b9iKTght5l/PGxhYQIso7PQwf+lKWp3ZTCFME2RRj0sj5v2fdBGpHNofO3UJob4reqbo6V301i6KqZiEVFbl18My+ZvpmP7fUH/DWtIKByRJldKzTCb/T3fXXNk+9X8O+Ok+eQGpGkRtRmoLrQQn4H5LYq6o1TgXBqnd0re3B+v5olD9mk7IDQt1X31Eyy0ceUMJ0qT2/xqO1XJfIU7cquQ6VHUntpMS5KjOsuPC2t2CEYWpJi5D3LmfHGx+g5aQ1jC6C6sM7YPME3738lR87awGkr3sJD4zMJfj+Tvk+toP/fVrD5TRb37X8DorURO+jG3jDtYU7Z+lIAssLhAztWcPijr4+VmUQEP/rof7HUG8AvSDV/bYUQEwrCliDpACgTp8I01lIOT1KUrdrB6+6/kaItVDtVa29Qjioo5KveqjpGGqTTCvcMpKUQSEcSpSSNFkmjO8CqWjgVQW4HpIaUmpKfU3M+Nazmpp9Xj6PW4WAFko61IS3b1IDODIWal62pEikRr12mE6VRGTL8ZGPx+Ne1PJEDpzx4KlcXO/jUST+HEY/IVcF7rVM1PjLUsXqL7hwM5LYLdR1FSxUNt8NTX1nMy/7tQxQjOPOcS5g2ZYRbR/dhUVc/c16ylZe8/k9kjhkgciQtmRobv3sYWcfH7qgz4/DteHuP4c4vcsjkbUzpGOfwWZs46dDVFB5zWXtQg3kPpHnNR+6gZ9IoAE/2TmFK+zi1hTXG56susu6YmruNzpDxA+pEjiTyJNP/cyWT7m1j3Vg3P9h0BJ/90+u5YtNhPFicReUNh9E2exSkIDVkU50aIYVak5yKClJDjxiwqbULMrs1QlqFbH9EvUVMuMcJdah1S0B2d8SUe4tYjYD29QHF6VYsixumNMWk3aKRV1k/40zH+4ymk5g9I+4cbeoXwsRJNNQ6kwlGO5Uq8Je4ZahMsuIssamzisdEmIydWE1GQtvmEEPLckvJmDD1UHZdHVftUkFmcXEQUxxL0xVtbnQvVajfssZl8LQVbPzOcv6ZNvbO5fg5FRxVJgulty9Qajr6fqsshAK/7IZSq3GqUhV1j6vuod64yqYY/nh+Z4RTVtcdgx66ZiBMq2DF0AO9MeLslCmQzu1W99apqj3OZKNVgbLQ3ZrV3u9qNZ1/Bbv99tu5Z1WNz3+8429631FHZFl+UJqvfHb+P+jM/vH2onbSDWIRO6Xm/5ZaVMdnC2qdSerP8DtNgU1cSOPpiniNuJrUll3Ri5ZGmYKcRhfsCRSMeoLGGZSDKOGshSmttZ1KHE1TMGkmsHHMzQJpkEqjZRvqqD3IKnTPrqsiQqMEo6ShROzMm3R2TJ/RjoO0REL1kYk2upAykYiUyvE3CE6QFvgZxYcMdMV6mGYPlN44kMYRNpKLhioSOwnmmhy16BjpKUFCd0FoRZOSSiPHVCOhNp0gq5uaTNB/9sZ1Fb2c4JSLJKCKlWLsCeccJii+QT/NRqM2JInfFlHrllSnKJ75fbtm09iZI7yzg/JTbWzaMpkZ+VG81jo2ko5UmXtqEZ/d9jp2VNtxSwJrZoVTFt/PxlI3B7Rs50+37kVq0EYKGJ+jVtjIFYQb88z/w7u5beNCzvnJG0gNqXEkN+UQgSoORUDbxhBHa+huOFkFAVO+vZIgo+QBXV3Y7FSTrJAIoDo9ZO60AWaeuRJn3hw2FLuZ4o0ya8qQ2vwzWrmkpu6zW95TDsx7IqOC2AjK0xXdxb2vQHm6VB0dI2KtX6eqm+Y01Ngcf/tyRk9ZTmY3LDjlQWZ9YSVTf+tw63370vv9FnYtH2PLEz24JSi/pEzHtDFWPPIGsmvSfGjHcub/4d1cXexgxSNv4CNt2ziodQsAu6OA7027k/mtg5RmS0b2Dyj3wGc3vp6Lhg/nvNdejimQSw0KMv2C/Ho35hLbhgolkvli+Zo/LGU8Vs26YjJrIlROq2kL71TVnBGhQW4FtQkKLNJShbu2/uwoHRFlIzydwUiNEDcOqk3Yw0qzJI02SaMr1M9DEqSt2PG3Gsq5q0y2iTwRy/4pHrzpYKqzQkKvX4YLW0vmlZk3QkJjR463F4Y55zevxRu1mDpvUMkadoZIV8Z1J6Y3g6G7pAdVYWlQ0M3RJtUYfFuFN33n0/y/VW8n9+kMd/96P5a1bWVD3yTuuGV/+jd3YIXQt7WTqYv7mZcfoJCvsXO0lUXd/bTlqmw+pELm2M3cvnofVg3MovX4Pvp/uYi7ts/j1r5F7BpWKRAZCkYrGdxtacKMpDo9oNEG9S6J01mDskNhk8Wc0+/l3zc8xSen/o7+Yp7+/haChk13rsSTw1PwTtvJ1A+MMnv+LtxxaF9j0WjTnPYWvdbpbKIBCOptui5GO8deiVipygrUOlbvgGmfW09+Rx0RSqozCtTabJBKJ7veqtdJ7RibYk/HSKuarK5Qe5WIiNVo4kyuzrqaxnZ+C3GX2RjxdqBlW6R48Xpt7V5dpH19QGFHoJDlCVQ3Q/+L3MShLPVolR1PrV3emIz3vtCF6uSEzhGkof1h1VMiNZLsk+n+ZJ8oTVeB3tbr9n0Wu/7fb8ExB9H2xy7+fcNTBBlBbndIeYqtiuLb1PoaZC2tYCY1CKRoSk5NEmQs/KzKuLoVSZASeKUIEZpsZ0S126LWreaZUQqKfY9I7fFG1tLcr4nqdKWpdpK10EXSccG2hOzuiGy/xC3LuNvrC92iKOJTHz2Oz36kna7Ov52fc84XuvjBj8fYuHHjP+Ds/vH2oqa7GKcq0kiY4T/H2ucA2imLwxntxMXHRHqPDpJCIbOJi0jRJ4KcRtkNZWUCDSMy3OWJ3DwnQaxijrxxamWCWlkNVI5Rf7+0IMwm6S/DdY88kBGIuPBLxFG/QcttvUgaPr2JzGMddEstPALNSxeazqI1tcvTFOokIhF3UvW1o2UcFEB1ZdX8QiPBaLTnTbAEe/LWDRc7MKiepkYY9NYtETtKka3uiWrOQ4wSKUUbYmUK8zydSrJhGhqOccBDK3kupnEHJKn9MAWRVjAxXGvDnxShIKolDWVEBLU/dtJ6+DDdS0q0eTUGa1nuWrOQnunDDEU57rpzKVuWdbDznuns/YoN1DtDXjX3KQb9POtHuvjA1DtoPWQA24oYeGQSQUFihRZBFlo2CPy+TJw6NTz6MKdUMwYOEWR32Dg1i9S4xC8ICpsE27+wghlfXUn3BSsZunkvgt93IkIVTJluu3YDrIrFxvVTmXniVLhpFZsHlnJYx2am5sYp7pdi7NEuajqDkevVwdAEhSRvTG2+Tg1aNmmUzganLKh3RgppLCtZSSyJPa+EfXdBobAdagMEre4glQJGzx0Su1GgfuIhpAZUZ0q5LUtq3xK713bT8pJhHh6YRlh1eKg8G6EjsPNuOY760b/n3pG57Bhv5bf7Xcm7Dspy08LfAlCVdT6w7Vi+1HsikavGt6bkx0XC0lbj2DQ0MmMjnlNSUJoB7piin8RjOZT4mmPulKE2STLYpZyMyFWKGEZf29QTxHMgALtqETgS6UX47Uq+sNyTFGuGKaX4o8a9oLAF0iMCEUVJlgOj1qN+H14SMbzEoudOvT5kVLt7k2K3Gonzpy4ShK+cOBGq31U3NUgNWKzxK2w4+SIWXvUhBh+cjN8dkNrlqGxMWo2DTD8xHcvSa5pbVU5x5AjCMY/slBItx/dR3N3OUx8q8PJlj/J4cRrRYIqwLaT7AYvBo+rgW/Su7+barV24LXV6Osd4cP0sFpy6mtc+McQMb5gvPrGI3i1dHLjPZha19bNmeApdmTK9Ozuw29qYO22Ajdsn49ggW3wsJ6LereZMJZ/CHbOZ/uN1vOqJEea5Q1w9cihRpFKaMlJZsEN6tnLjpv3o6VtD39hS/B5Jva605jNDiu8/sryO7YVkVmfj4vbIVT0HMoNQmmZp8EFoR92mbV2VfT6wkXE/zZbjM8z+lSQ1UCXdF9G+BkKtHNLIK1lUw0c2GVUjm4hU95qY+pjU+YhQOcZuSe8HNeUQGqogKDAjMxRR67DI9ofktpaoTc5Sm5pBRKrBU2YoVM56JWDggBxuWVJvE3EW2a7ptXtCQBK5anKZLtkms5DbmQS0fkHJhQ4tsSBSVCQpoG2jpDhd0PGEz1htz6zZc2Xrv38oN736u/jyfvb30iy84jQ6apJamxWDC6oIW12HAq6IFXmskireFJGk0BsxssCmNF2Q7dNZ7FBlm8ZnWArs0/sLQqn92A0liRtkk+LSyOzbgfq+hrdnwyiDoEtb7WMGQJC6QWF6KGBsnkf0L4CkX3vttQwMhXzkvW1/1/uXLErxttcX+Nwn9ue6XxSf25P7J9iLWt1l4SfOQuTTNNpVy/ZIF75MbI4DxAUaYZq4QREQN4AwKLaRezOOtPolQSHMZxlKjZEvA5IC0IlayJZOQfrJZ02UpTK8ZyNdKEXi3BrELpYqDJNqcKNXHmsj+8nngEqTueXk+mJpNY20IQ3fPFGyMPx9gzpbjQRlNlXmoN+n743hupr7YJoYGUfdpPyDCQWz5vvN9VvRhKBE3+v4nE1mwCFuahS6iaMVp/A1DSRyiNO7YTrJnJgOi0atwm+VsWMuIjArnd0Av0USOWqRFr6In4Pli5hGZboYqmyMJOrwmTR5jNot3YhXDLP/pJ28pft+VqTGOGTlB5BSEPoWc6YOknV81jw0B7uikEcTBBnVBLciiWxFWUEotBapkHCrapHuF+R3StLDqjFKtdOiOFcy91NKKWH99w6jsNlSNIcwSYOPLQkoTC4hhGTya59k43eW8+Xjr2M4zPPQ+CxW9c7k8BmbueMP+8VpWEP/MAWKxTnq9+wu4qyQQdoMopoaJm5YVZofIB1JboMbd/aNHLj1I+cyxc4zHlV5qJFlfX0K315zFI3eHE5Jpd+/8rZrKEZpXpvfRKeVYzyq8utKD4u8Pvb3lIdwW9XmqIyamH9q1NjfS7MlKJIVgi/2HcNAXW36h3ds4N6ReXSnijwxOoXtT0whNWjFAbepN3HLiRqFFIoOZlLPRsLQ0HpMx9JGK7GiS+QqzrOhzk2sLTE0r/K8AEIB6QhqFoWNNo1WTYOzVUMtu6poMUSCnpUBkS3iYFhaIg6891jjhHIW4kJyWzCylxXX5ti1BKwozZQIX3WKtA0dzWQAU1Ca77P6uPP4TO+x3HHfEuyKhd/l4w66qri1oTMltWSuRSmD3kakd1tUZvt0Th2n7juUh7MU1rgUF4TYRQunqkCG097wG86781iwJfaYzcLzthJO72LggDxdF61k89dX8IXXX89vh5ZQCTwee2gOOc1fL29sJepsIMYUGrPikLXcv3UWwWgKkQ3o7irSv61dQ8vQutZmbGEI+ZCfvuwi1jam8p11RzGyqwACFs3byZRMkVKQYvwlA/i3zmL7QAdRIHB2pHHKSrElTAnKPWr8N7oD7NYG4UgKp0NVtTtrctTm1bHciMK9GfZ/x+M8fO0S3vr+W1lbmsqqm5Yw/T8TNab1Fx7KgtPu541P9nP1jkOoXzEVy1c8aSP1aTJ9hqYYukmjLtPR2tEOuZ9XGWBTQKsyK4oKObH3hF2HwnafWqdD6MLIYjVugpaQWb+SSkGq01ISoeNKGcoKkgxopDPDblkDXGYN1oi7AU3SI0rv3i1JRhYp8EPVJEmCrGTe9XX6VmTwioo24lQisjc+d8Wkr1wzTlr4uCKkJl2u2HQYtZWd5HdIJfM5pPe3hiQ1FiEiqQtBQyqTPbxiSK3NVtrnaSXL6udU4XetC7K7VI1KZbIKmtPDEZErGNpH0LZeHZvtV0o9Zp5jqfXD6O6DopuaINjQ1ZwqsUqcUU1Lj6jsd3G6aoCV3lxm1S+/8IJVd6nVaixaUOBLn+7kXW/++89v566AvVZs4Q+338uhhx76HJ7hP95e1E763M+fhSikVVMNEqfWFD5OlGU03HMzQUKzyJQg1iUOlFPYaAWjfkCUOCvGOZem+LChu4DpCWS+zziaBs13ysTIqCkENcWSoM5poixWrCoik9+NioxJe6VH1FtDnTozTq5ZMEUkE4UIR2vuikTaKUwLrIbxphNKjAkIpFCoqSoCUsfFmQutpx6nWB1dVCYSB9qgAqaw1yAwBvk3xTMmlRe3mhZqIzCZiLjpkn6vea6xBrWxSBfiWMTyVgYhNaiUQX+wjFMEQTa5B3ZVEHkSS2ugTwzUGm0SaavCZBFAmI9wiqpjqF3VRaialmTSl6e//kZ+sOkIhsZyLJuxg01jHUzJKSRgoJKn5jvI29tBQPmgKqknMmT6dbtoTUdoFHRQIFSKOD2qUp1uMWR0vhvTqnq+kWz8O85YEd87b1whn9IGvxBhddeZ0T1M38ppzDxzT+nGjd9ezsylO9k11kLqzgJ2Q31/kIWpKxtErmDrqy3VWCZUzU0QqjiqNjnEG7FxSmqTVmpEir5RnRGQ3eZg6exVvUvyxFvP55ZqnkerM3l14RGuGz2YfbPb+c8nj6NcSbH+ZVfscW69YZFpdoG/ZOeNzGa6N8QrMwNcW5zD5VuX88qeJwmlxZzUALuDFh4dn8783ABZu87Lcms5LOVw0dg0cladsx57FfbqArlde3aKNIGhX1Bcb28sccpHDvARgYU7bBO5Us1bV5LdodI3QUbNgdSoLihLQXWKHkeBIL9NUJ2UBK5hWo2vqfcGhCmLRkGQ7VcycGr+SULPwm5ESdGn6Sbsqnbshj8PMLLAicEDozhjAu/iIh+7qCKHMB+QX+/Gf7MacMPHzyVE8NZH3kPtoQ78VonwwS0ncpQTO5aaYKY6JSLTZyEdqM6vQ8WhsN5GSCjOiZBtPm5vSsld7j1McX070pHM2HsXObfBe6b9kTXV6fxk3YHkflNgeN+I4w5/mF89tB9uSx1rvaJ4NdpDUlMq1EselhMx7x0Pk797Eg9vmsGk7nGyboPeB6ZhNWDmS7fBK3bgTJ1C48cubakaZ0y/mbQIee+T72RXfytOKmRm1zAAm/u6yOXrtGar7OjtxE4HhCMp3FFbdUm2IMhLgkKE1dqAgRTCFzCtBjvSSAcOX/4Ef7puH1petYsPzL6bZeltfGLWct6ydhdzvX5GwyxP1ady12uXMP+nvYwHaR4fmkJ0c1dMZbEbqibI9hWKH7pancqF3C6FiIdagEch2sTjzggcxN1oXRJJxki9PzPQYHx2ivE5grZ1Ml7nBw6wmLQ61BkZi8xwSGWSjVtWTqfVkLhVRfdotIp4z1HjUXUeDT3I9/r0LfeoTQ4hHSHKNk7RIj2gsjjSgsyAOr9J9wwihscJ+nYhDt0Xef+jf3Gul990GLsOE8y/tsTk723jXZPu4RvzlgDQtbKd4XqWoatm0n3bDja/ewafeevP6PPb2FDp5u47lpLpE3Em1vTuyAyFygmvqV4IAO54QORZiEAiHUFpmqvrtdB+hAqmvKKp11JyquOz7Hh+5HZHiFBSnG4rmpLJAku1Ppr6tEYLsTyzW1brZnqYuPDbG1PPTmnRQ3G6Cgrc3VUe/OkZL1gn/dwzu7nmxiIP/G4G1oTGiH+PffGcIe5cWeGu+yr/o8b6C81e1E76gs8onXSzIBl5MNOR0iCrhq9uCmHiTms6jR/zvTVabuTFYsqGTCg1MAHV0A6goSgYVMroskceMSpnHFXDlXYqyful4QuKBBWHCUWnmh5iOKRALFUYN02SGklzxR7Fm2pj1m3i9XcbKS8rlPH5hlrBJdKOcJDRVAdtJlgw98k453FjDB0gGQTFIN2m852pHzDooumGaJ6V2eht7ZiaY5xKgqQ7FYUUeePENBQTLJiagkgXddl17bRrJN4dT7IdoP5W75TJfZIiRt6BuFGVaS7l55UDZWoQYlWhlHrdUKHq3RHeiJKMe+eHfsvWahf3989iXtsgG0e7CKWg1nCp1VyymQalrS1IC9IDivay9l3fpy8sc8QfPkrXHR7VSaqos3WjbhLSoza27G7VptogMB2XTEDnvn+oKhiVKk1fbxEUFwV4nTUa4ymcXIOwYdPaXmFqYZxJ6RKL8n38YUmO3b9YzPhwDm+Hh1uCnnNWsv6CQyEdcsCCbZSO6Gf9RYfQusYhPaw27fE5EKUl6X5Bpl/ds3q7Hp8oJ7f9hJ0M3t4T1y802mHyip18Ye7NHJUJ+eHYVNZWpxJJgS9tzu9Z9T+uAffUIooyzTxnmAWuQsxHogrFKOT9G05mqKKcuQXtg/RXcwyW8gShxf5Te2l1q7yhYzUvz/h8su9gjm97hCl2kXd+5xMqKK2rMWTFmQgZy+eFaTUW3RJxl8p6lyRoDXCHXLJ9xE2rTDGr5ScNT4IsNLoCRMNChAJpK712qyEIMxJ3XND1aKjnhNyj+FQVhQrccgRC6EDcIHGWcpZ8VeAqLcH4LMW39XMTHHVLadxne4VZHhT1La3ACbN+PvLe/2J3WGOynaYifZZf/kn8QoQIhKLm6AyYagqmrsGsp5YuHizNJFa3arRAY5qPDIWiQ6UDsg9nEEeMUqmkiAKBuzXNAa94iinpMR4d6WG8nmZoRxukQ7JrU4gIqlMjMr2WLsKT2LPLNEoe2bYq016/hq3X78viybt5/P65tK4T/PQL5/Kn+lR+sHA+Sx4UPDrSw8Ztk0FILj7iSo7JBMz51fsQvgXZAOo2Ihsw94cSb3eR6KIqpUaKYi1FcTyDHPWwAkFum4gl9SIPigtCRN7nffvfgyUi/vD+FRz/o7u4dutBfGTeHxgO8/x85368oedhbh3cmyd3Tea4eU+wpdzJW6Y8wF1jC7nj5mXUOyIm3wcje1kEe1Vw12ax6mrO276ab0EqWR8NXzyWX5yQXTXUQgNSpIfUGpLbFZIa8dlyfIooJclvsei5a5y+I1riPhF+XgEp2V0KSR/ZyyLXp77fLcsYqfdzyrEN0wI/q9Ybcw6dD42y+Q3t1Lu0k16ySfdbpIeI9dSDPDRaJG3rVMBq1aE8M8KuCbwxQX1phfcsuZcfrj6C1DaPmWeuZPr9ed7dfQ9b/C58afPNx49hxhsfI/j9TBa37eYtHau4vbSYB4Zn8bEZt3L6k2/gg/PuJmvV2dbo4ieXHhVnw6TeV9LDEqca6cyXBN0bITXUAEswsF8au6GQctVNVO+XTgL65XabHhZQ2KEQb1A1KsWZIs7cmjoCaSWAlqHDGd8iM6g7eAcKmAlTIlaTMcXllg/urgoPXv/5F6STPjw8zLy53fz0B1M5+qXZ//XnFUsRC5dv4eIf3sDrXve6//0J/pPsRV04CsRNReLfNZprCgGNE2Y0uM2kcqq6a96fFYaZlGBc3IGeDEXiZg9mQokwabojgmQjBmIetvmcuNmEnEDH0Zs4UeJ8m2sy6LJTNso1xA2VjNRXZCdosXF07brqYGgQtRgFlzIuOvVzSVGbcUpN1bpTU/8aB12h14kz8OcdV51akpIz/N64G2uYIAWWr9FhHQBEBm2vT8h2eLqAzlCLHOU4TNQuN5xLV9OWTPMQt6Q0aVPD+vnb+n5ptD7I6gzIhPek+wVOSbWvdyoJbWei01KbEuLn1LXndqj3NlqkokjowNDwDxsdEndMoeuFHSG3DSzigPxWALq8MsdPX8OB3Ttoz1VovT2Ld1MbqSGL3A6L/A6lRHR71eWB2hRAcbkL21XmY2SxYGxhRJSS1DrUc84MhWQHIhotsO5HBycDKBcQuVDay2fwCJ/KdIk36BBtzEPVIih7yHGX0Z0trN/VzWODU5nuDrPpmgNo/0GBly1eR2HZILUuSfrOKdgVi1SLilDzd0+isNbBCpSyRTJoNQdbaBR9RKGAoJze4d/2EBxQUkWqWXWf+8cKvO/2U9kYlHhvay9Htqyl3a1wfs8q7qgJvjc6k1O3HfH0SQ8cnrZ4VaYRO+gA7VaWoolwgZQTUHBr1AKXStVjftcglcDjru3zuKO4mE/vOoh7d8/h16P70Ru2qgLTcc3n9TU31QSy+l+nooJEE4S6FdWW3h12aF8rY2ULM59NN8a4iDcEfAtvxMIbEaSGLKX20hliVwStG2WcQfPzNn7WQH5mbkeYbsFBWss4egJpCWrtFkOLbYK0RZAWcXbKriXABBIyu1TAbhx0IO7uW5sW0OgIOXdoKUVpU5E+D9ULNDpCRfkKJ6Tf0etrJDRNR0vOkWQqrboK2Hr+2ICKzZS7bNr+5BKVXMqzIhqBjesFWG5EOL/C6pULaXFqDFfUpp7e6VB4OBWDGoaC5lQgPSRoDGSw0yFvX7Ca/R62EELy2INz+dyJ/82XT7+M4TDFQrefz238E0+8fzGbdnYzfdoQ03uG+a/tR/PbqodbaCB8QWprChoWDHts/gAEF9YY++FMsq/chHNzO0ft9RRL991CmAspLm0wsiRibHHI+N4+0+f1M2vKEHcszfCHJTmqXx7nvNWv4D/3+m+muSPkrDpZx+fR0gwev28u0eYcD3z9IGZmR7hq52E8NDADImhdp9RenCq0FqpxsSUoZ8/PJvtYTONMqfEauWq9c6qqYdbE3h+WD9UuhQLX2iyq3R7Shcwui6l3F+k7okVR1GZCeZp6dukhUwRtkdspKc4UVLvVvK+3KUc1yCg9+nqrctCNkAHA4EFtKlva3oCahdVdj8cFaI35uupf0WgBIigtbSAiQVCIiBxovSPLdRcfhbfDw1FiVuw4tMSZG1/DLcP7cP2yuQTrC+z87334wtyb2S+3nbL0aLWrLGvfzkDYwo+WXMkDxTkUowzHFh6nMk3GHULNXK51CvycRXmSTanHodppEXqC8vQ0IpS0P+Wr/bEaxQ29jCRpkFM0xXqLhRVIWjdHWL4kNRpg+ZJau3K2IzfphF2ZovYYu56IHhi9dRESO+hhWmXBTdAvHc3xb4HqJBhd8MJ1Ab/6uXkcuiz9nDjoAIW8xRc/1cHpn3ozvu//9Te8QOxFjaTv9XHFSTeOuCmiMZ31IBn8cYFNlCwSTiUZ+DHSrtHTuDjUUg5rTGkRxIi0+kD27NKpqSt2Y0+KjUEXDI8QqbmwJAh+TKkJJxzPnrSLuFOc5gXaVZXqNLw6wzc3soxhSmnAukXiIlHzWWazNQUqCO18NLQD7StkfKK0l6HBmALOIDPhfhlefJT8biQyzf0x99pkGpwycQMiU+0fX78+1ilr5z6tUU40Yh8lz8OoWjgVaOTVPZ/IUTepRtMtLu7OqGkKdk3E6L4J8kxtQZBRSE+tU52XQizR7eT1/QiI2zqbwKfRHXDNsRfy5S2vodRI8d5Z99Dnt3HZmsPI352LCzv9fLJ4KwqOKjgyspDF2erzFIeRWMqzfX0YB2rVLpvIga6LFKLe+9kVymHUWYxaJ6p1e6uS2fF6PbXZFCIy04scOHUHKzfPZe7bHma/hy1u3zmftnSVvltnKNpLKxx/4v0MN3L0n+ix4WMLyfWq1LZJv3rjyjkwWs/p4YDidFfpdqOc9/I0SXaXkjasdsNxx6/iO1MfBGCtX+bqkUP56qTH4/n7yV3LeHx0KkFkcdveN/HzskLIX5f7ywLBC67+EKkhwWtOvoejCmvwRMhXNr+avVt3Y4mIX2/Yh4WT+5mUUZFoJUhRCx22/nRePL/MnDPB6cTeAKEr4oDSBN1xYbVIHHK3nNCz/FxCo2t0BaR2K2UXw+13aoqq1bYpUAVsmoJmeOZWoOk0llBIH2atErH6RHmyFRcKp4eU0oRp9mXXlTMRZIilRU2wHblQmhOR22pRnQzZxSOM9ef5/Su/i4tkOHJps3x2hRne9/C7qG9swRtVnPYgoz9Tgx/umHK+/JygOEfizCjTqLpQdJi2YICq7zLU14Iz4sRZKKUZLwkn+YgxB9nq4+V85Lo8+e06c1GWen0Se2ThwjQ0lpXJZet0ZstYQrJloJMoEoR1m5nThjh5+mq21Lp4+ACY90CajcUuso6PJSQtbo2dlRbWb51C5x89ap1Q7YlIzyziOiHjo1mWzNqJJSSVl+5myUM2tpA8OTaZ0XqGjnSFR9fNYOH7ldb3xm8tR/Qo6ampnWP03z+VX51yLgUBrzzn00RHj1Le3ArdNcKqw3sP/SP7Zbfx86ED2HFoidprDiHIqufWyIuY623GYK0tKWaHJJtp9hYjgWioViZTadegdVMDaQtqnQ67Xhpi1Sxa1lsglWNuwChpKTQ722vhlhKhAacmKU9VY9N0dvWKukbKS2Rc7bp6XvkdDTa9wVGZRsAds8gMEsvlWhpVDjKKkpfdqeZUeW4AriS91Y33nvQQtK2rMnBARtWBODB1pY/32wfY9M3lfOnE63hjfje+DPlNZTIb6pOZ7g0zw1XV2zaSmnRYW+9hijPGAm83p296Ax2pKg+sWkh6QMROdOTo66qpDJpTl+S31QhyDsOL3LjmJkbjdcbXBOhhWnHN3YrE8lVQXe2wCbICP5c8J0Vbklq5TJAajzA9GeJGhSIRWAAV9Jenqd9TQ+DLGk9954XXcXTz5s3svfc87v3VDPbdO/Wcfa7vS/Z7+VY+8v42Pnx6/9/1GRdccAHnnnsufX197LPPPnz3u9/liCOeGQx697vfzRVXXPG01/fee2/WrFnzrL7vhRtG/ZPMqidIJpH6iSvj7QlcZj/ZPO2aasJheODmM8z7jDSf4YeB3hB0YYxBYkF/j/4O29efpZEwI/PYaNGtuGWy2ZsiU6FR+D+XkjQ0nchhD/6cnOB8xs18fIX4hZ4gyBr+KloRRWmcW4FKgZuuaCKSin8XKA6ekTtUyL1aYJAa/dYbuml/7meVVnmQUeeWcNX1ecrkvpjXYgddO41WmFTVh+Z+ygmZCc13t7VEoxXoYsaqRuobJFrqppoeYl1opFpoLV2Q6Y0qjp/h7ntj2mm1wSmJmCIjRaKK0ugI4/s+ulBS61KSePUO5XS1bQxjVMvIUppCrsgGq2rxhU2vY33vJHo3dPPVW07iil8cRbQrw+iSkLZX9uHUwG+NqB1cpry4odKbQ2q81NsTST6/RenvWj7Io0bU31ssPTYFTlWqIEJbrVvJ5QVZlcrteELijltk1ntkNnoqi+RJ0v0WtW0FJqeL5Fdm2HLWChZldlLw6qqhkqYUBTlJf71A/ymT8PeaTjCzBgJSoyEilLRsk1qOTm8yKcHYXC/mcFq+pDoZ8tsnpG3r8MddcwHFKV/k5sgacqu2wXoeS0guW3gNoJxz46DPv/3dAOwKS3u8Z/5PivgHqGPuKC5mY2MSB3T0cmzbYyzLb+Xlc9aTdxuM+xlKfpq+SoGOVFkV5GXU2DFzAkHM4zXj2AokQVqNgTCldcx14G7GqWcKlV3irJhbUv96Aw5+a0S9XSm5hCmUBB9o6UQZn4NZY9Q4lNiNKJb1s0KVGVP0NaXRnR2IaNnix4XgZi2pd6jlpTolUmjdhEAaILfVIsxAy5Ih5nUMIWzJPCfPTKfA/l6aaXaGG0cP5rz9foppGOeNSYJsQl3I7lLXX+sQVKZCYbNA6m44malKiaX8YCd20cGuC+yKFY9tEQrSmz1VDzLqEm3Kkd2t5p4JBE2mM9LrcKgLfsPeLOVHO9i0s5uxWgbbjpQSUMWh95GpXLP9YJ4qTmb7F1WtRn8pzyNrZjM1M0bKCphXGMTyQvyCKdQWlIeyFDe20zN5lF2lAo9t72H9FQfy5CsKPHJARP/ls8m+chO1l+1i4fsfYPzty9l07f4gwHFDbDtix1OTSY3AB9a9lRU/+yRT3rAVy4qI2n0mdRb5j5f8irv3TWER0elV6P/lIoKMRb1gEWRUIOuVIi2HqDT4M8Oq54VZd00tgJFMNWu0aUwnpLpHli8Zn+0ReYKGLkpP77ZwKjLu65Ee0qBBC7qPhkJrTRE6UvV2sKuq+V1+Z0SYgvIU9bz9PDF1NEwJRhalsNobuEULd9wCS43z6iSNItdUoB65at+pTlZj1R63oaEog6bx3uChPps/COP7+lRn+LQdNMCOU3x6b9yHzkfgkcosxqI6FRlwcHoHvrTZ6bextt7DUJgnRHDb+D78sm9fhsI8j9Wn44c2O0qtvOuoO0mNqEwpGqQxTQNrXUpJaXxumvJUBxGp/cGumw69el+f4HdkByIKW2tYgcQbD2IltsAUnKeTbL7ZL3O7Ve2JiNTcVjVXah/O7YpiOmxxtn7mZbWuT+x78EKyz31iX05+XeE5ddABXFdw1hldfOWbwxSLxb/+hj+zn/70p3zsYx/jjDPO4OGHH+aII47guOOOY9u2bc94/HnnnUdfX1/8s337djo6OnjTm970rL/zRY2kL/j0Wcj2tEpZecSdLA2SazpfxuomphhRJg6v0ZyFBIGInX7MpjxhUzMOtp8gy5Y/oXBGJKh0zI23k/ebSR1vvHpym/OZKOdo+OgiJC4QjJtW6A3YvN9qJAtfvACI5HzshkIFVLZAxuizFEqyDYhlH4Xm1JoCVNWEZU8eud1Q9znIJg666QpqnGRzPhNbYBtUyNb3wehwGwTZ8oklD43evMlMmGKqieouEylK6qYlgZC5r6aQCqmoFkZ9xnBwzb2eqOJjioJN4VXoKafeKVtMuT+k3qrQriCtEHaltS9V6l+3WE2NCA5+7ePUQpdGZOOIiErgknV8Vj0xF6+1TmqVQoYjVwURoeYtp8YUdSAubtXBY3bRKOVymuzqDJELrRsj7EaEtAV9Kywmr5Lkrr8PgB2fXxFvckhdrCuTQCdMKdQwSkcsWLgT8dl25Nkj7N26i3XFSTy5uYeO+zyIFBL/mpPv4cH9BZuu3Z+9e3bROG6c8RP3pTjdigOCeRduYts75mKkM71xNcfsOpSnKm5tuWdC2ndWwAnLHuH8nlX8tupxx/hizp78SDzX37LpKA5t38SJ+ce4YXwZn+tc97T14KZKlusGDmbLeAdDxRzV0TRzZ+/GEpKXdW+gyy3S12hj1M+yV7aPEItIWszyBvClw8OVWcxMDfGj77wmpr+ZAq24eDsOvBVVrDopGXduUa09flZdb6yKNIH20mhT86fRpsaGdCXSkbgjNqkRPb5daNukBmBkK111pdUsNF1Pxvx4s4ZEtoglUCNHFY665YiB/RxSI+q7TXaq3g6NdtV1NbNLUO9QtRqRq8abn4dKT8ixhzzGqt0zueOAyxmNAmY6BerSxxU2D9ZDLuo/krvvWEp+q5adLKix5JY0p3h2RNfCIYbHswQVFxlYOGM2+e1KFtIUWPstEfmtCsk1spYITanzFcrYKIgYrTTZN29MS9rlSSRqbajO8En3uvjzqkQjKfAiRCZgds8ggzdPp7h/HWFLrL4UQsLSFRvpTpVYdfn+hMeOMj6QI73T1TUTktSQenj1ToldEyw/+nFW9c5k/6m9PLq7h6zXYGBbB1bFQk6q09JaoVJN4Q+kkakIYUuo2bgjNn5LBNkQJ9fgs/v/DleEWET8cuAAIgS9F8wn855eKpdNi+sRDBJu1yWlHhunphrvGODIZHxMsJUdiHCqinbRaBHx3qWoj5DfXidyLTa/0WLBh1TNh7Xf3mw5qY0gK3FLOvga0cXfeeIgLLeTGAVWvQGUkxg394uUs26y0alRaN1UZ9uxqRggc0sqo50eUEizFSrqTKNFjZ/UvuoZiIZFasAmPaSDvk7V9VVEMLpIEqUjclttyjOU55oaVg794ac8yNlT7mIw8umyXH5TmcyTtR6W59YzGubodsZZXZnLcYXHeM3PP86nj72ZLbUuHhmdxn5tvdz6gxWKDppX2u8qAybiLIOhHnnjkiCr1LmMHrxXVHr5qpvwhJqshtpTWzc2GJvrEaZVbYBR6ckOhnHNiZ+3FL8/JTC1ZEjV3Mo0Roq0go85n7BRY83FLywk/YEHHuDIlx3K2ntmM22q89ff8DealJIjX7eDl63I8rXvDP1N7z300ENZtmwZF154Yfza4sWLed3rXsfXv/71v/r+n//857z+9a9n8+bNzJo161l954saSTeSVEbOyNL63dJJHL7QU0V/QVbGzYh8nfaNiz4t7VwGiYMeN+nRyKtBvWFP5Nh0KjTcT8NXN8VT5vjYiSTZ+A2f0DjhRrPY8MyNNGGUIk6RxZ3gdKGmr3y8uLDV8BKtUBeQ6YAhyBgZN92ZVCRcVqcqYwfdtJE2zSwik9rXzrj5MSoDarNV3+GU1WeYbEPkqftt0uxGYQKIU3qxvJ126qRQhaP11iQIMi3nBQmKZhQ2TAGvUYABPQb0OcadY9OqSCn0kufqVJPi3InKPLH2eltIML1GfVJImI2wJtWIPEl5kk3oiZgbnO9V3Mowo7pJhhnlVNfbJQ/snEFvuYVD2jfzwGPz2DTUyfZiG0sWbqezpYztK06iQTdzuyIyg5J6S/KM0/3KqZIzq4z3FZCR2hCCLBRnWkSuxcgCm7mfvlc56Iftx9DNe2H5UNy/Tnlxg/IiXwVeuvi21gXV/ap4wxaFtQ7b7prJxjfn4RU7eHSkh3U7J+Nt93DLagy1bI347Q8OB6CtpcLGoU46fp/igE8/DAKmnb2SWV9cSThzEj3nrqTnGyuRFozsLSlPl1SmwKwvrowDPKemtbYrFrf96kBuq9q8KtPgZ2v3Z8UnP8hnd+8HQHe6yFyvnwVuPnbQ/xw5P3fTsRScGvNbB5HAK5Y+ydunr+LDM28H4IHx2bgi5DcbFnPpphX8sm9fVo/P4s7xRVzXfzDXP3kANlFCDfBJFIzMWqMDaFOYabJp3ngybk0HXTM3TBG2aWyiiigFbkkgXYnV0iDyJH5eHeuN67HqiXgcqxoP1e1QnYeIs1EiSs4nbhNvKdQ1yCn0vN6RUFK8MShssuKi0Uy/eg7euDr/9pft4qmTLmCokeOgydu5cHQpBcumFNW4t+5hYXHN8GF8YsqtSEs5/VKorGSmn1iWNkpH1H/bTVBTDnpmu0O6X2BXlcSpcvQkZEMqPQrJdcrE/QsaLcrpCVLqWuutKnMXppWD3mhVToxbgvLMEKeiakfy610FZOzI4FQENCyELXGO3sZ5/34RqS0p3K1pnLkl/M6AWuhwy8NLqE6G8cEcqV1uDC60bBBx5i3TJ6hPCrhvxyxqFY/7N82mPJwllBbT5/UzeZ9+oqpD7eEOom1ZpQDVsGjpLEMu0P0nYK+5O/n+wddw1q9P4sd7TePKvWaw69x57K7kGdgfPDvEK0WkhwL8rBWvXaolvfq/KUIO9Tpl6nzcsqR1zSiD7ypTnCV0JlEpQbWvrRI5MHBAGue2h3jzoat47RNDnPTkIEddvYqZX1pJ2OWTPWSI7H7DTP3WSrouWhnLbFqBajhkAtV6uzqXoSWCkcUweGjI+BwRZ49ArU3ucBWsBKmvTg3j7LUZ30E6UUwq7s4jXEl+kwpcq5NgZO8Iv6CyhJELhS2C1IAqik8N2qS1lGqjFX6/eS9e8+SbqUmLMelzXHY381K7WVvvUTS3sf2xRMRVw8t5zUtW8/1LX8MNdyznP2b9mt/37sVrT7uDt3/yt4wtqzOyN5SnCaqTIegI8OfUGN/bpzRLMrpQMD5XUu1WcyffGxG62lfQgJ9bIhazKGzziVxVT2D+HrrgFSNV8C0TGpfZty1f4mdUk0LTXdY0JHPLuiNpSwIwvlBMSsmn/v1lfOwDbf8QBx1ACME3zuzmOxeP0Nvb+6zf12g0ePDBBzn22GP3eP3YY49l5cqVf+Fde9oll1zC0Ucf/awddHiRNzOya2DZCaXCVEmLEGzt4KhCjKQZQ6jT2TFPXKMN8evaiTTKBebzwmyisS5t5bAb7W2DVEo0aqU56kbZwETAeyicaHnHiU2WpEOss2402yfUwWEUJ0Cft+bAiWjPxkDK8RfJ+ydkDoyO8kRN5cib0IkUdb4GoTFdWb3iBETRpPYtXfg5nCwihrJjUHq3RCx3GJl7nYZQI90NWxV7Gj1209rdfI6RhXSLxGh+5CUIRZAh1oKO9dn1v0Zlw6qTFBBbyfO2q8pprU1SknhRSuIWlbRVZIM3ZBNU1EYfeRJnXZYgqzXUQ0mQUourFUgyQ5LKdIjafJwBNSBFKPDckKnZIncNLsDrrHLJsit4qDqbx8vTWPP4TPJu8ngbLTCyj9pgC5vAKqogbOkbnuTJocmcNH0dNzy8jLDmkK7ocWVDtdOi2qNW6x2fX4E3CvYvc9QWSrJPplRgmpcxv1SMqWtuuSejnLicygJEHSoK3bx9Em/efzU/37iCRkEVMPlZKx573lUdzP/IehqRQ6dbZtLDKhqNbpvBxrUZ/u3ScX63TwtBDlo2CUpHlIk25eJn4xbVeft5SO9Sm9Tl/S9hZ8caDpq5nWu/9Qe+MriYS8cn85aOVTxUnc1Hx/bm37pvZ4GbZ4qtikWPefLV1AIXzw64fesCugplUm7AJTPuie/p63Jr4/9/4PDV3FqZSSVKsbY6FVtI8k6dVy54kodLM+NakRg9J8mcmVoTNYg0clxW1+FMUF8ygf/EAnG3oh12T/2tPCfALtqEwsXSa5ZRbGBAz79Ixvc70k67CEAImTQlAsqTbTJDEbYvsYoyVnExTYyCXKJ0ZJxhK0Q1+jLLii7mO3LyemxhkXfqjDUy/OjOo/n029cxFqmq90PO+BCDB0eMLsuSGhaK/tWq7kd6t4jXVFxJ9YgSjKdwhxxF9akoOkOUUoGsFEDNAktSnh1RWGerepJWdT9qmgqU3aW0oQ032VCljKJWbpsNEbQ/YsfZnFAH3biRUpMBbi/uTb0rxK5ZRDtziJaANq8KvsDZdwx7S0tSAxTpwr6UuneFrRK/z0HuKmB7ahB7FUGpr5NxVy2IrpD4eUl6UODrOZOaHeBlfOqdKay6QHy0hXt/vIAfn3Q+xdem+dyTr6c13Ud/sYDlC9b3TmJ6JPHzNunRCLcU4udtUqMB5alODEa5FQW0mODOqULLZp83X387l2w9nJFlklpkUWw4TLvWJXItKpMFPees5ICHYdjPcffueYyUsrRkawxcWeCCw6/i/931TrrudnnF42WuWHsYje0SV6uCuUU1lqozfFK7XeRRI8x57ZMMfXAFbsmm5eqVbPrGclo3qkZqThVGl7Zi+YJGZwihnkx6zXZLUJquFLVq3WpcukVHZWo95YBmdoNbspS6maZ5hp7K/qSH1fyotwkV4PmSsC/P1iMd3nH9pxhdLPnUq27i1JYtvG3Tgby/504qocsvPnc0O462KGyyyA1JnKrg4+ecxoJ3PcVN25eQdgIuPuJKzvja+3j1x+9gqJHnoMJmimGagzObWeyGDEc+N5cWc/G6IxjqLZDbauNUIdcXUZ5iJRRPFUswsperGn9lgRoYeeQgY+FWIqx6BBkbK1ABWWQr/r/tKyTfUIicKnHHUkfT5xoZXlB222238cS6Br+4cuo/9HsOXZbmhGNyfPU/9uYb39u+x99SqRSp1NNpNoODg4RhyOTJk/d4ffLkyezateuvfmdfXx+/+c1vuOaaa/6mc31RO+kmBWppCgYa7Yq7jEJcZGlreb2J+tmGJ26oIsY5NXzqWDlFy6jFKi3aGZ3YaMAKk/ebDSSyATdx6m0t6Ri6xAWNsWOp0XSDlBsKiLkG0BkCvUHF7zV0lgnSgKbJiEGITTrUOMgAvq2KkoQw3yn34MNGrtCKMLpznkbXjTMtUJuoU0o6JJoFxOilC6kW5Lglsla4iRywA2h4iituOOrG4iY6Min0jDx134wjYOuCOKsxoaBU7vnMRQCpiqYCiETT3m9BOVx6MfVGhc6OKHS83g71DtXp00pr2KeieMTeiMX4XEgNq8VTLbbqffmtgsaKOg03wtmWJsxKXj5tPQ8MzmTn41OYt/92Lt79cnZWWti7dRcz99rN6PqeOMMQORC5Ed971ZW0WRU++IMPE3nw+A2LKR1QY3V6Bh33e/hZYv6zef7uqBokpuFVkIPJ90lFaekSWL6gOtdHbnMVlWC7iAtz7TrI7jotrVUarzqYBac+QP7ROvscuYHH7pmPN6aoOH4Wtt2wlJlvvI/hn6jbch8ONg+y7YalHNv6FPUFDg+OzQJGSI3A6KIIZ0uO2f+hmtN0/ymiMsmKgypThJWxfRZ5fXx1+/HcNDnLRzoepN1SqgB7e2t4IpNjnpuoBAxFZfzIJu341AKX2Z3DDFZyzGgdBWDe9R9k/tId/G7Rr+L3TLLzvL0wrH5p7eMnpXYKhSqT7CJ/qs1kFcvimgYRQaSdCsuXcREnKPoJAuodktx2Qb09mZMKMZfxGuHndFAcqMDIqgsIdPFf0cZk7Qy/enS+cjY7nwhjxNxIuU0MQkNXICwYWRJRGbBiOlyQj7DryvlxS8QNUgySb7JME3sWSFvNlav/uIJ3nXgfl828m7r02a+vB1CqOUemJb//6ne4sTSL4TDH6R/6La++8ZO4s0rkMnWCrV2KGuGBPewwacYg28dSpAcTSpxCFlUjJWlLvElV2n+eY2iJKngN9NpR74xITy/Rnq4zbHVhNQReScaOmtBrb6VbobB+q0KU/Zxe11tC0rtsRODQPXuIHZ9fwdGFC7lh6v5URzNY4w6ybnHypFXs+vk8Rj4aUkX1EShstjBdqMOU5mV3CwpbJeUeoYuxFQUns1uNBZNxNNrflg+NtojB4QIytLBcFeTL9Vu4Z1+PeziQwx4JOG76E6za3yb36wV0H9LL1l2dVLps8jvVmiMFpIZ9gpxNaiyi2mmTHlGDIPS0JKzea4ozPW4fWcTi9t1sdduphw79YwUO+coj3LlzHlPPlpy6bhsznCEeqc2kr9LCK3ue5MDsZs7PvILvzFvM/JcEvPOSX3BYegsXDb+cRftvY+sfZsW0L28c7K4Knzzi91y7aCqnrtvGBVvm0Agc1q84lNSgoDRN0TCCrOqMHaYkzriFNyqo9ERxoFWZrJ3PHLH2vAhBuppWose6PazHj50AaqrGSs0tt6T2q0ZBPYfuW1Lw1gHsh7v59i9ewzkdAd6Aw8ei+aow9N1jHDltK3/ILGbcgnRrjcaOHI/+ei8mPeiz9XWCoTkFTv7U72izK1yz9iDWXLgU+/YH+QWd9P/7Csbnq14AN3zomxT38+gPCwwELQwGBS644yjym+091M5AjU2nogKSzKCI553K3Cj5VMdXcrlCQr3VotGSdCzP9arA0S0qZz9MQxRA+AJD0nfs2MF++3i0FOy/fvD/0l5ySIYLruqgtbV1j9fPPPNMvvSlL/3F9/25xrqU8lnprl9++eW0tbX9zfKPL2onPUyBGyUFjE5ZI79GDUUm6JYUxKm2yNMONIlDaDWIUXTTiMipJBuY4bFD4lDLSNNkzNushGttnKeYV66R/Nhx1ouV4VVjnG6Z8MGjCZvoRBWZyNHxyASOvFFmcYxzb+TXdApZRIprZ4IQ26DkdZVKdqsC1RAokWcMbbXZO2GSupNCOfYmkIi7GcrkeoyeupGPNAh8mE4q4pGJgx4j51YSbAmdafBzyWcannOM+OvN2jW8ch3MmO6jrn5+xhmNNerLavNNDScZCDMGwozOABQtrGELv9UizIXYVRtpKbQs8iR23VLKMzUtoRVpLuE9BYKDqwQzali7U7y74x5u274QaUs27epmtDXDeDXNQDlPPlWPi4jMs8r22nz6qlMVdSsF1WkBwbCDHPWYNn+M4fQ0yjMltm4jb9e1/OSYHs+6oNbyoTJJNZVJjUoKOyQjgavOVQeVUlOU/BaIGjbTWscY/ViD8tTl3L3vvRzwcD8Pt87BKdsqVSvBXq3kzirbCux10TDbz3J53ZxHcUaHqEYuB3Zu54kD1QSMXEgNWTTa1YDyijCwv+KPAmr1CqEy3+c93XdxcMol9G0GggKf2HEgy1q20uOOsMir4IoASy9315daOe8/PoifE+w+sURLpsZYlGFodwvpaeq7RSD2cNDn//RDRO0+XrbB6hU/JG+l+ea6Yyg/2KnQbx9yejyZAmJ1ESr7pOaaerE8XY359ID63S0To33SAUKR0GMaysmXtiA1rHoYRLpgMkpJUsMWmQEToJEoU0mdsZEips0YRzcG0qVk0iqL0fl6nXPACgSTVksqkxRNLTUqaehukyKASKsimdS86W9gBVDYZDPPzXJVsYsv/fYNdDxmcdsyj/Eow5mXvYPIhpatqk383I/086PXXswHVr2ToU0dpNsUrz2QKoPUnqqyXSq6zcSi/czkMv76FoWmr88jpARLUp2iKCbj8xUwUNuRp2NRBREqlZj0oCC/Q1FdgixUJ0fIdIhXVBSXhqbcZQ8ZglWdinaUjejb0MWrXvsQp/3wNP7rfT/grtIi/jQ6ndm5YW4a3h/n96spvucARAC5XapQOnShMlWS7VNrYpBTGbOOJyNG51o02ol512ZtlnaynogA3HGLetamc+o4w7KAl2uw9ar5fPuA6/Clwz3FBZzY+jCrOADXDtm2ZioIGDwwot7ukt8ZEaQE2cGQeqtNalwFbWFKd7V0LNXUTEv/tW2osfrmfZjy8h2UGylcO6Q6kuap8Ul8fq9fc/7dC6hFLtOcMk+IEM8Oufzh5dw6ZRG1wKF64z68fcG9PFaZQY8zwsIPrOKAP0k2ZWbFHU3LPZKfL/sRKyvzGPv1AjbXq/SPFkh5AQfsu5nKK0tsu2ou9SdbSA1Dy5aQRoutaU6Q22aRGlU0FitIAv/aZKnkSMdUd+ryNLXWtGxRKkGNNj128yqzYuqTGgXIDigVnEqP4tI7nsC+tgv/JQFWXjUbK+w3RqmawhaS2pYW/ujPI7vVpd4ued2Bj3JLehHDrQVOeOsdXPjwS/nh/3s9ows8Zr9tA87DebacKJEnHYZVE0SpiOx2i/LiBieu/H+4T2S5+NQLafFq7JPq5SUnPEVO+Lx59fvJ/6ZAozBhr4pUQ7ryZBGDUpVJdlzfJR2dTRPJfDEN6SJPrTNhVtN6dXaaF5iT/s+2hQsXsmrVqj1eeyYUHaCrqwvbtp+Gmvf39z8NXf9zk1Jy6aWX8s53vhPP8/6mc3xRO+lORaWQ91BM0Tz0WGFFvx55xKhV7BxrVRfpJPxxozQihEq92tVEgspI8sX0EVelVifqlBtHM37NoOoGAQrAihJkIHZCtYNgkO5oQiBquNPAHsVCZqM1nLVYlkun44Uu+FNNRhQKFKQnpOV99T1uRTsAmuc98bvxks8EYuUW08RoYpp/YtGrka00PPGJtB3T1EXausmQnbwPK0HcDdJqN/R3acWCSP8tSgGNhNpkii4N39woXIC+x7qY1nDmy9MkuV6FikqU427qHEJPaqkwgagpB126ktCVvPPwe1hbnEIgLR7eNEPpONdE3OSGnWlaFo4wFlks9TJ8YMEf+ebQK+loLTEpp/jUw092EW0XYALGCZt9bWpAYZ1DbbJk1px+Wveqse72uWz4/mI8V5LeLeJMj5+D7EBINbIZffdyWrYEBFmLWpulxplUGsDZwRCnZsUBkqEgeSX1vcGww+5SgeHeVuTykMhZwcMHrGS/u7bwSDQbobuMOjVoPNSKZ8POs23qT7ay6iQb2MlW/dg2fms5md2qqNAtwswvqULWls0KRXfLuiDNVtz4pfO3MxplgQYdHSXe0/L/2fvvcLuu6uwb/s1Vdz+96qhLlmVJtuVuGWPjAjbNOPQeIAk4kAKhhDwJKRBIgIQWSggtBEIz1dgGjI17kZtkq/d2et99rza/P+acax8lecr7vlfykA/Wdek6OvvsvVedc45xj/u+xyRvLE0ueQhzfL3SzavueRFvPO9BXtLxOPd/8h85EVX4zf2vZkvXOLf//AIufeZe9n11I89xnwe25M6GzQpnkfVuAW9BEA+HJImgYKnBVN/eg1dW5xRlUQ5Hia4g0X52TFOiyNfl+nyCt6hoOnagLD9TYCBpj38j/jIt2dPGMpr2lh1XFYXqcu0r31D868xce6wllqrwxEvGn/l+oyfp3itp9Fh6HlOVryijk/BYkGiqTmNA7dfMJ04NZNA+ViSc97dvRdrw8tc9wMi1c/zJvhv5w3V3quvgwNQVEbmuOtNRiYU4TxzYqUjfq5BS+aofGEH8huILmzkxcSGse9hCOUmFpZjIt4j6QoSTEI5niH2JFQhKRy0m+kt85CVf5YMfei0f+9NP89p7f5viU8qZKMxbyKZKhrKTbXFyo+W2QZaaReJJRuudrHzOMf7ynW/iVR+8lc1Dp/jKC6/l8PuziJslcdlGdkZY424qAhQIWp2Qm1SJRqMX/EVB8VRCOGcpr+pce+5N7WtjRaGzIogqDs6yBFF2aIUW73rG7Xxr+mIskbB3bpBlWtl76ngvtlS6E4DaeQ0SN4tbgUZiUxsSCGlrmgtEOUt1jA5lGrjPbczgVWDmthEG//5BTty8hd5hlbn/6+QldD8A2ysZ7pg7i8MLvVSbHrm9PpPjg/SdO8nMXAeLUZZl3jwnwx51HJGPs6GM80BJN5YT7GiO4IqYvlyVWFp856LP83hzJV89eQnHPrMCyuAKFVBOvLRF5smcQrAXSK1crUDT7hJVAc2fVD7gkVnHtKNYqyTafUdi8HQ1yIokYcHCL6PtR6FwUvHyGz0CuyVY+SMIs75yNir20FNW4vraoMDflcOtJVSWW3z77ktVgyUbvvXAs+lvSiYvFHDhIrvvXsfI9hZHXiPAkoi6jxVA8aopapMd9HVWOfeF+/i9T9zEppfv5fKug1yX30dTWnz43O9x39oN/PRfLlHnG2jLVnSlId+eL4wDlLFSdmtqfAQdauy6NUlQECmdNNE2yXbAaXbTvyybBJL/guwhQWJZ1v+xYNbzPM4//3zuuOMObrzxxvT1O+64gxtuuOF/+dl77rmHQ4cO8aY3ven/8XH+SgfpJig2Th5hQS24qauJQAU/S/jNBl2XNmn7eDSSK2JwEt2iN2g7tqRcSx3kp/vVwb5pSIS1JHi12iU7Ebe/Qy7hVEvNUU1bBdNeME2Abzjatgkw7fbPVJBqUD+NFAsg0UFw7EOcUShvdrJNQ3EaqjupWlRlmxajhWcmAFeCVfX3QLdGB31chhagRa8i1FxvTSmKMjoAyrQrESZwb/WrknSUN5QRFeAmmrPo1AxXuo0ipu48CalHfOy30fDEXSLkW1IBMYlXys9PlNAtLAjK6xK8BUs5bGjeYFiUuIsiPc/EFrqUrwKIyVaJ3VMDLOtcZGRojlOVftyyTec50wSxzVkdC+w6Pky22OTK3Tfg2xHWostZZ01y/72biLoi/IZo2+Q5imKTG9eTd6w8h19y5UN8+5GLILQoaK2kHagFsD6kfHKLs+DUYkSXamCT+dF2Fl5/adpV1q0rLnp5hdN289HBhb+g0Ci3BnJWsLinGycRxLmEK256hFvWbmP1Mx+Ez6xi5OoTAByb7iGXbdH5mSLeX+wFYPRPtlEfibGrFtKTdO4VqVNHlAFx8dkcfJuDc9LSfv5qvERFiPMJT+9dwbf8i7luxX1sGzj274b5HQ2HFe4cIDgnd4JuSw2sFU6R0blOrho4QOJL/mzZrTz+9qeYiUr8wcsMiq5Wxj1v/uy/+95Wb4JTt6iNKMeJxBU6UG8n/Wa8xa5IEzhv3lJ8YD3nGEcL6ShubGSroMOr6uqKVJSVZo9IE2CnLlLxadAfkZlxaHWoe+JVEhbWOmTmlb2iaUgmLaFsGPXxma6IVqTsFxNPaDcmiPIiFZMK1PsNDUHa4M+QisPNmGh1k1J2zs8fpZ74zB3q5iXnTnLlTR/mSFgko9XzTeny+tt+B7th6eRSObGYuSizZwxetLyNCmoQQsz4CkTIKtvF+Y3Ksz/oiclPSmorQPa1iMcz2Adz/PWdr2P2mS3e/E9vxfehsiHCalgk2YTSHicV6tstJab2Hyipc7GVSFU6kqePLeMV5zxG8a8Os7c2zO2HNmJ/IAEJrckcTsXGnz0dUDDe4+b7w5KkNijwyurZzk8oz3C3qmgI0pE4dZE2xGp1qmtfafiInha5fVn+8cDlnDswyn0PbuEPrruNY81eICbXU0ccK+GVoXxGgncwS+PshsIUxjKqL0NL+3hXVIKdm1LUkVanEhdEPrhaSzP6vU3EB4qUkyLPvO4wO991Lhd89HF+dupMLCGZmyyBk7DpuqPs3r2C8dFuRCS49dgm+gpVXjbyOADDmXkuGTnGI89YSbRLNft6oLyeDblJpr+4iqffHLIuM4ktEn6w8Vtc/MA78LfO08wHLLp5ksii2Sfx50QK4Cixqw5CiyIdZ6aDr7H7BUWjtMJ2V3AjrjeibhG1Kat2SyXRmTmZ+pI7DUmrQzmj+GVV7ew8FGO3JPNnuLhV6H5KJTtOU1JeYTF3RQv/YAZbwJXP2cEDm1fzkc238Kc7b6Bw0KeyWjC9q48brnqUW/Zt4WUbtlP4zYDv3XUxf/gbd3BXfR03FI7wP05cxrW9e9JEz6zVbrW9hpngvHgqIShYYKkeAwp8UdfGq+rqb1NitzTNrlOvAxVJyyD1v97+j7Z3vOMdvPa1r+WCCy7g0ksv5fOf/zwnTpzgLW95CwDvfe97GR0d5atf/eppn/viF7/IxRdfzObNm/8f7/NXOkj3aiootMxgNUEspA1CjBDTUEpSxFajYIZaYYJqaSmedVrGXBIAx9plxanphdkEfprnbMRahgNuaAeGp2hoICldRr9uxQrxPM3NRKOqCSAzKJ6kTjZSdxdNQTH2jgZF9hZBRm0qBKjgwLi2KL9WPelXISipRjRLubSGIqIQeZHy65ymQj/tluaEaycb0zAozraDfwChHQiM2EtoVNxfUDcqLGg+fUu5rxgLTafWVsjHuTY3z1tUk5QI20mFHYJlJnDNX09dcBLwIo2y62DelKRjT9ExpKVQdbeilPTSkQQ9EqthIR1lv+bWQFQEjcGEp+eUKCZKLILIgXxM4Emmj3UztHaGk+VOZGzRmMkxFtoMdFX46Ys/yg8rWzjzueN87sFn0XHYcEu1u06r3UzDqdn80Ru/y/t/diNOfwNxJE91TUx1Y4LwYtyjGbJT6vrYLUnQ4aiOsTFw6TkgILOQKAcaXSmKA2V1ZmmP+eKo+rtXUTZoVkvRN6QNYWLxwMQarrpqBz/78gWsf8MjHPrEJVxw/iE8L6L/hfuwOzrY96lLKB1W3QgzMzZRVqE/blV1w6wPqmf+yI0Fhn6YsLAO6iMxQRds2HSKfYeHGR6Z44Gzv8e6X/wmf+A0OVbrppo0KVgZEhLqScCb730rR57zRf70kh/TadX54sJ5dNh1nlvYy7qBaeajHNKSPN5czmPV1SzzF06bJ05EFVY4/341S3IxiaeEaaoxi0yTWAARSyyDZPtSuypIvIog1LalJpCTAmTSDubdmupbYMZxnBEp/xYhdDdHNWY6djlpgOhp8ae0YXGdwFsQlI4n7QRaB+rSVj9VUi/S41UBs6qaBcW2naFAjUFHV06gDTIklq6qLJJW5t55z8spHHTJAT9rdPCCnMtEHHC+LvX+/fxqbnvBx3jBt/8Ib0HQ6pKKcliFRkESD/Ug/YSwaKUJCYDVVHaSiS+wWoK4mODP2xS2LrDQ7yErPplcSLKthbWjg/f98T/z9kdexurnHKU3U+Ohn28mGGnRc59CScOcutatTpFSuxo9Kpgx+40sh29sv5hSf5XKbB5CgTXtYDeh0NSCyCHJ6nNOMfOD5WlFzmmoKonys1ZzgzWnONDllapLcX1I0ZbM9Yx9JXpVwnQBT5aws0q/UPRCJhpFCmsXeHB+HavzM8TPuoBGBZySQuCTTEJjWYIIbM5ff5zcmoCJSxfpfqCHx46vYOhVTzL27m20SpaupkqEJ/AXJVFWYF81R0+mwUXP2c23d17Ak+89j+zBcW4/fhbVSgZZdxBNC+lZHLt1NWJ5gjWr+JONgsdkUmR/fZArn65w1+Y8V+2apD7gs9dOKI8Xydoh3/uTZ/P899/NiDdHRgRMRz18q7KGrgOSyTVZhC3p3TxDx3MPcvDLFxCGHqmewoYkFGnl0Gm2q8ypb7imbuXHSIGxKKuqTPkJ5XqS2CD9NtXSaSpqTGQL/EXlmlJZIWhtbJDbkaVVsmh1QtCprlv3noTFNboiEajA3w7AP5ghyktaVZ+7f3IuUV7yxwdfTdQVseo1x3nDwFN89J7ncsd3LmLlNaf4/twF/MXgPdxcuIB9wRB//bMX8ZLf+DgfXvl9Xv7UG/Hn1fPpVST1IcU9JwvZaUl9UJkUhHkrrcaEOSW8lY4au7UhsGI1j2SnFGCWmVVzTlAywckv1yalJJb/+Ui6/H+xj5e//OXMzs7yV3/1V4yPj7N582Zuu+221K1lfHz833mmLy4u8t3vfpdPfOIT/6+O81faJ33Nn36QXC2jeMQa2TYNcwz6atxVlga5BjUOi6TixJRzrbmkqfDUINY6ELaMHWBCSp1Jg267zXkWUvtSa2qKEW+l3FU9SSGXcL11ti1t1bkP/ZaUnqA5q+bYDOIeaXsyw+02HGfTaTCtIggdUOsnRkLa9c1ckyjbpt8Y67hEC12jjPY114h26uHuLjlfXWkwPNelwlsgFdom/unvNUFIWFxCx4nUdbCWIJqgKybGss2MU9nmWaedP5N2sG4QQ2mRVl+kpf2rdYCU+BK3LE5zeXBqpBSlZo/6f2OlKs8LSyJmfJKOCGdKITPWBYvUqz693RVsSzJxrAcRCJZtnOSSvuN8eOBJ1n3zLSy/IyIz1WBhY1HZbOnKgAroVCL0zGfv5NBiL8eODOBNOXSeP83MfAGmfeJCjIgE+aMO+XF1Q71ywuxm3Xn0qTi9pghBo8fCDiROQy1miSvS58r4yNeXKSu/4lFBdN0CWS/kssEjPP37Wzhyk0BYEvtQDqemED2vIlPvfNOww4gRm73qXFrdUrsjJWQmbOwWVNdFfOCK7/LR/ddydt84fzp8G19buJhXdm7nQ2PX8/kVd+KLtu3NmjveyJFrv8RXyv2cnzmOKxL6bKgkCaucIrfUc/zBna/m/Vd+l067zjJngXO9TPp5E/QDbHnkVQx3LLK2OMMdd2/FXlkjSQTu03nyY23nFPXsKqqK2UwX3hQI0OLdKKv9oU0n0Fgt+qCCqMRR/68PaR1NRVPpWgqhVei1wKlCblri1CUz51qq0+0+QXYuUbaP2qMd2T6upfNIepyuYHaTwFvUDcACZWXXccBKxZfQHi+me7EBFExH3mA4BEuS3+dxwY27CBKbE5UuujN1HCvhr1b8kHri8p5DL+bosX5EYFE4aqs5DyifEyBDC6thkZm2UpvUKG+ADEnUp7iE3phL2JHgD9dI9hbJnD1PfV8nTk1oQaxEDDXgVJbuXYoj3uxeMhdqTUl+UlJZJpRblxnjXQn+rKUpQJLiUVVhsiKoDiu6RJSD5LwKuTuKilKSac/NoILuRPPO45xKgKIOVT1yGgK3rMZEop25Ql2Bt0INIG2osmlwgnrksrY4w/rsFONBB5aQfPvuS0kcSccBm4UtIU4+gtEMnWfNUnmyl+++9u84FnbTadX5qzVbefvhvbzjn99EZqYNLi1sjpFuQv/QAp3PU8HxDWfvIGuH2CTsKg/z9GNrsEIonFDe33ZTcbwXNiiPdHlWFZkI/nLrLXxr4kJyTsBDB9byiWd8g12NEe7eoqxEjn/7bIK5DBduPsJcK0st8OnINNi/b4T3PesHuCLixzPncvgLZzB/bRP/6expJgxIRXOJMqryaTrWxppuWd0QYlccsmOKpx5nFLDkNNtVOOMV7tZkSkULi5om00XqhGOaMzl19Tmvqp69Rm97zYnyKkENSqSWyq0urdfpUNWYJJvQM7JA9dFeZSPa3ySbD8j+qESYFyxuifjE1V/nsdpqxlsdvLn/bhIpeNV3fo/OA4L8ZER5hZM6jiWWeqYys+1zMfGEW1fzdHmllYKIBjgTsQrw1bMtCGWTp7/wy+OT/pWvfIWvfvEmbv/2f667C8BnvrjIPY9dzg9+8IP/9H39f9l+pZF06UCrt40OpgFkopH0RjsAjPRAMEiSWZRMIxBbC0etiNT/226BtUSUaLy2l/pzWyHgtYNZY9dmRKVWpJMB7eCQNuGJ22VV5Wuujtv4KocaBTOLr1nYSJToM0W8dXBtxG6JB2FGLYBOTXH6HMORzKrgyfDFRQKtYhu9R6hJL3EU3SL20e2gIdGVBG+xvW9D+1GUEIUEpZaUJliONI1FI/NW3L6GwiJF2Exb5dgndaow/0SiXRwKbfQvdXpI2v83bdidRrtkapIIKdSxKteBJY0p5tvXptWjgmXjlmP48omnLOtMEyB/p3JICYpQWxeBLYn6Q5KsjbO7g2QgRAio3NXPD9/697xh1+vp8ht8b/c5fG/3OfhzgumtLk7dxStL6gOk7bFrGwOsOZfsuCBMbGwrIdPTICw61O/sQ65IVHLWsnAXbZwaOHXVfdJbjMjMKO54mLf04tUuD9uBcg2IM5pWlIfuvaoxU31QobatdU0atQxB1eeC9SeIEpuw4DL0XYsb/upOvuBsw/tFAb+seJJOUzmfRFlF7whd5cQRNYR2FFEoq4gEuQnlRlLa5/Bn8UvoXr7AP6+8l+/WhtiaO8bDjdXsm+vHX9kO0OeTOp+6TFlevaBwlB4rzzerXZzpjdNtqQztYGsAaUsONIc40ejmyyvuOy0w3xl4QIItElZ1zZFxIlyRcPDVn0v3s+HITSSOprvocSWFSIP2pY28THXN6DOU+4Vq+mWHUnPGFdptvNVjt93oxYADCLBags4DupNoSNrptP8xdRwLa23qgxbFkwqNUztWTjPqeE8fByoYkhRPCC0QVshvx34rTT7NWAnzqjOtFSrkXdrQ7E/UuXYG3H3FJ/GE4NiVGbZ6El+4PNoK6bZb/LCyhY1uhlDGjG5fxtB5U0xMdAI25bMi/AmHvntcpp8Z4i04tHoT3EULb7495mMfZCxwCiFRwWH4HoiyBebPgNr+TpymoLm2pSYfS1J4LEdYUgGW01BBsdOQNHoFxZMqYTSCcUNHdKtgNy3qKyP1+6xDWFCVjeKpRPWBCFVAVj9YTLUaBvywGypBV1xhFVgqkEXiLtgpOJSZk9rNRNtIRhrYyCrXmDXd8yy0Miw2s6wuzFJPPL694wLefOE9JJmEzKhDZaXErjjELYvSGQtUG4oDXUk8Os1CBLxz50toDsRIy8baUsZ1YryWSxzZTJ/qovo/trH72R8nK3x2h3V+Z+9ruGLwELvDNeTG2yLiFBxxJP65C2zpHydrh9wycw6r8rOsz06yq3OI//G515O48IztO3hyehnBjItdsdn5izPov3gcgJLb4u1X/ISP7buamzbcSz1y6X18gZnzS7S2NEgigXMqQ2ZazUOqo6dImwkaymqchcJ+Nw3qjZDS6Kf8uqKmeDWB3ZKqGpW3CItqTQkLuslPBvyyoiTlRxUCbZyWUkcrGwqjqurX7NbHpddx0zfErShnrKBksTjXS9yVkJ2waEUZokaW1W86wL6ZfvIPdfK5P9vG4C0NLu84iE3Cg40z+MpLPsNv/ctbkZZDfkL1Ymj0WliAN62Oq9kt0vklN6n6UgRFK+2bYNyjlPOR1NU0LSKd/p9FR/93t2QpavCftP13Qad/pYN0u6mo3ImngjMTVPmLquQIpMGkQZCNANMgr0gQwizKbUGL6bpp0JQoq1CYNkIrUs/hsNBGd01QaOwgI40OpBQVzfM27iXGgSTx1ftN6RnaCGVqaWgCez2JxD4p130pOm0BoqE6okm3je4gVec24z1u11Umv9S5xninq7bEpKhSShkSS4JeseRYoyXnrZMJp356AgXKScag31FWJyJCfd649IhEIVaGxmS3SJu9GPTf7D/Rol+nQTqxG0ZT4qhEwKAQsa/QEnNeqWe7tt+0mxqxC0WKspvkRyTKQi87odwGQH1Haa9DbUR95pprnmBldpYDtQGu6tzLn518MVu8LO8546c8WV/J4dkewr0dBCWJWxMEHep6uxWobA4hEohFh5Et40xWhnlsfDmWkNx01r18/I7ribeVObNnjr17luNP2W2K0YIgSQTZ7z9OeN42RV3Sz46Q6hrmpmQq3nMryiXDaSg0pj6okrnMBXPIlsvqL4zz0ruewBYJ3xy/EO8nj7Jhe469tUGGOxepP79B+cE+3eZeqNbZRUjmBJlZteiZClZrcwNxPIudQGEiIig5NPogP1ilGTisvu23EE6CteBi1yzWbDt+2hgPZcIqd45yIqglCV1WwisK80BG/4N3dB3lHc/9Ahv/6Sb2/rbinpsAHcAWCevdFjtaJYLE5hV926kkChV8oJnQYzfSsrnZ0ufb/K6fa6PFMCitFalECEsF+KcJvpvq99hVwbqh5MW+QsJErErsmYUk5ZKb+2bFkjBnUR9U7509V/mLD9xvERQFhfEYK5Q0u6w0eDfjSiSweIZU41CogDJ/su04YzoFiwRyE+o5FLGqeriLqiQfhH7aaXTQd1hzxxv5za0P8ae9u7mz0cnF2cN8pTzEhZljXHHtTu796Tn4iabHuQlBf0Q44WD5Mc7Zi7RGC7T6Y5y6TXZGddMFnahPZUjyMaMvjCEWWIsu/ooKQcvFc2LcxwpEF1WobLApHnAIS9otZEyL5wKoDgmyM2p+zsypjCXxtFhPgD/ppIYC/qKiTgQFS433RGBdNE90ooP6kBJX5yag81DE/HpHo5uKWlZdoewjS0eE5gqrpMhQ/KRQvurSUp2IW50gelps6Jhi/2I/Pbkam/OjdDs11r/hMTK7IwZXzjER9eDP2rT6Y7L9NfoKVaYqRQb/6kGeeMUqht15vjN9IUc+fCZWWMebVYLdC4ZPct/e9axYPsM3z/w6O4Ju/vDxl/PP5TW8pWOUI2EvE9Md3MM6El9SWwbZSVVlifLKacUZbFAeK/HAiQ7c/ga2nfDidTv47thWRjoXaF5XZUVhgZ8f3IDjxlizHpl1ZZLHOpit5HGdmFPVDo7leukvVthVW8bbRu7kJ185m9ETG+jINfDtiFqfz9TePrp2C5rdimZiKstYGjiZbY+3pS5dsavmaStW19uOpQrOC6LdLEyqpEzotb1VEmklIygJSscSmt0WzV617tlN1TRI5kS6PicetDolmVnlQ2+uU35UI94zipqSmVFj98C3ziDshNZwwuSN69n7RMxdzka+evUXqCceb3rs9bz+N+7k5k9fraibnqB0PCJxBLUhmygnyM5AsxuyU8qBza1J3W1UVSbNXBpnVdJQGFX6D2PA8Mu2SeR/mXD0v8P2Kx2kOzWwJFh2GxV3KxqhcVCLqp4EjGDN8L4NAmXQXdPSPjIe1KEODrV/sdOESKuwTDdQITXPU3Pj44xu7a4RcxJScahpIW5KvoaGYsRjIlQBdeySOsOY4DBF0fXn0/9LEPqcDLd7Kac85Z7qxMA4Ebg13VDGUb6txlsb1DGDvgaJQjLSjqqtdpXBHLuhvpCAq7m9QBpAm+M3FlOJ0/Z6dTQ4lNKFtANGnFHX3XDLUycKLcyNHXW+bk0fh9+m0Th1dS71IfUZFYiSNjPKj6lr7LTaba6DbklmWqSiOhFLrEikgiVQ+81MirYfvQ7QRATnXnKIZ/fsxhYJvgip+hk+fuhqcCRX73kBs7U84fYuCtumaU2DFSh+q6n4VDaGiLpNZsqisTLkxL5BWNUiqPpYkz7fzW+lb/0sC0/0sW+lh9vTpHtNlfqPB2j2Kk55bUSSP7WVqKBKunZTITJWDElVOX7EniDMq8DcJD2tToVCDVwwzsSTg6x+z0NEwDfONOXKMQ598hJuKNzK7VObCRObN61+gJ+XzuLpn55BlIMtz9vPE6dGaBzLYUXtBS8sQNxwsB11fWsDDokHq//kYQ5+ZSteLmTbWYd4bs9TfGTfs3n0gq+x4Zab2Lemhq0n4J/UzqIaZ3hvzwFKJvv6N9tzhs8BIPhEe2G4s2HzzEyLqgy4xM8BDldnY968YzmvXmLNeFnGAvKpheXSZloiUceQuAKnrpFxTWkxFJbEVkj5aR7mnvHdl7qDqQrW3apIg2MrbOs21Pco0WdiC8K8hV+OcesJ0rWRtvLEFiHMbVKdOzMLRqS4pDW7qbplBHZdJX9RgbSrrqHsmTHT6pZEpRgRCHKnbOJcQpxXJ+EsODzaCnm6NcJZ/ihHrv0SNx56NlbvXq7NKqX7ZZlJWtLhjNwkv8hK7JU1gtCm8LhKgDIvmMKTAktI4kGL4GSB8PwquVvzDN05izxyksk3bOVZv/UIB8r97D66DGoO7qLAeaCEq4P+VjcUflFk2b4Wx55r488L/HnFF/fKEq+qeMi1QZWwBFn1s9kj0k6rttbFBF3q/N0aNPog7IqJhyLCvV3YjoS1NRKgLvM0+hxEDI2RGHfOxooE/iw4TeX8Ujwp03ndbqlkymmaSmmCtC3FUV/0uG3n2WBJ/vTSH1NLfG6ZOYdj31pBzH10ZevURjziYcHqUoXFZpZOv8nhk/2ccX8flaRG3mpxeKGXF1/7ENtnVnIyk4NAsP2nm2BFwKmnh9h28g9wciEvP/MJvnzkUm75w4RX/PheSh11xic66TisAsxGn5on3YpO8kOLodUzTO7rI2y4hEJy+6mzaIUO9ZNFkHDUHcJZtAm6IuwYgsDhiht2EiY2D51YRXk+z67rDnP5U4epxx6BdDg3f4IdhWV4dszWrlM8vTDMlOxjcZ0KyK1IgThRjnYDMaHmZ7eu6ZYtDZA5av2uLBdkpy0SLc42fQ3CgnqPASiMWYNXbgNJ1RErpXqJGGpDygnGCnUPg0CNW6+sNFpWS4F2Zp0ylpFOQ93nVgc0BhV9qjkomd+UMLhqlonJTr41dxFB4vBn59zK96bOpzYC2VnIzkQknpWu06YbcHZa0uwSZOZVl9jYFwSa+ukH6nenqVD12FP6IlOp/vX2y739Sgfp0A4ajUNK5Kvn3/DM7UAHyCZI1BxO0YREB+SRI5XIR2+GdmFF6v3SUyVBABGpDNqUy6AdqBtHkzSYjknRZm9xCQquk4LEuKdo7pw5DyPaFEk7kRAxyuNYv9+gNpFGioy1ngkqDQf831JiUhqJrSYaf5504jJ/R7bRaqEDSUPZSZHlWDvOmN04Kng2vvAGrU658lpU5c+picattcWnids+n0RbRBp6imgqipKlqxuWFuQ6DU7zTF9qvZl4aj/mfFLP+UjtO3GhJdoWVt68SBF2b0FoxANqI8qPPDMLOOpav+31P+LC7FGm4wLfmr6YXbOD7L11PU/2rlMCp+4IISDb2UDGgt9deTefOnYVV718Jz/6hytpXlNlbf8Mx2a7CQIHZ38Oy49xSy38lQEELnZPgpRQm8vBQIuJhRK+G7HpikPMNnP4dsTRqR7OecVBnh4bort7gcWT/cxuzjL4UECzxyHxhE4GpUKeAoX2+QuklJ44074uRa9F9j0P0Xl/L6vzM1xYOEI98ZmOipwfPsQtr7ycA28sccH5h/jGqQtZXZpl8JmjRJ8eZO6Ds6xiltL9fRxd6CaRgoUjnSqRKTvp82HK7KPvuQRnQnLZlftZl5vmcGuAHRd+E3AQgcVt1c1cm99D0Yr4jeJultn/XvS5dPvp2E4AjkX3A0WqSZPj4Uq+GwccbfVxRmacF+crlJMGh17xuf/wO5ym4o+DTuITSAWZiQ68JYBIk1TQY0nz+92GTKkvRgfi1FVb9DhvURhtdwRV9BhodQiF6GaVyDE7k+A0JUHRJsooMW9YEORPgRULFtcp/jBSB+MtmeoOpD4ou6WSolY3BN0x3pydHq8ZL/WRmOJBm7DiqOc9C3bVUslqXj0bf3LkRm478wd8sbySWxe72Ll3Jaw7/bqdilu8rmMn3998Djk3YPTe5Xhl5SU/OV3CmvTpPGsW206QPS2Cqsf89XWmntGB5RfwcxV+eM9FZFeVKXbVqXk+QYegVXYRsUB2hGx83yQnPtHBkQsznPGZKgfekCPO2PhzUBmxlAOGqxLoMK+e+2aPSEEL42fe6oTiUX3ges7JH3GorZOQTTjj7JMcHOsnCW3sMxrkHsuq+ddN8BZsEl8BDvVlkuIxDdgkJjFTaK1bBSuSNPosIh+aK0P8jiaFbAvPjtleXsOmwijr8tOUBzL8dFOJK58+TLPLZcfCCBtKU2yfWUH5GdN03bSekS3zVKMMe5ojdGQa7F4cYraWR3qSoCMGR3L+GccpP2Oadx/ehS0Sbls8l5nZIjN/Bv90/BkszhUoPO0pYKMKQw/H1PtsWloXkZQ96IWN5x5n39ggAAuLOZj2sVtCPUtd6npl++q4QzHLOhZZDLJsKo2RX9Pirh+dz/DDJebDOs/t3Mm/Tl/K2CVlHE6QALe86zJa59fIrilTK2eQrkfhuEhtCa1IjcFGP2njreyMJCgJ7V6kxk51WFBZoedkqShPxowBSPtEtDo0tTKrx7amc0oLCifVmMlNKoevZp8S+arKktIeSUu55ZgKe1jQjZc0BTXWmgVvQVF2eh+zmL+2ycRkJ6uWTfOTe88jLsRcdeVeXtT/JE/b6xCxJMzb1IYtkCpZ6tmdUBuyaPSoSlBtSNAIBW5dJ6FVJSY1WhG7qaxUzXU7zS75l2STQPxfIJWUv0bSf/m3xFXUBleLQWIfbE1hsTViZPzIkwxpAx4AhKLHJJ7iJ5omO+Y1u0naaMZqgLE7kzapeNN4cxufdYNWGSRfJAohN3+LtfNIGrxr9Es6al8G3Tbtu9OOo7ZyTbECgfFhtvTnU5tIjWwbdNdukvL9rLAtnkn58JovaXyTTZBvBarUHvsqcAV13E5VI9aODs71tVjaKMgKSbmOsaWTD0tVCEjUtRWyvS9zrnFWJzX62I3wN/bVPq2W4tkbSgoKtFKovdDJSkZTdPT1SJ1wdHCPqya0KNtGbVp5qasvgsycFsYWIMqppM1MjFKo781MQ49d5enmCFfmDnNu8SSv6nuIa7dGXLX7hczW8rRCh/hYntZikQ8879u8OF/h1PBO/vGb15O1IKh7TNUKDJQqzNVzlFc65Astmg2PxZkC61dNcHisjzed8yBfO3Ah/p0lvOdPMz1T5FWbHubTx55FzgnZsmycxw+tAODo/CB9I/MsjPQRZzz8eUl2LklpFgbddZpSXxOROouQQLAioBG6uMAbhu7DJU79xZ8zvAyArU/u4eDurSw8Y4b3Hr6HnY2VnLq4ytwfLOOzxx/i01PP4vCF0/SgSJJ9+rE8/p2zSQ4XIIH5LTHLfwbT59hEhYQLS8fIWy0ONAY57/GXUz7QhSVhtNXFYa+XF+Vr/4/mg1XawcUVNtuyRxi2LUqF+fTvJSv77z5TTho0ZZyKtoyV6lLjAEVjEZRXqVKzSZqtGLBJA2UjJLVCxaFTGhGFkItE0upQiHyjX13/zkMJsS+0oDdJk4LYVz+dhqRo2D9CdY4tHFcgQaPHwmlKFtdZBB2SxEuwmxZ2XRBnJAjVdKt40CYsKKTQWxBpB1+A+rDSCpiqnXR0986aGqNHdi3jjMM3IQKBiAVOU7D1sZfzxnUP8e2T5/PxDd9iLu7kzvIm5dDzjbfw7Oc/wc/vPE/xgkcz2AHUHuklLEpkX0ius0Gj5iNciaw7JMcz2DbUJvOIlsWK22MW31oh96NOxi8H20vY+xeDMGbTvdNm9AofogQrAO/qGWaPdFN6QN2PzJyy3JNZyE6TCvnNPJqbaicxcSAQidZqlB1EBPuPDZE74Cmq26YGTl3xy/0xl6AT+p9IaHZZSEukHOlml8CrgltLkJa65/U+QWVzyAcv/y5/s/c51Oo+VlZySf8xdi0M0enWKUeKjvWa/aN88cRl+NceAybYCYx9s4PLHylwkX8fX3/4UvATuvsqlPwmXHWKzQ82eWgxCxWHizcfpt+v8Izdi7zle7/Nuv/xOL335LDchKjiMVvJg5BUzwoRNRt/j0JxRCy1ExNkx2wmih1csPEkB50+VvfNcnC0Pw1QG4MSf1aQf8Y0/fkqWzrHeHR2BQtJhv3VAXbespG3vfYWQulwTvY4b/v8W6ivjvjUoX9hIc7R75R5x1ObWH3jbgYf6mB7vIJWzSEsKpF7WJDEpZj8EUdpczRaHeZFSolsdSjqR26qbZdoaxQ+9hSFSbbUvY2yQgm8HQWO1YehdETS6FPnm1ahY/Xd2UmtSwuVaDMsiLamKVGVHLulAC3Qa4iupptnpD4gyOzM0uqWHKsOsv7ckxy/fwUfPXAt84e7cCQgBG4jIT8GtWGLvp1JCoQFnUpfl51oJwT5MRWoG1qL0VqJRDXzchctkv8eceqv9PYr7e6y4Q8/iONm2s2AdDk3NnZfeqE1ohQjljIDw9BAjKuLCWjNQp3+BJZSrIylmaS94JnX42z7WEh0UK6RFmOttvT9QMoltZttVNs03EmPS08aRqhkztUEF3EGorwSi5rynOHfG9TbOK4YJEAF5KQBvldRryWe5m6bJkW0XzdNWYyg0ogszbEaHroR2fXuCpk6z8VQb4y/uxEtGbqPOU7TATNNpmhfG7e29Jpp2oEt0uREXVPdPEbf0zTREaQNntQkJ9NrCarEmbjtSgKWSorS9vVN5Z/+vZd8jBvufhveSY+Lr9nN24d+xrlehsue+g1akUMiBYtHOrECwR89/xY+sftZjHQtUA89xic6KXY2qNV8hnoXyTghJ2a6WdU3Syt2ODHay8jwLHPVHBv6pikHPgvNLH98xk/49LFncerxZbzjhh+xtzbMRLPEWK3E9GKBq1Yf4KcPnYs3XCNzd5Ge3S2mzvfJzihRkldW5+lVEiW067Fp9KF5yBCPNJFVl/U3PcLhv7uUP3/+zfxgaivVy6eo/mQtw4UyE7UiG7smacUOE5cqbsjxb59NUPOgaWM1LJyaIF7boKNUZ1lxkdFKBz3P38+hfzkPa9LHLQty4zB3Tsz7rvkBv1ma4uy/v4mB609yZNcytXiGom3Zp9FokajGN3bT0r0PdFQJJF6C29ukq1hndcccq/MzvKX7gf/QcvF/tV3wlzdhHKBELFOPcyuU2vVIsLBeKOtMPePaYXtcK19t9f70dZ2MW6H6LmWvqKwZFR1MML9B0LNrqcWiQsitiLQ/gd1Sx1AZUX0FjL990AH9j8dty0g9JiYuVMGOoc1FWWguiyjuc4hz0OyVJJkEu24R5xOyo3b6jIAaA9W1Md6MCqIST9mQxvmExJW4vU2CRR9v2mH/G9r+8y0Zsuk7byMpxmBL/nbbzfzZt1+VUg6jnKKRSQvE6hphw0UGFlY2ws1EBNMqicoO1EikIAptkqmM4ow32xXMoATJSIPVn4ep87L4iyopTWyoLLfT9usjd1YZe0aBjqPqGtUGbJymcjCqDalxYeiNtnYFCQuSOCPJDNWQu4tLKiKk80NuUs2BtWXKncepKdQ+P6oCvPJaSWn9PBknoh6oCbQ8XgQvwVp0EYMNbCch6wes6Fjg3ctvpyIzLMR5Hq2uZqzRySWdR/js7svpLtaZONQLxQiE5FOX/Su/d9+r2bruBDsfX8PQxilKfpNev0bRbXL/6BpaO7oUeLSqTlRz8YoB4YJP7rhD54EEIaG8XNHcwqKqutRHEjIjVV6ybgdf3X4pmVGXYE0T5j38GYvmmoD+gUXWds6wJjdDwWnyjcMX0Hyqi9ZgyJVb9vOc7l18/NDVNO7o451v+Q4WCQeaQ8yGeZZn5vjH+5/F+rds5+BXLsCaU+L7gUcSNv7xLh48tQr73g4MTTI3LTXaLNKxoSZydR8y8233MrOeGBqpv5BQGbF0x902ZdOAFPUBQXZaIdLpuhKoMV9eYZGdUZ1cF1dbOM02J9z0+0gdxPT4Nsfs1Nsiz+CMBkmkaC1iwaW4apHKsQ669lgsbExwFyyccxZZ0TXPidtW0eyVeGWR9gsx8UOsHXBMjGCSmOpKlWCz0OTwh3653F2+8sW38INv9f3v3/z/cfv8l6o8+NgVv3Z3+WXepEPqE24GayrQtNucaRPEGp9oYURhSZueIeJ2UGuHSwL9li4F6+DQfJf6YxstNrZjwlAwEoUgLw3izURi0GzjBpMG5KJ97NJq00CW2kEab3XjHGPeF2fAqYq0zbf5PuPDbsUKjY4zakEyQjkT8JvGR6mA1DkdGV8aUBsxbCrcbLaPL8qCG0PPUwFTF3jMbHExTYyiHCktxg408q8X8ERPuFIj9aacmFYhfH3JQ/VdYUGkYlWDziuLTHUNooy6b6bqYSzZIpNYNAVhQVEHTCdIIzqVQgVd/nx7/9JSYqETURcv2PwUb3vWL1hIfHa3htnkTrFYzyAExDs6kAMxF124n09+84Vk5iF54SJxYpErNalMFnBnHer3Z6m6EK9JODQ5otx4KjbuSMw5g2M8uGs9pf4qrhPzuRNXcOOyHXxstI8P3/08rIbF6nNOkUiBbSfsmBnBXbQIwwKyH+Yjn/yECtDdqiohZ2b04lG0cBuSoCU4+2V72H7XWarBTFfI8MMl5mZn+evvvJTO86a59PE5EnmSPYsDjB7tZWxfP9nlFfK39jO3p5d1fSc4dHxF2sSl1SWxj2aZG7EoVzP84dl38UN6KD6WobpCMvxAi5O/E/Gn5/yUFxSO8idTl9LqhpkfLsfrUV0JK+tjIpStXewpqgiWBBvVACfSFBSUj72ILJKTOaYKPlNRN9vj9XyLS9WzmYsRloTAwmpaiEggHYnVtNR3JYLEURZuj/zZR/nziWdxfedTfPDQcxmb6MQdU/ZGVqSeSaVnUA4uKW1FjxchSbsbm6qO2ZR2RaX1saeOXwoIs23ELrVFDMELZRrcq2ZcCkWsrlI6g9wEiKxIG6OADtB1sJ6dgcoahdJlppU4MjPmKPpYCNKR5E7YCiWeVFSY2FSMtHYnf9RWQulxkdpJhp0SChFh1ePo8/+JOxrt5efRVsiFvsvznvEEO+eHCSKH9zzwErKN9tgOOyWxC0kmwT2Up2NSa3ASByTkAl0N3VXCqyq+d/n6GmJ3gbCoAvz6UELpsEUyncV94inkRWcr4W0scSLoOhQxt0GJRKfOL2ges42/KCmORsSeavrlldV8YHoxNHu0NWaXpLi8zEjnAkejIlG+7U7lzymrQxHbafLjawFhZlaJ+SqrJUl3yPLSAstyC9x7ci2b+ic56YVMTHQqekSUhZZgYSCkWs1ybLAXW0gmww5qkU/OafGJh6+BUDBR99h67hHGqyUmTnTzrh0vYfhWh/JNPr1nzDJ33yBTOdirqS+fueaf+dgNGzn8sUuJqy6dAxWq1WzarTL2Bc0upYkJi+1GQ07VYqRrAVfEZMZclSTPe9h1i+DMBs9ev5879p3JsuIixxo9PDU5zAVDJzh1w15u2DPLsVYflThDx3MP8heHf8T22loenVtJwQ1IpCBIHN75zNv5IT309JWZlSWSqsPoDRG5ahd5P6DnC09x4m1nk5lVjY5Ul1MVZDsNpb+IfJFWx2vDUDgF5fUJRc23lwLiAYvcjKSuA3x/USoRaSwor1LPa1hUzePcugZ7XIG0JF5VVdalRVo1iz2tJYna65Kj6bRhCYKSamRlQCSvDKXuKpt6xvnFE5vIjFRZ3zPDx8/7J65I3kWSSejbNsnywgKDmTLLX7LAXXedq8a/jg0MM8BfIK0g26Gi/zh1BWZgyXYX9F9vv7Tbr/Ytkm2Pb4P8GqQUtCLca6O8iY9pQKjLaWD443ZTU0CMcwmkVBTjimGoEyl/fAk3zUILGkttZM00ajCJgkEFTYAb5dRibzdFysMzaLfhdRvHk8RqB+wppURz7Q2v3SQa0m2fIzrglEawZugull7TrfbnpaV4m0ZoaUrFiXe6f7lJQKygTQuStkbrNfd84mKPxAdfT2ZRjrTls60pKkYFYGk9geGFI9s/DS0IAUncRtLN4mq32p/1FpbwEBvt627FSoCUPjbCJDtq8g1LEmnJtI24SZaCDvVep67ua5yR/NGTL+Wms+4jwKJbR2KHoxZZPySMbKItFayWw0wzz+AzRqkFHj/eeDP3NIt84sQ17JvLEXbFJOM2tWEoHrFY2BwhvJioELHYzHJ0tI/MmMNzLtzHjw5tZkP3FJ/+7vOgN+bNl9/Fl793LS8bfpwP/fyFuP0N5qo5wlVNsnsy5MdU0FnvF1TWxuRGbToPJMoezlMBZm3Awl+UPDU5TNgbYVVthJXwxMQI7z3rJ0yu6uD++XXccXwD9cmCqirUbJyGoHGqSN1PKI4KjjZWktUIbJSH3Lha3KKiC3Wf/euGWHzt+XQejgg6HA6/wqIn3+Q5+UP0WEUuLRziZnFZqi1oXFyju9BkbrpIEFgquA4FiS9xuppEDbfNQrQTorIL2QRRtbGrqmQSZxOsQKH6UaS429KVOFVLB9RCPz9qUY99FSj3WHn+YXg7AF8plHng2d8DFB2mZGW5rwlneTXuqg/zZH0lf9T7ECcjm4yIOdPNM5vU6LHy3Nmwef+R51O9eVgdjw92SxDmIDsrwdEPvlA83+ykTg5NQK47lCo9ijpWQz+LswlOxaa8RvsrZ9Tf5L8ZT4vrE+yWqkgYBDIsSJp9Erdi4c1bKTpshdqGUdPMvEWRzj/evKAxpLrvJi4cufHzvH38fAZ9VUm5NhtxXxNunruQTww/ygPNhE8MP8qXCgN86MnryB30sFpt8bY3p5xTwqKt0OgluhmjH2n7tCtUsfjTghKPDqj7LBKFIjpVwcTrz1Y2iYHEChLijEWYt+g6GBH5FmPPknTtsglzii7R7HTIzSgPajuQ1Pss/KpM75G/KKmNCOqHOhg7IyHZUsXaV0itHJ2GpLTfprw+VhUBAVFs4Y0pxDfoBNnXotTR4GS5k+gVsPobcyQIpmaLjCybZczrJLszq9xpjrjUl1t8/NDVfPDM7/NIZQ13HVmv7nnZwakJgr6Ipx5ai5BQmBJk5gvkb36I1e/OYZUSfrKug+whj7BH0r98ntlILXAiBuFKFo93IjoDRMtSzZlKit7UHEzaY0JXHEcXOqh3e8QelI5Cs1vZdiaHstx16hzc1TWm6gUW6lmkhJ3Ty6i+v4dKcgfLvHnqiY+zfi3HghnGmp0ATDXyOFbCXCvL0Uo3p/5iOd7PYdMNR9m3fRXFVTXGFjtoHiyRvLyP+oaAesPGrllpVdipK3vXRo9I6aJ2SwMPAeRPKEGoOj8VJC+uFeTGdEOvhkg1J8XjSquRmVbnXR0RZKeUwxIC/MVEi7dFanygkjmVhFmhihtETEqpscI2/QkN4lXv7+Oe3l4uvOggCYLvrPk5H507F9nbgtBisZ5leWGB+8fXcMnAcf74Rd/jE5//DRp9amy7VUmYUw5cBohqdiquunpA2uvUL9smgfi/gC/+a3eX/wabaQtsFhVbIzFuVQe3oo0qm/crVFY5NViBGuiGxiET9XurUwWhEtJGPmYwGI9jI9iwgyUDRZr24rRRZsONlqS2jtJWQXfqCKFRaickdQ4xiLkj2+dhgmsTGC/dj+GqWSGpK0pq/aj5phh6zJLzkRbEWhBjOr+lzX808mYZrnoIcdIu5dtNbQFlgnrvdBQA816dOLkVXSaUS+6JTjzsOqmzi4hI3XpMYC+S9r5Svn7SvvemC5vhj9eHdNCuJ8/UzlLTmMIiaWnRbiiURSH77WgnrcRowaOIobXo88rSLvrtAuWkwSZ/DFdIvrvlS+wMBrjQn+LO+go+eegqHtl6My0Z8swdr6bycB/i3DJHn/sFtj72cra/8Otc+uSrWMh00bXDAeGwcHbE7EQJe9Hhp2/8MHvCHi7fup8/+OlrcBzIjNn84z1X8eAbPsK2O3+fc845yo79K+gcqGDvLBDlFG/Zq6j7uebmiPkNtuJ25lRn06BoKWTQFmS/10FlW6xQoN0Z1j3/FLfPbmH37CALizlsJ8Gqq0D5yqt2shhkmWtlqbQyLEz3KfeQvHpuisd0+biuEo/FsyL2LA7Q8S8PUX71pRROSeyGS6WU4fLb3oEz76QB9OI6pQsQAh4779uEMsIVDn8ydTbfuudSRCDYffmXOBE3WesUTvNAN9u+sMb/OPEiTpU7SBBUGz7JYgacBGJB4NrqeQkspKXoG6ASL1G10u9pyZDvrPl5+vtYnFCy4PIMQJ5PH7+Suzf9EMjTs6RK1mPlAbg6G3Nn31F+lgxjB5LsjELxsg31DBrObOJo15Ix5XGflvSXVKichhL7Jrag1WGRG1VdB2vLNG98qf5Czz/SFrgVlWxGBRXMSqHoXHEg0gpZlFdzXbNbi6UdaPXGJA1FqXEraozlxtTnm/2SNT/6bX56/cc4EXVwzvZX4joxj533bS4ffhQwTjnwxtIkz3/Gp+m/osDmT96E3VSuKqbrsltuVy+lpqUlBTWWHV1F05RthYy66tnPzCnOfNId4K9uEC124lUMMGARZSzd9VniyITiYYdGv7LPq44omkp5pcCfF+QnYqwY5jcKspNq3+U1giQXqSBqrMR15z/Fxs3jfPp7z6N8ZoQIBXbDwluw8Rbaxxd06Pkkn2CPZqhN+dhNQevMPPaVj3PiHdtI1sasXz+NJSSTF0UEEzn8WZvMuM2s6OI7fRdxtNKNvS+v5v2aEi6Gc6ozaqtb7UNagsyNF3N24TZOtHrYuvYEJ/o6iesZNnZPsskfA5bjrqrSnW1S7/DgwQ4lGM+otc2pQ2ZKOc9Uzwjp6K+yPF9TmprEIeqIqS63cctao5OVJD0ha3vm6c3UCWOb92/4AXeWN/HIZy9i5GVznAq7mQpK7P3DXn7TrnJR6Qgf2PM8RNkls6zKuUOj7JkZ4IYbHuTJrfCs3yqzcE6W0QP95MYt4mUxs9sSMkc9JVCdUj09GoOSzIxQFYA+kJYKtBcuCLD9mHh3Fqemnq/6GXW8Xbm0YVh9UCHRXlX1dAhzom3TG6nEt3RMofOJrTQ7UVbQ0p08hdSJcKQoMV5ZJbNBSaRmBHGmXY0IS+pauYtCaTuqgidOjrCib453T27lrtH1fPiSm/nCqcsZzi3iioTfWvMA3zh1IcOZeSpnRHQ/4Sj7RVSzuDgjUvppz56IVqdNUNCUsVj8Ugbpv95O336lg/Q4qwJbw0k2wWpQ0mj3EpoELKGKtEQa3DcG2oGl3VLBXaT1ZV5ZCSajAmnHSsP3dpeoxVNluQ6yvYo6BkNpMV6tiaNK1YYPLGJxGsUjtXU0YictcLF08rG02RJouotG3p0aaTMIg3jLjApwrRCWKhdMEyYjorRbegGw1eRm3pPYKBeEiLQKkPL5NeKF1a5gmGrE0k6lcdagiaQ+0HZdJR9BSd8ztE0j6npLff6mpXraNCkC4/GsmpSo1w3lx3CKTSBiEAiR6HxIJw1RXh2DP6fPy17CdQ/Vd5qEDjQdyVPBzEuv3c6Nu19HnFh4TsR8LUccW/heSKWcpdTR4F/O/jK/teYBZpMatSTha5u/wvUH3ok8VWDtz9/AeWtO8s7xS+nK1qnP9rC4IVHPUS5CzHusPvcUV/78DxFVB2/eYv3lJzgy2Ut4MovX3+BZj7yFnr4KeycHWL5yhrFdgySDMXbDojEAVqycApo9rhI12qpJlYhB+CCkblhlCfoettV9sOHwXA+1/Z3qPjQF/pyqPgUd8PM9G1n/m49hAR1ABwfT52nzEzbfe/w8JcDrhLgj5kXnP8GDE6vpBGbOhbg/wD/m0/GTHLEvqKyCJJuQZBSC9abn3MU7uw/TkiG+cPnUwgpu/uk2XvzsR3h99wO4IscX57bxwf6n/l2AfiKq8I8zV/Ll1T+iYPlYWMwmNeZiyXq38B/OHaGMSJDMJy0qCZgSW0JCS4ZUZcDln38nYUGy7sITHJvt5gvnfZWPrLuZloRQxvjCwRX/fgrevThEs0/RoxqewG0o3+PYE2mjHJFA1B8QZj2chuIiKDcqJVIV6XwlsZsJTivBbtlkZ2Jy0yLln5vOo+Z3kUjlYKJFjIpHK6gPS7x51Ykz0sLKWM+bzbWqgRaOTINnY0FrHJO8eUFUFPzT3OVcUdzLTRvu5S0do//htd0RNLm9ch7v7TnAF978KX5vzytp7uhNaWVuo+2CZRormQQ/1Hazlk70zdgzIELPDsHCGT71SY9iXVEZxi9x6N6r/PkLo6FqJOUrSktiw/xGRWtb3JDgT1tUV0piz8atQeEEzJ0b07nLJs5IrIaN1RJkZizuP3QeP9kccM2zd3L/iTWs75tmslZkarpElPWQjk72pCDsDRGRILKgeFgh0LObfarPuxTpJPgzNk98/Wx6dzY56wOn2J0MEo0X6DqQMJOx+cXh9dhOQjAYkT/s4Nbac3PiQtAh8RYFzT7JqU0xX/r4C+j5/IMc+cha7FU1fn/TL7hj5izes+pikjuXs9aeYbxaIt7RgY0K0GNPzZthUVtbDkYIV/LclXv49l3bQMD3Z87D769jnyyCUOuSiAXhQMyrl23nyepKRp0S91bOpMNpUOu3+derL+GlP3+MuzbnedmTj/BgZR2/OLUeKi5OxaJZ9zhZ7eTMnmnmwjxQwxUxiRTgSKJzq4iJHLJl0bczZvJCm+oKNf9mJ9VzHBY1r1wnnfk9nkbHNcBVB/+RHM3udrXYK59embVC3RDPVtXVVk5ZPWZnY6SlEgG5ZD1TPVf0uIohygkirW3KzKlnXc60A2URgj+vUPVGBvV82AmOlVCNPB4779s83Iq4tOcosbTocOp02nWeO7QbgE9c83XeM/568qfU+A7zqjFcdjqh1WFRWa48+2vDClhy6pA0/+3o+7+/KZ/0/3yU+7+Lu4v1v3/L//9udovUX1sNIs17tkiV36bcaygwqahTaq5brY1QG7GaW12ycEDaeTPS9BhpGfqD+srEU8FMWFDZf32w3eDI2BcaykzaPYx2wG1pykacUQun8VC3tXWUoXUYP3OvqiYXIwhd6thQPNZG2Nxym36SaOTZ8NcjHcybtvDq+KRyfNELo1kkw1J78QR1vc2xmwXd2LjFPmlziqXX04h3pdBVCs2Xd+oapdZou3GQMZOqEb+RqOtkqEatbiUOa/QqNDAoquNsasTJbqp7Fbvqb40+ZQtnHE2kTiDCovKLDnXgvvQczXNjhYqWYLfgZKOLV6x4DClhcr5EkgiEhjL7eyp4dsyLvvMOPvr9F7GjVeKPTtzInfUNbL3wEM+/7AmWDc6z5/b13LJrC0cnell99THcssWzL36KM0YmsfsbzDdylJ7ycKqqNfzR7Sso3Ztj2dZx9l32L7xs/ZPYQpLLBJzaPwACvP6GOt++UFGtGpKxqyT1AUGUVYFclFXiRVu7IBjvdLuhrmfryS4Kp5TlWuEkZOekck9Y0SBzRD1g1+6qsnp7jtbzLwKUe8vazBTP2/oUr7v2Hp515VNkTzr8eP8WOp93kNYdq8isK9PTWyHoStj+158jee4cn3zpFzn0sn+ErOLSvrP7MAC+cPnQ7Bm8tfMY97/qo/zo1ku4vbKFh1sRL+58jIZs8ffzq7m1nuGc7a/k4ZYaTB8bepzb6sMcDk09GCzB/3RzhYMvXAbtAqscNZD3hTWm44BXHXkuPVaePW/5LPe98qPcvuE29m77GpdlLC70XXzhUrAyNGT4H373TSO/4Mu//Umuuulh1RylJCivtLAiiRXIdA7qu9fVHuuazuIrSpIKTAUIQeIIEt+i3meTmYuRtlDdSxOFGItY/QNTgROptkTEKiAub4zw50T7mZZQH5LUViSEBUlunwcDTUQuotUjCToUNcZQCKxAAwlVi5t3ngfAd8e2nnbOLRkyFSuSfLcVMhMWuOyp3+A133sbj279DtnN83ouVDzfsKgDJneJHsVSlUlHOzgtFXanjWpiGL4vZP3XFqgtI/XJrg4p7/LFNS4nr/YYe6aiBTX7JCt/EpI4cM75Rzj3eXtJRprUVkilLYjVfFBdAVZL4M0LSoeVK0irCyw35udPbCIMbUYrHSzWM3T3VHneFY+zZvMoyUgTpw65rgb+hEP+pBIsOg11jm5ZBZWtvpjFc0JOXpvh6dEhgrpL0CVZWK86SxbvzxHUXPzeBtkZ03VSId/1IUXjavYlWCvrCCshfO4CR75xrpqLheSjdz+Xgz9Zy+GvbWUkv8in13yH8u5uxbPv1KjyopoTW5sbhAWJVQjp71/khzdfht1U+gw7F9Iq+zQGk3TutQKQsz4f3XMN+8r9bOs7SjX2+dKuSxl4/TGSf4E9jWW8bv9JRpudlKMMpWyT3KiFtwiDfYtUWz6r8zPUIjWPfPXoxWzpHscqBoQTOaQtwZaUV9h480saAzpLaJINJRiVTnv9M0CVU1MAU/EE5Meltm9Uz07sKZcUK5LkJxMy021QqdEtqI7YuI1EC4ilslKVkvxkTGYuUVSpLkWHMlVWEZP2BDEOa8alLCiBWFMjzkjW90+z2Myyf7EfgM1uxPXFp3hN5yO8qvQ0MRbNxGU86GBPc5gPvuarah7PCDLzSgydaB1LZj4hN5WkYle39j+f3369/fJsv9JIepQBK6sGalhUk0mU11zuPCm3WjpLEOAlwsUwL4nyalF0q22kPTGCVI0mOw01IDPTClVM3LbwcSm6bEWk1m0mUJaWRrdjIFpCKdFlbROww+mUFizdlloj7SZnTFxgSaOfxOc0cWd9sE35iHLtEjPQtoXU+zS2k4mn0YeW8tG2dQMJp6a43EGhHRzbQXu/VqCPU3uhm7K7sU+0QrXPVCCrF+PEBrQaPs6o65s4bd572rWV9jmkAb6tVPBKBEUqPLUinahoWpGhpxiRD4v6+nmkrb9NF1a3LNJra8UgzLUz90ZoX1oL8nbAJ299LlFXRKm3xr9u/SLTcZ5Bu8rDjdV88pMvpndRMncW/M4Dr+PwNV/mMwsjnFmY4LH5FXz5zK/xd11XsxhmefjQahqhS1SQ3HVkPYPdZc5ffopHdq4jm1dVl8UzEgrHbOqDsLBnkHWTv8nNz/gc3/3WM/nLN3yNz+Wu4NhUD9lMQHOVJK56uHXlrdu528JuQuehJjNnZ9TCFCj3kMRRQqzYVS3mo6IkM6XcU/xF2rqKOoQC+p+ICO9YyXhwipLb5Dkfuod/ft3FrHzpU/yQHqDFQTygxggPAnDwyxdgP+ly9qWH6fOrrFv5BJs+cxNWCH9855t420oJPQFHrv/CaeP6vT0HAIt+u0AwEugAvj3Vfenr1yEF7H7rZ/XrRXaHdW7It7i5uor17gxPtDqYiDp5VMQcaA5SsJsk0uL64tP0WAkW0G8r9PxAFLDJdTjTVeWc7669A0DTbtSz8amFFfxe54nTjrNgtct0h6MqNpJVTpGz3FlWOEUuHHiSC4JLAFW2b3VbZKYE+QmZOoqk+pcIaiMW+fFEj1k1mOwgSYXR0lKaAlMON4LOlIwuBEFRuXZY8ZLKVdmm2aMDDAmJL9M5yG4pW8bC9izls0NkRwQNi9y4rcaKfp+yZRRk97m8d9cbKJ5K2LL8ppQeV1su2XLBEb699jbq0uIdfffwurllfOvFn+TlR64neKJL94sQhCVSwbpT1gBI1tAHFErZ6iZN8FVSqYRzTlPS6HWYPqeLrv2S6Wta5HZliHWlsngywbp+nuqOHjijSjyfYfivDjH207N48shyHD9i/fAUU/etpD6gvtebs1MQpNmn9m2FKggq3pvFCiUzF/qUj+fw56DhwY/7unCH6iShxeDlo5zYPYTtLukqm1H/9xbb1BIrtIlysO7Nx+j7CdwbbMCfVeho7IJ/3CdanzBzeUjuoJdWFxWopDzjhSXJHMjQOieC0SxJIebS5UdxVyTsXjvI6Hg3h8s9fMB6Dt68FsV7ksJJwfyV2nEktLBj8LMBOTdgal2Lnr4KF/af4CdPbyZ7uL1vJZwEEQmadY9CX8B0UODAQj8yFhyc6mPrslGWefP8aHorXV6dSuQzNt1JVmu6Zit54sji7vH15L0WJz64kVXPe5B1u6o8VFhFbcZHliI6e2pk7u5kcY2VIudRXt0Lq64AsOy0FpEuJiSO6lwadChKk9FGtTpF26wgAyJRz1ziCQqjGmyzlHjWn5e0OgWNHjullzW7BNlZVdlqdin9TpQVqVDcrWn7YkFqCRwW1H1qdapnlh15XAGHhno5e3CcVw48DEDO8ljp1NkTFhltduGJmHWZSR4qr2MqKHFT59P8RcFo5iysUFXWvKrSUASd6jyNlaS3RDz+y7T9V/ik/3exn/yVDtKLJyVxL6mjwr8NqpZ2G5U2oBFbwwu3W8pT2KkL5UyhHT+kcTaJRRqs2NrlxSDWabMh48CiaRagy7N6kZRLglFjH+bW0BkyCEuVQxSXUn3eisAuq8nRBNmxppaYZkzGA960/rZaKnA2iUlUaAe8Sykwxu/c0rQOwxlPO4XKtjOFtBQH1G6c/h5pt1F4hAo2vLJqJJX47eDZ+Lomtk4mEmj1JGTHrTRoN97wVqR45VFWXR+RoMSymkOoLixEBdU103jWpp7VuqxpB0uuSdy+TrELrV6Z3i9/TlGNnJp6j6HGmHtmhLSm6ZTTAHnxIp8beQhe/VBKy4AcuBLI87fjG2j2QmWVev9LtzzBrfUMH334OXT3V5gd6+BjxasoOAE/278Rx485Od3N2nNOcvLuFUSX1th+ZCUXn3OIPQc34NSg44BNdbnEWlHnrIEpjv94NS9zfofhZ43xhVOXc3nfYVYU5unzqvzNwE7ua8LvP35TapUZFOHkNRncCnQeTqgNWG1XIE0rEgG4CxatTknxhE6YckqkVDglcatZwrdNUr9lGa94+3f50eJWXBGDgP6HOtnx/bNo9kqsUHE1e3fGVIdtVi8/xcThEY5/dR3VV57guq6n6LtijOrNw9T7YeXZo2zunODt4+fzqu6HCaSd8prNZk+pbO3Ohs3VWfUgjHz4UQ5/6ILT3ldJPLLC4bzMCSDHMzI1siLiWFQhloLFOMcrOw7QZeUAJQg1248rZ7Op+9Bp3zcaV+i2PG6rreTy7FHO8kf5bq1IyWqQERG7W8t4efFg+n1rnTatxtZB8631jKJ+NSA3qoKJ1KFJAwCmyZS0VNdB86w7zQQrkEgtHg1Kyo9bWiBC/bpJvq02/SXKiJSyYqhgmRlBdX2IN+UqOpsQBJ3a292TxFkVqBd3u1RXJshSRG25IDOtgjmj71EdEpWLxcQ25elsXLCQ8Mbh+/njyYt4Y8/92Ai+uuFfORIW+dyqW9j1+hzv+dO3sLhGecQbQaBxmEpsiHXlM8pq3roGPryqEnsWj1SZ21IkyiohYFAUWFM+Vgj1ZQl2UzDzGw16v9ZF/Ko5qge6yM0Knt57Frkm9Ox2ibIeR9etJNgckxmskzxZTPn3ytlD0wB1dbSifaqzp+x03IgIunZbsKtAdSWcnBlOG+i5FWgMqbVEVSaVC0/QKclNCqoFdZ/mWjmsTER9mcBdtNtz0YEsbKiTeJ62kFUWj/GKFlIKWos+Vl+Cu7eA8CW5/hrbx1biOjFSQqmrRrXlc9eBMyjofhbZSUF1ucQ+kcUNofviScYrvTh2wvG9Q6pJ1ngv91R7KWpgJqpD5YwYIoE3UMe3E/pKVTwrphm79GZrzGVzdBfqnKp28K8LFxBLi3pziMZChsJ+ZbHYGJJ4dkxQcxkqlJlvZhm6cAyAxSjLSOcCB/p9rMkMcWeDuY3WafyAxFVUpbCoaaQdKhEzLjWZWb1+dxqHM023rKn1pNWpqq1dBxIWV1mEOZHqRNyqCuiRar4L84LI1+CFB0HRJnZZ4hQn2i5xuSUV1lD1PsjMQXW5JDel5sHaMARzWZJBwXemL+Tx2gzv79/Fg80B/nLv85WoV4I7VOfj532LBypncCQSVFdKiocFfkM9K80eVT1bWmFPXG1MkfDr7Zd8+5UO0hu9AkcjUv6i5n1rNNVY51maT9326tVBcFMFr3bDdGZsOyGoBUktdkqsA0FODQrDXzf0GMP5XorYm8BPQOosYyghapFUu7GbbZ71Up63oX4Y14u06RG6/NhaQsuw1PdFhTaFxDjWmH3LJUmLCd5NwG28Xh3toy5t0s50Kac+ACNoM9x0KyDlb8d+u9W0qQYgThfvitgE5VbKy0WqSdckJ6Yhkgkezf0wlQrQjhRB+3qFRRWwiwiaQ1JxGG2VNKQ2mrFKmlzT4U7qpKnZvk+mM625h7GvA35NTQg6IFzI8t1akcU4RywttuUOs8nNpc/jl1fcx4deOskXfvEsWsWEH/5oG7kbAy7feJB67HHNsv3cO7GOWkvxqISQSAlHJvrInz/PxPFuSASPPLWOkk40Og9HlNdaxA2Hghsw9NwTjN2+gqEXneKRA6vZf3SIwaEFmh2zrPnB73Dh2YdpdatgrTgqtSWn6iK5uMoiOyvJj0ccfbFg8B4bkci0I26rR1IdtshOK5/gZregMJYQ5gXLszWan3yQ9914A9ZvWuz7QB+rhmZ49OQKbFcFAgiojyRMXaBEZ1M/HSHqVFSCx868FYCnBg7wvj//4X8wmt3/4DV4zlVPsP6e13P2yBjvnO9GCGj9cTf9jyes7vothJuwYniWxteHaHYK4hzUl8WqM3DDovvsad6y5l4+duvzec0rP5Z+79LGRiu9WSbiKoMaWb927/O5Y+OPAXhtcQYossqJgUr6meXOPg6FGXJWnR4rST8LpB1St2Xm+OjbP8/7Dt7A7PEeCAXF43ZadWr2CnKTMk0yY0/5qCNUF1JQ3s7SEuQmE4Kiek1V7doBvd1KiHxLuXFYBnnVc4kGLtwZFztQNAEV/Im2G1NOi8C1RkVWHZJ8jDXaTqbN/OmVFbf+b677Ju954CV871mf5iXf/UPWbj3JA5X1vKXnXlwh+b3jN/K6wQdZ487w6bnzeE/PLubPEKlGyIjOrYqaa4IS+LPKLhSUvsdUFVudao4ury/Q7BQqeNdzY/6k4gDLjpDS2iqt+3qY2QL+vd0UtPtUq1NdhyijxNOD22MmLnJY/ZEFDr+pqEAULQ6XFgRdCkgw9KDMtFAt4vU1MKi+FIqrjxApzS/OQn5UUB9UVQPViE45eCkLYIFwHHozNWRkYTeUV30rtgg7EmQhRlY8bAcSR5KbUEFlcjLD4npBlE9IsglBJiHbW6dR9Sl11lndOUfGDnn40Q3KvackU7phdVVMZtImLCkx8diJHrKDdYLHurDzbRDEW1TalTijqsu54zZbb9iDheQZnQcZdBd55+MvYVXfLHONHMVsi9lKnlbD5fkbd3H7HReo6oOmZFaXK2Fl83gJYUvKgU9ftkYkLebvWMn2c49z7a4DjFdKlDUq6mxepDaTR4SCqD9GRhZxXmBX1UJXOKkSH6ehgvPZLYJl90VEGcXjl0KJSJMAyqtVEO00NAKu+fi5mQRpWSmlstWpO/faAt1YPF03naYag9VhoZ5NDQQ5NUUjSlxYOFM9Z9URqZLxoubIz0GyJmDvbetpDCZsb57JUxcvY/cTq3EXBa4LcVaSHMnze+Gr+Ivzf8TPq5voXD+H2NUDQFAQaQfUzGx7vZeOomP9MiLpmp36X7Kf/w7br3SQHuWgMKn4nAbtbHW2Fym72RYs2oEKJFM7RNpokwn4BGA1BSxpkGBcU05Dr3Xg5pU5rQGOcQNJXUHs9mJiBFAmyHdqpN06E+1Ig158DPpsuOTGacWIuJb6lptjEhHYS+wVnboO2jV3PDZ0FH3stnFSQX+vaH/W0FWWnnOK0Guk2/Dxw6JGOyoq0zevKy/y9jVwK/p8dOBgrkl6HvpYDa/d8NWNfeNplow66I9y7YXTkpA/ZVTvbQqOCn5IS+zm2KwQZVUZQ6i5hKZxRGoBiULzRKJRv3UBL85X+JOp1dx6bBMfPnQD7qoqQdPhrmd+iqJlM9HqIMnGOPMOdgO+eucVJG7Cpecd4NsPXMxvX3E3D8+t5sCONYpmFUKwpkn5ZAmnahN2R2BJahcHJJEg2p5BJJLly2bZ8fMNyLOqBBsDqqEHNZv+NXPMPtHPxGAXr9j2MN8/dDZ/8Iof8fc/egFuXZAfj4k9mzirArTYF5RXuuSPQE27H/iLCVFWIDoD7MMZElekNpaVERWoBYlN5p5BJr+4go7jD7HutSfV/f/kMMUJde38BYm01EWOffjnN34SS0gqic+JqMKbD7+cD63+HnC68PN/td37zfORQ5KetTUyvSHlIMMtv/stNn7+Jpb9FD724c9yoe9S/kDj33UUbcgWp6KQT0xfxXOe9QRX7Xg9i5UsSWQhyy5ub5NLVhzjgcNr+PK2r9CUFRYSl79f+x0g+x8fkN5WOUVWOZBgY/1PpEGTseTqbMxXO2YYEz0Ii1QQntht1yIjLlf82jaRXiSq5G03VSZpt6Qqf2uaixE2hwU7bcCU2JoGY2lNjN6f01DPtRkDUVZVyBwdfJouh9lRS9PiLOKs4nR7C4LcpHJImbokQXoJ7/npKygct3j4krWIGEbyC+yvDLCqP8OOQPKplT/gC/MXcE7nJG/oepR7m53c86aPcN2H3kV9UNvXeZqXrsd+0NEGUNyactIwVnixJyicCqkOeiS2AlsTi9SSrnO7D6FPNlYVHTNfJK4Kbhr9ygLTaSQ4jZi+nRYTz11OayjEK6sEMcqpuS0za9Hq0pXPojo+U5mLXOWpLmKVlDrNdsUz1nNOUIKgN8KbdtL53lvQ1cgMYFucqnUoqmBHjIgFUUHStXae2YkS+WMOQYdUlRAB82eKdC2LswK7aiMdSbynRKYJgcjwdLELuylwLQg7JG5ZaGobUIxIFmyizginECJbNs3xPIxEOPMObkVVGe2WcjhJXJHejyOLPTRCl7lWjl0HRxBuwsG9y5CuJHvKoTkQQy7mDb338bPgAqSlGsUlrupjIYsR2UMesS84fKqfcHiWycUitpXg3XImd2zexwXbT3Ln0S3UBSSRwOtosW5gmv07VpCUIkQ2wZpX1cCgKDTlUpKdi4lP2Myc5aj1xFe6IqlBK6eh5u/EVh16MwtSaRc6rLQybAcKoY99Zc2YnYLEUUlAlFFUz6Ckkq3slAHmJFFOjcHaMujaI6guR9FqOtT65jT0+j6WRVrQsd+islry9LFl2FE7rnAagsbyiHNGxpiJSoTS5s1r7+PjQy9S3Pak/a/ZC/lTKjg3yXez638zgf56+7++/UoH6d4CJLbAranFKSy0S8AmsPLKMm2z7ZXbVBfDn05cCYkAS9mVmYAxRX91uQvNZ3fqhqMHrU5lv2TeY7d0cGuBjHSwGS0JvE25VCPNIl4SSOtA3yDGS20VTZJg3h9roadT5zS+OmJJ4Gu3F4XEbS8kQqqFJu6SqYXT0gqCEZwt7Xa69LPGtzXRYl1/Xi1YxgHGLWsBb0EihZrc/HmtEbDVcVlLgm3TqEG2Y5PUacWUvo3LQZrsOBB1q8U4zCnOXqyDDlW+UJ83PrbKnULdl8QhTT5M+dpuamqMPgaTTKCrImEJWt0JTGdZfdtv8Y2rP8cHL3oKLoIXH76WPr/KCqfInQ2bW/dvInvKxalCdUtAf/8iK0vzZOyQvtVzrPanuXHVk9zgvZPEUw1aXrjpKX742HlE/QG9A2WCO3uprrTxZyzKZySs2TRKwQ2YP2eBjlyDUxMDzDVzZAbrNEOH4jmzzM0U+fau8/i9rXfz4Ueew/oLT3JkeR/y4SydB0L8G+ap/KJfUYliFdwM/3SKw6/uR45aLFzaJLcrQ6urLZwO8+o6NQYla4szPDq5gulLEmo3bqLZ8Hjf+T/maxseZuambSycH5Df6xFnoeOwZPp8uNBvcyEebWW4fcNt/J8G6A+3Iu6pnUnjvAbWyQx3PryFb7/wU1QSBcXu/Z3PAvDRuTO50D/87wJ0Y9PoiwBXxFxR2scrux/mH8av4Yl7Nig71C6LV/Y/zGO3buLt99ykn5m2sBNB6jBUG9ae+j0ROJL+oQU2dk9yeecBLswcY6XDvzsGw3F/emaI4n6HVo+yVTPc1vlNCZqqmnY/Tikspnup6azrCi2+blPwgNTL2WtKCCWNEVsFpFMKGTWdSZ2mGpuGupedUucVGe2IBVFB8Xz9eZGOv8y0miNaHWoc+dM20rIJemIqZ4Z8+9T53PmKj/DVhQv54vIHWPOzN3Pk2V9kRxDzp737mIoFiwmscJQoJDOf4DQF5dUinePshm4OUzddhSWFUyG1YbetN3GgvMpL+fmxB/mJhGa3BRKycwnNTovYEWkDnMTVlQMbcpOSynILp27h1hW9ZGFbk967M2ruDiSV5Upcm20qekSUEdT7BY1BSW5MEBS0uF8L6nMTaq4xVbjEUAItKBxyqC1PcGoWUV7SWBFR2qPOp7VpBT3+cQ5XHHLDVRoLWRI/5rz+U9zfXEPQ4eiOyZLGIKoqpIN0q6WTg4by2W+siMBNsGddYg/ivOpmaTj2jX6wp1XZVNiSZCoDxUhpEQaaBGEWu2Xj1AS1Eag4lmra5Ss7wUboUm947Jkf4oVbd3LP6FrKtRL+lEPsw6ZNJ1hZmONdh19CvKFG5tE8mRlBeb0kOyYInCS11+WYjzUsaVV9vHxAkliM/9E23tv7OSrnZzg430u5muHNm+/j+392LX/wgdvZXx/ktu3nqrXNgyRWjmylI4J6v+oIWhiXZGYi4owSZ9cGHKrL9RwfqoA9dMCKBHbYXtcUp12NIxGTmjSoHiaKlmWANLeiqleJK2hpmk1hLGFmi+renJ0ySXa72hL70L0b5jZJWl1QOCEobplnanQwrYYHXTC4Yo5m7NBh19lRWc6MV6DVm+DNWzrpVs+UtwDZ2QS/rJ5LtwLBf4wP/F/dJPzaJ33J9isdpFvasqu2TE3MQQdqMOdUAKfU4aItRBRtfrgJcuNELUhRntT6T8SnC0PNoigdiNHBs1Ql/iivFj9Q/O2lHHhL2zRGuqQYFiT+vEIpTdt6g7QI0Uax06RgSfCceJzWRTQNSFmCGOtSskGKjZWksS9cek52S6SLs0hIedyma6ipGFhxex+GjhN0SqyWSBOQxIek2Lb4EonifMcZcOfbIipDkzHB8lLaUOJqpxpNFTZNpEyiEeUVN9MKwKtrxFFAHKqgxW5oa8UmuJq7F/uqJGk3VaKQOOCYBVVfT2hTkaygndwYLr8Rs3qLesL0Ld598CXM3zHEb7zmXp4eHeI1Zz3K7rDOH+97PXLWx66ra0LLYmauQM5VfJ5ayyNvtfjzky/ktc//BV98+HI+d+OXeOvXfwf/rAri6SLNLpfWgHp+m6tCVq2YotLK0Pz0MMO/dwpHJEz0NZje2U9USAi7W8Qth3xHAx7u4CuPXM85Lz3MnvvXkptWHMniCQv7C70M/u5JDu8fRoSC5T9PmLm0j5Xve5CZm7bxN5d8jz8/+Coys+BVEuUi4qux07UXfr5qA+FYDjsU1E8UEYngUHOA5MrzFEd3uwoEAgHTF0iSYsyrj13JK/q3c54/yau/9W72ve7TzCeN1FP8f7Vd4jvkxdN0bG3w2dwzqdd9XvvYG2lWfa45ay9/O/xzuqwc7+w+zMGwymve907mrmvwmYu+zr7WMJ/7+vP48Bu+jCccjtV6eFX3Am/6h98n6IL9b/xs2qRoKq6mvuGO1l4sTRhBPQuGQ52ZcsCC2v4+HhN9PCY3K1/mWjvpM/oPQ+MKiyB9iH3JxOUJmTGb7DRkpgQT14QpYiAjCysTIasug/eLtuBdwtT5UDyuaC9WBJYueYPuMmwpL3wRQ26MFAk2STW6UmgqY06zLTIHVXZ3yxatgRArdIkzCr0POiXZSQuhq2FRDhoDCTgSIeD43iGuefzdPPaav+dgGPPg1Z/gjH95J8+75lHOHXqcexrLeGlhkbeNXcT7B+9mdotFx0GpkH3aDlxG39LshsycoLLcTV0tTCBsRYoKJG3IzEuaXUrobEcQFCzsltSJlcBfVOcHWmNRUHNHfVhZqTb7JcsH58jfa3PyhQMUT0n8BZGKDaOM5ijnFFUlLKnmc2FPhL3oUDwuiF1txRu3QQtDcUxcZcVYWR9DIrCrDmEBguGQY29KOPWLM+g5b4ZKLUOpt0rGjchaIc2qh5MIpL2EMGBJvIpqiJWZV9XioKjmRKtu4+meAyIBf0EtGpau6EaFBBFqKmfNwVA5uzfOMD3ZAfmYuNr2fbctKK9Rdo/ShTCyeeaqwxxa7OXW+85XXa1zkigr+dsXfp33PfVCDk71ETRcvON+6nNvtRSqzIKn3Fhq6nhOznTxinMf5Xi9m50Tw/Rdf4oPrTmb0v0Wv7vuHv760efymR1XsOkPjnNh9giddp2939/CiWerskKr0zi3tXnfhROCoNMmcQReOUZISf+TCUHBot6nAvNAc9ozc5JGryAzJ9M+GSkVs6ZcscKcSAEvY6qQWVDNjEx/kKBD0Oqy6TyYUBuy8KrKb90KtUNMNSFx1DEVTqrxWLukziVdE8w2BgkvqnLrxZ/l4cYKdtZXcv/EGu6YO4uLOo4RSpuO/RbVkfbajlAgY6tkUTwVIhKbVskibLMtf739km6/0kG63YJMXeLWlJgQDC1DDzJflyDjNv2iHaS2KQ2q+YFIA1bTREehIkoE5GpBSpwBdMasuIaqpIamkkR5Rf0APfg16mKBQn4LS0pdBpU3Qkddok2dSfRmUDYRnY74mi0tmWuajOGlGyszww83/uEmAE/3LRX1Iw3iVSp8mgd8WFSThIjBmxOpzZg5NuP8IuQSYa7mnRp6juG3ptfGuM3EIJbQekyJ3goh0o4wsT5pYw3pz+n36mDItLmWtkgpR05THYNTI+XyCXn6cabNqLTw1zgExL4KXLx5bYlnw/ILT5FzQiqhz4rnHWM6KPCiDU+zNXeciahIFFu8/JkP8cH+p/jz6U18dfulxHWXE7uGGaspIdkVF83ygjV3AvCnz9/HmV+6SSVVTxVVpzkvIF5bJQxttgxPcHbHKA/OrGbsbJvRfSN0L19QTYbWVdjYO4MlJDuPjBDHFnFJXdsd+1fgAWe/bA+P3HMWA+88wuz7V2H9j27WWy0Sz6Ky3KfzKw8x9fvbqKyUjIVdNJdF5MccwpwgzqgW58+98nHuHVtDcKqD7j0Wbk01RFr1qkN8/c7L6dgomN8cc98L/449QRfneAtUJNxR28Bab5L17jxXf/ndeJsXecupZ3Cy1snBsX5FOQksrLqt7nVvC88P8b2ISiXLs9Yd4Gilm7XFWT6w+Yf02WWm4xLTUZEbC0dxl1BM1rsF7vzrj3Pl+9/On/z8t0FA/ZKQFc48DzfWcGXPAQbsJr94+0f52uImRuMKR8Iil2US9oRFRTuRqoytHk5Sn/6llS1oj7GgQzlNSNpjyojMltIf3JqmsklF3YiLkuayiMZKtS+77JA4EvIRwkuQsYUIBU5DdT60tJi5/zFVfo89kboSnTYXiHaAkTgKRTfHHXQqRyTT4Ew6EOYUMhdnoNmjtBzV1TGiZWm0WnU4tUIFKgTDMZkpm+agikSzJxxaPZLETwh7Qs699ff5yyu/jytivvvyj/HWA69kzdPn8ug1n+RgKPmH4e0cjhJe/NwH+P4PLksT/KXUMikU8m1FUgVWJVP1Ub7+5tpn55U7jZlbaKBsCy0QsXLriHwtSreUkFdqqlFuTN07EcPywgLHtmwg6AJOGctEzZEvCipr1NwfZyT+qKC5OiR7WAWdzR41LzWz6ruLJ9R+Yw/cJZa4mUmbsCBxGgr55JhLlHeRNswv5JEzPq1cTK0Q8tPqmeT2+9SXqY6mVtNKK4hBqa0b8BZNlbbt652aJuiKb/v6inalMxfjTLiIssXCRB/0RvjjDlFO0upRLldxBpJMQhTaiIEmjh3jiJhyK0OSjQktCytQ+/2znTcQHVYdWQuTInVZM4LkZKSJrLm4VSttLpfZkWNubZ565BFFNlOVIpsf6OHgfDffesYgK663mf7tOodmeulc1eJnc5uI3z2D3D1Ic1AiAlXpEYmqSkmh1tTMvHKqmjvToXQ8IcyrLqT1i+tYR3JpBTHMibQ7d5viKImFwDQdtCJlXWusHTMLqrrW6lTPa31lDNmY4lMeXjWhnlg0egX+vHpOE1uNzdx0ghTQsNWxZB/L8dCj5yJLcNmKI1z3zXfymRd/geX+LI3bLoFXzjLgLvLBz78CkYHEV2CYAfJqwwpsanXaetxICqO/nGhy/F9wWP9dNLO/0kE6KA9i0/HNCtWNS6kRhk7RUoyWoEOLPqrtMphpIGT8xFNHmFSoKFLhpaFdGDpG7OtAXmrPUgF2XU+ICamLiltul8EMjzQNbJv6V6cd2JrM3gTTpgpggoeldJClXsKGOpN2E7XbE5E5n9gn7SRnmjYsFcMazr6hiYAOzBdJhaUiNpZsurrwb11oaFcDTAKRdki02sdhqDSm0pBoz+O0Q6tGLUwiYD5jkMrUZlPz19ETrTlm89Nwfk1iYAIbc63Sex+e/gyZFulBB0hHcmzPsLpvHRHvvOin/G7nKVoy5PZ6J5v8RRZHO7BXqAs93urAm3bJTKnjf8dvfZcvndjGG46+kJwT8C8r7+Ht4+cTrWpgjWYQDUHXjadohB7PWb2XR6ZWsX+yn5lGnt9c+RB/s7YXyi5zxzspjZRZnCrwmYtu5q8nrsFZl/A3K37Aa37wTppdgnxPnXisg9FqB6+8/l6+uv1SRt4xy7GxboSdMPxDj6AkmH7rNmrLJJlpwVc+ez0bX3KMUwdWgbYsu+DSA/zk8EbCukvnbpvsTEKrJOj97INc9NYa1XdMceQjl+Iu2lz7T++mMRIhvJievgqzJzshVDc7E0Ip2+JkrZOcE+K4MZYf0YwyqSA6qjkkMz5y1sIF7t97DlgwFi/n7sy5aS+BxIW/cRU1LehUFQe3AkGXJNOx5L67CW/Z92pVceiI2X/+AO8fuotrCntYZhepJDW2t3yW2fX2GFjy7LT/rxZer6KevTALuKp7pdGxIPVcI0lpV8YiVVoK0bVbUDgJuSfayYVIJImt3KQS2yXKtBG8KKOsF2PHNCVSPHOECkzs0PiYy9Moaa1ONRfVlikqn3QkViDw59tzoukn4S2oMerWBI0hqYLwtS0CV2JVbZJ8jKg4BP0RVk39jURA3aYxmKgkIRdjlR28BYv3f/+l2C0Y2DbG1GKRu6/6OB+YvJKPDT1OQ7YIpaDXrZwGeCSeohAYS7nEVnO6FavzUEmPrpq56qcBD7yKsbxTIk5pKaTRDkD47bnB1rxx6bYt/UQsmKgXycwERNkME9ugY7+yYPQWoTaiKnfdexKqQ4rPHB7x1PxfVUFhmFNiQhFDebWg47ASNRrqX5hXiVxjJAZsBd4IDW5Y4OzJqrl9wUIKl7AjobUmRLQsrIaFdCWiJjTNpV1VMRSgzFwbaDH/pAURiuoXZZWwtbm2hTPhYS06KTUn7IpxZxyC7gSZj7FnHYKeBGJB7qRNczBBnMpQWQaTXSWqdR+Ri7AqPokvyU5YZDYEJCfaIAYojUuzG2RvC1nxIIG580Psmo0VKt/0+79/LvUzW7z6nO08PLuKx46vYEX/LGc97nBW7lZu3tjP8MMlvjK3jW63zpr+GfZlqzx2ZAW2HyPH80QZqA0JCqf0OuILgpIgN6WaWrW61L2RsSAqJtgtRYWxAzVm6v0W2dmEMCtodgryk6qcbYWSpGCl1sZmC4pqnml1A5mY3H4PK4Cpcx1W3TzD1OW9tLpUA61WlyDxbJy6TCvTRseVmYW/vOmr3FfZwHOueoKDrUFeU9rHxy+8msFMmc8fvxzvylkSKcjd2Y3bIBWOGo1cq8PCLydIIf4tXvfr7Zdw+5UO0ltdYOvJ2G6Q2vwZPpgJ+lLOeEAqWgwzWjyZbQflpgGOpL0IpGpqEwgb0Wmi0SqNTAUl9f/UVkwjcSbYNbZ+mNfidoJAAkJTLmJfc7Y1Am6Oy2mp9yVumzOdDtywbZtoPMATv13KtkKwmu1jXdrUxLhAJG57UjLBOEKqtt2uQlkMwm+qDZHmLBsai+GMQ5vTbJTwUUGVUlPE32snFYnTPtYUXY+05/CSe5EKd1nSBVbTYZYmQEGnRs/jdpKQeO3jkQKw2pUME1AFHadz3+NMOyGyW4LElyS5mMIej8/sewH/GMDOd36WTrtOj5VB5EO+/uTFVM/2mWwUccv6Ovnwkd3XAnDHpu+wK5RMxQH7ygNsXXWKJ6fWkbiwrfco37nlcu7a4lEZL/K2Z97BzSfO49MHruAvLrqFv955PZeuOMa9j5yFLeGaL71bBYZn1vhx12Zmn1/n1ks/w0cmn82FG4/yoUeu5y/X/oitVx7jT776OhiJyB3yiL2E7GzC9DnKacfQPI7+YhXLnneSktfirOI4AOU/dNn/rtUUxmKirMX8Jlj40Db2VXdhnbdcBSNdMf4hm2du2Y8lJG8bvJNjZ/TQb1d43c9/m67LpvHtiGrgc3S6B9tOCENbdcGNFVpszTskvqQ5FCkEsWbp0jGpu1Gi9QYiEppOpttze0u87nXSnD3gs3BgAFeAU3W45+R5XOafR9iZYNeU0jjOSuyahZfXY10HQSZAVw4P4rRE2Nh0xl67mYipUklLd8w1VZtYBS8dh5W/t6leKdcg5ZKi9iOUbqKmOOEyaI9NK1LuLkZrEXsqcYxdFaibAF29R+Ivqn3G2QSZSciMObS6E4KSoLEsRgSC0mFLjRldWQu6Euy6yjj8o37aHE4kih6RO+ZQWxNiOwlMZVSCtLwFbgKLHtJTnUrtJjT7JSdGe/jt8+/nw1NX85qeB3nx4esZyJT5zLJHuPE715Gr6jlGAlIFNv5iQnWZlTYREjoojd12YyAzdxhNSWYuIcpahAWBHci07bu01OeERPWm8Nq0vSivnnW3DIdPDmC/wMVuCTqfAq+aAJZCresq6JaWauo1+YyYzLijm9hJnKbicNu6mpiZ1pVKbalpB0pvEmWgcNhR4vWirjJaWk9TkCT5GLwEGjZ2zcItu4hYIfOxp75HWkLxoW2R6nhiV1VDXM2/N/OnqkToeU1XGe1pD7m8STLv0eyDwlEbadvaZtYie8TSVVSFpNfODBAVB5Y1Ge5b4Mqe/eyb6ieyJXExxmparL/uMEe/txap504nJPUZd6sQH83QHIoQiUA0bXKnrDSAt0KwJz2+vuNihfzHgonFEmtLs/x46mxgghXZObqdGh12naOtPr615k62TL9Krfvdan5v9SR4C4qXHhQslRTNSmoDFk5D8cTFeFY1LWyoa+QESnytmhG1k8GgaCkgTuu0vAW1/tSHFdXI9DWIM+Af98jMQnmN8mc/8Ds95EZ1pSOj9hUUlY6l45BU2hBdqV3YmDARdXJJ4TB/fPsruPS6Q3yjfAZ/dtGthNLmujVP8e5P/DbvfOu3+DuuJf5pdzq3uFV1r2MPEseiMB5T/z/X4P+XbTqk+S/Zz3+H7Vc6SPfK0FqpuN6G4oJQE0VmVrm5LKW7pJmxXvSNE0mKvsp2AGfK2wa1SN0+gvbvieZNLxV9RQVwF1Vgm5bB/TY/XSSqDGuCShG0gwIrAWG45jFIIyi11KA36LIJcq1IDwY9KqTTDjJNMB21neHS8wnz2kbM7Es3TEpsRRkRifZaliJFahIX5ZKnE5FEB8aGQiTt9gJoXnNrelFyVPCiKAU6aM63E5WlQk7Dq0+MuFdfmyinrqu5h2lwYuvT13x9OyD1jDc2jMYm019UAbOA1PvdjtvX1ampxdw4+xj/5Dij3n/La/+Ow1E31z0v0I1u1EOyxinjiiKHr/kyfzWzkXf17GAuCbiy+12IGRU41OazIOH3Rq9gdXaGfdVBtnSOU408tl50iMf2rOb9/bv4zplbOXdglFOFDmwk1w7v42t3P4Mv57axvn+aTYUxkosEj962Ca8MlQua/P6We/nUz67jLdfewc3l86iEGf7msev41hX/yCcnruFktZPmQIxVt6meEVJbbbHyVglYystZc5n9Waj/0zLmSxZPr12LWxFkXgSd+9SCFuYEZ3zqJG/8+T18fv0ajvyrR2aHoL5MUF+ecO/TG7ArNvf0rOfCdcfxbIWsTy8UWDsww3wly3DXIsfHe1g2OM+smyecLpFkJFjgLlpEeQG2JCwlOHWB4SC7FdJmZeh75jR10r1EZG2FKvFOBdcm2NXjRtoWcU4iQnCqFk5dV9qc9vNmxGMmeT9NOyI1j1W26RrCUwm7aSCUiqJTLnU72WNJk49ml0V+MkYKyewmGyFFWrEqHU9OQ079RCGEVt0Ek6TUFuPGEeZEGqxJWyJtRZFxqhaN5RHOgk3+lPZr14lHlAN/xlJc82UR/oSj7EyHI5yyTWZKXX+77KhGOJ0hQbdEBhbSllgdAUlg01gfQSJwciFJy+ELdz2L/kcFtz97E79z3n28p/sQfzx5Dnt/57NcsuMl1B/tw6lqr/UMNFzVeKsxoA0BXHUfY01vK4wr7+rqMgFSaZCMJ7y0oNml5n+3qiofdqDua1hoB06mgVqUVZ1Yux7xaPZAfkwSlIQOrjWNyVb78heU00ffQzZCKkqFHbSreqVjMk0iW50KyIj9tguJHSjXo+rydk+OZq8S7VuBQLoWtCycmoUVqAqNeW6dprrniafvrU6oraDtVtXoh7A3xMrEdHTWqezpwp9RVZfaqhiRD7HHfcKaw5Xn7+W+Q2uprnfJjDkEXcoFprZSKlcz1Hedu/Ykxxe7qDc9Th3u5wv1y2iUM/jFFsmxLGFXzLW9e/hSfa3qiumAtDX1JjIdjQVOzVFJYGfb4tdpqCQszkosNyauuQgnoVnzaIH3MgABAABJREFUOFrpph569N87wMPnTPK2Q1MM2ou4IuIr5X7OHRzlgQNrsbNqjXJqFq0eCAM1P2Sn9b1vtZtjhZ1qPPqLkHiCKIHqoArsTYMip6mqU4kLzWGphaKa/pIobYihgvqzitfe6hR0HFKvde4RaWUoPy6xYkWTsluC2qBKfEyFTZYi9taGKTkNfnHjR1nhFKkmY8wlIUXL5vMLZ3Ppa5/g6twJjq7cyT9fdjG5R3M4de1cZ6r+Gagst0nqv8bSf9m3X+kgPfaUa4e3IGj2qoFvgrdWFxh3jsRVi0GjXy+YLTXJGS4ydhthNwF1urDqEqyIISxJHCGUvVOdNoqsKSuJCTottQ8g7SwKOsBcQqUxvPmUvoJB71S50gSuBm03/qimtG2FpClr4urPAMRKxCriNjVEhO19pnZshnqj92ssvtKEIjaLvUkOFOJn0ErQKPwSx5R/h6qbwNxXSKjM6YAnak82JkGwW+rcHF0VseukyBGGzy40Aq+DLrvaTqQM2maSryirJkfTWClxVUXCtHQOOtX3Gs58yp2PltzfuC1mvf577yTpDvCP+URZxYs1k7lB63/3htvJCp9lto8VqSYc/hz44y5WBGsvneKK/D52LC6nYDc5XuvmvI4TrL9oirePn8++y/6Ff6n0cjzfSz3xGPHm+KvrvsMHvvlybn/Dh3nvyRt4+tYNvPClD3J+/hj3lDfwD7dfB47ktvFNvGnF/fzTvmdy5Pov8In59bys71E+07wSmUlIgNxxl1aXZOpcwer3PsjYu7ax4geTHHnNgGr+UVKBo6c1GlFW+f6GeYvKOQHdXzjJ59evwTlzPc5BlXj4Mxa5SWj2Wmx70U6emhnm2GIX08e62bL5OMcXujhwaoCkaeMNx9hezHwtR6vhInNJGuQEAxpVbFkQWohYpGJrKdJhpGgfGqUWOvGNMmCZCpEW8JmOvaCSM1DBdNJQ98x0w43ymr9st58rNSi0lZxsL46RdmxKrVxF+xmN7fazmY6FSHUINQE3QjUeErEkN60Gr0ige1/C3Eblcy6BRDcxil0lUJSWGt9hTiCkRZAX+OUkHadWqJBX0zTNLduEUuDPQatHoeFupV3pEjE0BxKkK5FugmjY2BWbYCTAzsSIRY+4N6DaYeEsOPhzgjC0Cd0EZ9ol8VWgLjoDqKkTd/oaJBNZnJYKKCcvTejYnuE91xyiIVv8zcBOXnrkGh4+92bOePotJI5oV9xaKkBNheM2xJYa004Nav0qEek8nFBZpjpSuhXFVw+KIrWnbXVqkaQekyJR4Eerq51EGUDBIM21IUF0do1oIovoaZGENtnDis7Q7FZUCm9RB8aaLuRo68dGjzrXsNgGULxye/5T3ZQFQYekeFQht6UjSp8S5gXldeDPWjRGIs7ecIJdO1ZBd4CbidgyNM5T96wHAcWzZ+nLV9m/azmbthzn+C2rCUu6qZvlEOVs1q4+ydg5IXMPD6j1oGpRWFanPO/hLDjcf+8mLrzsADvHh7n+oj388BcX0RqIGVk7hSMSjo32Ieo2O/avUHahCXTst4mPdGINSmQ+YOTiU6wtzfL3P30+ffV2wunWlIbCrDFhTpCdViJNQxfNTaokp7E8xMlHxBUXEQuyPU1aDZfDJ/uh5rAwmGXkLpf3fXIb/Z98EICjf3spYlWd/r4y9kBC+a6B1CITFLreGILEl/gzSqMmbZUM5cdVgJuZVb1V8pOS2IXKSkF+VFWhpF4X86cUZ72yUv1ut6BVUkniwnqBNw9xRlAflthH1fyeH1fNxWq9qspnh2r/Tl1pJcKioPOxkIX1LuGsy3Bmnm8eOZ8V/ix/t+satg6P8o3VdzEaVzha7+Ndg3fwdNDJ/toAhXyTek+ODO3quEgAXV36ZdwkbQ3Zf+aW/Dch+/xKB+lBB2RbpB32RKIsw6DdTt5wpBuDqEDPATJ6sjZWgjrQNSh3isQZWoZevEXcLn2nwkf9U9rtZj4GPQb1faaRkJDavztEBRoGudPfaVxGMH8ytBMg5dYnqAnU0nzEJUiwQfEM5cd8ztBokEteN/xZjSIa+ondUMmIFQpwFZIgZDtQN/zd1C5OtDn3QqPfxslFaK6u8T427jAkKb02tZiyAxPUkFpkJi7t0ruhDDXaC6C5NsZNwZ8jFccmXvu6INSEFpTaSJS55gbhMVUFQyVqFdW1MZ63IlLPVrLgK7SsW5IbV6Vxf45UT/DpH1/Hp5aprC3pVtQNK1KNSpJMws8mNsIgLAQZqnGG5/ftZJU7QznJ0JQut9RznOWP8dkjV3Dt8D4qSUY1T9pQ400HXsXcD0bwEhjyFvn8yctJ9APjT1scH+/h48HV7L/uc3xo9iweW1jJP5y8kkw2oGugwvxEEaStqDselF9zKdUNIYdfOwBAea2ylUsckZbY7Ra4QjB7ccjGPzxEDJz4y238+Su/yfueeAGZ+/PEOXXd6mcEHC73sFBVtkJ2zeLGgSdhAO6YO4tD8714TszGoUkcKyEzEFJf4WEJyUCmzNFqD9XAZ66ao1HxCW0Hq2HK0LrSkpEkvky/X+gxbUTXqQVaU9NK9HiKtQBZOiqBNjQ3u6WSQSPejl2h6QgKHVR8c5GONafZ/k5oj1fgNEqciEnb2atxs4S2IiHOWgoBD9vf1703UX7InVaKTpqK0vwZIrVObHbpAF5by4oE1chIQH1IkngKaQRoDiif88RTSUvtrHZQ7VYswi5VYcmNqs+LSU91bHSg1afHoacGu1MHmYuQVRvZGWJPeSSRD7YEWxLNZbBiNeHE2RgrsCivTzjrwddwy0WfoyhCPr7y+0CRP3vRzXzk8y9N5+nEUcK47JT2JrcVBck0hjVgx9xGi+JxSbNLBceipdDzqE8nckuqpsa1KnYhO6NtJPW8mmp9dGWkMZ2hcMKi2mFhLbg0RiJyJxQS7C+055faiHr2gu6Y/HGboLMNhhjAIYzb81lQUP/PjxpkXaGwKpCF/AmL2grlwLLr+DDSkdi2JIkFTxxdzmuefy/3Ta1lXccMP997Jk5dsPvIMjpaQEVrhSxBPNzi6EI3Q4UykyVJ4iXgSho7ull2yThTDw8RdMc88vRaiAQ/GLuQ4roF6g2PuWqO2kweq2EhEoE/UGOka4Ejjy1HooCN3Lj4/7H331GWbVd5N/xba6eTK1d3dc59++Z8da9ytAJISCBARJMR2Bhk2UZgwAlswH4BC5AAIwMiGJAAcdGVUI43x76pcw6Vq86pk3Zc3x9zrX3qvg7fN773NRZD2mP06OrqE3ZYYc5nPs8z8c41aA8bPJVuZ4pRldK5QWmb1HZ2CVIdjwui37goe2BaE7R6/OmArCLZYnqHiOTDSkZhFEnPZ9/UCqeWp/kn7/xr9v+TBX7+zJvY+9oHAGh8cZZWMORLs7Oyn0eGcF4qQd5AEa4r+tsKKnM9Ds4scezL+8Tisy+dR2UPth1+F+W8wo7EAl5MKQo3gYGBVBi7h1Nqiz5he0SXbJ5TDGegeU664cYtRTaeMf3pgtVrQgF9fFtdMdDdHpC+ok0zyOlmFX7o4Jf4hS+/iem5Ng+d2sMj21LuiJq8dOw4vzj/OvbXFummEd974AHe+/wb6e2AolLQPOWVDb908oLC3FfOYaD4Ozivr8hr/x8cX9VBel4zxDUrBM1Ab6iSx7yZR+qaQuCD15MgzLmwhP0RxSKrSjDuWRspxyF3NJigS9nS2gXmuWeRd1tmB0tDcZu3GQk1c2/TJm9GG8pmFxWHqjtqiNtQvMQuisUo8djst67zEQqfVSnFko7H6QL4vPJCRL8Uyub8d1QBJwaSTW9TR1Zb6ncesq4Laukt37TXmIvTgePSu6oE7n3F6H6pXJ6JN1Qlz760RXQIaTFqbBR05XfxBOSRJBXxhF1E/dHzlIYp1l2hy4h3v4kahLH2mRZNcc2XHM1nOD1CzpStbMw8quhvgaxe8D1v+izvmTrBpwce//gPfpDnXvV7LxinjyUJS3mDpaxFoHK+tbHGn5+7lfs++SI+dOhWfu2lf8JT/V38s6mnWStihsbwHbsf4lIySTur0ckqjDUHXHpoB2oL/IM3PMrnVg6xEVdYuDTB+DkRSR3Yscg3zT3Ou6/ezS2N8zz7uVdj6oZuy0f5hsrlQFC589A+IPSBa37sWc7+5M3s/tn7mf/xe8hDWN+nCTcg6kgjj3gc5ravka+v87NnnuBfnd3J84Nt7P3Wp7j8nnuoLEkSNDPTlmfSjlC+wds54OGNvYwHA568up07t19gftDkurGrDPKA1Hjsq4lDzaAIaQUxh5pLHN55Fa0M//nZVxJfrpMHshr7XS3Wn4lQiLKqIa8byJUEkr64P6hMNusiovS0xtjGOZ5whd3cwQhCHY8LpcfZk7ok07n+lARI+3cyDpVlm+B6Mi8d2h70KJNYl4C6w3HMHTXANSYS60djfzYlkq5txWDmyWJE4WG0thWBAmMIOyJa9IZK0HFP7kcxnqAXK1IxuGsDL/HJDfgLoaxNk0P0sXqZrGc1mXNJw4h1n2/pb6lsinnsSfVCG/JagTcZU6sm9E+MkY/lFNVC7FTqGYXx8Qaa7FSTNz3/z3jNGx7jZ7d8hp9avJHvm7yf4axh7ISis380n8OOPJ+4ZR1UhqO1MqvL2hyPi7DZi4WSEnZkTchqgA2mN/d4CHri3FMbyv0azIyuE6BIwetLoGcSD2aHaAP9nS7Dg5m9qyyvNDFGYVItnW8ntbi/VCGvFYiTiiRXmQUywg4lyt/fgtBn+qCMoX3Q0DiviZY1URsoPEHlG1X6e1LCVsJfn7+e9YUmS6e2w46CdCKndTQk6BmwWgYA71KF9tWI9s4qausQ0w3w+proxnWuPLeFag+ylpLnExVUWkO6GxX05Qp77zpHu9Hn0ulZopke+uEWZ6aaVFZEmKhTAZdc34/Ml7WvddZQhIremC8Vw3VD2ClsEyp5ZkF3pF0yvrwmrYsQOw+ht1iFRkZxNRQ3makhoZfz7Yce5S+v3sy5pSnec9PHWX6myY5wlZ/6zJ0c/OGHGf9+Rff1G3iPNulvLzCVHH/dt6ASDNsVFmpN1MEuHdWQRkShUJmShlRXCj1aF1Qu4JfKJUjPqwXNMx5JC1rPBqVTUzw20ip5fZnjg2lNPAnBis/Zt+SYSsr0gwGT/+V+stfeTmd3SPsAcGKMWBv+aPkutm5d57++6nf57Ma1fNcND7HfbzAwMeNen4VBk5ePHWOuOsVi0iIbl+Bg7/55Lk1NUFyuUT2v6O6w1/C14yv6+KoO0lWmxNBj010orRZtIOi6xLlg1tEfwrYqUVPXZt7Z8Tk6R4mOaBtzWn62C+xc2TNtbbL5A6HPWGSuCDch3pZrWIQvDGpLSoeRxSMPgFwWRocG5pFMSIdKwwgBd7xZs4mag6WguKDSod6ly4kteztKgE4k8HDJTREY8oohaGtMrkp0uvAFBXdJSOGP3FlcUuC+x9Fq8tDedysETDfz5JWtSGikUYfj3EWj5+ISDfcsnHOC4yJ7QzWyZFNIUuaBsZtj2LH2mtnoXnmDkQMChTy/PBolBsaXbotCdxHagLNuKyKbzCVQv6j51MJhvrB8gOPP7MQ7PGDfX/4gXl8T2OZYx773fUDC77QDfvvCS/m5x7by4Hf9J7gZJnSNY2mPoJ4RqYCLGcznY9xUucCfXb6NCxdmiC4F7Hv5OW557WU+9ej1LCd1ttfWefbKVsa3dogvTuJd1+H0lRkeaezls6cP8pnKQesioajv69E/NSZODoHBeB55RawUF7/rZpoX4ORv3UnjpJ0zlq7Un5GkNxk3zJ+ZYvm/1dkTfIk3bH2Wv72uBcC2Lw1YuU666i1enmCl51HbtcHwcoM33/QEkc44359EKcOJ9RkWV1v00pDIy2iFMZfNODeOXWZ7uMbByjyPbOzlQ5dv5cUzZwiDjBj7TOsZqRLiuCoUpp5DpkY0kkCiV90LyoYvOpEgwWjY2GvsmFQkEwX+hi7Hvz8QRNLZcpbWnOmoSpM0hdfqqFph2/YTcIJSO7dVJoidPxh1zAV7jsUoCNepssJNY89VgneHuJf6mJLOo0bUN2PsvFD4/aJ83/pBTTJeIL6N8qXh6YpUCLtQPNDEi6C/M0ft65FnGl8LB7d9XUr9dDBqb18xVBb1yKLVrnm1kyH9/Sl0AqgU5LFPZyNEVQ16oCkqBXrgoYfRqEkb8pmf+PSt3Fe/mSe/4de4r7+TT7zjl3nNX7yb8ec1gxlZH4aTqgQTgg15b14BZd2hXEXA9U/wB1aw6KtS7zKYZVSVK+lII1HpZoDAiez9gWL6mZwlzycd85g4tMJK7HPd/kvcM3WGJ9s7aferHJ5d5KVTpxgWAV9c3s/J57ZDM4NMYwzoKCdfD23wXpAeTPCDnKJQBE+LK8lgCyQ7EtgIyrGnc6ErFRpa5w2tcz555NPbVicKJdgPntcEPWX7TohvuviEW860p4hNleDABnlH5kFnuU5tSRO8ZJX0yUm8ZU24Dsl4iLquTzabcmJhFn2sTqWA2uNN4nHE5tAGrNHaqErsgtT6VaHCtfdD4xI0Lxblfd1cyTVaqju1K1KNKiZkjc+q0sinfs4jvm1IMVuQJx5TMz1uGbvI892tvGjqHN+x/SHOxjM0vCGXkkn+0Us/ReW5lD+7fIX8r7axfmdM86mIeFwLoDKXY4KC+oQ0envDvuf46Jk7GGxRdnxZi82WRdA3VbGHMzLGK8uQzBYUoVdaN+rUkDZUuc+pQqgsSdPpQmz1Z90jq2lW7sjobbuHxiUjug+bOPYOZNRaQ65enOR3xl6OVoZ0XPHFITw+OMyvPfJqvvjqXyU1cChc4LHhHr7pzkf561PXY4wiv1yjqOcMZnyMhsaV/0lw9H/w+Luiu/w9AdK/uoP0cB0qznEkpxRvKMdBtMGGE33IhDSlY4MTmrmJN5wV2y1pliATOW2J2KdsuGMb5TiBpMptk4/qqBRWBt1K9mXjy+Zd+EAwaqiEHp270aAUkI7QaW9TKVzlNjj27UdbriWJRdss/9JLR2XIkqZjR/NmpxmgvM60ZXnbPSvW8h3XWpWIe+mAs+lelh7Snggwy86kmfzxhoJCu8DXJRslT94GIg5pdA4zLglx5+w6q5ZcfjNaFAGIJKnw+2p07yy/3V2rGwsjrj3kipKT7s7LOfOoHIK2oGRZ3ZB3VZnQOYtKh/a3/2wHRsNYCBt5xJlv/q3/4Xj9gbGr/OLyGEUr5/G4yaurOTc89G3Ex8fYefsl3tOv8SvX/xnHh3M8sr6Hb97+GHccOMvfdG7mjz71Uhp3nWTvoasc/cgRXv72xyhyjfnMJDe9/ThHP3YYP4L7n72JWgzV1yyxMmFonlM0HmnyC//x93jXY9/Mjqk1ztZmoOcTdmTj8WLDli96LNwtiM3Y86LGbV+f0nouoHZVcfe3Ps3ZO/vkFygDdIClm6tMf8NFhlnAHx7+E96/+Eo+9cWbaFxS/HVyJ7UDba6ZXqQSZtwweZWngYNjS4wHA+LC576jN/CU3skdB85xtd+kG0cEOufRtV10lhvgG7yBhjggG8vwuj55M0OlCpVo0Ea6NvYigigjUWDCHLVYFbpJIgizTsHvqpE41DeSadqEL20IraOyrMpqlpvzuU3KkubIenFzBUmnm3joBtq7ciae9qznMvhDEYHiKfE+zwxeashR5fgsAkVWVfS2aaFf2IDBldhdQi7aFLFUrKwXeKkpE/TGReG/RiuaeFpoLvF0wXB7jlfNiJ6vklegetkj7dTQRmEKSHcmeEGO8QLhXluu62B7LuLGyQQz8DFaEgqFACT+QkARCL1GdCOKaMEnHSugUGRjBTpW+B1N1pDKpY49XvIr7+Jf/OCf8uq/fDd+T9O35fusNkqko3WbQNsk3jl6uCqb7luEtwb9WYU/sO4XDZtEdSm7EycO/cxs4G8TK53LeutofyvXeTTPi0f2yniLl193nLdNP8a/fOYtfOiW3+Hc3DgfmH8ZWhV8z8Qj3FI7x8/Hb8LTBYM04DXbj3OyO8sw91kb1GhGQ9rDKotnJ3n5bc/z+dUjNE94JGMF4aWo9GyvrAjFLK1D44o4/PhDScTGTkvvB5Ub0poWm7+2OL3oFFpnrQOOrQhHKwrTblG3Fo3FuYAsguxzkyTXprSOBmLN2AH9ZM3S/0JQAgrFkzLGXHXCrXGqpAxKtbO7U2gs46ckuRhMi55iOAnD2QI1FdN8sCqi0f1dNuYEFVLaUMQ+k1s69FfrQIVsrQJadBu3zVzij0/cTq2ScLXXYvfOZRqbNoS1tM51tctErz3HL57+KO+89/vYuDHBZIqwmcAgQHd83njb86wkNT52+lqmb1xiptbl6MmdRFfkPMJ1ysqrykbxQlaF/lZD7WxA0rJV8BawJn7sjhMu3VxVOW7dmmIKhd9X1E/40gndUjRddX7mfp+lu6sEKz6PffoIqoB3LF9L+5aE+sSA4HJIamCP36Rn+pwbTrMUN5hq9ujENuFe9tGZBP6uqv614yv3+KoO0pNx4fVFq1Ka1znoDXAWVTqXMrbjKJrIlBZLbuPLK7LoFEoCU28oyKFwzKVxQlqn7NipckrBmUPVjd4UvKoRiu641G5zKaBssLQZsXToMAAOJbcBrVt8HX8aRkGxykGFIwSYTYj85qB2s8AtD0cboUtoysqDDU69oSpLgHnF4A0kuNHDEVJSJj2+lKddFcBdT14VbqYr+zskvaTn2OTKIefOBtFRU0q/a/t+o+RcVGHbogfCTQ7a2lJ7VIn2UWxqFJWPqglZzSZZwQvHUWntZlFDGN0P6UgnSdoffNd/5tv+/B8TrSna+8Q31/iQvHgDYxRKGXaNdTj4uX9InmjOvO4DLOZd/sXlN/C5pw8TrAR4ORRbU/585U7+2cIu4tin2Dlgf2uFT197L+84+yqe+9Bhsho8OnuArYeXWFxr8u2v+SIfv3SErY0N/ubHfpUX/fKPw25Db4fhUneMwf5E3BKuVKhfVqw9OSNo6eU6aUPzqfZ1ZAtV2vUhd+w/z3MfOURtOaNd9xlOKiprhtZJj85NCf1t0jZ9+yc8utula+lnzx6kfm/MD+wa3bf0k7vxPgSnz21FBTk/kH0nWa6pX1IEfWieURSXxjmRj2M0fLE5BQa+2NxCeKjNwell3njj09z34M08/Nw+wrGY6bEu+8ZWOFxfoD2ssrO5zmMPHxSEa2JIHIb4QUFUSeh3qoDhBw7fz4V4kns/eSc6gLwlVTIvFmQ2sTlF1pDmIF5flwm1Q7z9HuJmZOecQ8tc516vL2M4aY6sQXUCYSpJrRdDbwfUL8HkU54EmEZ44+sHfaJVGD+b4zmypjEooyCD3lY9EoHZhDjYGIkbS2S5C80L+ajzppLgTnj5isG0AAzOyWI4U2AaOcorMCtRucZkVcjGc6HEGKg2YpILjXJ+VpdEHJeHBqZjtGfIe4poUdC7dEcMkzkZIeGahr5iuC21XTUNxViG6sjW5PWlIU+yM0WvCN89mYB/9yffQmArg8pW2yqrVrNj6Xu+1bFIcyFe0LhMpxB2DWlLoVIJLl21sroka2LasJZ1FUP9oiKZkN95Qyk2eH1Kly9XaRtOCne8ci7k/qvXk71So5ThJy+8lfW4QieucGZ9kg/md/Kd+x+mF4d898EHaWc19kZLDPKQL1zZh+8V3DJxiavDMWZqXT7/3CHC6QHJrCE81iTYEACjtiBgUBGMGlD5A0meC18Rdgv8bkFW0ygjqEYwMCRjMsfcPudojP7QJiqWDz+clXsVT+fUjwUyPtZt4rpJZ+TWYPcc3Prn9g6dSjIRrstamIzJ5zvhb/LSDYZLNXQrwbtQZfypilR1M/C/1KQ63FSpLGBYm6J2V5teK5BxqAw/fPfn+K/P3c3MWJfQyzh7eisfDm6lFQgs388CKl5GpDP8/XvRPMOvf/1/5XevvoylQZ0k81k5PYvxDOd7k5xrT5B0Q1bt1IrGYrgSlH7jjiKVtkRsOthaSJVOixC0CGDjUA61DHMmIp4qqCzqsmKT1awQ3VJLg7ZksI4GN5hS+LGIzZ3TWdSGxqmA/vYCBopoWdG5cwjtgGR+jLxieOXf/gRvuPlp2mmVBx47jBpPqDVielcaBInQpZybW+/2wf84OPo/eBjU14Sjm46v6iA9WpENMh0TNLi6aH3KC/E2HU6NFnoJTlWJbjkk2O9aTqihdHUJNmSzVpZiEa1KKawIBGlLHSfNot5OwORZnmtpHwilawwWMS5tBe0C6FxEXoAMW6Te+Ze7BdS4JEFZTmUMuI2uGDlPGKGplpSazQJU933OEUUC7RG67M7ZT91rLDc2GXX4c3QQsIiy494OwZSOBtbbfEO4txu7VPn5rqmK0pt49w64z1TpJe3uv6s2BF1V8tKNJ6Irx6N1olInGDW88PqM4/Mqi35mo/vuEi/gBY2igLKrbNqAO6KAk9/xfv6qV+dUvJXH2rt528xj/PRfvgOVK8jhkt9EaUM0UFzzu+8kmciJlj3q8aiC4F0IeO3LnuH9Ox7gA50tfG9roRzTf7L3M+w9sp+5nats8VMCL+fLL/8LAP7o0y+lvaPKnavfw4G3nebpC9t42cGTPHjvjfjX9wiP1iXYzGXziD5bp7PPMJxVfOrCYRhPaHdqPPHMFGNr0J/2CLuGng0IetsM/nwowWsPqgsxK9dXCTYUcTekB7Q+uYcLl6cxiebQax8m/fHtBI0EpQ29QURRKBpdO7dSAwNBiY0HenXEETYLY5wtxjirYKorG1h3h89qUmdhf4sH1F60V1ANEhHBefDyXaeZDHtM+j20KjgYLfC369fza4+8Gi/MMZEEiOQyTpIWpfC7dUY6Zzr/aH9g9RF6RFvz+6Muhq4S5pI8nYPuyrjUuUPeRwh3boWi/a0iUgw7gsh6ls6QV2HxVo94R4pu+9IoK5F70d9i57DTS9g1SwIqqC3mFjG3dBhFiZ4b66jR26oliZiSiawzMJUChhrVylHTMfEUeEGBUgadekSVlDDISDMPtgzpTWpM4glK3pbJmg/8cmw74Xm2LllusKFHDioDT4KbiRQvLDDTOeSKtJpTnegx7FTp703xV/1SH1K6O1lgI2nadS8a0fhcz4vK6oiiZzwX9CjCdejPvVAA391p0cshqKpQWYaWTuOE6YENiJ1wVRY+eb+j/xUBfPmJw4SrHkejcXG0CQvCqSFFrvj88iGGccCfnb+N3a01Pr94gH+w9Xm+bteznOrNEhc+D1/eRdyNmNrS4fXbn+cjH3wp8dQItU2ro8qMBMS2w2tLEHOdGFRh8IYFadUjaosto7HrJVoAHbeO5pt41psrQtQzwLOWsuLYVF020gSoKfd8cM2Q6vMVonVDHklTqcICHa566Kgd7l6tXqtIpjNaX25S64NR1ZJqpApDfV7OIWmKA1symaPHEpRnMP2QYGZI2pcH++fnbmX/7DLDzGe22sM/eIXbJy6QGq8UyB+qzvOO5gXevPNufuwDP8gPftvHOL02xczXHyMCmpzi0k/fw9Kgzurz0xx89wOc/sNbmKl18XTBQlRHGbmuyqpLHOx49DRpSypsw605aMORw5dY6Da57vApHp/fgX9yjP6c3VN9SZqK0JBO5lQu+2V1J48kHjGexA7DGbmPtQVJOusXRAORV2H8yxXpyLoGeU3RunaNu1un2Rcssn5DlR/Y/gXe/TffCWFR2qbe8+pn+JEtn+FzS7v5Sb52fCUfX9VBelaTQDm1G39vm81sQ7FWCnqyWAnPVBBaFwA7uz205aX2IbcCF+exG/QorfWiFTCB8M/8IaR1Q2V15DlchLakVbOLrUWLnYe62bzp57KwOu61E3BiKTGu4ZBRYOpyrToZ0Ul0CliaTjJuN7PBKFjX/zeBWcnH3pR4OgRpcxdO51PuuKTlZ6gRml8eVszlWx9ZlVqudkKJRruuiI52U9h74L7fNSxyiKXRJQNBvstRShziYxG3EvWaEX98J2pzyVgeSTkzWpPvEsGgReTGXrgxO3vGNJD7ljbsuVq+u7bJQtYo+MXVA/zWZ19N7bKmfzCFWPOQOkA0HN1YncoYcBZ9/oYnbjEzOWfe+tsAnEy73Nu9ge9evgVf5y8I0gH+xUvv41effhUzY12Wug0eiVP2BQkvvedZHvrY9Vz/uuM8vbCV6tEqD5y4keoyqKN1VAadwznRoifXbsSFII/ALI4xljgEyVBZLRhOaHLrMFL4lod6Zxv9+TGGd/c4c5NHdErGenglQKcBV6p1wtQGg8DGDSlbWz2W23X2b13mwkf3yLMtjK3eqJJDDJQCZ0rtA5iWzNuxUzJmzNlKyYXu6hoTVbmGB07cLL7IzUI2yHouNoCZYnymQ2WqTS8JWV+pixjcJhsqG9FHlBHkrAiFGhW2bYAXSNWtumKT09yUbehVIdfgkqzC0QsCKZMXgYAE4brMsaQJZkKqcmhoXSisMBTUU8KTMUqCL1VA/aqsS0IHU7T3jzQQ9YUc5wIlgxzHLCEel0Y+tYWCxpWCZEy8y7OGaClq5336hxJMoShiD5VoTDPFv1Ch2hGB4kDZ5CQACqEqEBSlWM2vZ2Q9n3DFF+eSg32KXoAOc9IJqByvSFfeCasVyDTB2Yh4srBe8oq2bfLg9Tyy8ZxozS91P8YTAbA/sNS6TKgsDtBIa/K3o604BxedGQZTwtOPVgSd37yuFk35d7RqRfehVCYcCi9cY+GylxasFjRxaLvKIWsoWqell0AypkgbmiStoQo42tlFuOSzOB3RnqoQdyJ+5/gruO76Czx7fhtKC/3BZIq1tTp/tHwnwaQ0wAGhigC09yoqqxD0DL0tqlyLdQ5ZVRN2Cwrb2CiryPn2dkgFeOyUCDHziqxV/e2G+mVVVhJ9G8xXjkZUViUoz0NxbNnYbX35taC/1c9bgXFFKFlV6wee1qBojUCQzYBN4RsmH/eprIs1ZtBDunZ6Ut2JJ2QvS8akS3C46pEUEeGWPjmaei3GawyYrvVoBTGPnt2F9gznr26nqBScn5lkrD6gF4cEfs6/ve0xTmcZv/n77+VcNs5vXn4V//bIR2idGfLIYC8PrO1nR3KB2WqXa18xzzedOcq/3wfF5+ZIc4+sXqAyr9x7MaN9Pqsb8mohSakyjG/rcKCxzPNP72L+646za98EZ75rjGAD/LvXGCYBu95+lAv/+h6M55E1bNXZ7ufxhBUtxxatX1H05hRRG8ZP5yzf4FFbkLilNi/nk7RgcaXJ0q4mp4ZbWPzgHrz3fJ5gZxfzfJOgCzs+2eY7vvV+vu2BHyDbiIHP/3ex0f/pwyVV/zsP83fwHf9vHF/VQXoRAFbkldXsZLNIWXenZMrgAj1VoiNFYANeG9Q6yltekaAvqwk/NavJRutoIdoG74L62i5kVlDjuMzOMcCLhcNXBoP2b0ezcaIyh7i7oKJsYMImJMn6fruF2/EynQDVcdJLFN1uuOVrNyEhqFGw7QL+MnGIRo42nkP1PIRGw6hNt2viktmExNkyOoS95K77iO0ccj4wKq+65KcUc1kqTmkRyej7Hcpf+PI5ElSp0ubOIe4ou/kW4p9cWZUycVZVuKZEzgrT79pEyLMex5ls4n5f7qlnqwOBHRuqUGwL1kEZevsycbvxRSzn0BNn4en3rV91AiYwBGsKozyufd87+env+FN+48w38o7djzA/aDJbFVuLVz37Zn7v8B/R1B4/PHaZH37JB3kkTvn9lRdzORunqRelZO7DG6ePcuIPD9PbLkFIVoHenoxbj5zj6AP7qS1QagC82AZPrnI0MBaN0fgxJMHofg22KJr3tmR8frYuga2WtvE6HjWD6u020LADxC9Y3aixc3qNqxst6gvy+YU3su503NbSlcgibSAdEqUvgCGzloIuAXT++DobVTwqS1BZlgEcT3hlU652e5qVbTGTU13CWkp1OSqfaVwbzTOnGUkdX9rqGIKhXTPWRtW2wqfsSmjMCGWVRjp2gKpRsJI2hALlpXLeyTil9aij3BWB2iRatAFiPqKv6EwCx3jcrmWeIhgUiOhUgsThhKa2WBCtFyKKtrtA0hI6n/PyNwpqx0IZr34hjYc2hHfuAAP5DkrqWbChyXYmaF+EfPlGAJ6IyPEMRSckmhgSr1eI5v2yclW77DHYWoiDUCEoo0o0+XQKqUYPBKH3NjwJfi1lSPoiyHN31ArnyqJzGR++XddhtL4OJySwTS39yL1mc8fgwjr7ZBYEcM/C9UkoQiVuW0D7cEHrhKZzqKBxTjpW9qZkvKy9dsj0fRVULk3yCk+ThzDYYpthXfJJ+g2ae9tkZ8Z5tr4dHeYlxSha12RNDy+VLqZeLHaEWUW45rUFWf9XXjsker5K66w4Lw3HFWHX0J3zUIXQe1yFNexIDwGdU3ZkNb5UG131oXcgg0Ix/rRUVpKGKiksyTjUr9jqjRLKSnXZEFeUsP5sc6LqskGNK/pzAsS4xFqn8h3yfYZ4TJeIezyh2LgxJjofoa/vcOPWqzx0ag/qckS6LWZmpsNkrU8jSHjs1G4oIJvWnDi7EzOekncC/FRRTGdobVi6OIG/7jN28wJH04Iv9a4jNR5vaD7Nu3d8nJPJVt4//wqSwmN9UMX3CrZWN+hlESt5A+UHZEaXln1i4SoiXWX3puGUVNWN1uQzCfWxIa/f+Tz3L+2lMtfj2sd8Hlr0qWarTFT7vGTmDIMi5FvOPcK733kHrZ+8yNNP78bve6hM9qE7vvdJPvvJm8UOtj9KxONxKDxPBKoNGD8pyVkRSbKUDqv81oXX4w3hT3/m/6JnAubGOlR/9QrP/9I+zjbH+Inf/EGqCtLi70eg+tV8fFUH6XndiAbIbuo6tYhzZMtRSnh0eQQJvEA46A9H6LYTl/o9VfLKBT2WErPjnbkya9KyiYG1BHOHCyixZdyy26FFg8VzmZKXZ3xKizi/R9mwJbd81sKixg5lNso2bclkUXGNmRzq6wLezbzq0iVi03m4oNrYKsJmYakXA4Vd9L1R4F+i2I6DP6TseOoqE06A5Sg94Yb4xzq7Q29I2ZAIGxyqjHIUu06qLjBzG4LbdApfELdSPGbpPzD62wlAe3OSjWRVEZUNq/JcsNeeV+19y+V3ZTKgRvdIJ5QNbqpXFT//Z28ndOPCg3BN0L94wtjzlcqKs28UIXPBYKdh+95lFp7cwrc3V7m680ne//xLUY+0ODth+Oev6/Cz++/l8Xgr77v4Ct6y9SmWsyb3XbqOxTOT3PXaM3zH09+D7vjEcykL6Rhf+pe/yn9auYnf+9QrqF9QKL/giSf38fpXPsEX1m+lsgR+7ESTIjRThTQdySNVjgFVCEq9dljRPC/PLa9IMF5dFlTYufT4A/mcopWx+79pVn7oHmrNNtmzY5yZi2geC6hk0p5dxqulktmg1Ns0jh2i7zQOeajY2AOTz9mN01VcChF/OlFvHih0Lh0i65cs97glnzfxYEShI6qezI88EnTM7ynx8rdJmT9Q+ANVWq8CbOyxfvi5bYhmrRFdcu2akzhetD+Q4LB2RSgupq7KRCJzVqxOBL5JX6EyJOK3QXnp4x4JlSWtqlJ7YTR0d2iqS/LZ4YYEQ82Lma1QKHRiIBN+m6O++FcjdAKDXRnRVZ9ofEiWephCEc37xFMCRjgu/uCmAf7ZKtVF6O/O8FZC8qaITXOj8PycItZQzQVBj33CJb/suuqqbsGGLilt0bIn86cdluCD8SCdyuhv11QWdVndKql3Nrh2wXRqxfUlvS+xXabH7PpblWpGtCaOLg582Awk+ANoXC5o79cSPHVlTg+n5drLMTYYJYiDWchaOVRzUFB5okrhGcKuIehJVaTwoLakySqK3nZZC3rFGEEAei0AFaCUYeZxJZZ/F4XeoHKXJEN9vkCnhqQljbuaD1WF4pKZsvOxsuuoFxtLedKWwqnII0V3++geqlzAB7fvNE74Jc3HS2TOuCZyYVvunfJG+59D8L3Y0J+RdTtpCRhSv2IbB9ln7ro5V1cN/VmZS/G1A7RXEEUZLV3QiT2Yr/PQ4gF2HVigvjshyT0qXsbZ1UnS1OeGvZc4sTTD+mKTuUPLzJ+dwpuMmdm/wdJ6A60LqBTc8pIT/PKuv+L9qy/moeXdfO/OL3Mla/FA7yBPtXewvdZmJtzg84sH6CchF7vj3DBxlXHdx2QpG3GFpQuTYBReX40qxZYCqYxUg4p6jl/JePv+JxgWAdFrz/HO59Z4//MvJR4G5H2fXivi3sH1dDpVbr3jHP/mN/4LP/Z/vROO5Hh9qWZ4A8Wjv3szxSv66OM1onWJG3QqHW572xS1ebuXj0uyOGzAcNrQOqWkOdOOjJ/4vh/F+/RjnHvvHLUf1IRXpHLkGiaqTSYLXymHgb8jTvrfj+OrOkivLCjyGUrbReNZFwBXlnMCSUuB8OIRAmC0LO5ZtdwnRenecUGWiCfTxgiBLULbEMOh7xbVcFxSx/dG2+AO+bexiKDzUXZtpQFbFhwh0u7vtDFC7dOGRWUtvzqzJWosJ7FsiLSJSlImDAa0LRe/IOguLAJj6TQoSTiMRaB8609cWleGYMLROblGTq6xUnlPjKMI2LJpbkiqErw6AZJOZIFxrjcO4VA5kk0xSrR0uimxSdXoe21gXdKWsOissn72FUjrowYiha+I2sITdi4SjpLibaa3uOtzyUIuAZ/KKIPYyef6GF+zcl1V2opflO8p0b50JHSLVgRZuZLMcvo7309qMt4x9iTvvvs0n7tF8fNn38SE3+MVFQP0+Jef2MV/vnWSn77pY9SCBJ1ofvYL38DLrj/Bow9Ooa9qfnvpdSy+vsUTq9v55lfdz8nuLMf++iDf8G1f5ItL+6m+eBn14Smb4IkXd9gpBEX3rHNEbhhMewS9guGkZubJgqShSet2I68LV/rG15zgJ7b/LT916m0Mfm8b8QS87oZnOft9fbIfv4fqfWP0t0LjeEARwPoBJXz2ZWO1B8460LoqBaOqx+ZmPTqB2lU7po0LZqTEn4eCMhk7TvNA2Wdj8DbAi11AYYPwnhXALUN7UspSeaTKJkgqlX9nDRHgqUKCFgl2RsG2zoVekNZHKK9LmtEQLImbStCVNWM4K909dWp9v40gwZ3dgjLWF4VbDKO56s4NhB6wsUeoelkFGktQXZEIX1nB6WBGU786mi8y9q33ui+TPZuLybYq4YQfGFD0Q0yiCZd8/B4Mt+XogSavKIqtMdXnqqXI0qunFHko6PnAx68nGKOob+uSZh5JP4CuLw5aWzN015PKUWQwodAc/J4mrxVEyyIadWuwiqG65BNPQDwpbi8OAXforANXQNa88VMF3W2a+lXDcFKoF65CiJH+E1kdpp4t8IcFSzeK/ZWjZKRN6OwV7nwwsN8Tj0AAw6jSGE9KouH3oIg0wZJX7gt5pCCWsaQzQ9LwGE4qonVDbUExmAY8Q9qAqaeE9712rYzd/pysjV4sFYDAAjvOISjoGeIxtcniVxF0c+KmTzwpa1PjEuiOJAnDcU1lzRCtQ/uAgEhBLOflqhJZTdzKsnoB2iNtqFIEXURSkcImP06fMZxQ4odeVSUFsX/9kK2zbVYe2SLATDISiwY9eY/0ooCoktJfrZKtVKif85halTnUn1UsXd7Gws0btKpDzh6bxu9Lt9lT3j48A/6kYWz/gJvveIrr65f50OVbqVUTNtpV/uGt9/Oz08/z9jNvZX99iVYYM+V3+fDKHZztTrK1usHF/jifPHYNM9MbzNS7LHSbnNiY4Ufv+0GSDyQ0h332HrzKSq/OoDNBd3dBtCrPenhLHy5VRcAa5eyYWqefhzS8GIh4ursDpQxFJlmg7+dsdCsUQ5/3nnklL91ymrlPL5O8MqRn6kTLHnkFVm/KOTK3yOXaGOpTE2W1fOVVMbVnKrK+hIrqSkEeKobTiupVWX+8AVSu+pz5zoLxa+5h4jlZj/OqQSFal9Lw4GvHV/TxVR2kO1TWLYAORY3HReA5nITaoggYo3VZxNyGmFqxoQsugz54QyOlaqQcGbUNlVUYzKgSlcby2J2IqrBBuMpeOGmcG4qc6IhKgd7Eq7a89XCjjIdJmqOkwAksNzc4ygNBlJWxTTFsIL6Zg55How3ccWF1Dq6VuvFttmvR/tJpRWIfsXG0iD3FpuDfBsYgC315Xvno/WXCsInn6QJr9/+ueqAMwju3925zUqBTMBbl2NwMxqGRLglzPuzGA+JR8mSUiHW8WDiggRUzVhcFKe3uEHtFVyVwlJnCd81PbOCe2K5+Ss67cSWnCDR51Rd3iboNIC1/PmlZSsQQKpclyBvMgo4Vd/zMOyUYeGObSphy4/QVPnnkb8pr+831Hcy9VuwM/83jbyJfiaCec/uRc9x/bi/FoSFbZjr0Tk3zsT95EfvedIaT3VkefW4v6pqEP3rsRXz9TU/x8U/czoRFqbOKIOnxmGb9IHDjBlmmqT5Yp4iEh+4PobNL07hiWLkjZ/phj+GUYte/up+xN9b59nt/lMYZTcU3JOOGE+0ZAs5T+LB2naEIChrnPIaThvqlTX7UylY9MgkwtUWpjVajFu2+zBMXrMhYFaQZLD3EonciyjbWqlSRh5Ym4ehYG6PKULS2qbpSlcmhU03hG8KeJqvbZj1aNr6sKt05yRXVBSX85UiVXUP9nlQXUCPrNlMfuci4AL7wDUFXEpPCJknjp8VWL68oilDOO+wU9j0KlCIPJKl0HYqri1Bbykr3Ftf9dPaJzApHzUgYGNomOr4EGWTS20AZKLIANdToQlrRZw2FShSVHV3iC00qxysMp+Sc+weFmkIODLX4oC9WUaliuA2KxQrVJV3qVsIFn6xuqNy4RudqE3IFviFrpqi2iAFLKpqW5Gg4KWtxsCFjwyXvqgDsOlSElJz1zk5B3JOmKqt/DilWxlrk1WD5Bk3zwsjXPa++sLroBPwqE81ItEYZFEfrBv85WHpxilfJMOerFK2MONBUr3qiU1mXJkpZzaO/RdaH/t4MMkX1qkfjkgGliacL2gc0Y6cNrVOapCE0ymRHitrwqc67ANvgDwrbtM41qpIArbKek0UaLxU3oiKQPSgZ82hezMmqyiY1RrqvToolp5eMaFiDWekSOpzyJLHJGHV+tgLbaN3g94WeUnZqtfd2OFMIPSnMuXp+iuYN6yhlSB+ZoL29oBgXgfDMxAahnzH/4DZ4vMXkijxPfyC6iLQuFCEUpF9qMlRNGoXVddVG635lSXH2i7s5sWcLnwoP02oMGcYBYxN9fnb6eV717JuZqva598z1fMvBx/nY2k08t76FlY06p6/MUK0nmHaIN1uw1Guws7XORhIxdtrwkq97goeXdhN6OZ31Gv7+HsHp+gi0G/j4mZJCqzbsbq6xmtZ5cHkPEecYDwb0NyqEtZTt29fZ01zlxPosK0Gdq2enubdXZfJInWE/xRtq8qqRQLuvOfHwbg7ccYELrQmysZxiqAnOVgQ4DBTeUPaIrCqbr5dYmpwNwptHBfnJqtb9qK9G/RkMhEPDV9oh7i76//sL/x8eX3N3+XtwFD6Y0JBMFFSveiVSW1lRJaLqBF8AuR6VsIO+BKzxlKAx0botx9vnrlNTBrracUwt99GVyEA2Fc8Gi9Yha+SSUlj7NptEbG6SVDhahQ2cwSKFpcpfvsu3Qa9zeZES+ianFFcqtmh2GeTaAKWk1ihK32C3GDsP183dTjc707h7pyz1ZnMLc2dR56yg8goY61DhucTFcXtDbGMdSiGtK+WOuNOUVCOwfFLP0pJswF+EEtAVNglx/FRHLXFNmpxg1wXawymhvJS0Huc2sqkq4A0tT9YG4yqjDL49+52d/Yas4mEOVpl6PqO3xaKwqxBtFHR2ij2XKuRZOgsuLxb/Yn9oWLi7IMo1Kwst7h9EDHZ8hqHJee/qbbyscYyPqJu4fGqGaNlDhZBOpxxbmqXINGYjYL47RfOscGaffm43kzvXGd/a4a17jvJHz9/B33z5VmptyoqGTo0NECE+MGTy403LAzY4bUXYMXiBorNHUb3ks3xbTuOMx5lfupuTDxc0z0pgkdUUenuP4LXn8cbHSVoQ7dpgstHnUjiNvy58Y9dESRWmDGDLMWlFf1lFgTfqNFn4IzTQjWuVm/L5KiUcXne4CoE3HL0+tmXjsCNNRpSB2hU96ihcM2hU2UG0uijz33UYzUNFOpYz2KrxexJox1M5/oYnCGNF0GJpVEU5aV2C3DxvKwebxLFeIgLPwPKJ3flmVaErZFXXIEXuVVaVcRiPQePqpjldjCpKha9o7/NoXC7KoBTA72rSSOOv+5KYVHOCq2FZZSxBhlrOYKlGMFDEU7Y7KQrV9ShqoOo5DD3CiyFZs8Db0Scd+HiJIm3aCkkOFIqiUjA8OgE7Y4JqhjpRRxU+mQ1UdDayjk2bVphZH2lygo0RdcUJ+d26qlMBN4Ku3IN4Uv4vWpVEye/J2p22DCq11IzCCsRdtc9QzkkXsHtD+b5gw1ZjYkNlNSd+LmA4FZBuswtLIM9kODXqHOrW297+lGDVJ+hIwJzWbaA8kO6h7X2K2gKkEzB2StEdhhgt2pHhrIid576syCLxzu/sFfpT67yhu83HHwgKr6C0nWxcFr/9oCdzMffEwSzYkLUxtTxylYuHubOvTFtyz4KeISygaENvuyKtC+Uiq1pa6BvWiI9OSNWho6WT88k6Zi4l/JtxOvtA3dhl9+Q6K706aeax/uAsXh8qidzfcMPQ26pImor6VSPVGQs4uQQi6IurjdsfnCFCtA7+cxXiKUMnq8PeHknq8TvtOXY21jm6NMeB6WXe2nqct93/ToIwY7gRMTXb4ZrJRZ71t9JPAnaNrcv3vPY83/3c43xy+VoW1prcsP8K11y/QCer8IC/Fx5tyt60FEhwXDOopQh9WCZ0YDfRhWGTWnNIlnuMR0NOd6a5c+Y8921cCzlcv2We9b9Y5u0/A4MjIY+v7MDTBW/edpTfPXYPC135Hmo5/qpH1iqozOuy+/BgiySb9auUejmjoTpvK3Mued0EDholcUda//sRqH41H1/VQboMZEU85RGtSzko6NmNoMlIWOmQWIeoWORb2U3CKOhth9q8KsvcI3GXRWdtEGgsuqoT+TzHr01rTigIjoPphJpgA2Dkd7kN/pxox3iUVnFODGl8SqS3DM5toO73KEuVjvdatriHMtAsqSl6NNG1oewW6twnSvvHIWUzpGDDcuPhBe4cjvdZ/tu60PgDKwKz1QNjFxqjYeJkLiIpA0lDM5xgZA/puIFmtDE7tF0ZcRZRubKaAfnsYIMXWkvaQCltCMXB2ZvpQJwj8qoglLUFCaLSumxaaYsSvc8a9tqsYFDb63MWcUUIQUeCgPHTOYWvGDtXMJjS4hk8psvzcQlMEYhoUcdybRu7FTrWxL2QuW1r9OKQO3/tx+HuNr2FOr9ffxEm1UItWBtj8qYlttQ3ePrYLoyCaM3DHOwxfWiNM+e2sHv3ErdMXiI1Hs92tpF0QrzpGHWhOqr82Ge28xvOsvJbu4USoiEek4BWFRCuFWRVTdYVLuQb73qS+3ft5UXT8zzzR9fawFHRm4O/vPv9vIu7Of+PriXswN7pZU5+eh/64JCX3HiMu8bO8PnVwzx8ejfV5yuEHatTyIUK4eZDEcr482PhsHuJES/7iiqpXdiA2oslkCq7CGcSkIcd4femdfF5r89L903ndlFYsXC0KhUOZRNplCHoKZJxSzer2kY7GVQWPOtOI98VrkryL7oKRW7R8jwa+fK7BLlwc2E4Qi672xXRuqDyaRWitgh23XvcNYgYxZBMCC0hbcLGDp/6vAQKwl9X5ZrSOpdbFN7O91CRbUlRA498OqFyJiIZ0zLnxqXC4dycaqdCCSybhnBNSV+EJlQWNTrR9I4kqHSkz0mXK1DNS2G9ThTGM5iKIWh7pHuG+EGOOlmnONgjfLKO3xO6oGtQ5pLdvCpOR2iDv+4TrVgOv6WeuIQ8q0FeK6hf0KVrkyDkht4OqCwqSYIG1pEpk3mNGrl1aSiBlrQu83/ixBCdFKzcUJMxUijSmqI+b9fyFCpnwrLjaVYFfaBLP28Qb5X7ayo5W77o4yUGv5+zsdMnHofx0wXdrbJAjp029LfartYeTD9VkLQUxXm/rAL0Zz0G0xAfGTA10WXp4gSNS54ARAVU1gp6FV2K+wczmubFnMp6wfxhj9q87WTpOxEntrcFo6Z7tmKV1Sj1OX5fqGXGOuZUlyTp6V1qocaEplSbh9a5lOUbQsJ18RavXYG02+DsoZCZmTav3nmCj+bXMdHqsbDSYuKzVYaTskbWFiXJqKyJjqWsPinZX5wGAQuCORpm0BOnnsoy9Cs12N3hl+59C7OPGwZv6/M9R77Emz/5j1GFgiYor6AeJkwGfWbqXaYrPTpJheQVV/lHp05yJp7lFVMnWIurnOzM8Oa5o8z4G7xq/Hl+Qb2B5FQTCiWdegG1bcADF/eSXGjwvrf8F/4j1xF5GZ42JIkiKzSeKlhPqxijaO3s8PT8HDtZ5lB1nn/7pa/n0Pc/Qv7q2/jbT7f4pqeepJtHsB0+84G76G0Hr6dJxqGyKnOsuiBdaP3BJspex1Z5VqUqUupgGqO4IY7AW/qfBEf/Bw8DfzfuLl9D0r/yjyICNZBBDtbGqGJLqIwoIy5wcpuATsSCrXRssRMgtsGjHyvCDeHtOssr9KgLniuBu5JqucluCsydp2/QhcqKCAv7s4rCCqBcgx0nHtPu85zbSn8UqL7A3cRRBNIRyu+a9pSuLhbZh1EA7PiP2EDYuas4lM0t6k5MqXMostE1uA0eKAPbsmJgRm45ZVKSUPKbnVARBWG3ICyFlYruNjVydchH6HfQs+dixXAOJVcFZJYb76oC7vuiPiVdKeiOXp82C5Lpgqzmi01ebu2xui+kFjkUz3hSEtcp4t7jjwTCeQXWD3glvzC37hauQdTmBk1eAiaRgCtaE2FQUSlQ7YDeE1uYejbh07//Pt5x9lU8/txh8qGmdkUzvCXjja9/lHsfu5nlRgN/3SNcU/R35tTDjPUP7yB8RY8Lx7fAYbhl8hJH5+dQmaYY+sw8ldDbFhB2CpKWBgXTlR5LgSobitSWxI2kuiJdK4tQ+OpeDFnhMfP1x/AfbJUCtv4W+Pl3/CHv2n03F3/2HuqXZUM5/fF91JeAG1O+dGY/3V0RE2Gf77jpYebuWOfPLt3G5dVxtFdw67ZLPHZ5J+mVGrVLQvEwWpVuML3d9jm2JTB3VCdtOeReIueYVeQ6Vm4WGpHxhR6jU2W1CDbptQGzMpZqhvy/ayCTW7pcsKHKxF4xokEoG0w59LUIpWGJsxp11DYXBEWWfx2PW+pUaJh8dkS7GE4qEqPwFwtL3XjhJjOYVCP6laN0FJsTY7FtFOcNNfrZJvIYROxo5339srKdcVWZiLt1sLA7RzxVYDyDHk/QJ6rkVWnk49aIbCYXEUyqoZaLhZ+d9CrWFBWgE2AGEXloMJdrZA35/HBdEGeA2rmgXK+CNU8Q9FiQclUIR93ZqYZtC4Ks6HLNU7nMoaIrfttZw2poPEqHnhK08LAOXTahL+T597dAWquUVDlXNVQFVJcTujsqzD6Rk4eK1WskwQk2wDzYIK9C9WLA2GlD4fnE49JbYPy0YexcxvlvLEhbAePHjLU2VDQuSdVh+SaoL0gFTyfGriPCQW9eMNTmqyzdHjL7gKY/o2hcNTYxUWXiEHXE/ag/49HbJvfO6aPiSZkrE88pwl5BWohdpN+X+VNZldcaDzb2GsZO2vvcKchDXa6B1aseWU3OyWgYzATlPUxtldHrw9ijIWs7ZvjI8WkO3nKBOyfP84dLd7L+6j61h2plAO6Sp6w6orVoS3/KqxZAY7THZQ3QfVCZJNBmKmZwscm1d57j5N4Z4rUK737o7UTzAbWbVzk8uUQnjbi0Ps4b9j3FO2fWeDLewfvPv4wr//4ehsU5Jv0uO4MVjo9vYWHYoqJSUuNxNp7h5btOsbKlwVNXt6EKRbIRogpFFKbccfdz/PHS3UAHjWG60SWteYyHAxJb+va9nFfvPMH8sMUycEflHIe+/xG+5dg8iflb9oRL/Itf/z62/sr9ALR/IydckfdOP12wfkAy07xiA/UZuU/1S7bCN5T1y7+ujfeFMfrbDTpVEEgS4+ijXzu+so+v6iA9XLc/KFtKs2VhF1AlYxbp1RLA+n1BrsqgihEC5jqDpk35OW4paeRjkZnCt5SYIaKyV8BQ/GTj1mizrV8VBCFpSeAvVoQymyqrguA5hMoJphza4dBu11zFlWidl7mXgHHcXHvOuULQ8Ki8FaUrTK5HYs6yjGwRPnEaGFFwjIKsRdmsorIsr/fspu6Q4VI4pxDU2VJoygBVjRIfb2hegObmoSLomxJh92LD2JnRa9K6BO1u437BoV6IuDv9gbJVksJtCrE86xLNtj7Iui+LY16xz3FFytiVFSuetVUW2PQ9NuExVjjb25/ibUgjmrRpyCuFvK+RYjoB/oZ8R7Qmm1RSh+HuFB1lDIY+jRMBftcT4daKYfn6kH0f/z5INQHyDPo7Cm7feYn7F/ZAVKAuV8jqBVlLAtLs6Bi9u2L05RpqJub82Vl6f7qNYBzyaXmGyzd4bOzPmXjWw7kEPXRpN9GYjNPG5YL6hx6k/Z13l4hu0JVocPsv3M/ZX4B/8GyH3/jUi1AHDVsfMFz+Bzm/fXAf3HMzw605E8fFDhAD3R1QjVK2jsmGtpbUqHsxJ7qHecu2o2xsqfBHJ25nLBhweHaRPXtXOdWd5rkTO2ie8EmblpJgZByLUFeVtCajlXWosF1eNVRWDbVFAAleSn1KLOMg3pLhr/uk/mhMe8ORD7YTUWMTS1d5CtsjNNcFx4UnPFFHzXJ2fuHGKIHWC8aW7oXiFE+Aaiv8gYjCdGHwYkV3jyGracbOFmXDF2MkGBvOjuarPwB/aEpBuFur1KZKmKsMCJ3P4K0EZK0cv+OVY9mzc7HwrPOHluuI92RUrvoYrcjqBpYjgi70dhUwE8NSJJWPVKFijQkNDBT+QOMN5T1FtYAoR68F5JFkFqZSUEwZTKYodmb4lyuoQqxsM5s85VVDXpXkyI1PlUM6nhOseSOgw4fBjpzaeQ9dOLee0bpfRBI0unuRVWW993tCTxk/lbJ8Q0AyNgIuknEZA/HkaM2tX4GlmypCH8oNw3GP8VMFyzfpsjFbZVkS28GkNEZyAtf8gjyM8FIoTh2TIvLs7pRk0x8YKiuatUOKxmXRsHhDs6mbtOwHzZMeSVMQaBDal8qgPm/ozmkBeXYLeBKuS9Den7Xah6mU6S8EeIlUpdKaJMD5BKXtqfEh3h0TXozEHSeG4aSmsmrHrxJXEgqxaow6hvWDqgyq3Zrr9AjVeShCxYVP7eZSupt6Ad39OfnL2qjPj1F4gto7pyOVW7vMVsGvfd3v83PH3sxEtc/lz+3EmRboTDzDs2aO39V4VyN0qjj78b34QJhBtObbvg+THG1Nikh9xfAja98JytB6IkLlsPfX7+eXT76D5TsKDr7zIbY+EHF96wofOjLLq56RkuwgD1ka1PF0QaEULzpyhscu7uBVO04yF7b55PUN9j5co5eH5EbTDGMevLCHqVYPrQxv3XeUm+vn+UDnJax+dIa3fPxODvIwB8MFFvMmn+sc4aXf/hjet4e8bvxpfu7YYaZ+9Dgnf/cOVgioLo5E9IOtNia5foPskSY6th1pr8LgYpO6D95QkVelO6pzd8trfEUeX3N3GR1f1UG68YTb5g0ouc4OIdbWClCllJaGKpcyf7ghi2AeSpAtXFBF0DPoXBCOzR7gtQVpnOFZKzvxdX4h/xkog88iECTYbQzKyHc5vrnKQSlQQ9lMHJJceCNUu6TFeOI+4pBh16nUlQpd8K1jy+N2Yth4xLE2PuWI1pbb6u6fcgJV+10OvUxbNnCylBltkXZ3j8vXWns+oESWS29rX9xdHFoqLisW7XIouAFluynq1DB2Tj5s9YhcmPNOd6KxsvoAJf3BHX7fjomWvdZ05PRTRIa8akjGIRlTRKuK+hVYu9ZYV5eRmNFLRuh6UhslKOFiUCL34ZrCeJ69j14Z1DtRrLGl+B07l1nqNFCeofnKNdZ7VfZOr7C3scInP3EbxB533XiKY39ymM5dCWY9ZEdtjYqXcj5MBM1C0X9gmv7ulKJSwFAoGNOTG7T7VVZvqNE8o4lWYOoZzWBKnkU8Aa2zBbX5FJ4OSVs5va0e7X2a+f90N95QMXEMutt8onXD1l+5n/iTe0hzj9/41AzKwP53PQDAoT+HM//xbvJ6QbTgEfQzQIKHf/hNnyDSKb/1B2/i7L6Mb7jtcR5a3MPhiUV2hCs8P9jO3FiH4+1ZGkHCR49fx96tyxw6cIWF53aNSvOFfd65jOtoVX6XNGW85CEk2+z4HqqS61rOOctvri5A/bJH2hTEPBk3VJZGKHXpaKRdNcZQRCLS04liOCMUq8qyTZwtr9lVzfzBKKFzVDCVq9I1yh8Y8dneqkrha39GLPgwAh7ETU3YM/a6pXDrLGArK3I97QOK6ScVWU0RtQuL2OvynDa7OTlLR68ndJeiE+HFcv2O/+0SGZVDuOSXtqj+QNHflZNVNUFbkw+rZDMplfMBxhNOv4kNxVxMkYfkjQKVKBE1GqcFUlQXNGndIx0rIDR4i1XyWoHuqRLl1qk0tiEsYMOX4G0sJ1j3CJc9EYkb6O3OCdoe9TMj+lEpHNWUNIkiErrGcMomK9moYrB4W1Da2/oDEZIbDbrNSH+Tj+w606amuqBFWOkrtn0po7PbZzAD3T2G4ZQqxYZJXRKo4YTGj02ZmHevT/AeC6lfEnpbbV4cU7xEbE5nniyIW5rmBaEr5RVFb1xRWTFlBSWtyjOvLhdkFXGDySJJJlyFqAgUQV/OnaGW4Lwh98VLxVN9OK5GeqMMgo2oFGu7JHXtOmv5Nw61A23yB8dFEH6N5atXZCy2rgjX3Okm4km5D7WF0T7YPOHxijtO8snx26UZYN/Ya4TBXEGwrc+v3/qnXEymmGt0ODK2wME3L/HI4i7W23X8k1V0Aq0Tsq72t9p13s6rIrei6iXo7jZkrRyvr0lbmtpxSZLShiRyp37tRXgDhQkKPnjxy8x6DX6nPcc7T3b41//5u7jmW4+zt77MeNBnudFgcdDgbTOPcfPYBT5zfZ1naPAPnu1wcejz6OJOBnHAldSjWklpvuEUyad38qcfeykfPngzH7z9A/zk6bcx+cMnuO1Jw7/bdxNvfX6Zvzh+E9oz1CoJp7rTvH3P43zgT++h9mRAPGXobVdk4zkH3/kQAJffcw/D8w2KaxL8xYBgQzHzvgeZMaNw9MR/uYPapaBMUL0eXzu+wo+v6iB9OFNQ7Y8C1iJCNj2L8Po9yuY1LngqPGkgoDPh5GaV0QbiJbKBu+ZFKnWos7LetMiGZCkNOjWllaMLFoByo3GUkNxXZYC52WbRbdJZTWgh4+dS1vcHwtN2JXoji2qxybrO61OiFI6rNpweVQPymg02B7ywzG3LY+4+ZTUICso28A7dcSU4oNxggFKM6qwGnYuC41gCI544UnFw/EqjVFnCd84uLmhy7hTl//tqdL6W8lMG5JYe5IJg39KC2HzvN9yma38XK3IDhCMW22CuYDAH0YouPy+PoHGB0mrTufg4akBeE4EaqFLI6g0RFxr7vHUmQUjQU6RjcNvURf7q3K1UrvhsedVVfmL/p3h7o83Bz/1DKkfa7Gp1eOjJA9Ra0GgOuXbfeT5z6SDdExPc8+LneOiT1xHc0CarwZbt68SZR7db5R+99JNciCf5xJ/cRT4rlZ3aolR18opwq3t7MryBT9j1pKwdyX0+8HWneebhfYydFrRMGdjyaxKMR689RwTc+qUOnZcsoW6/gdPf2pBNMiwI1jymnilY3yctsDduHzLpd6nphOGMoXLV597P30FlT4fFaoMne7vZW1nipsnL/IPxp5lPx+lnAXHu8/LZU9wX7xKnoRple3OgbDzmxp58v/zeCeXcs1GFbWYTjH7vxYIm6hSiZUV/W4HfFecFvz/qUktgMD5U56VBTdqQYBklPztdRNBTmEICBOPB+jWG2uUXCpJdEgoS/LUuCA9fZ4bKGgxmFX5Pxk5vO1SPFqR1cSTRViQ73JaRTIiwMOxYCB1YutGjumwdcDxKhN6JlPNQBPM6Bi5H4nI1MVr7XKLpegQEPSwVzVJTFn2yul1P+uCfCxjszNCVDKUNar6CF+Ql1QUURVMmbVHNUR2f/rZNtfdKTl7VUCjSyRzT0aRTGdF8AEGBGupRhbPjkY7lRCseScsQrSmaJ72RxoYRMBGtWKcsKzQvKiOL1M12sBu7LSUxlHUiq9tqwmBERXRAhkuq8xD8htiH6hzae3y8ROgf0XpBf4tHFgkaH61KUjacBlWM9hCUYWOfoXFBfPxXb82ZvV+zflhRWXIVUMNgyhPkuyGgUdJSIycsu/YbrUoqyHBKlfz6aF2sQwtPKj/huj/qiBtJgJ5VpaIzbIy84b0EER+mUhWIx5X4u2+DdDqj9tB4mfg6D/3MOl7FY0qaHbUU2pfEN6/CMJcBqmMZUx/75O3c8toTHPvwIbKa2EMCMJnwn275c37ymbfROzFOsKF4bmo3OlbkY7lobgbQuCzju7tdhLcgNBC/L/+3dHtBaAXq0aKP35Vr7u8QgXd1QcZwXlWwp8fcWI9/eulN/PO5j/P1jZOsFJqZJ/pMfXeXi4MJDtYX+aaJR/iz1bv4L4f2AHDml+/mzhcf48MX9zNeGVAYRZ5rqpWUwfExAK4fv8prvv4Yb2w8zd92r+c1W47xW7//Mvr/xqfGQ3x65Qi+XzBcqcIEnOrPEOqc99z0cf7kW+Y4+Zt34fVk01r8sXu45luOc1v9y6ynVU5vTPPWFz3JXx6ZxrvhGpb+Q8Fbdj5NoDO4/hFO/+EthMeroEdNwb6SDoMi34ye/e/6nr+D7/h/4/j7cZb/m449115h4p4FvAQGWx0qRekoEE8ZejsNG/sLBnNiWTZ2riDoyaKdVSXwjNbl8/JIyrLR2iggHE5Zx4UqtlugoOJ5BGlDyeLqjUrRpQ2hN9owdGq5ZQMrgAttCd6Xz/CGBj82dLf7I+45svF4qaDtQVcU4JUl2UT8vizQyliP2nXLnw7kbycgKt1kbKCf1SkReMc7NVZg5/flO3VqW5w7VblDK+15lW4JuQ2UB6PPcsGAC7Kl26QRPrEVuhktZe5woyBaz0vOcWkbaff6kp+aus9xZVdTImrSMEiuqURVrYVbiaQHhrxWQC7oX14rMJUCo2WzSRvyR246ZQOjsvmTvYdBR5G38pHv/nBUtXF+0PKdsnFlNcOvzD3GO+58iH/zbX/MXx74BG+oLbDvk99LsRwxHIRc+uJO3njXk/T2ppgvjXPyDw7TXqtTv6Q405kCDb1LTYxniO+bwRjFqw8cZ8zrc031Ktu/0KV1WvGN3/s50oZ1cZkUS8EfveczoODKi30Gk5rBlKKymvP043vRibhKBF2Id23yuLRH5yVLHHw04sQ7K3gDRXVe4Xc9qtetoQpD1DbsfccpfvfFv8e10WW2+uv8+6//E9KmYfeNl3nfzX8smxuancEKhdEcH27DUwXft/PL3Dh5hW4eMZwaPbfSf7xH2UU3aVBSGLwBJRd8Mz3FVVCyqoxZl7g596EigGhVyzzaUGUTLJ0Kn1nQbZlTvk2A/d4oYfUS8fN26wQGxp9XVFaN7UJsUEYC9MITrnIRYDn3IvgbTijSsYKwLc4b46cMeUWXtK7CVzQvGuY+51Gd1+KaMpdx5RWGxRcVDGcL1m7IWbrdMP/igktvyVm8XXHlTfKa9n7FcNqQTFhKSYWST++OvGJ52xmlBsbZqupM7m2yf8hwT4LOoXbep/5UhcqzVXSiUGfqeEOF7nuYVgbaoAKZsMYzBB1NuK6JljXhpZBwTQnff91DpwpvQxaQaMEnXNMk21KSXQnZNiEnp01p4qQK2DiU0z2U0b0uQZlNSLmW564dtc5qULxEKCluXYzW5foryyNnFteZOm3Z9Src9Po1W8mpQH+LYjA1CpC72xUbu6Ra5tk1obAVT6eBcGOq/lwkSd4r19C5YcuXNIv3FGWQ7A8NtcWcxtXM/ixZVtpgxLW31UvnVpOHQkOqrBkrLlTlcw16dhzHkuimTcrkzbnoYIQSImNZXouC7i5Des2AcB1az/mEndH91Kkg2c46OGlJoJ5X5F61zijql1RpypDVrBajVpAZzXBGntn6NQZzV5uXHTzFjz/8rQyenSg1II2zmsYFRfOYT+t5X2yQU8NwQpXJuutBoFPo7FWMHffY2F+IW1Yf+tsL4smCxllPqtKOxjY7JIoyXj13nLlKh/ctvYKVQvMdT30PR371ORpezNE/vZYv3xjyY7/8o8yEG6x+9BAnfucO8pmUrPC4bnKe9WGVQRxw07Yr9E6PsePWK6g7b+Cp1e20sxr/4cob6BchH3vPK4nORfS+p03rSzN0kojrts4zNtchWamSzVd5+sI22pafcuTaixgPxp73ePP3fYFOGrGcNAhUwfXjVxn3+ix85Aj508dYb9e5u36SxaTFa5/pEpyqllodtSkv/trxlXl8VSPpl+/fQW1YsY1LJFj2BjCYk2w8WrWLiJHSYGevwXhaLNrGFPGkobogDSncBmw8EXh5g5GwKauB8zrXsbKBsCq7VZb0hkQ2aYdCu8C2XDgKRWiFpCVtojPiZBe+IHODOmVXVMef9YaUrhdpU40ErEMIbEATdq09VyTcb1UY1q7RpWinpNUELkChbHzkhGe5s8aKeYHjzORzhaB9rkJgUfDBlIgoRcVvPeUtci8WlFIilRsidCGQz0wbstMUnrMiE7cP52XpnGNcwOzuZdBV5fkKemoEQVpTZZLkfPMdBcm3qIXRCHqqDf7QNrhRMk6MgvZBUwbnRWApEKkkEFmrQPc98nqBGeiSFz/92qtU/ZTzK5Mk/QAvzDGFggUZCL8we7Qcs++68irGJnq0u2PkGwGehvsevpnWtg1ec9txPnr6Opiv0Z8zbBybxeyIue+V7+WNn/4x1icVs37GFy7s5/U3HeWD8/fQ+zdd4s83+PM/fAWzb73E0sd30DqtqH3TVa4mY/zQ99/Lf/n1r5fALYKlmz3mvpCzekSe77Zfur88t5UfuofVuxP0us/UwRXue2SScGpAHvmoQrH3J+/nzB/fQrWq2ditePHkKW4KezyT1BiagH/33BsZP64409rCd5/+AWozPSajPj967NvYMbXOzsoqq1mDX3vwNbznno8y7vX5TP9OkjE7VuqWU25dOtyhilF1KLflbJcUJuOSUDqurENJww3b+dR7YbBeWbFzzRuJhquDUdDjRG86lZJ+46Ig0iX/3CberrmQzlxXV8sjthUi7fQkFvnEwMwjSoJ5b1SFc9W1wldlQhxP2QWhUqDaPt5AkzVyGdc9TbYlwb8aSlOZLKTYNaDYqFLUcpJIYbQElE7Y6vQneVV4zhlC6dNW6+IC2GSiQHuGPBcE1Xgw2JlBYFBdDzUdU6yHULHw/dCD1EcB3kATz6WEiwHp1ozKJZ/BrhSVaVSiMLGidllZMaENaq2YNG1J051iLIMNj96hHIYaNdQw1Gzsy6ld9so1TBWCCGdVysZwRQBYTU1eM3i2WY7OLRjj3ERcZcxWX0pLOy3UDXcvgq506DT1ESDhBOets4budgFqSpFxMVo/AYovTjCYEfTX29AU1YL2YQh62tIqrTg0Eppf45IE30FXTA1AqJy9OUV1WSp+S7cVZfDqKqxBR1FZlesJNuT3/S2jAM6LZZ0fTKmyCVF1xTCYVowfN/TXq2V10q2XrtFb2pDrM2OyF2U1CdCjjjSYMt4oGdapJBgvu+s57ho7w/VvusIfP3sHL9p7lsP1BU72Zqk8WSXcGOmJ3DWEHfld1DHM3w2NszKvVWG1Zlqq2mJ1CWFbM5yVTsLVeU3aMmIzuSbDMh2DItMM+iGPru3ie7d/mT+ev4t37b6brZ/d4PbmWbb5a3xo19384rmH+G9rsJLW6Q0iSTp7Pmfak/zkoY+zEgtn/eFje1GVgpVeHe9nUmZee57pZzcYa/X5yM+/mo1rNGnTkJwd59k44BsOHOUvTt5EMl+TRDg0sBJxZjCDvu0QK/2YsZPSi+WDD9wD1ZzBtoCf3vdR3v2rP8gz7815y1NP8z0XHuR7fugOfunbrmf/IwE5iuptq+SfnaS6bEhm+Io7DFD8HeDHX3N3+XtwNC8Z0q2UjXcsPZLaFVWiL35fOKBFBNUFVQonJ54X55bhlCyE0boEzI6zmdUpOeWuQQ4gC4al0DgKite3P1uhG8j7nKjD/c54MJgW/mbUlo1ays2jcml1pUBatVtBUme0MblARKcQWF5qsSnALgJxiBCxKujc8goj2TySMcpuoy6YcQEpBeQ2+HEc37IBkZ0LSUMTdosycC48QVgqKyMbOScU6m0DZQSprS2YMhgR9Evuc9LQeLEh6BuijtgaZhVxrojWLRc5ZNS9dfP5gojXrKDG8fDl9zYIcOI/x2GPnIuJNMQxgUFlqhTummphBYsGCoXKJEAPNqxGQYlt1nDGYHxTIkKRl3FNa5HJaMBPbf8oN4RVnk37bPUM/3zhJTywuIcf3vN5fubT38T2/UtcO73AKS8nCjLmrtvgnonTfPDsnXzkc3dipmPGdq8zODopYyYNedNfvQvGUqJLIb/46g/zk8e+kePxHM9/6gC1qzB82YDGI1XWP7wDX0Pr7Zc5d3GGb9z+JB9bvJ7H/+X7+Lml67j3t19G81JBe69H9e4Vpr7uOKf/6Bbq9ZiNlTpTW5epJwFpzWPx6jjVqx5JXKNyoEM8DClefiv+iQrLtxhmHy041Z/lV7Magcq5vnqR1+w6TvTOjKfWt3Nyfob+epXnP3WEI99yhulKl7trJ3lquAu04Wo6zmpep7u7oHZZ+NoOoYw6I+5p2qAUTmbWWs5Y2oIqJEDX+ciHvxRX2mTQBXHOa9oFepvHt1GUfQx0BtGSJNGVVameRasypgwS4Lgx5eaS0TIPQIJ9fyi6B51J63ecWLsqor7hJNTnGVnSRZTdYHVq0LEmGy/QusBEBW5JoVCkMylkWv5WgYzp1EN5RsTRlvKm8hFi7ILIsq+AGa0nRIIkx5NG0O0JBV0PjnRl2ixXqZ71GexNCU9VSRuGolLgL4QCEiS2AduOISrxSCczmlu6bBRNlGfAicy1IMV5rSBc00LLuWmDwVKNaNEjXPMoQs82aNOkDWnTHmzImp2MG2oDVYrY08aommI0NM8b/CEs3ibrQSnstPQnv2+rCyEjipIZBfGuCujWAkcnEYGrTVrsOrt6A+ihBPXxBKXvviosT9iug7UF2NipmHzOkDQ1nQOyiRgf+hOyiDnNjpcYKmuSzLk1NBhAlgii7fehfkGXwIkXS1Dq7GrTpt23qlBdlvW3ddqOS6tHiK3wM1oXpLqzV3QXYn06ElU7TUhWt8LjWKq4ybh8Xn+rpnbVAjpWeO2SnS9/9noeW76euTdd4LUHn+fO5ln+3X1vI9hQ1NvyutqC0LyMB6bA2pvCwmtSmkdDsTBdlO9yVTNVWNtIW0kZTottojLg9TXJeEG8OyW8GInl6mrI+MFVrh2bZ9LrcmZ1iolPVvm6mWe4JrzKv9x7Ox8696v8t7W7uDoc41R7mrgfoIMCr+2xdmyK++cOsh5XmH9iK54v93fbWJsLqxMs3XsNn7z9PMVgwNIfx2Q9HzX0ICzIMs1/+/KL7D6vyQ4OiCoJ/fUqrxt/mi/cczvXjj/PAzdO4vU0r7v1Gb54cR9Ln9zOL/3S9Vz/wHPc/sNtchQf713D2/7TJ7j678d57OYh7ft30H1mkiiAPFAlpfNrx1fu8VUdpK9fA5Et+2RVaJ0zBD0JAL3YUL9ikbRMl78v0aoxRXXVMHlcxDndbVpKusWmTN8Gd26D1ylg3Ryw1AzfuQtYwQ6FLSknkv07tKq0UcutYn+bwngSjOrU8mwD6E+L7Zg/pGwJ7VCetC6OAZvRbC8ZWcmpDLSlZwxmVEkh0Dl4bUohmWcDGreRaYvQu9Koo8ZsDnxR0gmv8JW1XJSbU102JYrkms0oC7g7fUBWUXJv7Gs8Xzp+ivhOUVlR5NGo6Yz7uwjsdXqQWxS98Ed+6TpRGG1GYr58lChJAmVKtCltGArfYMIClWr8jkblI0ReFZBb9BzAVAp0okhbBtBEa5A1pIIRrltU3pNN+tzjO3jNG46Ro/jup/8hj9/2p8zogind4OTGDMPM5z8efy1UJNy62B1n5dg0QVdxcfs0j/i7MYnH7OFlDk0u8aWnDzF9yzI/fuDTfHtzlQN/9kN4VyNmX3SVXhGxMYj43Y++Br+Q75/6ZIX+VujcmFKb6LPxp9s5dHSDX19+Pc3zisPb30nrDKy/NGb8jzWTP3ye5BVX2f1wndP3R8Rnq1SHsHF1mjyU6w9ycbApPEgSnzceepZPvOp2ofgc6XN1xmf89XV+8+mHiE3K2Szh4NQSX//Zf8zvvPT3GN8z4A9X7ia6JaPhxaxlNZ6Od7I7XObI3iusJA3Ggz5mLCXpRdJYaHxEDcuqlBakTkvifPWNHftFMKIZwahpTmlTmoOKpQlnHgKxzCnXwMs5VxShIOWVVWOrXyISFzRaPNGjNWmQJAG+Gj3/MSv0tAJn1zNg83yXqox8VtCDqC33OK1LQj2cUDR7UvnCQF4voFDoxUh+BlQrxfR9lG8wKegwJ50U5xViTTaZoVJNuOyVgIXfH81jnUFuVNkEzM39aE2Q+6An6Hr1uYrwt3t11J6+rHcams8EttGKohhosUgNbIBbLTA9X85FQa8XEUwOSQcB1DPhzAN6LaCo5aSpIp4p8BKfcHpAXA2g75dzk2pOeDGkflGNuptu4ucbZRHVjjzrxiW5h9UVQ3VelWt1bk0FfOuY4/Ud15vSttLZdKa+pVLZtcM5DkWr9l4F0J+UZ12dF0/2/lYYOyV/F5GlZWSC8utE5ubYyxfY+OQWKquG6oJmYxc0LkvzszxQ9GcVtSUBMdKKorNPBKJebEEK7dZtQ/O8wgzkmgvPUoAS0aIYX56f8aG7w+ANFau3icNR/ZLtH2Gb5xSBBOPJTEbjok9ak/Gf1mzFNpXvdodK5X7oFIYzMnbzqiK1ovqwI+tyMiZjP+jB2Yd3sXpDjb994GYaF8Qtxh+CyoX6WASGPFAEsbjUROviCOT2Ip1B45JUM6I12Nhjk5CGKUGvYEOTjOcQCdUqOheBEoFwMZ4y1+iwPVpjvajR3ajwE9d8mqf7O0hqkiD99tLLub15jr85ex3ZM2NU+7D9P9xP8vo7iCc8nvmnOXc8cYEzU1uoXA5I9g1ZG9RQyrA23yR+1y3EUwZ9QaEaOdQzdDsgKyqSdAaGeHcCicZECuUXFGhm33s/O78XLuxb4sriOCc70+z4xmeIv/5Odj9cR5OgVcGwCPEoWMxazIXrwAQPPHmIak/GZH8rBG2+Ag/1NXeXTcdXdZCuB4p0zOAPRGQibZElIEzrCi82xOMafwiDaVkMJTgVxXx/RpE0vXIjjccFxfOSEdLs20WxLB1bKoq2QlXHGw/ikYAx2KS4VgawZVZHienPWrFNNqLSVNYl8taZ8HDjCXmPTkb8eSdayys2ELAbjTtHhyz1t9oufWbEQ3f88OZ5Q9qUCkLpyrIJbXOiTifOc0GvKtxnyOKqckNWFV/fukXKh9Ojjc8FTlFHePjl/bCfE63K5/qxCJgKz4q7HD0oHdlyYaxlmg2onZuOIGSqTDhcExTXqAqlKDJIxgtBzVOF7nryd6pK0WERyKaBUSPXjFwJhz2XZxatQeMKLN8AaUPaqMe7Y/yrEUVo+N2/eS1//Y7/yK9vexiAaa/Gvo/8IN6GpnZFseMbzrHRqXLpwhRzO9bYceNVDo0tcai2wO+fvItamLDerfHK/ceY39/kDVuf5b6VG7lvBSq7NiieGCMvNO/6s++RpHRnQu1KSFYVXUPvUErj+YDezibxq/v81c+9j3c8/51cqs+y5X5JgHZ+2KO73SP/lV1UvUUeurIbPdCkzYLo+g7eF8flntngyz/cYfvbngXgwe++G/ZBf3sOvYA9O5e49F2HOfQHh5m+aZH7b/owAGde97v24YTcNvcYAPs/9T382ct+ix94+jt5/LY/5ff8lHsfvRmM4tk3v5eqing27XMmnebHPvPtFJHP+ImC/hZN5vz5baBZAIXlWxf+yAnJJWilpsPyh/Hs3LBzpuQVI44d4aoErkHPOjDZBF/ciVwibsrx5fjmzkZVWccJbUXnpaUrDjzYRKWxVaDMJrpZVZw/KqtS1XOdSlUGeqil6hMU6L5PUci56ZWAolZAJUeFBUYbdJSjVkPMWEq6J4XzFUnELWfbIcouoXFJrJdQWiEWvtxfh8zlFYO+UCNIbBtyT9YE8d72yvkHQsEpxjKMtaw1mUYp8CJZNPNOCIWicJWqagG1HGMg8HPy0KPQKf7VSNazRQ9zpEs39lErIbWLcgNVblFetSnY9uR5pXOKZFyCvKwmoIZr1rO5b0ThybpW2qymcr+DDQtO2OQlXJMxFk/I+1Uq63pJB7HgkPMs99ehv03e5wAenUD7c1vo3xATPhDRPC8e6oNpxQCxDa1dtZ+fSwdd0USIm1gyDs1z0uimcclSYXxFMiYUqjxWdPbLvpG2hNNfhNJ9uwihdsEnnjS0rytonvBIW0Lj7B5KaRwPmH5YbB9dVSHojVzNyr3Prtlxy+0Lco6Fls6h2laqKmuG6qo42OgUWmdAPz/FNBD0i7J7sHPQkqqXjHt/AN2dCjXwqFlHm7SuaO9Xo54gdn5Hq4qkKefqDZBgOBpRnrR9Lgd3zwPwoQu3MtfoMH5/he33rLJnfIl/euybaf+rGU4+lnHyT64l/ZGcPT97P7UvbOHothcRdDQqh8X/dDcb80t4HbvhrIUsqwb50MevZwy2aZmngYF6Dl2fIioIlz2S2Qzd8yDW4BuSxGfn3CrvevibOXjjkHvPeHzX4Yf4SHET/msucPL3bqfa7DM2aDIZ9fnrqzdy/fhVVnQTX+UELjPJ7f33IB0H7YCJrx1fscdXdZBe7OtTO1bB+FKuC7qUAkWdGpKGLR+nEHZlkfOSgs4uUe2rAvpzkEzmzD6o6W1VtA8YGucVO+5bont4krWDnnBfx0ZiShfAU4zK3Vl1hJq58pxnN8ioPULTCu1QNUq+tPEgrakyGVCGUaOOoZTdh5OyaIYbEkw4aywRXY42HecDTkG56ecO0bcJyubyZYm2W3QN5HfOAcYF+w5hBErOpNG2KU5dlRucE3O6Jkl5oMrGNCqX81eFofBlIxk0hRKj/FHp2vFWYRTUewkYdz0hL+jq6JAzhxKCTUw8Y11uNCY15M0cExWYTGHaPiYwmMBApkq0UWWy6CrP7ur22Xb2i+uHFwuqpjIkqPCF+pJOp7ztA++WRkwb8Ff/6JcxQUE+VaAvBfzFwb/musf/MY29HZaenmHXrZe53B/j4au7qIQpyytNpqc2ODuc4Wq7xW9cfgXF0EcPhM+q9sdcuTBFVMDYHUt83Y5n+MiWG2j810mWv6VP9akGSQuqVzXJoMbrnv3n0ijlGzr4gwagaTx6kfY372XiAw/x8qcHjHlfZHVfgw88cQ8bqzU4kFM/45HV4fBLz3CkNc/R6w9z7J82Ofg9DzB52/U0fm2Bp750kPlWi+f+2fsAuJBtcC6DPb5EeD+1eCNPrO2g5qeMh32u2TXPRhExeHySfUvfB9aznkbOHe/9cYIuPPFT7+O6oM8/MYIazr9M8Nf61i5p6pGsVaBQUM04sucq5z++R4KKTbxkF5BK1+DRHCh8eV65pQqkEfT3pERXg9KpKa2Ly0XrLGzsURI8WWciNy+Dnvu3KpNfxwM23ihwS+uOVmCHkKWQOVqALmA4rmjfHqM8g3+hUvKo84qhaOT4qz7pTCrWjq0M7Rm8VZ+iYoTj3QkwUYHSBu9ShbAN+XpEPCl0NDeX83BE7XG6CxO+cP0pedmeSzoMlSVd8taxlITBrCEfy6W5kRIHoWT3ED/KoRva84FKPSGJffJeIBzfVFFZ9EoRZNYqKOoG73yV7qxUB/RaQDaWQ1iQNzU68YQfXykAXVoHllU6NUJc+7NC33BdnIOuiHadS5db4zKL/Po9CdTTujiKuLnv3F6iZRHiFqG81ijImpIYlA2sNGU/DlftmXq6YDCt6Vkk2+/JOuovhPTmpKN1uC7f64JP4cnLml6EUL9iGMwoejsLqgvSaMitp3lF9rOwLYYFQnUxpC0RJVcva8bOKdp77VgroHZZkVfEez5oyz2pXApknDbUSINhr8slP0F/VL3yXTUCSv/uyrJUHt3Yzq2pQmVF5mTagonjpgR2HLCa1hRJS9tEx1BgyOuKZMxQu6IpPElE4glK//ywTWlaoGMI7bhWdlwnY9Lkx7mVeQM4eW4rB/fMUw9jOknExst7/Mqt95C328Q/NoN+eYddrS6dfx6gH5lh/ifuofIBQ3Wb6CbCdRg/Cb3Ls6jbB2RFBaMN0cmq1bcE5BMFYUccbHp5gCrk+Q62FXjNlMopn971OdovmBnvkuYeShfUf3OZ+JED3Psnr2Ywp5l/7zSqDTPbu/i6ICk89jZX2VlZ5WC0wFavzZPDXeV+6JqjebGM86+0wxj+Ttxdiq9x0r/yjz3vN6y+SLJ4oyBpitd5EUiJ2nWfzCJFtF7YLmheGegGfVlMDv7IQ6x+/z1kNWk3rQroXDvJYNorbd/CNUp0ZHM3S8dBlS6Zxm5yVjy5yeJMp+AVoDXkDq3VlNaDLqBOmqNOmN5Afq8zg84kMOhtFeRPfGjBeZe7DcpL5doxUr6UYNVu0L69BhvEBB1KO0XnKuDEdC4Q7s8ZaleVDdRHSLNDMp1orrpSMJzUODcZoRm5pGmELmVVBUizp6Arf/yhNAlxPs6uYUk8aR1Uok0BuIbamiQtuqDkMVeWLZJZJhTifW20fEbWytEDLQI4A3kzR8Uab0NLp1Zkw3NNIFWqMIGhdVLTn5Pnv+2LGxShR3dnhc5u4a6rQlrHJ+OK4UzOY9/wq1zKFPv9Brvu1cRjmrQOR/7qR4k6ipn317jyEsX37vwyf3z1Lnq9CgfmFskLzXS9x3TQ5ba5S/z+7i/wfRdfzGPzO8kemqDxkjUmqn2WtjVYPTrDBxZejLcSYF4M+kydva8+z8Kf7xZL0LZUY9pv7tK8tyW82GMpvVt3MvWsZDF/fu4W5podDjSWUdoQ1RNu2HqVo4uHoIArH9xH8kdtjr+/wcHvfpQL//oe4j0x0acO4hvYOtYp56GnIDWKbjHkZxZezEfuvx1vKsYNlrnpdT64dA93vu5Zzm5MYoziizf8JW84/kY+9rr7XjCn53avcMv0Ja6vX+aB9f18+fQ+jFF4rQSlDNVKyrfNPcQvZnuAUZBgPCCVOZFVRYcRWG521DVUjDRpcRSq+pd94jEp8zutRtiB3pzMp+5OaJ4X2osqKOezKiSAy2oGL5F5EU8YavMW4Vyj9NKWeW9AKXLfJqh2fFbWoJ1r/MuBJBk1rN2kwviabDbFX/PJJzKUX2ByTbY1ga6PFyuyqpSqvNXA+rwL3SFc16NuvHq0PrggLK8aSXYsD1/ZJFfllA3ewo4aBfr5prk8VBjfkyZE2HXAMxS5xl/2ybak0PMYplVUovFyuT/RigQ+2VyMtxySN3K0to4wjQTfL0j8nOB8lawhzkssVshDce3YfOSBXSttAKl7dk1LQQ1H1wIScGZWi1NdGq0rOhcEMmy79VuAhjwQYCWrKVwrzKgt1+oNbdzrjaqpJcprA93udk3YhvHj0n8ht+LbYE+XuB8QrVcI2/a7LD0m6Fm7xCGEbUNWk3FEM8MshiX45Og9RguFM+wI/apxTtPdl1O96olewlaOimDk4oJbryNKi8Uiknvg1lRX/Qz6gm6Tgm+roa56UF2G4YScT1aze1Ri978A/HXXe0TOd/lGLcLsRfmc3g7ZV6aeMaWeypkmRKvKdm0eVRTCdcq+BkUgc8s1oiqstiBr2PXaVodcstx4NuR0ZwdBW+Pd0Ka4XOPMu68jaxiKVoq61GD1QouoDXVLHdGpdIkdTLuKtlSR3nrkKZ7auo1TT+8AROgcriuCji6pV9G6KpP1xq4OGwsNmpcNg+0BeuuAJPcYJj6+X/DYqV34c32uvDFg69w6E37KlbUxLlye4pYbLrE1atPUQ5rekHHdJ1A5Hzoyy+X33CNxSDHat12vhK+kw/B3E0B/TTj69+A498MKvWJ9jzPD2NmU/hZfLLx2CkIbtUWcGVoKStDNMU1PUFab+Z7/t/ew+2fuZ+bGI5x5+wQoaO/1xFowtvzEhNJvN21aPqQ94jFZqDp7RIgT2rIkUPLZXRt5ZwuYR8hk05sCS8cj9Sm9j/UAy4mldHRxdBpXgs+t3aArx+vEkFfUC/ioOgEsul1YFMq11nYoNDaghRFyErbFFUCQcFelcBWDUbvxpHAkXMoOqQqXsEhJ049NKeyL1i1FZlKNNkV7v8J1CbaCvkUCfcpmNsaXAN1xYp1d4oj3O0L0VaHKXcDreRS+EWcXEJ9m32BCu0Fl1q1HjzZglSm6O0TsVgSK5ZuahD3D6jXybJ2oDaCyqBluy7ntIz/Ombf+NgDVy32SRoPeNrjphnM8/4X9XL07IJnI+a3zL2O1W2NmYoMr9+5mcGcP3TRM+x2+eeZhPtxr8tnHrsP4BrUzZ3h8msHeNhuXm1AvqB0PqS7D9d//DI9++HqW/ng36SRlkpRXofHxplSA2obhlE9nj2Lm8ZSr776Hua+/n+d/4y5237lKoznkZ6/7G87GsxSvVnResgTAx648xVtOjnHqw9ez6xvvZ/r+CZ4+eoRkDBY/s52fmLyN9bTGj2z5DF/sH+JdE2f5lbnH+OvxGzkwt8iJS1vYt22JV82e4D1TJ3j7mdfQvm+OdAyu6Xwn6ZUag0MxuTE0tDjh7GmtsjBsATAeDPiBm7/Ek+1dXOqOcWVxnO5Clf9gXl92bVVGqGyAdROS63V2n84ytSzh9+V38bj4PmcVy4dVsjGjRuhzVhkl1y4hz0NF/TKI8tgGBUPFxj6nYRD00tHL8sh6mVvXJ5XL+fS3yjmnkznFhhYej5HAMWtAdDEgbRrQBr0cCpre9wg6mqxuULGmubNDcnlc1gIF2Zgkotm+ISxWCNdV2Yk5t3aD0aoqRbpuvnqxCDP9vgSAIsgWIanTa4Br0KZIxg1mOkYtRegL1dGcPhfiaHdZK8ff0KTjOcmYFjE2imhZ4e2KidcrmK0JLFXJgkIS5iEEXQ1KW92MZ58hZbCZ1WX99GJZm+Mpa89p565by9zaEHRGDl2lmDYbrcFOY6BTCdD9gXiXV5bkWVdWDBs7R30cHLXKgTdGQWFF5cYG8GkDGudkLBQe6EebFPtTNvYV1C7psgrgD8W0IKvKvQ3bAqwYDZXT4Qurqko46EFPdEXRmnRmHs4WBNND8rU6Qd9a/AZ2De3J3uRZFy8y2VecZW7QNaUdrnMrctUVVxV2AEtele93oIfbd1oXcrrbhDbjD2Vs1a5CGMJgi2gEetshHS9soqsYTlj3sZzSIAEgmQD/pGEwZavisQBO1WVDPCYiyWRsVBGJJ+w4SBRZVRqQOQMH48HUk4rBFJiHxqinMv47B6B6Jnih4NuMOg3ngSr35d4renjH6/zFZ+/CGyjqa3aPihX93TmtY561YrYJLzA4mBAmPrXzPku3iqaHyzXWt2iKxCNsJHzzTY+xELdYT6pkhaZAsW2iTTSTcWUwzomNWd618xN4duL9iz13cfJ9dxFM9mh9sk5vzlbwFCXA9LXjK/f4qg7S6w/VqFjRaH+ror81KOkmwYZd2MYFMXcos0Os/YHQLtKGpnlOPi8/+jy7j8rPl99zD7kN1uKtGeGiz87/+ChFkvyvT0ppLv30i0p/V6BsFISSRb6yKkG0TgCL7OkETMVtIAbnglJYukjhq3Kzcm4AeahGLbRtYOENAd+1UQcsBaBE211Aa8WhDm1zrc7xRp/lbBoFWbe7pD1cadyL5XzzUJWd7EqkPZKfB1ssUper0bVaFCW3tBq3cdXm5R5Ul3KKQNwwxs7EJOMBK0c8CiUbRjxO6TDjaDLOH93xbjFCdfGGUsIPe7rsMKkyhfEMeUtgNxMq6YI40DCeC0qtwYRSui5CWD9iKCZSiDXRgi/3sCr/r3MIVqWkv+/DP4ROFa27ZANMtiec+pv9bH0+Y+WIj57r0e5XiYchC72IrZcLqvfVeP7mPfyb4V7yyFBMpew4sMiVp7eCgmj3Bo1KTDzro59u4CWwekPBFx66lv0PDrjyErFSyyrWP7+AsbMxa4ciKR9b94bBrDQ+Ofn+Ozn4ww9xGtjKc/w2+wBY+pGDxD99kB0/fz8/tXgj79n1UZp7En7pgddzbHWaH/n+v+a9f/hmshr81eO3UJ/q8y/734CvC/7i517Hxg5NMAWXntlNI4bFx3fyOzfP8p7XnuDo5W1EHtTvXCZJfY69/beQblWj6fPBPZ/h28++hkDlXOhPcrh2lQP1RV4+eZxwd8bDnX186ks3UR9IR8fKioyxeBK0paSVCXImdnaOAiMOKhIYaBsg5BXQXZkbXiKBim8TYxfAZdXRnPRSyg7COjfoISijaJ7RbFyTYRT05zwpgy/KuQR9V+6yAWEm1nz9bR5MJuTaJ1j2SSYMflfO3SXY/qI4uHg9D7VlSDIuE8ykis5yHa8p71FAsCZBbdILUOMp2TAs9TXKBny93TmVq97ICcfSBYKOzN/Cc5Qxex6hrAs6tSh1BuG6Is0i/IHc22RHggoKohMVCRA7oBPh5frrvtDHcoVa9yV4LhReLSUf+lDN0VFOoX3Q2jbJsfzlocIfSGfg7k4518qSnFralHMzeuTE5VxPVGbXHn+T73ghPHuVqRI0CTas9kfZIE1Z4MEK91UhCaBr2BZ2HO1EUN1kDEwuQfRgq6wDRolOJp6S+16/JPQQ3feYObjCenuGsC3n1LlngL5QRR/oUqkN6H1xppwL9Ssyfgcz1i7TUvtULueQtCAeF+pTnmmoGtb3a8ZPF+U+4Sq4CkqNBVbU6tlCl+v5UFooMXJ5cc5ieQVqV+R1/lACf/ec23tEqJxXJcCtzQti3jxnJHiu2x4eiS51D2HXlJWmPLLNqAo516Sl6e6R9/p9RdVqzfrbDeHayMUrbZmShhUty2uLwIJqY/LZ7f3izKVjyrigcV6VotyycpxS9uJQhVTIzOtXCR6alApBX5UaLdcTAyNdT6sL1kjBipQZatT5hlRANmT9zysGOiH1uS69dpWT3VmeOL2TSiNhsFbBq2bk/QCvllJvxEzU+7T0kG3+kN9duxN907Xc98Zf4duOfi/DyTpFBPXThqwDa9v+1+HI/4nDIP0x/ncfX6O7/D040jr4iQSktXkJ3JRzcrBBouOi5pFMpvX9nnRq625CR8L//rO3/3vxj55/1z0c/GERA/7/pCY2BTv+3f0Ur7iV9t6oRJ7DDQnMVSG0HNd8J2pvcpSwi0k8oQg7tuyoKDtwBgNDUneBpvAT07pFEfPRpqUKiCtSyvf79ns38eVzR3txHF6LCBoruHPttZOmlCqDgSl9nTdb1mWRwh/YxCcTNNLZmrkj6hj6c2oTOk2JjjmBaEkdcgJbBd0dHkHXMJxUTD/SI1jTdHZNkPiCEOUVGzzoUaXAs2VX9zy9odASdCre9ljOsB6okp+sYm3HgEFveIKI9b3SI934gtQUoVQBvJWgHAjpXIK/EIrIbmPU/ESNJ5x69X9l31/8IGfe9tvc8GvvFH/gUBOtw7+/+U/546W7eXx+B4Nj4/SsjWhRzTG+onpFU6yHLJ2fQ1cMv/323+Inj30jy+0Gk/fWmH95ykCBv+aTTWRcfE2VLfdcYf7Bbfg9qUDMHE2Izq/RrE1jFGzs9GVeIAFiZdXnwr++h9o8JK9r8+LtZxkP+jxxy/1wz80s3XsNn7uasZw0WBo2OLs2yZa3PM/v3Xd3iRxFCwFjO4ecfG47Xl/TnBX00FWgisD+vBryphNv4JmXfIDXT72VJPd52dxpfqc9x3949PX4Yc7xl/4BAA8M4Z6JU7yidpyViRofWbuVPZUVfu3ZV7JveoXnn95F85Iqn7/xpKzvLVDaqzphsUpl/MdjSmhMqZTzndOTK807IVvhKcKetfW0YufhuHRuTBsyJ8Fy4F3vAZuU+gOI5v2yU6Nnv1vnkNSFNuMP5P2uq+SWhxTzL/NLlFhvGq+SeBu8vmTRRoFZqqAtHxw71vy+KqlpjuYRzfsoI77neU2QPy9XDOZyEbrZxLgIAE/6DugcsgCKaiEVp0ZO3JS1pXEikCZoQDJtYHZIEGUYo0gHPno1tP0EZM3tH4pFPOoZstnELouK6GrAcC6HfkBQTylsvwO1GBHa94dtRb9eYEJDUTNkhSIZ1+hUkU8n+P1I5rq1VEQZi5xKVctpgygsNWLcrjkBeANVItPOFtJRC9OGPBfXGCv1YLBV7CKdA0zp7e2qdfb5i1hd0HcvkUqfo+j1tst9q85rVvszZLtisrUAv6spYg+zfQinGrTzBvmNA4qliMY5Qds7+8T+MxmXioADM5qXCuKWlipCV+EdrdK4JL0f1g7r0v3KWROnddCb/Mj9oa28VIR26JyO3F7gmvw5YCltyHxWRu5nEcr5OKpKHtr7WJU5GbYtf76QtQbAi1VpCjCcUGX1xa1JlVUINgxrh5XthGuoXxKaVDKmaJ6xVsqWpx60FXnVkFcMWWOUiEdDK35WQjMru8smlAYIAPUFQx5AVldMPp2ysSPAjw3VxZSlm0N0oQWgm8uon/apLRrWjkD9ksy3sWMe3Z1StWhcgJVbcqLco3LFL5Og7t4CNRXz0n1nOLY6y9KlCfbsW+DJczuonIkoggh//wDvdJViWrjrL95+hvFgwGd6R/jc0iFOHN3J7/3lb3EsmeWG6at84VCTYMWnb93b1Ka99mvHV+bxVR2kgywaFWuT5Q9g/docHcui3rhsbEME67/tWeHMinB2K2sGk6r/Ja9r6/91//9f56U/9zgTn4PhW+5i9ZDHzNEMb5DR2VuxbZ+lrOocKtxGPJgRhF2EOAh6Z3ndWUUQdJQo3HWqSncX10CJwgp9Bg5dlotz4lbteLt2o9aFvMdRbpwINauLg0l/ixURucDHjNxvgoF0h3MLfHVRFvusImVl48HGLlWWn0s6jQuKNgXnygp+jA+VZcPqESVNpYZw+bVTpff7ZiGYa9LkaDBlU6ZCNmRR+6uyeYkTEjqnB+GUSsKkC2VL5aPzLSJBGN37jYLGBeGTyqIfysbeGbX09nIIzle464lv4szbfpt9f/WD+BNyX+Mx8Qb+oS9+F+NTPbQuKHYM+Jlv/DD/9rk3oc+ME64rBnNCnTAeeNv7vPfya1g8N8ndN5/ggRcdEhpPJWfy2mU6gwpp16P919vI7+mTG0XzoxUqT55j5Q0HyRzdQknSNv5cl5WbmqR1QflWX5RCu8In2keoNmOiezPSLKV/Zpx//aYP8rG1G/i2rQ/xL579FrYA2UdmmF0t6G3VIqj9zBZa1tmkslaQjGuqC2KZplMpxwZtxXOntvPq5JtY69XortToJSF/deYOqUIMFbxUnsmdUcHQXKaich4f7OHSYILlpEF2psGlLzeZbhswI263s0PMg03JpifjLB6XpLHwoXa5IK2KB39SV4TdQoIGJXNK5+JaVFiLR+ez3t9uLT57soZUlw1KU1aydCY+/0KnEcFbb0+OShThuiboWHqaDfBUYchrmqhTSBO2y35J9RruSfDnQ4pQUHfTyFFdCRKZSGBdIpoiKNCJxovl+rxN/udGjeaXaWbotQAvFk9pry+2o1nNJpwDqwPREE9Jf4agrcmqhuiSN/LeriF0gkKR13N0oYiXalDN8JZDgo5iOJuTz6UiuG6Hwm1f9siahryeo4KCZHuC2vCpnQ/pHVKQKzmnYrT2xHti/CsR6XRKuBCUmgN/ACxHxONiuWiU8NGLQI2ocDYoDSxyno7JHDaJdcSoj9Y3nQm1xHVdDbqUVr7ueXhDVYIfmUVK85p7jnYN8UYobG8H1C/Lv+NpQYNdIomyNrrdSGgbEzkMPMIl8ZtvXDIsbPXxzMhRproIg1lLLXHe6TYA91JD/bKifV1GZWpAP2lKlXZpxBc3SuZBZYUyWC0bcuXWh9zy1t0e6GgsQdcmPEYqDu4ZmYYkSGXioFyVVPaU3nbD2EnZn1Qh3VurS66BF2S2gppZnrk0IpR729umSj97L1Z0d8l5RKv2nHrgL0plVvYyJUBM1VBUDNWrurRxDTYUzUsFwwlNPDmip5YU0UDAr/GTOYMZHy8xBF1p2BduwHqnQr0rQIi2NqlhWz7DH1LaBMt5Q3VexLmu22/iGaIVzR13nOHLDx0pE+7Lj2yn2pEKT9YomJ3YYLEZMbVrjXqYcGfzLJ9cvZb1ZDu+KjjwTx5k51s3mM/GKFAo25/DVY7HT5n/SQTyf/b4uxCOmq9EQv7/4PiqDtIdOps0JACJOobKokdWN8KhG1fUF2UQ1xcz1g7IhItbm4I1i7j/34/5d91Dddkw9gcP/D86x8pHHqLxHXezdijA6ICJUxk6KYjHfKL1gsJX5JWRX3d1SQIAaVokdJe0KqV113FUFZYuY23BPCsKNVD6kecVWYiCvr1Xdi7Hlrfs6C6OMuLstlynOlf+Np4g5rGlDYlVlyCErlzuLOuyiioD4GiVsgOkqm0KHiwC5TYN57xR+KIbKHwpMdcvj9pk55ZXK8iYwYtVGdy7jcghMjobcfel8YcEF16sRCBlRq/z1tWoulDNxeu47ZFMi4OF8G8Ly3UU8e5wShbpJBo5YriEo6gU6FQWp6Wzk1zzxDsJNGWbepeQ+ZWM/lOTUtE5uEG/iDg8tcTjvQrDls91+y/x7NntEGvCZ+o8sbSXb33Jg/y3J28HozjyU6co9szR/YUc3yvw5jVJC2oP19g4lNM6O+Dytx/i1d/1EJ/5wF20j+TgG8LJIW9552Mc725hmAc8dWE7P3vbfXiqQFNwNp6lX4QURvFwYzdLWZPXjT/DR1ZuJVzyuPihGwjuB5Vp0iZMHC9Y36/Z2FcQzPXJL9UJulaotzDiARce1M4FLCzOUbt+Fa+a8WMHP8vqvjoz/gbXRldYK4Tc/+8WX8KE3+dv0jpfvLqfjaemqC7CmN28CxtI5yGldRyMvNWdwNMlpJU1obXlgQvQsbQgGdNhW/49nJDPrS7bsZEUGE9Qa98isFnNzqFxSezQkBdCZ9nYJZ76RaXA62ryZk68OyUubAQUC+/c73rWi1/TPKsIO9A5nEM1x+Q2oQ4MRQ6q55FXxAM6JRSXn7DAC3PyoUcyCf7VkHBDuMkqkaAlrxiy8Uxo854h2ZZhCsrmangFwZWIeGuKV83gUpVgQ2hhWQ0qKwJchOuUFDmd2SpZ6lOEHlm9kAAtVQxnCryBJq9r/Ishau+AfOiRtSQIN1MZpu8TrPij77gQEE9KpJvXCoxtAkMnIK8VUiVqyP/XLumy67A/5AUVPecmkkxQVhfyilRRRPAv69hwSgK5cFX/f9j777DLsrLMH/+stdPJb66qt3Lo6q7qHOnu6u5pegiCo6BgQsfIgIqZEeOMOKMzfkdn0BlnxDyKIiAIwoiEBhEaOtE5d1VXzm9+Tz47rPX741lrn+qvCfiKgz/Y1/VeVXXqvPvss/cKz3M/93PfVFakJ0Fn7hnG4/VI52ALt950Rcfe0wmHLmDGjCl2KMgqDgRpFXQqiqAnz1qnDlV21BsfqFYXQJ8JGE3J9QryC8m5iHRLSrKzT373pJNClQGuClVSC4dTmt4WoVHMfDakv7HJcNad1zUAR+nYzG8466g9k/JvlKswuAZEr/RTKmk5bwwBhmC4y0hAPHBV21yqRRdWQ70vgU5VmaBH6+7zp1S51suYcWMKkQQeTbp11avhrLiG1IG4BqeT8nymnjG0d0olOa9JNSxeVQSpKgPX6pIkC1kTVi6VJNnTanzFNW1A1FfEXUva0iU9rvrckLweiXGVFZpT2IPOJQVBTwtgE0lyU1RELx81lnYdXFTIHEkVpmJQO0fc9cg+knXtVI0Kop19wihnY73H1dOn+diJS7jhhkPUwhE7qivU9Yh6mHKyO4m1ihrQMSGRytldW+LM1hZ6m+Xw8Y0EKxG9SeBP/9bQ4yvHl8jxZR2kmwSSDnQuKoielCaO6gKsXmYJhlBdlvelTRgORNXD89h0JlJrUdshATdeib3vMYL9F7N4YNYh0pbOa26i+Y57/z9dZ+uP76Hy8hsYTQYMZgTqq64UpE1N1DPYQIvJRCBKA9XFnMFc6JqULOFINpK8IgifMk5FIrXOfEnMVnzyakJBJLTbeKKuLPTJmi0X1jwRV1NfLsvromxhKoIe++Anr4sToj93URG6jt8047Z1ZVCRuFQG0lBJH5xTmPCNn74k6SUMS83m2MlMzjgb9knhPfqNWCGccmWEoxr2BKmPOpQOgV6Cz3MMjaM8KRf4+IZYE0MRS8BtEwmsTWTRA40NLNl0DkZBZARNrRaYQjR8Ta1g1LDkPdFatz05dzrp3Ec7cpOq54WTC5Sa2iaUjWewueDm7Sf47PF9svHe3+ToxXM8896LKfYUoGBbfZUnh9uJVgNGe4eQay6rniKsXM2/v/kD/OeVbwTAfrYFBtJtBZXzARe96jkeObaVky+pEa3Dp37jRr7mB+/iHZ+4FdWHnW94kk/ecYC8HnD+Xw947ZV3E6mcz7T3sjxq0M4Snju7gaSS8i0XPURNp5zLJ/nejZ/gzM+1ue4RyztWX0D9aERlGU6/yBK2RfaxdU+Nlf2qTH49IgeQ7hihtEUtJXQ6VZSCmbBLMxjw6nqHx9OC84XldN7ifXdfj0419RPCs67osX4zRqzSA1cNCvt2fI8DCSyLiiRQJhIu7GhSxozXME9WZSzmNVU6NFrX2CxNyoogNaCUQ3dtiYLZuhUq2rodJ/kKupuVVJ7aCrUaMJwvCLoBtplh0oCwlpIHEYw0dvugnFtrzYgNdwdsvFuzvku4vSaGsK8ZbpDyVpBqRhtzqtMDgsDQXaxTdEIILNUzQSn3aEJLkCnHOVYEvaDsqVDdADWVYgsNgwDVLMgmCnQ/EIOj7QPS1Rg91NjIEq9rBvOGqKMJuy6QyxxVog/9aUO8EqDPB2QTltppTe+ijMqJWBKV5QTqOUXNEK1r9ELizKdk3oGbt82cYDEiWQ4YXpJBpSA4k0jiXDdEa4HQI+ZEYco38uLQUOXW8sEmW1LSsKrUdA8cf7i3VZpiUZQKVx5Rv9BfIexR9tp4DrhO5TlHXeeYWpGKpylVuyQgC9ua2klRA0tbrk+lVPgBXIO50VJ1Asqm83hVPmvyoGVhMqCjqtRxIgKRoPFRXxqii0TR3Qaj+YyJJyKhPDZl/KYTAsJEbQh642Bbuyqkb7a3xRjg8uou3sQvGIxVYQKnyBX0NWjpFdCpYjQr3P64LXNSud4mG7rEzims6FQQd+/+nLUovS/CngfYZO+KInHiTScksfS0FlVYMAobWtZ361Ig4MIGfy/PmdUto1mpEHkBAp0LtcVXoj2t04RiaGi1UFGjrqG9p0Z/g6tgd8KyYhsvCfCHcvKZGvK5jKITldUrT7EJ10NsaKkdC9HPhRTzVvTrI6mOZUcbDJsFvVaFoyc2UDke80BjgsYlq6RzIfsrZ7jn9E7yQnPT1uOcAXo2Yq2o84L6Yc6OJlge1bnh4mN89vE9XLn7CMf/gfjjn/qwKMxXOOnl8WUdpDdPWIoZCLqa4TTUzqvSYVOnwmeLepa8Dt0tauw8l445eCZxpdL7pGN08ZZZBnOyKI9ammT9c2Ki/4NH/KHPUpvfxJlX76Z5Wpw7g6Elr2jCoQs2aoKax4kiWS+I1jOKSkA6EZJVNbVFCezF7AFQ0lSqUzvukrdjhNE3y/rDu4T6jck30gUj2eCDoaKIZcEPUuHE21BK+rUF3AIpai+FW0SzhueSWsd/lBK6qUtZNBxAtoGxFbcLvLXnJFYFdR/MQd40jDpiET+cl4aBoBuQNyyTz2jae2TzKxzvdDgjRlZFxQrK4+escqXUqhVe8lCSjqwlm4vOnQGStkTrWrTZJ6ThSvVF+QcUwUCTa4tSUN3cZXCuTrIaMtqQS+Pb6YqTjRQZNV3A5k+lnD0QS3ITChrnXWmtBuoFU3FfNvEUmncs8Af33Mrt3/QE953awdfseZKT/Sn2XnKafhZz+uwU0bmY//Dw1/Day+/mzfe8kld+zf28/97riFcCdr9jidNfNUs0gOsnjxPuMjyabCa6s8Hai/rcf3VA8K4+F71xkYN/dCVFCja1qE7M733sXzJz8RKZCVhbbjDxYAwH+mybWuPUcIonO5v51e0f4Du33cLiDxzgfX8Ou245zblTW+jNQ/14QDoBT/zQW0W55UN7SVaF9107n6MKy5nXpTTua4iSwgQ0J/qsd6rc393N+bTF0dF5Xtl8FK3gxqRH/WRQSuMBJW/Vm6ZUl0UizYSuJ6EYK6iELpjxlTWdu4brYhxkeRQs7DullwsQcpXD2j5xb9RDRTaTM/nEeIktyiZShRrK8/VoZFE3FHMFFELstX2NGYaE9ZS8F0Ng0fWM8GCV4RbRP1du4zYBTB0yYKG9Q6oUtTOa0ZTIFKpUMVyqopsZ8VJYcqO943E6ZdGTKfQrkvQmgFElpSVvGKxLGlUtx65HYJVw1fsheaqI1gPR+28V0juxoku5waxlHGqpMUDlnJzL97AUFYgWRTEjWldiz95ISduJ9CV0FaMZQ9jVjHakYsjUKEhOxCXyHR+tlEHRcEsOmSJvOvOjxGDiYFyBu6DZ3VfniopU2KKuBIZF1VH+Aml0TaeNJOJatLq9TGXQl/d69+Bw6ILnC1gE3gSqdlbWNxuOm2iDIZhUj7ncmfQSyO+p55nE5VXGa5TrhcprlsZJJX1KFiafDhjc0ad4QYp9qEl1Ubw8hnNWOPRtFzguRHS3S4Vo5gnL0tUOVR4xDmStUEO8GosZjnnpvqKp3Ff1CbVXR/F9Fz7gFrqPBLlhV5WiAjCuwuauwdbvmL56WDsne0PUkTW6qAi409kp6mprF0sQDvIcdTYOvoQqJElWkTh3U0ehyxsSAEcdoXDJGitRs58Ho2nhx/t7IMZlbtw6fn53iyJuByWF0gbOA2DSkqwq1+ukyOoCFNntA0gDmXdOhjVvFuhmRhZY9CDAxIrRVX2CIzWpgPSFChekEK+FqCJkOGfFKf2wYj2c4r5+ws0Th9k5tUJuNSe6k5z7s+38wkt280Mf+SBPDLZxWf0MR/QcJ/pTUMt5bnmWrxxf2seXdZA+mlRUBrLItS8yxB0xSagf1yXS5iWjhrMW1hRBXxBpP0G9w+bq99wsnfQVQUImD1kGs5rhlKb+j3S9+dlz6Hw3nS0B9XOGzDW8xF0IB4asFhBkFhNp0oZiOBUQ9i3V8yNGrao0RxmnFpBRuggah0J4UwpvZuSDdS+3VjaZeE524Pnlqgzgw6FDGrU0uwW9C/i+1nX9r0M0kODCN2vmNcVoYkxx0SP5XsKrHzsq6tG4vJo7nqXnO8Yr2kmYWYKeSCQGQ4XKxGgGGCvV6HEAFww96jlGwlQhZdXIqWWghZ+qlaBZaEFoRttTgkoOmcauxsLRR9AxYw26J0odnGxRd4t4shCi01AShY2yJcUdCQQXro9lE11TYzTfl1knLGo95C/vu5pbXvoU9SDlkyf2EE2OeOidlxNE8N7hVVy38yTrwyrdYcxP3PgRVvM6v3PXC/mdR27lI3f8d04XTdauq/GZT1zO6ZfP0tldcMn/7vHH73wR6YTlohtOcOjSOrfvfo5TQLZS4fRvTKCerhK7ICLfWGCmUjqDigDC7ZBNrzrOLTNH2BqvsC85w95oxLduvQWAtetTdFSwo7nKsU2bCCZSRssJsw8pbv2R76X+7nuJf2gvvdt7VO6rs3pJxNw156mMYooAqgui8NF+cppgpHjPwdsYbU+54aaj/HV/L0dHc/zpXx1AXd1Hf7YmcohG7l3cs44upUqKFsbRThj3J4gih6V+flzBCVJLd6uTynRc5HDVzceaR66lilNdlMYwL6dXWQ7L6k+Qyu97K/qsPm5+E/3mAJBA0puYRU9HhMNQpAD7lrwSiTb7WlQqKOU1WY96Wz11TOZXOgFsHcLpCmFHVFvyTFNsEN53fComdU26lSWFOlst+fgqB/oSmBYV0fEvEk0xl6FXhUMOwv8mF++AvGnQI0W4GjLckpOcD0VadUNG9WRUJk0IU6ecg9XzrvnQUCYO0ZmYdIuV9WKzuPISG/JNOfQkGdADTdaSIMeGQs8pPydXcist2MkMUkH2vWtp9VQgWtVOw7yypEqude45445C5ylXnr5aWZDKqh9DCpmb2osHuKDaSxZ6hNkjzkEKmVO+shrSGYNyQWW8LgFb2NPkrQLTE56yl4gtE4pkDBJFHeUkFWWdraxZwg82yF+1SvuyAeZglbCL6Hs3C2w3EurKjCQwRU3Q5sYJSapG02NaUDAa0388b14cip1CSkP2Ct8YW1mxbvyKNGMwgrSlyvvqufx5ZVwljTsyd/zY8J8Jcv+TNaEverUxT6nxdM3eNlvuVXnLoIfajS1xiBaBA1VWPrKGSyi0M0pKVdk/JAmR+FdEXVWq/nh+vqc0ZROWZEXOWXSlihsMXcbiPATivvQ0FBVB/VHOdXh7D32kTuOM4/67PWfi6QCoEg5Ec324wRAcq1HU5F6GPZdUIteRTcs1jOYMvc2a2ilF39boXF5hMhmwNqqyo7XK7Rue449f+0J+dc9+vvmZcxRWs6O6RGY165srdP+RQMR/zMMCxT8BX/yfi076F7+m8CV8+CZEnQNTKVkdutstw1nKTnKfPcfrCpVJ4Dh1sCgVAIIhbPsPd7N+kfBMR9NGAjsl5/Zc7n+sY/Y37xYlgViMlwCGk5rBTEA4FMRh1FLlddsQbKSZPDykSARxKfV5XeMbOO3goSwoWR0JSj3P0gUNY21zRZ4oMWuoUOpI+/Kid5or4rHBhy8BRx35nKwq1Jy0JQtV7pq2dEapvZ7VROkAwEaWvCoGH8mKLN710049pmdLNz+v02siQb2945zIKapy01RGNjjt0KwL+ck+KQkHgrhmLSt60TCWnnPn1msRRT/CGoWdzFBOPUNlCpWrsmytR5Q263nVMpqRxTFqa/RQOv59I1aRjFEkEL6sN2q68pqjzO9Z4jOPXsxHH7gC+0yTPA3Q/3KF4TUDfvy6OxkWIWkRYIzmfz59O7/7yC3cfu3T6FNV3rZ6E5/oXMp9p3aQb0wpKrBn/xkOfVsTe02H5KI2B09txFQMf33v5QCoVDHfalPU5Jr1SKHWI/RKzGCtwmipSjTfZ1/rPHct7eGKyikKq/nWrQcI52Y59p8OgLZctu0s95zYSTwzIHm8SuO4Zup/30P93UIH2/Drd6OerdOft0w9Ywm0Yc/0MrVzltkHVulenFNZdLSDS7skx2P+2599Hf/PAy/j/7zjFuqnFPV7a6XMGsgYK3wS6YLA+llTIufhQIKgcOCCMt8kroQCY0IpyyfrY4UO76AYDsZSrUEqw8dLg/r+DxPK+NeZLcv/F+p2p03KZjWVS9l7OCN/6tyWCGVWkzkWjKC2JM6MtXOUDpkTzykmDksvRv2spXEKJj5RZeKQeC8kK2JUFJ+P0GvRuHnaBX2DeTuWHkXGW7yqUb6vwkJ8KiboizX8cHMG7Qi9FooLbyS0Hr+jjHakZPMp0XJUJr5F1ZacZ+XobqVZmqPq+OqCzTRBNxCFl83yMG0hdBzbKDCxOPXmm0YUUyLgnTVlfaidlAmcLGvIRO7UKihaOZUzAYNNhrwuzqr97TkYT1tyFA6v8KPGfSMgSVhlTb5DXh1T4nQOYVd+vJoJjMdAkFIq4ngajPUVwYEuG31Hs6YM6IOeBu2RXIfgdgQ5N7Etm+A9Ih2M5Jo72xTdbYq1hSYzk11G00Y8ARY0wUpIsiJjy4Yi/2cC6G6WAD2dgHSmECBnmlK9THjS8hMOoXnSUj9rmThiidteMlOcW7vbFO3tmu68EvnJyK/pqpTyrJ53m5nE06UrK8h4RDH2r1BO+cVp0nvTJFEm8qCK3Ex1AYKujCr3DeWCf09n9I3RwUj2wguTMH1Bs69P3vOqe37aVVMLAUyCEfS3GjrbRbABK5U6n4SGPYXa15HxNlGIQ/XJGvGanCudgOGelGxCfkcXoKzXqdc0TkH1jFSmlXFUIC33a+I5R2Na1+RNS9YSmd3fufPFfMeGz3DF5Blum3iWD5++FHb1yF9yPe/at0n2HFVwvDfN2bu30Hz1Eb5yfGkfX1Qk/RWveAWPPPIICwsLTE1N8eIXv5j/8l/+C5s3/93inEr97dnNL//yL/OmN72p/Pc999zDz/7sz3LfffcRRRFXX301H/rQh6hWq5/z9Q02gM2E+mH7ofA4cYt1IJPON0hWl2D1UsPougEdbSlO1Inaim3/8W6O/+IBsumcbEoRrQSkk64rfEq67v+xj9YJS7KSU1kcsHRNS5QlEkVWl8Bd5xIgK2PJtSYchPQ2BeQVt1jlYxWC3ha5RmVlMfCblC9V+pKvXzCVkQ1FKdA9Sr6514j2rnO+2QcU4ciIvm2nQBchyWpO2goYtXSJkORV4bwXFeXUaygbq5I1QS2scgvbLK7saZ3WuEGPtJQqgWAg9tB6JNd2Ia8xGI2TAF/SNaHjivoAv2JK5RvleLqqGFu8m0jKlnJ+sVu3kZRJTUUQqrCrS73m4exYvzrqSmOdHjm5wS7kcy5ACSRI93SgtGkxmwbYQlF5sopViqPv3cOWrzvG/3jZ/+Jb3vPDFLsHNOtDNrfaPH2mxR8dv5GFlRbN5oAsDSlWY8KZIfed2kHtHDzT3cRDD+3hu1/4Sd7xp3ew5T/fzZErrmbHladZ6dfodKrowFI5GhDeukL+kuvRmWL0/2ym9QNrrJ1rEa4HQvtJFTYpUN2YHd/4GE8BcIqf4Qb6r7qRhf8UsPGGsxQLA152ydMkOufJU/OYtRgzadn1k/ew8IMHSCddOT2AHT93N8fffSVX3X6Yj913Bd2da1zy+oM8cPfFfPV1D/Gh6mWYUcCuyXXO2QbxElQWKyXdwKPJ/lkOQ5FA9A6aOpf5njjHRUHvpMHa62R73WddOMOU2DfdyYj25xLzEpkb1QXGiaoPdl0Q3p0UEyCPIntkPauN5eqyhkMmV2W8BgNKrf6s4crtVjbz3DWK+/Goc4vRAhKkU9LzUV227pqlGVkZCE7KxC0iCEemDMgHM5qekga7sCeBg16JhELgEpt8ooBMUz2vGW6wVM5EklxPFFTOin65KLnYMijWmVBphFImyd1oUnSkvQPwcKOhek6XuuPZdV2KPECNgrFqlgXdyAijgnS1AkONnkwxo4CkkWIKTT4KAJEUDUYh8WIgKjS1HAiZOKgxoXxO7bRmuMlgQ6idCMt1y1MfPGXB00xGs442E4p5GmacYHjQIEohWTMMZoVulFchzmXM5JXxeCz0BeCPlZ4d5asLRlHUpDoQrzuEt27JjIKGA5Ucyu+ffV6V+9abl3PUT0kQXn0gYlCfg+2GoA+9y1Iw0N9SUKzHzG1fYbU7S7yqGGwU6pUNLY0jAXkN6mdlfAZDoCLXPJqWsYmRqmbjhC3BLE8d8/093gAq7MFoWqpgYc+tw1ZoN+kkmFnHqc/kPD5R86ov2lU7fY9KkLpKtnufHrpgXFv0UAkCXsO5xUpFtYht6bEBYAMnHpBL0C3iAA64qtiyMTWvyvXmDs22gVRWTQTpdEHYD4jWNUVF9t+86uhsLmnSKVQ+3iS/bUD0bFX07Yewtt9g6gW6F0A/QGWIys6pkOZJoeEuXWsoKhqMaMcHI0qgKGu5RmfcmjaS/XG0UMc2cr7v7m+n/miFv0CewY7bT3L4lZv56l9K+LPvfBH2/seBM9S+fyczH5uEF3/eIcgX+fiKTvqFxxc1SL/jjjv4mZ/5Gebn5zl9+jQ//uM/zjd8wzdw991/tyzh2bNnn/fvD33oQ7z2ta/l1a9+dfnaPffcw8te9jJ++qd/ml//9V8njmMeffRRtP78Hmx1AWhKAJ5OuVLzUAwQdC6STukEFFWDDTWtw5resEZas9iWr0HKQrTt5rM0IjGdmb/XsLZbqDN55R9/IDT/5B6O/acDNI9FVFYN4VCSi96mkKwhG3SuwTevtbfLdeZVys3UGxfpTGSuggHEI5G48rJfRksjnM5lEdJONcYrrYCUlEWBw1EHnBRkbdGW78uq8n95TZppOlulYaa+UNDbGNDf5Di/M7IR9vdmqG5A7bQuqwHBSDaBqEvZSAqKALCDgCK2BJk4E3oerrgUCqKRThpqZ4Svnteck2BNNslgJEFzyf/sB6VEWhELX1B4ugDOmS42mJpF9yWYMFUjfGKLmFloSlTdN52pAkYzEghkrTEyVT+pShMlb3SiE5FhM6OA+tMJVkuzV5BGNMKUb/yLH4S5lMozVdqbIw5sPsqh1Z0sz9Sp1Ub8q21P8sHfvo3ipWsYq7ht62GWNzXo5xGv/5cf5yenn+MTL9zLkUuvQR2rsvBQje7enPpsj0qcs3JJiD3fZP3bDHu/6x4ad20gum2BDW4M5i++nhNfFWEzzUU/ei+Hfv0mquc1tZuXWD7fgiHUNq1TDTOCyPDs+gbOrbewywm0Mnb9wIOEW7cIqufGXNGExR84wJ5/t8Dy79b5rts/RaQK/ug9LyIZwV/eezVBX1NdU5zozVMZeZRaAlyvGOG5xkBpvJVXxvJzXioxHDhOtxvjFzYJe91zcA1zjqfrA4VwALjP9tr8nmJTVtE8/aQzDnhMKPGYD9y8EYoNJDAqUUs3/nyArgvr5E8NWU2V31EqVJbCJQZ6URrZQKptw6nAKWgIv957EBSxBMrh0JbVvqgt8yo5FrtEfuwFYbUug9awN66+hb2gbNLz/G2PhqdTXsJWrtXElqJqKKpqzJl3QV3WlN6f8KkGIaAjRxFarjDcnGM6EaNqgcpUqQSjuiGqNSLtxKhQkPXkXEjWsNgNI2w3IjlcKe+vdsFtXhFqnG8AFQMhiIwqqSTgKllWgjpJ5lwVR43pIOHA0T96YLWitmjoxBpiqUj6caf6rjnQjUnfUEogN1+PxlK02YQhm7Qki46776h2IvepygpbXrMky4rR9LixfTAHzVOWUUvcTgcbFd29OeSKoB3CfM7s/ZrB4TnMvIyp+mnpE0obok0eDKGyYhhNaqlQZmPAJp0QdFp3ReJ2OAsThynpTJ7GE3UcWj2A2lklgJjj4pvkgnHvqDC6GCe2fiz5yoN0/gv3XzvhgMwlAHJNXs1MCcI9FEEHE4kWuogNOM65owgViQO8A5n3eiT7hcrBxuIfojNxOo3WHeTvaJUqh+qZgKgL/Y1QPyOuw4UzGsPN7/pZua6Jv64ynJaKWTplsBPSM+H3CBtC7XhI2BNqT3XJsuE+LWZpsaeUUirhBEOn+e6UkxqnRJEmHQboPCCrR3R3FUw/EjC4rs+ZtQla29p88t3Xkf14lzy7hvhZobc9/d5L+MrxpX18UYP0H/uxHyv/vmPHDn7qp36Kr/u6ryPLMqIo+lt/Z9OmTc/79/vf/37uuOMOdu/e/bzz/vAP/zA/9VM/Vb62d+/ez/v6igRULFn/xCFFe7d1ZVP5/7wK2UxG1ExJNyhSoBiFRKdj8gZUFhVnf/wAJoTJZMjjZ+aJC1C5a4JsClI98/dexRd2VBdlc447YmDTnwucrTNEPYMJdanz7Evmybo0xSlXQrQBKK+RjKDkcUeCGGWd7bNSmEA5h1V5b4kyhYLu+dc9rzRrqjIZCFJLOLRkNU28Jg2vobbE7YL4Q5+lAky8+HqWL4+pLVh0bulvCbCRJZ2AbFJkqXzgQ61w6IMsrAD5dE60HFJULJMHpaHWm8coKwj+wrXB8/imQhkSTiJAUXOoaUU2e1UI1zXoaXSqSxQUJZ32OtWEy0oaRguFGmriVV1SbkwMRotsm5nIiU/F2EBkt4xTRUhWoXE2xwaKwbRmOC2oidXQ2WEJBpo3vvQj/NqpV9A4DlZH2BA+e2gn4ewQdaQuFvOE3Pfotez6xhMs/el2mq8+wxPtzQz+ZYeJOGP9/jmOT02zOqixsNzkT/e+n4s+8b1s37BC3guZv3qBc+cmCRcjirMTtCsWNqYoLffmyJ9cgzmm2LfBcvQ3NlEUmmxg+Zar7+YT//WAPPxGzu03PUGicx6Nt3DRxBL3n93OykC6Ks+tt0jinEFs2HinDMjnvn+HC/Rks03WYOaRDr3/mbMp7tMvYhbTBunFA5r3ViGyTD8pm3qyIkoNYd+STijH2xY03bqGvsgHGK46FDg6WJGo0v5ckG9XEndN0kFqnTSmKo2KfIecBP2qLL37ZBYlqjDplNCsKktynXFHbo93tASeZ94ymnYVnEB0mn2pPIvE8r1+Wua5p84o6x1IJYnwijLgqlvu+/nAO8isSAK6o0wmXBKT1YSyphxiXjiljcFcUTaPevk8L4Hn+eQ2tBTzI+IjFUH0R+MenaxpwfOCtageqUKh6jk21ww3RIQdRWXJNfQ5qcPSxdHNo+GWjHghorIImau89bcVqPUIO5EzXKihKgXhubisDIQ9RVq4phPlqEwalL6gQndBD4oJcNraruF/ktK8BiBsByKDGkuQGAz92iFJTtK2DKY1/TlpKleuFyJvOpfRkUvSBg4pduMmr4ryia+KBFesY4zGMWNIs7rwqWtCNzJVi+oLPcYbUemUUgbXxPJdV/cpkiXQhaJ5FHQhfQ2d3ZZiPSb3SR7jxNUq6RPK6jLOzt+g2PxpqXhmdZlfeQ2aR6WfonBc/dYRCVTjtlRC85ogzsNZlzhouba47Rr1+yJbmtclkPdNujaVe4+RID7qyk3w/HVPGfQ0wLArj9dEgm4XiVfdclWOhkhzqkw5TrqAMd5wyctnRm1N3jSgBFkP+4rc7WW5623yPHnveCr9Qa5BduQMmkKR2ywT/FBop9mEfKfqonxu87hibV9EPlk4HX2pMHg6qCpENQYlzbFJW+ZkPJSxO5hV5I5OFbfdeFaS1Ic9od8kW3rYNKS7rYpZqDCYyFGtAUUV0vO1cn4W0znD5EuTk26+opNeHv9knPSVlRXe/va3c+DAgb8zQP9/H+fPn+eDH/wgr33ta8vXFhYWuO+++9iwYQMHDhxg48aN3H777Xz605/+O88zGo1ot9vP+wHHfzOw8YERVkug7rW906t6XHL7EeozfcLQUCwnmEwLPWaTrHBxR0qAwbXrPPjIbtRTDbdwjFHZC7v8/zGPjff1yJqK/oaQsCd24l6vtz8XMJgem+p4LXSQQMhbOXt97hK90KpsqDSBLAg2fD4/WudCSSliV96ryJ8gsozGN0UFgv4J/08R9UWS0L83awSEe3YBEH7sASortiyR60xBIegORjY+qgU2NtAJUbki6miRaOsqdC+QDStTjFqCyFslTUu9jYrVvUGpNV4kF5RUkeBcVB+sQ1IU8WogyNZAO+qThUA2Rj1ShO2AoK9IpwsJWrQEUemUYbClKJvNgqFi8ilN7dmYyhK0jlrq5wyVFVlgR1Nw6o6AxasCutsVQSYb4cSRlOqCUCz+xzteQbQuCg0mgtFFQ5pTfZSC//7Nv8ef/Nyv8O3f+HFWb0xZ6Da48bUPsT6ocN3kCW7ffpiXbH6G5JpV7pg9yOJqkw0zHX7q7K3csvsI18ycQsWGWzcdoXZIkois6SzeM01tYsC3X3MflUeqxEcqxO/R2CebpJ2YanPEew9exabXHyH/2HZ0VHD4hiGbknV2NFd5aGErk7UBg8/MEjxZJ/mrFutHJ7njmqe4+AeFGOMpD2XgosE+8DhLnTqfeGI/H3jvAYZFxHU7TrK+vyA5GzKakqCyumycEoZi4mhBbVFkU1tHLckK5b0cbJDAI6s5ikldnHbLuakoNfu9KZE3JFKF/FvntkTShctqSxOisC/rQGVVkGCMjFu/oY8m5DnnNUrJumDkSukjCU7jNaFHjaYto0lLf1tB1rJMPy0BYFFRpC1FXlMMZqQfpIhVOXc9z124xIr+BgmqPE1AdNtlvIuHgiUYSvIcZFZACesa2VwzeeVc4Po2RLMd3Nx0POtsSoIMM5LMo0zUHSjgPQiKiuPYLkbofkB0rCJUmtlRWQG50EhsOGdJJw2jaUM6aYjPR2SbU9r7c4YbCvp7MqgWMJ1CoVCNDDJNNp1LX80I0g05ejkCoxjNFWMjNYfU+gQL5RBtJY2U3vfC05V8r0LcodQDxzqzoEy+a9pQpHUtCjWDcWWnXF8SJ7vnqn8lj7zrOPqeWtGwZFlIUWjiSODY1q41iqopZfpUrsgmC2xgn5ckFo6OEoxcArskrw0dPWXUguGcXHvlbEjacjTOyZz+Jrmm9m7o7KCk5VSWFFkjIG4XZa9E3Abfq1RdkKE3mpTvaQJZbzHSIxQ4JRg/LrO6rOsTh20pDCD65bach17v3dN6Su+KVL5X1hw39iZr48Qqa0r1FHePBCCz6KEWSp5yrriZVCQyJ4foPTJ8IF5Z9vKbIsdpA5nfXm7G89NH0/LskzVKdabhLAxmBZTLncHVYON4nBUVoUNFfcvU09A4GNI6rGickHMFw3EFwY+RUUuqFd1tivYOVSqwqZzSxyNu25KWE/Vg+nFNOgolXolBzY7Y+10PoJSAQkQGUy3Q2/sQGLbvfz5z4SvHl97xRQ/Sf/Inf5J6vc7MzAwnTpzg/e9//+f8u3/4h39Is9nkVa96VfnakSPS6PDzP//zvO51r+PDH/4w1157LS960Ys4dOjQ33qeX/qlX2JiYqL82bZtGwATx3Jmn0jpzccka4bJ54aETlNZH6rzzKd3M3quRX6oKWoB6zEqlyj2oh+5l9UrCtTeLr2FOv/uxe9n6qClfk6i8rziN/ov9M79A8c9j1I7b6isCtJcWyye1/3ubZnDPqV7W9qSTdGjZhJgOlSnJogiCA3Ac+p0Ko1SRSzyjqOWLlEVb67jEUmUe5/jZBaJKlG7ks8dSBKTNhTtqzaQvvwGzr3xwDh4rytZHHta0OYVTdDXJCdjgk5IvK6xiRFkZKBFiQZKo4900jVATciCOdxg6c/bUibPhpa8IdblpmKw2pK1TNlsahJD1jQUDUPRLDCxIOVSwpWV3VQN2XRRIjEmcIi8gnA9KEu9IEFaZVWCpM52RW9es7bfsvqClP4VQ5F9a4PnxgMsXRnTOG2EwziS8q644EHt8QqdU03SdswvHPoa/t3JV/I7d72QSmPE+ukJ7jm7E6Xgj/7iDg61Z3nfkSu5asMZfufJW0gqKb1RTCsc8N0b7+LPP30DejmmEQzZ9dKjbL7iHNuvOMPcC88Q1HIG3YQ/P3olV37d0+R7B5zptEgnDZVTEffd+Hvkp+s8+tw2JpMhN+85SvzX8/zV5XU++eB+1g5Oc+LZjSX6HAxh4llNonPO3bzO4V+9GWWhdcII/9rAzG/fzZmfPED0iQkmHoloHbMsHVhl8Rd2EXZ0Gcx7NFfnFgzSb1EV509Pz4h6MoY9suVVMZJ1I++zY7UI35RpIlWaFplQAuEiVo4OIzSScCBBfNS34jLYt0SDMXe7edzpTLtgNlmnbO7zzc39zRLQ9zdbqSCsyAbaOqqYOKSYu18z8awktGHflsoRwxn56W1RJfdd53It2jVt1xYtjbMGndtxw7cG7Fib3Zss+fXJJ0p5Q9Bvr/IS9sSgqHI6dKY5lrzh3EZ7oq6iUk06ZRjuTIWO4IJOU3eBfSqARTadi4pSIMlrcqgiDZF2HOhYDUWjkOt1ykzZfAqDgKAXUDkfEJ2PROFlLYbQYIYhuCbtwZZCem2qBUWzQDUzqmcCiuoYjEgbjJVSPII9lCZZ3zgadd28c6BBXhknISixqvfUQc+N3nRvn/4myoAO69bgimv8dIG/l4AUR2XrKESWoK/I+hFKWdqrdbSyxEEBjRzlqn1eZtDGF4xfO256zasugWoJUu3nS3XJMrpoSFETl1puWKe/zUjTb+DkaycLss0jhtf3RPp1CAvXgYk0M493qJ+1JXWsedrSPJlRO2+oLrmq8cR4bo5agvD3towVkJJVmH3UCIXKUUJUIaZ3YZ+Sr+1pQNI/Mt6fvIKXp9JkDYc6zxqnfiXVnsAF9CaSiqiJLNXF8bapcuGd53Ux90snx+i7N7cChNKTCg1xNGPLhlNcFVq7pNeDUmV/SOoSIjV+PVkRlDttavobhMbSPG1KEYOyouN6XfKKU0RDKkBR26HmA1smf5K0Cerujdjymozvqb+qsu1j0lQdHq2y/LoDRGFB+9JcNNiPR5jjNVpTfVb6/1jac/94h3Wc9C/2zxfKSf+N3/gNdu3aRaVS4brrruOuu+76e98/Go342Z/9WXbs2EGSJOzZs4ff//3f/5w/7/MO0n/+538epdTf+/PAAw+U73/Tm97Eww8/zEc/+lGCIOA7vuM7sN628R84fv/3f59v+7Zvo1KplK8ZI6vg937v9/Ld3/3dXHPNNfzqr/4ql1xyyd/5xX/6p3+a9fX18ufkyZMA1M72iRf7NE6OyKuK5UsrpJOue3tzRlEVdDVvFiLt1MyhgK3/J+DIf72ZyoY+W6bWICm4t72Hmdcfozuv6GyVRqrKyhjB+mIc4cBw6o6A9T0JwchIWbHjkKu2BA5pU8wYSg3akFLHd6yE4ha8SeXK5ePG0lKXPBdkPBjJBqEK+SydW+K2dc11sul4i+xgJI5vHimxAcRdW0oy5jXNaCqkedKgM8toQjb06jkp6foOe51B4wTMf9qy8f6c6YdCpp6G6Sfke+hUtM6xTk/dbQKSaCgILKNpQ7zmuJ2xoWgVpQKMzsZlfT9vw7UAPdDgKArxqiYYSLBR1ETqK1wXR0fttJj1UI3RI5e0ZE1BWNKW/NtEoDJFeD7G9kWzur9F5kN1Se6NCaC9U5eqBljHU3f8/GQpYH7rKldMn+WBI9vBwq3bj3DHtU8SBoYtzXWyzSlHT81x45bj3PuJy7BHZTHunG3yzo/eyr/9le+TDfys4g8ePMCRO3dx09xxjj23iVMLUzSbAyr1lPZinc+e2E6cZBRWYxsF+oo2V733R1AZ7N15jkqQ8dCZrexuLNN/1Y2SrDVz7rjhSbKreyRXr7J8IOP673yU4y+ro15wBSa0JS3AhDD3G3dz7D8fKEva9bOGicMDDr/lZqrH19j1k/fQPCZoUetYIbryOSRtI8i244b3ncpC2hK6k+cNR12ZExJkS/Nkb16SxahnS/1r33Ad9S3JekHcMQ5hl/4SLzVaROMFXgzD5Pu091gGG8bNzXlV5k9elQDbRIJSBkOoLkgw4+efR13ThlSwPLdcFw44SGWz1xdI28nGLtUBlPSNWK0c/1qQckmUVdnkp52JmQ+Qsyakc5kECHXDcPeIbNKQTRUlF9bzzcOezJF8KkdlQD0n6uhSszxtuaSsLZQ1k1iKukiRprO5BCY1W1Jnwr4E/172NOgFRB0xBtOpQq9GEBviVVWauiRLAZUlTXIsQUVGNN5rOVSkshUsxqhUoZRlsLlgNG0YbrCs7y/obTcMNomqlFcsSadMqdZTxBesIWqsTR67RLt5QhpuPZoZDWSdG2xISFZcMHmhQskF/RH+CAaUFVZvaBT1AG1JOwlhJSMKC1bWG2DF7TjqaDFACy3RSkD1rJLgbyDfIWvZksKT1101YkaaY1euAKWFuhHtXyd7eoKgr6mfVKRbUwYXj7CRYc+2BWrVlMFFI3KngLW+U6OygnBgiXqW5qmCYGRZuiKis11LsjqUykDp1OvG1sRzlsBVN+K2rGkXMgxqZ2U8e1dVH/ha7Sg8vsIWjhMqrGvYTVxfVU8Tt1VJT0lbMpdbz2nXE6Kct4EE5iYRYzGfdIV9JaBKMK4Cod0a3Zfz1k/LmlLqxUfjipJ/jmFPAnzlmshr5w1TBy2Tz1kqa5bBRkpH47QJ/Tld6p5Xlp00pKtY6+JvjhkbSJUsGLokcgiTzxmi/gVVbieTaZ1K1cxdCaONGSvXFgxGEfM7lmnM9IluWGXuEWj9QYsw+NKju3wpH+9617v40R/9UX72Z3+Whx9+mNtuu42Xv/zlnDhx4u/8nW/6pm/i4x//OL/3e7/Hs88+yzve8Q727dv3OX/m581J/8Ef/EG+5Vu+5e99z86dO8u/z87OMjs7y8UXX8z+/fvZtm0b9957LzfffPPfe4677rqLZ599lne9613Pe31+fh6ASy+99Hmv79+//++8UUmSkCTJ33h94YYWYVB5niNeUTegRK6qqBkJVCsFRudEpxKSVTh7s2wqL9/9FIGyrPRrLA4bHLlzF3EqOqfVReF0r172xZsElQ/cz6bkJqoLKZ3tCbpwDmxtkW5L1qyYIky44NvJ+PkFIBiAt7UWdRVBwqO+RWfWdaurssxrlQS8JpIyZ7IqKEiQWQgcleACvmteUdQWCtKWRPu+GWg4LVSOuCtBE1Airr1N8r7qeUVvu1QJqmcDKqvFBQurddbuLsBy503nCkQbWxGvjfPPoK+JXONR2NUUFbGBvvBQxhlamDHXPVnRpWKHzgVdilZCaSQOrOjyZkKLidcCsRdvOkWHhnVopHwfo2QjS6egsiRoFyuhOL8OFYNNhvhxS28+YLBB5NGslg3MK5fYwDVIDmBhpcmdi/vQ5xNecMsz3H92O1keMN3o8+SxzVyx6xSzlS6feOYSmpeuUY0z1h6aQzuTpN4W+X5RH4LliLAHicr4tpvv5kO/cRvreyscuPUpHrr3MobX5KQjzaCbYC0MOhVqWzu0qiM219q0wiHN6ogj3Rlq772P+DVX8pmbf5NfW7qR4kyNjT/2KBuB40CwfwsHv71O2NNMHrL05jWbf+Vu9FWXSp9EOHY2PPY1NYIhnPjaOTY/c0g2ylQQ7LTlEzhLMrK0dwTUz1saZy1pQzu3RRmLyfo4KMwa0jAYDi3NkxKwZ3UxLqsu2TLYNaElrwQlX11n0hgmvRiqRL98s5gY8SAShY5C4ZNTb2ZTIoTpmD8szqbC5S2iMT/XuvkqyL4oBCkjRjDC9xYktnZal8lokEK6SRoGPZ8+HFgIbakUU8TSJBuMxkBJOAB1JnK0BE0RBgQ9jZkcYVVQcn+DEaWknu4FFDVDeD5G5RLoAo5jqzAVh/o2chgGGMerVrlcd5AqRg3LoApFIyfsRZJoIw2mQdc5nkYWMjEzSlY0GBjNGWwrB6eJbXLXYFko0glDMDOSz+xF5XpnEku0GpRJQZDK8+vuzKieiMpkKa857nLAWCrSSSgm67Ke5rXxmujv63Bal3SFssHPzddkRYIzT+vx0raqkCQtr7vzFArdDtGtEf1BjA4MLFbKcaRTRdANJJmoOrk/hKZiqoao4/4vUUS5mFD5xle1UBEe9FMTZPMZmzavYqyit9rALiVoCydXpqhVUnRkGG601E4r2pdmmM9EJGs53c0x7V1B6cbaPFkQd3L6GxKCTMa0V1/ByPof9aB+vmBtdyAOvhNjXndRkYC+P+846LiE1QiC7CtgvtpRJO5PV52IupQVJeGpK9A+iZXKZ9YUIEbUsyxhRzvgTNb7wKnDVJbGleZkRe6hd6v2SXYQuERyQEk3Monz4rBjiluyZktfkGAk/Qq1s0J/UQ6192Ogv3G8DoC436JBD5+vKOXlUuOu3MO8BsuXiQlW66h1tFMcZQz6mzSNk5b64YjqIizfUGXlySZhF2wBgxkYzgbkAy/w/6VzWMs/iU66+QI+4y1veQuvfe1r+Tf/5t8A8Gu/9mt85CMf4a1vfSu/9Eu/9Dfe/+EPf5hPfvKTHDlyhOnpaeD58fHncnzeQboPur+QwyPoo9HoH3zv7/3e73Hddddx1VVXPe/1nTt3snnzZp599tnnvX7w4EFe/vKXf17Xk6xbVM0yrClyt+nqoaZILPGaRhlNvjEjPBdz0Z+scu7WBJ1B55Kcn7n1g/zSfV9NsBix+7qTaGWpLgn3tX7Gc8ENF//RgNHLbiD+8Gc/r2v7XI/uZg02prqUE6SGtBUS9g2rl0REHevKnYbuZl1qQXuN3aLiSowu+/Zyi6OWorJqJOivy8LnkQyrxIY5WXPl6URRONlMjwCEfedgqqS0XsqNuYCjtuD+3/qSvSVy7nMmVIz83NEw9WhAkFoGs6K+UyTC+zSBUBpMqMrmmagbyKJsBE0yscgwlo6iGmpnFP3NlIhOOmUgsNjIoDIN1QJjlMi85YKU+4a/3DkNYiUw8sowGIeaXdiF75zkSmkxx2f22r7y/axDbiVghsKVh63TtJfEYDSNa2qCwUZDvK6Z/XCF7hZFf5/MpW6nwoYPJpx+aYW7Xvxr/Iv3/jh2IqM5OaDbqaAnDEVsMbUC3Q0oEmd1bqUBWln4k0/eQrhpgN4CG65YYDbpkjWh8miV3u4cNdSyaTVz5ifaHFuY4bf2/zFvOfdS9kwusXRglefedi03bTnKry3dSC1IueK6IzzznisoDjWlkStX1M4q+ttzFr82ZfdrHmH5ew/Q3yj3ZeKIobKcs3RZTPOoBDDzv/0IBvn/wawCFVBZNQxmpAPQI0ndeV1qCmPBOrfQ4eSY3lFZNdJYWaqWuLHnBkSRKBfACX3GN416PqguIFw3wr+1ELpgN6srOY+SIMXzUqPueKxdKO2nU4ci16WC5atapa36Bdxoq2HuQejskCazyooqPQ68+VfuGhMbp42rCjhjr7o0fQeuUVDnkoT43hOPBno6gbKCgpvIolfiUq0iXoPhJsels0JJCwaafFOKXYglSKkY1FCLLGvgEMv1gGw2E3fUbkB20QDTjxhNS6JsFUTtiKwhVDMbi4SjiSDbMiI8H5OHClMvGDal6TRsZARhQUqEjgy2UNgsQIUG6i75GAaI4Zh8v2hdl4GUoNOOv302Ep61S+Iqi2NHYq8spTPobzYEQ43tOX61T8QUIhvrKiHKCGqcNaCwF7wPysqRryqKfb2sX0UF9FokrpxGoQNLdrZGmI1NzYIUglVVasz7Z1ZZVAznNKMZS7wqYyNvCIAw3FRALUcnBXqxQjpZMLNpnZUHN5BuHYnfgdMXz0/VmbtqhVEasvGqFc4MthAtR9L8aC3184a8rpl+OqO/IaR6fkhnZ9VJb0Jl2Tr6jXOrTWE4BcFo7KiqrHzX6oIE50HfSc4mrrHWBatBKkpj0hzuejlS6M8LkGJDt3ZaIJdzeAoMeixXGPYV6aSMA52pkvamxkOZoiLVJC/Nq6wE6nlNqDUexPPPyStx2QCSJTVu3A0vuPaKInb7r7h7yxwaTTsk3s2rcODXF0t/s3hzxKsC5njFI+tUXIKhNOwah/rLfilVtWAgSUDYE3Wg+jGNVYrRrGX7B1fJGtOsX56hQkv1cEwwEBrN8FztbwYVXzn+1iNNUx588MHnCZYAvPSlL/07FQs/8IEPcP311/PLv/zL/NEf/RH1ep1XvOIV/MIv/MLnLBf+RVN3uf/++7n//vu59dZbmZqa4siRI/zcz/0ce/bseR6Kvm/fPn7pl36Jr//6ry9fa7fbvPvd7+a//bf/9jfOq5TiTW96E29+85u56qqruPrqq/nDP/xDnnnmGd7znvd8Xte4sl9RSRWN2xZpJkNOfXobJrJUljRRGzb96j3le89/3wG8ZFfryYgnrtnK3u3nOLyyjUMnNsFIM78uOrlKmBesXhKwfHmDyZsXOPnSm9nzxnv+7ov5Ao+wD/UzQ4azMb35mKhvGbVCoo6jjwCp1WWA4ANHz5mLO64MFzp08diAohrS3xgJVcWVbYMclLUlauiRhGAoi2XcNUIFUGMd59CpUCgjwb5f7Ly8Fch7/TmTtiWrw8AFrtGKGDR5qbi04RCuIQSFcIiDVPjmNrCl9qwqFEXDoPuasCeGQn5RHcwJup01hLNoEwkco+XISYIFFHV5LW9YVxJ3AVr6fB6+Vw3wZi06ExkvEwulQUiFsqiDBPWVBVU2P+UNQ2UxEOOaDDpbA2rnIFkVBD/qwuyjXfJaxNlbErKmNPL1d0hWldfguotO8ODH9nPVHc9x/NumqN47w23pG6FRENczgsDwnVfdy7PdjdyzoU7r4YTWvzpLEuSc/uQ20aTvQf28YXRbj+FKlXd8x6/znfd/D49Fmyn29pn9swqDeXngJrSQag6f2Eh0JubHX3MTII3Y+ce2840zD/HqyQf413/yw2X1RhcSL0WLUu4ezln2ft/9ADz3328iXpNyff2EGKGs7o2lCXMBNr3lbgwizWheukr04SmKWLG2KxBOcGXcoGZdgBw4aTcZfJS0kOGsordF0NTOHtcsYsX0RsyPFFPPFNhA0dukUUaaM7M6TD1riHKLDSQI8gliqeW/bulslYDLc1O99n3Jy0/HJW+0nPfC5k5BQSk1w8u+kQuC/Kw5pgf4xC9uS7Id9XEqFIpoYIkc4qeKMWqurEMpQ0GsKIMUK3NloMpGRasdYtmR91XOy00Va/TAKWskUqFLFUFfSwWiIX0cQd9VpM5H0sfSKjDtWCRKQ0s6ZbFalJSUBQIIupKM5xMFejmWZCQyRMuh2KlbRTEIsRUkWPM/FlQvhHqOKRQkhrg1Ij1fRRlFtnOIzQLCpVAkVCOZm77K5RHzojpGzo2752JapUsHSq8OU/LPkXscjGQ9KuUtB5QGbiaWKgTKU1wY29er8f3HQvRgnf7lQ6I12UtGMwXJclBK78VtysbcvCrrqqchZS0XqFfBTOSoqIDVmLwaMP20Rv2rZZaPTREpCM8mxK5/JupKAnFssJ1o3zqdNCGdNOhUkbYCKktZaahkIsX042362xrkValCJeuUiXCyKopLowkBGbK6qBB5906djgP0cCTJDEb+rnOpMhp3n612coNeMtitxcYBQ0XspFctqKqj3NRkTQ4G0kDtKx4+SLeBlapqT5WJarw2pgqZSNE8JnvjYJZSz973UOhAlV4WXpZSp5TrOFZ6TXyy4pMyT+m5sAfDgzhRV7wE8qpQU+N1xcwhEUHwVBiVy0/g7iPI9zUBmIZM7iBV1E9o0BD3BHgabG/R3WlJJkdgYbAHpu+Jpdq+9EVvS/wCDoX5J9A0sSiMMaWQiD/+LubF0tISRVGwcePG572+ceNGzp0797d+xpEjR/j0pz9NpVLhfe97H0tLS7zhDW9gZWXlc+alf9GC9Gq1ynvf+17e/OY30+v1mJ+f52UvexnvfOc7n3cDnn32WdbX15/3u+985zux1vKa17zmbz33j/7ojzIcDvmxH/sxVlZWuOqqq7jzzjvZs2fP53WNO37+PopX3ELyS9Jwmv/JLPpsBX3VOpte9STh1i3kp04D4vS5/LoDBKkY9bTzCqE2vO6lH+Nof447n93HuZtjWs/BV33P3ZweTnLv0V0kj1XpfmwDN3/DU3z23Vey4xsf+7yu8R86ioroj3sd5KwmzSTJmsWbrXg9VZ/xo8clt6zpJOF60NuoyJMa4ciWC2vYh2jkOOcDQeI87cSE4j4KEmwHqVvoan6Dl41jdT9839d8mF+/+0VMPBFRWbUkawVWK878C412SIvOBMHwqMv0U85Zz8LaXoV2tIH+vCzMyZqTmysswVCj2rosfQbLgUOUBFFXBmnA0hAvyoJolCJaDURfd6oQRD2wqNgQH0/KJqQyaAlkg+xvvkAdxFIi0srI323gNpaKRI7aJwnKmYHgvutiIItvMeZ0tnc5bmnFoHPF+sV1pp6EHR9YxSrFyZdPMvV0QJAaFq/WtKIBKFge1tjY6BC+ZJ3HDm0DC+lilSuuPMs7D16HsQq9GtO/uUf38U1svfKsNGzmEpCcf9WQCEBbfvTpb+FdN/42r/rwDxEvhYwmYP5TBWdfPSI5VEUV+nml2MFHd5HmIVNBny3JKiDqH9FqQJBKUJm5/qT6Gdj2C5Ksnvy5A8SrCCVkoBjOwc6f+ZuIRPvbbibsW1YPTVKrCJoWjBSNkzAMoXFGzMO0HqsWlTr3Hr0uxnJlfg4EXU3RKkgnDZPPCHWiu0WCRBOAjSXgrywLn9YHXaXakaV0kPQbcKkC4hDzwul9J2vWNYJ6FJWSB+0lO0dTMhcryxci3C6SRoIakwhiqDOHQLpERVRnXGDgAnGQ+WqDsfScZZzQKMBqCSir5yR5LA2IXACTtgqibsBoSsr63g4+XoPQzXetxoFHkCpx6nX3PZt0Ddarcl8xLtELcBmDwlQKgnaIHohBVjplCNcC8laBnkhR6zH5REF4rIZJLFpbWAvRG4eY3KEFFqL1AL0YMNwiCEA2lIC8aOaQBoS1nHyToXIkIW2JyZLXTwdKjXQTU3pFeFlGWe/GSK9vkswr8nxriwWdreJT4Z2ofUJfVCj7AXxSZiKH4lYtJpeExq+BNoDkOaG5mBjqx6X5dTgn1S8vmTmaVA6kkesYTUHjpHLqOpphaIlPRSRXr5LfN0VvHqaDohy30rvh5EAjCI1ILNau71MYLT4Vxl2zlbW4umwZTQTEa4I8DGalD0c0xBW1hZzONpF8BBdcu+9rIied6ChCJoHCzdMglaZHr+5SuF4Af6+8hr+/Hgn4rXNBDkpnVF+11KlopHtNfxtCEdpyrcEKui60NfGu8OfIG4a1/TKm6qcU/c1jSguGUvHFzztl5ad+WvbY4ZQuefR+vpUcc8tYaMEINQcgyp2CTUOVhoOd7YqoC7XzDlzqjw3btAvYjdvfi5rQe0InqWli+f+oB50tIbXTkG6FtB/BSLN6maF+clyF/HI9Dh48yMTExPNee/Ob38zP//zP/52/8/823LTW/p0mnMYYlFK8/e1vLz/nLW95C9/wDd/A//pf/+tzQtO/aI/oiiuu4K/+6q/+wff9bU2kr3/963n961//9/7eT/3UT/2NssPnexz5LzegJhSXfLTCwV+5mou+9V6yO3dw8uHNmBdeyzNfH2Mbm2Gk2f4hy9SzA2fsE/BgeDn9rYa1fVUumlgiOJNQPatY31/wgcNXMFyv8F03fIY7Z/bx8xd9gHcvv4C0E3Py5w6QrIoF+j/GEaQQdVKyVkzSNqR1XQZPlRUXbCeCspmI0iTFbzblgpfIotOvSkNb62jK6sUxk88NSSdC2jvCMgiwSoLcwpVhdS4NVONyr3Big9SyeINFTY/YHS/wthf9Lt9/5PtZ2g7GBfDRTJ9adUR7vUbrs2I8Ul2yKGNpHelz6kUNqudlIcoagkQnK5RaysMZBJ2KLMSIocmi8I5FW1YkrExFNMuVgc4uS9TR4NQS8roECzoV11LVDcV0olKIbFxHS3nVBTvJiiqtv21ghctunUlGfAHNYaDLYCubNJhmQW4AK/q4NhAd6Whd5O562+U8gqhp6qfkczo7wQZT9DfCpvtTrILly2OKmuGuT1xJ/aoVBmnEqfNTzM+ts3HzGnunFjm0OsfD91/Ea/7lp3nnx25lct8Kt80fZrQn5MP3XUXTlejRsG/+PEc/vAu1M2dhscUne/uozA5IBw36mxTD2YD4mSqN02MXzpnfuZvGXRvIhoa55jpXTZziispJvvlT30v9eCAUHUehqi7JRtOfh2ng1L874GzOZVPOazBx1HLmTQdKDeX5/3Y3537sANVlS3ebJGM6h+YxCehHkxLUrOyXpl7tqCGlwczQJabwvApQUYXaCQk81VCX88EE4wDWK31kyTioSFtjuoK3GC+snC9el88I+rhnON7AvYpK2B9Tp7yD4YWHnz/9zaKE4Zs8i8Sdx1G7LlSDAEojGz/2htOK9guGmEEozYaR8MGDjkiHJiuCfAaOMuEdNeVciqJqCIby/OJVuU+AS3Zdf4vbWzwnGEvpMRD0dRnEhl1R5cm2jLCZlvvtKkzBQK7HhgFZ00kNGjlfvjGFXohZTQj7wnNPJxyVrVkQ9AJMOyZekgDNJ7v5xQOCsxVBurshplqUJlX2fIVkW5fhTgW9gLQK8VJQJk7+e5XOnsX4uQQjefZZ3aHOPnh0FRWdmvG4iKVPZxSNKW8+uSmDtQv2dKutULMcTxsDecuZ6JTUGFlffINjNiFKKTqTxsfKqqjOSBAo63PzSMDEy85y7uFNBLH8XjVKCaZTwuNVoQ16nnwCuZJrn4+HHFqYI1SuctMpKGLt9PmlN8PEAd3NQckL9+Ovtyksn4WvPBcVp4vu7psuIK3wPEqRr3z5P8OeS4S0JOV6NNb+93M5HCh0HpSfL0nQWLzABo7q4tZplSmq55w0cSIqM97crrvTlCICwRD0SFFdkmvw+uqedmMDCX7tyCX8+ZgyqlIgHM9FgMI9M09tMW6cmFDuC0rWj2R9DCj4Z5KG0oSuM6ifE7CsqMhYjNtOoz2hpHV5n4XKski3Zk1Lf3tB/UhI2osJFiLitmI0a+hvNagVvuQOCxT/FDrpKC6++GLuv//+573+t6HoIFTvIAj+Bmq+sLDwN9B1f8zPz7Nly5bnJQL79+/HWsupU6c+J3+fL+s8av6SBc6tbubwH17CVGOV479wgD3fe4a5Gy16WGATQzIxxD7V5NwNMH+3JeznsnBsNbz0lkdYz6rc/elLMVULL1yH1RpZGqKTnLc9fiPWKH70Y6+HA+v8+E0fof+ChLf975ey8m8O0DibE3/w/n/4Qv+Bw2pRpMiqXkpOUG5vN+2RaRgjXpGjuXgzDI9ABiNpdulvipg6mLJ4TaXUbRXgy5UZPUJvJTDJK4pw6OgtTms6qwtCZIcVfuK9387//sbfoL9V7mvQDsXd9dk6g9k6drZgNCGbpGjdKs7fXCNZhtVLbRlgDbYYKts7pMdaDDcadKovWOhlMR/MF4Q9jYnGNs2FkajBL4CThyztXfLvTFtUgKhVREp0ZIcak2viNQm0TWLRI8gmLbajHX1Gvm/YdfckGZtEpS2n+hKO9df1ekjYF4582HMldyvNytmUpXoqkFLwVkE5bCD3Y+f/6aKGOYNtDXqbIqH4VKUhNhzAdK1PKx5hUJw+M80Ne4/x8NktVOKcZEeHP/3gbRBb1Ptm+ERzhsqypb5JegtGE+JY+F1bPsO/j3ZBpeB1136a33rny5m//RRLYUGxQzE61CJvGnQmqN6Blz3Gqd+BSpBx7NR2brnmPj65cBF/8oEX0lyWexH3obZgGE5qxze3or6C3B9QjjIhG+XKfgk4SiQNmHtsxMLViahXuNK054rue9VBUhNw6m17UEYSQ69sVD8nvP7BrFRP0gmHbIWilGM1NE7Jpmy1fGbavCD4dYF21nQbdQqF07rWToPdS0sGA5lLUQ+8NKRw2+WalaJUhbEhJc0iSG3JLTahJDI6HUvdoZSYhbmA0csCel574QIvPZQ/0yYsXynjvfJspQwQPSLs1SnyKnR2igtvsqSJVxTZpBG96BSiU0Ep35rXnTnQtFBY8pqhel6XQYaykLk5ZmIr3G8jlANVyFi3E6Jvp2Pp9/CSglhIt4+EZ17LKYYBphOKsks7xE6nsBaTb0rJhwEUimQxQKcRJrRUVsQ8LG1Kkq6Mwp6vYBID9YJgMSIahGRT4lRaNHLMUhUSg2plRCcqpNMFQSpVN1xjva884prGTeDpdVK9q503BK6xXkzeLOu747HzbX+svuNlBI37yl6gQOVgJg1B16Gu1pI3BAHOJkx5D5MVATN8IGoinGSsUBtCV10ZTklQGval56d9EXQuMkRpTLwqe8Fo2nLJxAJHT2yQMWZgsMGSOB571IX2lSkGRdqPCQJIZwrids5wJkYV1lWpLGkrKPcPn0QWnsLhaF3ef8BXFryZE4rSXVXnAmrbAGxE6eTq6Vyi9iWUHn/fAodCy15BKUFoQnFgNYl8V//ZyarQuEYzMJi3qAx0rsq+osqCoqhKpbioISBUAqUqmaJUgPGJsXFVZlyVxDuD5pXxuPGVAG3GVRSrKBF/zzUXpTMBnGw4ruKYUH43dOtLZ6vQRCur8n/pBKVhlFe3krEH1ZUCEyiq5wPylqK/vSA+EUvvWReskgQwz/6/xR7/3A+tNa1W63N6bxzHXHfdddx5553Po2ffeeedvPKVr/xbf+eWW27h3e9+N91ul0ZDkL2DBw+itWbr1q2f2zV+Tu/6/9Oj+aaAqftj5t5XZf2paTbfdJpnf3Ae8+3LHPq2KtW5PsO1igSnMazsjygqAb35mNtvfoKPfuZqHnvffvLJnJmHFckHJsDC9g3L3L73EEEoqXSQQu9cg99569fyB29/KXlDOrT/MQJ0nVmyZkS0KnCaX8y8qYantfhFwU/kwnF3Q1dusy6bV7k0qJkQulsjagu2RDV8kGNi2Ri8VFlREYSpt1Ek7bKa0FdWbx6Rb0oxiSVeU/zIU9/CJZeeIlqMsIEl2zKifWVGuiWlelqCv2SFsim1elYzmjFUFkUOK+oqonXN6LkWYVeJG+hQ1FislmBGSpyaomIZbcwZbi5IZwx505BNFmIaMlXQ3qXKUqGNLFFbU1SFI0uuMJO5IFpV0VE3oSWfkM0eHFreEXm0YETpaumNYazjUEY9JUFNKo1yqnCKLw6ZsaFFpYp4OWCwtRB0w0qXf3/eEq3D2QMN1i6foHaiw2BOsXqJpnlCzG5MDMfOzHLN5El+bf+72L51iePtKfjsBOtPTVMUmnBf20l4wXe87sOkTUXF0UwkCIP/dewOouvW+J3b/pDfe+wA6SUDjh7fyKVz5/nqXU9zyY3HmNmxyuDSIcMtGY8tbQbgwdPbqE8O+OP7b+b8x7dSXcDpkUu/QnubBCFxV3oKdAbnfuwAu3/inpLakTUpG82CFKEkOQZc2grRhTRo1U5L4DOalt6FJ85v4vETm2mcyuhv9M2UkLQLikT4qPG6LZPPuHOB/J1x9BDHAR9skMardILSptxErpnMyUQqtxGWahxqrAOtrFQKdGHLplORPBXddc+N95rnnm5QGiS5Zui06d4bSOWgSBRZTTGakMDYb9j9zYa8LhvycNZVFRwfN520pBOWwSZDb1/q5FWlVF5dNtTPGaafNmy8TzFxVJB6PdRlxcDThfKaBDG5a8aMtnWJN/UZTVuGM96VlVKVR+WCHI/mCqKO05Zf0yTHE6LTMWoxoXImJF4JZI5WDdGZhMrpiOBIVVSGupqwExCta3Qo91Avx5Bq0FK1ql2+Iqocnn4wHJvVWG0hkspYMHTlfyWyqyoyqHpOWM3Q5xKKxJb8dA9EeHdJGzI2sApd0JmJMEDaVIS9gtrZVDjTDc1gg1uPXaOocWPOr61AqRQVDgQpB1mvlA9YU5/Aa5JlTfW8BI5+7IA0GCoDYScgWVNlAmdDaJ50+vtzUqX72hc8zPK5lqvSFWy99gxPrW3CGsVoRt4b9VTp+muBy3afZqlXZ2K6K9XKoUanhrSpSqpj1C3Ia5rJw4X0f4SSKFVWZGwr6/jlvjfEjgPvcOBoIi7xvVDxxlecBL12AbvrE8COaSVFIq9d2PxsQudj4RLuyqJUXypLgphnLUcRa7tkOXCmRsBwo/Q1hSO5D1FHPru32RkuJe7/+/K6n7NZXcZI1oDRDPS2CnjiATFf9SoP69a4bEyxKqsAbs2rLLlrWIf6KVGJ8z4K3mfBJwW1s5bKirt/AdQWLcmaIVmz9GcDhlOaLb/9GKqeoYeu78bK5yfrDmiIPvdY45/yMKh/kp/P93jjG9/I7/7u7/L7v//7PP300/zYj/0YJ06c4Pu+7/sAkfv+ju/4jvL93/qt38rMzAzf/d3fzVNPPcWnPvUp3vSmN/E93/M9//cbR/85HMdeNcdNX/8k108c4y8uneL7Dz3H26s38+Bz27nhmud48IGLiAaCDHkrY5Sis1Xx+G9dgdoPky8+R/+ZDay+dMBLLnqGz7z9Wo6vbuFYuBnbzGk9Kg0ar7v1r/mjuReQnqqLycmKJn/x9YQfe+ALvv5w6xZBYiuadKZKsm5AabEJN2OEzjscRh1KMwSvEGB8KbVHidioQjSko+6YNmA1FJFiOE3JzTZOLs+j86VObgj9TQqlrSgvaJh/8UmOnp2l06sw8RzMPtDm2TdWmd7YJv/YDL0tVjiGiWLzFedY71fZ/GY4+o2TDOYNUVuTTRhKfWGnwJPXLeG6ICEA4VCR10XZgJEYH2E1NpTfNVUDuZexEy6CiSxZ04C2IvmWK9R6OK5EFEqULCYKMUNqSjAfr4xLrTqTEnS8rNGF6I8DZQkyWXUbfzTmLg+25ZSSj0NF5VwgfNyuliAylU2tumJZugoa39Ml+9QUwp0ey8AltYzVrMbjo22cemyeyqI0NqlCsf0FS2gszz7XpHdpytt++2UoF7BXVhS1c7B2ieXE+WlMrvk3n/hu9u05w80zR/nDR25iZVRlYVDn5NIUWluUtkw9HJE+OQschKcbFBm0OrJhrl+aM7mlzeqxSaKOOEHWD4ci1TmyRD1Y+Vci5bPxgZyzN4dEXdz/y5+Thwsq778PgM62oAycvBmMyhX5ZT1iZdm/9RzhzxjOLWxg9ECTYAjt7WHJwS4SOV93PijH+YV23hhK1Y/QBfBhfyyLllfH/GIvCeeDrsA1ifoSddTxc8uWPNRw5B1MlXMzFUpU1Lflhms15A6VRkFal+qNjiUosEoqZUUiCF/tLASpEF6TtsGEIpUajCyN0y4I0aCMQpmI/gZQbR80uIsvbFl98DSNbEIoG8mSoGzZhLjPmtBRsFabYkzjONpF4sZ0OEb7lRG30pJb7AKyouqSFkeRE18DmatCiZGA2YZOiUlBkWr07IiiH6Kc23A+mdN/Ylr6BdILEqrQzZeuxqSiM+/3YN3IiCo5o3aCNYq8HcHGlPhEIs2FIRAJ4OBRUJ+oeNUmLy0bjuTZFRXN+p5Yei2sJHNpQwKgUWs8plQhjX55ZYx6WoV4MFhZR0oKlEuSvH67VWBqvqoiCZPOFEHXPZM+Y6Ml5daEEXR3GRpHNB8/dz3hpDjKVs4HHM/n2XfVCS7efZZDJzZRzIHNFBDJGKxattVXWeg1sG5dtHMjdC8lGFWoneiQTVYYzsbEHcP6zqB87vWz0iwada0E9E6S0dMvVA7GBbDBAHCUjSIao8fP45X7KkZIaXZW0pocJS0cUBpORTBWQ3JBfzB0gNIFTcKyVqtxAuEqJ60jY/qcn9t6JMF91JFAv6hKop615Dl4KlvYk76AtUucSozTUM/rco7S8Ag3nhzCf2Gvg19vTHABKGAENCgq43sYjkTaOa8peltkj47XhUqXO9lIb3BUXTQsfNuV6AXxFxjsyagdjBnMwXBrRlDNMSftPxhn/FMfFvVPQ3f5AiQYv/mbv5nl5WX+43/8j5w9e5bLL7+cv/zLv2THjh0AnD179nlS4I1GgzvvvJMf+qEf4vrrr2dmZoZv+qZv4hd/8Rc/58/8sg7SgxE8/J7LeMRcRvdtQ37yTw+QbcpgqHnmzy5mbtGSVUU2Ka/BaENB/oRwLEeTispF6yysNWnuXKdzfAKzR5NOARuH2EITLMSkt3V49UWP8KGzl5I/18TMZVSOR2Dh/AtiattvZur3v0DVlzAkayryakjccdqs2nWUa1kAcycn9ryyZDJGLPwGfaGOet6Q/xtskMxeB+ONIupQ8tH9QuwXvLQpJXuA7k6LWkywMym2WvDijc+wPlPjk+cu4uxtIe2XRly35QSP//VeXvGd9/LKiQd57dt/gK/7mrs51N3AcqfOsX+vyE4bCcarlmRZl/q6eVWCH+9i6Kknxi3iRStHhRY6jpeayqS3WJIVTbIK6YQE6/FqMOZEBmOE0FQN2iqUR+jyceAddgJJFNbHEz1ZdOoXjjPpF1dPTwDZcLwVuh5owo4urdPzhqVyTj/PoTCdABsqqmfh2INbidxmU1mFlasLpretccXsWbY469VX3nE/733wWl5y1VO8bu6TfKRzBW/74B20jsHKRqGCDOak2Ws4Jb0K9dOK2hUdFlaa6HMJZrfibXfezgtuOsgTC5sYHm6hMkXjimVWlie54l8/yZl+C35Vqh4mhN5Ow54fvRf1gweYfG+DuY/eS3Dlfp75tzV0Hpal/+42Rfxone6H99B42f0UL7qJypIkwukkdPZldJYitvWvp78horJsWd8tNBhTkblYPwMX336aTZU2T61vpBWMGLUTmiPpjciceo6JpfQft3P0bIBB5nF/q/B9w65sqDqDjfcPGE3HhP0Ck2hW94TCMR+6ueK4wp4P6wNSX973gXqQOipYpMoSuCos3hgMnPqMkizCnwMckmhAG1vy40UdR8Z2sjYeTzoT+b60oUsk+EIKjA9k0A7htI7WFvnEQWHUWFY0awgly6sgefQ8nZSEt6iM51SWiQtw0HMXrnzVQRSRfHAVdRVZ02BqBdWTsuYNtmdUTkcoo6gsCho+3GhK/erRjDTpFRUrnPJGTtANCTb3yQBlJcDKq7aU0hxuzokXQkYzch4UY8O2AIITVexFXSqtEcN2AnWBrrOW+B3Ea8HYBTMdz9UyuHJrpa9SDuY0laWxh8KF8YS//+CQdMfL9opaUXv877yuMI4GZSIBCEpDNS3jTWgNlrg9XntUAdEFvHmfkFglcyRZ0YwOdAkfbpR8fBNDMNA8+8h2ikZBfbrP3tkl5qvrLO9vsKexyGeXt/PE6jytypBj52cpWobgfIIyfaxW5BMV+vMJKOjNaKIeNE5ndLZFomiTS4BY0lxcwmuC8T7jKSuRq876npTSSCgZB62lsZBTeslrlPSjMkDujwNyj7DHa2CaY8RZZ67vpSH3WXQR3Xx0KH9vK6WajN8PxYVbqlNhV4CvwnHIvVuxX6PzVMy+lJXgezQlij16JIE0uTzPIKfsKyh81dvpunvQxdNk+pvlu3tpSBsIJUZnkgz1N6iywj3YoKguyHpSP2ewgWI0qUnWJIPTI0URBwzmDdVtHdRqjaIXYSf6fOX4/I43vOENvOENb/hb/+8P/uAP/sZr+/bt48477/yCP+/Lmu7yra/5K9Ibu6gXrqJWYrLNKcFKSDA9onP1iO4WRdIx6JGjgmSKrK5pnLJ0dhckUU42CGmfaXHghme489l9HHjZY7zv1rfyW7e+jWCgmGn2eN+7bmO1VyPflFI9EjlHOFlMssbnn835w7Zq4wadWIkdc2bLYCDuCnIZuAXJL0L4DZyx8gBQBhJhl1JpIJ2UoCd0ah5BSrmh+WzfK3dUl0QqcTDnUaCC4HzMvj1naOoh8/EaeaEJKzkXb1xgb2OBS247wgc+eBMfbl8JFj56ah9rowpzrS764SbV87pEirKGmNiYEGwswbRs1oIaekkzO5mh44KomkEzJ+gGog8+8s2h0L6kYDhXYGIpoSfLUlbUzsjEIyomMRQThbiMFvI5NrTkrYK8JTbbHk3PWmIUVDq2us3a207Ha7J4h26DDdtiuiOGR6Lc4OlEoxlTam2nE6KbG/YVl33VIUY7RwzmgFpOHBT085hPLF3M20+8gNwEfNVVT/LxZy/h2x/4Ht5/8gqax8F8zQrffs29LF1rqSwLAufVSpI1y/JDG3jNZQ9w4+1PsdhrsOeakxxdn2bQi7n4Lce45OajzHzNs6hUccfUM4TasPiGA0y9/AybX3aCN770g2y4Z5Kvf/1fs+sXnuG6RyzFY0+XAy2rC61g8pChf3HK2l3SaBN1hFcf9WVcTTweMX9PwfquWJRJHCLlx3A4gO4OK74EQUocFBxfn+KOy54Zl6BDeX/UhdbRkSDRdlxFMqHoF2vHBw2Hls7OClFX5BeXrgjlGXmagR4HWdLADMMNIsl2IY2s5DNbCczDgTjyAihjy3FSztlIlYk1CkysKCJFXhHVJD9fC/d6OX+h5Nt6NLBMAtNxUKkLiLqG6nJB0jbEHXFQDfsGncu1qRyG8zlmKhOKl8LJ2rlqXKFQuSJZUahhAMOAoBfIWtgyoqeeKsLuuBFaZ4q4LWYxtlEQdEKG8wWDbTmV01EpbVokgjxGbUlUhztTbGQZbU+J97axsXX31GIKTRAZ6hMD0klDsUEkAYsKhGuBWw8zSXJGQnUxEWXTap4GZFkArhqkowJTL4hXxgm67xExEc+b11wQoHvlF5Sbly0Zn0VVAAJPhfBrlrlgLVFOLi9wNI6wJ2uCziTBCYZC2/OynybGSYzKs0+WVelq6huXffVTj8bJmSpE2clcJ6WddLYQWsZsJsZr5yMG3YT1UYWTvSmuaJ3m7sVd9LOYNA8ZFTJRwvWArR/PySerVJdy2rsqxG1Rh5HKhWU0FTq1EVtSpIx+Pn0ldImuTzLzutA9L6zgFsl4vilLaf7kVWFgXGmLnIKJl8z0dCSfrJRa5Jn0+/imzWRZKrA2sOWcUXZcKda5KKn4xuywB5VFocgUlfH5o46itjBOsFUhVDkbyLrqqyveIdZTXrwMY5646pIHxarjnrCoL0h52Vyduu/qKomBE2jQuaV1zI6rSENpGE9bQjfVmbgmr++Wilsxk0ulOLBYqwhqGfHEiEt3nOFL7bBAgf6i/3whdJf/G8eXNZL+iRvr7FCPUdxxHRs/cS/62svY/NZnuPvDVxIE0Nstdae4A+uXWPRQUVvIOPoNmvqGHivHJqFRkMz1Odaeptka8MlDezncnuXEwY1MLMHp5+aoWegu1wjWQwYXpej1kMwoGidt2Wz5BR3WErctWUMazOKO0yh3m4O3Lved5n4j19Zx6wJZBLK66yB3C4K3vcaXVOvjRQIFlTUr8l8DwIhGtBiriK19XofKsmJUCMXgxMd28Gd3BLxhx1/TuXcOs2/AqfYEl02c5YkTm2HHkMtqp/mTScOB+aMkOqeTVzhx8Qz1JxNMRYIFE4vpkHDR9bgEPRC1AOHTWmgLapfVJQozkUWNtMh1WTBhUDav2cCiC0V3TwGFoJs2McQnI6rn5Pp7241YnGPLe6BHmqgtQXXWlPsgPFN53b/PxEAxRlz8BuNdNU0oG0NlRZoqw4GgUyuXigti5yJBB31j0JMf2cvPfduf8f7dV/PokzsZZCEPHt/GL97wfh7rb+Ndn7qZV992P5s3rHHusY10Bg2+7nvv5uHVrXz8F29lUwhBajCxFoQqhMGcYupZyzvqt/C6F3+cepAyMiGHnt4CwEvvfIbHulv46kNHuCy+m0hZ3nHHPO1f3c5ckHN8aZpf++zXkDcNS/vraGU5dWOX4396JSwK9SGvyRyyiSFciBhslQgo7FEa8pgYZp8YsXpxQtqE3mbN1LOGiUOKdGKcJA53Z9z75B4en91Ef71K3Eg5N2gRpHKekg8bQNDLGOysl7z0yopremsZqgvSO5GsW7Dyus4tk4ckiF3fKc9/MC10pdwlo/J3CbDzhihKhANFXpU/o55l7WLRWvYBjNXjpm7PSw+Hgmz7QF5jMcG4oRilxs11XgnG0wFcY7gy0ghngjGdxuoxBSRtaYpIdNNhjGr65tjudqno6A0pRT+iaBQyV+oS9OrIwIkqgy0FYUeTTRlMK6dyPHIIu+iiR21dNh/GqxK0RB1FvB4x2FQQLwWk20bkjYCiWRAth/K7kzm6H6BmRoSnK+QbMoJKTpqGhI0MHRiqk32yPKB4qkVmq5hNOWqkyfYOCI5V0bmrWizEZRWsqEj1Qg0UdhSgW7k08HZDMIrK1g5hY0hvZZJiJic6L5GgMohuuh1XD02FUhfbG7Z5VFdfQHfTqVtXPc/aNUNm1Qsog1UZh57mFHdcgOboNtFIkOjRlCVX46Zmz+32kp9+/S752cE4echaQGhRDzfJNxeEU0Na24bsnVriyPw0a4/MoRYTjplZgthwbHWaZmXEMA8ZjiKG6xVUL6DahmRxSD4RE/Yywn5AOhEwmtBOilFRP2cYtZRQXFxzsx97PlFRRoCAIBOllKxJaawnVRFKsyKfCJnq+PuWyYejgRjX1GkcKo+S55NOuDniEPaiCkFPE/YkmTIRVM5pRtPO/8Ktqf7+kUnyIFTBMc1NOxlWz4vHg/FOsjTqymtRV75XZxc0j0mPiq+UXOhE6/tKjEsEvY+Gcmh7SYnruX/HMt5APkMqd4rRpCpdTv3YVblrXh4qwoGhdUzBMVi7KGI4XzDxbEC7aGADS2VLlzPv2fn3hhhfOf7vH1/WQfrh/34dlS2w4xsf5LdOfJrD2RP88p7Luf6ep7iqeYq3/+ZLGU1D6lDhicdDztwSo+sDJmsDbnnBUT55Yg8TtSFnlyao1lJeeelj3HN+F8nGPu/72rfyks/8IMXGgsZnm6gcemFI9bQEXUFqabzr3i/8C1jLYFYx+0TKcDokbWjq53OG07KjyyI5NlTwXfdWQepUNXwzD67JyRudeDUJj1YNEmcak0PF01saLthEkEBrBBVMJwzptEW3Ukw7JrlpnTNrE/z0Z/81IbBxps3CYxtY3Nig8myFq7/6ae7r7GbTxYsEWD59djdhYFDa0r98SFzLyN3GEfQFfR5sLqCekxxPCAaQGMct7YlShR4p6EVCWRlq0Sw3iqJRyLU6BFBljg+beZ1cjbGKrGVls3P3sfFsQH+zKLaAu4eTwuGNV7Vw3JGFOGtZkiVn3jQaIyjgzUDkWWRzgt6nTagtSLBYJIpzN4+7eYKeLuXfPHLzH//q6wjbATNXLNHpV9gzv8g7zr6Afzn7LHMXLXNb81ne9/RVhLu6jNoJ8/E6tdmUv2hso7JmCIaGygoMZuXcVsNwSlFZULztHS9hsLWgfjSg7pCtv7xsgr0PZPy7R1/J/ESbE0/Os4d7sTMjTn5iO+mulMnjirXL4OSdO9jyn+9m+jMzXF59kg/pS+nmdcKu5vKrj3Gu22Tn5ascXpsp7603BUlWYX1XUmqON5e8q6A8Kxz/sznZp9upUE0y+raKNYqjSzPo+niDtdqjcbqki8w81qOohVgVUySCNnmE3ypVyoaKuZClcdbQ2aLLiohvvPJqD0UsyJagyNBYVFRWJWmeftKWNBQ/rzwCGo4uKK0X48BZFaBcCR7GKJ3njutszGM3oUOBnByqfGf1vCZFv3nnbuypwqIdeqQzOWfWsjAlAbqu5JhBjKkagk6AXopLTeZ4KSDdMUK1o3K8W3fdNrZOcQRACbJcM9hQEbUVlfOB0G6OJuQ1S+V0WDb7VU9GEsC0q6IEU4g5kSk0lXrKZH3A4loDe6JGaIDLOujTdYKhIjeKYkMmdJi+cPdE/UaSaevmabgeYNdqZFM5qpGjQsNoFNEfhlR6imA0nm953VVanFINFmwoBjcXUoiMC6q9mY6vtPhgOq8hKiKusuERYU8X9D0Tw1nX28CYDpI7hSusk/ZMKWmK6aR83sCtTVF7nBzMPDni2NcKvzxcDUWBpB1w8OvfxocHMSfTGb5n0yIP7djJR8/tZ7oyYG1U4ei5WW7ecoyqzvj4n13P9C3LLJ9rse3DHQZb6kKhrMmeYgLlKJSSjHa3SBnCG3H5wDduU45/qwXljRzgYyIwuePvT8n38IGysm7NjPw4l0TmwoqE70Xw8+RCBZZ0EryGuaey+MpG5J5T2HdrczreF7ULbk1oibpqXC3IIHRz3RsxebpN3Bknz1HPJWbxuGE06o557p5+pczY56BUu2E8fkrai3Jovq+Q5OO1IrTiomyi8T331aC8Lu9NWwqUJquKe/jkc4bsjCjyTD6tqS4bsE0yM+RL7bBWYb4Avvjn/TlfQdL/GRyVAvXUBAd/+wWcKx5ke7jOkV++GW6+h/d8+0vo76e0Jm8cDMtGqeSZKrv3HOHsoMVrLn6Qtz12I/Nz65w6McPSpgZL63WiJ+r8h61fjT1XJZsbks9K6b5xVFNZk2Css10ztWcX+eGjX9DlF60qM0+m5LVALMwD6G4JCZxVuVdrCB1P16NMftLnrkPeuM51Twnw/MsLXdFUPuZnpk1VNrgEI8toSlFZdioaqaClAHY5gcmMSpgzV+9yci+kp+rcvuk53tetcd/7ryS7ssfLZp7gzXe+irkHNNUfOcxFU0uc7k1g2xHB9IjsRIOkI9JkNpSArXE0oKiIvng4BDw6kUD9hC7tnvWaV8VwCgzrIcN5QeIoFDguu+c4oizxqsYk0sgKsmFq40qlkaD1tpVDLxCrcIkPROataqCRk01rqiejUl1HyrHSFBf1HKq7ammeSjGhrLCDWWny89SJsD9G7DyvfbDZMLdjhTs2H+KHZj/NbX/+47zmio8QqZyjI5GYeOOffwff+pK7eKK9mVv2P8fdq3u4dvI4L/iBh7jnd6+j6txQgyH0N7kNsgs//h1/RqRyzucT/Nb0baTtmMZzEcd/8QBH/sqy+yekd2Li+7aQ3bkD+0xMOmmpPxuzdkPKxIMxG/7n3XzVk20ebk9yZjDJtm94vByvj//GjWzatUz3lZaZ5Wc5/osHqCzC+r6C6ccCauclaK6fM6zs19SWIBxYBtOCeBchNFYM7WGELTTT1T7dVkKgDf1OhaZrBtWuLKwsmEog1aUAilqIygxRz9DfEBA4elQ4kGQgHBSlQdeoJRWA2oKVQDihfM6FKGmN+eouWB1sgKQNKzenTN8dl0G1UBBkzmMpDZY8Z9k/Wx94+/NVFo2o1IRjOoyJAZdEaEdriRx/16uRgASI5bg0IJacEvCDfJZVQg3JM4k69KkKpmVEgzy2hF1N1IXBlgLVyNArMdGaLhVPTMVgQ4Puu0jFzaXBfEG8GpQ60EXVEK/KMzQRDLbmhOvOGbgyrnoUFUu8EGGDkOol63RWagzWqkSNFL2zR5YFmF5MOBxrzEcroZiRzRRUzohClE+I/Lz2yjzhWkgxnQulZBRiLQy2ZsQL0Xj+W+H8kjtevBnLdHq0vKjI3Mwasj7mDUkwdSrrbElFiuS2+2caDC+g1MRjWUIbufXX9zi4RMwbIfk+gSL21SBZFwYbJCjVGfQnYDiToIeQz4+IzyQM5yymZrj0N7+fwdYcZWHrrkV+ee97eOP+Z3jL6j5+674X8gu3vpc3P/AKgmNVio2G6CMzbD1dsL6vRbKSs3RtSDCEiSMFeU2VMp7KqDEn3yUoJoRKx44lgNW4suBpkTqV+8MFz8mEbu/BUXcKRLowHFd9Lmza9pUxPfI9HvK+aF0qCb6/o6Qs+c/Q4+dQVGStuPCZqlwkHD3XXZkxFcUG8nyDkQu23bP2//aypH5shD13zkKuMYshc4G+V3RSRt6nkHUhyIRTvrZXl5KewUDuFa6qEA5tiaIrV1kp+1+M+26BqPzoAtoTmmRNfk/oqYrONk3UAb32zyNQ/XI+vqyD9OmZLo3dfc4/MM9PHPoGzixO8l+//o94609cxEv+7ad5+123MJyVwWxqcMnLn2NYhBz55E4eOLON6Uafw7059mxe5NDBzXzjjQ/w7s9ez9R8G9uuc9e9l2JqBXQj6gtK0KQ1S3W5IKtp2rs0T//bDex9wxcWpKdTMUUsHFZloHEmp71dVjoJCGyZqcddx0MeURoY5dUx5y1rUjp6FjVXfvSBTkxJ64jXZZHTTrFgMKsIR+KOBs6wwiI23hp0O2Fi+4DZSo9D3Y1sul/xod37Ga5VmL1lie/a8RBv/vTXcdt1z3Dfxh0AHF6bZZiFUCsoVhPU7IhRJF/E1gq6E5ZoOaK2f5VWdcips9NUjiQMZ8WACAW652Tc3IYw2CDa3FFXQeE23tCWkJbKFMohMtmENJR5syNlAuERarCRQ+YLBRWD6ogiizJOWSK0RAtJicTYmuPezmbUjwhqiPWqOYr1nQn9TXJub63tm64yRzPKq2Ntb50q9k0vkNmAe4ebmd61yi9++OtFQm9Xj+JslaJVkNmAr517lIPDTaQm4MxQIKuv+r7P8IlfOUA4MKxdZ2mcVNCWzzyft/jth2/jh6/9BEFgaD0diQtmYimmBZbddX+NxfMrHDs15zYYCWAqzREb/ucDvOaZsxwebiBUhoVb1ui85iZu+LcPsZZVWfrDgPhD0xz8yTmRjDviNp2eLhu8or5s8JMHnYZ7S8ZV4FQN+nOaxqfqDDZA5yNbqU5LgqMdPzxuy33yTdInXlohmyyonoaVSxJmnhhQXUzpbqlKojKA7nxA0rbYVL5LODTUzqbilRBp6ucilq6IywDYl+o9J9g3XaItvY2iDJS2RD6tRF5DCZC9PrT0JXiE3AVxmXVBgaCV/Q26dCTVGWinGmOCMc1CGZmHJhKk3Qc98n8uWPIqLpYyapRmVpEozCcVqlaQzeRSWXI+AXmrIJ8SgyKbBlTWdFldi3qKvBqgTCC0lQ0Z0ZnYKTCpkiriDx94JisKVmTb6e/MSM5FQhNyjpsmFDfZwTOTsFEgZHO8RpAqzGQBkUihWg1hI4N2RWgjS0EJKpTcfzvWtxa+N6ilEFVEIn1YuKAsks+P+m6tC+SZmkRoEYGTTMUn/vm4IR8o5U2DlLLp0T8nrxiU110y5gItb35jXFDuedA+iAwccorXzI7cWKtDVHGcbofGTz1j6GzT9HYYzESOWoukz6OjyLTI2Kq4gGHAuYc38V33/5D0EowUrWX4z0e+GbvBkM7l1I+FTlZQU1kp6M2Hwn3OLMNpUQ7zPUkXGu+Ue4yr2jRP56zvCCVwdNzycADV8zhHVEf3cDx2b/5Vunia8ffzyj0eSU9b40A3nZJnrJ0UsL9PKpf5VyRuHc3Buw5LMz6lYhS4c7tkyPP+PX3O9wb5+c8IsqoqK1UmlKEeDhjLHA8kWbgwic8aLikYMNZRd4lMmYTkUuH0zadeR93TgqrLrmHUJfZegtKPqaw2pujYADFacjSevKZKXwZfRc8mvzSD9OKfoF3ynwsn/cu6cXTqG56j+tKjXH7bc+xpLWM6ETdUxE3qz99xG1NPinbw8IUdzLUdHj2+hVAZvv6Vn+HSjecZvGcTdz2wn8Nn5gA42pvh1isOsn5kkuEMzF68zNzdARs+E1A/Z5l9VJqd2ttCRi1Nbf8qYUdz6mcPfEHX39kSktW1lK1riu6W0DUujZG3caOZLZt5qkuW9etT8oYza3EyV8Y1cqnigmaoSLrU86o023V3WNIJWRCiniw6WU2agjxv1wYWs3NAvjEl2zHk2Kd2MBt3uXHvMYKRZfDINEpblo9M85dnLyOoZdz14D7yNGAtq/EHl/0hL5g/gc00uy4+y9Y/i6CeE69qkgWB+ne94AT/es9nmav2qDZGjKYN1HNUrkXKzaH5ym2QOhXt3NGMrMo2tJjYYiJHjXFlbf9/9eMBlTMhyfkQNgzJWpAsa5KFAFMvRHM5tEKncUhbkYi9dF6TqkY2YZy5Dkw/FJWKL+kEpb7u+l63aHZkoy+RtkTUXjDy+8FIXovXFHc9vI8/f/Iq/texO1hZbGJaOUXNkK4n1I9pJp4M+eDbbuETq/vo5QlXTpzmL+6+ltSE1HTK+X9R0N4eoDNFe48ha0JvC7zrrS/hom9/iKWsgbGK/rzQGPLJHEaaxl0b+Phzl9DrJzAImP807Pn902z7yNvIqPgAAQAASURBVDrDs/VyXNaClDM3tQk3z7P/R5/gLw9exrmb15n9zbsZTAfUTysaxwXlwYq6zGCDBJrDKRnLNoC4Mx5rykgAWl02tC82RB3ozetS5i7uyM+FJXGrpFmsfjwQHmgNlq6usnBtldGkBBSjafnpblasXBywvjtg5eKQhetrLF3bpL27Rn9DJFJ/DrHzFShfZg6GsmHbbUN6+1Oi+T6VZUs4ss6l0aH7qXxf8IGK8Mj9Jq2KMcoeDsdc9NKfIFTkiSiCjCZEdtHLOwbDsTGSR15xfSI+mADKSkERyz2OOqAHAWYYkkyMRKo005ipTBRc2gHRYoTuB4w2FvS3FWQt0Y1OZwoJ0FtGjIpizwUy5K1CpF83jTBVI+pYGwtGU5asKT/JuYh024iiYRhuzrETGWZ+hJchtJlGZFHFwEfgUoUaaaLlEHW8Sr4hQ+3tku8akE4X5BOFUGCGinwyZ7DJoFP1PAlNE0tFS4+UoxOpcp0oGz9zaZgVDwYoapa8AqPZokSGfWDklX7873rtfOP6c4qao3C4JuSSKuMTf4fGK0vZ6F8qQjkOtFcoCUaiyW090p5I74bORTqzciwmWtekLRlvlQUF0ykMA+k1qNjyuRVVK86906LNHi+GqByStmXiUJ/hdIAuoLdJxkzomBE+MPTyjyaQCpYSfISspli6PCwNttIW4wqtr8L4atJQ5qhQzMDTvrAXBNIO1Mhqngo0vgbtAmlf2VVu7BTJ2DsgcLQWG8j+5umGwUCeixdPKFWRPGpep5xTfu6rQihKvoqSNd3vBxIIe1Tdf9eiImMha8qcTlbH/+911vO6/D1Ix9UCzz33yYgH1tKWEufjYpw0jKYonW59k2zUH1OPLhzXnrYznJHrqp+5oNTwleNL8viyDtIBDv3v6/lXc4+xMqpxy1UH+Z5ttwKw+b/cTW3RiAbsR5roB5vUHqny+NPbufP0JcQ6Z+KbT4kU13LCt998N4eWZ3n2d/YTu5LwII1Yv0ixtldx2Q8+Tmd7RHUxF3OjrTB6ZIp4XTH9jEF/jsL2zzssdLYpOtsVWXNskBOk0lAajGyJ3KYtkYJqHS/4D//+94lrKVnLliVBb4edrHn0XKKJ4ZyRjTK2jGYLimbOYJNlfa8YynR3GNIpy2CjLAbDOYMaaZQ2BIsRaiUmvmqNg50NXNw4z9lbxBUvWI7QUyO2NdawZ6vM7FolqWS8oHWEXzn3Um5oHiWZGmKt4pNv/W2iesZoc8amG88Q9DXL/Tq/9fitPPT0TqKwgKkUMo2qZxAbqBjSHbLhezvnC9UaVK4IuhqdaoqJwnEgpTyMUXQvzkR2rmIxmVAfRptykdXqB9ANoR84LqQ42nkX0cqCNP78+St/jbxpGM5aXvMDH8W8oM1oW8bUQVMGjV5LerCRUrptNCeqGZUlVSZDRSwBVbwGyUJAeKLCmXu3kJyICc/HqEJRPRVSVEUnWd2+yjMrG/j66Qd4bH0LV159lE986kre99Y7qB8R6Kd2BqrnNYONhtlHDW/5t7/JrvtrvPsvbiPQhg1XLPDNt9+DyjR733AfsS4whSJbqDL1eMDSlZrnXreF9sVNtu87x+G3X8M79s3z11dU0dddzrO/sol7/vJK4iernP+RAyy//gC9eaee40q0UV/Gau28NDH6JrlRSwLJTfePaO+mNFPJ6orqWU3eGOsMXyg56DdNkI3KqyR4X4C8Mi6ZG4demlCeRTbhgoGWQ0ARSbnODqlUhX2onbfUz1qaJy0TRw3NY5bmcWicgvgpMeSxhxq0dytW9mmWL9MS5ASUtJsgo2wY906kEjxL4B6MXBAxugAVdoGLLizaze/QNYMG2TgQ95QNT7GxWhFkdqwMo+TehyP5/XQSTGyIVgNMoQiqOcHsEPqiSR7u7sKuHjYx6FaKbqXjBriOlkB2qDHrMSYW5Dk5L4ZFOpNmzsrZUJRMloWbrnIJttNpx9epFVTOhtALCU5VxgFcJyA8kxB2lFS6XNCqCkXeKii2DqlPDqjEGUk1g1oBuSI8H5XJGkA6l4v0HlL50SNVGr35pCZ3gVoROz3yQqpW4NZCA2hLshw8Lzgvn40bU2WS5GkrjjdcmvY41Lmoyu94ZRIvW5m2JOiyoRurLtDLHcfae1v4ikk4lICrv0nQ6Op5QZBN7JRnqqCWY4JugE6V9PS0Nc0jmuaxMTgR9iWAbJwR/v2ZW+us7JeG0GTNukbJMVfbVxUGG+R71k9DbbEgbtsSyc6dZKqX/NUFZWXIy/gWrinSO+lGrproqUXB0KmgQKmcZcOxMoqfJ34/tEokK4NU9qPBLGOgqhjTh6IepbHShWPFjwtvbJVXJZD3fhfKjOUefaIUpGMFG0+Ryauy7vjg3uuZ+2QRnwhMULqrRh2nuOXpjcU4yfDn9c3Z1n33cADVBWlG9xUcX431IJrKxmtk1HXUOBesr+wP+FI7LApj9Rf95wvRSf+/cXxZB+kL338jwVLEL3zqFeRWs/KKkHDPLg7/8TWAQwtu7vDTP/HHBANonjJctu8k1iq2VVc5fe9Wtt1+gq868Ah/fvRKCqMZzLiFPbJ01qqMNuYUVcvSsMH6CwcsXB+xftF4gZ97OCNezzGDwed17Qd/5wbW94prXHURsLJgFhUYzMjiOpxUpVSXN3ZQxvLDn/0WeLbBxEE1DnRyCXCkeUY20qJiSZY00br81E47VG0oSiv9zRK8221D8pqluzejsrXLxLZ1tLYUEwUqV8w2ulw1eZp2XmH/tcfobxckZ/rjFe56ZB9oy/K5CQadhIe6O1gaNvjfxw5QTVLaowp73v29ZKsJQSXn3GqLaGuPvNAEgaE6PWC+1ebrLn9U5KWMonI0pvlYTOOxpHyOKNHH5oI1KRyIdJwaamk2M4r60YDmEQ1WkW1KyTelqECStXgxJOoo9rx74Da7gOpZTdYSVY9kBW58yZOyAdUMr/w/P1rKcP3BH7+U777kXsLFiMWrNP3N8jx8g1VRM2R1KcHXTolCTNaQ65ZgdoyQRh1RG0hW5O/JmkPMcFzItiZ9cIql52Z459JN3DJ9mC21Nf7FbY/T3m1LdGrt6oz8mi7No5rGu+7lo+0rqAapcJut4tXbHmZrvMLeN9zH9x96Dq0Mth8SdjX9jW7cFLB0heb8ZzZTDEIO/7ebOf6nV3L0pzT6VIV8fw9VjMeVR9T8c/GaxPWzBa3DtqSQeIm7td1JqaBQxIK02wDSKSNoUCgViOGUBARlqVwLKu0VbLwLYNSVcw/nixKJ8shZid5dgKYpA7VzttRyNpGf32ACxYUV08YpS/OYonUUWkct1QWYftqUcm3ewEi4u0pQcy3fy0SQNhR5Bdq7obNT/swagtwNpxw6GyjnFCxJuOeZSnOyKD4MZuXP4ZTQiPJEEhwTCB81r0jCkNWVazxT5A1DkQYEkWH3xiWi6SGqUGQnGhQLVXQ3gHMV1LkKpl4w2JphElFOMtWCsB1gGwV53ZA1ZYwN5guS1QsC4lyCZBPbsrckWIiIT8bSUHo2EFpD7ipd9ULMxTwFDGmENLERB9HlmOHhFt3Dkwx7MXE9Jd7YF/rJRSN0X6pF8WIo32W6KNdmn7R4kMInRBLUqLJCYyKhMhU1Qz4rSbp1id+Fe7xvGA1GjKkxMeMKScWWBjxRm7K/x2vrB8PxXPDn8Aitd7S1LpkUgytKyT+PshYVAX/y6hiJzZty/cFAHJuTVTCJpbvDMpwZB7j97TnDWVi7SDGakAS2et6BGwbyqip1vcvvOhzTy3InO9jfKHPCB+M+6S6pIg5hDoaUrr4e5TaRJCV+zzKRo6YEF/C+XYXMa7HXFu3zklmUUKpK07gLGlCN4/R7c6S8Rkkl8Um4D5A91UY5Xrxf6zz1plwf3GtZzVWda65K5n7HBBc8z3gceOuMUmwgGIkfSeFpNY5rjpZrzh11z9Ol8ipjoz3j750qpUM9hdWLFehiXPUbzrgKubu+8Csy6V/yx5c1J72zp6DWUex+0/3kQO8bbuLyn3iMp5+cAaB5uMO5Ey3e8p5vJZyE9Z2ay2ptppM+7/nkTcQpPHdqA8er06Q9WYX0Zss1NzzHg8/u5Ma9x3jo1FayvIJWltr9VarLUgIvEkWyXgg39AtI6CYfjWjvNUxftsTXvfIx3v3WF1E7LwHLYJOhdkaoOqrvGlnqMrHXd4eET4dUFqUUqTMnXeUab0QKz5ZcutGsEfnDqkEPNEUzF61wbaGiiCdGFJkWCkihUA+2WL8oJViJYDrDqoDjj23hOFuIVxXDPSkTW9cxfzVNUYHWMwGjacgKKTnfeXgfF21c5NzhGaga4jMRcQFZU1E9HGIjue6+FjfEsA+noianbp4kaY2oJBl5mpQbl8oddcQtyKrv7M99YAZE65q8aQk7Cp3CYN4SrgUULaBiCOO8DDQAVi6Vk+VTOcEoJFkSlK+3w3Ju0CR6wSrpwUmH9CiyxKBuXOf9p68EZGPLqzDcmlPsSSmWKrLYuo3MW1j7cqWoI8jm3N8IzeMw+5t3A3D8Fw+QrEBnb0Ho9KZrZzTDGWmA/cx7riZ79WPsr5/juf4G6qcF1U0nIFgPGQHFjbJS9/KEzZVVJg9ZXv219xKpgse62zj3xqv5PysN7n7qIoJGRp4UBMcTauckEM4mYLgjJT4bi6Th3Q1aJwoWvrkPz9VLFLEMfh1KGGTQ3yBc4O5moYQFI0HUVSGmRWkLdv/XJ1l55aXjgGYE9rouxVqL/raCeDkgWQHj0CVl5XnrVAJ3ZSSoV4WSqscIaieDEi2j4aoaLmCJOhD2BU3N6kKJiDqUKjFYCZazmgu8M1t+v6hnHa3Flk11PqgQd0Trkkbp5TABBIV1CJoEcuv7LFQNOsnpbQe7kqBmRvSNIqlm6IeatI7aks7mz5+sGSqrboGwFhuoUglmdZ92gYottaLjlYB88wi9KnKKphORr8YcXN/sUGuF2jTEFsK3D+OC9HyVoB1gNo2wlQKTBqhugKkYVFcCdTLNaLaA0NK/OCVckPPrVABJVcg9zSqWQMk1RV1FMITeLpFrVLlUhoxDT4u6cU194kyKD7QjcR4eVSOKcwnxng56Zxd7soHVVvTekcBUjwR4KCX9jARs6YRLAhxlLRgqRxOQv9vQEvQ1NpVk/kIaYTB0y7d1NArXyAeQt2xJWYrWVZkAmmSctHgTMx2qMmj3cn0eaffBJkiwrwr1PKS1cLb1Vim8dr6JZL3I61Lp89SQZB1soOlvNgw3yT0N+hpbMSXSvOHhgpV9AZEbk54vXVTcHClcD5MLVqtLlryiCIYGlQdgxpKHOnP+Ezll9dAfwZCS357Xx4GkTwLC/pi3jhnfDxij4v05eb6efhS1pSrp0Xj/O/5zfJ+V53t7pN6v7QIISD+MKoBg/LvegVT1n/9dspZUMfKqex5V1+zpnp2n3gFlg7INhLroVX/E88Mh+Jmjx/RdNcVzzBWk05RUHxMKTdHft6jj7ourMnjjp7J6Ux+PTd8b4xXMvpQOCxT/BHzxfy6c9C/rIH3bhw21j9/NO0/dw7d84/fx6f/xW+z73e9n789JAGQeepJdv7KNo2zF1HJm7w944A+ukix2r6V10yKLy030Yw2SECYPWmrffZoHntqFrubEOv//sfff0ZZlZ3U3/Ftrp5PPzbfuvZVj5xxLsYUSkgUCJODDmPQaC0yQsYyxwTYGG2MTjHECLDJCBAmDUM6xq7vVOVZXjjenc0/ecb1/PGvvU7LH+433G8Poa4a0x6hR6dxz9tlpzWc+85mTeK1M9apm5cGDlLUNOIkz3J7BuAonNTiffvz/p/1OH7iT8pbhDa98mPd98T7eM7ybo995DldnnPzQEUrrmsqqIbLhRpknjHne6iutWzbD2gPWL8kNX1nPqJ/apn+giUoM67d5pCUlVoP5oItrBIAoQGfEQxftZOw+sM7VK1O4PZj9jMfqy1N025WBsHwx8WFhbovlkzNkt0b41Yg9k9ucX5pGu0KV6RerXPlylYoP5Zdvs6kbOEEKBnoTDiZV6J6DcSQa2d/RqOs6xJfqBOuaSAOBPKwxMiibAMEQnKGWjsOcuMSkVWThrmSoSBGNK7KjA8brfYafmqbTBLXj4r/gE9clDTHzMnp75DyUrrroFIZTht9+62/xUye/DVdnPHX3n/L7x2b4vsZacc7OxF2+45n/C+PKeXGHMPGYS3ePCxVD3sZPS7KoDXYZKkuqaCkbxxBaRnHXR6/y4n++D1NLOPIDJ2h93/30O5p4MmHyyx5hU7oEKoP+Qsbnzxxh7IYBX/792yi3Dd15WbS9rkKlLmpdEMCn/+Iufu3vv5vP/O5D/NS/PcvDYcKHbhjnnS/+T/7tp78ZlSm8RY9wb4S+qc3guYa0XHsw93GX9TsM+z44QGVw9YEK/uPVgqXq7xJG+Nphs6gkP0smevLBpADoYENAZ1STLsHGt90gDFhoyNMvqx+u2+Fbh9I2xTBlZjXcuX+yWKsZSuu6YJaG06JJ9rcpwABc08YPhN1WVhKSt7qxkpOc+RvMQLsJjTMKv2Po7lGEY8Kml1qw8Q0hputBkKLsNTvxlIM7lCChuKJHw6AuBah2hoqsEeMGKdFaGTUWkYUOQSNk2POpRWC0wh3kgB9ST5GWhDGXFMJRk9SJrvFPj4TJdjsy8EnfJQuMSL+MLb6VgUSjY02KD4nCVFLizaAYpjZdD6enSaciUA6kiqye4K3Z2YtpYXD1tidpjdey1qmwiHnRlv8usyOq6O+mAUS7BdlrP0WtlEinYvI8A7cjL0xLBretSWoZPNEgubknEhmjZAC0IpI93RWKtLDo9OTa0LEqLE51qAo5hWetNQX0GBnOzlSRIZHr0Au5hBoBtcLTPBoB+uJ1ea2Xs7JD6WgkEylOTxeg0h2ogvHMfCm6nIHMvKhU4Q0hzSVMVpqTP9NlCFtCt4yyQNYyqSqVVNK4LmFWST3F23ALBnbrOodg217n1pY0CuQ+ze0DwerorWY92IGk6hQSH7Rl2XNgnSLXpiNpxyjrOBbIM8DrjO69zB/di3mBouwxzF1bMJA7xORzPNoWJcqIbOZaSVIO4nNttteRn0+texbGGilYx6W8c6Mt6C3Ye8v+h5bdzhzr0GOfP4Xrjzt6zuVsehogSafuiGzo75J8DaM0/o7d/86oqM899fNz43UpQpVUKt2O3Gtd2W5Kmt9T3ui7X5tinbvFZI59/n59e0lvX9MgvXTiJACnYp/d/+kct/zqDxPvzb7iNfobrmB+fYH6aZfBW3boX64LezM9YH2jjn+hRLAtALe3S5P8yW6cGwz1XW2++Ph1oKSFv/6NQyY+UyI1CieCqOmQlBVOqKm+8nb0F578f7XPaz92vBhoubGyyKcObuPqjKudJr6Tiiwihe6CkpRUM2rfuX35szswRHUBOxMvxPR3uWSeoj+j6c5P4kTC2GZerudWGFeRlVNMolCRxhloMs9Q3tOhv1jnamsGXPmuSaAoLbtETUMaGMprsghFe0NmKl3SY5qX7zrPw+v7OHdmjr2HBMzOVTosT9WZLve4uDPO6xZOMdjl8YGnb4NYQ6YYe8EpZA2BBVl9p86eLyUs3ydsYeOCMJq1qyEr95QkJMNqOsEC83oCQ9GU63KCSTwapzT+kxXGn8vg8UeI/tW98voYwtkE5YleXfVE5uL1ZKH5qW/8AO/40x8inovYcOocfPYdBFuaX8qEffH6wv6nZfAHIgMwO44MVGljbTBT3JaL0Ya4LgA7rsv+BlvghgpnAGNnQzp3zOMMFKlx4fhtbF8P6WRC+bIng7nzkk7oDCBoadLLZT50+V4m2gIOg21FacuC4C3FcApW33mc/nzGrxy6kRsed3n1P/hBgg99mdPvvptZ9z1QTild8Emq4F/xSZXP/IMR3QWP6RPrXHzbDM0zsHZXRa4zLd9XRxIgFNfUyGmoI05Ey/e5xaLjdY3cDxFUV8Vzuz8twNrrizzD76RMfudVur+1m96cLhi+/i5w+hSDZzlgzx0RgpYUqUkg/+917PGtMrIZTSiiwwU82cLJLsRuf+ScIv9mqF+mGMCMq3K/9Rcy0kDcgMovlGxwi8NwJgPHsHV7Su2cQ+Ypqisj3/PcGUTYPUUGZKnCnxkQL1XwdzRp4KFd0Q07obH2jNA6qmics+BZj5JJR0yrsME5g+12NfFYio40JAr8jHQyhoEjIThDB7wMEgOJ1YJ3RYvtdLQAklCRTghVaXIb01AXrGF50SWuSQJvkjN4+bClHeRz+rqQekQN6zvdkYRhnQmoCS77DOdj0oGLZy0zdVuWrXg+wl3xRXYTCIge7MpgswSTKU5fBirdTYdwJiErZThDpyiyjLbuRK6w22CPWTRiKo1risTJZFyCl/RQjkk0luK1HZsAOQJBRll7vb4Fx/nnIc+gwrs7yfXnonkPbPCXykRXnQ8zCsgbyazygjEfwtSRhKAZJ9djC6OeVOVc59KMtGTwW9J9zFyRyJW2oL/LKYpPtwfNi5msD4E8t9NApFlpPjZlwa4zkPUhHJf7bDChiyFY18rKCulLziTnHQxr/+q1KfzIM1twYKUnju00mTIkVqridSiOQz6r4wwohjSVkb97tnuso5HMpQgjshKWrCTXmL/DVwx7JoGVGhoLpq21Zmo7JbkmPP+uch1ZuWh9VHRmrnVDi+xMgT0e+XxMXMm92zW+/V5e2+YoKIjH8meP7DPYjkR7xLznHcm80M+99nMpoSwgFFr1nDx2+qA8MNH/N7Tx/69NNOl/05tB/a3g0r+mQfqF/3aIQz9wikk95EB5ky/c1cc/XSH7X0Gzgm/7vs9xf/UMP6nfxnStS5ppmrNDnk73oDKfzkHFm1/5GB/5zJ04u/vsXGmKbnmgGB4MadSHtA+UmXwuo73PlYCQtqF9QONEAZX/590EQN9xI1f/JVQ+YBhOKRZef5k7SpfZPjeOqaXcfPgKl1rjRE3x0Y3GDKUtRVRT9OdksM2JDcOaYjihCpZi63qPmSeHnPtOF6friF7TNehQC9uxLyQbuqAto2gUuCNNaXSmAdUMv+XgDIRVDsdl4a4e3GGq1qUdlthcbVA+E/BEso/53Vt8YfkQrW6Zu286z1KvgVKGzCg8nfL46X04mx7vf/Zlojcck7ZsPpAT18SZRSXCBrl9xeIrHYyVoITbHq3rYeVVLnqY4bXkuyQVYc2ML9p1r+2Q1FNKp0uUNmHnviEmdth4pQ/9u3Db8kCNG+B0xW7OGVgmciCFjE7gN3/9rZh9QKaoPVuitGkAU2gpjYbenKKyCp0D8rSNx4Q1ywLRwuuBQ1qWZFPjK/xtXbBGw1lDaVXRn4XJdz/O6r87Tu2SeHIvH68w8bwMM2ZuLJ2Cq0KhODHs3Bqj/JRjv9Snd6BB2HTwBjkAEJAXbMoD/mV3vUj90RIf+szt/KtffT/8Knxqq8kvX3gDDKVn6u8ARhbExVdJwuPmbVMcfucJrvzL4/J97TWbS1vCMZE6JFVZQMvrKa2DLo0LMkAZVxRJRRUDWZkHfidDJ7pofQc7YnPZ/R+72TmoaZ7PGEyJxaYKR4tQHnqioPCazgcDVUYxRFW4OZgRgIgbo9dkrrDS+cJuNNaNxhSa0tDXo0wCq9ulnOIOHLy+oboCalF+tn5ZYbRjmT1TJDLmTGnOKGN1vMlmQFxLUJ4B1xCPZQTrmrFzdiBcgTPMSBua2mWKfcjfy7Va4J3DisqK1WGXpIPktRz8bUeAxFyMX4tIY4d0aMGaYyBTZPUU1ZXzrlI5SOl8iOm7GMfgtDzcvrIseCagn2u+lwEzFZJ0PFRsY+8V6FzXX85I6gZnqHF7qrC6y38+LRuSmtznJIpkJsYkimBDiX637ReOVf6m7Gd6UCxI0sjB3XCEwfRBJUq8263dYs6k5/77/g7FEHFeSBgXKWLsc89okcy4A3kG+dsOaZ6dEAuQzkFf7q4ix46i4wE5+LdDk/UUb0d86WUY0xSa5MwzlhVXhWRBp3afLODKXHl+5CSEOxDtOI6V+ESK8ooUPc5QjVyKrNa9u1uuObcn915ch85uTbBjcIYGBylAjWOPiTNi6nPryLzQjOtYS9WRdCzoyHogYF4Vvt6DWQrP99x2UWfAALLaqAhIrtGkF+4vmdVvW7kKgJNReM8nVXFaATkPrtX75/d9fqzEQlbWFL8jxyG/LvL0beNQdPpSTw67ju2fjYDd3C0ll9fkTH8O8DN3xMLHNXnfcMIWEx3QgT3fdv9z5t3fGWndC3lTaudrbJFgtDDn+fEuZIW24NCpFBW5bMxcw/w7sdThX99e2tvXNEgvPVpl+V3H+dF98vd3nfwU/+nsN7Fyf5n5L4xet+sEvG/P7fxJeifxpRrhPpdyEHNpeVLcNXow8/JlPvjYbQR9xeHZNZ7b2YPXkTbg4VctkRjNP/6u9/MPH/lu0shBb3qUNuXhtfhaw3WnryN99sX/bR/P/M7duNWIe/ddYuN3biAcg9oVaP3BHr678S78KQibCZ0ooH9yHNMwlDYVzbMjb1+vS6FdTUvS7i+ti+QiaBl6cz61M8I6tW9JINJkkxH0XRi4qJL0DLWTkUWOtK4bEVmsUVs+5RWHcNLQvH2DnX4Z/UyNzFMMhh4Xtmf49tse47Yjl7nuNct8+8P/AICNrRpZ7PDixgxlP2Z1aYyragqTKrxth/k7lmn/1Tw7xzJMkGESBdUU56qPcSXlM6lAWssIthwkedGgIs1gTtiv8pLYgCVlSQHN9chqW5NUtA1oEm1ybSmluyx0mt9ShYd86gvAq1+QxS9oQVJVRK9qU/lcg94CbN0Vo3sO7rqHeKArakspRotVXj4M192fiZ7fN/iTA+K0IgtFV1xcnL4EacRVCCcyyiva+oOLHaK/I6t8LuVIbYtzMKUYTAhNnQ8JB21Dd7fC2XQxrstffOw3edtrvovSqbMs/5PjBSDOtdjhhMFVGc9tz5HNhjy4c4QXWrN0w4Awclk4tM7O+V2FFjUPQ9IpZAPNxV84zsGfe4xzP3cX/s5oYRC3IVnAvbYsmN0Fx8pgDEErpbPHpbQ5WozCui4YIQFschyNKw4TfhuGExpnOAoXMRrat0aUz4k0CSWfZ1xQ0QhU5E4aykou0rJNGB1K8qzXFq24zlevnH3T+QCXALGceWwfsOyuZWAnH/TtuRlJDK51XCiY+XDEfBUaU6tDDqeyogglBJXZ93Lta/LhMKWkSLD7AnZxdhSpNxpSdUJD7bKiPyu2l3lIF4DquKSbnvhmG9ChJts9hLUSWZDBeITaDChsIjeCAuTl4AwjrHhWMv+bNWXa8sVtKVHE4yluy5EWu1FE0zJYnvlGkoIbGc5AS1qpY3B6YqequxpnAIO9Ke6OSzQuYBkH4vGUYM0ZdQvPlEUDbvehPy/UtrvjEE2kRbGgUiGkjZZOVZ7aKsX86BrJZ3VUCm41IRk66ESjExvJHiuMBWX56+L6CAjn90q+ZZ4wwyoVmUPlqmP/XYoBt6dGoT1qtA+S8GpgoAsJhxtC3DSooSo82Y0DWcnYZ4oQG2kFUiP3SuOyETtTo4mreV6D6MqNUoRj8tn9GQldS0oj+U6eepq7hPhtQ9RUEFuAmYO/IcX1Eo6polByhiMXnXzWJq5ZUIm8hzsAZQFxODHqiOW2ikllxMTnTHGuW88tBvP7MWpQpDWDlSLZzk0O/JPcZrhKYbWYD1+6Q+kA5j+vkNmg8rqESOVmDDkgz4eEwZ4HTRGClg/E58fHqFGR43XtXJiR98vnqQqpkyezBKlnj8ukyFxyS0knhOGkzE8ELSuryZl+C+7zYKy4YQg2ZZg778a81Lavniada30kXrLb1zRIT0vyoD7923dz4M8Nf3n9YyT/0TB59xr8h9Hran/6MGvfdDszE21uf9VpPvf+Oxl6MH1JGNPhhKI9LFE/7RJOwFSpxy3HLvPi+kE61w24eWyJS/0J3vGl70E7GX/0yncD8DPnvoWlJ+bQoeLM946TefeNWGwDP/bGj/HuP/Lw+h7Pf+EG5j6/ys5t0+LaEIi39MQLGa3MZ/vxBUoBwvg40N0lPt3+tsbtQeeAsN/lZZny3/OGS5x9fC/ZkRbtxQaYlPKSQ+Wsx+D6IcoxZIEMgZnQwanEYkVoFCaGTGuyoUtlXdsBLEWrW2G83mdjskLlqqYXOThByvtfuJ1PNK6j7MVkqWZ/Y4u17Tq7JlusnpmiPxUyuavNobFNXlifJWq6NP0he777BR58/Bi6Fgub33FpH0kxviFzNaV1TRboYioewJ0c4j9VJalAddWwc0iSSp2eLryQ/W3xO8YxqFATjRvCKU1pTRVt0/IaDKdFUrPwiQ2M79K6ocnEl9dIzpyD/yyf1/noYeJMk3xsCicSmU17v0KlTuEP7LfkQez2pR3vtjVxVLEJpCIfiEuGcEIetJkdXkuqVq6xJa3p4bSAK20ZGWPdRcIxqC5bZmgoC07qy4O4fv02t89c5abP/BDf+76HefAWn6gJzXWDThRxA+ZecQX9DVdYAq7+7lHeePNzfPzFG1Da4LgZYx+p0PjUFoO/I4uIDFAJoM2ZTIAsEvopqQpDlrM3cdVGdjcEZAa2tRs1ZNXKXBhMy2LiWX34zn5dsFDlXkZcVlSWQlpHyrh9Q29BUbtiaF4wxXCb3/EYjtvF/4Y+M5M7rD0yh2cXo8gCjHAqE8nHZIK75YoUoCJ+2rn94bWsXT4Emks5jM79yaVgVgaxO3TUVySBDscUfhdJHk1HLXKdjpi4HJwLKybOK0Yb9ECT1QRJGi9FdVyisYy1ew3Tj2nRCddELwxYoCAaeq+XkvmapKSZOGnYuk4K8NJGrnWVdn4WQFrKBLS7BkJNPJ7iGDCToRTpPZ+sJCCbRoyJtcyEeAYTq2IoMQ0MWSkjmY5wL5ZJalkBiHXbtc4UMhweNU2hl0WB8QxJRYYzRVOtUIkuOhbRmJF7uO2SBobShi60wcbNyFwHrytApLtPgH4uWfG3HZKaIamnhe95XDMYT+Q/WTPGLPoFgw8UGuV8ODEHqOpSGe0b4rpcPzoTr3h/Q2QqSVXuCaDwQs9dg2CkS86Dc/RAC3BMYTidQi2B0EEPNP6WLlKfcwlU3MxkQDcSAJ76oKwECC3XH0jRX7DPoQC81vXyDGwdUWSOKmY1/B1FOAHlDdi+OcPf0tQv26TcVAKMChmZa4cTTW5GoApbU6cPaCExoms02XnoXc5mu8q+fmDBcza6L/IkUOmijO7BXN9fuMDYLlTut56ngzrhNcfdDm3mDjtpadQdudYm89ruRi7NSQJh9TNHFddZUrXn0Bb8Xvcr9yV36FKJOIbl8y85UWFcOd6VRVXsc7At52wwJaDfHdjjiFwnwyn5TsHO6LOdSO5bo0fFiY6g1FeEU1I05fKqvJjJCbo8Ydg4kNkOYpb8P4Cjr28vme1rGqRnvgyblK94vO5XP80fnrqHw9/5GCaJOfee2zn03SPJy9GfWGTxf0xSc0JK29A6ZkhWFd/7jz7MkWCFH/vLH8BtygPi6fV5jBG9GW7GZ5aOcsvUEtNTbVKj+d4TP8D4eI9bppY4+sA6nzlxMywMKD9ToXcopnrWIfPgT/7DGzF77ENDw3D/ODsHNNVXr9P94jSlTQl0SSqG3/2+/8pBd8jx9/0T3L4MF00c3qI/9Bmer4t0IhKgZzSc+/JenFgxeH4cdkVMzraZuL7Ppc0JWKqQNZNCB64SBVXwaxFR36PRHJAZRVxOcF+ogRZHGU8bwkScHsK7B5i+xwPXneQ7Jh+hk5X492e+kWo15Nm/uJ7gZTusvTCN31WEnk/XTVkPqpT8mOHZBmefOUj/QEztssMgFnccf0tLpHjbwe2pgl0KpyRQKGsmsF4mORqBNqztFYs3o8QdIvMFVPQXDMbPqJ31GMxluG1HgPskHP6DDU6/Y0IWrhXN9FMhF759ir0/e4LGk9D62CF64fXsabaIXr3MbLXDyc8fQk1ZbaQjKY69BWicNzZ0Rh7smSeBSFHTFEyhM7A2eHagL/PEf9odCDtiXENSV5RWFaV1CwBccBNhdUAWzcEUjJ2TWYM8/GM4m3Hj+AZX7+2ifi3g0a19XPjFA5h9A7rDMhOvXGF/pUv3FWv81uUv8ZpP/gRuJeKF1i7Y8nHbovHf+IYh2zfs48BPnWDzB4/T2w3BhhKglQhTl2tFcxeHylpK5ip6c7pgkt2BXahDsQPMXEXUUFSXhCHLGUxvMHLQCCegtKXwBobhdIATGQaTiuqiMOCDaduaD03hZ57d1OWOuSVcnXLk9es89fu3EDYprN10pIhmYvx6xNSnHHGmCEEZK1PSwkyK84KyWm5TLO46FZYt9RVo0JbNVpn9N+vgUmqZovWds+T5MdJYcG512kZJMihagrjc2ZC0I/7WquOQx8x7bV0AcyeyYMoYopoUoZGnGEw69nPk/8fOmP+tIAh2pCjYvA3ZmVhLOrKCoBwTxw7Gy0h3ZHCUqqzmuueIhrqUokKP1Bf70bQMTldDtyRSHCvlkuesAGK3ZwchPYOKwek5wogjhUlayUDpYggymkpxOrarUjMQQmlDF6w1QGlRNAh5Uqhx89RWiKcSKd7WXcJdGWhI6wZ3zSOuS56D3vGIG0Jm5CBd9mcEgvJEVBw7TKpUMevjbzoFuHQ7VhLkjwCbyhC/+ZZLGqiRfZ/LVyRW6lijl3PPPMNwLpWwpVihtLyvM9CktRR36ArA8hEZkg1YSOwAumNDmuKqwXEUUVOeKUk9Q2UavyX3rL+jiJoC1LevkzCkmcdiBjMuqQdZVYsDWDICtUqDyWyAjp3j8HoyUxLXRjkAmbGpm1W57pOSyFiulZ3Idx3JQ4wjszvGdgUK+8Tgms6GnbVQttOWd+ByVjoNBACrELKGfTgqVdy3+YCwPDjtb5n9jETW2pwcyKpWimMHL/Oi0TjWUtYOoZbX7bMr0YVjWM5o53aP0Zgp5Gw6zj9DiBg5tuKQU3jh24IoL/Ayx2rbLSGVVKRTGE6OvoOOFW6XIiFcpXJuwnEIGyKn0qGAeKVG+Oelthn46mjS/5b4pH9Ng/TKGvhGYqj/8NQ9TNV7DD+6QPC6i8xN73zFa5PVNTqXDvLB5CacGmTNhJ0jLu+5cA8z1S4PvPIZ9pa2eM9fP8DxuQs8srqPo286zTMrc/zIoc8B8KUP38qtrz+FO5kyE3T40JmbuGfvJZy+5ufu/Gv6t/tMux3++fnvtelyhuGM3KXBpmbtNunl/cihz/Gqmy7wll/7p+Lf3VL8/f/xY/QPx3zfaz/PxxZvoOyJx/iuZpuZ48s8+dlj1G7bJPnUJJkD/TsGaC8lCV2qtZCNpSabwwkaZzXR0RS97ZGNWyeFkiHreqSdEkzFlLyYja068zMtVhaEYtCxIjtfZTis4Wv47uNf5D2n7uZoZZV/+NjfZbzeRyuD1hndu/pkV+qMH9tCKcPrZy/STkpshRUmy32eTqaEPeo69G6IcFc9nKEmmhC9gNdWhFPilextiitBOJHhrvhUbtjGc1M2L49DObULvzxMvZ62PuOKLND09qeoSFFZFk3h2GnDiz82jr8lwGD3Z3qEUwF7f/YE7ufmObs6TXTVZ2puh5NP7OfozU1Orso5yRkXd2CoL2b0eg7dvQLYVSI2hXMnZNBy4zUhZAoT+sKotIQNiWu5dl7+7rcV0RgYRxgSfweiN99D85yhs0cV7d7cLSGqq+LBHFcgWNesDmoEbLDw2ZTT8zO89rVPcO7uIZ2PHmai1OfSzjhT98zyhoduFZlToFl8cg5TzYQd3RXSGOuzk2oW//lxFn7xBJOAMzbG5R+6gawMh//zWZLVNS7/a5HRVJfETSSqK6orGb1ZPZKu2FCO6npC6nsEnYzObm3dZoTd2bxZFtrhXMK+D8oClQYalRomntzm8lsmCZWivGmY+o0TdL7rfgYTmqlnMsKmYmNvwBPJboIgZjjw8afkOBV+y6kinc5IVsoMx0VXbrQA8SRQNrXPoHqywOfDZKJXVRAado5p0mM9/Ker1K9QBAflrL7KDKv3iQxk8nlTfEaRfKmsVMhKY5Rl7pwhBMsuLLuouYTSqkSEi1uHwQkzy+pnwjLXnWJILR9cVEYY9bw4Sn1VzAnkjh3FVk+g46LGIvRGgNGGwaCGMxDAhW+7AG4G2z7GEU272hJ3GONCZGdGCj2sA2lZGG13IOdRDzVZYF1UYmvpasGkjkVLnVQEZAzmxH3HbTlk5YxMQfmKS+7kkQMWEGvNYFMXDhflZYe4bm0UAafjkBwYoFKNGyQkfY9s9xDV9Qg2NcN5QcrpNTKSXO4QjQljrlJV6HtTf3Te8vs+LVNoxnN7S9NMMH2H0qqD3/IY7E0oLbrk0qSkLPuYlgUkC9iW+35wMMHZdkknYkyiJegJSDQyXO4I4CJWIlNKkB3Scj5SZY/fwA4KDyEcM3gtjTsUgJ6JQpBgS4BieVWu+/4ul7ii8PqGcEyKubjCV3jKf4V8x9oXJhXZf5WAsW4ocVUYYhgBcZ0CedfCylPyYigt2TAjbe0HbfE/mLWyvEg6A47VZecWjalHkdJaJA7H0sF0IpHwoK10xzLsuSuPSsBYgF6cCyOf058daeF1h6KbkOva885IHuhUyNdS0bpra6WYuyoVchgLkJPy6HeRT0nCsjsQUkxyBWR/lTNyn/G6IqVB2yLAFjDlVfusrIy6NRjpHKe+IisZO3MGqifkkPN1TfpLfvuaBumpB7EnspHAS9hV7XBybQbnHx1nd3CR/7UTdPjHH2b1A9ezc33MwX2rbE5V2XxxivDyNCfvGXDvgYvUb9/gma15WjtVHl1vEFz0+fmLb5ObY2/MI6cP8MANL/LgykF8P+Ge5gX2vGmbXzvzDaxfGWf3wXWGNwxoNAcsb9Sg7xBsOEW7Pdgx/Kdfezu/OAO1HUP4TTs4nx9DP7DF/vKAv7x4C0rBQn1HQHqlwyPn9xMMoff4JNHBjMqiJut4pE25Q3s7JZSfQaJp3xqhtz1xsLnqE83Laui0ZbCRjstaMkZpbMh2r0xwqE05iOk8OUVaMoSzCd6my/t+/wGigylPLuxBacPaWoOgFvHOGz/LL33hTQQLPbY2auya3eG51i4uXJ2GTNGc6tqW+DWtXJNrsRVO2y0m9Qky0oohLUNpXROOG9qtCvXmgNJ0nzhySavglBKSrkdSVwUzoePRShNXRQrQPqgorTgM51IqVxwyT1O+2mXjw0cJPzhFADABW/0JDv/jh/imkxvU9YBffvA7ZHAoEhBnlAw+Dic1cV0W+8PvfBiAMWDs9+H8r9xPWkuJGy5JIotR4bXdsUxTBv62sjZogIb1W10W/t0Jej99nMwRmUt/F4ydzRhMaBwLNJIKDGcyHEsbhU0Hc74KB+HCvz+O7nb55WPv4+cP3s7SPzmOUl1hWaIAb6DIAquNzRSD0Ie+XINLP3kcdwAz//UEC/9erEoTYPDWe4tF1ChxhPD6BneY4Q7EVs4g13B7v6L+3kdJ3nmctKSLcJO4Iovd/a98gYc+dyPzn9aoOCEruVbHqhjO1yltCNs+9uyOrENWlhK0Yoz2cKsR+6a3SDPNZ+77a9qvGtDQZY4//W2UvYheFLC5U8XbDIrhUuMAOUiz+uBcJwyyX17fFG48zkARDjyqVntvvNH1JAEpCjMWYULfMr/WS3+Xon5VOiYGy7LVRZqVufL/4WQmWtyBSA8KQGFEkx/sZKSe+grHhu5ekVv4LU39kmWw7T45kZHvZDcnHv1dtTxMI0FpsRfViQD6ZCJB9xwZ9nTA9DzrBy6zH044OjYmyHC7rjzjPCAzuF1NWjGEZYO77RYMtzMQwOtv6mJoN5zKSKrWXrAqDG8hgYh0kd9grJbZtdrmeDIRLbwHWdVYKYs8JyoroDJXANClMtoBtx/gGhjujwlWpLivnXWLYWVjAVgOxv3W/87mKWWHLHNtdX5Mcy9sZf3Ql33SakZSkqK5tCifk9RkLsUZ2GKwrwgnxc9dWxeq4KpHUjYQOnhtPQrXSUfnPCca866pSkezCSqVDg9fUXRYEJ0KKPU68lk5k5uzx715Oa8zj/foT9dEIlKjGDQtwGgOdG1nQCd2yNEWK7msS18Dnotwp2wkbUlLI79xlYlbir8t7+fvjNxXkrIF7Zkw+W6fAvSaQN7b7UF/zoJVLcOemSdywaQ66mCkZfnZ1BkVD2jr+mSslrzGyE/fznbkrPq1mvikkqd6S0cjlxypzHYSaqPvVgx0WglT7kajjHQG3J4qQt+coRQNbl8VGSfF3Ar2GlCjeRwnHhUA+bGWzpqc6/I6DCfl3tW2gHUH8rkvuc0o0q8Ck/7VYOv/T2xf0yA9rkP5Neu0Lk3gPDLO4itifu3WP+dHTv0gyauXOPcf7+fQP37oK34mcBOcUsJSq8nR6XWed5pM/J0l4s8v0F4o8abdL/BHJ17GT7zqYzzV2cNnOQYDl2PXXeXsyjTVhysENyW8affz/P6XXsHDswdZG9S4e/YyHz07ydJzu1AJdJZKUM944K7n+dzDN3Hwf0Zknmb1Lp9dj4b0FgL6f6fN4FIDtS8jiF0ubk3B0OH+W87g6xSNoR2VcC+UGRyO8CsRd80v8dj4XkqnS9T3bKMUrC6NFd7j9FyysQTddokbGbrtinaymUKQyeCSmxF2A15x7Az7K5v80VP3wnSC2wwpeynppCY0MFEJyYzm+tlVTn/iEFHT5+MzN2K0IRp4uKWE9VaNXRNtxiZ7XD+5yi2Nq7xP38HOyQmCLYVa9+ntTzFdGewrrWrbGjVoP0WHvmWhobqo6AQunaQK2sDQQUWK1IAeSECKjoStjCYyskqK03UIpwzu/S3C9Rr+mkdp2WEwm6G/8CSXf+Y4g0spekH0/MaVFNarf3ETf361w8Vzs+y5kBLVhcFrVxSDGafwrA0nMo782MNcef/NGCDs+cxMtzn4podQjsPVn7yXaNyQlhTlNYqkPZVe02K2D2i3JwDl6s8cZ/cvnGDlJ47T2SsP6q3rdeF64wwVu25ZFe3//S0u/tmtxOsS5vPl1X3c/LKzXG6P8cP//Ufo/n6EtwjRTkB5WxNXDeH+kNK5gOFCgl+JGftglY07jOhKIwF9Gz98vGDHU7u/RoPfFVYtLQkLpxJDbSWBJUPrsIfRkuC5/K7jVNbzOPtR5Hvnloin/+xGAqu7bO/zCdrCGnuDjMG0sO9RTbN1W5Oxp+2NqSD1BND84p1/ybdVRX/zp91xWukC3bTEK3ed5bbqZU4Pd3FqbJbHnT202gELH3PEplBR+IknpbxFbopgmTRQBRAqr0Nl1ROJii0SlBGAr1KRl8x8yqc3p1BZZlv8iu6RmMqaO9Lxa5kLSCwwra4Y6fjkDi3OKBSJDLp7Fa2SUwy55QmuRguoVCls3mYwjQQnSEh6HmrgoMZCTM9l6suOfEcre3EGol3Pui7OwII7PxOnp/EYtRyQllOR29QTsWm0No8qVShjUO2RO4nXllyFZEIkHq79LqlvQXRDrs+4LlaBwgIqCTtKhRn3djRJVZxJ4lpW3O+4Bqfj4ESKpJkSrLoF8HEGSpxgYpEuDaYootNVBiQjoFQ+7xVBZ7GVc+RuOPn7+T2KIb98oDlnSnP3Fb8/+vdcLw1SJGRlcdIBkTq4XXGFyQLR6UdzMc6mK6nHVgakEhtsNFSk9ayQAiW1zH4XRRpIAWQcsZ1MZmPcda84HyRSSAoLPbLjLIZ5Q3lWphUpqPPUz6Q8+r5+G4yjqaxLx65+Rew+w+YIkOfHyx2K1GU4oShviEwtl4ppywR/hT7aEXCcS5ZyLXlSlusnca3ELJGZKh3bayR32bFFSgF0FSKBiayNZ9ta1xqxJM/BstuTejYcG8mMwIJmK6eBEYOfOXI+tPUzz3wIK6OiJE9K9VtyXjHIEK2V9aXB6HOzgCLxOKnJcY+acuxyx5W8E+REFP7quce+jm2RYZ9DuX5f54SMdcfJGXWvDcmM2GA6kWXkh/Iz/Xm5hryeKhJev769tLe/HaXE39A2OBBz3cQab7v/UXoHYuJMcybcxY9800cBecj9r9vGVp3ZqTazzQ7PXZ4nG4+58vQ8qQ+nHj7AH33h5XhbDr/28OvYCqu87dYn8bYdzj6+F7NSZvItV7nQneR9526HUsojF/bzmpnT7PLbGE9sC52hwuspnLGQL5w/jKknXPmRhK3rfIbTBvXTa2QeHJnaYNexdcxExN6JbdxSggo1Dz1xlIcu7ydDceHjB2jesc6B3Wv8y1s/zJntKconS0RjhrXlMVaXxmhOd6Ud5xkqi5rgqky1GU9CQgpv1UoM9QQTOdB1eOjzN/LHn3mFsHHacGzXGg/sO0PU89HP12h3SzxxdTfPL+1Cx/ATb/4Qrs74pVe9D78c06gNqdeGTJT6tDZrNL0BdT1k62qTZDwhDaB3XYS/4fBdb/gi3/XKBxnOZMKcrzqYzYDShmUi0pypURArVMdFVWOc2QE6SDG+AD1xjpCHvhpqSGXR3FmtUzvjFU4Ch9/5MOEn9zOczaidc2ietn7Ykwl7fv4Et+xaZrw0gFRx5Y0wPBiRVjKcCIbHhnzfd3+C+PCAIz/2MO7B/fBMnfqHazSeDNh8YYpz77kdk6ZE49JizVNI80GfqCnDmVhpxHBGvMNj28pMXnsXk89H7PtXJ6guSWx9sCXf5eBPPkTlDed5+MHrmXhwUoZ1P5jh9DVbF8d4+tICjjJ0b4won/WpLkL9lEewKYVO7dmA8jqQKIITNVZfmVBelOIoj9HOHItX7XBYHqc9nBA9fnk9I9gSTXB/yiEccwoZgeioxUGiNyODa3EVWWy7rujTrQOG1zeETU3Y1ER1XTCIwU6G17Na3JLCHRr8jz1K5ioe7x0o7tfr/GV+qLnI2xpP8fcmHuKQt8bvP3E/Dz96jGirhO47DCd0AaJBtNwyhGtwYrvARZIs6g4Nbj+jvJVSask++O0Mvyv/78TW+9wCtsEuw9o9itYhzWBKUT3v0Z8WD2onlo6A2NiZwpvdbxuClrxfriHPAY3XEabQb1N4jOesnrFSqWBTQwZZoqme8zClFJPIhbTxqojNO1Nax4wAWVeGp9FiX5pORbgd0ZM7qz5pOROg7Vv0Wk5J6wlJI8V4RmRb17Cn0Zg4syhtSMYSkrIRe8bc49zOXkiUuSnATs5WBhtygp2BABSnb094NbUBZJkA/J4U7fmAXgF2rKQqnMpIy4ZoJiFuGpEeVKG/OyWuyf11bTGcg7IcgOU+2YVbCYzCcVQ+rzAC8DqkWE11JCnGbtux7iIC3pKKDHWmvkF3HNJGSjiVChNudfR5UaEiRVqVYVcVSyqojhVOTxeSCh0pcZTKpMjJtdY6kdmba11/korYdiZluYaCbQq70ZFnqnV6GoPFV1cYOz1g4fMD+jPikz75QkJl1dC4KNdnfs5788oy7PK6IsjHdnmK54W6hk32rFSlJOdQpXK+g20Lyo1cm85QFba3TjQ6v/lAblq2XuThaHA0Z8yV1cVHTQinoLtHLD1zyUpm5wK8jiVAbIckDSwAVgKqxQZIQv/Ka9eAZXtvxlW7H215r9wxJqpDNG490u0alXl2KDaV/a5dEYlPZVnAtY7scK4dOs6C0XXhduXcFAPJ5FIxubZyGV3myr7kXvO5rAglQXGN84rhlAxrm5cgTSu1mPob//W3RenzEjxFX73NX/RY+dEdJh53+amXf5Qj/grHS31ufc87OcBDUv3ffB1cWSFttXAPH6RWH7K7tsPjjx4pvMK9jmLsvjV2vjRDUoW5e5a4fHmazWGF28eGpGWDt6dLEjsMYh+tQgZ9H+2njI/1+OjyDdw3fYnm7h12Nmu86vXPsTKos9GvsnlhnHc+8An+x598I63bYioXPf7Z/o/yQ0/+IC988RDOsQ7X7V3h3Bf2E3Sgf/OQSi2kv15lox2gjkX015vccN1p/v0Lb+Rzd7+be8++S5w5JjPoeLS3q7zpgSf45MfvJL2rQ7MyZE+jRcWJuLm+yG999HXs/gSs317B1GXBM3sHmGFZ9HcdTTIlRq0fP30D7qrHja87Q5JpNgZVbp5Y4onGHj64egtnlmbIjOLbjzzJy2un+PH3/CCvfftDVNyYT507xsfCGzn5lv/Ot575Ji6f3k/UcUlLhnuq5+hnAX88FjMMHEqLLl5bF04MfkseyvgZ5SvSWh57NCANFK3rDP5A2chmQzSV4u446MjB3xFLSrclbixxM+XIjz5C68NH2HxuCncwcuiIGwplk1GX+3WuLE9ANaFcDxku1sjKKXt/9hEAPkmNfa91uPTnt8DpGsEGdPfIwllZUvQpcea/3cv1v3CRS997wCZOQpoJOJcFYMQ66qEs9L09GePPaTZuES28vu44mWXLwgmDmh/Q+vAR9jZb3GLO8eTSAmnksH3Mo3ZVhjA335qxttaAUBcsYL4AXsse+lsOg1mov+jRXxDrrsqKMOW53VtcQzSmCuoXRTvvDmSR7C4ITZNUoLaY0biUEewkbB3zCbZtCqYLekvOYTgOtfOa6952mie/eJT+jC4SAJ1YGGXljIBVsCW9WqNh4ktL7Lz9PpzQ8OHffxmfbh0v2PCcqeotiKtPsO5Q2oLKaj4AmhWBQsXrY5PP41n9rh3I9RFf+8QUBYOgTGHC88Ihc6E/q0nrMSrUZL5DZ8YOOHuGqKeZfFYYyvGTo/TNzFU4sbyHiilcYYSxV5DJwp+7njh928JORN9sHEkYrpzxiRoQjhtKi97IctLXOM1IBjxdSKcj9KYvbjcTBnczIBlLCsY6102rRKMiJdKYgVNIQYQJle/kdgWVKQNsOgVox89IylBadm2svVinmnqMd7FURKdnroCJcD7G3XbxuiLlKOwfhxqnrwvbTNOwzH4mwDRYlyJuOJfitqXbQCzD2eGkfK7blsFXYyAaE0AY1jMpDvRIxuF1rSTEWvoV2l8EKLk2NC73607LwgYbV2YPpPCwtqETCaVTrkjfJsT1JnMgWHULn/EieAYZNDeuwSknoMSLPk/VRMs1rCNNVhFSJisnqEjjbzkorQq2H0YgLdhShWTF7UoxnVsrljbFScRrC6BMS/KaxVdXqF0xBDuwc9jQus3gdKRbEjcMpTXoLRiqVxVBS5KUc0lNLrdQmbVSjOWY5faAqZMf15G3PEp9xbCuvy3nFmxB0vvfAXp+vvKOgbcjTHrQks/J/ct11xZyrpWRdFWRhpxffzqWZ1Du6JMPpkaN0TkGkc/kksv8c6IGRcigEwnzHTelA+K3tLhbNbFe6YbyqoTIkUnHMalI6Ft/l3Qh/Q7EGYXDT16YGce6SNmuZp7i7Hbl851Y9tPryHfNbIFxrURKZbIGDaekC/pS2wxfHbmL+SrYPP6f2L6mQXo0nfKG59t88u5dvNCfYvjNb6b0gUc4wEN0PnqYA997BhPFYGTRPPNv6yRbHk/H89x9z2kAHr2wlyQu0/7ijGjwEsXmJ+fx7+5S9SLe8+FXY3YPOTi1ycnn9rCyHXDvrWe5+8Yn+OjvvoxYlbn7u5+gFZfpvTBB6XCHrbDCSqdO4KYEu/r8pwdfh5pLmXjc45/9xHv5pUtvZNfNq0SJQ+fL05wp1/FC6O3NCCoxw0sNnBhhfGZDjFE8fHUf8aUad7d+nHe87lN0kxJ/+sJdzB1bJYxdPvLl21i4a4WVzSab56doHyxhnqvzUPkGksmEq2811Mc6zFV7rHxxAf1MpXjgqgzKz5Q5X5rErJbISoaGN+DxlT0Mhj4fP3UbKoPvef3D/EV6O3eNXeJ0b5aL/jThroSNuM6rJk7xyNn9OH7K9118Q3GO5j9vaO/VvGf1OI8+egR8A6kAV4DeHigfaJM+2ZQf8DMGu2Xx6s9o5n71BM7fu5/OPsveVFLUQEKMKlcc+gckRTDYFkC3/2cewb3uCOuXJ6guSftf2AtFNB0zO9Nm6aeOM/+6Ezh/2iQZeOxqtnG/7TkAdj3U5Mn338jUszIkOvNeh6ghaZr50GTmYAGNJllaJqkcEN1kRRiQpGqjyx3LhmkjmmcLGuO6ZcS6FjgoG6DSBNdLGXvzGf7R+Sf5H6uvZt/bnwFEhx5sQjimSVbKeF1hj9OSLKjGAScb+emmATQuGKqrKRs3usw+bNg+JkNYzlD8ZXVsigAXpw+l7ZTKBvSnHZJAFcNV4sLiENXAHfrUlmXljWpgUgG9iV2YjIaTf3UUtwK9V/Wof7pKaSuzzOuI6c5cxWDWY/PnjzP5fEZy8RLZ/XPoGErbhvW7DM3TAh6kLW8YTmpqFxzUy1vUykPaH99F83xqHVyMhLZoG7hzjZuLDLzJUGneYhb7NkUebpS5AqKl7WysdzHWSlDhteXP2S1dTOQw8eUSMGJmR5IZYTy9vrDqAkpkv9yhoXkxI16X7lZcVZJa2Fe4NqCqPyvWfXFdHI1MPSHruAWbS6xIEw+qGcG2g94Ui8WsKnISlMFfc4Vhy0R+YRxTdFGcNY9kJiYMNHqgC993agnuZb8ImIkbAizKqxqjxOY08yDbPSTrevY9bUhOqGR+YiByNG9DOlrD6ZTyioNKFc6mTx4DD6L5j5vyLFAGslLGYLcpWOd4KsZf8/Da2nYZFMlcBEMt5ErPkdyEAehEM5xJKS87o3j1YOSkkUfbO0MpdPyWKpjaXEYC4vySlCELDF5HE02m4uLUdcSFw4jrjXHk2gr3RvhXJBBsuCultOyMbA4zB7VZLgpFHcNwPsbbcvFajjDUkQzvOh1XtMuNDK+jScoScJS7gBRa6XyGwB2BuNxxSSX2+WGL76Qm12bYFHKjeVqxc8QtmNfykoDc5hn5zuGYoryZ4fYz+jMyC2Bg9MzzKPIF8kIhrlsHFNtdy+0pdSTnNy3J+c5lRsYR8Ksta154gZdG4DTzrWTF/llCoeTcVZYV4ThFQV4EDg0tWE9Gch23L790YgdUHZGGpP6IsdapWMeWNuXn0/Ko2ATpAvktKK8bwjF5dokXvCq+RzQmz1t/BwYzqvjZcGykNy+kca7MFuSfk1Rk38IJK6OxxzGfbch9+r3eSJLlxMLwJxXbyWr+beGTv3a3r2mQ3njR4fdW34j6YQG43lyf6FvuRO14XPeOq5hkJF7Tvs/seId2qUS3U+J1k89zdjjLI71D+D14w9se4S8fuovysiMttC/XuEoN594O2ZUaF87sx6lLS/mRFw9Sv3lIfxfEcxGXehNs9KqiZTtd59QLdW7/hlMcqG7wgXM3ozIY27vDDXes8FNffDvECm88ZGasQzRmNYhVhA27VKO8oujdFKJaHmozwDRjSp+rUwK46PNu/+UcmV+j9GSZbV1m7DUreJNDltebZLFDdV3hXqlz+DvOcKi6zqX+JGdbk/zM0Y/wq+dfD7d0iM7W8TryIBnMGMLDIYFRwrLU4XOnj7Iwu03JS3jl0Wf55ubjXIyn+L2j7+UnLn0ra/0aJ7dm8ddd/ujh46hyQrkWMtio8PQnjpGUoPKybZyTdfwOPPLiQZxIUbuiGU4h7hADTdpM6LVLqCnrc73pkVaFGZt5KmTw1nvpz6pCFuCe8kjL0trs7c3w11yiiRTjOMKKAJXfbsG5BknVkcHMWciq4NZi1pbHUAsZK//oOAe+UwYnnbExTv3n+2A84sxjPkEDll7ps+9fnODyzx2nuiiA1jhiW5iDAKPg/C/fjxNCZd0wHFN090B1URidYmhxoEcWkjvy/cHqPfU1cojAEF+qsfqB6/nvK+Pc2bzEa091mHbb/NohOPPf7iXYcPB2dKFNTWopcc+Rlu9w1JrN28ed3S7zvyTfY+KFjM2bJUTI64KpiP7X64kTkTPM6M3JRGRpOyX15fGiUihtZqhUozJTRI6X11P6Mw615ZSwqYkrVoNrB7v8x6p0X9dlcydg8svCBpe3UlQGnQVN40pG46KAaxDQtPSAYfpRxcSz4triDi0rnYpzQuMC3Di7iFaGJ9NdZJ6ygS0CdKOagOHc+xxG2m8JVrLAGkXulJKzhls3wvgLCscypeMvZiQXtThPaJGuOBeqhYwCpUYssaFoiQtgUcW/5wOWufWi18+sE4yhvJHr56UwaFyS10Z1RX+XxlkWX/ysJE4lWSQUpuib5Wvoodgv6h0XlSrCXQn+uripqAz8HU3UsOFIDrhrnji7OEZqyFijV3yJnd9Rhdwhc8DYEBuvrQj3RtDx0LUY5RhYLOP1oHcwFgeVWDpbaSqMc2lN5jyMliJZZyOwljoGuq4tgBThngRjnajcyz7ejifDnI4tiofgnfXp74+tlt5aK/ZE/1xZksHouCHDejoUqUEugTBWFxxsq6JYyAForgUOp6Sz6lpnnDxkSVl5l9EQHx6QhQ5628NZ9Yn3D5ma7LDTKzMMfEyiCVblvonGMzn2U+KOE6yK5aW210rckCHUrJQR1uXPSapkHicf6IwVkkhqi85UUkfzAlBZaVY+40A2AoZOZtlfI+dw/KQk2DqhvLayYejtUsV9sXNAYxypWLwOhcRIm9GxMgpK69bJpTNiiPP0V6PtgGhXuhdxYyTvyEFpYn82tfLAzLcMuJV05IFuMAKneUonZqQVzwu+zAW/Y0bzBYycW/JBz9xuMvVH7PxXBGBd4/bi9uS7+C1bBCXXFA92gDV3s3FCkdBEDfmOfkeCpcKGKmxA8+e715PCIB/Oz4sXf8c+/325d9yB3Sfr7+5bUwIyAf/5sdQJZNn/a7j0Vd2yr4I94lfjM/5PbF/TIH3usxuoC8s4402Wv/0o/XaN+aczmp8/i0lTlNIYk2DimFO/egcT8Tad7QrNJ31+6cK3wvVdKKXMvWqFD5+9EX9LhLpRU1pd5UWN76a4S4poXLRgKvMof+sKi/0mfgviBcPpL+/DiRRj966zvlmnfLLEMx89xpP+MWmfXT/gtbtP89DafkyqcBsx8VqZ9iNVyh4Mbx3inC3j3NhmttFh81CVt+w+y4dO3sShhTUubU4wnPYJ94XUnwlI+y7L7Qa3fesLPHjqMP0XZ9Cx4thdl5gpdTl61yofvHozDW/A8rCJVhkv33Wev9y4k1a/zKBVQu2KmLhlh/ZD0/g7ikHZJ14O0B6kjQRt4Or5adyWyxeA1WGdbhJwrjnLEyf3o0sJE5Nd8VnedkliRXKlxMte8wIPRtdBPaF9tcHgPofqLVscq3VYnanz49/0WX7+kb8DmSLzHaozPXpLNfxtLXpYz1C+6uD2YfPGoGjrul0EdAAmkQU4K2foDS0AIIap3zjBmf9yHzwtwSoyBCRscTiZwVoJt69JGimd20La776bykUZ2hp7ATqvTjGTIfEE7P5Tj8WfPs7enz3B0j89jttXlDZlH9IA4hSScsahP4tpHwho71OU12HslKGzX5Jo3YEsoOEk6JZNH+0IcxI3DMNp6xBhWamsmlI969GerHBi9QgPlw4wPdXhDQsn6b39vmIxjMfFf9p4UJ7rMTA13IEuhr2sXTjDCVmAt7//fg6+d421l89QXYTSVsbS64RSnnjcI3MgmlY4sWcdUAS86sRQ2s5wBxlpoKiuZnQWZNiPDPqzAhgHE7Ja+h0B8DnbplNwn6gRz2V0X9sluVLFeUoTtDMqG4bhmMYNDY33PMTO99wPBqqXtSyYkbyXOzR2IRVwYRQ8+NANZKWM6R1hiI1SZI5hMKWFdbL+6KVNq9m0ulpnmBWAGeQ1sbWey+wCnzOfYteWa3XtNZhIsaYTkbmILEA6LJkSnX3upS1Wg8LqO7ZoKJwdGAH3IpBFCQLx2ynKgNdTlFqKpKSoLcJgSlutvPhmB9u2EMzsfdB3QBvxgx6Ip7Ye5l71spLrviYNjAyRewYGGhwwmbi65MA/l27o1F5L9njpHU8AV9/B6SuSWkY4hjDndpBTAsBkHma4S4KCkqoAqNQVwxJ3IAx4GsgBSQPQLQ8dysBmOJlKVyBV6FAkcUkzpXzVpX7So3tArl3jGsIJKSByWUURzmQHKQczxoJUK7ewK2bhCmLlUbnsJW7IZztdh9K6uHWEk+Ka43YV3lnRTCQV0ewTO6yvSRdQdd1CIhKNZaixCDUXY1olsnJGVM7Q1ZhktYQ7UOjIesjPRZSrEeHlug3kUoXeXo6PSIZy7XxSkWIiH7I07ki+E1lyIAec+Z/jqlw79csQl6G2nNGfFm/5HBy7/VHKZxpQJPXKybdyDctihxMUw5KFG4kdCs3Dh/JhSLd/jcTFSmOMlQfmFo9J2ZDP76gUCNTIRcb6hhfMtKbwPo/rUgw4sXSl4rGM0urIMja12Q3K3sduT37GHVAkqxbMu50nyv3dXSPgPdgRCVQ+PJofM68jDHjuMJX64O/IcytqjOQ1QFFwljYFaGO7nsqIdEgn1s3GPmuMGrniDKYpjAzy7ooURwqT/e0Aql/L29c0SE9On8NVHsn6BlH9KG4Pmk+vA6CUPF1U4HPqvx4iOKfZ8priWGBvyPT5Gm4AV5Z3k5Uypu5cZ0+jxWMvHODfvuovuBpPsB1X+bO1e6ifctm+V+wNt07PsFhJKftA36WypFDAZKXH5nNTlNYh93VtH0lpVId84g/uY+fGGLftkLoZwVyP3oRLthXAts91r7xAL/a5ujnGvuktPvjczfjVmLOLMwTlmMFcQvlcABnMPOjSPjDOY4zjOxDXM2ZuWuP8xiRMwTD12Hhqhs/OjPO2Ox7n7up5/sX7v4t4PGX/4RWma1321bd5en0eNPT3JFQvuPSvC0kHjjhDeBo9FjF/aI1Ll6ZZPzMJwLn9kyLf2PHZTBtQy6AiLiLufMqlzjjUEyamOtQWQq6ujjMIPU5tzKG3PJ6e34MJHVk4e5r+5TqmkqISh5lHFf0pTX9ekIHbg+jQENP2CDYc6z0vmsKdY0JRDneleFNDsjXxe7/z9nM8fmYf3powa60j11jdjUXcePsiT5/fjbcU2KRFOPCKS2z+0V4OzW6wtNOk0yqzfJ+LOdTjzO/eReW0LCYqkc/XqVg+llcc9OcfoffOG3G/1CSuAEpRWhfvXTJJ4HRsSzquy89VVmGQqkJW4PVhOGNQsS5sEQGW/vJGfujgF/jizhGq73sY88a7US0NiSJtpjj1mHAgg4U61kUbWA+tA0RgEwSbitVXz6Bjw9RvPMSVnz3O3g8aVu51aB8QPTRIQmvzjMbrZaQlRWk7w+ulqMxglGYw7eKEhsGMFCxe21C7GtI+EBA1FHEm7VgYDdDWLxuCliY7W7PskWEwYVNuI4PfEXSVeor+3DXWaGUpYAaTmuqqaENTXyzaclef3NbQt4mmtcVMgHUqrHdcs7HqnirkH+YaoHyt805ShuoVCJt2HxKD3xEwfm3aaBoIcM49l8XH2rL9GfRntCS2bkoxlLmix88cO8xmrKd7llknGgsqvVw2NNrB7BrbxdKWDN6lPpS25d8GswocSTh2hgqMIh5P0Y2IrO1jPEXmZ+Aa/HVxezK+QQ8cTCiSCiJAC+hLS+LPLYFUoxZ8foy8HSlAwjFD6ksxl02Kk5SO7XxCLAygv2m/hxJLRieE4ZQpLByxtolJIyXYcGwCpxynfAhRh9pa6CmqF2WpSypQWnMY7oulKOk7pA2b8GoTgHPDAIlTVwVbmg+mYovYnB0t6rJEUVoVC9d0MiYeSJKp15b9iCZTVKzwt7WkvCrQpUS6GwMHf0uIgaRqoB6j3YywHaB7Dm5PSwBTpyRBSV0hhNKywbQ9htu+UNZGkZSN9d22+5Wqwo5RZdINiKsWUEdA3vXI5SbXWPjljLHbp2CkkyoMJ3ThRAXCfOehbcZFwoaszCSpiBwuZ7Fztjy/z9OSZYcdO/xp9zsfCh5OWRlgSe6B3G6wGBR2sNePLaq1dBVl4NS6xAy0zD2vyXskufTGBeWPgKyKVFEcyOCyffZbRr1wVbKDsHmIm1WEFW41ztDe26E8g0obtnNZsW421dH1Iz728h3DcTXyW7eFuDIjYB3VbAfVpZAI6mhUxOjIfhf7s9UlOc9AkS3gt0fHW4W85DYDpF8FT5O/LZr0v/kj8RLfrvyr4/IHZSPJuz1hpWzgR3T9HuqPlQha4DRi9KEuO4fh733XJxk/bcTlYO9AQICl2A4cWOUXn38jTWfAnz99J6+8+RQ3f9tJvv3Wx8jGY1519wuQKAazGQ/c8TyHv+0svXnDuS/tJ61m9BZEN9a7dwAKSl7Czo2xLI67hgSNEOeJOpUnywRbMkx18sn9XH1sgYlGnzhzKNdDjs2sMT7eY6rR5eU3n2bfay7RuT1k/U5DcNs2ydE+SS1DT4csn5siiVxOPruXp5bnmbptDb8e8vmlQ/z21ZcTj6eUrzosPrrAxcUp2nGJ/sBHhzD2nEtlxeAuBdTOuvibGlxD2vNYfHoO7af4Cz0AdtZr5F65DBxxlUk12bkag25ANwzYv7DOW/c+w28efS8fesV/I7lQQ3spKoUPfvEujt90hvqLLqUNhbHWb+FURndB0TmcSgJiYFmitoeOFcO5hP58xvSTIWPnIvGE7jtULzuky2X8Nqz/yHGevLRb2v62vVletyxKOcXEDuf/6hBjjwaF1Kd2Fdbfu4/t1w756LGPcHhyA0KH49/wHN9/48PsmmuR3tWhfN8mcV1Y8f6sDFxlLmSvuoPmn9XJXrFD3/6bOxAgHo1DZ5+RgbMmYNvPk791gnBC5A1uT/69tK448sOPsPuRGufeczsX/v1xzKNNfvMXvpXPPnc93Y8dIrjq4e/YhabnoJ2MrOOjQo3fkfeLahZQ9a7RdjojD/O1HzvO3ImI0gceIXMNez4VU7ss3saZB9090NmtxU6uookaLt0Fn+GUSziu6OyXczN2dog7NPTmRcdc3jD4Xfn+uaxBtLk5iw1j5xPcoZFQH7tQlj7wCL2334ffzRg7mzGcFNCda4UljVVkNtNPSxCQHogMoQDH1gM99YUZj6q6aHUn1i9eR8LU5YAzBwiF/7HIhAt2zTiK4bhIeKKatTuzLKG2DHo+YGi0shIYVSyugyloHdbsHNT0Zh2ihpY0U6UwjiKpWBLB3kv5fgG44SjWXeYG5HtmjsiSKuspldWEuC76A6MNcSMlHkuhlJK1rbd7kOFMhFBKBVR7BsqJSGMihdO3zhvNhHiXIIBwKmM4YxjMGaIxw2B3Wrh6iK80GN9QOtKWYeihJgvEiSXeNySaSIU1HhPXk6RiiJpyD2S+lR9Z+YjbRwYoPYiaGVnJgC/Wh6VVsUFNxhILXqE/l0l+wL4YveNiYo3xDMGKS7CuKS+LL7xOLLs6tNIBLAtt3V+MO9I7J2XLGluZUhYgg8kX/EKLXQTcdOTz4roBL8MbCzGZwr/qQ5AR7g8xN3RxewoTa9KtAHq2gFFAPcbMDTF+JgFRVn/v7Uhyq9excyZlQ1oSi0bjmkLzre2cksi75FdSEmCX+RTXaO7LfW1wUWalE6kHjUtGPNGtM0/uhpMz98qqRK+9V9IyhWSsPydDqjmrq1IrLerLZxvHuj0h94tK5RhnvvzudUwxoK0jC7rr1rXLSLEkLL04x3gtjd8ZncfMGVkaygyOKZh1lY6044WcKZ9LCa/pZtkOURZYPXwghAnZaBhTp4CWjtVwymrwc614aI+7I+dAJdDbLYA6sW4xhRwtgsqKdeSxxWFSkfcKx+w16Mtn5bMSmWNdX6x+3R1YRyjrgKPtMb3WjvLr20tz+5pm0q/89L3MPZXA8duEmQth7U0HmfnkZUhSBjfvZvN6r6hk07aHGZTI6inPtHdz/TufZfWRm3DOlqmvQn9tiscPNfDrEfFShV/pv46fu/+v+c0Lr2RvvYWnUhrjPb549hClyQGlIOZqb4wrW+O87oEn+cSp62HHJznWZ9jxcTL45vse5/NLh3FrMe6Sh5lLCdcrqOuH+OdLshD4Bmd2wPRYl40nZonnIqpjAxYqLb5l9kk+vnkTD754GO2l3H/kPO2oxPPnFyAUB4d0x4dqQqUSMjWzyaXn5mmv1qkc32Km2uXMFw7gelDeADbAOeVz6vRhKEN2V4edrk+1OYRTTY5/+1P8yvxnuefhv495rk40nmH6LuGOjxMrpuZauE7G6skZqEVkqcakivL1LTpbFbZX6rzqjrM8ubOH/3npVmZrHerXbdO63IRKxrEbr/LII9fh3t8lWivzX173h7zrvd9PbRF688Ke1S8Zgh3DzgGNjrT4EJcyDvx1gr/SoXdkjOplh/6CMKy1C5qZ/3KC7NN7aF3cRXVZFy1OZwjx3pG7RVyzSXrHBnzrjU/zyStHqfgxe92Yjw18todlnEbEg5+7ic9Xb2Dm0CblIGYQenC4R3qlAkZAdX+3YcWXAnD+W55n5+/dz9abe7hfquIOhTXHqELLOZwGfw22f+B+/J3RIGoawJ7/+ASrP3KcCxd6eOfKJFVxW1h7IAYNO5+fxQ9lEagsaVIfkqiKZ90NOvtg/JShtpyyc8AV2YEe6d7dIQzHBcBsXeeT3Xicg/+zBw8/zRSw+NPHmX4CUt/Q3aPoLmjcPlQGWcH2ljaF3XIiw/bREsMpYYz9dlaAiMGUSH3yhSVopThlTfV9D9P63vsl2jsT8JlTmGFTU1tOIDN4XZEA9OZh9mVLbPcq/Oixz/GLD7+JsUd9qktQvyxgNdergkhKnMjg9aS4SAKFzkapnZln00LVqM0MFNZ/OhyBiVyuInZ6pvj+QBHykmvMM1eRVoUFzwFU/rwx1pkhqkMWKPrzGcGGU7Ta/Y4AsLChCtZTpxIvnrtM5IUKqV28PUVvRpBGsKUI90Q4m569zhRZpCHLQafCWangZ+ISA2BiOywaGNKGAHDdFj/0JB9UzZTkLjQT9LYnAS2Bsb7PAh7j55tggb9yM9JySlCOGYZ5J04AptvRRRHk9mQoFmVIahlu26FyVQbp8k6Qvyi/xzXISgZnR0BuXJefTysZ1VMexoVeQ4Yuo3HR63tdOWe5zMPtQzgpOnusmweugDpnKJ2sQofeE6CUW2GGUxnlZS3Skli6DKU1xUBbadeGi54aoAJDerhP2U9QytDbrOAeGaAiR7oU1QTVFZbcCQQFO+UEsxHITICGrC7HAnIgbtCRDMjKwLVd8Ox1EDfFVtMZyAB4zsKqZASkwRIFdQsS1wzdBUVageGYKrT2cX3ELOfANi9mlHWJ0patTWq2k7NhO1oONqFV/MYzX+6tyeczNm7Wxb2pLbDM/cc7+xXBtryPFG+I1Mm315g7ejYIWWBAqREwtYyyjnMNudx7+d/j2sjtJbdbJJNj4/VGQ6n5/Z/PGBUFnQup1Z3ng6c6EYmP12EUfIV8X3d4jc7d2j9mhiIEKvMgtuextGXXOetMk1RHzxzj2qIlBH84AuTYc5x3R5zhqMuRd4FeSptBfVX04n9bmPSvaZC+5989gqs8zv/y/ez5VEz55DJoh3TXOIuvrsug0Ja0xPpHI6rP++KgsuHw1EeuJxozMBMSXCgRV+XmfuDGF3GUYXWmzrMXdvPL734717/1NI9/6SgvHJul2ynR+HKJ7v1yR198Zi/GNXxs9VbLGiiSrtxZWeLwgWdvBQVjEz1aEyUqTsrNN5/n1F8dIanKou72NPXakJXT07z9G0/w/udvZ3CxwcfaN7J9uMrJjRlhk9ZLPLRzFKop9Yk+nVaFFGktx3VFp+fSTRuFprFzapyT7hh+ApMvSLy7PKCUJCE6is2JCpRTess1mAvZXdrmHZffyK5mm+qrN5gpd0gyh7IT8/GnbmJrp0bSd1GuIThfIqkY/LZiuDaGqmZMH97kg5+7G2d3nzceOsknLx7jn9/8MT4ycQu3NK5yaTDJKXcP//SWT/DvHvtG1pMG6eEB7aAk1ml7u7R7dXSiGC4kvOnOp1kdNnj66jyZ45OePE0weRtj37BB7+IUw2lFaV1u1vOL0/jLXhFVffDXTnL6Xx3jVfc/x9qgzuagylytzbMPHsYvJdxbO8uFiUkeP7MP7ad8Yeo6FrfGqJQjugsavRGwsV3DcTPi9RKUM5yFAXOTOyw9u4uxU6pYRE+/+26O/uBDjP9FBd1scP6HDlJZEU186ovTQWlTFonWEYXXk7hsZyjawzO/cz2HvvsE7cP307wi6alOCNm2B46hP58VISilDdHg+m3oHMowjZjmEwEYSaKcOBmxbi0eURJQlOssc8Zw5r+cYO1Hj+PccpzJ/3GChX93gpV/fBwdQbAprxlOQdRwKG0Je9udc2UxTCEqSevZ64skpD+j8Dum8PytLRl6M4rUF207WJDpwsQXF2ndt0DQEtBSXRGAvnmjhxPC+q2a+MCQ1RPzOAP4leffSrkvi1RaguaFrAj0ybeooXH7OVNr8BOxGsVYOU2gyDxVnI98n0xfFV7m4bhl4SzIMS6YbASg84HR1IOgI8OfbijpobmePW6I3trryEKeWs9llUJp3cHtyTUQV6G/S30FSy12cgJGkjHLkllZTQ7E/O5I455UjPhsY1lKV8Bb3kExVnqRW1iijTCNmZLAHU+JzaCGeEw8vd11r7CCpOMWjKYzUHbQUU6kpGSCHmqMq1C1mJIfE0YVsvEYx09RyhB7JVSk8FuauJnhb8sMSbDpMJg1JJXRoKobjYBIaROSviay0hodC5BOplOMo+nvTlGhRu0akG0H4nThKobTso+ldemmeG1lnV5E3uOEkDQy4okMp+uKnh0rf3ABO+QYbGgrbZDB4rRs6B5NxVbVHpfhSgXqCSSafsdHOQZv0yMNUkwkrkBZqmRovJziGvm7djOyWkqaKMmEaMTEQYa36ZJVwWs7RDPibpMD0rRsJUn298yTY5LJfHBR8Bf3mQe9OQGY42dksFsnUF6W4t8djKwo82AhlQIuxSBq/p5JTX53e9IJ7C3In8ttxLYRKXaqV8R9Ze0OXVg2Rk3AXv95gZx5Vuu9LcWSsRaTSUWCenQsnam0JEO2KpGCqijqp0bAOp8ZUQaMJ/KRqGFdXCyLfW3irdcbdUbkwI3mEZLKqAAg7yLYDn1i7SJze8zcv90ZSPcy9YUpzxw5Xrl7WVoGp6+KzkdcHj1LZPjf4A2UWK1uqKLLBBSp1SKZs7urR12ha60wv769dLevaZAOEnNuHEP5xRVQivXXzJOU5SE0nBEAEWxi278w/ry4RoRNhVGK4FKpGD4pr4mriWl7uF1NMFQc+eazPPHQEX7073yMG0pXuSPY4T/c9HLacYm3Tj7Ou576v2SAq5pAx8ObF5FjpRwRJw537LrKi1szrK83MaWUqXqPfuIRTkDphhZTlQFv3/0E77lwDybIaMUVZqfarBhF5fkST1fnSU/XqXTh5jefIsocnjy7l86VBl5HQFtSy3AGEg6SBRnOUBcOACqRocmwqWlfn+A0YiY/WqLUSlm5x0U1YkzPRdVj7jl4CYDbG1e4paH4zNoxzrWnuHxmFmc8RHkZ6WaAasS4tYjy/pDk8xMMp+B3vv03+IFHvpfD4xtk1ynunrnMXz91K99z90N8aP1WKm7E2f403bjEP33th/hy+yBZqvnoxs14fkL9pg16oU9/vcr0nes0SkP21rb5yHM38wN3PMjTF46wejeY+48TNwwTf1amMqMIdkRaAOCVEqKFiOCytPtf/OXDOGVJTT1cX2fpTw/w5K2TlDsQXaix644d3rXwMX6y93auXprif37oZWSBoTc/5PDCGufW9qCdjGolxJyuMnj5gKjns7gyjrPQp9urFtdh+arHmd+/kyPf9zgX/tlt7PtXJ7j057egn6tRWbE6ZwcalyK2b3LJIl2k6WGg+ngZddfNzD5i6E8pG2xjfdYbBn9bkzQyyBSNywlbx1y8rgxaOmGA1zVFmI/pKTw7BOYORuxuPhA2/xeLnPy9u6ielH/f/AfHURns+o+ih49ffxdbN/iMnc2IK4q4ptg65gpADGX/3FAKkOGYAF+vaxewhizOgylZcNzQMJh0KCtN8w8fAiAByodncD79OADbR1x0bBc5Dwazhh+/47NcvGGShaDF7/zF61EZ9PYaapcUd/6Lx/n0e++humKBtsayz/J3J5K/5zpvEIY6bCi8nimG3ERqYnCttKZvHVmS8mjwDaRoMY4qItC9rjDahfuGZTHdAdQvUlhM5jMPUQMc29EYThuiMYW3I+8znBCQVFoTRi5zZdH3eiMAog0k7ijhMHfDSesJ3pYr97ljcOJRq1+nCKNuhAVOy4bSkgRNpeVMho4XHZGajGdSy1hwkOvTVTMia4kHe1ITj3hnqIiDjCzIROrjGnQpwaSanUtjlOe7VEoR3UGA76a0nQBTzQhrKf6iJ4DKHtfcCjGuS5ppWskINjXa2tNhxBbRb1EUSNUXxd2JDEyQoS5WoC7BTDoWjb6y91bOVIqPtip83P1NBx06BZtqtISNZZ7B33Qkh6HtkNRyZGnwth3UjibaG2KmQ4Z1B913UNseaiYk3fLRifhp60sloj0RqhpD3yUrZahEk4YOqu2SKWvjNxuBqzFtD6UhGUtRQ008meLsuIUkIweconWWazSXOVwLfovCrS/drOFkDq5TkrJm+smIcNzFHUJ7r9yf6BHwVFr+7gxHMguw8hctn5lbHhotRfy1Kas5sM2JAHE8MZCpQphrsH70StEuKxrn5UsaBao0ul+VEe19UrH68ITC1avwDXflrZOqdEtUKp0DGLHgKhXla2olKfkzKj/v+U45IRCO9j2p2kFVR/TvRUFgJUJJedSJyIe/46p8DgpJ0LWpuzoWQkWlMtuUe/a7IfaegmBH2VkcCr93ZyCv8ewcQBpY4G4ld8aer5filn0Vdiz7OpP+0t/W33EvXh96pYz+9buonFyRhTivfENFZRlQEFz2RauXQFJThRSit2AXLd9QWnHwz5UkEn1THgrPXJ2ndmybX//s6/kPr/8zGmrIX5+5iXi5woNXb8MxkNVSSDXu9IAkcnC9FN+RX1/68vU0D7ag46Iz2FNr4aqMpRUYv7tHhuKvl28R83/XcKk3DoDZ8ai+Yp2qH7Fo6vT3Jvzo3Kf44837KZ332fPAZc48v5vG3h2+//DDDI3Lb335VeAYwkyYK6erpFuAhFk059t4fzlO66hi4qSDOdpDLZfx5vvEyxUeyfbzVHWechDT2qoyNtGj/9QELERkicarxKQtjzTSGE9T9mLS16zTPT/BP/ijH2bvFyMef8ceslTx/Td8iY/Ft/JHDx1nes82250Kbzn6HF9e2kc38RkmLt5iwI23L9FPPE4+sZ99tyxy8WqdnSen2XbhG9/yPNfftcJvPfty/C7c9uaTbLxrLxfeWmHjrozyksP2XTFvufVpXvw3EK2VZeFOIK3C2EyH7zrwGH98/i7aOxXUUUP9jFAPyigeGRzi3SdfRrhewalHRBP2po81W4MKan7Avuktzp2cx9yU8OaDp/jI8zfhBinus1V2vfoqVx7bLazabEL9mYALf3orB77zBPMPN1h+X425Xx0Ngl79F8c5f7um8YJmMGfE53koD+S9//oEKx+4nvl/tkX3G6dIKwKKyqsUwTNpReG3FMMJp9B0Ny+Io0hUVXh9AU7DSZfSVkZUF7tFbCs3HIPdH93gwvcsYNJYAFojH5QUvfrM4328TzzG7Cdkn9MH7qS7xyfzxDLQ72T4Hav9bigmnxvQOlLG70mLu3aFIjQoK8FwXEJpWt97L3FFMXY2wvvEYwTnNkgQ55ncAnI4qSh9wzrJ4jjvPnWc8eqAj+7cQHpkwCsOn6asY1aGDT7w6B38ve/5Au87cztj/7OGMzTXtLtVYQHpDsXfXpITFV5fLBqNVsRV8VZ3QwAz8ldPRnplbfXiuVVc3vbW4YgNS8ujdn7mWIcXX+F1s4LxSjdy/bCi7ct8Reo7pGVDZVnTPGeZ8UCkRE6siK0zRB7+kgesGDVygfC2XIkI76hi+DctWQTDaLBNhkFVESufeRLgNpzJCimWTkQfnQ/cqcQh9g2qmpKMR6iNALcvTKfTdsQxaVcsHt/jQ6KVCmP7W7Q2asRnGiT1lNCxcwBDjUqVyDS6mnxoMx/8K69K58/t66K4yHyI5mKbngy9PQI+o2ZGaV3jdh2yUIiJypLDYDYTyUJH43aFmVRZnmdgQ3Ka1wAzC+4EuCmysQRnzRPZZFeTzEQoN0OvBTgDYaGjpsFEWjCilxFsSdfOe65MUgb3xh2ioaQtm0SRGQe/EREPXJQ2mI5HVs5k6DlSeEuBsMWhItkV4a55qESRZnJ+jCMFlNfSkI6uT6Mp0n/z7hRYMJ2pwqFEArAgLTsEOynikGSsf7wqznUukcnlWZiRxWFxDZesntt2feKqDU+qyDFOaqYY1FbGypU8Of9+K9eRm2JmAKSg2DmkxK4xB/9q1DWKrf1gLknLux3BltXI61zSJ6FZfksVgWa5Tj+3dMxlb+5ArHRzR5bcqjMf3szscfVbXykzyuVvJneIsXJCHQuYzgdJiwLCwfrpqwLUB61Rd83foZjlScoKZQsix4JxZ0gx3FqcW1uougP5e1Yij4D5+vYS3r6mQboTQvcg1M47DKY1lRc1cyc6XPymOqV10a7mlbVrp9PDSbmqK5uKztGU+imHV3z3k9xVu4ijMn7xj99eOBroBLK1EoOdCrqR8VMPfRv/fNtDDzQlawlIAvgZjYkeWhu6vQBjFGtrDcYmZdiytVbHGSjYM+A7px/ht5deyc6dId2NcVwvJez6uCsBamHIxc0JSp+vY25O6Ec+jdKQZM8Quh4/c+5bWG/XiMYMnbCEakYMnhvnP7cfwHQ8nJ7ot92BZTNnxJFhuCsjHYtprTQo7ZOFdueAYtd7Syy+WhH1fXAND1x3iseW92IMeFcDOqs+pp7hVWNKQUx7rYYajyHSpJHD6ovT4tldlmNaOr8BpsHuyRb/8jt/APP3M6qTfd64+yTv+dzL+cipe/G34fx4k7RkOHT/Jfqpz3NnduMYuLA4TWV3B9fJGD49zsd/8JWc+bsBP/HAx3j+0AKfPneUo8vbmL2Kk6/8bW7+4v8FmyW+9Dt3McUJnImItCUDX/s+MqB1c4anUu6YvcrDj9yC0dA5kPGW+59gK67wWx94I41bN4iHNX7slZ/j17/0OnYfEHegq8sTBNWI888v8IMPfJbtpMr7H7mLt937GO977E7SScPKTgP3cIdhz+dVx84Q3J7w8HtvA+Dzzx9DLxgu/+vjhHMJN193mb3/qEX25Ass/dRxsYTrQn/ekNihvSTVXH3zuHgbJwq3p4QtNhJNf+Snn2Lph28nqqsiFjtsKPyuKdgWAK+b0t7rUlsaMctRTRbly988hcpg+kGXjTslACZqCtNDBmt3VcjuPS5gfwr2//QJmkDT3nPb338/mS8rR/N8TNzwqGykdOcdpp6RwsAo0BmU1gypJ8xvsGMYPxOxcZPPwuJRkuclTCzzpEVeXoO3fu8XeM8z91C96JJZW8d6dUjJTQhTlzhzOFDdwL814Y+euI9j+5fJ/v42rT/YY8H1yBFD9KuqaGunHhglVqpuD0rbog1Iygocy97Z1j5QJOFmnmhnc2DUO5Cgqgls+18BanMPcpWJD7q8OSO2PRNwIEVTRtoAFWrCCcP4KQlAcgdGhkUTQ24BCQLuZafkfVQCvXk5Pm5PFbr11GcExq07RQ7C3L5d8LWw3yiF19YCVI0RG8dQwLyOIS4ZnJ6D0Qa36xWSGWdgCwAP3JbIn+KlCl5P0396Ap/R53hbklCa1hNUX4Y6k7qEHhnLJme+Ia6rIsnRHaiCDfZWxLM/DSgkXjrUkg46E+Gu+ZRX5TtWFrUNLFIWdIk8xxmqIkTH3xkN82HkPTNXft6/6hd+6F5XYTyRmuQSE4ZyXOi6MoRuxAM+2FBE4waMIn22STKRiZNOPcPUUuKuLwFMyLlxu7qQXyT1VPzl7f54hzukmSZrB4Rlhe7LQGlSN9aGMiFY9SAb6aLzcK58qNeJ5PsZLaCwt2CI6prShiBjJzajUDHhlsj9/A3ys7kLSs7SG0eAqLlm0DS/3nPCtLSmCoCbD6E6qSqKCtkvOxCKyHVAWHjjqmJOQMdiSZuD6Nz2MJeN5Zpz+b5G3I2GIqGKa5btt37muZd5PryKvTbzQWGjRvd7at1qclMEZWTY3u2P2PPcFz2Xx1RWob8LMkbMvbYhSyBBYHknIJfkFBaxuRNSINd1Urbv7VmXmDH5fzf3i/dHzxeVyXFXychN66W0GaMKE46/2c/5G/+I/yPbS7TZ8dXZhpMw++UUdwCdvQqiCGdxk0O/eYnZL/fYOSxPnrhuEx0PDUnLGXcdP038sg46VHRujXhma54j/gqPdA4ynEsxjrCbRok2sbwOpVXNxImAylVNMpbihDbG/RUt/GrERKVPu10mjR2its877/4Mh8Y3Ke3uoryUo/dcwjlX4Z/88fdzU2MJN0j4N3f+NUnk4ldj/BZ8182PcsPsKjt3hSjHMBz4nLsyi8k00/u2GMYeSskCvvnkDPOzLbweqLUAUtFml7ZED9u6Jca5oU04leH0NI6XUZnsCxOxrRgspFQudvC3FZXGAG9qSD8JGK/2iWKXb3vzgyQTCU5PE2+V6KzUUF5G9aRP+YpL40lfBqz2hYUG/sq3zuM+UePKU/Oc+VEXp5Jw48wqf/jo/RjXEI1l9PaIc0HluhZnH9vLX370OL7V1VZfCJj+nSqz/yHg4J9v4rQH/Pob3kNsHOZLLcY+XcH9g5B79l3iz7tzJKGLNzVk13dcBKBUjsQ5YSZDf+FJNlea/JcnX83nHrmJ4UxG3DBQT9iIqrTCMpPPGZw/mySrpPz2738jJIrF1XE2O1Umpzqk52oYbfjkynU8ubXAv3vN+0mN4rdf83vcfOd5Sp9s4H+xjnYyHvrkTVTdkH3fch4AZ8vF7ckiVb7i8uyFBc7+U5/uxw6x578/K0OClvlqjksxVytFwuLsiA5YWfcGJ4KDfzHgwj+/nXBc2O98oUxLSnx564qoLimtnd0ujh3iHEwqpj63JCzj0AZ1pOKhbgJhUt1+znzZxSOVBaO0AZvvOM7iPztO7233cfrdd+N3DZO/dYLJ3zpBsN5n65hL2BSHjs4eTdiUxaS8LrrxtCQAvboSE9UlKCy1AH3r7x8vUvV+/l/8LkdLy5iuRzhuqJZD1lp1Wu0Ki0sTYis6rHJlMM5TKwu85eZnOPX8bo401nnzuz5PXFXoyLKnw5EMRgCChCL5vYzyurjL5CyZE8vAaVISMOdYy8yctUtKo8hwYwGuaXuYZkxayYgnUsLJrLC2M2rEfuVFk04sU14WfTM9B2KNKWWWuTSWPbQyGUeRBLoIRAraGV7fFHIe44g2Ndcg56AzH951rIRKpZYBde3gqJVOeG05X2SIl7pjcDqOFBMWzPgt6dq4PV34Vefe2TlYSKsiETGeIalmIpHJi5ahtkEtiup5D8Yj9IEeGEimEtJGKrpdywSLn7wi2h1Jguq13t9jpmBT8/kAZ8Mj2RWKBKk2+r75sTAOBFu60B/n8fMqxQ7rW92+PUcqlQTR/O9ZIxE7y0QKZjIpiLy2QtdjVCQFhqRvqkKS4W9roomU0rqmcs5DBwmqEaPqMTpU1vZPkZYzKYgiKcYZOvQ3K0RbJYgV/oZUm3mxrhIB7al1wyq6InY40bgjCUz+f1EDqlcUpW3x3k8Dqx9vaLm+GQHv/Ppx+qNjkofx6Nwu0do7GgsQ84HrNKBIQY0aI8DqtygcWHQk8i6/Za9Tm6CbXy8gunuQYiOzYFycZUzhey6uKIZwUiRXblvjtwUwl9fkfby+fE5x3ZZGrixpSYkkKbGBbsqCaHs/lPIZtlnZ56gh3z/f/+J+UzZVdCDfPZf65J+V1GzRNKAIjyqeCbYoKvbLEi5xTf59MD26d9PA6tiT0XEns3MDjIZdv769dLevaZAe39SjddgR0OJD7449UC5BrYK71mb/B4cMZg2lDRnS88+XeMerP8N8ucVwuUpaSzGpYvHkLH++dS+7/Da/9frfxR1A3Eylco4o0s7CpmhK3R2RTLhdRfzEGNFWiaXtJnfvv4zaCFBexn9+/AEef+4Aw74P2z43Nle49dWnSY72WY/qBE9W+ekvfhuTY12izRLGhT9++h58naKdDKcSMzPRxvFTgks+7cemaT02TX+pho5ExrP+6C5uf8sLdhFSvOW7HuSW/8/zNL5lCV1KGSzVKK9K2uXC9DaDTongphbDmwa8/q5niX61y997+6dRDzfZO7XFz+7+IMPYI/ATHtnYR9AMMYd6GM/2xJW13MrkgbLvhmXe9+rfpHLbFv71O/RvH9Dfk8pivxZw74GLPPHQEarnPIxn8Bd6GM/w5tc+ylhlIPaNVg+46yE7dFjSkBnQmq07Jnjnx7+b91++gz985l4270p45vQeHnrmCEf8FfxLAcbAyef2AHDTzArKEwbLnZ2h9oJHOnCpXNU0zmpqlxX1Z3xO/8717Pz6XlZemVJeTzjyeyHzX+px9Pf6TH42YNAusXV2AmegqF1wWD6xwOpH9vAf/ut38rG/uJef/NV/wJU/OkTmQv1NKzzx6t/gh7/1o3z6ylFeePQA7t7dHPqzro1kF6213vQJnq6w84VZ1v90jvkvDmkfsSDZEbTl/OFkMVi48DlZOPy2wQkzlu+vCGjJBMSHE2JjpjIB43FVitbUh84BQ3cPzP/2M6gMkbfkzI0FJv07BviNiP6RSDysF5JieDFf+NOS6KN1ImmE7rbL4htSzv3H+wHInnieuV89QfMPH5Ikwi0jvvAW9KrU4LcN5a2Unf0+rcMOM/9F5D+9t98nTJa1k9tMamRo3njX06hUMfjiFNnlCmapjN720MqQGM2+yha3zC6hVcYPvupzXOhO8gefeyV7vvscxpFB1swVPfpgQpGURdqSeTIoCRKVPpjWDCc0w3HN1vW6cJ8wjtzjuS+0cczIacUT0GT8DBM6MCYdEB0poskUr8tXJIyCPZ6uImxoWtdlAga0DDaqobYLu5YWvJ+3xqW4SX3Zf1nYR444eVhPGpgCeKZlU7CDmS86bznXhsyT/4uaphgQTANxacnKMufgdnNZ0AjsqxRxfNHCWgpIGjnmOH2NDpWQAANduOO4fRmWS325ltISeJdKJFerMBHBUAuIj6xMx8gwp8rAXfVw2+IOM5zNiMZk5iaXHeWAXhlw1vzi+xRDkxZQ5cVo5so+a9sZyWVR+XMns0OhxgF/0ScNYLgrhUThth2GsylJNfuK4sc/LfSu8Yxo56851+4QqhcdAXQGnMtl9GqAe6WEShRZIABTWflKOp4Q7xtCJcWtxSIlasQyCDsRkVYym6hs7PeTwj+pyWfnlo3hZFp8/9wq1DiWaU2FrXb7uTe/db2yXeaimLRyjlwClR/XIoUzs6BUy72QX4eljXyWRI5tZdkOeVsm2usI+E0D+becpdeRsnMDGeh8OFnmJ5KyscPABmU91DPPWMCvrARJjmfqC2BOc7Y5tfITT649v2WveX8knclBcG7F67UF3McVcXFBXXMtW5Cd3xf5sHf+/kAxrJuz8IVcxZUB06Q60rEX75GM8EUuTcvPRy5Ziiv5jI10RuIGhWNNfh+8FLfMqL/xX193d/lbsFUeruIEAhxLm3DldZrrzmiIYlAKf2mH5rky3QWIplKm923x3t9+nThilFK0n1I+WcK9b5sPv3gjs1Nt1qfqDA7EuNUIbyGBh5sYB3oHYuovegRbkvSWD3hkAXibLt65Gk8/f4xsb4y76rPnzkVqXsQLi3M0D22zOGhytdtk/8wmz2zO43Vh1/w2w8TFHQtJNl0qJwNOP3wM/xs63LlwBYCaH/JP7v047/ji96DaHs5ERBy4DIce+roOJ758HZRkQOXDF2/kltklxoMB2ew2W9UKyU4TKimLT81hxhO67RImdvj0uaNksebd53ahbxlw4endvOnUT1DZ1WXy96sEZzJKb6jRvj6hOt2jt1lB77iEswkq1DQPtlio7fDvr76J6MEJwklD1kgxfkZSE8vER87vx+srsjs7NL0ErQ1mV58PPHsbdFwaawIsvTZs3aiZeiZl/VaH7M4q5dWqHfZRdD47w/iWPJx2jhhuufccP3vhm3FubBNfrRWlqlaZWMxFmpM/ewBvG4IVr2BhPDt0pIzICg6+LyX1Nf2FMl43JdgYMPXoNs2zZVbu9amuGrrzirhmqF5VhGNQWxQNYVqGf/jDf8U3187wxeEUQ+NS8WNKN2xw4fv3klzfo/4lRW+PobRlaB8RaYfKYHOjzsTnH2f8J4/RalVIM/kCG7doGuet5rMird/q+x9m6SePi6VhHyobKVvXiSZ4+5gsMr19Kf62w9yDMYMpl2BHHC2Wv/8WjAO1q+K7nXqK2pJhMKlwqyHdTolyc0g44eOvuUTjVp8eyeKQ+sKeJTX57NplBZfleJ799fsINjR7/o2A7ubFlNqzq2y+bE700tckl3bmXXRq2PXwEO6/FR56mqgmoUOuDSz5hfd8B8ODEartUruuRWYUM+UhP7j/S/zy86/jxvoST+7s4dP/6Tipp1j89iX21FoA/MIb/5wnevs5P38InUBtSVBkdU3CcbCLal44eH3zFf7JgynRq+sdeW39KuQ96wIgJ2KXOH5KW7cVRVx2yfWm4YRTvD7zZOZFp4bhuGYwI+eydkmkaMo4xA1D44y2xVNm/aiV9HCtLtiJxK0n9XXhzCOSmawYIMsCgzIKt68KaYsM9gmAkVAg+dxoTFjYpDr6bnqgcSz4Ng44bTvwWqWIZo+nEkgUqu2Q1jKMp2RiD8DJ9bziHFPYylUyvB1NOBcTLItsRUcKrA5bRYpsz4C05+F0HdFca3FjEfZVUIikqzqFJjjvIOmeKiz2clY38yiKGMe6ehgNrnXwyWcM8rTHzM+/owwoGscQbCu8jsNgLiVpJihXjtmgrPDWvWKAtrzsFFIKHVtQmHdQypBGsjbkjj2FXKgvNpJZOZPgnUhj+g5UUtLIwVkYYjJJnM3cTLzlgxS97YjLTmRlHka6OsRynPwtp9BSK2PlEonIMZoXFSoxRA2H3i6nSPnMr4EC7OXAPBkV6dpqvB2r8c7ZbWVBa54CjL1lXGtxmHu4u/Yzorr8X64l1wmYVJhttyuORn5r5BbjWUvMfJAVI0PG+QCnHkDkSIchtzBM7bBxd6+9NEO5BtJgpCnPh4dzdt8dUPjLJyUKyYzRo/OXeVJ8eV3DYFoVlqL5wG5SkWsK5L3zxNC8u+NF0vnSschZtC0YEmsha9RIrpQXAyqzznS+3NP54GiePJoXnMnIu+Dr20t0+5oG6VETqEN1WW6kypJmuGeM0sUtcsGSjg3x/pC/e8uj3FM7zwenb+PRP7yVzv0hrJUYXD9EnxrjxnsvcGZ9mk92j1F/1mMw69FrpgRluZEbJ71CRzaclBsrnM6on9MMp2ylXDHgZszfsUzFjdkOy6TbPqrZ4+GzBxif6DFR6tPKygym4VsXnudPz97BNx4+yQe3b4fDQ/prZW6fXeXhCwdoNvr0hj7vOPP9BCsuqQ/ufIJZKRFOpxwab8F4i93VHY43z/InV+9msdskTF2myj321bd5OPRwrpRJZyJqzSEHJzY5uTyLPl2FspGWbRRQ2lGMP6KIak1qp9fZunNK2sepIorkMtMzQ/ZMbXPlqXmmq11eP/E8v/D0N5Le2ufwrnUufW4fzhC6R2KUNgTlmGC1zMTnfM5/r09jvA+na5jZGN2MeNc//CC/9NtvRycw/WRCb87FGUrr8u/80Bf460s3UfnSBME2RUBGOhXxzNV50oGLU0546yse5ZnteQAu7EyiQo07OSRZLxfDRtk1D8PKmiy6UcOhu+DSW8BqTzVoj4XP9IjGPPyugLq4IRrV/jxUlkTbvXNTgtHwg81lHo983lwZ8ubKWd5/6XZ+5uhH+J3KK3jxy/tRmbSb63/yEPU/kWt27ceOs+e/x5z75fs5+At9KrM+5b96krUfO24TTQ1xVRjUxiWDLpcLZ5akAr1d0qfOY7RVJoCpvAbBVsjmjZ61TMyKAUmvK+4+mQ+9BcWx157j6Wf2U7vg4HdL6NgwHFeFBECVJNzIOBLelDNrmUthl1e/oAlahks/f5zqMkz9xgkSoHn+IubltzGcChiOa/yutKor6yn6C08C0P6799vkTmjfkKBihR6LoOXjDDTtNRGK9oIS/+bUt/Dq+57j+8cfpaRj4nddYiVscqyyzFPdvcyUunymdT2bYVUSTq+kZJ6ivJGIX3pJgRJW1+/alTRno31hJcdPZ0Xk+YglUwX40IkpnB1ydtFog98T1t7rywBYXoSlvkJjMJkcb5VJc+haltdo8f4OWvk1KkDSs5piFERVjTcQP3ivlxFXxZkq85QFqwrdHwEJUwBmy+ZZ/Xjeavc6owG7wUKKHmrSWoqKxKEmraXExhXwlyqiyQxlHWPIRBajIkXWSNA7Hiq2unJPGNY0oEi7zLXXpSXRFUXjGaYZo7fEUsWJFGFP5nvMdIh2DPGOj9GOBNdk0tEwvpGBUutBnQaSxjmcT3B3xKHFa4vcpBgCvMb5xLUdkP7ulPKiUwCeaEKKCDlfuZOHKoC+M9Ciq60nqLaLZwdeS+ui48/8ESOPZUXz8J/cNSUHbigxJ/A61os+l5fEEututEFvung9xXAqAy9jsDfGWyzhRgqdOKLX7+nCXjZPhkVJoR7X5RqIxqRb4u8o9AAoQ+uAS1qS1+RJn4XFoDOaV8jzFKK6vG/mjeQiVMVpJGfBc+vHPG00/2VcSG33MBwfyThy9jePvVcJmGusH1U2ksrkgDS3WM1TPsGy3h3xGs8lV3ogHalR0qkh2JLnWWY7A35Lro3MswWAHSYtmPeGgPT8e+f3au7AJTMTdi4iHy63Uq08QVTZZ3T+HTHWJWZgrxHr8JV/j/81BVcnNtnaOszkia3GStvyMKu845WWkZm4l9hmgKyY0P6b274aXuz/J7avablL/sC6dshl8ZU+puSB1pBlbNxu8EoJf/KZl/NQ9zCPruzh3/6j3+NX7nmfeE6fLpGMpbzwyAHmxnYoBTHhpGiCjZdRu3uDtASdwym9gwlxHQZzovH762/+Nbp3Dwg2Rc/o7O/RGOtT90KeO7ubjXaNH331J3njwkn8CyW2z43z3NndbLeqxIcH/N5T9zNeHTDpd/m+l32Ro7NrUEm5ob7M3plN5mptslN1xp9yieuGeDLh7oXLZJ7h3W/8HeLMYb7S5kJnghM7h1lqNZks91k5Nc2zL+7lyeUFkp7H3jsWuX7/Mo3ykDF/QLkU4960g5kb0jjQAm0IJzK2j2qmH92Gbp+JL68RtAzOWMTdey/z1jueRF2scNfUFYwL3zL3FD/3obfhOBkTjR6nn9nDrpcvEo5B+ZJH/Rmf5MUG+k2bbN4UsDC3TedSk/ItW+zZtwHbPj/3kbeRlqC717B1zMXtG/y2MBYf/fVXsLNdJalK+zGuijWf2hFd/oG9a0yPdfnU5WOcX5xm8aeP0/vEDPWFDslmSXS3gSHYlNTRpCKLdVJROUlK40JM9SoFG5Z5EDc8SuthwSaXNoTpD7at3ZYL3nhIZbLPa57/Jj7bvZ6fXb+Rp6Ihj97+PlaSMT549GOc+e7f5F3v/DN2bkjZ/v772fzB46z9uLinmEeeobSu2Ly5ytqdDks/ddz6Bst+5Uxv2FBs/N3bmfuVE7bdafC6Ir9onFfULyhKGzKgFNVh53CVzIWglaFjg9tPCXYEKfhdkUbE1w04szHF1OOaypro3t3hqG2aB44M5gxxM5NFuiyJkXFdBl07h1L6c4bOXmHA4iq0vu9+1n/kOK3vux/1paco/9Uj+B1507HTA4L1sLhvN29S9HbLZ47PtWnu2aFWG+JMhGR7BnhbLrqcQMfF6Wvmgx1e8YF3sRiOMee1eGRtH39w4T4+feoYw9Sjl/jU3JC4IbpbmSlxiOoar29IAuhPK5KS/VUWUOrEwnZnnkhNjE0pzly5RnK22mhxszFaBg3jiryuAPQO5M4ZMJK76MRQXof+voT+QiaDYwNTMMBpSSR0G7doBpOK/qyis1fTndf0dtkh0czqdEvaSjUy3EEmgSmuIR7LRD6RCTiJx7LR8Kxl5NKShPMoq6tOAyAT5tjbdorQITLRofvbWgY3tx0BnX0HPRGSTsWYIIOhIA2/LfIE4xjipujuw4lMpEGOsVIfC1oiRXAhoLysKK1pkU94GX5L410qkSWKYM1Bp5aNrdkhUM/YsCM5F2pvn+jIAPyMZCzF7SnCmZRwQorv3HknZ4fTktzXwbpTuPToBIJ18ZPPAXpcM0V6ZNQU8sIJFXpLugBxMyWaja0OWxXzG3mAVQGeyK+Z0T2lUsnCiJqSpoqXkQfs6FAVrxMG2g4CDzXJrohwNhHmf6BIapLKKpp96ZJE45m4zrjyKy3LbEBSGjGvgxkBf5krXZR833QqbG1+37sDqC5nhfWg17HyFCPPvTy9OB/qlJvFEih1LGkgf899xVUmP1valHMTbFFo3VVqk5GHVl5lOx35r1yWk9uiRg0pIMJxbGGk0AO5L/I023xQu2D8bdckH7TMMwd0eM0Qpy9/z92b3IF1zkm+8h7KwTJq9Npgm9HAKKNUUNfq192evQbyz84Rm5FjmZMfmTeSwzjWNrfoxMR2qLQk75cnOLt9inTUr28v3e1rGqTn7bWwIX8ubVsmYLYGWmECH+ox4U7AT33jB3jfJ44TuCn/8uQ384ryGoxHDA6H0nacH3JpZZJD45v8p+/6HZgdokspU5WePHzLKe99w29w9xufRyWKweGQHz/zHbgXy2QBVMYGpBer8Nlxzn7+AJULHoNWid89dT/v/8Ar7INHsW/fOmqxRNbz8C6WWFycYGk4RjcXt8WK0Hgca66hleGuB05y+O+exrgG5WV88cUjqAz+5em3cuWFXTy6uJera+N86cJB4qUKF1oTmGaC2wyZqXfRQcrFpSn+b/b+O9zS66zvxj9rrafsevqZXjUz6rJVLWncC8Y22DiUgClJCIQkpJFGwvsLgQRCSSGGvJgQCAHTSww2GOPYceQmy7Zk9TIq0/vpuz9trd8f91rPPgrkepPfL/Aql7yvS5dm5uyzy1PWuu/v/S1HO6tcOr3IsfZVdnT7JHHF4vwAazXNXUPcbMndX/UEf/63PsH5bzgIiADvnsOn+MJnr+ePfv9VVPsm/M79d2Fjy7976g3YuZJsErOyMoPrlpxbnafsVux4uGTf75xh/hnHfHPE1q0F588s0biq6feanL+0gBlpZp4Xn/OH3/NebAKb1wrqmM0qBu8Y4ApNugHDAxVVCrM3r/GGe57ght1XcE5x69J5rllYQ19NKZuw69/ez7cd/QI615QHJqgKRrdMsMaLmOqFWjGZU2xcL371nQuO2dOW+ROWfCZi87qWcBn7fkSdTZEmMwFeaFNZzbnVed4z+wgL0ZDCGU6Xff7a7AUAPjaO+JbuOr/29vcx3KvqePFzb2nxS+c+y/4/XGPxP9zPwe+/n9aVqRisbKl6YhM2wov/8DjLj8pflIX9v30W8M8JgqQIZk8MxI/XBlRw6ioCftM53cQ9NEvkA3GqVJqBaCSb12TJ+U1JCjdnBKkMSLNNLXgxV9kU/m7/2pLNaxXDPSJIvfx3j7P6147T/p0HaP/2A5hhDg88Wt+2M6ehcxbab7/C5lqH7z72Kb796APsWuhxw97LlLsFWVWVQh8dcHq8yOvvfJo7O6f41+//OjYeXubGxSssLAyYjcd87fJDbOZNsl0lk3ntUWnvm9zR9bFSlTiohEhyk7m6oMM5H2oUCnU5hiaXQjnK5P9Vqli93dVWb2HjtkaeX6WCiCsHedeQ9Cy7PmmYeU4SMYc7hFqRbPgippJiSO43WcdCWqmM3YWn7iKwRlG0NVUiSZhxX/lz5ATdTaUhUxW1wC+sk3FPvyihNdk0mJE8IV0Vm8xkJSKfDRZ98v6Nq1pQ2wsN0rMJ0WZEtGVQJYwOFpix8rHsguDGPX+8M9/I+O+Rrimy5UpEdkpccvRmTD5nyXaU2ElU86CHe4XOoSv5bDqbCpvLrZQorWBk0END2bFS3Odeb7DgC8ZtnF1dyLGOe/jPJveW8uJBlAhly9lKXm9DXFiqTkU0EBec5iVD50Qs3tVer5Dvz2tf7HCsTeYRaS9ADs4gQl/QRD1D40KEyhXVTCVNw1hTda3/jIrGpUhCpyYGPdaUHble4y2NKsAMRWdkE7FvDMJPZSHqy3m1nipiY/mOVcN5IaWqKS3BVCE4l+QzsHVNUNJ6Tvlw+tplk7risAkEO0YbTxuiWqCZemqLPzaThennCaFAzojY0/rnBzS89mevpmiyzpFwuJF8pqRHHejjtHjkh4TPoCFR1TZRKPI7LqK2Xy5902b8BCYU4kE8bhMplicL0hzEfWhfdnQuujobwRmmlpfbmtLKa23C+dd2ei0GZD2ct/BQFlJPuQuOTOE6trEU5MWMrPnxUBqfl6Jw1KGo/gz++z+Fk66c+z/FiOZ/36PX6zE7O8s13/8juMWUqC88ced9XBsbsPRwj8v3zjB5Q593XPMUH3jodl5387MsJEM++MAdRH2PIA0U3Nznzx97mN/+wOv4u9/0e/zIZ7+KqFVSbSaYuRzzfJOq5XC7JthKo1cTkoPSKh9eWuO5zx+k3FEw80hC/xpLuq7JZx07b7zKnk4PjWN10uLU03tQLgTQyAKxda1stsrCeFfFT77tV/jA6h188ks3kO4YkQ0TkjMp+UKFmpWKTF9OqboVycIErR2TYUJ8PqXsWjoHeoxGYsNgIkt+uSVR7IWinCtJZzPytSaqXTC/MKSsNO858iD/4RNvRi1k7F7e4sKzO5g5sEVvs8Vt15zjmas7mAwTbGZoLYwZ91P+/Csf4qH1/bxwehdqIMiamYjDTChcio446jirSE+nNNZgsM9RdSxRXxP787bnDy5y5pv2kK7DoW95nifvO0rcnwbHxEPonivpHYwYvX7AM6/5Za754HfRPmXIbh9SrjbAwLHv/iLR8iIn/u0+qmGMiv3KOIxoXBExVzyA7oWSzWuiKRrmHzrwGoGZ03Jb9fcLVSIeeJFZQxZuFznYN+a51/8SAKfLPociUWL9xMZhXt8+wW9v3MU3zH+Rtir4qatv4pNnj1I83wWnOHjXOV54ai8mU1zzDz6HecUNbN40Sz6jxS7Qf66k51h8eAueOcXFv3obu957P8/+3F0sPhiTdwAFC195keSfz7N5rIE1imRgMZkU5+MlGQWPdkM+a2ld1DTWIelZsjnNtd96ggc/dy3t84reESv83dSRrujaxm+8U4JWsOASKxSbyKH7RlDkmYLoUioF5kxFumKIRrIpjnbB3PMSJBTCN/rXWJoH+/zQzR/kp8++kTfteJYH1g8TaUuiK16/cILfv/IKTn7yELd/xdPkNiLRJU+u7KL4wnwdQlPMWu6483n2tTb4wspBlppDzv3qEaKRm46iJ65GxkH459GYGvXWQXToXF0QWyP/bo13ilHC568LPysoeV1Ae+pMcGDRhZvyy5US+0vrfdsb4i8/WfLF3IDaIjAaegs7zzNdfLKq36dutCr53Jfv1bWtW5U6IVx7Ozq8uFDnqk4GVYFe4VHHaKhqOhhMp5HZcgUNGUvqXsTBWy5w6sxOXKVQxtGcG5NNBF22WUR8JfZFiiDPzjhUqWrEsUqEshJvavJ5S/OSUFeGt07QV1KqJYFQXaFRCtBO6CVbum5aAEb7K0GoU4tplrAijlbKUecNhIKpangkMzTl3vceHZBW//9tPuNVKtOGZFNPBacdR/OSetG0Nlg4mgxGe8W2MhpNm+DtBXtAlUMhG6gjkXdQCYYEKMjnKhpXjaD6XdnHlBPku0od0UCoOSEZ1sUy6dUjQ7KppVHSgi47I2tssm5eRMkJqHc9efZrjArOIduazvDZgdqRJFBWQoEd+Ow1taemh8lrBgFnoFttPzaB3qFCIaun91bQFyQbMv0MPuTpuoji0zV5o3yWOtQn0HjCsQ7WiaqcNpzRyFN+PEUk3RDuPvh/94V3KHxr4WzD+5pb/Loq1BfrhbPbXWrMmDqhNVBmagoUcn+bTJr9KvG8exXWoCltzWTbinRD7Yufzft1wk8/+3MTTv7w/8XW1hYzMzP8v/34xV/8Rf7Jz3wf7/qZN/+pv9fjv3GCxWf38nu/93t/6u/1/8/jZc1J1zmYdRGUTJagnK1oXDYUBZz56hnKluNv3fgpTox2kc5lPLaym61Vb4yqHOVMhdtVkDze5f3rx2m9osePffFtqFxT2pivvedBWjrnPye30ohLhsMG9CKi/UPmf6fN1TsVF+KSr33r5zjR38krbr/Abz13G+aAxZ3rcvnqLFeeWeaOO5/nNcsneeuup3lw8xBPrhxjcEvGvt3rjD67GxAuoZ7LuTG5yj88d4jbbjnFdd0r/NaTt4t95MESV/oVbu8EckN5oS0LyY6MnXdd4mB3g2404YmN3YzyhOX2gOcutDAj8a5uXIg5/oqnubqjy1OPHWS9MBw6cJVPXL1OFhUNh2bWuWCW6Z+ZZeak5t47TnK+N8tkmDC7Y8A/vuGjfGzjRs6N53n+5C5U7Dh44yVOP7sLUHXIQrYA+sgAJhGNF1JBz/ZA1bW4yOK0pn1BAmzOf82emof4yMPXoFqOuKfqcIhdv/MsV772WkZvGLBrrscv95eINg3f9Zc+zK+cehV5K2M0Tnn2P9zBtX/li9yyX3NyfZH+WhsisYjLFi3j/RWzT8Ss3hTVIruQBmcyQUfzrmwAwx2KeDxFJYuOoC1mIhSYfFbxQ3f8Hr/cX+KW9Dy3Jl3umyh+5uKb+ImDv8e5ssk/XL6f7z79Ln7y4Ad5YmM3X3PkcX7n+eNUTcv6b+9nNhLO97l/ehxe0Wf/1z/wouu7/5576B3UzD/8FAC73isizcUvxGzcbGle0WDh/BO76b5S0b1QMdwlNod5V5PNKxxyLuafFmeE4R45pqOdQpF5/cIJVm9rcc9bTjOyCZmNuLNzml8+fzeXNmfJLrQxI43pa9INRXPFyMYC9Xh6uDv1wTyKYmhqIVQ+C+2L040IxF7MNiyNpOBHn307G48v8x3f8hs8sH6Yb9t1P1094WO9m1lIRzy9P+fm7kU+cfVaLn90PzjY/ylpjp3RjHY3ePrctTy03/KW449hUZyvoOk9oYu28ZxTKZZ17mhfkaI3b6uagx5cG8Jo2xTUgtP1GzVl07H8iCQPhkLGGVUXBwGhD0i8Lh04R9nUxMNA/5DJRjy0KKvpXLRYo9g6osnnPNXJTXndAUWvkintxRqFqaaIaHlAhLbRQArffN4LUBsVqmfI56TSMxMN1ZSmoJx89mgsDYFNnYgkKwXev9p5OsyFB/bBvoy0W5CPY7JJLDzqSqEGZio0LIMLjVBUan52rlATKaablzSTXZbGFaG4ZDsLKBQqcaSXYnF3alJz6ouOpx16gatdKNCRRRtLOV/U6wp48Z5/RENPYfBFc+BKw7QYCgV6HRBkJDQsiGWVheiqqjUYLqLmOJtMrul0RdeuMlUKpvJFVuAQl2DVtJgNxyoUXaFBUJUg4KFoxQpKb9ZiypkKlVYwSkSbsGnIdxbooQGt0IUi21WKhWaual/zaEsa6OD3H9BZfL8aqDnB0chpXlxE+5+Hn4VGL6C6Ogfn7Rkt02IZ/L2zjWsN8rPGmkfYG9RCSWX8+fJod9mmRu5DAaw99cTkEnxVF62Zdxty8oFrfUFA6gO/3DHNPYmBICJNpAkIVJVAbwkNXPBaVyU0Vy2TBU+tMbLP4cGbyos7zVg+c2jWwnWyvemxBvA5E/Fw2jBWqT+GHulX5TTMKXy2siHXhiqnk6Xw2V9qjz8Lvvj/KfD0y7pIR0F+/Zj4uSaNFWic0ESZcFCH+wAH7/vtr6J9xxppXGK0I2oVlE5RVYq5xyN2PJiBG3Ly61v8x6/4Jf7iF/4yv/a6n+UbPvw3ecPMM/zzE1+FeqSLetU6VWZo7x4wvNDh0ltLVGzpbbT5rYt3c+TaizzV3801S2vMJWOeTZZZvTiLcYovPn6EB/OjzF6zyS1Ll4jv2KR4fpaLGztp5GDu3mRyscvCnHgwlbnhxMoy1imiuGK016E3JKzIxg7biIiGgsbn8xY2Ei4nM9w8f4mtoskgS2nGBXPJBDtfYLua2eU+k4cXuO+Bm4n7Gp0Iqnf+wb2UCyX/7O3/mU9s3MDnP3wzetHSfV6z+YqS3zxzO0utIe/c/wQAn+9fwxOru1k5uUjS1xR7ckZFwsfe+RO8b/V1fOR37xb+4o4cnRvefdOjfHbxGq6uzNB+IsUdyMXAolXywLf8Al/z7Ds4/ZHDpBuyEcw/qRntgs5Fx9CJKG/zTUeZPZnzK6/693x0cBM/8Jl301mDf/vpr+Sm687x5FMHRODWtKx/+Fp43bPMf6zJcJASnWySL0pseONizNbNBfOPxNORZA7tSxWTBU3eVZ4DKA4u0Vjiq6sGVA7yRcuuuy/zyvmL/P4Tt9A1Yz62dhPftm+VJ4sRJ/PDvGfnA/ylZ9/Djx35ADGar15+lFRpLjy9kz8cN7B7J9hxxHu/92dZNkO++jN/A20sjc91hc9dwXhRvMWVhZkzFnX3K7jwhg5Owd4fu5/Fn7uf9JvuIemX9PdFLDxjyWc0ZVOTbjmqRDHcq0g3wEykMM3mtCDIY9j56RXW7loin1H8u199F0UHVi/sJ5uTjekT4ztoXYTqEBgNnfOhYJTbLoieTC4IeTyQIq1qwHh/Sbwakc8L4vWWv34/37bwOW6KW9z18DeQXZzl/W/+eVo655+e/hquf/1Vvuqxb6esNP1dTV7bvIqdeZK1dpcz++Zp6Zzv2P9ZzvyFRU6NlvkvN9/AwV/XmMJy5U7N/rvOs6M55DMfuJWyDfMTKY5D8SScYUU0EfQq+MDr0k39xK2rhV7BrjEUi3PPOUzmQ4YKVfupg1wnATELojjxQ/eUD496B9u7eOKwif8sidAOZl+wtWOJjcR+MaBtU6s4X/04RxHJn52B1nNJXdSrCqKJWEkWXYXJFW7vRCZKfeEz6xKqliPZ0Ez2FuRjn3w5UNidlaRiWqniVAzOKvLdFS435JVGJRW2lIqz0cmYAPTTetQvhd60QFeVp7xEUHk+buOqFmrFvhxtrBT8ubjAlP2otho0Q03ZrdCFFscXDYwTyrajnClpnJGApWy5EsQ484VYJoVXoB64ZFqI6oIXIb51oqQvZMN1bQOCvC30pi7eCl+EhQLYo/NRoFU4z3WOphQOoBb31oWw2vaedvrzIJ5kZLA7MlQvRo9ijzY7iqZFDyUYymxEIpy9EFF0hCIUZeByVQsmq4ar3W1qa0VftEbjqW2hfGFeZOnn1BQJDs1K0GqEiUKYRNptCHmgKuWz8t7RMBgrSBMWfjfZlKK26E7tB1UlU5BaTxBNJyF51zsXRQKsDHf741iFBtHTYIIjjXd3Kbr+PX1zFpqEojVF1ZXdFlyEnO/Y88mdhsm8UP/yrqrPd7LmKFt+PSin7xEQ+UAvqycUpRwXkzsKT2usU0Qn08lCmCqkPa+78+tKcJWziTzf5XUP9OXHS/jxsqa7HPjxHyYtW+CgfYEXLb6bN5e86saTPPSFY0QDRb634Mihy5zfmEMBk36K6kXMntA16nf4nSeZSSZ89sHrMRNFtZyzuNxnbWUGczWGfRNmZ0asrwrPYHZhwNalGaJNQ7FQ8jtf8T6+5QvfQX61SXP3kPxUFxs70r1DWo2cjY22jHUji51EmKEhGijuePPTvGPxMf7j2dcwKWNWHl+mmqmY29tj49IMyWyGO9XG6W3extqRXI3FLSBymPmcHQs9hllCXkS0GjnrZ+fkgLRL9HpC3FO1fVc0VuRzFteVZuOv3/YpPrl6jCdP72XHji3u3XmK+y8fZn2rw7fd/Hk+t3aY5y7sEC79XEb7U236hxx/+6v+kC9sHeazTx+FkSHuGXY9UNZ+sXlXc/VdGV93w8N8+soRLl1Y4NU3PsdsPGZvukmsKt730OtJzqbYxHHwDzPOvaXB4hNC2egdlETMbMnSuqAZXiPwVLTlXU7mS9onI8avGBMlFfkwoXEyYf8P3c/K719P9V8XKGYgW7Skaxr1yh7V0zO0LskibRMRljY2rCR5Gs+Lnxe0InAbA7ezd2vG3cdO8+ilPTTSgi/d8Zu8b3Mfn908ym0z57ihcYG+bXJP4yxf96Pfy/f/vffzhxuv5OMP3cyho5dpxgVPn9lN+8lUxqpfsc5wlOLOt+icFb/zxqpcy0nfMl6UqHRVeYsuv2lOluQ5nbNIYqQRi0iU30B6ri46N28Q2zgQ7m1zBXCwdZ3jH73tg8SqwijL+XyBq3mXpin4zx9+dT1uj3uqtq4Lo+0whZAUSojHeKqH508mitEu+NFveT/vbg/58fWj/IeHXwsbCcznHNq9yjBPWdtq89XXPkFmIzbyNheGM2wMWwyvtonnMq7deZWFdETTFKxkHdYmLc4/vptjt51lkKfcNH+ZR1b30ntgmeZVSPqOaGyxiaJMhVPutNg9bheEVg0Rem73GtaloO5ThwlF75AXmY6EL2p8YBJs48/636+Fgl7saSaS9ghMEXHPS41Htg6XqekIeIRTCVVGeO/yWmEaEJwdrt4hlKJQpAckOTQNYbPHSbGEcdhuBblGef72lMussLElXZMpiS6EStS8ohkeEtuSuJujtSO/0hK7x/0TON/waapCDTGjaZKkLqcUEOULt9DMbKdVSMGewcTQOh2Rz4LdP4YrDUHRmxXp5VioR143EVDqyosPq6b32lbSBBRduWaDjWCgaATUOmgxgrgvoOy1U8t2qofaxisONJlyio6H+yGEPAVHl+A3XtM6Co/uewRXHFqm9Iawb1UNVwco5TsK9NgQb2mCuL2YdbWgVmgdqk65rL+H/9zljEVPBMwJdJDgHBL46PX1Uk+ImBbahXy/2u7TTzaNt8IME7MwEQhNDL6pMaM/HjSlczlfC09Zhrs1+ewU1TcTWbvK1hQ5D4FAQQAcOOetq45sTjHeMZ2UmPGLqTh4RNwp+a7dsyKiDZ7j+Yz4t5fevz3wxW1Ezb2vj4eitp3c/h3DNRUkZXKvyl6Rz8rvhtTQUMSHRrA+X57b77yoNYhSw/Et2v79KmmGgiVk2QC9MeGJn3tp0V3+P+/7Pr7qfW/9U3+vJ37zaXY8t+fLdJeX8qN5SZO/aszcp5o1jxQn91f7ZMTBu9b5QqfCRRo1NLxwYg9moInGCvbnqFK4oXEfhvstjz27H1Up2vv6RKai32syzmLmFgdMTi1w04HzLKd9Pj64jnIzZZwlEDajSvGbG3eTrzaZe8rQm4uxLeFeTwYp1+24yrsOPM6Z8QLLyYBz43k28yZPn9rDly7u491LD/NdBz/Nr196FfuPb7KZNxjkKcPZDPNE20cSK2ypcCMZu1UNv+nP5zSaOa/eeYpLkxnO9OcZ5QnJquHY604xqSJOx0vQa1I1rRwgrXGxY+GBhPVXVvz8U8fJeilHD1/mtcsv8IuffB3Jhub4VzzJk709bE2aRCfFDjCrFL1rHEf+/uf4g384D2xy9LUVg31RXalUqa5Rh/SxJr9z5V4aVxXzm/DwCzeK+0DT8ygjxze889OcHi+y+mt7OPK+i+THdnP+zU2SV27y27f9R975B9/DZNnRPBfVBUhjBTZu1oxunqAvNWhet0G+0RA/aKA/aKB2Cg0q6hnGBwpYa9Ga+E0lhvYlWeyV1YKMakFZ25fFbrFsykYRUjk7j6dc2dthsTvkB49+CIB//am38+fv/gLnJgv8+0dfy5uOPct/7L+a2a+9wE+c+gouPr6L1qri8sW9THZW0CmZ7HBg4fuuvY8f/dCfkzj0JrQuO7aOKmZuXaX/qSWG+yxvu+cRXj3zHIfiVa5Pxvz4ymt4dGMPV3/3ABu3iJVcECMFvvZol6JsSwT7G1/1BP/twZtQlSKfkzj09lXLV/zVB3h0uJ+NvMXZ/jxXN7tUhRa0dFeBWYvAClp5+AOV97EuUKVlsqvJaNlQtJU0BX1bF31OCz979gX40X/xbfyIR56637hJLzekLzS4cGafpCfuH/M3lz/Jtz/zrWRFxKHZDSJlGZ+aIT7V5pQ6zNM7XG2zVzVgxwnHyrUdbt9xnq2iyet2v0D2rjN8/My1NH67I6h/7AOMUuGNJz3xOne+iWlsWsqmR3q12EFaA0qrejxtMsfcc9QIWvBAHi8qTAatVUuVqLo40YXzxYogl1KgSbEdjR0ugqyrvRhO19aOAW2dclddnUKorHi7u1gTOO4A+UJFPg9Yz8vuyZTNKYXxCG9AT5MtJQX+lvZUAVkky9lSio+xgcgJXaZdwUQzu3+L/mITVWnmFoYMnlzAVZB4xFefalJ2bN2smbGqqTQ6g2LG1Y2h81SLALaG5FJVQT5fkZxLyZcqJreMqUYRkXEkh/pUlaYsDPmCCC7LjhSogRaEk+8p7699Aq+8x3Z7PXG+kb9XHdEAGY+4B9Gf2Y62Q82pDtSb+uE80u4boNCwWl9EBWS99JS9WiyJf71tNp42nX7WgHyH96oajub5uOatB05zNPB6g0JJcecbshDeEzjoVctJ2FThrYHxfvEemdXVVMAYHE/qxiJQdPx9gFyucn6tD4cqFMViBRXoTNe6quBjbiNQiZz7aJsTTGMDhg3YOqKnyLMvaqtUjm2gpEyDuph6nHtxaj+V5iTZ8B/Pa0hKz2YNhX/Z8MfISbGrPDc9HNei5Wk1LjTm07+HcLfauSfyEwMlr6Ur+U7xaFqs29jrSrrTpi4Etikrv68QSp3zU5rantJPgErJyhLvd+8BX3SAbHq9l03595cdQvt/4ONlXaTjwERWghsyIFibxdIhf+TX76HZlPQ9VUpqmUscjBRmPSYayqI13iGLvEtkVjXcaoBTNLoZzt/ti8cv867lR/jS4CA/fdev8dRkHz/zgbfz6rc8xZcu7mO2kfPw+l4WDmzS31ik0coZFQabadIzCU9cvYbHo2tqfmPVlVCgeNPQfmWfj23exGOre8j+aJnRq4fcc+A0j37oAG63E09X51GWTKHddFG1BtK0YL494u7O85xJlrBO8YXPXI+dtZz+8GFsCmkF490WOiXJOQkUSdYNW9c6aJfsmu9xdrTIXYtnOZyuEPc1t735BO9aephfuPAahllC3IfxHseuT4v39/aH+vTDrP3IcRqrkPSiekzZWHNeha5Ieo4og2xe1W4DVctC5PiVL97D/g9rzv9ty+Ffb7F1JKHoOLofmuWdF76HpQc1GzdAfuMYd6mBbViaVyXK3DRL8kXN1koXPda1qLdabaCbltZ5w2SHRWUampUIRj0SNFkQWkg+631wAZxi/jnr0QrZ0MMI22Rw4Qt7KTuW/6v8c6z32vzTN3yQ95+7h52tAcf2XOXjT9zAG296hlhZHlndS4g233f7RU5fWAYrIt5vf9Vn+fULdzF3QjFZAP3qTVrtEfmoyWCcsvstFxheWOKPnryZ+zrH+LU7f56hteyIe/zkkc/wzW/9y/y9I5/lY6s38vU7H2TGTPi33/0efvbnfpJPj48Qq4rjzdN85Qf+PtFYy8h0A0ZvHDB4vsOHfvc4b3rXQ9zQucyuRo9jB67Q1hnn8wV+/r+9kXJBphbtkxFly9HfFzFzTpOuZhQdXY+kk4HQN3Qlhy/KBL0uUylYBwf8JpfH/P5bfopvfOg7mZyaEb7yqRbftfwerp+7yoXRLIkpWfvwXtpaxFplGyrvLqNzOf6D3YrioUUe6C2iLDwyJ4h/96Siih3EPrjIF5Q2Eg73djeFvKN98eO2iUHlGhDqiIe8fBGRbrqak9u55Mi7io1jmvZFf/17aks0dvVmGziweVfVG3jinWVEXErtfhGQ9IBKhqKhbCiUk9+PRw6Ho2po4g0pSsu2rG1lSwpYXUiBnGyKKDufAyoprMxYSdJo4kSYOYxrO7rJLgdzOY3nG5RNGD+6gF0uae0Y0ohKNudLkpVIDolxHgGWqZ41DpVUVCupb1bUFJndRoWp7f8sVMsFTDRmNocdltgqrFXM7ezT7zeprCbrpahCCnRBg+UcukhQ9MZaoFD4CaODZEMOZmgE6hh7K0VNNBSeeUC/lUfYtzuRhOIriPbCv9vUe2KHfzPbJkqOesqRLVZS1I5NDRzV4TgluKDp8PcL/vxXqaRrau8+Ehq98P6KaXPj6t8BfLEfiu5syRINxPXHOhGZgjR8Iqx1MFGUM0JHwUnYX7JmqFJvPekblO3Ievi7qvw9siXCVJu4GiBwBrLdOcn5pP6M2YJco9FIEoyNnwZWDWmYQsGJkiI7THOcb25cJOcpHkpGSTSmpuDUrls9aPQctq9qS0OnxQ0FN53CVCnTBtZNOfDOT0vw+0IIbwp1Bniqjb+WAlccqIOKgDpEKyDh26lsdfPj3y/KPH/e883DBMDkU2vFMKEJIv5gaUkpH6vchuC/dB4K+2fgvPJ/irvLy7pIH11b0HqiKzeC79YDKhWQk3zW0bwsxfhk2aGsoph1pKvTeOSyCcWchCLY1OJyg4oseRahtENrx8VTO/js/DG2iib/9/k384rZCygLz20sc2Bhg1ZU8PzaEqNRSnrDFqOVNtGmcAedAZvKJhrs7IpRTLFQUcxVrJ+d42HlGH1uieQt6+xrjfjM80dwt2Yo41ArIpDSmU8R9JuBGSnKXRXjfgM9M+Af/tE3k+4ecu3yCubwEErNW17zBJcns3z+xGEoNAy9q0niqBYLoqsJTAyXH9iDvmbMb9x/DzrT0HT85V2f4tHxQcZFzFsOnODDxU1Ez3T+WIEOMH733fUYMh5a8o5m3FTe01lhE83WUbUtZtnzCNuVeBED599Zcuw7vgjA4sdh0b/2/C/4/wPP/eKdRCWosWbzetn0eaYD+3P0WoQuIYkFdlJzOXZLEjLjLQkhYSgITveMY7hb0VyRZqG5KuK9qqHIuzDYpZk5K5xYG4stZBj5zpyE/leOqJwmerbFT33m69AlXF30I8pFx2IyYj4a8rHnXoHbmbNv9zqnT+7EdAuq3NB6IeZDX3gDjQ1Loi39w5rl5oTl5pBunLE+abHYHHEaUMby12/8FH/lh/4uweP4V5tvZev2nMd27peYZDTH4hVe9eMP8oH+rcyaMX955go/t3WMH33Hb/AvfvqbyeZh54MZ2QtNVl8hRc6hxho74y1apsuFbJ6WyXlmsAtVKZIrMSjZHPv7I0a7oH/YULUbtM6Lz/Roj3iB60rGxiK6VDUCGY0d2YITMeNKk/WqRZbFVN2K1rNyLV769D52vHXI3Qun+a3nb2P/JzexjZiyHRMNCmzD0DuUkvQd40VN2ZQpCsDCiZyrtyY17zuaiO95MvQe495CzuSObHbKVdel84U4SHqoD5UpXM1DDshmuN/Cv4nbj2N2AL3DivYFV9MwAjoPoVBQXozqBD3T3k/dOYqWJnLuRahvQNMDshoaHvFnlzCjsgH5cokZGGzsiHNx9JCiQkRt+ayrw5qAGtUtNdimpVCQrmmfxihFVtwopw4eXpA2HqQURYRuF9jZjHKtIffsWoyqFA5HtBKDiuoirUpDoSLrrYtcHeATjZXchwODmWhsW3gj2liiuMJaje0llDM5SoEqlHh/NyUgqWo44oFMDybLkrSc9OTkuAiKtpO/45HNUPDhi95tQlAXqCjbkGwzmZ732hu7RrGpEzPj4MoTEjR9emXR9baRxbRQDFSbQEuysXdfWTOYCYx3VGKd6BvJfG9OfDmRz5X4VN4wpLTgGtKYROOpk1YIN4uGinhTUxyeYM435P0nmnKmmvKyC1Wj8+G7J+vGi4nVVOgahJgheMc3LmXb4hriLGMySf0MIkalIT2X1KmlyoGNVe1cVBfK25qPgAwrK1NtE0+PPUrOST0lD5MnNz233TMOUzg5ydvGHk6BujRt1LIZ7e0oPb89k9eoEqCcnmdTTb937eYTsiT824ScA53Lmlcl02MWeO/G03Cs2taQ+Y8XhLZVA4poSkEK50P7SY7ynyVMaMJ6ZDKP2he85B4OJAjsT/t9/g8JM3pZF+npuRjtb4DY21ppphd52QIXOcq2ItmAONHkS2IRB7LgNi7ITZUvTzcSMzCgDE5HqEwxUU2SwwM+d/EQo3FCtzPh7NYcACvPLbK5u8lse0z/Qpe33PUEH3/qBtJLUc3/k+AGJTx3z5EEiNeNCHuGijU7z66TjnxlgfV4gfj1AxpJQW+9TTxQVE1X8zCdAdupsIkmnZ+gnuwwf82YO179Ra5mXe5//hqWF/v0Rg2+dfFz/OzVN+BKjSoU0cBQLBbEazFlQ1N2KqLNiHxHSXKyKbSOW4dUF1p839Nfy/9906/xD256gR9YuYnIVEy8Z6+55XouvXGBHT91P2t/9TijHaHjl+JgsiBpndHYQqYYLYm3bzTWjHcK8oWDmYcTqgbs+XFxLuET+3juqb24hsX0IpItRXZ0gokrbtt3gWOveZBLf/844zvGqHMN2cArTXRFioZiV87BuQ0mwFde/xSfPHuUamOGsmuxDUHTWxcliVO46JXQIxqK8W5N0hO+4mAf2MuKwR4pOFtXp1Z2ZVPRuq/DK//iSR7IFyna8jvWiLi0c1rzsV+4Bxx0DWQLKSundqPmLfH5JlEEsydtfR07LWP/fZ0tJlXETDLh6Qu7+EsHP8f6pMnZq4v8wvP38ol/9m8onGXFavo24W899R7m4hFaWR4ZHuAd7TPMx0MGZYPr0ks8kJWcypb5roXP8rf/+geIVcW/2fwGBgdlN5jsq3i4t59v2nGJiY25YOc53Fjhgfzw9NqNxL6xasnnjQYaF2nGOy2NqzJOX3ljzvJ9Sf1dwBcODUXvkP+LU+hc0VAF1STidbec4AsXb6rRygc/dy2PHd7N/h9XqDzDFBX5QsrGgRZVItzyvKuYPzFhsD+lSgShvnRPIhzv/rQgqGJBnatU1WEhVTq1BawTAdW2EbWnqgz3yHURD1wtKC2bikBdAS/a0vLaSQ961yjSNWlIjOfACu9ZeV7ptNBWVnQCYREY7NV0z9kaqQwNgjOqDkTCec/4ytU81tbZyAfGyPOigRa/dSVe+1XT1dM3G8s6GG9qsZ3tyfqXLVgBEfZPUJVioTvi0u4GZqTJ9uYkZxrENw0ZbjVQxlFOIsx8jq0U1UyJ6UdEPTN16ih989+wRH1D1bbEm4pi1hJviQXqZIetudxOg76c4vZMKK80camlms2IFyYYY7FJRT5pEm8aisWSqlKSpFnAZG9B40IsxyjztnelBCyF5FHnnUOCUDAUQdttJ+uiKTh7+OK9Fnpaz1f2RVYQT+Yz0z+DnO98Zlp8uQiynfJLyZoh2B/ioFoscJUi22VRkSNqFJQ0iLekaNc9cZ+ykattM2vLRL9HxUP1omRM1/GfYc5ixproXKMW8upcNDw1Au/v0zqUKZHnlG1b+82bTOECV9o3oFVDPk801FR+CqFKMNs0BrW9ZMeRbKm6oHQRlH4S6ZTfr820+TCZP66z0/090M5UJfQS538/pOqGQj0eir5Dl2ENkJ/pujD2Hv4jSzT2TkmRUMBU5erpiY0UJhMKG0r2iN4hRdybNglhem08FcYmHpUvkQbQL+thWhCcXsK/R8E7HwE1wJ9X/9qwbR3wE5v62gsTmW3OOS9NJP3Lj+2Pl3WR3lgH3RARXdrzF3A0vRHEO1d8oifLctGnK0Y4ek0vnuzKDWH6Mk+MRuLnq0qxt2LfBC42yC+0KSpFuq7YPCx3WYrnQj7RoWc6NG/u8ejKHlozY0a7NJQKnet64Qt8vcAJtbHDNSxqEJGsG2zkSHoWXUDzAy0m8xruzCnmLPGm9t21YrJXoCE1n1NMIvYev8TjX7yGp/bt4sdv/888fGkvX7n3ab5r4QG+7vFvZ2W1ixkYb2tlURMjyvqWjERNBnYkP58sO+ww5gNf+17+/vPfQKwsRz/xl3j9seeYnJqZciYff4bszx0HYPFn76fzzldx8XiEi2C0rOldW9E6b6gammhY+QS3sOEIn7CcqXBKs/8jGzz7b+5l6YZVrj65SLKhMZnspPmcTBJmnlY8l1zLxs8d5tDvlaTvfYzbHyrZnWzyB5dv4Z7F09y/epi7Fs/yW0/ezhEu80eP3QITzfW/tc6J75wjWYloX/B2nU2YPV0yWjIEURhKxqnjncK3Nzddy8zTEfZRsUC8+jePE028XaODx3/2FtJmQLL8BpE4hnscjTVFug4bt0gBZlsVKtOUbdjxoJWCSwFKio4dh9dZTAfsTTdZivp87sQRCmd479Hf4mue+ztEs0OeL2J6tkHfNlivOvzcTb/Mgi54qljks/1r+eDgGgZlg7PjBVom51B3DYAP9m/h5sY5LIrBfsd1t51hY9zi8pkF7n/yKN+84wH2xBuMbMqVYpa9rU1OHulRFIaqMFTjCNMosaWmyqUYt62K8TUVZJq5L6TgHKacos4A63cXqFjcQVQhCbBdnfP6G57lk1+8kagp9K3mZRjtVuz7NxF6NMYlEZOdbfKOiN7Gi5D0Fc01Sz4Xk25WFB1Na6WiTDX9/YIIxwOHmYi6VZdu6sJSKXQhF27Z8HSCzNWfU6gq4qrSuiSouxTzUhEJyhWqMfFHVtahUDRXp4i1jafOL4FbK83BlLce3s/kgJFwlICyCl9cLBx7hxQzp13dLDk1/T5lUygCqhJEXWWadF3XPFixcFRki1auO+Mg1+Q7LMlK5P3jQ2GtMM81yQ5mbAybmHaBG6foSyk6g/GZLnopI26UZJdbuELj5qXJt6kUd/n+HL0WE40UlRWOsiCraloce/eLeEuT7ajEvWW2RFmFvtrwfZym3GiABTvSVAsy07epI1mJaj60MxCtR3VhmC05yp0F5mqMi6FxVdXIZdmaIsa1MBLq5jCgszai9uwO04cg8gt+7WF/YVvRHM5p8LZGUWsX0itG3Ld8A5Z3HMmGIi81zQtRjbwW3ZjUe6074xthLR8yfDYbO3SpaueQsiGNc9yX4KJqpkSPDNFQ19+1WCglkRNqL/Ka+hWOgQ4FoTSCzsh5s4Ygf6gfZiJTELuYE11JqJqOScfSuGzqojGfEQAm2dR1E+HcFAEuG0Ecq2oxqdwT/l7dFhJWi6k9BWTS9Z9RT5/vtDTM4ZzVjj2+mREKiW88crlHpUH3ImyfP2CNn2758DNVQbplWX5U7uWqITwVaebci5xy5PNM1wecI5szRGNxUBN65XYHGj8BdupFLAA18XqNTOguwT3ITKZTiWx2enx0+dJF0m3t5fmn9/izoNT873i8rIv0KpbxGiAcwuC2ANRWWH4MFQ9FbW5T2Qht06IGgq4VsyKuKjqI52zPULWsBLdsJrjZEjOIMGOPbvUikk1Fcf0IE1nGGw1ed8sJtHLc99j1woUcGlkUWxW2DWqiqZoOxhplFViIMoXenC6iunBSBHif4camo/1MgvUCx81rZfSrco2LLUmr4G/deB8P9Q/yitdfZKto8r0PfR3feuMXqZzmH5z9GlbXO9hJBJ2KZCXCRY7WeU3ZEieE8Z6KbH+O3ozJFiwzB7bo95p8dHAzb9l5gt/bvJ1/dMdH+Zcf/how0Lg4vTH2//P76z+nv/8FzJ1StGfzCO+6CVfuNOz5tGW8Q54XDwT1nOxQmJEmHkP12NN8zRsNv/vYbTSvCDqbbsDggIid8nlL1VRMFmHhSzFL3/ccl1p38dCtDwDzvPAT+zl7YJ78Qhv9d85xhId54d/ci1mTjeW5vzhPsimozfodBc3zMVUDBrsjahGagn0fuoydabJxs6jkbTNl5a4u43cfF3ePTVj4+ftZ+e7jFF1JKq3SKYeysQbZksI2HMODlvEOjdOO2WcM451iM2czzZW7FVVXUP2Z58U2cbk14NRgkds7Z/hvG9cz92DCb33g7RQ/FtHeNWBzq80f9G7lSjbDXDxiR9KjcIadxlCwzn2++jiQrnEln2HWjPgPK6/nzHCBYXEY9sCNjfMsPg4vDA/xlnc8xLnWgNVxm+9/+muYZDFFHlEOI3bs2WRHt8+lzVnsJJIC2xiPApbibT0xIkTzSFjRlvPdXHX1WBjtcIMYEovqFLhK821P/CVibdHzGeWMJrqYks37sKhYYxda9A43cAbGy4p8Ru7d4R7IZzU4mULIhi/i5Ma6Y+uIEmqIUZiJrQtvG0mBbjKBssKov0rkZ8WsFzdvWs+r9xQY32xIoQ6hYqin6WGThzrhUISj8hrGF9fxyFHFIqQNxVuVqhrRDMW/TZQPOYEiVZgRDHfJ9OFFG7GnILjIUcw4GpeiF4USOSOcdLQPEOqUkGlM39TcZF34YqppiTfE0SW6nJLNG1SrZOnoGutbHdSTTaI9I+K4YrjZRM/nJGmJMZZhX9bDfId4nevcI7ul6E1MpqBQFF3RvgQv8nzOkvhJpipjytkKO1NiNiL/GhZVesDkagxaPnM+J6i/KhXxUNYQmwR3G0XjVFJ/txCfHhDV8F89QUEKI5kwTPeLUPwF3+towDQIycn+oqvp65oxBLs8Kfj8VLfvkXwNrfNiOSkOTQqbQuf5iHwOij0ZzedTzHhKz1EWKhOuP7meXCRc9UBrif2+lWzo2gc82oxqtLZKpJhtXogo2o6ybUk2pJB2bVdPlKqGo2pazEhT7ZAqMLqcSGNg5BrD6yGCtWA0VpQbiXDZrfKcdGmekg2x88waU8rJ9rC40GThBZqB2mGCLWI2pX0EFNpF4BKvLUkdBXIc44EU9PVtZLYXzVIoY0R7Eo/FQjVMyuuf+y7EKdA2NBGKdNPKfZzb2k5VWVff70GPoALDxvrX3IaYhzUnTN2UddNGL9bEg6oGsGRdcZQtgyodLlKUqaZqyASvbErzVMZTPn7QMdRNyZcfL9nHy7pINwW4dDpqC2io9QKM7eILM/EiEUUdp+y0BL2EZC9dgOkbbOJYOLjJJI+YnJnBepRAhChOlOYGqs2UMrLs2LvB5XGXlWGHqFNQbSa4WBZWMTytcL44KBYLTD9QYaZFjosdV+6BHV8AVxcGUpyXTXHQWHrUsnG9JjuYQamZrDf5V599GzPLQ1699ySJLikGCQ9v7ufxc3t423VP4dZSvuONn2RkE37jc/cQbRnhCCtoDBWtc4aiYygWKg4cvcL5x3bjUssvPXMPX3HoBP/17DGKp2dZPOHovWvAcD7l3PcfZ/8P3f/HzseBH7ify3/vOLMnHTYW6ojTUHQNjVUZb+azPjxoDLrQJO++Cj8Ln7x4lOZzstFG3nIr7svC3ViRjU6VMNoJD3/hKLzaYd9xJ/GlRHjEj3fRXceZ334Fh5fWuCt5ltfOP8tPPfFGlFVkaw3SVSPHvoS55y0zzw+wDz2Be+1tXL67ybN/dSeHPzShf0CR/e3jwjecODrnvMK+qVj/zuPs/p3nWP+Ko5jcUS4pmmtOBIcWFh9WrNwtK7WqYP4JQzRxtFYdl2cMC08KTWN0b0Y5jhntShjuVaxf3sFMZ8KXBgf57JeuYzGD5vkBFYpdMz1WdId3zT5M4TS7zJiVqsGT2V56do2Rm+WF4TLaV5AHGuuczpb53p0f577RER4cHOLO5kkKDPu+4wU2LuzmLbNP8oMX3slbD5zgryx8mokz/Lurb+avLH+Snm3w6OQA7x/ezaRUotWogI7fQSOgYYmvJGJv1hYubrZc0VzTgoTG1KN2qxXOaJJ2ztrlWUkq7QoKX85VpBuG4cGKi68RRDXpQe+o4x+87UP8y098FSYzNY3ExbB1WDbOeCQbdZw75p/1YT+ekhKKa6E3KIq2lmIgERRdF8JJNxNVF2omD0X29JrejpaFTT48lJWmoLHhGC8pkoG3ejQe8bQOnQsaHqguri7Awosob/soiHq6ZX2xKNabTgkVR/ip8n5bxxTVrDTd2U5xaKFQRH1Tf2cqQT3NalxTy8xQ12N12xAQIt8pzaIZa7GSNY6rl+aI1iPG+yrUpRZ5t4SJoT0/on+lg2oJr6BaLokaJVUvoVwoMVuGarnArMU10qesTzb1x81FUqSFgjTqaXQun7tsOVSupZiNHXauJGqVlMOIeC2uObrOSAhYMSOJn8rK2h5v+eTRbcVL2BMCol50fREdCnSPtuocQS29X7cZMF2b/fMCgq5lWFNTMQJiXDf8TK+ZsuMRdjwVxolTh7KQnE2nyD4wOZzD0JBsGGlwfaG+nc+cbG1Dkv01FKwYzUSSWeNNedHgnd64YrwtKlQNi4uk2dG5wsWKcq4ShLrS/rg573gzRfIDjcRkom8oGwidyfveV92SSaI90j29Seqm1h/neCDXZeCJiwjZOyoFXnZFHWxVNuXPuvBhU+Ppdw9o9nZvc+enXFvXCP3LTJB7cNt9W7so+XMk500ajqTv6vu6bGrxNO/IfVOvC0rVgvOwRgjy74t/7UPLPG1KWVc35WZiQSmqhq5/r2pokl6Jzv2HLB2NUYFT4lClKiearsNRTc2pwpTwJYik49SXw4y2Pf70Zwov4UflnQOiEX70KKIqFW4ov6lWiecLes/rEJcdFrl8zgl/3QjyqnPF1lMLFE/P4rRYWeGpDGIBJqgRiSXu5myNmjx3ZhejSSIXjpHfMROF6hTopMIlTpB5L9IKqnpB1jwvrlBM5lVdDOhShHCtlUo6caVYfNyy+49immdjom5OY37CD9/8QVayLp/96CtQpWJ13EZpxx+duJFX3HaKD567hfW8zfxjpt6gAEa3TJjscJQdS7xu6MYZd93zLGaime+MWC9a/JObP0I8gNGyoigMC0t9yjac+eHjf+I5aaw5BrtVzWN0BiYL2ge1UKew5YuWouu48twS/ffcg1KOfN4R+UU4m51GNadbrrZXq8/RRJOeTTxyJijlq44/w7de90XetuMp/uKuz/Bv/+Cr0dpRDBLiLUO2WNUj7cFuDU+9wPp3Hufs364YHKmIhorLdzdJNuV7pD2HrmQ8aTJHY0OK77W3HWXhvjOAn9bEwkeuUY/E0tgxon1BApF0AXlbM/+krp1Cil6KSSv2fLrAHRxxbNcKm5st3j73GB/4qp9i8LY+X/tr9zGoGmRVRO/iDMeiiv3RmDWbMnExy1GPRFXsiTaxTvEbn78bgJbJeHJrF30bsRz1uKa5gkVzTdTjSGeV373337M32uSGpascSld4Mt/J1arDmcE8nxjewKcG1/N4fx+DU7PoTiG+/E0rCigUMw+n7Ps9Q3b9mOKGMaPbxrgbBvX3D3Zk7SdTor5QqlypKCay2+++4So/94b/xO9/1Xv5d1/xfmmeI8fkugmjAxW9o45kXfGLp+6lsXNENPTJmN5iznpf42DtFzya46Gd8o1duNfFN71KZQONJq5O/wxCLOX5qNs335r76aabsNBXZF0JVKXg4tK6ImtP4K6HMXzZ0tPC3t/X4jTixMM9IPZ+DO+UFAzRxHlvdF9khHG6g2pnTjyXUXQtZqaA2IKBcndOsSjiTxcLmq0qhRlrqpalalvyA/KcaKBpnI9JL8XoTIv4L4F4JSZei2TqVyrcXAG5cNn7F7qQWDrdCWpGKHfOKpIFMYJ2MSgz5TUHIWb4Xs5AsiFJmE5B2RGL0FDs6hJctxTtSKlQuabKDLpRCV+6nArqgh85QLrmBfluSncM7wsenGGKcoeCPLiz4KaF9nY3jkAtqV01lPzdZNS888BHrgWRavragQJSJVOxZB1TH2gyHhW1EcSXkrrRwsq5Cw8XyzVlkxe/R/jPRsLn1hONjVyd1Ooi+U/45AIM4ZsgZxxRX5OsRkRXYxqXIml6KoVN5HoJxy2czyqByZ6iDh+ysehpGhdiMGBGuv7c4R6qefu+iI6Gqj7fwZFIe3eX0IRVDdnXo9GL0fjQXIVjUecKQC16xklIWGvFkvakWC4b02NZF9humnkwLdj9NC6X4LHJvJki4NH0OeERCnAXaDM+i0EX0qyH5t5pH5LW9kmwPv8gn40wE0vZMLhISQNloWya+jWnn5va0SYESm0/Nl9+vDQfL+tTNNrnaA5lVA7UiHPN9esInzBspJMdMiq0TUvc0zUnMUTQ21hQHp2rehQHMl4LG438gy/wjcVZTeWcBBRVCttLUO2Cwggq5MYReqwxlTgwADjtKGZl929eEkFp2QQ8dz7t+YXKQBXLLh5ENDYRx5SFpy0brywZrTf5xUuvZm3SIj+QMzM/xDrF8tyAcRGR6ArnFB9/7jrsLYKyxH3hhE8aCVW3pLM4op3mPPHsfjovRER39dkaNfjlV3ySbzz5ZtJNv7l8sUUWtSj3W9J1zbkfOM7+f/ZiRH3ulz7HHHDxHx2vUQqnYXBQbOHKJuSLFcmG4ZvfdR+ffUXCC796G/GDS7Q3IN3wi96yqici8dBiCsVwn2gCwig09n63ZVuRbMKvHrqPJ4sRv7D2Gk6MdvKONz3E7z94K50XIia3jdGXGyw/7Fh794j4423O/+3bZOz6VIf2CF9AS2M0XlLs/kyPbKlJ3C9YfWWLzsWqLq4uv/MQrasVcyczrtyZSuS1V/svPRBTNiXmHGSDSAYWFN6dQ7H8OREmZ/OWPb+heeFblrBZxI+ffBs7WwOq57r8lHkj1ipu3X2Bi+NdfHKyyHPZTlaLLuMq5ruXPskfDm4m1QWtKOdttz9G10wYVSmJrvj06BhaOVaLLp+x17LWuEBWRXxxfIg5M+SeuZNcyuf45Pp1LDf6PPvCblpRwaH2Gu0oQ+8aU05iaFZSFGlHdEnoKRcPKWylaTYzsnFMVRpcYtm4q0JvxNhOBYUi7hlUJPeHqxRkhlhXfGF0hNe1n+GrWhP+vgKVaaw2qGbJW+98kuVkQNdMeN+Db6AdUV//AQl1FfSPyFSrfV6ulXRTxvxBRBZQKCqhs9Qx8IWjaiiyGV0LSEOUOUz5raEoCcVhzXFVCC1GKW/LKc1cPJK0UxGqudpDHVQd9OQUxLmtiwZdBaRUkHT8Jh8ABOHOq7owUNYRXUwp2zFuTpyColZBFVn0FaFO5MsVjctG1pTQFIw0ulDY1OCMo5yr0HnkJ4uWqiPAQjlj0bnnNXcqXKEFNU5FPxKtxPQnXfRIY0qoGhG5hmRLky+VMI6wkXce8Q1I5ZM7gyONLqCckSIx2M5VTaHfqF6E9o4uUc9QFdNmqqaU+PU89rznqjEtpG0ybeZCDHuyIYV6eJ1gafsiQaab/jzQWZQvHGunn0B18cW6nB9fOFtw6TR4p76G6mvuxXz2sjlF1hFwtQ46mnqTyz4TeOTbw5KsL0in/unyu4VGphdKDOp0pig6Tor8GLAK27A12l41vIVnt0Jvmjo4rabHqCkaHhBsM4jIFxxxTwvNZd1z75sVZQVmIthhEI1q39hk8/57bZ9K4I8X08IzCKDDuS1mZL8p20KpCQLYepqwrWgO1JLQOOFft2irOoisRsA9V105wDcixlPWyoY07Sp8Vk+TmTbL4f5X2CQAbq6e5IHnrjvAI/OBS64sWF+Am8xStk19zqeNucXFWugvJtD2/DFKXtxQvtQeckn/GSDpX+akv/Qf6Zpi5rJjtKxk8TLTCzif8bQJj24M95XEGwZV+mhqr/5Pet4FRkPVsahCimZBIUQAUzYdVeporAgijBXv7LIfU8UeYUwtdjWVaG1ibzHo0GNNNAxiFOUROdmcdCk8ZklFlEU77yjWbxDOXeeC3OSb1yoWnhQ0UFUwWjIMv7LPtUurPDHawyOn9rFn5ybHDlxmZdhh9Ic72XxFQXNuwkNfOEbzcA+bG8xA17xGOyeLSbwaM24mGC0WlJNbR7xqz3m0chz71b9G54yinKF20EBB1ZyO6i7+o+NTZ5Ztj+5Zy2CvFEH5jIw5Q2ockePtb/8CNzQu8lkOkT7VlEbAhlh0x8IzlmxWUzRhuEs4rY2rghbZxJFuKMZLMHNaFlWbwj2PfD39zy4zPpKjN2JalxQctIxfOSZOSuxYXGcWf6/J5jFI16cpno1VaK5VKAf9fYbd921iH32KQPkr7j1ONqNJ+pZks8RkkUTEa0Xcn75O8NZtbEh4jvCRhe9cNhVJ3+KMIh478o4im9MoaynPtUn7itHOhMe3dpP0oXh8lrLtaO/PMWPFStkFYHeyyYVsnh+7/JXsTPvsS9axTrGRtznYXKOlc9YmLRq6oKsnDCKxALg1vcy/+tffyu+/4VZ+8i2/ys54i2vSq7xt5jFmdMYb3/A0d6QXOVd2+TtPfiNFP6mLRRVZXKk9d1z4sNmCoywN1Ui4wyqSaYJd9DBh6ihaFc3nE7JFh1vIcZGlGRd8avUoH7l0I//y2O9QzlhmD2/S6zV523VPcWUyw1Obu7i61SVuFmTzSe0dbbIpYhYNvDVhW67PrcNiExlEcPHAN7UDSAYiLNWlq1HMaCK0F7vNqrCKVY3GhaaqdpmwYK383BnZsEN0eDYjtJfWpZyqZRgvGvE197POeCjXgE2mTbccWP9eboq8sv1HgR6jlX+OwzachA6VGpVUlJnAa+VsRdVS6JGubQILjyLbhqPakdOamTBcb6GGhny5lLVsqFF94T4TO1AON1tApWUKOIxxuca0SqpCQwVuOaMcxCSrhnx/TmEj4rVIpo3ZVED7IgeUUo6d+GPLVKnoeq9s44g2jRTRLVlTy24FVtXPRQEWxvsKGhfjeooakOiasjKWY9k+78hmlEzktlGYth9gm3ie7zbqSCjyQ7FtfaNWp6daatS+bE/R30BrqZF2z1EPnuPgi17lue0R9f0U+NehMVRWihBdgWUbn9pfnuXujOhySpWK40q25DM0CjmPOld1gxGNFWqgpsE5iJVlmCo7A+maqQXwJnDQrUytirYUycG/H6SxUz3RpWRLFbpQxGcTyra4lTk1XQud8ddhEKmGqsXvIXF/ep3bRIp5XUlxLteQ7O/JxrZCN3w+f4/K+6j6A/736avhOfWpt/gvOW0mxZFK14W4zoX6UjV0HVRWr4e++N7e0Id73RqhEZnCQeWm9FXvMmNjjS6saHBiVe8T2qcd60rcoJQv+HUp9qr5jP/wXlNgsrq3+PLjJfx4WRfpVSIFbOec55r6GOFQmIexYpVC41JElfqfNzxCMVtSpiV2K8ElgnTqLKrH3HHfe6nnisaaYrLk6g5eF7J52EgJQpH7wJL5Apcb9ET7AAdZYEofVV2lrv5snbN+RBZLqE5AG0wG+bxjbdEjMLHj6t2IAj22kFgWmxkn1xdJmgWHFtcBeP6LB9CForxrQvPZBvpkTHsExcYsTX9jC0fcsXxsjTfteZZz43m60YQTWzuIjljWLs3w0Pn9ZL2Ud73xIT76kTtpXZaFLhlIoaEqVS+4ZRMuf89xZs5WtD7w+frc6FI2oOFe+buNoFwoiecyumlB4Qz/10PvJvpnLeFOomhdEYFguqlwSoSiwV4TJWJSnUO2oFAFtDfknKcbsrhP/ssys1cdzdUEnLi4NFY1mUtRq01mLsr3zzuaxqpsHK3L3hUkdxRtTdKXZS84uoTH7n9zPyt/4zgLj/ZYf+UcC49ssHnLPFWqWX5kxNU7WsRDx6Sxjerj0SBnFNaIeFBLXYTTQoUpvbixmi3Z8aBhvLrI4orFZBXRqKJsGR69fg8AqSq4vXkagJPjZX50z0dpKMP92SzxfMXExRxLL9NQBY/N7uVKMUsVaR7v72U1a1OhWL1Fk1zV3Ne7nuubYr343vNv5l8c+V12mD5DZ1g2Q0aTBD2SysI2LYwiTK6k2DaOhcc0rYsNf9yUF48hfPREAlVc5MBOaWbRpZRyruLk6iI377pMw5T8vWe+EZs4es8JzHbl4Awnfu8Yu99xlrv3nWFSxTz22HUsPGPZOCZNQtJ35DPivaxLob2VbXAesStmwcWOyb4MlxuqqzHNNRGXZouOaCjWo8tf1CRlWCMUvYPy8+ZlxewpW4++Q+Io8CJ0MSqhaMl5DBSa0a4YGynioXi6x0PP782l4FITV6Nof5KLRaCIhYKwLi3cFJlTJbSej5nscDgj/tomlwyCybJMCwuPVJuxEs1jX1OYiCxJ/HsrzJYRZDVxVF2ZbpmxoZiT860nGtvQmJEUE25kIBFHqvRUo16D9ZZ/bupqW7/a1cXTGsquACBxT9xuwve1DUsWC8VQOS8GLHS9ZthYCpsQJGMymH1SkjhDcmYVyRoQkPFguRjsU4E6jj5QVkKYWSjeAyr5otRR9+LiWldM7R395w9Fsy6otQd1oe9fb3v40fZiLkza1H+HhjrjJPio8t8/l0AimTo4KcwCEp2LUDd83ip1YnXrbTaddlTeglN5GpJbyjAXG5SdCt0zYmmo5HsFm19dUNOS4r6uedz5nJPmOJkybdNVQzEjhaTOPapsge3ON/l0H6j92Y3vu3wxH5I5dSmTlXhLzBbMaGqfms9IY1YXx5Uvzrc3t3+CFWM25wESrVAIgCYC9ynKLYi8AC/h3LtIplhCXwtvEJxaZC8f7TS0rlRSTHuKi67C9MWH9jWmrxteYzuvPZvVNDZFj1Kletukx9VTnuC9XyPojpcs4fnPhJP+p/4O/3seL+sivbEGUezHmuHCteCSIJLxC2ksxYLJVU1pAWCiseMEDERbEVWnmnLjClk0wuJQtoRLV8z4yO54yqnUI9l4bOKIriSUbYtNxCvYaSiWxUps0nHosaldYsSz1X+XdfnzZEnGWmaiaj9UE8RJ2smFmRk0juGlDssH19maNOmNU171mme4Ou7w/Au7qZowXi4wQ4MZaZpXYbwsi37zkmYtW+I3XlgkXdPsec159rW3eMvOE/xGeQf9i13SNcMnFo95HqMUz2hBtJw/HnEfDn1oi5NfP0v/lRXxHcdZeFpuneFOiaCvGtKc6ByUizCLY5Y6A/Y31rnmPY9w8l/fSzRUTHZYxnscc0+ZWvBrxtRc9KIlvN9koGiuC0KWd6B1xUozsFu4ftmsFE3jRRFSmYmM+uOhLPBy3CWJsXl1mhA52KOZe6Gkvz+qvWd1kmDzYBcEyz99P2p5ifw189inX8Acu112mfsfYffGtVx9zZK8n+caK5SnW8lGGbjaIW2yaGuisfCkVeS49KaKqJ3RtzD72SYmEwvC5BcWKd6Z8SsX7+GXjv4Wj+eznB0t0FB+ZO00C9GAvdEGczrjuWKZO7pn6JoJy1GPSXUjRzurHEzWpDnpglGOls5IVMXrdzzP+1dfzXWtK1zKZzk3nidfaeKaFhVbsRIdi6DatUua52KUFRtB5SDtOcpUkW7IuTe5w56Se0I5aS67F8R1QsTEbS7ER6SpnlHsLPB+xYrTTx5Dd+Dspw9wrpINvNkTW894JI5HjbWSzkV5vtNQdEJBIhv2YLdicLiCzaRGZqMxLD7pGC1rJotQLFnyGcNwt1RZ8YCaHhIPg8BUXnMyJyFCssGHvALFaFnRuVAx3CX3+WC/prEiTcRoh6a5KtOvaCzHxUZ+Y/a84lqYqKc86FDYKusL8mCLF1BcJ5t2Ni/3VTEDaKGS5E5cPqoUmhcVpRczWwP5coWLLNVGQmPFUHbE9SP41xM50ekYhxmKyLaYtWCciDi9E4zuaZwxdfHt7xQJs2o41ER8ygNFJDQe8aae0t+UIJ06h3jDN4JJQA3lFVUFri3ixKoNtCpUP8I2K9qnYknkDPeUldToaCziy/aTiaQdr8s5rfz9bIQ6L+89BpX44j2dnn9rECtRT5Wp8wI8cBM41qGwDGLCIGoOke5BsKqqaV5H3FM1aBTE1coXf3URlkgD5Zwg5FYOb03NNGNvxbspnULV9IFRONEoTBSqEGplQNMpt1GPmhYTW8pdOWorknujryXt1IUiWtXnp7av9EV81PfAUiImCI0LIhI2Y1VPA+rpEJAvSPNXpb5Zd1N+ftAXhITeMFXIlivSVSP6gqGs4wIOCDVVdFySYNs5s80pKVw3BkkBLan3V11M93KQP28dMmSLsPxwNQ0q0jJ9G+5SLJwoUaUj75oXuQAp68WlWuxYo7Eg8lvXGDrnbb3mOaWwzaim0OjS/7/w/CYvMi2bGlO4uvAPAnFnFFWi6kCzWrsRKFsldSP05cdL9/GyLtIDZ7xKhY9qI4/wlrLRymgVWaSME7eDkSIO8b6VuEbkXen0VWV8gAg12m1jh8lVjS7oXPiSJlfMPym0mfFS6JxlMYxLUy8kugCzZSjnS/TYsOv+qevM1lFF97Rs+tmcqhGc7YtY2XLYlhVEslCQSyjRysosLnKM8gRrFeOLHe5fPUZ7acju/escuWWVzz59FLeQ0zzdYHzvEP10W1AAr7LXpYSenDqzk3PtefZev8ngzAzMFbhNQ/SJWRLPg0vXZZNLBo7RTkX7PCw/MuL598xQdUtUZDlwzzkuTPbTviSolarkffI5J9QTIBvFXNFdPvGWNhf/0XG6pzzicF7TO+wpCYn419tYUPRAa8nmhNPeWIfmuqO/X4Q9VQoz50oGuyKhnRTyXkV3inw1V4XWUDVhPCPIW9EBpxRFG9pXHOvXRyw8U3LlWyeYG66levpZOSFKI3F7cP5br2X3/QO2vulONo8qFp62pED19LNUb1ki3RI+e5jimEx0Ebp0FKmu0/UCr3kyr2hfduz6aETR0qzdqdn1KUXn3AgzzBnt7+CMojs35spvH+Qbz/xd/tPP/ARPXNzN5kGpaApnWC87/MHarUyqmDctPM3IpsyaEYt6yN/d+1EmLqahCvo3F2AcXzP7EM/lu7ineRatLEfSmBkzEaR+Fv7W2z/O6WKZI/FVfvjsV/M1Ox+p77v3/cTXEmWyWZmJo2xpkqH1kwNVo0TKQZmq2qUkHrgaTZIC1JH08RQQeb145IgmivYVKUbLpmzK2YxsiJK+J+FTwQ1Bmh55jaRXkndjWhcMnfOy8a3fDBvXy/1VdOTeSq7EtC/ZuhjGQfuyYjInHuvSvE35r8L/Fe554AM31h3DXaZGv9sXpEFJ+rI+4Iu6yZyuBa5lS65lk4sYObxm5WkwtVOFEwQ8cLal0ZNjWc1U6G5BVhjUVoSdqWBkcI2KcrbCxRZVxbVLEoiLSjnnSDaMp62JXiBbstjUEm35YlkJzcRmss5o7zEYbxiSLVUXQZNlR7wl39FFDiqhzZRNoa+4GCiFTlh0pyhyTQ3xPu21O4VSNVpe88ArJMhovhLx6kyBNo7RtfJ+zZOxiAc9ZaLoQnI2qRuT5mpF3tX1dZj25R4OaGeVKE9TmYr/QpFtjUfpE9lL8lk5f+F8hM9ZNVytYSpbwu8OYuQpn1yQ1LI1pcQEj/XtRWSgzMg0IFST4b3Ef9z6a8AaILFirWnCtEHVNpVl11LNiANQ2bGCxkeQbBqqUROzf4yaxFOaT8PVHP+ARFcpQmPz36nWSigpyuOeXKy6lOUx21GhJxozlslatrsg2oym13QI+gpFfxKmAaHBlv+3LphaC6LKqeYgXZXvkM9CsiXnyxRy/09dVKQxKf1Es0qUD0tyLyqugytTMTPVsKjKkfRKUJJi6xTYhhaRZ6mo2oqktHVBHZqDoDVprsr9nM1qH9ZEjdAHe+UQiKZzi020OFJl/t4uXb2Wxf0SFymqhgdiEgENnZH9pHJSs2QvwTAjh/oz8Ul3fwbv8b/j8bIu0oPNYtkOmxx1FLNNAAfFTCUBD5XMqG3sO+CGVAqF8wX8rNw8yaqkgNpUxuLRWE3jgZ1sOjkSiR4PHemWo3MBVm7Vnk8m49d8Xsb9NhdkQ48MZqxZeaVsap2zivZF/0WUoNxO++AMpouYLhRqoKdq/ZkSeuLvnV6J4LlZxocqFg5v0Bs0mIwSsknC5VOLsoFiyLvQamb0uy10rsgWHLYhKFmyMOG65TU2xi0++NuvpjOCKk1prEvzMvdcwZW74/p4l03FzClHY9MKxWMAVRf27txg5UP7KXfBZF6e21j1gSldGNycgYJ9uza4+OQuOH4rd/65J/jMZ25i5nnFZEGeP1lQRGNI+nIchvsg2YT+QSW88aFYUvaugZmTQrVQFQz2iK2lyadCtcBhXr5/jE0Mm41EJiVbIvLLux6l9DzQ5qpj80jE/IfaKCv2BTptTNF0pdn3m6dYe8shsjnFgR98MRc/6TsGexWd8zIGDRHxRVvVBYFTimweoU4ljplnhauurNjvzT1hMFnFeEeKKRJZwBuKa5dWeOVfe5jf/k9v5J0//b0UN2b8bv8WRjahXzVYivscbq2yL1nn27oXeKHM+MX147yjfZ4zpeaRyUFe3Xye7z3+ETIb8/0vvJtJGfPT9vXkRcQ1C2vMJWMWEhEeX9e6TFePeTbfyfqkxcV8nq6Z8Cun76o3RBspbCfwRBVFSyg94DdiI7SP7XZpATkO131Ah1/E0bZuKqwMTWLPkc0q8q5CF4YqFTGumTh05dBjS9HWVKmmfamkuaoZ7NHEA8fOzzuUlZ9vXK8oO5bFRyRRMB4J6rZyqyCU3TPUVm4BDYyHrkaEcYKId84XDPbGPiAFmmsyvZF1SBPoKUVb1o8ikjH94EiFGRs6l8Te0xlFGQu6FmggcrxknarpB6XDjG3Nb7WDGD002LkCxsINLhMFjYrW84kvpHxSo5FzYLYMVSKFSYhtb17WjA6IKt6mDpvKuhWtK/JFr+yzjmhoxCGrEMSzsSLTr6jni7LYe8X3ZdqoM0XVFpS3Fkz69bFM5L9iVmBonWmZYk5kDU02JPTLTOQ5OldQaSrt0HGJnShUqRkdLmiejTFj/JrmMBMtLicFFB2x0KsSxWQZsjmNKcS5SQulX4TcrSlKmfRcPbWobTO1fDfRGMjxD0VksEl0Svag4LhRdOU7p1sw3CuuYIHfXjVkshvQ0aCzCJM2l/rJgr8nnJlaCOpSCSiSaxFbx959zBfTAbGOBpoqBP/kQodynsJSzVboS01xfZkpsSODmy2oJok0V8i1EI0Uzk5tGOvHNk6+fCYPRvQ05XKB6yU4LY2wTcWxS0KOZJId9wUYqU0eKgF1wtS2zh/I5bzqQlEulegsJl+s0JlmtMfRvOwXEiX0FRvrKbVIK8xEvMp16RgvmLq5CU1v0ncsPqnqdUmXrka4VSnaK1U5lG+Ym+tVve6FyZ+8ToWNFElfim1ThMmIqz+foOiy1kmd4qlHEeiJhDuJs5NvKltGGjIfrAZiOV1qD/IY3+T2+fLjJf54WRfpRVeKuXRj6oOezU/Hmvm8pXVePGKLrqDoZcfDeA4RMuFHyhZwPk47KK0tdRKdyfymF0RIgSNa4X1Mffy2HzM6BfhF0qVOFpGGJRpoVK5Ieq4eCzoNsy+4OrylarpagV+lrk6Tsw3RTLt2hasU5TVj7PkGx264wPNP7MOlluV9GygFa+eXfCy3Ye74VS6dWyD2vNiop7BjEdHm7YgTZ3ZjVmNSO+W65TNhVKzJ5xztM8ExQ4rOwT7D7CnH4jsvcOrMTtY+tRu7MOUeti/C0W8/wUPn9qFOtUnOp+SzlrtuOcsTf/cUR77Y4L+cuAG1Z8JGM8GMdB35Pe4IetVYc6RriuE+GWUXHWidtJ6zqhjtUDQ2qLmgVQM6Fyuc8c4dG47RDsXW0QZFWzHaDXMnHI2Niq1rxC+9aOMFQ6rmvE4WFC982w4O/pPnUe0m6pZjlLMJm0dT2pcrxguKXe/942JZkwsFS/iugjLWITa5FJo2grQP3XN+Yyjsi1LymqsiLN24VtO6LIW7TRRP/pdjPNo8xmxfEJW4UfL69jMYHA1VcSzu8JMbh7glPc+FasI7PvE9XHfoEnbZsT+q+K1skdWiy2+9/42km/C93/trnCsW+MrOkzwy2cdrm2fYshENVfFCuUBMRYGhcBF/bt8jzJkR62WH4QNLzGTekSQItf3UJx55tMpTAOpIe0ftHS50Db9BBZSQgBaqWlvyIttC5B5rXXVM5jVFR543WdC1EK11RZDpZCA3b7pekHcSdOWfZ6F9pcTpqKaXRJOpKFR7WkPvGlh4khc1IsGX2JnwPMdoV1Tb7kVjmMxNN92yKc1JeH6UCTUon1EeBICtw4ruWSkiA+0tmlhU4Sg6pi4AdOkTgSOFTQWRT69osgWLXShwuSZayChNgpporBLecGNF1UJEF1NnQySbYc3zHt4T0euI8FLB0NTUh2Rd0pnTDbmWy0URhda6Hv99q5YE4hRd74ufWJItg/UTLZNDtiDpmLlfs0PaadyThibuRfVEoui42iZXZxq7UKC3IlTksJsJql3hnCNei5gcydAbMW4hJz7ToBbUNTw/3HhktSUOKK7C23BCPJaiLR74ptAjxU4L0GKjKTfZeC1B4FRbLxyOJs67kohtpvGJr+qKnNOipWiuCf2haAv1yUZT4bALhbm/lrJ5aRrNSNXOKypyYBU6U2Ah2hCBrosc0UAAo2IW4VlXHskvZF+rmo5ytkRfjbE+5EgPTc2DjzYiyvkSNTawf4y72pDrJbXYQqYoFrl+nOFFwUvF3hy9HqP7cj8W8xVmMwbnXW9ioasE2pC8kKo1A9mC9U4+1LklTsngMpwz27LEVwylcuRLFRhHekmEstmSo3XZ33d62+9biMah65efBRG30JOkoFfWgXVov5dXsTQ5ZhKoV75OcNPmzOlp4JnJLDZW2HiqoQAJIWtf8lz0NEzHpk5PQXQuYvgwHfEC9lworS6V19SVxRrFZF7XU/7gAKTCROUl+PiyT/r08bIu0heftIyvgdZliy5gFEuAQT7nx4bO2y72BRkIIqCqLV6+8ZZsLDgksCWIOispFrNdflznUfQ4RPsiosRsQcIV5p+tWHpEwohUGSLAVY2AOAXRUNTxzSvTsR5IRx2CT7J5Qdl1ptjxoGb9ejBOoYsYCYjQqKEU60SWKK6YOQGXr5uRdMH9Ja/f8wIfP38t1XKBKzTl/gkbwyatsxFvfPdD/NGnb68T/rDgCs0rj57jxAtHZOxoqNPynIH+AYMZQ//aiiPXXeTS1gzFw7Pijz1sMvrwPtpezBJsr5KBLFgPfeZaooFisq8kmZ/AWpMnbq94/pdv5/THGkSlcBZff+fTXLynB0B06CCn/sJeQcJ8iuX8My/2nW5dLSg6SY2ybt6bs++Dxm/IimxWk25aio4i3ZqiFs2rsvFeuSuiedVfRH4tKRvy56QndJjFxy3nvv94jYrjZNqx+LOfZ9efcC2ufdfx2nUAh1hx5QFRoS7ETe6Fg775wwl3sbY582IjncNgv7jEmAwJVPLUAF1C+uEWf/Uj3+M3JvkSt/3VR/nDKzdxemURJoYTZ3bxlv5f5sDsJqMypp81eOM3PciudKt2irl/dISJi7l/coB+1eBQssKiHnK16rI32uSB8RH+4OItvHbHC5yfzNG6Ql18oIT+VDakeLGRoMaRH+kGka4p/GYUITx1O63Bp0W6bFS6ELvCaCRjY2WFgyl2Z450y8q/lY7JnCabldH6cI8Cq2hdVbSuVlSpJu1ZzNhSHIjrzzdzGnqHBSYPaJfT0D0FG7eIP3fvkMJpU4s0u+dczZ8NVLUqVjVtw2Q+GdJT7UIjW/nrLptR9ZjaaShm5T1HmaK5It9NF05cgBqa3kFN97yt+dm1BaFHCbNlQRPtwBCNNW7YhEREZ2ZgUKWqXZCcloJLl/IZAjKZbEG8hUdOEV3OWO6BAF7kcxYiR6bE616VUsgqK8WaiNCnvuhmLFOKZGNKVwhTiXhLEEJiEf2KXkRNNSulTJcaa8KnUBUoJ++Xtwy26S08Y4fuiXVkuVyQnk7lPlpvSCPR8QhwLpOtkAK7/LCjd0BjEwnDmj1lsalcEzUtwR9rp32BHqwzfBOqfYqtyafXd9Gexr1rjzBPxYHbBH5hmqSnIkhlHSqX+zr4uzfWpgi+vIYU1hIkNEVmcx9fH9YXfVY+c/CED97sulREw5gQnlf5CbMzktVhE4fKJAXbXWrWHHsz9Hacmdda9YwU3p7q5QzEF5MpoFWBKhTRUICwcE3IVNtPEoLLjRMgKvE6hTBJCLSRKpXz6IwD7cjnLY0zSd0ITHZY4k1xqIlHtt6r6vOl/FpU+JAwozxtbqrRCJMxZT0VRStJJXZgU28IocSSsUy1fGcVXpMXNQRhNRNTBZg5I9S/qvFiu8gACDgdDCicn55bshkz1b1YmRaLw5A0sYHSO1kUfVegir0kw4y+/HjR42VdpIcFcrhLFiy1jUvuFLTOacqOFGCJv6mTLUXRMZ72Iil1ygpKW3vZOr8JqYh0zTtaRH5U2JTfk1AjGO+xzJ6WImvX5+Dq7WzzxpXCoUbrchjvFPrG1jG5CTtn/XfpKMq5EpVpiB1XXyWba4iDrrmDswWqH0HD0WllrN7ZhK0matbSfSzhY4vXsnVhlsUDG6ytdtFXUnbfusbpww0+8tnbcLGl+2RMlXhKkIp5LNpL5Lne42V8+AO0L8l3joYy+rv8R/sp7xqQ3rHJ5NwMw32CdAdeIQhqZg2MdstnLmYc0WxGcbnF7HNynr7xlof4w4deTZVCvgyf+cxNXMPneO4X7uTe619g//Ez8rxnLvMjD76d8UqD9uEtJk/NibXe3oRkIJ7yc886GicTqtTWi3GVwOyXLlOePP0nXjcL/v+n/8VxOudF+FM2FEVHELiZM5bxooxOW6sVTisaH/w88/+D69DccC1FC6qWNAJFR4pVXTiibLpIQ1jYheMY+NBBZBYeNla0VhzJC7ZGXZKBOIzEQ0c24693v0EKmqe4vn2JfY0NvnXv5zkUr8p3NSPeed/fJG6UVBda/Lnr/zNDm9LWGd/9S3+N4roxX3ntU9w3vo5Tmwv0Bw3s1QbM58TNkmaac3RhjSvZDJMqFr/vMAJWU/Gj9mixNVOajy4dsQ950pXDhvCfwvrGRdfTGXzstrgyeCrKwNXR2CH8A2TqEZD7tCdofX+/oehIsT5ejkj9hKV9xdE9V9DfF7NxrcFMYOEp5x1ZvE9xU9Ncr6ieM0wWpPDuXrDkbc1gv3yPMlJ1iIo4ufgJTFsQ8jBNsNG2REuNaElKQTbjoYy1Kx96VKUw2q3onpGxfJmKQ0znosSS511pNnUlDUnsUdj0qpachdhRNUu5lia6tosFEbXLsfTFtRWqgZkoGityvQVKoCrFqaZ2QvFc4NYlzXin9X7m4osd1tdoRO18o70gX+eC9tpIwAZQ02LdR79HI18o+nvBjBVoj3SPxUErNPYqV7jEoYxDb3pP99hfB8ah+hHZgqV9XnubyqktJ5ptCbJSqHUu2roJRgnyXbQEUR/uUDS8rimauJqe4Pw16wxY5J6VYCzqIrxuNM2UHy2x8o7YW/eFYxX1XS0cDcLGer/wU5rtLiBBqC9OMdLM2Xha1IZCMxTONhKgwRpoX5y6EwXqRb2XKGqrwSoxNQ1tvEPObT4L8cBQdB3R2CPFcRAr+2mxL1S1F8HGW97Ws9C1jbF8h225I36di0ZqmtQKtROLM5DtKYjXIoqOPziJY7K7pHU2Il92pCuGbKmqBc7KOiqjthXDnkbWEPG6LoWKlncNSd83+oX1DZrCqinVJDwCEBCmKdZAPPJFvIEQoCQnflr0OwOX71HsfMDVDbvJppqZFz08taZKRAdjckvlXXPCmh5+Fhzg5Pem11vR/eMv+//2w8GXfdK3PV7WRfrR7zhB/z0tnvqRw3Sej6lmkIKgCIWlR3EG+DGWIp8VVwOd6frGrxqIfViuUM5RtVw9OizbU9Qo31n6UaMl31nSPBvjIseVu7VsTg2LKmHx4UB5kE68LmZ8B57PCOKkCsXGTX7jUQ4KXcdmUyh/8/uxeS5Jciq2uNkCk1ZsbrXE5vFCSjFXCYf94wuoI5bqw0voY457XvM0Xzh7kBuOXOCFTx8in7MMbp3ARoJrWI4cvcTqsM34TIPBfqGpTBbBHRyz4/seBuDiPzzO7LNSIF7daFCOdR0qYmOIM2iuCF0nGsu/peviVGNyyNYamEyxdUfGrlfeyNHGJ8Q7vQ/t04bdnx1x8XuPE12Bhy7cQPr3oPHmFX7iF49z5MeEVvLcz9xNewNG+2RsXqaQrsHWEUUxVzFeNYx3woEfkOf/d65mRLt3UV66XP89f/tdzJ9wzL7/cwCc/WfHaawJ+lY25Lsu/+Dn/h+vwejYEc6+c0mEqT5F1gQEvZr69gO137WNlUdwQ+Sz/L1KVb3pinhZONhyTIUilW6V5J2k5r7qUprVogO3NM4xcQl7ok0Kp1mrOqxVbX7k3t8lViX/svOVnMx30K+abFVNvvrdD7BZNGmZgq9afoz1+Q7v+8ybYKbkh+7+IDNmQqxKKqe5Us7ykdVbMIVvhiNXexVXfsoB0vBU6bQwUp4SZs30uwVxF36MbDJPJQiorvPFbCiGmB4/hdxTVRKoA4IQti9bNq7VNFcE3S+aMoXp74+Ih4721Yq0L5vxcJem7R07JguR8JZjRXPVkne1z00QelSgQlnPBTeFwypHNBFhosnEurPoaMYLisaae1GTVrZ84FEurzN/QihYSc+RzcHMaaFn5V0RQCd92ZyzOVlzmquywfcOK+aep0bnnfYUiJ5QF9IN5Sczimy5kgNViIgwGmqPaFpcDKM90FhVmJEXlvpJUeTTc108LQ4bK7q2fcsPZESXUu9v7m3yfDDaeJejnBWhoi79uDsgjU6mc0GEX3Z8mFziyLviGpPvkKllsiWR8yrTmExB8EFPXJ1hEYSJJvPC+hjKW4YUw5jmSdGdVAbyrvZNsZyDyaIi3XR+YiAFt00UZM5T0UTnUMVqW4G+zVnDse0epb42A32qDroJzWZtbOBtOudUXbDpMlzncm8b36iXDY846+k5gGljYSNVv64zYQKovC2ho7ka0HtF0RUgKKQhh6LaGY8Se2palMnPk4GlueqvcSP3n9gTWl/wep1Fc0r52P558i7E/Yh4KInRNvGTjaGaCoI98h/88eX4UAtEzQTSyzH5QoUqlCQd++8z2i2NZ7bgg65aU8R6WjTLcQrnpBZq+olGPHT1OhKOqRxLNRV3bndfURIMBWKjq0spqk0h4EAIO3JmWuDv+VRoAOTcVClsXK+ZP+GmImUN/f1a3GCsZDeEiXp41OfcQLYgYlkcNDYgm5Pj6yZ/8r705cdL5/GyLtK/9F+vZ8/dEbs/oZnMi/Bw/RWWZFPXwTJmwnQxNRKIEA3F3ql5NRK0d4elcUWTz4ewAUGNbAz5rLxeMVdBJc4HIbq5agAeZaqaMkYW8Y6PYPYISShmwmNwyI/ywv0YC7yhJwJx2Ib1fr7bN2QwmcJuJKAdSTcjP9lF7RtzzS0rnDizm/g1WxSl4eaFNU5sXcPM0Q3yKuL1h5/nsx96JeWC49te9xn2Jev868e+gvnuiEtbM1SPz5JuCgKzeZ2jXCi59psf5twPHGeyp4SiYhg50qUxx77+cc788+Ok62KHV/qAoryrPHeW2q6rnK2oCkW8JCtJNYqxjz7FzmgLc9sW6pOzREM4+XVN1M4xM59uUiXQv8YyfG6xLtABjv31z+Necysnv77hz4sXc/Wh2Fux/L6pRzsASqNedTPu848BUF66jH3D7WwcE2/veOSY/42H6nTxAz9wP7rV4uzfu5UqEQeOK3/nODt/8o9zz8MjOnSQs/+ygf6U0D/SnizAZTwtUEztQEJdlG53IyhauuZPRmPqcXQoQHFQtARNmSxoinYsG2SmSIa2Dt8pOorfWL2bw8014nZJv2pSoflnv/5NMkI3QgP7r/M3kNuI0mqu6ayicSzGfe5unmK9ajE6njCqEoxyPDXZg8Exa0ZcKuZ4+AtHWVJQtrajVtMRdmhEdeVE8BR7/q/edg9qajeXsJFWqd8AK0edzuf5vgH50z55r0pUzRW1vpgqveis5S01delIhmAzGO6WwswpodwoB/PPlzVSXbSCP7cU1O1LrnaM2PnFEptIYZTNSKFbNqTQikcyJi+bmiqVz9XYcN5JQn6/SpR3fZBgLoX3VR9CY8MyXjbYRF4v3SypUhG+mszRvjylVIRpRXCAMB6xxgfR2FQK/kAlwkGyZjylQY57Puv5yqWiallGexTJplh8BvCgmGFqrVgXh7KOqQriEynZvCxqVeLtEZticUrkxCs9dlRNSLbkBYJLCpVMLaumCENtjAhFc6/riSydazfYWm9j0gpWG6hSGgAbIw42TUd6KRa/7oWKaCh2tmUTytzgKimIwucGXiRUbqxJUSwItGWwT6wzG2uOyHmKSByKUeGR69Jb8XqhYEBug6We8lqmUAyGc1Zb9BkpDMN1XKXbaCAhft5PMLYDOTXC7L3ghSLj6nvHw5UCQDU8x7/yU6ew3/h7smwoz8Pf9rt+4mUmci2HJOXgjR54806LvWrweXd+QhGOazTx6bqp8pM076YyDmuBvwZK37yXQu8LYnkXeeeStlBZCu1IL0e4xGKaJXYS4SJLelk49WXHQulpOqU0EOFidVomNrVzTuXqxik0MTLZUfX1rUtH6SklUe5QpX2RBSLKeYcX6uI6OLikWxZvijx1rfHHT/zNVb3w7fhSVV8zRVsTDyzdcyJqDec/rHM21gT/dvAIv6c96Vwod+mG3K/mpVikO/Vnwkm3/89PeUk8XtZFur6xR/crh+RvuMT6Dx2nfUFU7UGIk/TEvi/uA76DD0Id7bt6VYKeeDFLLrzXuOeRJ69wr5oOM9Y+ucwvLpkXmU50PfoLm0r/gKo5cq0rskhn88LDTPp+ZDg79a4VD2qBamy3wqxHlLMV0Yah9EhTMWNprIhzgWs4xptN1M6M9OkWdqfiwN5VzpxZZvfeDXJrOPK601wZdHnkU9eSbED2yjG3HTrPxy9dx8pmh3KjwTgtGK63WDoHGzc58p4i3VTMnIzRSUK2YEnmJ9hTbdmY5zS9b72X+WcdoyXFaKfciJ0Ljq3DimzJYsai8G/MTnCbDcx8QTEUiPTQ/hUAzhWLXLOwxuPXdlh41DB7QjH/B+J8U7Rl4qEzxdkfPM7c85Iou/hUQfzRL3LkM/7c33Yj9uGn/oSrwj+crQv0+nq570s0F+72ya2O4Ttu8yiXJd0osJ9+mH0/fD8bf/leJvOKxScL7OtuY7KUvCioCYSD/qa//gAv/ME9tMfUoT5hbI2dbnbWQOQNovv7NOmWpJuCbKDxiHqMLbxlHwiTi0WhM67e1Grus6NGd4u2PP+x1T0MZhtslC2ub17iUjHHn3/3p1iIhnTNmP905jhvmD/BLY1zPJfv4q7GGZ7MdzGnR/zMyhv4zK/cQf+wxSWOjz98HIAf+N5f4onxPk6NlmisyqZTFxH++g3fWVAlQc+DkKtKpihaEKuFAmTjes3s81NrtPDdgsCqaGkRXU6E9iIew7LZFy3vQV9JYR6KrRBioqxw+XWuGOzVHnGTArpzQbisjY3KN0QVRdtgCkXR1piJJelV6NIS9y35TEx3s6RqaGwigjOdi8CzbEphFLjykzlNlQia31yvqBJNNjOlTITGZrQsHN9sVoryEKZVNhRpTwqFoiPPQcHSo0K7yua0FH59xWRnJRHslXerwmGbFdFWRNmWUKOw5qFFF1PMS9VthrJOBmpO0RHfaZMpXObXyVIaYZPJfVmlHrEvPDWjMuSz8r3Tq4ZAAcnnrTy/LYJSV8jaZ30BXcxKJWkN0C0pS0XSLBlPEmYaZB3bAAEAAElEQVTmRwyHDZJdI7LNFFVqkjVD41JUi+Xk/pb1RlnR/rhcKp2yI5Seyocdhes00KqmBaZMHvJ52LxWM3PKypTIF3VlpIgyhI7QULjRtiAaqENqVDXVYIR1BcTycbhXMfecrWkowaWHansRzIteV8SZAZEXhL2K5fuGZlhVoTiG8aJ8zmjkQQHPW9+ucamTQn1Dm/QdlNPnmMzVTaDJJD9A1iMJ4LGRAAIw1WKobVzo0HiE9w3AFASeeSjig9WlnA+TS7MdGUVz1dG+ILzs3mHY+akIa6JaeCnNl6LqJUJNLWWSUzV0TTWJBxYUVJ7qAlPEf+NmR7KpWHjSeQ98P+0L66n1DYYCl2pPO8IDBnINmTD9dJD0LEG5GAC4sqFq68rtfv+6kkldoM2kW/IL1vgCP1CSKrneAlfd+maj9K44VcMzAnLqBHA35MuP/8XH+973Pv7Vv/pXXLp0iZtuuon3vve9vPa1r/0Tn3vffffxxje+8Y/9+9NPP83111//P/V+L+sivToxw5PFHHu/7iCHf+hBnvnpV9I6HVM1gaEE4FRNQR9cJL6+ZYdpwloE5YznSXrFeZwpskVLuqpBKYqdBdHVGNtw6ImqxVgiwd72YTRUeyfYqylLj4bNeHoTN9amN3M+J39wRizK9ERhWw7rILkgoz5J+ZOkwICMlE3PhTcKqzTJ7ITsGJxZXeCbr3+QX7q8wOWrs1yu5jBrsfi5Hx6RuxZJo6RlcjaHTaKn2tg5h7pvjnYLVu8uaJ2OayusbB7W33MHLrYUWUQyUUx2l6TPtlm5U6YOyZagH+NdlvFuqDolZmBItkDnMY0dfdwc7Jnb4vTFJVxhOP38LvR7d/O7NzzAPz35EVb2dPnBE3+BogP9cULZlATQ0S7F3PPW+1TLyG/jWMxs8ioGe8SJYufPPfjHrof+N99LPKjIvQgnoFuVRyuTfknr4oTRnoYUkR7ByGcMazdGpDcdZ/nhAfO/IDSXC//4OEk/poqh+Av3MlmQwJ6ypRjshw//zj24VvDx9WI3JcV1EPoFnUQoMHUlBU889KFVuaN30OCA2TOVp4XIVCbvSpEKshHGg+A9Lq9Z+TTTpC8hQeaZBc4li5xO4FNh3Grl2kzefZW8MqyWXf7b4EYuZ7PEquJQvEJDlTxw+RD7332KTpxzfP55zt2zSGE1v79+K8MyobRGrmEn3ylYpxGaEjzNx4NHNdc+3B7FdiSK6T0UEFsLyk3Ply6B2NX+xlU0HSeHsXVd+FpqDrvJ5QsH/qsIbyX9s2rJNds7rIgGhpmzlaejScE0XpINP28bQcp6jmRLdlubaKJxRR5L0TKZNxQtua6aa1XN+W1AzbkGKQx1BfFYKANVrMAXBWYiKG3RVMS+aE4GU3qFzt3U+k4p4aymGpsiwVCbxlvFOVSpKbuWaFOKWdtwgk52INmU6V7VstAQKkzVhaqtKLpaaAdK0O+QFmrxgr4IKn+O9dgjwOm04Ug2BYUMYT7K+nTTGXGy0rmqPcADeBL3vFVl4rBWUPQyM7hSk48SVC+imilRscNs6JqeEJBSudgcqtAiKI2FK6wSi21YRocsrdMxo52K1mX3ouszTCVspEi3HOmW2LuaPKyvst6EpFjrHT906errtg6h2sb33m6557RoI4Inf3AgCpQWG0ljp7cVY7UIcRsdJTQXYRoXqBlFyxeO3prU6Sn3vxbCp5425KiDnySDwF+X2xFzT7NQTq5zKaa91kg5kuHUdrBsilNK4FqH7xLuy4AGh+YiTDHqNE5/vwbuvS4dqnAEIa2N/F5ZCesz3rBT1LsIWg+hooSGoHdQk25AqjX9/Yru2el9M1rWFDPQvCSTSpt4CpO3PpTz5QGFVDjstTC4ntxR2zoqr50x9b/5c+r3mEAd05V7EbUo/H37ZCc0MpMFyVvpnhX0MExBgljZ+oyWYkYAPnFG8ud521rzUnk4+DNyd/lff4/f/M3f5Hu+53t43/vex6tf/Wp+9md/lre//e089dRTHDhw4H/4eydOnGBmZqb++/Ly8v/0e76si3QXOxqnE0bLUH7DHey6D64cr+icmiaEyQYFaqKoWn6R9cIbFF5BDbZhBZVCCq58wQqqvRZhmxIGYZu2jr5WuaJaLGn4pqDSDjeIcQ2xlQoLeuAehoV6tENjJvIechOLv6/KNKoUrmU0lD87nwIYjcBsE+8Erl52RTjpdtzg/edeDzsy9u1e5+JTO3nz6x+lcJonVnez49VXePLMHlJTkk1i2j1BxHQBw32OxsVYNteJHA9TwNwvfY78664njSrWrqS0l4Zkm+IioyrYus7SPqdpn5U0z9EuXQvpbOzYOjVHuqY5M9sRN5lmiS1j9K4JF77vOP/8Goh27kB9oxz/1mrFeDkin4HZU468oyna8MN/8/18/7/7i7gILr7G0LgqC/jKt99JNgt7/qXQUewbbqd1JSfezGifLKByjK+Zwxro/OYUBY+uP0b7wafQjZRqMGDj2+8FYOasbJgn/kpK+vdfwY5fb7L3x+5H3XkLGzd3yLtCrehcKFi9JaF1GY/CCpd3O1JatmSDjIcvHjvHlaN92U6RJiUocPesCESDw4nz6HQycLWgqvYbr5y3jpONWdBq2YBt4kWmPSk06gJAK9yvLhM7+H33JoqWbI6fmrmz3jAALuSLDPbD7JvH7GlsMqDBN859npVqhidHezlVHKvdTeoI9dorWv5fNFWNlk3/Xb7X9lG+Lh3NlWnjKpudtyBLpeCpCzKoC4EqUbXOI6BfIQVSWVc/b/t42hlFa9VStoVvbiPIlqCHoePPR39fNB29N2HuBdm0+wdikp4jyuQFnefq1qJdT23ByUadzSiyWbn/G36KEtJJ0y08Yjldd8xEzl34/GVLkHVVOdx/5xUfuNVVKjxfZWXjVoVM9USPI8hyNNRULUu8pcV21tPrlLEo47BDQzSQZiafF0pfaCp1GTjnfgqJnMt8hppe4yJH1JOLp6Y0FNNjEo2l8AgUuDoUaltjFg0VpYqxrQoyjS4Veu8Il5aUffH2dBEU7UpG/ZmqBYfpivGWuIay46k1TUW6ZiRcq+fFrcIcqF1edAnRSE7e+nWRuNu4KX/cJlJ0bnd4MZMp9zoaW0wViq/pxCgkZwanntlT0jiEfah26vH3ifOc93g8BXJqH29/fMZLEnRWo+JleK5opZyWYxiuo2RgKVq6TkOt70FHbUEYUPWa/uI93sVKUArNbEaLa1NL1QCHjQCvAwlpvCDoMkDW1bUFq1B5qDVLVTItfGsnJDUtaqcCU140CQsWhoErXjapQwWdVjK9cjB/QgKGqlgx97zz9oZybuKhBJ+Fc142dU0ZquZNDYDZSBobESdTAw3xwNVNd6Av/veFdtHW9VoHcm4tytcX4Xj4Scx2qlR9nUHviGXrepg5YehctAx3SWKxsrKXBLccuQ6o14XQgH758T/3+Imf+Am+4zu+g+/8zu8E4L3vfS8f/ehH+Zmf+Rl+9Ed/9H/4ezt27GBubu7/p/d8WRfpqpSxZvbWLaIPzrB2m0PP5di4WY8Gy7agL8HmKUQ+B9/tuAeTnU6K7oYUmM7I2FiNtdx4VsbJLnaQVlgMSgnqbWPxCXYa9EjTPaWYzPtwh8x54aeWMX2s6B9yfoOW4BAz0sJF18LJs5mGToneiEXolThKtA9s0ZJ+mjoJJlksIamo1hNxXjjV4OLaTo698hyPre1hZ7vP0flVnl7byXUHLnOkdZX/po/VzhhVooh7wpE1hSyAZiIF4ZXvOc7Od93PyV+7Dbd7wuTMDFEmDc9kT0m0acQzvpRjnPQ8d9TiPcLDuNCxtHuLymq2rCKKLPG96/Q/cpTLpxe57nu+hM0m9L71XgZHKlrnDP39itYVx2gffGFwjW8eBMUZ7bc0L2rUAFpX5XNWKez58fvRSULx6ltwUYPoYw+SPC3Xibnlei6+aQHlxMbK3b0ktmeGGvEJvMClB2Le/De+yB9cd5zxT97DwuOahZ+/H337TYz2tWUD8K4KIoASQY9MTWTDnix4juWMLMDtC348va2AnFqsBYRG/jqldIRRq6uFZNoXp7qEqJD3iyZCN4iHlrIh1wluyhsPo9zgP249jzQaO5KerQVxIBt697zjiYdewX99lYL9YxZv6XNz4zwXs9naAz88t0ZQw/u4KepXux2oafEchHAS5y5I5ouCjPCpsIki6dtauCaouR/JG+Gvy7GS4xSP5BgZzxEPxWagwggFBxaeLqkSzXhZk/Qc/QPKb4ZSfASHFkG5RTxmIynKq9QQjZXnwUuDFI3lfJQtIwJgX+ikPREfh4JGCp1pcA7IRh6KyKQnQUvxaDrqLjrSDMvEToS0oXiMe1PE22kgdjVKbaOgj5GflW3P+S4VaiHDVhqtHERSeEUjRdl1tWe1TS3JmqmRu3xJQobingYrBXooSItDE9w4glzTuqT9NQuTRW+l6dFpm3rRpy/sbOwToR1EE0XZklTMaKjIV8ROUgfAxIpfe+CGF11qZ66q4d22EgvWJ212LHa+IH488Yjv9N4KdLGyJce2fdmxcb0SJ6AgBPVFW97RbB2T9TAaAhsBBQ3XHmxPkHRRKMSnKK4zU+EpRvYhGylqQe22Brm+Z/w5Nrmjc3HqEKL8/YPDF22iuaqaPslXeWpKIpM2Z6YoeroVpnFTAaXTqm50szldf28bT2kpqpoW98pSH09BnYXbHa6FsiXNQyiOQxaJU6rOh7CRL9R9YR8cksK6l27JtMlMpsdZFyFnQaYcSd8xWjYkfVtPAUCoJkFMHhxbcA5TOPr7NbOnqK14YTsdRRqFpO+phUrO62ROLFxx1A5TkvpphMfe/O9EvB6JD8V92LMCUBPWQufdhmqKk4PRTqHpJpvQPS/HIN1yNXUpn9vW8Bjh+4cJnZ1+pZfU488ESf9ffH6e5zz00EP843/8j1/0729961u5//7/sfYM4LbbbmMymXDjjTfyT/7JP/kTKTD/o8fLukjXOTQG0F9oE80r5h9XrL1Wk79ySPRUm3xeeGhBYVB0ha+orCwqID7qVbcSJwTrwzVGCrb8CuqQ8bQXm5RtTTlbClIZacq28LBNJqrz1qpj7SaxewyjS5giiGi/iCTiMKMLEXLZhri90ClxfoyrcoUealQh42sXOcrEc+dTB4XCWoNGin6xhVQ8f3mZrzj6DJ88exT32AxlE/bfu8mZ8SLVSOLCA6+xueKdDLQsIumW+BhHY+h9671c882f47n33Q0Ni+oZyt05qh9RLZZUY83uo6uM8pitjTau0JhGic0Nc8sDNs/MQtOy1W+SpiVxo8QBB2Y3aZgSDsHZXzvKXHvMzNs+R/f0rbz7P/xXfvbn38ngHQO+7+aPsT9e40PN1zK8DronIR6I7VbZEtFUeKz+NeFQh3FjvPtebDT18w6CuLColv70xiNHPHS1eDEZWP7zx+9l/5svcP3cFT733O2s/ZXjU/s9FdVFMxrMSDzz0/Vp8AkaWpeoG8V45HyxGDia28ahOvhtT0fKwTsf3xC4CJpXSz+qFSFRNLHeJ9fhIiUCxkThKn9uR9ZbIW4TwkXbNgtPYbC1teCUm6kqx64HLPZLDT70wTfz4cyxfr2h61w9Vq9RJb/hVKmqx8Ey7lV1AR/sCEPwUfATZpu/eHDDCcdV6B1C65DGRc5XVLp6ZF3FUy9rKYRV3ThUTdmwxTXBedtHh8mqGvGce956P2Ipckw+LUKcluI8IOC6dBRaXB0aqyVlS/uEU+GVJwNH3gm8jHCevOf7xNWNcdlSNc880OF05Uh7QnWKR64OVkFRNyQgRcZkWZyThssWNsVVCi0JyapUVF2xTLSJP8+xQndzXKlrA4woKalig20qSmStSS+H+HZdF5FxXxENIvLlSqz1EkvULNDaUfZTtHa4RoUemNq3WVmIvYAx6BBMruomTXl0OaDqk2VLsqExI1kzo6GmVPJ/GzvMOAh7Qft7K9lU9feL+0qEdU7WQLdnApuJTDV8QVwlUkDWQmWf7hiPHI0VCXUaL2kanlrhtBSS0UjVaGVNB/EFswiew8RmijaHey1sHiGoJjgahYa5bhyCl7yipoIEbQeBlrHd5jHyTW7iJ2gDef+yJVOAvMsU0bWgI2qKioheId2qqJKp13povu02C8np5Ir6XAZkPqyXqhZ5Tzn/4lRFTW1prlq/tm57HabaGiJZR3Th8xbi6XVy+a056emUued8MFRHUVYCgrUvy7kqU12n3YKbHmvkGFa+ESjaeiqOjVXdDMdDO00G9WJNGysam9Q6oCBUD1M8XThiO0X8wzoeivdQXJdNyewIrlVixTm1+I1HjqKlaKz7IlwjoUUafy3KGvT/Ze+/wy29zvpu/LPWesrup83MmT6SRs2WZNmSLUvCDbCxsSk2mAAhBlJ4sR0nIRTzpryBkBBeakINmOSlmB4DJsHG2NgWFm5ykWSrd02fOXP6rk9Z6/3jXms9eyC//PjlSnyJn7yvS9eMzuyzy1PWuu/v/S2zYzPyp/I4Yal6ng45ALZ5Vj+stezs7FzyszzPyfP8rzz34sWL1HXN6urqJT9fXV3l3Llzf+X5AAcOHOAd73gHN998M7PZjHe+8518+Zd/OXfccQcve9nL/lqf8VldpE8PVmSnoPtEwvRLhgxPdmk9nlMuZIIqdWrYSiKKngxVFC+FRbF1UVGNEvpPOzavg+LIDHM+EwGVaYoatL85ZorsQkrdFbtFlzhfZMO+u/yGb4g2YS6RF3Der9gmTgI5iqYJsC2LmoklGU7cEpwC17K4UkEOeuKDXbxINRkrKi3PC6PtYk9J1i3gkR4f+fxNTFctpiPWkp2k5Ir2RbIzKUWfmNSpC2Khk295lf9UxqnTJUX5nbeT7EhhUPbBrKV0r94CYOf0gHGRsr+/i7UapRy11ew/sMPpzUVeevND9NMpp8eLXJx0WdvuccU/HzN99BxToM9F+sDjv/kCBlmGPrfDz/3OVzN93ozbDp7i7w3O89bTL2b3hpK33fpBvnvpSS7UQ172ibdQnOuw+JAgYtWLdhnt5qRnMq/iF5Qnim+sH8+GAtFTDkJxGQRMEkSiSIeKaZWyXbYFcc+CbzAxQCIU2saI8DMU6MIBbiKvwaN3LWmKcA6FirxK8KP4oPCPPFe8e4TDVoqqay4JjJoumrjpOyWvHQRguhS/XV0Cnu8Z0TMdxvKhMHY4p1C1jZ81INggm5AgyfL3dBJEby4GhMyP0YXbqxqkyjVotvXontgMEvmcwf0j3JfgiwOlGHlxcjqC9rr1FnXOe3t7H3VoLPC81WMydZG/KqNzRdFuoMtIz3BE3/NAVbCJiseo7EO+Jd8rGVvSUY0uLS5VpBcqioGhfbFmsuLR3jZ0z9YUA+0LdKHJhGAVMxPEcLJsULVEjRc9TbYrxz944Lc3anGdgFg4OCUomlPQOS0NQtWVCZ9t1+iJAe3IFmaUkwSTWDm3GnRqsTMDxlEV4jmerZsofscJtUUXgmTWLSgXLK1zGnXBUCxaXKUoKwEzyDxXeJw0Xt5laAz8udTe6cajvkFUF6khIFSdLIjhwjXnBbMoZvsrzCgksEqBV7fwDlKOMvWhSG2hABVbGa3zcjNp3+S2NpqiKSCSTklx2F6H9GSgfEiRpP33yTf8pC2H0aqmf9o2dBjlQ3BUc4/oMEUKQk1//xQ9TToS6kLZVfF+FCGgYjaQ9ThMyhqr0tAEEAtvVcuxTIeyXocUVLl35VgnU7yNqPw8mbqYX+AMnL9V4zJLdlHROSu6jXC+xIGFWMTi17Vwjv97kzKUUKHyzdCoeb55AZMVHQvdKPz1a6eK62hzvKwRCpCqHQf/OCWZyfTLpsQwpsFJ6+9RFS0rVW3R3iYxrm1Vw/tvgqA8Fcf75EehugMSHQtuWVNcpJaE9UBVDfAWGzMH4OKUInDlg0OX9fQclYpNpa4c3XOVpxdJJoayLtKZqraO0wZlFQfel8bE2tliYwOaVlDPeMY9HF84TvojjzzCwsLCJT//gR/4AX7wB3/w/+PvKXXpZ3PO/ZWfhcc111zDNddcE///tttu4+TJk/zET/zEF4v0v87jyn/8GU79yMsFnag03Su2mX1+ESzMLpvReSin7EMx8J7OpWrGiTOoE5juleJ5+yrhGOrNNFpNhfGnzRxaCdfT5mAzS7pjBHSqJbm06tvYSYNHFVq+QNehGFM478iRjESxXQ4sybaJMdvyfMSisdDQreRPj34qBWhHlcv3SXxohNifCTqmrxky3s1oL0z5+Rf8Fr987uVU1vALd345C2t+PGoaNMOmfsFPBFHyHwPnlehmJpt41XHoQ2MuX9rgwXOr6Imm35rRMhXX7zvLAxdXOfiG+wE4wknOAdKfnqcDHAOe+Ne3kzyvRb8lq8vWJ/ax9CGYvPr5nHtRwuBJx9e84TN8al1EHNd3T3PLlzzJa7tPAD0+OdvHT77gv/Dy1hYv+3f/FKfh26/9BDe2T3Df5AiPjfeR64o//uhNtM8K/7+14eL3qbWKvrwQkPWmIVO1Y/CEY+VLR3z8keMMWkJdyTe8QDRwsPEIWhH+LteK2O/5zcgLN0Oa4Lwzi4yum0CjKKqqLxVIBdTa0WyA9dwYPYjOqnYzvnYdEzejgN4HUVoycdTWe7XT0HyUbtDPgGxFb/DC0jupBV1OwwbYoNa6DBQIaT7SiYvj9BA8FAp7eT2PKAYELKyPfoMbHQDQZLuO9rp3PmmrueZC4TI5VwElTSaCPPkpe/SQD8VgsERU1tsohvTWWj5HtiOF1mi/FL/lQL5fthOQNEc6rEU81zI4BRvXptJwLCdC6/AUFlM62hfrS/j+NlFMFw35tiUZW9pIwzhbEKrM1pUJC09UZLuNLZsurdixWYcygL8eyj6gQc980bZUidFOpVC1wfY1SauimiWxoFQaVGLRqaWeJGSnMnQVxKL+3Gt/PnTQWmjKBWIhoqYaCk3i/a2L1YrAgw/5CHHdRM5x1RY0N05KlFBUUh86lG0ryr5jtlzH30NBPRFdjioVdb/CJoZ0V2MzB1bWXQnM8UI+n2WRbZpLQnKKvorodZgayc8R7YAValjQWkSh7Nz6YBPxqR6ccJe6dnhbwbheBgHoX5rDh2CaZNIUuE4rqlzMDVqb3uYxU9F2lNBb6wZJDzz5IBwMHPvQ+IQGxAZht5X7e7xPRTpUAHoW7k+kiDRy/df+veUDukjLCfdmCA6cp+lZ33gnUxcbLKeIIkpTQG2l0alyAa2yoYvo9mSPonOhKZ4Dzcca70BD+I7NlDHbwU8T/HWrPJ+8o+N6Z2aOdCTGA6dfoeg/MdcURtAg8OW1t+V0zbTCKL+WuwhaxKZFhamhd8MpHbOBisDD8IiiWITOKUW2K2tBsSD3h1AWm+OnS5nwhUbHZjpy+cP6CXKu05klHcNsSQLZqh5xwvTMe6gvWJjR1VdfzV133XXJz/97KDrAnj17MMb8FdT8woULfwVd/x89br31Vn7jN37jr/38Z3WRDlAdnpI/2kI/0GH8XEhqQXJcKdzUfOPSxTlQXSTcSDaYsu9HmxVYrUh35WcucdG1A8BlDmuEL1m3PPpaSgwyVnHupRYzVrTPyWI1WwliSuFk2syJWCt1EmDkZPStKglRolDNzWkcdGrUbiIiUyOjTxducl9QNYmNIqaaqRYrxzYZKcf/ce1HOVctUtiETz90GYOHDaODgsRkm4rZXsvy53T0Iq686M8UEmi0/KBl+wrv5NIW+8lymrK3NeSy4+s8tHeVhx88zCkLtC1X/f1P8cgvv4jnXX2S3SLn5Noyiwsj1k8tctVVZzjzp0dJRpC/d4HhwPv79oUusn6z4kte8ADXdM/zZ+ev4cSjqzzvfW+h/8rzfMdlf0Ffp3xwYnhgepB7to9yV++88CJr+KWPfBl6ooUzbLzN3rYEwQQKRVggdeVEuBsKTH9uwwIfNtiLv3wZCytKNtGLDVXEZsQNHYihKmbW/D0auHreqSmCzeClzZ9L5PrBF+pYovjTTBsetizWTZELwUnFRUvROvPXuN+csZ7y6uSzT5dFv7HwBEz2SuhO/6kpwyOtSziToVAKzQTOUfTFT7rsyuary8ZuTtfS+ARqD5qoupeiwEVqjNOi0whCSF35psFzPkF+t3dK3n+yRwkK6pDCXwktKLjyBJ5s1VIyYcqI3wWIPuqBnx0oP9L4eIGZP0aSPuronW0ajN1jiu4Z572UFZtXZ3TWLPmm2DG21+U79U6XsTgLVKWgIbB+Iy+7WoqLLCDilqKfkG8JCl92RbzaP1374khFWpKiOT7JhBjPXvWg7ln0dgp7p9jc4HKLcYDVuEKjEofdzEmGGg5PqacJejMVJ6uRfM5k4tfEQJ8wDS1MVQiFRsuapBYKigWNWU9JtgzZVlO8hT/1TLjSgQMdOOjWyFRLORXXrKotBXe2llAfH1PPEvRW4lNSoXXBYFPji+DgrOHD5ZbEQcYZh7M+Rr3jZJ19xIdIzQKC7gtkX0yrWtYfPZLP0bloKdsiMqxz4tQHJY3XwpN1pMSZWVOcx3M8c5cW526O4iIYC0XrUj/1quundEuO/lNzRZkL6HkD+DR2fzKNAY/Ez9FrtG/wA50o3/DTvplQroJAtH9CJltlRwrQ9kWLKVy8F8d7NIOTNelORTlIKPo6Xg9BuxSPo5XQqKrd3HfpLr7IF9Cq9DzqqtMITnXp6J6dS1d13mUJmA0U+U5Yuxq6HjTXZZ01E7JwvOeb9eA6s3KvYrZABEKqjEg/08Wl2QuBohYdcjyHPRnbqJXJt72PulakzsXpQpgilT1F57QU6gtP1dQtRfuiAApm5pjsNczrcEKjofzUdLKa0NqwEUkXDZKnTZXOi5hlWus0lG2e1Q+t9SWuK/+jR5Zl3HzzzXzgAx/gDW94Q/z5Bz7wAb72a7/2r/2ed999NwcOHPhrP/9ZX6Rf+0NbnHz9flm0vSuLSxztp1Nme8QuMHDpTIF0yF4MZL2Tg54pKbqtp3844RgXC4CCaqnCtCooDKrU5GvSfU/2W1wu76emGlX6RMMjkopZt+XfBo8YKUjbHm1KgUoW/1rJ2DYIpWytQDuc1TDTuFSEUXoi43GJk/Zoe+Lk81fEETXtmqJMyLOS3zt5E1o5zn92P3/3dXfw/ve9jKorXuvTgzV6pii856wppTDPN+VYrdxXc/FGcVAoBr4QnQp7QuM40trgzl+8BfOlE2yluPJbP8uZP7yOW/c9wbDMeO2B+yn3G+68fR/6dxzrv3OU8lVDDi1tcfG9h8mGwA4MnnZM9ihe86J7qZzh3p3DPP30XvpPGFrrjvo39/GL6uv4+VQx2StFxPCo41PZVXDUiSvPUAqgsm+9eMyReeeJqMz3vFJnGp5hnCQYfApgM+Id71ekQ+gERCegjXgkOExZqua6Eq9iF9FjZUGVwjus2orEc5JxQotRNXTWHMPDmvYF2biC04dNvUMQMDxgSCYSYhPEVoEPC2DqMKlpmo+AJgb0J98Csyb+3p0LsvEMj7T+yv0U7NgE1ZZjNN6r6F4Io3gXkSRQVEmD0OHpDFUb0jGxQBYqgxQKVVthVONwEOgqjbhPEiGHhyRYKIzIRwd0TG8tFmH5IRvPa7brXSVsKHA8rUH5zdMnegZO6mxRe//55nyGjbM24tCiamhfIG7Y2VDixMuuZnpFRr5tYyFXdcTf3BTQWi/AOup2QtE33vveUyOsFHPFgliEJhMRurY2xZu6zmC0z9C5WGMKCVkJBYwp5NiKKFuOVzIEVRumhypaD7cpBzIlcSMpapNCUbcsaqGgbBuMdripTFmKJcf08pLsdCZAhj8W1jsG6UARLGC210G3hqkWoWjiqJcrmGiybRPpK+F4Vl1iI4oFPdeUgi/mq+bYiyYD7Ik2ae0pgR5drNpQdcV9Rs2kcHdGXK9CnoWqmglVvVJCoSnbiVDA6gYhNSFhsiQWO4F/PhsIpaL2fO8w0cJPoCTvoHEkSSY2FpiRAqLCMRTwJTS9gbecjfCcbkmZzIaaybJu6GSVIP+ynvsmoHZ+LfG897RB6531BbnF+2lLE+SUX8/3CGre2oCtK7UXA0vxHsCYfEs0SNDQKIS2pSj6mQ/fkdCj1pYUqHWufQKp3F+ZtZRdQ2tDnlu3/OTQyJo38Uh+uMbCtMAUgkInYxedqgIdDifnJRbwXiMSG5LCikd6aGxoKDWosM47WpuWsidWpdm4lvt3SdPakgY9CGXDdRkmj2GaNQ+shCRiWStcdONRBVHf0z4n7kYLT9UNMFQ2lEEzvfRaCQ8355vvDJSZ0OXCnhT+7J+y0X1mtqAZHvtLY5tnwMO5LxDd5X/id777u7+bN73pTbzwhS/ktttu4x3veAcnTpzgzW9+MwD/7J/9M06fPs2v//qvA+L+ctlll3HddddRFAW/8Ru/we///u/z+7//+3/t93zWF+nVY08w3bMflzhefMVTfOrkc6RodoBTjA+JJWMoWupcCqRgC1b2/ejVqUhTCHQD5aB1QTErU8pFTbplaF2UYni6x/lEUI0qkLGrBhKHyxx17sg2fTG/D6KIaip88mQMu1eKPFtZaG3JQlZ1xWrKlE1RWPWloNYVgj51BeXXRfOc8Prp2YzJuYyqZxnumWIrjTs44zf+5OUMlhST/eLi4FJLa3XMbHeBbAuGCz5FMAVSOPNycX2ZDwSxCShjOdza5PRsiZ0roC40Vx09D8A3Hv8sv/v4TfRbMx4b7+PJW8bALtV/uwEFdFoFzimueP3jnNkdUDvNsEyYTjLed9eNoOCdr/lF/q/J6zm5cRCQ75wOAUcU2Cw9iEcaFcrpqNoPCa3bV8tx2vyqMeUkxayltC4qsu3GxSMWwR7pqj3tRZeO6bIc13zHUXS98MuA1ZB6brspXMO9Dgi0kyIqmcrmI82PuJOYwm+MU3l+XUH3rMUURGFUWNcmez3lSMuxny1B/5T4v8+fC+dtyZJpk2IaCoPIDTUKZwHmkCKkcI2+vhD96OfpCtbIz9sbcx6//vfMTLi2ykG66+ZEslD6azfQypR1lL2mkBKkSxDVMHUIYU4ghUn3nHeBcA0dy2kplssNXzDVItbMd1zj+BIaBoiIuDQQjW9+vmUpO4pin6Zz3vrnq4iwtTYtwekiIPBykJR3bpBGrHO+ouwZxvuMFBo5QNaIUX3U+GTZoJwj3xEqSzISTjtK0mSrlqJ/ysYwrKoVkkXFsSdcO0B0dZkckPWn6tdQiM1i3ZHxiR5J8VovVeDvCbOTQLsiWZqilqHcysF495bCUPZd45PuKUi6hMmqHLOkVVKRYrKaujBQi9d81fZajVruocapB2zbYrz2JlgGGh9AZRMuoewEnY1NQPnjXC7W4mg1URSLVnQ4CzXpekIy8tdxKvkVITws0HiE4qIiqgwieAzn2BriWjAb+Pun9qLHoinObAbpjvP/7oXF/toL11NwHwkPM3OxkQJQfvKkC5l8zVMzsqFD7dCABVpFO8GwBlgjnvaq0yC+qgZTQ9Fq0Om6Ba6Uhrzsy3N2r6wpz3v6Wy6vV7WhvRbue8/droQiIhSvZh0QtxWhio32GW/d6BsYpTzYIIV5nclELUxinBEBd75BTIIFoVSKqFsK5LIz16irpuAV2olDOT9hNgpKS9HX6FqORTaWKVWYeoQ1RkT+KrpdzRbEGU05ScoONo3BjSY4tYSpW50q33g2e+xsEXqnhHLSXpcivPDWkxZZvwYn6hhKhGksWIN5gQhXdXSVmXfACtO8qq0kLEnNTVesP555OFbS5Kc7//uL4f9/enzjN34j6+vr/NAP/RBnz57l+uuv573vfS/Hjh0D4OzZs5w4cSI+vygKvvd7v5fTp0/Tbre57rrreM973sNrX/vav/Z7PuuLdAB1+Qhbaj7+4JWY1G/sifAU0yNjRrZL67zGarEVqwYWVRu0ko0BiCN4l8lBDYtMsSD/lq8Zz2uUIt95v3JnHCTe59yGhdVSdy3Vglg7JkMj3Fa/2UbLqlo4larWzFa8kCb1SFFPCng9U5ipjHRr3+mbmcLW8vumCCixIDV1HsbLmmLSxhwdU40y+k8p1m8pMbsJS9esc+XiOp/87FUsPn+DrZMLYBzZ+YRiCWZ7atpnTeSYBuTWpqATx93bR2iZkmp/gdKO9XGXFeCF3ScYX55hneLJ0R4e/Y83QKum86j8/gv3nOPus4dITc1LDjzBA9v7OT/sozszvuH6TzCzCV/S0vzOtb/F9/Vey9sPvo/Sab7v8Tey8a4jUbzkMh8wUgJOFnrtLfeqlqLaW5I+kfG6a+6hcoZHd/dyWXed0hkO5VtsV21OTpY41tlgq2zzlUuf57nZBb75B76X3csUxYIsfj/1tp/j1jzhxXe/EfWevSSWODYONJmY6EizQeD8WN8vwDZpNguXSLEgFokKnPVFg7p01NoiUnVsBrNFSQFU+CJAiYYi35HrdLIilUi26yK6p6sGxTdznEubKoqBj5jOicFDMe6+ahLyUI6ir+iea5xQbAhK8pvibLEJ4DA+IdSUYKdSAJTtYMenyIYe9a8bv+pQtEf3h4CEGymcBYVShPjxZCLFUtUW/ntAlgJyFdxq5LX9NaMCj19+lo6dF6jNIXByOV0inJOGveH+h+9pU9GXJFNLOlTCgfX/L7+jSbYrZssJyglaaRNF2XGYokHIy66ie17Eo2VHMVuSQiAG3pROCoGhxUwdxeJcodsSu8S644/pTGMXKhhqbG6h0JLvoA3JAVGcai1CYd0tUWdb2EwCfbJd7wwCcTJSt4kUjjSt6XZmbF/soYaJrH2JQ838uVNyLSWTRgOhNjXFko3idmnYmrXVaSAT33czVdE9pe4IjSVfM5GykkxCOJc4W9UdC8ahhya6gQQdhtOQjiV7gGnzHWpv/RnW8WLQNHFVJ0x8uEQkaKZEKouDOIUzpaPKtb+W52hpwVHEN9MwRx1yQqe0c7t2oI3MCw7Dd0DBZDnQJWioYzMpyG0iBbl8iGZ6VbXlsysEuEhGUrS31+aavQxmCzLJc0p4+dMlEQGHZiak6QYKV1j7zEwa0Crz/1Z78GnqRDdRzImvrTTb4pAj90B73VKnQaCOL9hlqhS89eN9q5s1MVCLRD8GC4/LVCL164jojprGP4RR5dvi4CVPkrXTFDZSaexccxkmrEFIHtaVcNx15eisNXoT8Yb357eCYiBaGnHb8jat/jsWPSXTCA8aKIeIRYOtp2kMAFABsW+u66ojbzr/WReeeOYh6fCFQdL/Z9/jrW99K29961v/u//2q7/6q5f8/9vf/nbe/va3/0+9T3g8q4t0/YLnwD2PkaYVrdwxPdFm9YVnWWmNuefhowweSHEbfWZXVSLAUjL+S3Zk9Bc2O4DxYSshRVbFcWcyCmlz/v8nggipGlQpPFjlNHZ1hss0biyIhdk11HsK9HYqPueDGqc1nbOKyT6hLdQtcYpxRmEXS5gYlFG4bo0aGtlgraBRWEV+QcSlDs9JTZvNMIp7evKnstC57SLT9R5cEN/h/smK7ZdU3PycJ7k47fDQ+l6y1TE7jy1BR9CpuuO8eFGRvmiT3e02OrUkac3qwi5PP72XTl5y92NH6SxM0FlNPUk40Nvh8XfdwHf/2u38vb/1ft7xnldx+fd/HP2bRzBPt5ktOloXFR/93NUcvnyNcZnx7vtuxJzN6T5nk5+44b9wQ7bFW578Om46eR1b6z1+4aXv5IlyD58eXc6bj/45D77lEC/sPsHd48t45+99Ofm23zzDBu0bs91j8Pbb3sfPP/w1bJVttHJYp0i1ZVTm9MyUPckuPTNjbDPOTwfc3lrjZ9ZfzJu//w+5d3iUt69+iEOmT7i91i4sMEjFnlJZMAFBq1VEliAspEomFUoarlCYqFo43aGQMTOiu0xA7czMceZLHcv3GvJtF5Gp1kWJ/+6eu3QB10FgZOR6yLZ9I6C89STNOF4cEJoxcHj/bOhi4RLs6upckJ7KJ/CFQI+qpVBZaCj8PVg33y+4XYRjUXurM1PIz/MLNgqxgttMOAbzo+Ug4A2TDvEbDimIYdOzUaQ2r89ophpynIJ4Lo6tIT4/ak10+CX/napGNCsTAhePZZ35hkvBaH9CvtUUCaGwEN5+TbFgpNny1DZdNrQVodiIH3wo0HUFvdOCkAUk2MyEDz5b8OmzDoplS7au0X76ppwiGcL4iCU7k1K3HP3HDJP93poxs9gLLXGi6lWCho9TVFfoYds3FZi1VJJH/blUNSiNAAWFZjrKmIw76H4pU8eNhGTceJBLQeKPtR/Z6wJUoXAtKap1oWMq6XzWgLIqupYoC9lGcLKCeqE5b06DGWkBJ8a+YKlhdqQgP5lF9DpcQ+nYevqZ9toAEUFHPUrVvC4bxMCZsPcHLrCqxTfdaY8Wa9B1U8BWbWmOxee+KWLnUdA6J96b8r29jaEjThIcREvTxK9tyVTuo4bK4Y93S+hOTvvnZH4N2OESC8/lz+s40araRHG6ULP8WtFt7snQaFctFWkzyheLRS9QbsKUUBqUcExQRHrQPI88npcEkrCuqcANd35t1I394lwomQhJ/UTE01brlsOMxVZyNjB+6iSfMVxDclzkRUpPUZGC3zd76NjchymkND8q0gbtHM1EPOflmNqwjsz55NeZYvNazZ7PyaKSjKXxFGqdTCg6F+u4xoSU1Tpvsi2Ua/aEdGQboMEvq3XaaHPmXWi++HhmP57VRfrj39jnqnvg0OI2p99/FJPD+kcOcGrVsvCYJhkDCnqPJAxvKMifFmtGPWsKm9SLJjtnJOFSiGp4e0VBtdW0QeVsAlXPSjE+9JzcbT+nnxt5qu0UM1Uk641P6uiYpJjmj6Zkm4rxQYddLDHrKfWgxuwYqtQv0ruCntvaeKTHK+iV/D34cVPJRid2XgjtxkC53cUWBqUlnCnfKOn3p6zkQz578jCuVuxZHjK9omTnYo/WRdi9uqb7ZIJNFaNiEdeyVC2LWm9zYrFN0i+Z7LZgpplOMmypUYWmsIZjKxvYH/o8//UlN3D5938cc8O1ZHkFV++y0p1wqL/N45srXNzp0W9Ped5lpxkfTvnp47/HyWqBl/yX76V7xTbjcY5Oa56Y7eNV3YdY7I/Zsh1e2b+PR4v9vGFwN8/7thOsmCGfnVzGT9z1ahbvyiRO3cA/fON7eFH7ST74th9n28Jd06P8nZULvCBzPFaVLOqaqVO0lOOhYpGtss1L/tP38n3f9Af8vcF5znUfZ78RSPFCPcQohd5MxSHGzCHjc4lx0T0iFcR4HmWW4B4ELZ4r2olcxyDWbYp9IAZ1WH1pQyYbkG8SLDjlsEZ2eFM2m/x8BHfdaryao+uDR++qVogFJxYhADbYFSrZqPAJgUJBmXOgcA1SKCI7O5cNoLw7hrzHeK+JyBKO6ISkPf1BGgpige20i1OIgDoFQV3Z8fSUsimq4r1XN9OLYMkW0dS50XP4HBJ+1PD9y78cemIap4fEeveJYSM0nOWadOIwU6GnVEve77yUhrzKpQkqO4rORUfvVIlyUPSNhC9podjk2xXbl2WkQ4surJ90CDUgmYqtZrYDdqIbDYoSyp5TCjPSFPsqqBXjA15InUH+VE4yErR4BlSpQbcrzKkW1UKNK0S3Uyxb7KCCUqOmmtYF4e5POo7kZEuKu71jVLtgbFpwISMdqiggrDriax6v4dQ3skPltQH+ePviCLy4tJDjXCyIgF+cLvzztaNuS4EUXFxsJveP9mL87EwWC3ldCYXGpooiaa575XUb0og2RaU1RNcZXTc6FQBnZQoURH/hXp4vQI0PrJm38wuTpsDVt6noHAIyixaKUMgLCDqQ8DlDmFfj8hTWEv89rITwKde4EoVCPNxvIP9fduXzil4m7BHEKVp4SBMcHIfEUzzbFc1IFUWyNG5T3hXGeVeooMsJ9BFdi5g3NAFCZyKCAeInLui/S+Xc7B6TZnPhKRePnwAVIdVVKDlmnMRsCVo0PufKr5O1k1RYTWMl6+v+cI+HzynHVpp0WWOIE4SwJjujUNWcs48LRTKNCw7hPhTgINQPYsOoUNpha0W2U2ETjUtUvOZkzZK8CzNzcSIQqWN+PbSp8lSsplEKguJn0sPxhUHSn4Ff/b/7eFYX6YnnYx3rbTJ+5BAXnye2iN1Tgprj+XzKQXYio3sahkcQoWapfOR0M15T1lM9TptLfLVhLjjHgbKaquOo2uIkQOJItkWsVa8W1MqgxzKqrXO/OOVSeLeelDHY+KB02taJh7oeSkSxnng+svE86FyQdDORG187L3YNiYJtMAamByrhb06FIlNfyOle0IwP1xx6v6HOLWVl+MjJ4ywPRmyP2xS1Yft8n95jiSz864lwpgF1eEw7rZlNU8w0pf1Qgv7SHbbPDtAjIwW6BbdYopVjT2vEC+7f4U+vexKdZTz4T/q07k9p37TBuadWsB/fy0d/5Kd59f3fSG4qKqsZZDP+w/lXcnYy4Nde/wvcmBX0dIsrf/vNvKr7EOfqHvdMj7JshuzULfp6wh/uvIClZMT7t27gtsFj/Ojt7+LcLQtcKAb8xqdu5YrsAgNV8KHJEQ4lm+xLdjhoJpyvoaUUBsXYGp6o+/T1lPd98kZ+6U2/zIvzXWYu4YPjo9zaPsHYGi7UC2SqJt31BaNRpDM/JvXIdEC7g6eusi5yUMPIOyDwyVRs34TvDBducKRbmu6ZwJOEg3coil7jGIFrxvNx0Z5DcAKPPDiliNCrQRnlT3luoCWE5zsNpmp+HuzBBCl0sSFRtYjSlBUrNQkx4pImBQTtnS5qse0s8JxPuWmUlUQ/a5riOWxwphB9RbC0C04woRmYR8HDxKHoKWYLzUYQ0MSAnonvMGjnfeCDd3PlGxPlOfw+1TW6P9Vzf6qmqA9NmTXE759MXSxOlHXULT3371LgGK9PQEHvnEUXjtGBlGxXRKitrZrZwFC1FXUrpbUlzg5lzzDeq+meq5kNdOSoYzVl39Nexk2DlY6k8JrahHKlkrUvgWRXNVS1AkkPXVMUy5pqXyn7v3HYZQu7CXonwbZsBDJmi8LVtrmjblvUqZ7c86nFHZxin2hjsyCQ+0sWo8wVsxOYLfvk1HAZ+0bP6eC2JYVb1ZGfS0qnb/gC8q09cBKnT02B6pR/nUlTfMsvOwKNCue89Z3/XO7Sa0tXck8HtLfqgilUFHWHqVGgprmmRvPick+9K+V6M0WY+mjKnmpoIcpfM75hcEr2o6T0Bb9RlL6gLTtz9oc+wRPmnEh8Exr44OBFpN7Bx2aCzJc98RQ3Q9n3bCaUn6DVgjB9wFs7KvKtGlXrSA2JTjkBFLByPF0SvL3FWjjum2MX75ftK2R/yrecn85J89Jel/Vh8ARMV8IES8UplLJ+kqbEMtElQpGqW95Vx18LUc8Rmi5PYQ05GAFscFomI9mwEVCEcDSZtGhJFPXnMxmLSDXS4HwBHYT18oGh97T8TjIWFNw5r7Hwzd9sINTVqKHy1z/KAzz13P8bWaOk4SEi/qFxCMcjJpR98fGMfTyri/SwAfz5n91I+eoKs+Non1ME26x5IcjNr3yQB377OdhUxKDD47XwzNsSUiRuKdA+bSJqWSwQo4JDwlsQWGEEvUqGGrUrlox17khP5QTnFTNVfsztR7+WS6yqqp7wKuuOJd00lANZXZKxR2JKhfGzNV2piOQGj+oofKwh3Uii4MtmDjOWoJ9s3YCzrF+X03pfzsatBVddeVFEm+Oc9qmEqgvtocTXlz3ZTPcuDrll79P8yXtu4egPfIzdP7mS1e4un3tykXxTNrFiuYZaGo1xlfFrj97KoRssW9cv0j4p6O7OY0ssPqq4cEtNW+V85Pp3A1C6ih9Zv4F33vdisrzk4dUDwFluymfkl+3y65u38hWD+7hQDPjbex6kdKLGP1MuMaxbvGXvHQCcrgY8UezleZ2T3H7dHjJVcaHu8HSxwrXZWZ6aHaZwCQM9Za8ZMcUydQlbdZfv/PNv42df8+tckW5xsta01Iz3bdyAXdbsTXaY2pRFMxYEsWws5YLgyGY6ioGkqPDj1Y6KqExMm/M802QsHvfb11jaZz2COYDZkneXyGHhcXmdqqXiyDsIQucLCilgXQy60aX1Y1lL1dENd141v/OXi/Hao2emvBTJj36+OLJdG/mwUsDL95ENyk8Vakf3vKXs6Dh6ni3o+HrJ2EX7waZg9mP0vo5I0iWNRRif47+7v59nC3L9R+/nOmzG8tQQXOK0Itj8OS0c9nC+6lyLnaPfBMVRQ4p1axTaz5jDuDvaIXrdQ7YbRIRhohEQPcVkRVP2ROhsCuH3zhYVs76MttvrFjOVJMbdQ4k08J77nIxd/FmgJOlaPNrLnonOH3UG5aK4SyWbCWUX6j0CGnROiG87Toq0yjbaAzOTot31K7CC8AHotJaU1jMpaltH95PWBQ9m9MSDvFiuUdpRTxLyc6mss3VzXYZiL/imx7A0TdTsaH8vmVnze2VPGtJi4EhHKtorhmtAwmzEwSnb0oJ4dqQgj02caQCX6YoPZfI0ju4FH2ozJZoCqNqHhaWaYOEnwUpeKOrEMWz7uGLP56WIC/ed84JAXTmswtuwXoqmhyKRRBpSibtvvnOglwQhspqja6naYaxHzn0jJtetiuBRMnaNG5OfGgtlRyYSVdsjtZWKdI6gqQp2sdMlJU5b4R5NG4vJwBMXvYqN4EBAqEPDrKzQfcq2hDWZ8L2duNXghBfeWpeiHWQvNaVQEcOkMWhAcKALFwWxNvX3pHeDCnQsXQggEe794I8ezqmqwxptm3wUr9UpetrrPjylyV+bZa7i99SFF5X6ojpQ7pxvjHRNnHDhXGwqJJzNYa0jQV8CPDhPqQL5uzWy/pkS8s1Kim4l67E1NJNLJwi9GFRII+QUmLlG45nycKgvkLvL34wG5VldpNdt2P7W27jsn3+Mp374dq541xaP/e0F8g1RnSdj74Vbwcc/cw3qKkEJyoEm2xBhZN0KPEKFGsvItX1eFox012/wSVNkZ1vioa6jV62LgkZlBaWvBjVmZJjtLylmmtYFE/mXdVv8fXWh0BONrVPsQiU826ERtKpW2NxK8b4llZPNpJg3Ywn5iAtY7iTYwHNT050GlREfcstsUTM4UZHu1oxXcx7srZIkNUlSU3Q9N15LU+I01G3HuUf28kenl1l92FF+4BgLb88Y332e6/9csV20+KbDn+bHP/UVsJmxNupRtiYUlWHj+QssvPPjnPvPL2LwuZQH3vyL8XzNXMnHZxmvaDneuXuIw9kGj77iV3nfJOPR2X6+9aN/H7WWc9ttD/Jv9t0HwF7zSX507SV82eB+XtOWKuzvLNxLqhQ/dO4VABxrX2R/ss2V3TVuyLb4xHSVV/fu47PTY6SqZupSsPDcbMSjZZuHZgf5oU98NR965X/gE9OjPFouU7qE/Wab+y/u55v2fpLjyQYAOy6jdVE+fzIRIWYQPyYTz/10fhRtG192CEifH6/OraVlW9E5JUmlYXMPY/HAVdVFw402MyKNJfAQg2UXEJ0JqrYmmVjKnvbolr9GM++xW/pm4S/RaoI4E+R99BwVROhVOo5hZfNoimwq2RCF1y4oeeV5nWIb6VH84LoSNj0nY3CcbGpVy6cyuuZ7x1RW5SkqvulJpniPZyKKi4PWViMgC3zf2o+FAx88uMWIbSN465sGVQt0JH/+gmtM1dFR7KicIJBC3VDCFUdBJSJbXUO+LcdwuiTnpnveRZR9tN+QTAStC4VX0YfOpLnOsl38JE6Rb1lGB9IISqS7YFJxVnJaR1Ah3VUiQnPE8JQmzdOLvzPh82YnM+q2wx2U0ZlSgBXKTzWo6T5tsB15P2XFmrXOoXXW4NbE0k75xkmKqDDNITaToYmK4EJBTCA1s4b6AEJBDOFwTkG6reM5CCFLVddhJvqS5rfsN68Vk6VrWbdDg5fMmiYqWKAGdyaURhcuFu3GU2VC2NVkr7xm2VERma+S8H09d9vI9TRvuWisrAc2IJ2qQXV1zSWWg4E/7jSoWTOFCPfu2i2WlbtNvJeimDBVdM9VfuKjvaWk/0z+mIV7rc6gfdFS9sQZyWnZH/JdOYbJSI5p1VK4Be/y4+mVMZlXByFks1bEdUn5IDNvIZtMmj0x3NNBPJ2OXHw9EbdrkqkjmYmmqH+q4TGE62ayR7IaJvuAa4a0Pt3zay4xJMqmQCpNQZgESHCSolbNfW38MQ5AgC7FljXfdr5BIVJhwjU4P30JGiicFw8rWb8iaOY9zzHK28ZKI1D0ZDLh/NoWGr58Rz5Y0AKF146cfvx1VUkh77QCr3mYBiT/i49n7ONZXaSnOzDeq1gAypWKp79qEZtJxx8bOSULarqrcVeM6HyiS9WB6YrESKMd1Iqq0ywMsxUpvm1maV0w0THCeh54CJNQFqo9NbRrKDXUijq3ZBcTEYaODdmWhAUFak06hGIJbCopgLYrFmr13kLSTvsVRVvEUapbUvVK1FouG5gXJColG7vNhG9u2xY182h+pkm8ILZzVpLybALjvQkdoHMB7J/3GB2SxafaX6C3Ema1puw67P4Z5myOOT7k6Bs/z+Jf7GEpG/P83/oMP3nPK7ni5ffQvfIKfuxfvoavveEenhqtcE3/PJM6o5sWnHxjxcI7pbbauarm+p99C9ULhhSjjFde9yCfPHOM/YMd3n3NH9BWArvtNUPIz3H3l/4CT1fwDe/8bl730g7fdeQD3Jg5fmz1bl74r9/CW59X80ev+2k+M9vD6zpT/tX+O8gxDF3FllV88+JdPFW1OJJu8sOnvorPPH4UvZ7hjOPYc8+SmppBNuPTD13Gb3/5L/LRyTEsmpHNeUX7HCu6y6H+Ns/P1zhk+lgsQzujtWkjV9WE6HO/SCqPcgTRZJXLRlXnnl+oxWdc17IRJjOHrh3JVFEMRBQauKBhNFx2G3QpToRQ4Gy0JwsUFmcUrQ2LM8JtrjoywYBm3D+PnENo6GTRd1o2z+BcEMb5AfELYjgQ0V14XefDgGymMYXQOIqBidaDYSwcHgHBaig7UOWNXiOKOE1TGMdU1bnnBJ57+P+qDVkprxdEm4ECYhOPSPkGQlmi0A0C2hfQQWkIwnk1hUNVDhMK9qmFXDVNkqZxzHEufq58y8ZmKxyLyMFvSeR82RHaQOeCI9+uyXYEYZ8NNDtHDdkuJDPbUJ4UtDZqhgcSigW5jpQV4WB4hBF/QJ0D7cN4WlPivf3rNswOlpjtRGxcz7So9xYwTEjGWhxbPPKa7jbNWtkn8sqjjagvspMRzJYclnmOdfOcoIFIvdCx6sr00njhadAH2UwQ4GD3GQOFfDNgpoJGh9cOlK0YdOO92lUFeETf+nU7XOOqhqRw0b8+nnN/nQVLwrB/5BswOuaiM1HthdOBppWO5H4NE5hkOuftrSAE34TJTwzSsio2Dk6DVY2IFHwDhDTWB+5UqMqKfWNLPkcQO4otq+c9W0e+WVMdTOJ0JxaUyGRLOZns2JT4uZOx7GtlrmLYV0iyDCm6NpWiv/DULVlXFDYTmmdnTRDs6bIWRN6L6Kd78HoIRfe0nLdI76hcRKWDPkWmK745R9ZAnGO6ItdNtgV8UhwSdAWWZrrgjKRp20xRGzm2kz2K3hlp9OfDtercO6T54zNbVIwOSErodFnW5dRPwYNV5/blQvHsn7QeFdeeimNRVnPxiCwMutJUHVh5oJLXr0EZySEZPA2qlAThqqX9NIdL0lJBrslApdF+LW2v19hcyxTOpzub2TMPSccRA+3+d7/P34THs7pIL7tQLnh0oVthioSl+zRbz3V0T6oY464s9E5AfV3BzpUtOqcN6a53vhjJxpRty3gwLJS6UHJnqUbcpFQobIh8snTLYMc6KsvtUokzHmlXCjMR5C8EArkEWCpQ6xm2U0MmnHNqJfZp2pGdSyiXatw4gdziOjaGHUlB6NXxYy9GHCcyujxYUXUrkiczdAnDw7KxTfdA+zyM98nloisJahkecSRnM+quiJR6pxTlRovZHsfewZCnf+95JP9gwnW/d4bSGV515UOcvOMAxf/Z56pv/zQPAHCeP/idG1noCwy478dzTvzr29H5FKcdn/iHP8PXP/L1fO/Nf8oV6Ra/lL6UgZnwT0+/gs2iw6cevpw3vfDjfM/KpxnoNq//r9/Jq159Dz988M9Y0V2gx49uXMlPfP8v8oqWA9rckAn6d8dkP4/NVnlu6wwvb61zsnas1QP6esK/OPzHPLTvAL/w1Ms5+7n9PPXwftIdQ+cMZC8d8cDsEMfSi5QYvqI9ZdsqhnZKK6m8swtoNGu2JgQdRXvFuqFJOH+92NxvPN5+TNAk70Qyld9TziNypaN90dLxXsXWNH7BowOKfLNBCisvDgyOH+A3eRde00VkLBQt+CZCnFWagjsk46labP1QgjImM8fOZQozVrQ2Hcoj5vKeUqwKnUfF15rncwekCIh/Ch+3sX10uimU5y3owrhcuYafG/jwoSAOwTdVR8bpAYnDENHSgOQWAx0tGsFzygNqV4fP1bxHcNqQN/KFvG9A5L2lkDNaYzN/flMZU1uPlio/ng/jf2nYZH0pOiICLHvC1Z8uau8x7Qs4X6SUXS0TGr9Ry3VCpAMFTm2+JeigLprjGOkeTq5DXYDeoYmp98gtFhF66oR8U1H25NhkJ3LR6RS+WfMgRHRr8euOmz/eqbx+1ZXfyzekeKtbc02eCcdX/iv8Wl0PalShMeOmMKvbAjZUWpxbdBFeW9awRoTZXDsRWHEIeDLxHPBZQ/PSM7kuQhx9uBZ1GaxU56dI/rslUsDXmaJcAJvIhCQJk46pixaiNhUnjq3jhqXHasxUfoZPz5SGXu6n0ByW7eD7TSwubSIAQJzgO1/Qu+Y1cF74OZafS06Df4ISxHh0MIlOS+E1ay+WVFrum3RsZerV92FunppiM/kz33FMl/xrOrFqzHZkv42OS7XQw7Snf9lU7rVsR5D8dOJIL1pmS5piAL3TMpXIdoSuJiJ3FSc82a6sm+lwrrnwtqmqdmQ73iGpEr/ybMffP3lzv2vP9deF8O9rj7SXHa/pKOfQ/TmBfViDYh7HuuRSROctg1/XZUIW1pV0LPd8sOLc92l/4pxjgma6JNOPIGI3M5l0hQldyLGI+QIOmX66BlAhXEOqAS3KrpkTws898YuPZ+TjWV2k46RQnX31LVzzTx7l8e95jnAi905JHmlL0Iu/MZOJw/7ZEvu+co316R6yTS+I6/jNdSKbW9UhxkYrL1QKIjLh+3r/YOuFUIUg2qpW5OuK5OmMqivPCUhX8M01U7FJc4XBLZYw87yDxEboRm+mlH0LrRqmBlfqKJ4KtmNBFOM0gnr5AjDdNJhpEjcyZ2Thne6zZNs6FjLaf7fuSUU5AGU142tmMDHoicG2a44P1jnz+f20fvkc7zv9XPpf+RjFV97A0X/1CFe94y4APrV5jM9//hiLdxoWHkjI73uaB39wia940T389KGPcMOdf5/vPPEavvXQx3nbp/827VbBLz/vnfzY6a/kkYt7uXrPGv/0tvfz7+94De9+5GVC21l23Nx/yhfo8nh59yFKl3DFH/4fPPz6X+AfnX4pP3voTq7LzvFl7fM8XWk2bMVnp5ezbIaMbM5N2ZhHC8upJ/cyOKkoe4bJVTPK3ZwDy9tckV3gxfnUo/maJS2z/aOdDb76kdfw8Ll9dNoFb776zkjfCMVy4EfqUopu6wVckVPqx9ggyLps6q5By/1GHq6rpGx8fNOR9jaOxAYxnEtomkhlG9HSdElG3UVPSYHiVf8hjCc4ETglwS0BAQruLijItrnEwtAmitE+Tb5jIzqtKycoUCgcMl9sZEqEVSFQSTdIdvA2DwFIqOCEoWIDUPZM5PcCzIuxcA6FFOdVrprEPr83mSIUIKERaf4tXO/Oiwgj4ug/P0o+XzJzl6C2l/yJNCNVrudEs45sp+HYRytIINupRUCqRTCo+vJhJGHUYrqKbNQU2GVXRwvKqqW9T7330m8rJss+EG2vorPmGDxdM1o1lD3IdwSVLxaF051tqcg7rltziHPw/nayxnXOqBjRXixazJambssaVvYdqWuOkXLSKJqJFLw2D+suuKmsl2XP6yZCo+B9xmOojW8g02Bpu5FIUFEQLCpQpYLMivanV2OGxtNHNFVbkOeAgjolXuqqUtR9CTwKqaNLD1lfcHkLzGhz6Mimc0VvIkVtbGq14tztjtaaZuEJoXQJuOMYPCmIZaCbyLXl0fSZULQGJ6xvQvUljWkogqu8cXeK9p66ud+SCfH6D7aELgEVqDheNGoNpEPRnGS7lmTimC0EMaLopFxKnGRVxl/3BpxS5DuWqq2jgJ24nhDTX8uuavIfnAS4BVqZmiviXUcyC+qc6AAT/NRDE7/4qM+BSKB9ce7e9G5Odapobfh7OpFCdnRQ09rw4Up+PZiuyOdsr0mBng7DBIQmoE2H72FRO3KvFv2EdCKFsxT+xBTqQOdzCfRPhBGGaFfKrr7EcWvnqKF7ztHaENAmHc+9RlifPfqvLPTO2qjVCRoF4+00TelIpzWzhUQ+a60iXz3w2+fXqNDQKyvnJh1bodTUjryY58Q8cx72C8AX/0K8x/+Kx7O6SK8WLPVCxalXGI7/t01CWmj2aJvhEcjXAb+BFwsS6jD5s73UNxRMWobOGUO2qSAsqkYWgDprkCPlx6tVj2iFF0RVwrmUQl15YWfwUTd+AwtBFLVHl9JtTVUo6oUaUourBHXBKlQhiLrGkT+WMbmqkJpvx1AtVNiOQgVE3aro7mAm8n5mLEV33fLiqxUbeZKTVSiPTdFnczpnFDYXDnrVtdx08+OsTzpcvbDGnz1yDS84dpqP/9n1dDbhlqUn+bS6jMOfSXhqdIJzt23zVY+c5X2b19MyFa3zhrIDm9fmFLdcDb0ZX7LwKLlK+eGb/ohXd84xdTX3Xv15fv8jt/CiF6Uc767x2c8c594HFzl3Ux89KHjLd36AzarLL3/mJXxz/0lAIuvvnMJLW3KZP/GGd7BjS/7R6gdJVYdd6/jVjRfy0v7D/MrWDbznIzdT92o6K2O+5MiTPL93gt4jCU7BysvP8o5rfpPVVyqWdIcbf/wtDE5YRqtCQXjdWz/CP1z+JM/vnuAn93+W2VUld81SfvPibd6rV6gfAQ2TldOLFZVsjsp5sZOToBzwPE/l+eceybaZbIIxWrua546quVALvKWj8teaAl9cR7qNhXxXHAmyXe/gUIKicWEJm1fRlyahbHu+Zovo5gNzm5yn5IREQCCOppWRUfK8q0CdqyiEDN71yGGJNKGAust31OhSBFeJtUxWtIiy5p4j96PffFUzDo5BSv7n0RbNNzzOn5MqmaMmzVEi5Hv5pkV7VxevJahbTYEVmian5dzYTPlGJfyuagr9gLw7eQ0cpBMpMDrnK/FT3xY0PZn45NQd4abbTOgA+Y4F50hmYuMYHEDMVJqtwQn5PJNlEx2pyo4U4843I9PDFel6IqIy/z3Eo70pYqo2VPt8SqcS1LxYsiS72vOI54R54ZgVc+thHRow+XvrgncH8UJVXcn6GXjMSjUIdSiObOrANrzs0FyZU6nQMBZqbO5IlqboR7uUA6Em1pmjbrt4bTkfIpdtaYpFS9VzDA9oOmuOeiVB1S5ypOctDosF8Zx3oaGuwSkpjELWRNXW0RI0FHfzFJKkagpIG6YVni4SGuDo9e+52oHCk46FblJ7S0abAaW/Xn0zbXPvgpTOWfEhFAxlm0lLmBiJ+w/UmfOf37uB+eKuvVGzeygRTnrSNA/WN3PRRck05zHsY3KPE61Sy27TxAVOfri+aiOUr0AfKvpyLdep7MGtdRepWdbIf4JYe3qcgt5puRfC+lZ1dNNU9qEcyD4tbyrnZnhIMXjKMd6ryXdUDD6quqDW3CX37LxzVaC6qTnKWgAbRHMja3LnguXijZrVT8naNR/4Fs5RWL+SSeNxLk2EjpaJ2W4F/rnZToXNpaFX0kdgChsBjMlyk2waha+zucmmUpEa+MXHM/fxrC7S8zWNnTMnFxEJFIH/aJoNTPtQhnwLdh0ke6aM05z+gwkK737gx8JVR5BFm4L2NBasbKYQkDPItiWdslqoxYllJhaQ030WM9EeaZXPknr0bHzIkQwVlfKg68SIULRTR4W5Kry/8dPi/1v1ZDMiEQ46vRpzPo2oarHo6J4OPDzZlMuuLICd05q6BXvvqTm1nNI+LyPcqi2c9c5rLvLA+VUmZ7s8xX6y1Qmndxc4/itnufH3nwCgl8x4YHs/ZW3Y+xd7+Ml/cxuv/b4/5/dOv4DZ1VP0+ZzhNRX52ZTWEzk/0n0Nv760xX++6rcZ6D4/v341P7Z6Nz/2DXfzLU+9grfu/xCfuu4o//fxP+AXzn8ZrzrwEL/+1K0kpual1zzG2bpiqyx5qDjAG7qnCAU7wEC3OcaUdTviRXmXF63ey51TeM/D19E+q9B1Agz4JDfyCX0jINHY917/bi7UjiXd5Ssffi1XvOFx7n30KC997oM8sbPCxGY8UPb50OZzWDafYn9SoLGcnQykEB65OAYPRWfZabQPYbGvc79JBkW/ASqPuKciAhRqg/WLr6TWhoIzhHEEsVdYvANCbT0XMZmIVZ+8v3yO4WFx5dBe1KZrRd3BP1/Q+jrzn2PHUdSywaZj2fSVd20RQZ0UEOnIEgAL5QDrUEoqlciZ9JSyS3yEtcLRoICmsGK7GGgofuOqM01r00Y0E5rNLmyEzltExomWFZcHebK4UkTPaeW8gFcKkaqlYlKiwm/Mnt5yCX/ayYQjoOcRzUp09IIPHGPhZocQKhevAZs2TY01UHcMydSS7whfF7zDjPWN28iht4VHjIKyZyj6IpBLpjbygqPAris2d9lQqHnti46dy+U86VKhR4aqa0l3vDtLJkh51bW4luhWVKWw3RqbatJtg5kp9Laas5cMCF441p5mUEP3XM3OUUG4822YDQAvgRAnFRpRsi++XSLfW1VeiN+FbKSop40gnkJ5txRHMlFkm0aQ392Od4gRNwscpDuack+F1VIlKic0qHRbmu2qC6wRi5iqFfYGX5BZob5oL+5zShg8poYDH5FNJIZZOcdkj5FrbEosesM9F+57maxZ0pFjtmhIJk1RVft4e2eE8228diUUV8nUUfhrvOz4oDFv+aisd17y7lGhiXDah90Y5ScFLu5doYmiNUflcTD2wktZZ4SSEtaXSPGswNlm/YnNtvUi9DII4Z0PR/IorwcZ0rE/nqlMvpKJi4JzgHzLzU2nYOeYHJfOObGpTcaW6ZKBDt75RF6/6gjgFlNqfWFetWQdBGity/WU7bq4hoBMf+Jkw1/TkR5YNzqC+PDrTCjqA4hStRTL9zsp0GsilWa810h6sUf95TrWJLNGxC7gh5O1XisvHA3rjKyxYV2PGRyVo71RU+eCrOvKiYB/KjoguZZdnOA9kx6yTfzv/1xfdHf5G/DQFaQXpRDZ/eZbOfqDH+PRn70VXcPig5rpkvDokmkocuSmW/lYRp1nbL94CjphvFc2p3QH72srIo901AimbCqj3pBSqgsftXxeUe0kJBN5fjGAbEsz21djRprWRe+0omC8H9zKjFnfoIxDJVaKc+PQaQ09qCcJSkFVK9JNI041C1KYq+2E1pqmWNBUXUv/ccNsSbiYDo98TECEZuCMjt/h1Fc6Fg/uMFtNmJ3ugROE4vzaADtNUKlDTzTFOGUL2PoReOT9t2NbgrrVKxWXHzvP8d4aD+67mjvXjtPKKrI/W2B8ADqn02jtxUN9zg77HH2OcLv/2cojPFoOedvj38irVx/gS1qaDz73vwEpv3L0Th6vhvzWQy+kPNfhx776XRwwCXeMj/KtgxPkqsXpepdf2XwR/3LPQwA8WTlSBSt+oXtpC645dJ6nHrwMV/vRbCEo42xPzRNveAcAHxgf5RWdp/mVK3+Pk1XOI6urWDTlkmHZDEmpeeOeT/HK9i5jV1G6gqc2l2l7hFZZWazTsQOPLFctP0JuyRgyjJFN0fDG8Ztr+2JwPhEP79ynZsaNy6NLum4EWumQmFCpS0eVesqTVkJVcbBzTNM/YcmGxI07LPZiSyiC1DAFiK4fpcNV8vnybRvR/IAiBUs5EWJ7WJRG2BcET8GRJh3buLHq0sbfc5lH7xRzDhUOW6lLXGsCmhmOhTzfMusYb2fnxXILKvpiKz99CImE4dgEgV/gHoeiKTQ/2oeNWAVJIpVa3Wr4naZwlPl8oEhT0EQU0nNNwyN42UtBLoV2sKTE35/iZe+bqJnFpQqXCn82UEOURYoVR2zEpkvis92+6MRximayVw6kSLNtC9pRLJYkZ4UnlQzlO6VnDKoWwXy+kUYkPPrd+wLmkr3VwuCpGpsoir4ci95pcYsqBvJ72aa4hqjasXmtwQJpmDRqZELoEdq6Ld+v7PtrLPDNnRSHZtrwtI1fXxPvsBU412YKycmE6dVT+by7qbx2y6EmCjfvmhLPh2+yTBD02nidQECIm+s6IKTBFlB5Me5oUUdXraBNybd9U97RUaQaaCmyRzmKrorFnzXyGeWC8Ih3QNhnDYIbnUICKu+QYq0ITRtQuji1kMmbjWJSOb8qai5spti6uUQNDXs+62lR/ndD+FqwZTQzx3RRRctTXflORoMqHclUXIt04f3XO6qxPTWIUNJKsT5bFDqLcPebe1+XML2sIj+Zkm9bH8inY5qvTLvk+wY3LSA6++hKEH1bieWpONP486Np7Clds++HdSUIZ4NuBK/rUdZ5G2MVBb0x8MhAtmP9uW2mOb2zVUO9m4m1q0ugDoCbk7XE+alY0TfxHEcLz1T91evPu3epWgLkzLRuXIhs83nN3Przxccz8/GsLtLH187oP94i24LdI5o+sPczirWXl4wOZn5UBsHeyhREDreuYOmjLdKhY/9PfRyAjX9wO1tXC5qT7tKgSa6xMYvx1bUgAFWLKPCaLcI1r32Mez99nNZZQ7bdLKjp0FHsq1C7KapdS4E+SQQh1w7bUjLu2k6w3RrTK7HdkknaYvCIZut5gqQHzny6bZgtN6hHuSAFejqU4tQasLmgMksPO9aOVhSlYXWwy1mnKE/2MBN4/uWnuPv+y9h7ZJPtcRv1QI9iKUXvnZKOFNkZ2XDqnZQn6v08b+kMP/8P/yP/9oobeflnDaNvP8nn1g+ye8c+8k3x/zYzoVJ82f1fw8mLSyjlyPOKq/es8ZbFhwjWC296+uW889ifczzp8dBL3snbztzCrXkCJNw3Oky+cBaL5R8/9XW8+eCH+dGNK/n+5cdYtx0vIpXHnVN4z9V/wvO3v4nZPUtS7LbhLV//J7x58VGGtmbblbxv4+XsT7bZn+xyoe7zvPw0q6ZmzWoMjm/4+e+ltQ7/ynNqZwtyPJV10X0gbKzBJ1xZKVBDqFEyFW74PGJbt4hczWAX1rjDNEipckKzsImiHnjer5lHdnyip98UBFlWLD4qkFfgN3cuVBQD45F3uT6FL+tdA1LZRGLYkJKxtE2Ebyr0DeHbBl67sirytoNrSYgrF6RQeNthchXEZYHHD2DmRsSheWkcDGgoCX5zLXqN53rpj79NvYNDqqLXtqkcqpAN3GUKZYXnKWEgcqxCswHNVEs1QwLwYsIwLYhI+VxiYeDwx8mBFxAHKo6yssFmu9YHzYjlmk19yMnEMtljGrQvUZcUhKHwAmit10xXRARoqsZWb+YblNmC2K/ZDJKhohw49FSjZ4qqK0L2OndkE6H5VW2ZCrbWFaPLZPLnjFCa0m3tqXpCK0l3PBBhRYhrvF/0aL+hDuJNP2EsBjK5m66I2NN2545tJXaIkXuN/NxMiUj7PHVGOaBqmqB0JzR8KlKU0FD0fCGXWBjLd1Y1Ef2Nr+ka9NVp+cyhYIu6B8K5myvqVEM/C69Rm+b+D4i08ZqU5hpXkQ4VmthgQVjlNBao/nikI19sVeDSpunEfwbnHZ5s6poPqoUulw6Fl2xTQ9HXPgNAx2I02/VheFrh/HU/+HxKuksML+uec5G7rguZTgV3l9RPjasOcWoDso6M9/nro5agLptC54KNVC+hFck93dqQJqNuCVUnJhIb2PfnSeThy2euKbs6ulGl4yaYLYjxtWvAD1PAZEVHGhLGN3YTH9LkJ+thXRF6lQc38AJgj1AXPe9oNPLrn5Xk1Qh0OKJ3fETEnUPpMFGD2cDrT7ytapjihetAKGwKXTdWs5FiUzX2vc4oVOnQhY0gQdTwBEAjVTgUZeDqPqMe6ovuLnOPZ3WRnnUKqhfvYu/pY1N4+t/ezrF/+TGK3u1M9vmutONgW6yVigHYnoxdg5jl4o2w+MBzsXc/wPJ/+hjLwPabbmN4SJFveQvDFFoXEO66k98zU+HH6RIGJxyj/SLGuvfpQ8L3pFl0nRHhl27V6F5JPZXTphzQL3GVRs20pJEtVjDRcKEVb9DtmwvykxnK+WTRdoV+vEW5KK4vEtAizy17DTKSrwsC0tqoyR9pUWUtLowWMEA2hboDn/vEcXQCF84u0lmaULbEgq0uDDqD6R7ZbMu+o/9IwnsXrmPpOWMe/X9eyPa5bf7+5R/lYGuLF3zHn/Bd73kTZs+UeprQeiLj9KcO0b9hg+qOZWa3jBhXKW2V84vbh+jqGcMyv+R8vveu53Puqz/EftPjxw58DEh5z7jH7x//AAA3ZPfw7tEqr2yvc/u938LGboeHXvJOvuPTb6LdKrj1wNPcUaTwcI9/8Q3/hf3JFp8roEYKf43jqnSLw0mX69Ip69ayonv09YxPz3Laa+IAUKFi+EsQxDktvOEoGHNi21XnqqFKJeK8ESs/X7gFG0Ph5AY02xfxrvHZn6d86FKaPjOTjcZsNwV2pG84ANeg1KXYq41WE7QXN+qhY7JiYjw1TvjQQsXxH9Q3B0HEBtKIJNMQyhScMPxnN0o+dxAYOidOD1UQN2n5HgWXWDHGQsd7n4diJnDxg1g2cjR1w/fMd4WrWeVSpIQ01mAl195oiLt1SzbuZM6LOxRvUqBxaQHuA1pIFFYDiVij6dpR+00zcPJjEuO2JIWGh7yfHLyyq0EpkqkgzMq/tjOK9sWaYmDk+HmHIOtFZyER1Sko+kboN/54tjYtZdeQjhzTZUGUq56M8+tA6SgRekm3olQGXWpiEJBfI6oOJNuGql/HgrMcOJx2pDu+0E5BJcSQp/EeHe3rQhhbvu3BgATGq8L9TXfl86RjAS8SX1gH3nwAFHQt3OUwOQjHL3ChnZEJR9Vz0kyk0kyESPdkrHBPtSgWLUkta7wZN2JHKfxUpCkpC/jjbEpvrenm9BLBRcg60Xx47nooOgMNSDsEUZYlQCgdXugbUdG5/AKhn0gRFkKWgs9/KGbDPqCrwFX31ntJ0xArC2dfCvlFLec7U9hFQWTbF0qKXnaJqDWsP07NBST5gjWIQeusWY+MD8HDNWtLvuuocsXOlQJsdc/BdFHR2nIimnT++yT+v3BPZsRmWFxMPMjlBc1VW8eiOQrD/X1Zpyo6OcWHP0/ByjLcs9ZvHdE1Tcu1J9+bS/QG4oIjTZIuLdlOLee3LfehTRTtNYuZVMxWMr9+Qfd8LQBNrpns1XQeL6m6zT1fdvUlk7U6C/QqRTJtBPKBVhSpcN4nPawxyk9Q6pZqbG6DPSXEwjwIU0Nzi3USuvbFxzP68awu0n/4hj/in3/w79O6eRv9sQVR2H/pzez7uY/x+H+4lWRHS6EaFpPUbzJhzOuRpce/aYFDqy8ie9+nAFh8eEg27ND+w0+yB7CvuImnX9MiGXuXg1I2u3Qoi/fmNYo3fu2dvP/0tSTGsnNvG2jGcvm2Y7ag6NzXoupAfWyGq7U4uFQaNTGYqURvq7TGlQqL8NpxwNgwO1iSbCSiBN9NKZaEKmMzF1NSAwdfuIx42zO4cDAh3ZbNcbJPbvLpXu+vXikue+4Znrr/IGPadK/aIU1qxp9fjuEgQrtQDI9ZmCa899R1DFZGfOtln+B3/tFryT7yOX7ve76NW77qYdb+1WUc+eFHePrwEhc+dAj1nmUmLx9Tbef8yu2/B/Q4kq5zWbrBZ7vHeNuZW/iTB6/DVZr+wV32G1FuPVjWTJ3iRfkFQH52x+QILVXwLY9/Les7XX7uhb/FK+7/WgCmRcr7738uaiehd/0Wi2bMhWrAYjbh8WIf39Lf4OdRHE368foZqJxHyyHf/uC3svGJVfQhGDzlYjGQbzVUjq1rHPs/Ttz4g21icDHBo2vpzEXnjlDQh9G/LufoEX6Tc1qeEwKHqo63GNsVJ4PgrhHi6V14vbpZxJ3f/J2Pkk4nItSaLeoG5cobzrkUFEQKT53J7wr/XBEcBcLnbCgvcxuE9y+etwqrPZIuHOmAOKrG7tCji04FZB9UZWNBOy+Cqr1QM2z0KCkCbKKj9VsQ9IawHOUR0SCqC589uJxEKs38+NsjkwEFD+cz8YWE05faRgabyLKrI23GpsSxeOb553WuKDuaYlWQ83RYRzeKwKONNo/eZUTQYN/AGDmeYfxfDDT5TkNZ0hXRXlaCi8RTv1hyqN3E2xY2xzMUP8lQihlVG2zmqBYrmeaFc51IkxTQ94C6RiHhDDoXnE9d9ddPLn9OV8ClDi6KlZ7wf4XmEtI2Q3EVBJniUCXvGz5jmFjqSgocPDc6mci6azNvFzmR79daE45+MpbXS0eWOtexCA3XXhASz9N6wv0UBJ7hGnQmWCUSg40Cwht0KZJnIDSvcB1Ezrq/XpWDMtIqwjQXlHMEy72Q4jnZo2PRHykWPr2zfUZoFMlERJK903Ltjw6kwnNn7lp3zedU1kULzzCRA3+8/XPDVDDflutyuqi9C5KkZmdbkkfSXvcCaaViqrFMlGStC2mtVgeLQkvqHXVCoRwnWi741EvTW3bl2GcjWbsS34QHTnhY/+ogCPeNfL4d1hn5ThJGJd+xyiAP3vhjKYitUdS5JhnXJKNwT8p53r2sFaef0UNfNeuL9jqZ0ATM03CEfmJlLann1iTX3Dsy7QiuW4oQCCdie8do1YCSrIl05MTFxYIqfGbC1EVxe51Js1PXzzwk3bkvctLnH8/qIv1ffP5refUrPstNvaf5ifpVzLb7bF6dc+TDcPy7PsG5777do1SyuOsZqJbcxMWiFNw2gc5ZxcUbUqrbbmf5QcvWcc3yg3V8H33HZznYu4UTXw3tE0kclzvlO/kp/O77XsptL7+fv3jsOO0UrvnKx3jg/Cr5nf1IldAF5FNQdc70YEX7ZMLk6hlkCrdcYkep8C4XCqphiq394p44VKlJR4pqyaISh6sT4bIPtdiWeTRNqA3yd+Xk8/VOeW7+RNAuZeHAX4xJ1oe4Vsrz3/k0Z7YOk57QDK/qiv1ZS5DSOnP0n5ZNcLbPoY3lwvkFlLH8+3u/nJ/6xd9mZHMenIxFfHnDNcy293D14gVO7D2ImSqSRzq4nuMVH38LL7vsce5eO0Q7LXnRnhN0dMnrr7uX9/7XF5PfmXLN7Ftp5SX33vLbPFoO2W96/MLWYb6q9yBf361IVcLrr/pTvi17GVelm9xx3R/x9Y+/immd8Ngjl/HCVzzI1+39DO9aeyFaOQ7t2+Rb+hsAPLd3Np7Ty//4O/i/XvZf+d0zL2T6R6u0tRQl4z0qhqLYFDrnBQmrO7ZBXmsgCQVkY6Xo0vl/88mJI4l6B0HxguVhKFShQYtrI6h8GElXS6ItSKae+9kOvr9iERYSNutU/NU7FxwYNYe8eH7pkoxtk6nww8N4PyKANaiycZIIny3YFVYtFXmVcgAuLXJ2LhOx3ODJUigc3jdYFzbSBxRNIRsEmIHmwdy/hb8HTn2gg4QgI1PO0V+UoI+XCGt9Qqv2dovWKLRzBOu10CjNu+MIoim83XlxYPj+8p1VLPAC/SPQefAoWeaTAwPnVNWOal8iji4+Gj40bqp2mLpBGuvgL+9DTFobFTbTTJfEHUN4v/6avOAkvfCMCEfN1AcPeV5+uqNjEZ+M5OfpCLpna+qWYrxH+4JVwdk0AhjaW/AFwWDVIwZx4ZBJopKpYKSQ+EmhPN9CaqmHiRRME3kNaYSIvOZgoxiKtqrnU499AFO64wGFPR7BHqlYzGt/b4pwUV6n7MoxL/vyemVPEnKDADNMDOJ9apprOxZVnnIWRH3B5hSPRjslolQz864sQGvLC64t4JxQK3xTVbUaGsZ8InUwMIiF9KzJBBCdkyLbdp6mEwKWPNo884XpJgwPCy0pHblIo5i/P+U6bBxTgu97oOZIEI6L65lNZV05f6ukai88LuvDwuNzDYAvNI3notvM5y7kzX0dBNzZyMa9KCT+BnpH6ZN2xYY2HC8RmhY9nxnRbrQM1vj73k92ImXINpkCZia93OigBFCZIhg22OioVfkmOR1D1TVxDVJWPktro440OuG4m6gXSKYOLKQ7FTbVzJYSoQilKlKqdBXAAT/ly5VMZvw1p70rSyjyw5RE6DeNWDjsCeEaMv7Ybl2ZSdOsvQWl1tTFM69I/+Lj0sezukjfNxjywffczJ8PbyaxMDwKxUrN47/5Ao5/y92SzjcMm3eD2iQjQXTqlvxsuiKbXPsCDA9qJkcrJhcloTM8yq4m2dRMVy3mhF+AU1kQtp5jaR0Y8cTOCm6YMj5e8rmPHyffVPTOSDe8fZmO3OSqKwvf5HCNmxlUqbDbGco4GCfUtUYlziNRDlILxjFdBbMjnHUAZkZEo36jS4ZzCCiCcCVTGB+QBLXJPkls0zWs3dRlureLU3DyyevJNmG6DwYPJThkczVTKHuy+FcdcKnFDlM6+0ZMxxlXfPM9/BxXxfdTiWF/9TGWv2GFDz94Df2TPuXPysKfP9Xjo+Zy1GcGjG7a5R59iMPdbX7t2Ed47/XPpXVPh1leMnpigeM7fxc2M3Sh+Ddf+7usmhapksv9oXLEJz50HX/vlkWWWhMeXtuLvWeBv/V1d/JNS3dxXdrh67sf4dFyyKoxgEw2Ls/X4mftPpnwytc8xucXDvPHlx9h4XHZXHrn/KIeinBv+bf/oxqnLy1kA+qmvReuqmSBd6rxX54tNqmRlWlG4aZyTSiSF7LZVJHtNjaGNpEidLaoYxEXeLMSwe7Hp37zaW3UVG3PT7VC3RHE3kV0uzVums/gEhNQcTvnRBHTNC1kQwu1d3jwRSkQm5bRUUvrnBZUsHToUj5HGAeH7xLoLLoUJxWgcTpQczZmvvALThNR2AiR65pOZCMPfObggDFPbZnniitPVYiWkh4xS3crvxEHCo2cd1MTv4fyI/dsR2wUwwYbjntAhIu+eFeHQh6kMI6j/XitKEEKa4fzQuBwXYSCTM4PnuYiKcJ1KlM5XbroLb3wuGggpiu+CCyEg14sikNVeJ0qrHWLmsGJip3LEuH0l76I8vS/2iPSNplLHPX/lkyAxBfHuqEZyAcHM1OooQSrqaopzJWT15ys+u/mVDOlQzj1QextM//6qUffUyJdJKzXIZU08Yml0RFJhclCk/ZpPHoag7e8N7/S4XgRk3mhOW/SWOhYKDrVNDxOi2uXU8pTKsJ9iJxPj843ybuBatNcN2GiFhr9cO2GsKgQJBau1f4pC05SQwG6px2di3VEa60v6pUVC0Ch7shrlYOE0nuaO9OsaUVPEkhDoT9b0Cx/TorkcEyCkN0UUhCnI+GuTxeN/54q6gnEHpDI866zJgnVeTFtQNtjA6NEUNkbWXaOykQ4HdOEltVgkFRXEIqpHJNw38u1MVuSY9leazRiARwJhXg2CU2J/37WMd6X0Nqy4tTlj1+gIYWJlzaKcV9TLCSybvk1MqwvYYoSCu5wP0V3LxdAH/HbT6bh+ggNp9APq5bkRYgI2JFtV9Rtg6ocdccwXYH+Sfm3qiWTj3o2d/E+gx5fCE56CKV9pj+e1UX6Vx+4j99iidGTCxy74TT/1xV/zMjmfO89b2Tr22/j6A98jEf/44tZuN9QWynMrSby08LfbSooifMJe+2TiXTGNz4Xe+8DbH37bWwfV3TOgjOa2ZJ06ckYRoegdVFTjXtcnPZhT43eTrC5o7Uhi/R3/ehv8/XdXQBu+PdvIdtUVIuICr5T45QW3mqlUKVCDxPMzC8EqaP23N9sU/yASR20KlylsJmmWqhkg1qtmI0Tsn5BVRjMqZaguUPhlpd9SVYt25ANoXPGbzofWGDzppJjx9bY+uODZCMYH3Tc+roH+fSfPpe6Jb+rjINCM31qwPHv/jjf/NBZdm2L/3r2eTx1fg+LCyNesv8JPvjb19BDCorhYe+0kQpSqe8dMLmyIH24z9e8/i84WywAUJ7qUn3nRYaP7MF1a/JOyeqBDYyy/OwTX8q/vDiQScNU839/5e+w7zM1v/R3fovXvPt7aJ/TzPZbvmnprkvGbF/3c99Htiub+795269xVXYeIU3CT/+Dd3BvscprF+9l62UdnvzItazdKLdTg7B6FNk7bNTtBkkfrypmS7D8gC/Ac8XOlWKFaaYNF9pM/MJdE5Grqi2CwTAmVzZYrzlBZ3JFOhTaShAdgxSmgW4hXGxNoJykIxmBig2gFHTBHzqK4bzjQyi0QxEQHCR0DXj6SUSww0JomsTQgDCGAmPlbsXwMFx8XkL3jKO1KUWC8cmPYTzrkuB9rMC70IQGQYJtPKrpebPQjK4voRoYOd51jm8MgN1QDNpLuKsBPQ3Fd9ltaAhOgfa8VOXH7rporO8CBSJwpadLWs7JXHJhoMGImAvSsfhmS2MrAWLpSCgHrY2a2aIRWlHgPHsUNRQOVUuOwWwpEbFhEah6/hoZOoaHdGx82uveGtQX1vm6FOi6EGvW1E8MnIGtq8QxZkgix8yL3qd7iEJ57YuexE8L21veUacntq6hAAouUlXfF9NGiu1QyOKLeJDnKuQ5dddiRlocaSoltBWaIttM5H7NdqWxaK0JiBIE0KEYaqYrDfIPjUXgvBNPEECLCFP7iPtm6jHPiw+UEecL5nzXRhelfNtKgbokrlnKgfa849mCFLzJlDl9iZzb2gdABSelQPuKgXTaNxKe3z06KBeQM7D4WOO5HQACiaJ3YJuBv/LXkFPC+56/71TtokhSCkbF9hVGUHL/AqG4jPeCN0eIqae+wTOFi9qXoq9i8F8yEXG9865KydQ1doIeWTcz4bOHyUFcW4InuiN6qqtKgteSqYte7CGQKx35a883mShJCa06/vqofEOnFN3z0txomomHLh1VW+O0pADrmUWnRqxwL6HvqSggT8deLN8W6lBIHnbeZWXnqDR0g6csDZXOgziV5DZIkyQJo7okggIhjKm1ZS8RrwMk4zq6iO39XEXZ0VLIe+etqv1MRNLVF4bu8oUQp/4veDwTz9AX7PGfH76V4U4Lpx0vWjnBc9Nd7hodxz3QZ+3lsqs/56cuMvOLvJnKJjBb8psNgsLU7WYBaG36COQOnHv5Io/99K1Ml+RGnaz6ha/lmK44qpbwI7Mt4UWmu9A9Yci2FCv3qpgyGAp0gOk+WRj12JDsGJK8wrQrXK1Itgy2U9O6ascLuBx2/wz6lXTpV4/JD43QOwnd+zNap9MGoctqsW/UjrrU2Knx8edEN5pqUEcv4yBaidy+MymnPn8gjowHTyo++ulrSXdhdONU/IxHBpdaBo8pzv/Rc3hocoCLZZ/rF8+yb3mHKxY2+LMT12BetkGxIDZddQvKQzN6125GH/DByohkDD9915fz6HAfbz//ArpPaTZHbdxCie6VLHSmnFlf4Kmze9gcdlhZGtLdNyI7NOJHH3k1F15o+Lqf+z5W7pW47se/4ZfoqpqpS7hjqrinmPLLb/1ZNq+zfPW338lXd8Zk1Fgsm3bMTfkuU5vywnwH6xTjfSZu9qJdUBS95vay84VjIqP11lpDjWht1izfD+mu85uRi37J0BTJzvjUT7+BVy3lnTuU57lLMRCKSGlwghhuDoXSyOZmGus+ucal0M+3rSBqfkNRrkGG5h+SPtuMfcPYfN51ocqb0aszip3L5psZx9otltley/hYxYWXVASHAvDXWSn8ylDgyXfWBGcD8USWfyu70iAUfRUdNoIo2mkY79UyGp/h/YmDTaQ/xqk43DjdoKLQCPMEofTn0tMWAnIdaABR6JoFdwdLnUqTVOUqOnoEt4jg9KJrQfzKjo6vLSFJiqKvmS0Z0nl3nrnmKVB8AlVGl9Kkib2gYrokjhVFX8SzVUsmZdNFOYa9s1b4ub5gDxqVqkPUlYS/zxblsycTWefCtDHxoWhV24eyIRSI8V4pxvIdWSsDLSaZ4i3rpEjqnkaK84kvlPKmSbKJJJ22zhnSoaea5JZqUBPE+DKhkOcXff97HiUPcfG6IDq5ONM0dOGYhsldEDurKkyAFLqwmKLxQQ/3ZkiRDQV61Zamum43zZquhEZTthvrQSl8iXSHOlMUvTmUFflsydgXvJ52MQ8CRDTayr3bXne01ok7+/blms1rNNuXa4YHFK1NS3tdvoebS+ZtqC7NtE5ZaVCCoDtOmqyjfeFS0GCebqbsnGbAI73xHvbrQp3Jz5OxIxu5+DlULYJtueca96iwFjiFF9uruLbZVMnEylPadN0cX5k0yrWZjINzSwOCBDprSHMNjU/IOwlrtoSNeQ1RDB/yQEzXxEZEABVZw4NV6rx2p85UpK+Got8miu5Zx8KTNjaHsRErpIku+ipeI6aQ/y/6mvGqiZQ7CbvzYUV+HXKKOJ1RlSMbWqG/hSmi/RsCJz+LH89qJP2br/oM71l/ERs7KR9bu5w/eN/tVPtKvv31d/DkeA93/uRtHP+ej1N290FXxqPpUDh9wb6tagtXXRc+CMMjILqSgmvvZ8RyqvYeshJ0JGhpe83hUsXokKO1rij7MHhCCgGbyoK9cyzlZfe9no9c/24A8g0v4OvU1D3H4K4u1sDkoPAyk82E0axH2oZ6X4Fez7Adi+3XMEvQT3Torgkdpbp6jDES51RstFDdiqxdUoxT9NhInHYtRWy+CZPENlxOvwCYmWxSnRdsUnx0GfBNTCH83fr2HdQkRc0UutJwfIp7zS6rX/MQtz76GH095adu+1I2f6HD9rjFG674HL/5idtYPCcIYt1WrL47oegv8R9/6Gd5vNjHf/qur6MYWMw04+FHruQhfSXdbcfKwg5PT1YwiWV9u8tCf8Ign2K05ez2gOmJPm654LKVDTYO9si2craPK8qDBVf91pvJ14U7f/MrH+TCpMfm7xxhKYE/+fxLefdXPo/Pv/i3OFHt8qnZQb6kdZaXtk+zpHu0TSmIV0u4zmGBTWZSlEWudEiXdMLVTEciMhVqSFN4R0cJJ8WbCii1Uj7tE79ZKrKRFY/sFGZ9iYUP9o0BqQ2Lu9PE1L8gdqt9MSAbmYvFaqSQVPKnbF6N/Zwz3lkkFAxhv/eIWb4TYS7ZmH3hbp14ZQdONQqO/Kn83vr1iWyM1PF4lD0pABoxmB+Lz3E1pcGQqcDwiCIZAhoqH/VedYT2oSeO1FMdXAKmUL7YdJdsxiZ8HyVTkGA/2US5N8c2fOeYbipgs+eX2mg1CY0NpDNQeOpPEP2JiE0KevFCDumz4pfe2hR6gQjQwOYi/NKuOS/hmFVtoSYk27VwXytBJ+sWTJelaBw8XVP2xDoOYOeIjoWdqkEZMFNF3XKYiTRBZiLTxGQkRU1rIzQlRPeTAFbMlh35esM9r3KPrvrjpmvhggd7utlCKI7lNZJZU0CHSWVoHHQBqlDBdj86KSknzS/x+hWKXgh1QgmFp24B1r++L8ryNZkepSNQ/rzNOwsFfnawGoznzTZZAMFBRBdS0IVH/M7V3GeDOKEI9qv5jrvEscbRFITJRNbd4KTS6DTwzktyzLSnmsyWlIBIXucSUq5DImU6EocSm2iqrtitEig0RkHd2EyKaLWxLpRrLBSOqrm/SxcpMFEk7mSKksyIEwI9c+D3yEjn8+h7Gtxucj8d8vahQqdSvoEOa6qKzkpOy77TuijhVNLY+ObJu1J51h5mJue5ass1YGmmNqEplMkiMb8h3JO6hGy78o2DkfvbmyzYREVxsfbHKjRT4rnv6Xx+TbUJTJc1rU0nx0yHNUXFiZ+ycnxiEBPNcZysqLhGKOsY7k9ErFv4tdaL+SXITGF8AFjILLCpivqIZ9LDX25fkPf5m/B4Vhfpv/HALXzVjU/wJ/ffzOYHDrD6ynOcvX+VO9eO8+rVB/n0FUcAuOLtH+fpf3u754IL4q29WCYZiwOKU+J4kg4VrXXxhb1wizigLH4uoXtGNrF6zhd97RZLsiuJocPjEsk9PKQwM1lkpntlER9++gA3/dFbKHuCPtUtyM8lcbSLEyR+dFklPy+kUjAXMjg0RW1kkIIaGcqVCjMVYZZSjqow2EpDrXBbGcVmJg4wxomQ0TmKJVmAeg9klF1RxIeHLh3jfYrpA0sseGQ4en6PFJNhTnI2R9VQHihgmrA9Ttn9zRfwPZ+4CTszLP3nXd502V18eusYdz3fcPyDZ3lidghdKOqWJftoxemvc/ydP3wbzjhe8YP38dEPPI/L/tuQU1/WY3LVjPrGkumfHiJvw+LtFyitpqo1Z7YWmG3nmFbF4PgWo3HOo3cfpXvej4dzR9YtWDmwyf7uLovZmI/+6fPIdiDzxYUpIPnQApNbZmRKcXV6gbXa0FI1+w38+0N3cMNzb5TRe9kcm4Zv7D3FbViIQ+y0eOMG4VVAQR0Nkht9k32RaH1xHBbt6ZIm37KoSop9m0hhq8uG+iEIU8PvDKjcbCAbqpxHoqdwMnXeRUC+x2RJU7fFejF4fDsFzMAEJCYIz5wgxgElDwgPOFQpKqbgkx4cD8J4NtvxyNic+E6EVBZdys/yrRqbKcZ7TdyMwnuFVXd82NE+pyh74uVsZn603lb0T5WMV1PqVBBmZUUcFs+Var6L86tjfA8XCq4GRZWJhKcTzDn2AJHHXntkVRWOEHTSPj/D5oaqrcl2Ku+2ANM9CcnYxmOQTF202rSpwRWKyvvLV7luaBmxmCQWOXWexEas6hD5+IOna2YLMlGoc2JIUDr0hXNIx/SFR0iCrTp+cuIbvdlCE9bjEimWy778e/AoT0eCttdtUEVTMM+WpGBOJoJ6G++iERqFou+LWl+A1S3n6QOOfKrIt8TRo1yssS1Pw/DNZNBcoPx38ainnjVNKybQt4QaU+dyrnTtsHlTJYfGNgiBo2DUNMWpIMCBouCvn8ZpT9BfL3IMlK/wCNdIa9NGIXgo7gInuWwLOpsNiX73Idk1NkEt5cX/yvOR5Vzmw2ZyEXjk2a6lagsnXBcuotuhKBf0VT7v2o0JnRevM/7kCvvurqI7S7ByrdrSPIuGQP0Vp5hAmwF5/5AREZpJCVLCN8RyHVfB890X46MDmvZaWAsbp5uA8DsvDE2HEhRXBxcsf2/MFpvjLTodWS+SsewBonsIAT9NE5lM8VxzAQDKtqLco3BHskiJifdc0Vx3gWoVvrMuXfRAV6goiA3WoqNDinTo7/eRP6ferUjCoeT6DDQVZR3Zrp/OdOQ7lCHIyX+e0LiVXe2pXs16nkzDhekuuU6/+HhmPp7VRXrySIf7ju3nda/8FJM64wMPX8sVN57i9OYiv/anX8E//rvv5qd+8PUc/cGPUeytUFNN66TCTISHGUanyVhez8wU3fOO9esVu5fD4gOajee72PmOjjjaFxSzZUGmdSkczOnxgux0FlXlZU8QoHLBCn1jM2PnOFKMr6tIvQniNoVHqQrFe779xzlZ9fkH7/5OnHGosy1U6nA1PmJb3q/zcIZ6sCuWktpRLdZkFw3lwRnspLQuiFXTdF+Nyy3pjtzhoyMW0GS7MF6F7tlGCDnZB+mu8PjKroi58m6BmuTicHAhI7lyl2KakKQ1WjsmkwRrFb/7xE3cuO8Mn33HLfzQ4T/kx3a+gsnTfdrnNE/8HU3+ZCqNyx644xPX87JX3seZf7mDuf12kvMZaprTWndUHcW584uwm0C3EnFsv6CeJmy7DulTLehbxgcdyVCTX1Sw0WNL9dhSq3I+lZzX0UERytYZoOGWn/kuzEzGpde88nF+6fI/AKCtch77pl/kuf/xLUwX55D0EGttQmMmE5JQBE+XJAAoHTov7GtcSULBaQp5noxJfWy13ySFYy6BHJ01sSCcLfkCq5L3U6UUbNlu8Peed2VpkgmdmhO9KV9YllK0bF3rWL3LRVcSCBtZsFSTzxqL8tkcMm1t49qQGUarhv7pCkfD63ZaUXU0yw8UjA6mUSwVRtliESj30Hif13t4UauMxy11pikGYveW7Xi/ckJxJcdW147R/rSxBSyb143UGd3Qdayn0czzaq0/l2FyMN5n2L7SsfCYonNBJgCqliJbe0goNBhVq7k2yoVUhLE17FyWe5s1Fwti44NIbKqoW5qirym7inxbrPN0YTETFxuKsmdigzz/kGPl0FWwrISdowYzleIlCvAq7+A09mg0TaEVaCcS7OKPXT1nnbhPrPZ0Ae3zNGI3Hew58baNzedqX5DXCzkKybQppmIw0SXNjsCTrTUV0XR6iAf6jqJarLEZZFtGhKqmoa6kQ28H6e0YA9qvPce77Ml3sQm0thqnHFNI1Lxc76rxRvfNZbjuN69KmOyX8wyw924fIhN0KbmkCls/8TIzn7hZQfecvP7OEc2CT2cNhZMuHbVRZEO5nmwqa4+qYbKqKBcs6bYm25SPEig/SeKnn9vyXcOkwaZw8fmKAx9TjVg1OKR4IEEmbo21XzqEnfuXaU38idMBwsdT4OQ+MXMFYu31D8GvPjQTZuYwfp0pO1ompbm3SSyE512nDbgRLEK7Z23kb9u5olJZ6Zxrn/5pvUBX1zKNrlqNfWaY8jgDettfn4bonBP96Wsw/rqTIloJ3WzgP09NpLleYpPom0+bwGRZGqZAq4LQgFw61UlH8prZtgB9rXVfoBvQY7l3ygFU3mLUFI6dI5rBSRtdwfIdF6/XCBJ4WpApZF2UEwBlR5PvyIh256hGOUV+kmfkw34B7BG/iKT/DXi8+Y3v5WxykJV0l73JLu/fvYHb9zzJfdlB7j7a4Uc+/NXoqyY89tO3ctV3foIT/1pCjrJNv2HnUPgbP98SEdbOMUU5qBk8KgEweqZZuX/G7tGMbMsjVx3HTCl6T2p2rqlJ2yXOZKRjmC7DdNWipwo9U9STBJtaoTZsakHTxzC6vKL3eMJsxdG6KDy1f/Kl78c6uCzZ4djzTvP0vYewKyV6K0GPG4GoWU+ZXj/BWYUbptCuMZsp5bJUbIKkQ7HgcJlD5zWz/QpI0IVifMjybV/+Z/zOz3wFw8OiiF98RFH0YHjMMfySKct/2iYZKmanu3SmPgRlDNNhRn9xws6FHmiHymrGDy7RvnaLOx+6ir9761/Q0TO+4thDVEcMD72w4JF33CLHPBGq0GwZ7vjctVzbuY/rv+FB7nnvc8g3INiDmaymc2SMdYqyMhhtGU8SOve1aL3sIoutCdYpWknFqa1FXnfZ/Xzw9NVYFOtrfdJ2hclL8jsW2b3cku5qFm9a48JTyyzeZ+jcss7JnUVu/cA/YeEeEZJu31TQwhcGvvgM4/noL+w3EqWFrmCmDhXCR9SlRQx+8Q9+wCIUbQqDZCyFsC5loRYEV9AkmwmSo7I5e0cNqS84Jssmeug6DXi0u+yqaHcGDXp/8E7xNK7zprANxWSkeXgEuvRIXQwZ8ZSBWJz2/NcLIjuPQmY7NWXPyOYybZIC5/mxdaY8FcwXr57TXWcmIom6hjIXNCukRgoCC9ZbJYZH5LyG410DTkbxqgaNbzq8fVssWrOGwpSMhdZRtWis3lxjjRfsEkWsKIVAlctn7p0ucEqRjrX3rBa7RWOa5NhQPKja0TnvRYC+KJcCtKYOAS/+O8zzrEPBaw30z1rPx3fsHpZGe7riOeD+OULngekeJ9aLOyoW5lFEa32h68fzyVgx3VuTjDTFgvxcVUq0OSmYsaCXRZ9IB3CJFCY2BaVgNpBiOttxjFcVyiOsVbuZPgZ/7OAK07oI2ZZMBW1LCy0ndWirGscV1+gylC/KjV+Pan+cdOnpeYVMB4q+8feB/3ePyoYmVjlQE/ke02XN4uMV5UCaRwltkueFELLEOrLtmmLBeBqUQ/tJSaDN9E/bODELVIggrnbeM90UsPCETIV2r61Y+XQqxae3zM12/eUdi2gPCoxh4wa5kQ5+hEjHCAUmwCUpucrnB3Q0gxOWxSccu4cMZU+LwNU3VfMhTkLNCFSLcOzl/fX8vW4bS1ZTyncZ79HRsSROPXyQWXCjMTMp6OcFwOLD3zQNuiKe95CTAPL8YoDn7cvrl/7fdSXXc2hWG3QeKiW+61VbxWsuULvMNLwP0Wlotkj8fOG5yciv4R4RD81BMm7uKWeb60/Saf367ZoGtuzI9dA76ymUXoMT9hjw4tqpTyvtCPrvtJoLufKTmY6if0qEuDP9N6VUffY+ntVF+v3Dg1y7d4dfeu+r+Kav+Au+9sWf4b6dg3SSguDpy7kW6RHJOJ4dLUjPZpQDz31rN0Io2QwU48M1+/9Ckr8my5p0G576qozuycY2zA4qklHK7nFLsmNIT3Wps8bKcXLYka5LvPFMa46+r6TsGcarMH7VLsUTPdJNQ9kTa8LJfinqf+WxW7niugt8z7u+DXd0Qr1QoY2l7ljy8wn1HlmJ0mNDinEKmxm0LMw0NrVQeoHJ/gnTVo5LJR7djVL0WFMsWdItTbateMd/+wrclY58y1tdIQXb4kOK9ZWE8T7vy9yWuOe6JShYdiJnvJahM4dbKDl0YJPTw73srHVJNxLuXDvO5YfXOJRv0tEF7/vdL4cdodwkQzlv6Y4Sp5ejh7jnbB6FaxHFPdNipFoe/VPUCjoFLH7ZORbzCfc/eYg3Pv+zjOuU16/ew6PT/dy49wwH8m22Vjt84vwxrl2+wJ0vaJN1SpxVXLN0gQtPLbP7kgnXD7a498nDHD68jj7iePqpvSQXUopF0RaEIimZEbnhdSa86rCJOI/+QFPUh8dfDg3BCZWl6KkYhDL/2tMloUqEUB3xwG02UNENNO8RPJRBOJZ1TuSXBwRSV942dCJIfjZsuJ/g0af5YJzo9BJQaymOTeDn+qIxCYicL+rDvyn/HVubPlETokAvcMKN5wOHDTVY0k2XNVUbcu87LaEpxHjtUGTOc0TD57GeK6rmkMB5JFeQKSJtKBRtetogsoOn5TOE49JMCIRO4DLd0Bx8EZVMHLuHMzrnpaJJRzXpyHi0vpmoBC50cLUInzGZ2oigz7/n/PWjLLTWS6qeIZloEc12QBfyxCpvbBLTIQyPeNFoIc1wKDhCsSpf0COSCdGvfLYiIEJrTcXvV+cwW5R7XuER3Zb/t5ZMqJRqjnWgAEatxBx6X/uU0vnCxhpIvcC0GAjdT7QWKp475fzn9Mel6jQTyOB6Y3yKZtAYpUNxyQhC0BhcpVTMj6hTFXnSppD7ZOFxJ57wFQwPGk/VkkJUF2IpGOwG52099cxS9ox8Fh9KFQpOpyDbtfFn1ntq6wr2fTSJPP7Apw7iaRTUHbnJnPbN0USTbYMphFo1a/um3yfXBpFsDAFToVmXpnNwsvK2lZZiYNh8LrTXiccJmOOKN98vGbumEUCOeQjxkaTRkL0h+qdgUYkiUmcCAh5F717snu26SP0BmK6o2GiGY1YMpIgPYujwb8o293qYkAmNK9ib+mbAqPhc55cshUydtEe4HXK8o3DZI+uR1hTW9jgd9OsxDbUmWISKlkv+rDr4hly8/413ZNGmuR9VTbS1dFpR9ho6VZjcBSAlGTvKnqK1YSPdiIDsP4MezvGFcV75G+Lu8qwu0vdkI1bTbRaeu8HHLl7O6w7cxx997vnorRS1Z8a/eNF7Wav63LV5OQ/84O1c9Xc/xhM/fhv5umJ4TBC0QIdwGiZ7ofekIZkK53PjpprOSUN6RpFOpAbe/2Mfi+9/8z2Oz2wcQSvHw08dQBnLrdc8widOXcbht9wHwPJHV1h42YTPrB1m87Flrnzj51n/jtvZuLVEDQ3pwTH66S5mqhg9vMj33vdtkDjM423qfRV2atBTH3N+LqdaqjDaohMf4jI02OUS1bboCzlMDOZCB5U53JFCbphaoRYtyeMd0l1ZPPItGF8/oyxb8fskU1m09vxFSvdsyWh/AirxYR6ywaS7CHI7U7hRzrmLq9C25OdSGceOuvzo/V/BP3nOh/mRj78WtMOMDGVfUgJlsYYvfdH9nHpoyOT8i8lWZJHLTzguvkA2bqWFfmRTQTOufvXjvHTlUf74zA0sfDbjz+94MeP9ij/nZr7xWz7Mh89cyZ2TK8iSmnZW8ukzR0jO5jibU+4v+PzFA6QrU4rtnJM7i6StiiO9LbpJwQm9l7pvaZ01kVc4W5SRtilUFBiCt0MMRZXfSKZLomEIKKlYGRIX9xD9Lvxk2TzD7yZTceWo2tIshXHwfJFRRsN+5UVEQaTo4njd4Tf80kX3AWuE324KLkHPA8IeiteA+pmZ0G9G+zRlHzrnoOuL0OA4MjjR+E5PF8XCzBR2roBuCr3WxYq6pZktmshVjeh8S6FnTjjqPoBIrNsa1wlJGG2Of1iTi4EIwAP1Jz48yhUmCdBY1qlSNeK/mhiyIt9Njuf6DZr2BfE2D0JClItc/YAUip5FGpjZkjhD6JaOFANrVHRpsK1QAbn4e+JY4bz/emgenD933uXCUwOKhaSh9CRCs6u6cn111hyTPV7AtiKFQNkH18eHMjXosyDEvpD2FIpwz7fPSfhR1fYFV2hSDBRLTYEd0MggYqw7oEIT4BvA8QFB0QNla7zHU2WsuGZN9hKDjooB0bmjrsH4IqnseZG+DynCgm016GaYbikrzXKwOLSZUMiA6AwEvvj0VKjQTNZIgqMEPVnMxNK6qCh7hnQi/PJIU2upiK7GJEjfFFYdHbUP864fwQ0qoKTSrF6qhwg+37p0sUFvXIPmGk6gd0LW7aIn4vIYLqak6XAKVNK8vwv3jUeXa29BiRMkd/k+KfCjtmTmIHG+abhUdDovhg2TAym4ZX0ue3K95ptyrkLDVHR1Q7Fz4LR3kaokKC9OKQ2R5x6u9XDMioFcH4FC4rSfQnqKiyDLHiSYEm0jG7cbIqW1asm/VS25T5JxACs84l0TndCCa1F4fmgQ6lxyR7pnGhtSoevMoeJ+/TPTsO4H7Zkcs0CdCyJ2UziyLbFunC0lcboQ9CPhug9TCWcUs0HoXP9mFKrP5sezuki3TrFbt/imyz7Dbz35Qjq6gLFYIP7T17yPn7jvVXTe32e8ClVfVsbj7xpx8pU9kqH3s87lJigWBV0fHoGLNxim+2u6TxkpTEew8ksf47GfvpXL7+rwyPZedoucD//ECoPf+DjFK18Ifxu697Y49a1DDnMfxz/V4mNnLufRewYkuwabOrKh4sS/vp3ZkYKr/t6nWXvr7ezsMahDE8pK43ZS3EwLun5EPCJNq8KspV6M4iC3VLWhnhmSqSZfh9EeR9quKPYo9HpG1XOyse2k7Du6ycWNHs4qqq7wLo1f9FxhKA8WbHRSBo8KirR1rSPdUZSdlO3rZbXLViaoB3peDCSLU9hAnYL2WTlOxUrN/v4uJzaW+Ll3vB59xJEcHjErxG5ytseRjBRlz/Hgf7ie4js1yTYEm7KdY4ruCY+8ee6pzWDxpec5szvgXH+RKxcu8on8ENMVvwk7+ND5q3nenjNc3T3PXZuXc2Hc4+jyJo8czFAXc665/CzndvtU59qohZLhJKc63+Zju1fSXR5DIbPcgPRZPwKNQp2JH8/mcPEmR7apaW3IojxblAU90hqsbIKm9AhzDeBQSpAvXcpIvr1uYxy3rhx64pgumSjUCqiack5CfRwR7a46nu+aN3Zu1si4NNBrrIHZovaIkLuEihM2sI3naJ9EaWNxmW9Zsl1f5KdQ54LgzpY8EuqLIUH+JfwpcEmDaFA8kiWyHI8mmollupLEtM/2urjazJakMcp2HHVLkL6t4yZGz88LXbWF9npNMWiWPWsgqZo0Q+qmyAwWaYGS06DJcxHlEEf4QaMintqglMKmXsRdOHTdJCtK8RV44i5SU8JxY0ZjkUeDkAqVwsXzED6DCe4SRUN70ahLUMfZoqJYkKIo3/TNjJ/mFIueV16DCiFD/pyEICmXSLEQNDHxGKYB0ZPfcUoKC9ut0WVCOajJtkwsgJIRDI9JQa+9UYaqYHhU7u9qIAV57e8hM5N7eub1AOA5wX7yo7IG3Yx0hgHCCTdIEul8QJI/dso1x7zsO1wixaguGqrUPNgWvmdSgjIiPBaBnqIeGGwW7D+NhGV1VdQrSYEdEHwBTVpbtSRv1uF+ddGtSJq6ufTYYDNoXbQdDc1Y3VIxNCigvjYBTGjg5Di0NlxEz4G4VihLbJIC7SnQ1AJ1J5l57rc/9vk20phPGx92ObD4Jjw03C4W95IpIpOJc7eI8Dvf8PdmJWLi0RHL4HEd6R517hOAPQ0lTOfCtC/oXYLDivPBTso6kpkj25V/Ew2Y0D5mizKZqtOmadMeiMiG3sawdtS5jk1Q1VIYpURk7c9j8PO3mTSS4V6ct/SsPbAwXfLfp+UbyFaTdKtnUvSPDjo65+RY1i1pmpMZ7F7u2HeXd/kqZWoVNCxVRzNdMqRjF1NXg5g/uoQpcJUg8HXWNIMQ0kqfeY8vhE/6F4L3/r/i8awu0k9MlxlUirWiz9uuuoOf+M2v401v/Agfu3g5P/OrrycLnbUfUW6852qWX/c5lo7cyu5R4YeHsV62Jc+RkSJk24bJKhx934Sqm7D4F3swf6H58JNXUW600GNNb49i51/ezvhoRW9pxPAKw9M/dDu6gov/GVQKPS8e6Z1UUTFuHsukWN9Xc9W33M3p//P2iCg44zdQD3zYSpOPYbrXys+Mpdho0T6RMN1nmexX6IsZs75BtyrYPyXNK6rSoC60OH9qSZD4WjaFyZESs52AcfTvS5mtQHG4QLmMZOI49OGaMy815Duw76OGOlcMD/dQtSw8yjZ/OgX5poqetXqieeTkKq1uwcprT6PGHYa7LbKLCbqQhXbnqpqr3vZJHnvnTWSPt6g7loXPa3Yul+OeTrzwLYPeScfsa7bZ+OQq7QvwAbOX9kVHsug38r5svDvvOsRT3+C4srOGdYorBut87revQ10m6P1Djx2UBNdcVrxirY1aKmi3S/b0Rxzaf4Z+MuPOU8+PtJKYUOvPSxAB0amxQ6EddM+IMCugOjYDXfokOG9BpmrheVrTFFRx06olPjyZWSn0DNJcGbkmUT6G22+wmacL9U5LCqnwFAUB7Z+ycROzPmAj35K5aXCziCKpGpx1dM7B+otLqnbKwhOSbNn2KYZhkzZTS+9MzeCkFI+7RxKyoRSKNoXxHkN7o47XAxCR70h3yaUhdhqy9Zq6paMQTJdgnKD/upLCYvEJGxHm0lOElPMb2MTSP1kzXdSxCAkbvXxZv3h79FvXcw2O8TfV3Mg8FATTZTkv7YtzYSQ+wCl8F1U7KQa8c0PwH4/j/ZlQi8JUIKCOug7Fh1wD0c1GeWR35mJ4FFb81iVsBdH5WbFeVF7sGQSgRV9FNNrmLgIPzjS0pFDsxXTPMfE606UU0+ODUkSbqV8rHUz2Q7ruRb6Fjg4VpXeSUZWnn+iG/pLPieLHxyrys8IlCDqGqk28/uvcC+4WfRMc9QdNExgQ6hBkY/0UTnQYNPx9wC6VknZaCDoeXHz+8j4uyY4qvp9cg00QULg/wqQpnFfhYTeUhUBrMpX1UwgdRdQhdVh5Klh0e5m5JhgtU9i+biz3vGNSY9fnk57bKoIFVVuxc8QIiODPVbBjDddgMpGCtXOxBm+BqCpp6IO+ouzgJ1FQt8StSVJdm2mgUD4arjquOdYAgyelSK26IiLWlQ8zShzFQM6t9hOVMDnBiSDUJf77m3CPEf3mBXlvOOz5lovCULkYZOolxb7/MFO5ntEevPBe5NYojHORNlcMpBkObi4Boa5znxXgoEqhGngamW6osOnYN3kjIt0quvN4ClP/aRX3i+hspKDr936bNHRHM3OYmezp2Y4jaEmqtibYh8Zr3YG2Xsvjm/boQjab4yJ98fGMfDyri/TbFx7jZz7/OgaDCR+464X0Tjve83MvE3SzFArCdFnROefINxTDy3Oqf3w7+37mY1z8veehHuzRPiebR9mb2wCQP/d9xlIsZYy+Y4uzH74arcA+1YHFGl0qxgcc1UAEfJOn+9Cy3hPYMV21ZJvCVeyebkZyofjonobWmuHx33wBx7/lY5z5/ttlrKdg9MIJBqjHKUnbMjlekPdnVKUhedhTVrrQPqv9SNrRWp5QPdXDpo5Z36CGCbYtnPR5GbTZSaSQMbB7haX3lEZVGZN9sNMDVSXUXUlGrLMGvQp85HIghW/VFeeRSimqrogzVS1NxWQ35+nTPXlv5UQ0morQ7Kq3fZKn/+3tZE9AuWhxg4rpUiZoZluOU9VzLFy/Tv+lU9508F5+r30zSjkufPIAsyXFv/jbv8u/u+8rmZ7vkmwbNq63bJ1f4f+5cDtKWxb6E4qX71BvtHFjg+lIWJRTGr2V0D6jmT6/4MYDZ7jvwn5WWmM2Zh30jIje6UoW7VhIFtA5D52zsmMGXmLteb1is6fiZmUNaK0ouyEQRza7sqMiyiYFnGyMtqViJHRr00aOdPD0Dsm4guoCzuG8RiLfFrFmQKGAGLohMds2FqoBdde1oNJqqpnttWxpTee8bJoNnUCKfvm+zSapakdrQ66JpfuH7B7vRp51QMpCQFO2a+mcnaAqSzJKqTqyZOnKRU58EEOaqXAzgej6oqxMJYLzwfBQSjZ0sSlKpvLZQqhRRJCdp+jUzbhdfJbDeWrQ2CYGPDTKqpk8+NdyWiYETgG1t4gLyKJvqHaPGPZ+dszOFe2mEQiUC0UsylVEyprPFdcGLZ8tGzZcZtEWCHqX7cjrdi5YZgsiBi6WPLLqpw5h/YpcXE97cIZguBKLomIgSGDiR/c2lXugOFSgt1JaF5Tn/Hskeda4WVRdaQza5wXprzPJipgui8WseF7Lc1FQty16pgiVc+Azo7wjhz+OuoDJ4Zr8vIlFfyx8/DmJ4UABQd5NcIk0c7oUb+/w/aFpVMsu5FuWoq+ba885XKYa61BHBB6yofU0MJn4RH1FCWYmgULBXYcEb4ko58qU3ltfIRQPDdRO+kQrzfxsUVPlitbEoWZeDG5FQKuQ4jAE5lQdRXutjjS3+QZk/ryPVg1VW2g6dSrosaqEqiOTLSn44xQwk4mBKWUdmeeiO5p7KvD0ZToijlbDwz4PoSvHYfCIaCziFLImNgXGC0bHq5psW+hfya6l6KumufZNTQhYCo279oFr4f+d77eFGI5M8ZxQQqoOdC7g3ZLEwSnfcnTPOQZPTlh7fgcXPNZTmQYooHXRsfjwmHO3dvFB2HHiFIXmk6aZVHN0uWybxtXK329BQxGv2TmO+2xBY0odm4o69xqJqQU/5XMKX8jLMZ4NNL2zFVVbXMXmg5WeaY8vhE/63xR7F/3//Sn/84+v+Zqv4ejRo7RaLQ4cOMCb3vQmzpw58z/8HaXUf/e/H//xH4/POXfuHG9605vYv38/3W6Xm266iXe9613/P3++d/7k61j+YIvkD5dorwmHWBZWz4fcKwv25qsmbF5fU57qcu03Pox7yfM59rc+h7pul9miFOjFYkNxCGOmzu9/giv+2YOMPrNCvi4o1NH3Fxz7w4YL6xILrRqbO/qPJILETxV6qikWa6pBze4VjnIBJquOug2jKyrKrn+v0vCKz084+KMfY7pXnD6cU/T6U1Rew5kWaaekrjTpgx3SIexeW/qiyCNGmWN2vkOdO1xu0VlNsjpBZTW6X2BWJ7Bvits/xXZr6n4l9oaZ9QuyoNwHPmrpnYJkxwgasivHsnsa+k/L9627lvLgDJs46oWacqHGTGVTEXusFIZSiDntaJ3XTPa7iM6+5dHHhLfYciQ7mux0hksbzms6gvrAjMsWNgH4w9PP599d9Yesdoa84Mse5uvfcCe/fvo2Oq0CfFBTtqlR2rFveYdqrc36qUVmEwl0cgslSVqzsDSGVk22LgjlwmDMqeECWjk2p22K2gjyMV8MIGJGZ2D3GGwflw1q47aC7WuE5pHMgoOIFF9hcQ2j9uCVHhqedCSbk4x4BfUWZ5MgNJQxvKB2zTkG7yqSi4C1zlW0bJsXW4XNJBSusbD0PsLRqsy7txz6sGL/R6F9kciNFkGri7zbsHFKKI8k3pmZY7RfsX2tTFm6JycMDyRxqiCNhSCHwyMdNq/rs3tZi+meRIocjwA5jwpVuaLwnvN17r2s5zi2yUSoPL0zJdlO1YjSDD4pVDa0QA8wXvRnphaci4mpUTnmXCyWAQYnLJ0LNqb+GS/qTSaSGixUJRcpCdYob8dpo4tPtuOY7MtJRyEVdu5YOyka9MySjK23uXSxGQr8+mRq4++E81DnDYIeEPHhAR2LgGSk6JzSkSMbBXVK1raQvBhQP1X79FHtm1Av9Kw6gBWfehyYiYqixuERmVyND1m2rnVMD3koz19vw0OK4REROVZ9uWeqLoyO1pR7KtIhYpm6pWitSVqvmdIE7PiCa7bomBypQDuKJQlfsz78K4AF8xz98Hv5hobQTKSBOy78cVM40pH1gtKAQCtmS4rpsmJ4UDPZo8UZZiA/s6mic95GfnYQp4bJSJULfz3qC7wNYRA2m1LOYThfznPRXeJDfrzmJN+yZEPhwBcDLb7YCRGVl3XUN/Tep7+512XNSEY1ZmpJxjU4mQbpUvQz+Y6ld9rSWbNyTIaiacmGjsEJS++sZeFJS/e8lZRinyJa54rJHs1ov2Z0QDM8ILS36ZL2aZeKyYroD2aLAlbMlsXGd7rXBw3ppmAte4rZghYbwS0vIPeNsCkaqld4BOpgmApGHr+/VsJkIpk0/xaOdXvNUXQbjn/3nBVnnUeHmJ0J++7a5eCf73LoQyMOf3hGuuunNDPH+EBL9r0dL472QE1I471EM+D+X/b+PNzy66zvRD9rrd+wxzOfmktVpdJoSRbyJFmxjW0mAzFg5imkE4LB6dAJadKBXJrhPknoDqRD0iaQgCEmhtiMNm2bwcY2HmRbkidZsmappJqHM+/pN611/3jXWr9dEDpN38ZXXHs/Tz1V59Q5e/gNa73v9/0Ocp6btP1edG0phe6iGrmnwnooxgBWhPwKpmua0SEdU12DlWyg3NVdTd1VfjoglMhgZBAAhC8+ntuPv1Ik/VWvehX/7J/9Mw4ePMjZs2f54R/+Yb75m7+Ze+655y/8nfPnz1/19R/8wR/wvd/7vXzTN31T/N7f+lt/i52dHX7/93+ftbU1fuM3foNv+7Zv4/777+eOO+74v/z+gkNFQFX6F4VHGDafdASbL6oxp7us3rLBqw49wYcvXMvR/+UM2y+DutYkvuN3iaNcVDFBb/+/vYeXfLrhLfffyNKGeIrrGsoFGamqGlwGemIw05Sma9m7RcSggjookrGmWqlxlSLbEkRqesBhhhWjO2rMuQ44eGKyDoyEjrKmyB/rsHskgUpRL9V0jMVoS7oJ219SoQrN9ECD3TCej6dohhZysYOsRhnNRJHsGEwhqHczqEkGFXQa1DhB90r05VSsrZxs0DYxTA7IxtK7oDyiIYto3ZN/ZxuGchV0rXBW4xKHzWXDyTY11aLYVspCpXwCJX7TgE+MT1AtWvINTd33m3lPCoLBGdh8fsPifR0eevJ6shdsobXjhx/+ZvamHYbdGZemfZ757GF5TisoYjOsSU53OT9NMGszTGJRylHkKco4kqShn5XsqB7f/i0fYKfu8unNw3z1gc/xq4/eRWUNxxc2uezH243nywLsHfVpghviPa4srHw88+NLgf7yXSkgy3Ut9BdaGzDnkLvUo0BiTeci1BCK0bqj2D0hQVq9Sy1VpOp4frsv/BPPlQ3cXqdh97gie8jTKpKACocxsaB24WcdglpGJwcvZupdauPqg4Wc03NiKAXTvokprCFRz/i/R8e7rbtCcMTJFcWi7Jyh8bEJlAuGdCTFajmU+0UcEmQK0dlqvFdzu/HK68J0LSHflYIj8IkDLcmmOm7i4ZiaUq7jUBSFoi7YyeFsFK7GdcUoai8gE0RaRK/JTI6X9j7e2Z5UGbqQhMvpekoybX30FcHPvrXiU37NQim2bjCsPNrQZDpebzHgqAHlnDh5LLYWcnJ+WvQ9irk9HcF6dLDpeucTf2yC84TxvPtA19GVfF3sE9pC3YEmd6TnMzob8nxN7t2w+tC9LNf43rE0rruTgz5IacHRP6ME8JhKgc6gRmnH9IBGFwq1qyhW5fjlW8HLukUl05FC2YR6vYoTu3TXO9UUbWEeKIyBdjA5VjN4PEE1vjsJzSuyP8h0SwqdyZqJwtkwWgjNivVFuK7EPrDxYkPVCA1ickhSo4W+pelfakTIt6i9TV9I9mwLrnJRrnenFZdeYOidh96lJu5d01U/KenD4Ezj309IB5Z1DvwxqOWaAI/2O4Wy2jfqOq4p4W9VtRQbuVcUnc3WPz4I4JtMxWtQeyvG5IqLhWfQ10QkWzuysbz3MJ3Lt+U9lQsw22cxhWZ0XByCkqkc66Yrlp9B1B5C4EJ6c5j4ONUGbYUGU3lww1QOKu/nnrQTRgGunA830xIKV3r++EAxe8lQXmvSOtoMzlTyHhxsPk9TLjf0PA7Zu9CK8COlswzrp7xmk8r5CcLU+cI5OPc03TC5UjTa4ZRmfEhL8JGCwfkAsROdjaoeJK6deAWtg0ycZUJpUwVV+7vPlYdDfV7cXf669Cd/pUX6D/3QD8V/Hzt2jB/5kR/hG77hG6iqijRN/6u/c+DAgau+fsc73sGrXvUqrr322vi9j370o/zCL/wCL3nJSwD4sR/7Mf7Nv/k3fPKTn/xLFelNR5FGJFNGW3gUKSx6WMX/9o2/xqOzg/z7+18JI8PFZg33v1/H9d/+MZ78ubsEhZqJT7PtELl3n94+gqo00zW/kcwQdLFxLD/m2LhF4TKHzRzpnqauFc2wQeUNzkFTGhnXzxTT/Y58S4mzzEqCKjS2Y8lOZ3zuvbex/ZOK2cGawRMJ2R5MtSOZGJhpyizFTRP6PVC1gl4DY0OxYnG5xewZyBtMZqX2KzVmptGVxIIDqJmhVmBGhqbf4K7kNB1HPbSoWtG5JBz9dCz8ubrjVenBBWIKtmNpNKhSPOB1JS4bk0NSpNoMsi3ZwKwXWlULjnRPkKjRIcvb/8vLOfxl5zn78H50pehcUlz3N5/kM08fYXxDxWJewqMr6Ap2t/ooY9EXcpSF533pM2yXXRaeEDRZOS92cyKs1Y+k2DSj8dOQ4roGt5MyLgyTS33MyPCe8zexlE9ZymecLZZ40aHTrOUjcl3zoHe3iYVeJtMEp6Gz1XJJJaxIRVtD5TnEwW2js4FsNn79TMc+pnyO6hAQNwnPccJ5zCStNFgzBkFinbcFa5MKNWQ+cEZ4xgr3X5kxti4iPnnStYma1rteCCoM+Y78h0Ps1IITiIR9OIoDmvSMQ5uWWiFjWnndENoSnSAqF+kBIR4d5D3PljULp0pBA32Eed1RpCMrPP2ZJRk1FCsSXqRL6yPVFXVHxyJGOaHz1LmOjjiKdkOz3r4siDbDORDOrwOlY0MU9xUX+Liqpc/gGyfTInk205LCihz/ZOq4+FLoXDKsPCzFlil90dY43FxoSaAPBH669VQnfGGuaDnVppQGWXuXiuBmUve9M4ovwMPxFQEu0c3GGWIwUDj++HtHeLCeOuIbonTP2/0VnhpVEnnQklQqk7DeWRXdX3QF3YuK6T5wqWO2z6EXS5KsEQ2IR8zHxxr6zxih83WJ/ucukfc5PVyT7BgoxCoW2vU4Jsg2VzcsziDI+5K4raQjGwtlaTgV1KD9/VEOieLwQJnQc0Jxm0KxLAVeviMNcjlQ1AN5r7NVGJyWgnD3GsPi0zWdLctknyFDCvVyIA1BNpKvq76Ox390DUwOysFe+0wTLVD3jkO+rYkOSP76c/jjvqTIt4kNvmgT2gCjcG+H8ysFo4oFeJgSmspP62aSpDmf3xA5+bEEUnGdkYI90Fu0RNb7Ji/x91C26+helt+ru7D0SFus6caRbPv1dNufU89+qnqKzpbFejcd4eXLtVd7UEI8/eX+aTq02pfKpyT7e77pCDVouk/+f/kRR75j/RTMU+dmlnQstpRrn51y+Uu6LDztsGcM0zVpILNdEfrvHpdmKh3hqUZQ9/y0sBFf9HLYNhLayr0SxLNOCZiRFNafB8XwdBMpcK0dbjivFmeEBgUuOj05o0h3GsoFze4xw+i4ZfXDz026yxcf7ePzxknf3Nzk13/917n77rv/wgL9zz4uXrzIu971Lt785jdf9f2XvexlvO1tb+Nrv/ZrWVpa4jd/8zcpioJXvvKV/9XnKYqComihrt3dXUAWTFmbQhqjoNsy+pYbZvkzhh85+7cplh1u2GBq5YtSxeNvejGH3w0X7nT0zvuuuw/JprzOQw9eQ++MoVxsO2JnFDZXbN2gsJnDpg4znrO7mmrMZoLNZJRtcymEOxdNK/qqNMfeJf7j3/e//BZvOXsnW/dcQ7JraLoyVjZjQ7ajKJccbGWYfTPGtzQwTlDG4ozB7CmavkUfLujd32dy0GETh3Z45B6aRlEeKdGbKazUmGGJnSa4BYfp1CRpQ7HTwaaadFcs17oXRSRZDX2qmkdKkpHsGOVKQ7VSo1JLWWqSrYR6ucaWXjg2lUW17kEzaEhGiUfCFIf+13u449vhdx44QLoni+16ZwS7KfQq9va6mAOCDh4/fJnFfMbTnzgpi6W3iwxuAkE4FGwHnZVCKZl4BXzq6J5OyLcMQUQ4ffwAEyUb8VMQrbVUA87TAgL3NjgmzKOsysmGFkbfO9dqZmuOZKpY/axl71rH8HQ7ppXfkYIbiIIw7RfkkPhpjRyfdNyKyMTRoRFee+WuKuxD8WyN+Io7gxQiXkgZkwj9a4ZH8HkPVJJiqL3QsC3wnW79nKVQ92hSGtwa5DWKFceR94zYunVAsaToXnZxZN3kiiDKVI42DdX7Vne3G1yiyPZqisUEU4nQtVww5NtNLAhMYdGlpemaiPy7+WPrN13dtPZuUczp5o5XIgiaoI/tcVKuReNDSil+0wzoo1DCLFVXx2JGBGeCEGo/6UjHjsPvd4BMAoJw1GqF8pts3ZE/3U1L/4Lzz9HSkoIncjhHTa4idSAZ+feYtiJ0/Gg93BfKCsfWpmBCge5Fu/P+46YQGsDosPDak7HQSiSQSJ4vpI1WQ6IOprMB6Z68h2pB3lO+K3SYdE+eJ9vRFM+fSNiaU9BvsJUCZcgvmRj6IoK4Fh13CjrnE8lkuGD89SI/pwAauSet8Z8tFEU1dM6mZDtIqFZf+wAYHTVATa5aVFj7a9sfD5tKodXk7bE0pfx/3ZVmXDfQOw+TA/J/o2NtQulsNWH5UUt3w3r3DuiNHTbXlEMV77VQfAa3FtXA6LChd0l+Z+lh3VLMgqNKnJipGLQ2XTEUi7JuLT/e+OK/vX4kAMle5W7jvMe7OAfJ9aaso7PtJzkeLAhIbUCtw/0bi3/wlqVC0Qn3uEzDXAwEE4cgJ2hz7kMAff5CtMb0DWAIEupdEYS8d8nGZqDJFJ3tkIysqHoqhqLFoB8/QQr0mWJRJlO6lGt5dFAAFFO4OCVJpg3Fckq2XVEtSKiU8PjlGg6+8soqdGNiMxiuiflrM4TERXcnLUV7CHhCtetUWLPjWutF6MbT5qxRXjTu/d794TKVTO5M5UjH8lk6m+q5iSY7vuiTPvf4Ky/S/+k//ae88Y1vZDKZcNddd/HOd77z//LvvvnNb2Y4HPKN3/iNV33/bW97G9/2bd/G6uoqSZLQ6/X4vd/7PU6ePPlffZ6f/umf5qd+6qf+3PdN6ah92AEgf/tRcPDanRz01nFaNoB8Sxb56QHH4OGUhY8+ze41JyhW5SmKfTU3vP5envjPL6DzhPCUTSmbUbEKZmo5/7KUpuNHuwum7fprSftsOu6qWYwZezeL3JFMFPklwzNfKyLK4b+a0jE19rox2YP9OIoul/D+rQo3sDirUNrh+jWuMmSXDcWhiu5CwWycYWbChbfXTnHnuhSrls5lLcXxZoqZKTjVpdxXkS8WlOMM1yiKrR7KR44fft82j/13C+A0Te7IdhXlUNDkJhXKR7EC+RXxPU9GCcrB7HCFShzpboLN/EjTo3Td0wk2R4J2Enj8398Jd3yc5o2Wa19wlkw3vP/J6/mZ1/wGnxif4Jp8g4dvPMQfv+tFXPzTw2yM4KZvfoxJnTJrEq6M+5EOEJqeJlU+gtojnb4o0xODLuS9C1WBiLYECz5BOYVOUfWUcGznEEfnuYqqCWgnbQJiAwunLAun/Jh3oGFtijV5RGsDygxcXbSHjUr5RdvB0uNBcNk+/3TViOAq0DT8ewtODEnlxN1gDiHXvlAtFnX0kw6i0atSURH0u/Gx5/M82DDa1jUwc95Kjkh9URYOfMyxdat3/sngwpc2HPhT04Z2VM67VbRi1CaFzp6NdmQ20R5NktCgbGQZH0xQDXS2mjY9tXGRHiPuCi46rwSUVs6ZfC940YdzoJyi8hZ4AlPL57BzxzqsIe0kgFi8g6fM+AYoXGMoHbnC6aiJDY3QcwTxGp6VFyv7mul+WHhagtJMBeP9mu6Gi7aVIlpUVD1pnrI9r2lIfahNqaQwb6DyU7+r0g47UpSbgtgoR+FfJTZ+4TXKgWL50YrRoZTZmpzDREO1SLRpTaZCKStWQFeKOpfJjkuIwUKTfVAuWnShSfdgfNTRjFKSfi2gb6PILqeke3K/1F1pPoKjjlUCriiPaCdj1aLslhgyE50umjmajPMTACefdev6RHIHOk5EjQYGZ2SahVI0RrWhStYLPOeoROH15q+HqufpX0bWtWQmfvD5RkBuYXRYs3DKYlMd77/Ge7XXXRXft5nJsVWe+lEu4gPlLJkXP88X2OFcWX+enYLulYbOJpQLGl1ImnDkrydt0xgL9FAkpjKlq7vS9Bvb/n/QiMRMAkN0oELJtCqIbXGtdkusSYn0ODOXARHvTWQP1d4zPYACIXk4FLiqcRg/QWi8w48OQINfI+Wcy/7qFBQLwbY00OycnxA5Fp5pwNP6qp72bkhaEPIVEbhOVw3ZyLH0dOPTXyVBde9wIs1ZLY1995K8XjnwE9GqbZhtJmBWcH6qOyL4rTse/EG45THx1u8lugIz9YFn4Vx5rnlY98K1g5bnCIg989foFx/P6cdfukj/yZ/8yf9qwTv/uO+++3jRi14EwD/5J/+E7/3e7+WZZ57hp37qp/ie7/ke3vnOd6LUf7uL+ZVf+RW+67u+i06nc9X3f+zHfoytrS3e+973sra2xtvf/na+5Vu+hQ996EPcdtttf+55fvRHf5R//I//cfx6d3eXo0ePit+0747DqLbJZANJZsIj/67XvZ9/tvY5XvSJ72DymRV2r2vonTUMnlVs317x8P98Dde/4R523n09tdW4B6RaV5dz6g509wQhmq0JL3NyIMEaSchL9zyiamRkXPd8AmRXBJPlosNMBbWvFiDdkxvOzCAZGZ74zy/gF64H97IDNN+vsWuWo3/YMD6YYDNJ+UxGinp/g601SjkYJbjcUh4rUMB0s4vpVTICV2AvdXCDBlLLVCckIxmfNn0rwqpKU5/tk06ViD7HOhZQ7oFH6Z6/k2JV6A7lgk+R07IIpRNB1colP5bzdm6Dx9LIHWSKT/GTxSTbg9JzsvNNQdOe/N9eyvr98HjvACqxuFrz6u5FXtffQaNh8Sx8332cqvc4aDp899NfzU7ZIVGWff0Rp5N1rHe6MIWLghx8wWt9KIfaPyN7tNsiLXOIUBj/NoHr6MR7NzZ8DjJv1xUcQHRNFHVFm0wXFktHsaywW7mgI9Wfvz/iSJoWOQzKfZsqdk7K73Q3Wk55sF2cDzcKHG7nHOVQk0zcXIx6636Q7droEd5kmro3l4Tpf15XUoRAQBsFlQ5FUSz8KxGfBS67Tb0LyZ40N9UCdM8mTPYJArxw2kbf4zC6j5aItWOyL6F/wTFdS9AVzJaF765L6J+raDqa0cGE7qYIPyWNzxfECP2l7sqExCYKXUkRFpqjULgHJ4yQrhmatSZXcSOM1nOI+LTJPcdAteNtpxXJuPG0FvmZQEcJ5yRY6IXj2OSKwTkbnVHSqSM9Jce8M5MD23Paj7f95l9DNrOYwtONEmnU80lLx5g/L6ppqSiqkfst37ZM9unoBx2cKJoujA8rkpF/LqWYraQsPCvFZTIRdF2EjXItjQ8kLDyhfDMHsyU5ltk2MX2xHjhIZTJYLTowonNQ2lLPEsxGIsXlZaKtZRDDxmJjrnGep1fMP5TzHOAKykMVyZWE2boj3ZE1Lt2T4zVdE/2I8PN942s0IYHWlF647bclXUpx2aRtAZlOxE4zWlj6+zWsAWufsXHNC5O88Bx1V2ETHdcmgkCycGQ7htE1ci/3zosbznRdsXutYd8n6xYN99MdpwWRrruKpGyLb1PK5Ml6qovYVHoKhhdMN7mOHHLrJ2MidvZ8ed9wh0leAC1a15KWux0ajugAhJ8yWcfeQRVTRdORnB9di3B1st6izknR2sDaxAvbPYWs6ai4RswjzTG92TdqAE4pTO2Rjrot4OuOIN/CBbexQA9aBFM6uhvtpCJQbeL+gWLrhBZd0GWvDTCKlUfs1QWxk2I+6D86V+Tbdb+9Zqtee5yaDnBZ1tmkcFHLoSvr1wkdm0Zdt8e99uJaHZJk/THPdywo+f/Rgecmmvz58En/vDjI/D/w+EsX6f/gH/wDvv3bv/3/9GeOHz8e/722tsba2ho33HADN998M0ePHuVjH/sYL33pS/9Pn+NDH/oQjz76KG9729uu+v6TTz7JG9/4Rh588EFuueUWAG6//XY+9KEP8fM///P84i/+4p97rjzPyfP8z33f+EIiSCeaXDE+LBe7mcHnfuAXANiwUz75wrdx60ffQOeyYbYKkxsLfu0Vv8JL8oo/+PIl/uOdyzzysye5/p9JaFG2rZgdruhdFJQp3ZXNcOekol5q6F407J0gbi7JxCO4mcOMNeWyV+9fUoxuKclPZ15UCGomVIHuwx0WPrzO162/i7fceJiFD6/zieFxbv4X57ny8jXMlVREi89Kgke5bGHQYHJZRe0oRWUW22jqAVT7vXA1s7haoS1UqzXplqFZEBtCVYuAq1wTBwWzYcRKbQJn/okU6KZQsempFxpMafyiIYhCMpHNpR7I53dhfNzM8Vi94LBc8M4tvogYH4Gjf1xz/m+krH8wjW4LX3nP/xiRkiC+CqiWTWVBqoZw2UEeEug8YiVca3wRGoo2R1PpyMttcjA+mCQU6nomCIxcSy0SrawvBvwCGSgPwRfXVB7hcX7jcA7tpPDoXtQk0yb6XttUirpi0dDZlPMWCjI8fUNpoUCsPGwjrSV4pTe5mnvPnirjF+1QzFzFtVb+OW2LMs+WDfmOJd9pERuhUcjzpRMrG1nhIpIcU0hn4kRRLBrSsfWC4HYiYBPFbFXFoCOUCLhtoKr4DV8VHv1KBBGSwCUp/mbLcrHVuSKrhOs9XTMMz9WCfvvrQleBAy/PkXoOfCwmghjXHwenED6cwvNlZbQv1BTb6guAcqjFVz4mjSoIXuZeD6AaB7oNrYpFpd/wq4Em227itSICNmKaZHD/CWNtKQ6Er5zMXEQam45qhZ01sTBqMt8od1s0WXtbu0AdaXIv5nNQe7Gb11FG55uQFGpTUAnsnNDiIuSLuGpBBJP5thOBY6qYrQgtxvn7qe63aH2+qaiHyotSpfKpVso48m5Wa9TIMNkveQ02FzQ5223f08Ilx3i//3k/DUimAo4EzroU2XJtZmelAqp7jmpRipb+Oc34cChioRpIuFKxIq9V92TtSqbE8BztN/o4lbGyjsxWVOusFCYv2r+XSPuQJrmxqk0R9vdXQKZjknCqKBYVwzMN1hh2n1cz6im6Z4ykro7h8u0J+z5V46yLdCyQ+77qK/KdhiCCDhQamwrIEuw8q65cv+Wi8UWo9jauDlWLpWnURDjAOtKZxcws9cDEZNIACoSGM0wBdQUEClEHaSadFOf5jmuPYdfT9bacb2S4qvkKtBe5VxX5Trsuh89sE6KTVJhQKevDyypHk3qf+aIFKYQi439fhfXcXfXczK35gM9skO9VQ1j7bE3IuED5EConRbb2a7/zOoy0adeC8PrhnhNaHowO+tfzhhNNHlyfVKT1BIpj6+wErq/j5C64u8BcirSRydgXH8/tx1+6SA9F9/+dRxCmzfPD/6LHm970Jl74whdy++23X/X9yUQqJa2vhkmMMVj7l1Mqm5nD9RQbX2J569e9kRfnKU/WI77mo3+f8myPytWkKmFV9ylcxYu/7kGeHS3x7Yfv50C6wyPFQd67t8J//tRdHPyNLa5/zf08/dbb6T7gaQIzze6NDf2nTESNsh1I9wzlstyI1ZGSzqlMhFIzRbqrKFekyxfkTjH8bBa9Vas+PgpbMTloyXTN2OZMvuku3I/McH8bHv6hA9z8U2d59B8dIR3BbF183pOJxmnN9JYGfT4nmymanmP4tIwHZ8qh1gr02Q7N0KJWC9RWLgj/VopdqlGVol5oQDuSbbHMMzMpMItlxw1vusIjb1gl3dVYpXCpo1hvACOTA48+2aQNrAhIjM1l8862/Ch0BomVn5utyAKb7UKxbEhu2eHKwpDVz7Q8zcgND1xFv5GY0iNHu+FClIUypGQGBxAJiCBuKIffIUKFJvcc3rkRrHMBCZKFtZ7jAMZkPiDY6EXUCeIoNo6UnWxU4xtLhp/NJCzFBw2lo5aWIeTCgJg64bwnIbjCRZGnbsSG0yZCoWh54QGlbVHHqqeEQ2yJfNS9I5qFZ5pYvItoao7T7hFlUzimq8bz2x1m4mJTUXd09P8OdmsE1NcXBlJ44j174ZqfvIcrb7ibyT7F8HRwTbHRsk43LlKr8p0KVTuKThp593VXKBizo3JdFgsJi6caT5dRWO+ag29+wmZL7bmmpY28bGeUiLGcH4VPw7GoqfomFiDha4ka9z9vdCzebdzYoRqKfSTeHm1edxCu4aajY/EdPNSTiUWXjqaj26I+gSaEmyjfDLh2UmO9DWUMTAr3CG3B2rvgr8dcJl3OiKgx34LdE47OhvKFqZz3dC9Q9rgqudNlUCP33t5AiS5nEsR8Rigzqg0PqwaO7kUV14HJIUv3XLs+lIvgKoPTDrWTku76aV6Opzn5Qq4f1nER51UDAQGE+kCkeOjKF4RVuyaEJsbllvRKQjKW45Pu+UuiB71zXvA3lZ8PCGYykS4q3A8iAm6bcOX8xMWvFWYmgvBA+wt6pyDGlqbWNxj+Xjd+r7xyh+RKJBNFuWxxfYsaKQZPJoyvaSiXxIQg0EyKhcC78VO3cM79+ZfrSoTVIhgN2pFgGepdP5xQrkL6aOCLB+u+YLcq1FAjcfSGmJSsPVpsChE8JnsVNjMoJ+FI030i0E+mQSjqaUNhLZ65aCOYjhyBlx2ob3Ua7h3vulMIXTCZ2nj/BBAgTANlrVHeKllF+lnkfHvxt/ZUFFU78bEP9JBwLD2QEYCo0KwoBwc+Vstr1C0trOpr6o5i48U1nXMJqw82keJmU8l3cFpEy6pxMcjIlM6vrco3GviJQ2sOAG2BH9DGqi/XQEhRjoW/Dpa/7R71XPRJd3x+UO6/Lu3JXxkn/d577+Xee+/lZS97GcvLyzz11FP8+I//OCdPnrwKRb/pppv46Z/+aV73utfF7+3u7vJbv/Vb/Ot//a//3PPedNNNXHfddXz/938/P/uzP8vq6ipvf/vbec973vOX4rsDvO8n38S/K27hx9YeAVJ27ZSTyYBHX/5rWCzfd/pLedPRjwDwjY9/HWd/7zijE5Zfa+7CaMuzZ9ZILmSonuW8XeZ6oHtvn2oILofeGSMpk1r+dDZg/efvYfb1d9J5x8fj+9DdLud+4A6xFvOAv1NgpprRcYsqFfmWLFjJxI/FjLgoXNu7QqZqer/zMZ75redjzhqSXc0z33mUzmUYX2NZ/ZRi77j8rq7A7aUekRKkaPvmBl1qCcHYSzFHZlBqbK3FAs1YbK3RuzJ2ptOQ9ir0hZRq0ZJtCkpWLzWM//eKA2+CCy+VoCOnDfVyzeygo+4b8k3Z+LJdjySMxRu3WJZbZvEJRbbnyPZkxSmHUrTkO7B4/3k2X3aIrRs1nfcv0vXhTdN1jwo2cozNBPaOKAZnw6rKVU4VAKrgz9jvtUWjFEutTWGIdg7PBcSxcNiwqr4iKdpiPHAxo9jKo6NybmVUHsRTAfFHw+Cc+DLLhul/PtAhPJcZ8AlyUnzq2gvElMJMRVApvr2WQKMIVBkd/djb5kS8k2VzbTJF75LfQCK/VHmB4lwT7BwuEQQ3PMYHE/IdS9UzkcMbjpf42LtIs1EVMc67XIRj/7PYsi48W1MOxFd54bQVp5LCtu8zvLwWAXb4fBEZTJSfYPiAnI5idEDcTpKxcOdDmErgdYb7renoq86V9ufOVA7XCEe87mjyrZq6b3BG6B6tJaPzIjpfHDTu6nRR/77luR3JTJoZ7ZNIg3tEkwc40ItTlY9+nwuEEvEqEQGHUFBJEZ5Mw/F3WG2kuA0ToRKY41NbL+50WhDN2Rr0z8jkqVyvURcSklq8savh/HUzd+xyocrQSIEafLYn+xXlIvTPQanFral7ob0udCPTo3QE2Y5j81Zp+vV2gu1o8i05Fk3HC0snRL/z0JjX3ZZHX3e920wtzUT/nEzjQpFvZuCatnnpnk0iFSH1TWaTy3Ml3oLSGsSd0HkxoxKRbzjnxVDHaQT49cR4UGZX3ku+JddRviMTj3JBi16gbBtnlBStAgr4JksLwOKMCO+rhQrbg+4lxdLjYKqGqqfjlCgmHXv6RaDTZTsuFqLhPgnrWECjwzUfKDnTFWlGuxsNjdGRdhY0NuGRTC229hQbT3upBl58mUijZ3p6rsB3sYEPDk+dTRv508pfuiE9NNhblgNNEOPLuiqvV/mpzHC78RMBefJwHIJ9pm7azIlyQQTzAe22HpFOR4GjD6Qq6myUv/+T2Z9Zi/w9GpBslKe8dTTOc85Hh0SP03smaUGqIJptZC1ofGPf+MYkTDgDrahcUP5e8wmyw4Cgy8/VHRWF+qHxr3oqNrVhylynwWdfAIQwvfji47n7+Csr0rvdLr/7u7/LT/zETzAejzl48CCvec1reOtb33oV9eTRRx9lZ2fnqt9961vfinOO7/iO7/hzz5umKe9+97v5kR/5EV772tcyGo247rrrePOb38zXfM3X/KXe409cuo1/c/Jz8eu37F7P3186A4BG8/zBWb760a/h/NuPUXdhckNDfsVw/qH9ciMNa+r9JZ2FgtnFHk++5Q5Ofrfw0zd2+tRnu5iJLPqqEZ7ZpX9wN87A7g/eTTWA6QHL+vUbHP7WB3j2f3g+0wMWM1XUS5Z6scbVivRyGtHmcq1V7OtS8Xu/+XIO/8t7ePqtt9P7SJ/RNXIDFiuOhScV0/3ys9mWd5dJYfCUiSEldd+hl0psZegOC+pa40736F+RRLlqtUbtJqjlkvTImGKUYa5k1IUhSR0ubTlyya7hzMVlkls0w+NbTKbL9M4rJiQRyan6YHNHkwebQMUN/2kLzl7k5vfucvyrr/CWf/U1dN7xcS7+o7vZvb0kfzZj6THH5t84BA6WH2tHubsnFJ/9+z+PRvO6J76SG4cXeeXCw5xMNrk+HfCCf/EGcVzQntrpOeI7Xzdi+K6BjL+7xLjlJpdFMZk5zn9lgxoZXGLpnTZCx/Gj5TDZaNKWUqAaML7Qb+bEhDYh2r4J0uZ8tLkvnpWMMZmJICts0AH9UQqqRMUCUERPrQhLVQ6VCUex7oaEUo/QqrZgxCNA8h+OzZvEdWC2rll+1DLer1k81UQkpt2Iwsbt7Rs9+tRk7b1kjSLz4lFTuUgrScaWpqvJ99oCP2zw4hABybidimXvupfO7c8jHQ+ouzo+d3jPYSpQLiToykZxa6D19C7VBG551ddMVzT5rqO7IVxpm4YNG5y3lEQRUTM1t2cFZDTwXJV1pKMGXUvypQmUIaG2xwYI1Y6WVRGcemg/A8HSznOBkY25zgJK6wOrUgnH0cEbPxzrVAqP+Q12XlOTjq3nvavYtNRdbwfq36+yIY1SinpnRWweRI97J+Xi1VMd3V32jgqC3+oM2tcNDUAQv1lvzZntEJ0yTAHd860PevAoD3aN5VDR8aFYyipqq1sLSP8e6j7xmJtZ+7rV0NtLduT95dvy3qbr4ZrzrjWZ508bIgUlFHOlNxEw3g8+BstUck2XAxWF1DEHoAmWpi0fXddzBVLjBD2vHN2NhmLRUPeEwhLOszNCxwuCyvYCBDJLsSoTVqcguZiJGYCnQRVLOn6+ee93Kc6CT7mK95o0nu5qkbcF7bUoTUemRjgRXgc9jWrknlaNQ1fWBy/NhwSJ+DQGCjnb6kjqcL/7a8fK86sDHvGt2nySoGUJfPW6I++9HHqqyEyOb7EkDUndh+l+y6E/bal6F+5KqPuWQx/097drNSaiM5E0cZtCUvnJpm8OwiQLpWi8DimITEPexFUIun9u651sUDKBC25RdUcxPCO0vXQijYZNWz77bFnT2SI2vKZyseEKzUa+006c01FDsSjPkY58aFrdTiF01dLokhnxdaquorthoy7JpmAclKHhfo49Pi8+6V/o7i633XYb73vf+/6bP/df82Z+/etfz+tf//q/8Heuv/56fud3fuf/q/cH8Hv3voh/de0DpEoOw99fOsPL/uH3s3dYSzz1oQYyS2cJdAH9Z40vvBTNjWOavYz82Yy6m6Jzh9vMefLn7uKG/2mLS/8gI/V8u4DKNJlsEsWycNTzbQDNZVa58osDDv9mzdk1Qz200CjyZ7IYa10sSaiD7VqaBcvwkZSDP3sPL/y041NfcYT60Zy9ay26FEGq04oD77/E7nXrYonli8pgj5ZMiaO85nIHeg2zcQaTBO03rmwP0AabO6xVFOMMk1majkVVimqlpvts6ke6sgGP9yn0zXvsXBrQ8+NrlyAppQpu+Hv3xeOvs4wz/+hFPPKGRfLLKzz1bmka1FdNufUNA7Lp0zx06jCzQxWzy2k8lmHzSWa+GPSxhU/93kl+75/8MS/+8Tew8VIRhuV9yD2SEEVOCfTeO8RmsPGqGWm3ZvGd/TYNsqOoFSzfJ82R9mPygOzEjbDxN5Ai2izqyjFdFdFd90qLXkUahUdqgw1hWERdCksPJNRdF/nq29eZWEDkO6C2bUSa5rmXZo6XCES6RjzOlQj72tEunlLTPteV2wTNrDtKNmBfSM+PeE3lmKwLP13XXow2az9TQPwla8CjOUMTN0dnwFpACSoXqCCmgCs/cDdrvyho+tbzF6V4nzlGhzWdDUl+DIj+eL84m+TbisUnZ4yOduierai7mmLRUA3a5Ejw4sdUCYXAyedIJg3VeoqZK35bhxf5O4zKrS90TGGZraViZTaViUcIvHEGJvuSGIYSqDo4SGdCIbCp9nQASTCt0zCNUdS5Ip34yYHnnpvS0j/vhBdvHdXAxOlDvm2vQs1043mnRUgZVUxXjXdC8cWt8nQO6wtz/5mLFcfCUxKUpktFvgXlOpixxkxUvA7E/9o3JV7Mrf19oCt5jeCapEvIZnIOk5mci3RPMTmIJBsryUgoViE9LffD7gnvWDETrngzsNiJ8b8rEwmbyXMnhVx3xbKc33wLhmek0Qxoup0rssQlhfb+SLz2xTfPpuCqe2ueHw74EBxpjqIzkArXs6wNdVeaKuVdWJwhIrR1Fzqbcr5nKzrqMwKiHcNqMi8Q9PQqPTFk257isdiIzW7fku9wlUg1XAeNn7YFvnTV134S0E5iAm85iLIDjURST4kOV2Edckr2ClOKr/vgrOxl4VpuhdZ+zYge7cpPWVTk2JPgee1EMCSIO1uUX0TSYSpZd9TclMlf/zteVOvAJhrlmvj7y4/IYm9TAUNM6WJeR1gTdNXy/nXTrlfOiItSOq5jaFug9ThFe3/6JidofJyWYxyQ+ZCjUA7EzrP2zWNnyzvvaHnNzrYU8HEfCJODSiZ9IYk00Bl17ch3XWyCWlch34TVRK2MsgLWhOsqCEnDdeMUqOSLSPpz/fF580l/Lj4e+Ju/Ggv08Pjwv/0P/NLOQX76/a8lu2JYeErHSOt0RBznmUf71PtrilVLtqNpunMI44OPcuSP7uTMlzfkl00cxWKF2hGoF4IkQ+eypqg7dH7/o+S33c3kuEVPDMVaQ7pjfPcvgilVKsxizcGfvY/RH56kdk/z9EeOofvCaW96lskhUJVicmIZM5Nxc9hMQ1BJGP02GeQbimkXkgsZ1XJDs1Az0wm9s4qmK8+bn8rRt+1SzFLoN5gLGSyXKCv+wnVPuO/6Ys7xN4957O8MUC/cwX5qEbdWcGjfDoOfHHDyvg5P7q2xV3S48OQq0KBqRborceKDU4rrX3yWc5NFekkFjULnDXUv5ee+/z/yTLXGx3ZP8icfvY3eWeGq3vxLb5BgplsqbnrTG7DXgd7zvOGO57LaFvEWZbwsTmvvy3E6p+4qj3a0ziWtEFQKpeDGAWATF6kmDm8/57mmvcs2irH2DovQcPEpKyhV4I2XgvTOWyxKHHyApqTIx8mGJQI/L+paEDuu8D6bzCNdnfb5wri0yQSdD3674aFrx/KjYkEW+PG6bPmp4Av9pn0/VVczPiCBKLJhycZd54p0KkVK6pHgcGysd9MIhbu43bTBITZREf1sXvVCkr2S5Qd32Ll5kdmS5uCfXGH35hVGB43wVzca1j9boUtBxnGO4akpo2s6EvriUwiDoE9XMDhdsHs8Z7aa0LvYoAuLzdppgQrIXhN4sB7FUhCpLN7lIh1L8FE5kN/PRjaKhPMdSzqxqMq2PHhfOKBU5Lk2HWniovOCD3Sq+joWDkHLEIpCbSHda0gjAt8+bxi5O+8ioqxQk/rna3Tj2LwxkzWnmKN1BQGjhsGzsol3rkiDPz4M1IqmI8mL+VZIl/XUmgbUnNBXphtEbmwoUIslmCl/X43lXsy2haoRiqVsS97z9g3SHDgj9rbprgKksUxHcm1WQ5lidbbEgSUIDgO6vnNC7rXASVee/mMTJGTOtJS3eTqTULGIBUygU6QToR8Yj06WQzknVd8nuM41/U0mnym4/whdTVJtR4c1IardFJbBOVlYau/KIU4lVvzZR3KN17kW5LqGclFcssxEy3FYa6h7SQyoUdZGnn64v4JwXFnJvQgORC1NSHlEV8X1IjxCURh1M0kLKlQDKc5DkR3ScEPzKzS60Hg4dBmABU/d8I4xuvbOUy40DWA8+iz2jF4s3YT7j2g1G/QxVVdFUXXdbZ2b8h3bfk7/iFayYaJpEM2UliYv3M/ppHW8mSdGt+48reg+HIeg3QlgBY2cX5eEyZN83tFhzfDZ9l41JTRa3MSaTPmwKf9cGUz2SdMaHLCcFqFrd8PG17X+NUI9UfWlwWsyaeyCAYFqvI0ovgFIFfVAPzfRZPf5SRz96/L4gi7Sf2nnMO8+/WJOfe4QLnF0zxrZSHZgAPzT73sb16SbXGqG/NhvfHdruVXJwqlnWtIzS+he0MxWHergjAtvfx4Hv+l+Fv/O9ewkCxRripM3n2PrrUev4lRWfT+irETlDgGNUth+Q35B/NTD/02vLTGdhtUlsXlJTcPF2RBuGMHpvqBZiRNbwNSxfX0qBakff4bXton8HfzfAz+zOVTAzKA0uLWCUS+BUhoQ23GkVtNMkogc9+7vCI1nENA0xQ13P83D+rjw8O9bJB/BS298jI+/4/non7qAdZonHzhCfkWTJ4LsJxPhjS48rti+s+DpX7texs8DWKwh30mYrcAvX/hSvnnffTy4cZBsWwqdJod60PCaOz/D+9/1Aop9DS5xqLzBZA2rK7uMiozJLKPc6EKvZnVtj9EsoyxSlLaYxFJsdCG3dJ7MGJxx3k3AtVQWX7iGMXe0YAzFl22RHuOdSNKxZfmJdtzrjJbCTYPtqSgyq7rCZw98UFNKcRAahmABCdDkmnTs4oYQC0x/TQe3khisg2xgQulokXFlBanNvFAuWBGWUfkfUllFIyCCJofNiWPx7oZQKsKEwUQqjIr+xHVHYZTnwnsEKVgYqhq2r9Ps+0RJ+sf3y/vKO9hihrvlpUz3Qb3co39uhikzuhdnVAsZ5UIiBet2gUtk9JttN2AkdXCyLrQgM4P+pZrt6zpRLLV9nUE1hqUn69i82EThsjaMRTWt/Zzy3sku1cIXxfPJixZNS6YSopR4P3htFU1Hx0JjHtF1Plo9Fg0uNC+BKzrvyoH3xrYiuKusNIt+KmJz3dIWlPja9y428vPBkcKomMY5vsaR7Xhf6UqKXrSEjzklx2v7tgZnHGZksD2La8QjHuf7FksUZTcBma5pmzHTXk911yf6KkkZTWaCgNa5p4aMZR2arbXj+slhS/ec9nx7T3EoRLeQjuX+mC0Ti2OlkQbQyhrSueL/L22LbpsS77XwfeXfYyja820XOemTfb7AaeQarXoq2vQaj3qmY/H9bvL2/IYMBKda+9XpqmZw1jJd11HDEq6jkIAq1BhBaOuunN/wXs1UmuJkioAZU4d9KhFnokxRdaWR04mKOgubtLSH4PgT7BXjpCDSlFwUj4I0EsEFJ+hWgoMOWgnVzzqxc9TSxBvraLpGhKV5+zo4h+0ZQnKrss7bucr1FFxRqr40RPPTxlBg1x1xeAkOSTgYHxTdTL4t/PHC87WLpYByi84j2i9C68Wu2vsu0Nnqjj8OfoLgtGihAiquGsfuMc3Cszbe73VHrA9DEx0AE1N6S1/fcFQ96HqLxYVTkvaZjoWiUixqD1aIEHRw1kaKTKDxFct+AuNpSpN1hSm195hHcge6KqL0ATyJzXMCTbCQnLV0F5miMC/zeU49Ph/4/l+XGcIXdJF+fXaBf3z8PXzt82b8w3Mv5v/4+B18/5e+jxd0T9FRNT/y2Ddy8coCX3vTQ/zAN/8B/+6Tr+IX7/7P3JZt01OGV3zi7zB9cJl8Wxb5xScdOye78JKC6o8Os+/LH2H7l1+M7tVs/eZR4Sd2pAgyviirc0Gglx5RTL/hTgkysgo91pSLwk93Wjaq4QMZdR/2VJfZP1xn/1fcQ35vn6+7/kE+ODjJpfNLuEbRP2XE+WXXMTkoKHXd9zzQGTEhUJegvEdyeiUhmSbM1j0KsOjQ/YpGJ6jU4UaG6lyP3mUt4QyXvfDMithV1XDs3RMe1SdIvXAsmcpCfP/5a5gcqzmYVHx28yDZhvBcVSKFQuNT2mZrkJ/K2Tsmm0ZxTYnaTXCDBr2T8HcPfJBd26WTVORb4vhij0xx04T3/OkdpA6OX3+BO1bP8Hv3vZD8kZyzR3PS1RkHV3Y4WxuajZzhoYKNy0MWV8aMxh32L+7x7CjHZI1shpH2ICNTnHzOOldsvKzkK2/5HOMm4+tWP823DHYAePH//AasL7xi0+MXS0E1ZMQbLdlCgeCRtDINAiAdN6PA0QyBH+ARZz+6FNSwtXc0lYi4WspES7OpOwrlG4xk4loaQFiklRSf2V5oKHzxFwprZJNdftRGj/C9I5repTYRVPjeRCGr9ZQIEIQnnbSUITPziFECm8/LUDfdzYFf+hR6ZRk9K1h4y0fhu1/K7rVddk4KwlsN+ijrmK5o3BHD4FzCwoNXcFmCcl3ZQMeQbRuKZYNNFDvHk8jpNiWoXUHado9Js5ntCu8127Ng2klJsKnTIPaPjZN0Yg1BaCYNkgg9hdLgETatI80hoHz5boPTyvtFywkLzV0cW6uWnx6uPxEuGs891cKbrx3Wn+PgLBE9ohMFHU06lkq0WDZiCuT54MnMi0Q9t7xYtvJ1sFhNLRSiVTB7hsFpRdVrkUjdtO5EwWNd1S2/POgUdOORQu+KFPjrxaK3WvRTKusbdWtkGqcszPY5OpdUnFwGJD4kOpuZBDOlI+8A5dr7rlogOrpYT2kx3mnFerphuO5DsFC4xptciQVhQHaD+1MCddreu+nEUfXEZhLr1znvo68aQUFdIqc5nci5GZxp2DuSMDxbS1O3aKKveqQmzPzkyTf1VU/QeWu82HEN1h60sZk0pVjfNplHpxsHBYz3JXEqN5/+61QLMgTbzyYKDuU1k6nzRb6sI+Eczf9Mk+mWJuHkeg2ggVij+nska9OFo5Ym1YQpVaAYZXveErFz9Tqpa0c6bSkdQVzfvSy/V/dkL+pseW3QnONJoDaGgjw8gsPP/FQxuD0FmlOgm6BAexHowrNWrvPatoV/LULgc6+A/R+XlNa4b/j1wRREO9qkcqQj51F0CU2quy1Fpu612pXeJSu0n4mO64SpobPti2+j6O7VmJlCWe0pPXIugxNPaLBCOnWxlLTON1amPPUX6S7P+ccXdJH+0k7Bv9x5IT/4wS/hyJENDl93mT86/zzeq2/izNYSxV5O1i/5t4eER/0Dr/6PXLEzlrVA6v/Lrb/LT/ze342jxCZXdC/Cxpkh5uEltn91Hzf8nft48t+8VEbxfRXdBqYHWpFM07OMDxpGRw02tbjEkewIFzzbkRtPhIbCY5/ug90bGvYD9/3a7fT+5kUunllGGYfpVUwOK9RCxWy5g00cszU/ct6T1xa7OTkGIQjElH6jWapkg7qcYbMElTiSDf9etmXT6F2U9xJFTg765x3PvqaHM7LgVAuCwFkDs4sDVLdGf9lpJr9/E93Lnkvq0wjrnnAKsn1T6tKgjAPtOLK8C4fhzNlVOlcU//DXvo/ll17k9tWzvH/pMOVqw4kDG5y+skzn0ZRiBX702nfzg7/xfZiuoxpCdsWQP9Hn9B2G/LEO/8N3vIv1ZI8ffeabGI26NJsZz07XcLWmLnUsjEXs6UV/yLjRFA4mhmmTcmp3ha8+ehGQayGg10B0OQhoVojHNhXRlzq4DQQ1v4wj3VXiz7CRqGYuqa6REXM6dVEQqizsnNQsnGq5sk7LZhiEloG/HygWAVl0EF8n+B/r2hH8+8P5DaNfOTaOyboWzr0jisgSv5k0c9xXaSrkeMyWBUVKJ4L0Bg/x/T8nXHQL2LNiaWNWlmV06xG2agj9swWz1TQipZ0rJS41uMQ7T2gJgZHzIT8TArOaTNG/UFMODVVfNvdkKgK03iXXUnt8A+ECCm6UJCsqX9u5dpPXpYsisZAcGlDMZNxQ94xYTmqDmVqqoYnNlg2Fi+f9BjegeYrN/MTXKXCp0GeUn5Ao5ppCBLXrbBKnKOJt7ad1TftcqoLxCaHikThsalGjBDWsZQK0kZBM/KTNFznR6chHmDcdX8x4Co0p/GXkp0xWSVER0MwwxQsFcKCizVZDQSbFetPVlOsV6mIabVjzHUd6TmgjJvDbR1Jky5RHip3EU2p0KSi/qkAZEew1PslYF1cf2yYNhb8gutBSE8uhDyAzbdMhSG+4YaQY114QGQwC5D6Rhtd6q8DJPkPdBVVLYmfZ12RjS5WoyK8PfvezJR252jaXKUv6lVdoPrDG1nWG3iVH70oTKTsNUmzj+dfzgs+QynuV+0ygZliHbhSBchPSMZ0WkXqTtwL28EintNM7F46hb+YBpWTKpIvGN45tfkTjE3ul6ZD7NAhNQwpv45uooA9StW8kSm8JmYBC1rKWX371uhsaGKc8PSuuYf6fHgSJdJ5A9fHTUTVnBBB4++VQ09kKT9Y2qcqJ607k+HsQJQSx4ZFrwjny70V442GtIVJ1xKXFeaBHppny+60OS9USZjZbkmY6iMqbVJH4SUWgfMlxEcQ80HKCC5g1SgIOn2MP2W4+DxD/XxNKjf5v/8j//z4KV/PNy/fx6a98I2fOrXLNcIvXH/sQP37incy2Oui0oTnV54b//AO87omvRKM4bIb8xKUX8bJPfyev6oyx37IhLh3+xt+5DoZPGSYHQRnLE//uLk7+0EdZ+k8fpRwKTzOIn1ygINSKeuCoBpIwmm54lG9HxcVfNn+hyHQviUPLM//vu9k74Th/cYkbXn8v13/vfZz87k/RPzSSorMvm0g9sPLcJfTPS3EcFqkwQjbebix7Jic7nWMKRfeCpndGOPX5FYWZtql8AUFyRt7f6Kii7ov/cTIWkdjseVPyLRFEup2M7AMH2fd1j8jB9wuiLpX4IC9UmAcG2CJhZWFMmtZMq5QLmwswEh/jZASXtob84QO38c+/6y3oUnPxfUfQj/UZXVdz96sfZKMZcueXP0QyUvTOw4mXP8OPv+EtrK3s8aHv/1mel5/lV8/czcHDWwwGU5I9w1fe+jlU1oCW+PJqIMddRG/O86zlbb/8BY/wPfs+wrce/QRP1LBrpahsOorZsmy+gQsY3Tt8fHXlUwwn+2RMWizqltftx9ZOi4AQxB/bKT8Ot2E64cM3ShfFZwC9C+KAUPXFvq3uyKYlvuUyfjUzF9MpBQ2mVft7//UgxgphJLL5EPnVARUbnm3Id5roGhNSSoMrQ0DdTCXNSTpx5Ds22qFFyoYB8/yb5WcHg3hvXv7Gm70wUEU/fV00DB/bZv1TE9Y/U2Azzej6JfauW8BmOnrG20xRLEjDlU4s3SsNw7M1NhXaTwgJCgXz3mHF7jFN09GygXYCXcZiCkvdN8J9dVJk6dqPjj11pRxI8ZHt1HSvVJG/HmK/jY9ej5afc2FJ4XlFw+BvjVBEubZRCgVA4hucOK5XbbGU7zofXW5oupqtGzOm65q6ExKN5b6fHpBzXA0dqlKoqZHraGpgmmAK7wSTeHQ70EP864nIz//tC+/g6BJQ9aBvCCi6rmTtCHqQbFeK0M6mL7i9M0vnEqQbElIWEOpyQe6tJmvBgeDQMj6o2L5BRa1PoN+ZKdHlQo4z0QpTWfl8yUy+b3zhno5dFJKiW394ERnKmheSTmtPVUwmLfINvpgv5D7dOywajtFB2WadhnLBREcWof20hawpBAxIp7JWo0QvADD56BrTw5bZujTnkkyqqXoiRnZKJjZOw+bNxt/HLlKuQiMY/+3vTxW0IgFNnuOTG998i6NJuNZpnaLwDUzVurw0udx7kwMpxbKhGiYUSwnFslzcoYFPChunb1EA6s9N8GeP98Pc9DF89kBViwJbTxMUiuCcleH8pLBun1Mma63HuFBx5DXSifPJ0+3r5zs2TgDmw8WUdey/r4kTwuAyJeFhwjGf56yHNTJMz4IA26byuzsnFZe+vpDXD5SkQMOz4fqWdT3bs2R7VvI9Sk/BM8SvAx3S+uOlPWUxrvGubSC++HjuPr6gkfSPzpZ4tDoJg8/xUy99By/vPs3pesjLO/DY1/wiL/v0t1MuTHn++nnefOyDQMJ1b/0BdKF47G//ApBy3x2/xbVPfT/77lNs3iqL9viIwyUOV2t0pTj1ttu5+9jT2H86Q//pJ3nmn9+NNXDsD6ac+rpOtNQ69CHL6a9x6Kkmv6Ij/7PpiHuBLPJEBCXbFYeLsUlJPnCIV609xlt++Ss59Lp7eOaf302x4lj/BFx+gYQKWaMiPz1wqgOaD+IxXixDsifPPzngWH5YbuRygRhg0nT8KDltRZnX/MEez3ztUPipXXnfC4tTmqyLNeKF/PThFVa+4Rr2jsvnsbnYou0+r2L4QIfpPseBQ1vM6gSjHWu9McOsYLY4Zv/te3zuwyexlzuopZKL1SLpjqApX/2199I1FU+O1vm9Sy/g8rQvDhFdePojx/ix5hi6hBc/9Y/pXBEeaXWwxFxOsYdnfOI/fgk3f/cproz7XMmGVJc6dK/IxpcWNgaEKAcr2ZhnqjUMlnVTsaCHADF8I4R5hI0TWvQ80E7Ghx1Nx3HgHlmwA6dRWdkAXKASzAWc5Hu2TeoMG4QvpgMqpT0tJvhlh82tHChBzOY2s5bGcnWhJy8QNhPQYXdEflcEtt7ZZSJF/3yoUxS+Ipt3nfpjVwfEtRWTukTSG9X2HsmRw9RH1kiu7HH55fuZrnuEtZBiavnxGrMzpVnsMjraYbKuI2pbDUFXKZ2NUuzmppbOVsPeUeEdJTN88qXw/3sXGzpbIsgenraMDklxPl1T1F1D97LwXRtfQIQiJoQdOQDtg5ZKsElCMrOUiwnZruz6kvInE5Fk0vggI3+8QwKj8tQWn/AqYVJ+MjGH9iaBV+y58/EacG2TJZZ57bmwRtG9Ij78O9eDXapwtab/lAAAqlbYzI/ncyvQt1WoSlHsl5TgmERatWtOoLhEZNLJ9cIcKml8fkGTBZqEL5L9tKDKwsTGJx46b6mXCvK58JQU2k0urkazVc+97clnNj4/ICQUB3qLtvI+nJICv+56IEH5yWEGylsrNqmn6TXtPZCUkO2Jjz5eVFj3pOFNx95ZJCQJz1n3hfs0oPxOw2xFx88ckpOvCi5y0tgPz9SCiOKicL0cKFQa/L3lc+fbMLuhxNYa9YhAyMnMUvW8H3kNIGvB+mfqlmrV08yWFP0LzZzYmNiUi4Vsi/ACka43zwMPwuD+BefXIb8m+Aa9McF20J/Hop0synUhTbzxou2t60wU0AZNhXJQB/9w2xaQQvkCp1oL0CZpRbyJpwnJ94mf02kiqqxDYJl3dXEJFENN3SNS/JRt7Y2jha1fI5UVznu+LUVxsDZtUhWzEOa1S3K/OJp5kbf/rJEv780Fam97qRtHNYB978gxpfDe3ZyffZPJdZntCjgzXTXxXOU78j3jJ6ZAbLyaDqQXvc97Iemw4V5N57MvnkuP5x7A//+zxxd0kf687Arfslzxuidew0P3nKR7CTobju53n+etN/06H7/jtwE4Ve/x6TLlkKl5y+veyHe+87/n2ne8nnRlxvJwQrZ/wvYNA3Eq8IuaLhR22WJXKzjf5bPvu5WX/Own+cOP3cX6/Y7VT23TPPAwgy+5W9D1VBCQznl5b4GPmY1kkZ6u4+2kJFRk71h74/ef0TyiruHciQVe8p2f4ZmfQ8SkZ/pc/PIKV+mIzgef4HDTh8JBlx5J35LNru5A/6xqUXyPijVd+Z3pAQuJY+WTht1r4dnXDMl2WmQt24PdR5dZ3PPoVwOV1eTbFdWaJRmn5NtI5PbllPE1lsPvc2xf2scd3/QQHz9zjCuTPjt7XWyjObawhc2cFBeN5s1P38VLvuohfvzwu/n3V15BqhpODi7z2390N69+1We4kB/m1a/9BMc7G0xsxtOTNT75m7eKyPX6EQtZxcJhIavudQ+yPeuy88l1Br4Z2jsigi+nZRMIAtLldEJPlyyaCYfNMJ6D4A7jKZpxBBvHyr4RcwpWHqR1mvEFr/B9W8TepopghZ5OnbefU7EoskZHcabyglNdhVCjtpAPxXhETPwGDX8Gsa1sRMpRiumqZroOw2ed7MS4yPEVj+d2cw0uMvMFekC9RPSIF1zJ5m5TJXZ1QwnM2XvhYQbv/RycOUv5ijsollTcfEwlwrHJekK2M2Dvmtyn8EldqSwc/tMpelqLa4xSqI4hVbD0pCBfyaghJC12L4q7yvB0xWR/ItSJsZwD5++78UFFNTBUPSm8Fp6VAkfHlEN5/d1rMsaHYN+n6ogsVn3DbEXTP1dLJkCmI9812xUKTLBfk2Mqz+n8NRPDthqH9dz/q2hITXt8w/lUc2JT44tUvDe2M4pmWKMKgykUk+srMA5XalSthM5iHDTy7+4FTbEslnWq9k4tKXFTDwWJqeTPfICSTYSC0gT0vWm56tLw+aJdyc+Xw7ZYrAa+mdVgB3JeQ8CSqqEeiG2tM7K26FJ+P/idNx1wVdtAzFb9PWbBdlp3mVBYa38MwzoY4uNBirhk2lAsJ3S2pGiu+irOncUHPTTSoEw7VQwC2GKxvRVMRURp4zSsEgHt6EDiJ2ma0SH5WXxxXHflczsN0xz0JfER3L1W0WRGxP9jSJL2vVc96bADSKAacTwKCsGADs9PbcI1BG2BaxMVBbFBSKkrJzS7TJ4vrG3Kin+3UJi0GB94q8W4BjoRvUsx7RgfdvQutcV0+Dva3Pqv6z4xTM4UYDzNT1dyr89hCODEYavqEul8YWqgXEtbKocyrXB+GiO6BBcbs51rRRgfkOtsR86vmYmzVqAiNalMQ7sbjfc1D/euHO66035+uVVVpDEGGlTg0gfw4uA9rXg0HAO5n2VdLvuK8qAsEslcTkA5kAYiUuYArDT/1sB4v2Hp8YJkIsmvNpMn3j75BV0C/rV4fEGfoW/4L/+I7/yWe1nvjNh/xwXOXVxitzT8m+Pv5XJjeO0D38LP3PzbfHxyB//90oMM9IB9Bp76pv8AwLV/8Pe4fLELDtaecIwOS7qaXa7IFwqaWtO/t8N7/+nPsqr7vGea8L6dF7BzPeycXIZvvTu6KgTUouk4+mc8MjOGfNd61wZH7R1Bkqlw1XEwukZSQ7NtzfihFT5jGpZ4nDyraWpY/XBGOYTeZUE9Q/dt9VzYAcgGZNsCXXuO+nS/vL9sVzbWgOarxZLegx2a125Sn1sg30yi1WM6ludYfEzsH0MjUD09QH/go6hvvlNeT7WLULKnOftqi545PvTI9TA1bPRTvu8FH+aXPvRKEt3QOyOowHhBcfnZFcZFxq/17uQd738J/TOK5uU7JCPF+95/O8decZr7Ll7DHz38Ajg8Jf9sj+lx8ZFvLndR+xxlmnDl4TW6PchNTf8s7Nzo0Acn1OOM/gUDTUvhaDLFW3/nlZGT/MOHKvLFAvf4gIWadgw8V8DKuPzqcXgcXVquWtwD4g6ysYT/a3KxaHMeaQ+FzbzwU4p+hTMt31xXV2/MgZIyH3QU+OaC8EAUdZWOzmZb2AfXhmzUNhKBsw+C6kXUyb83myrKoY6C1jDiDY4w48NCZUnGDXtfeQu93/kY2cOnya6/wdONPL0gk2CVyYGMzlbDzrVJ3HAPfHjbI9JiJ6ecI9maoGc5LjM0uUSRyzGyqFqQvNmKobMpwU2dTeuRbxUbGl0Lell3YHxAwr/CBEk3guYOzzj654VeUue+wHKKbFcKmXzXevcIcWqo+kbcW3RLcxAxnIruOcJDVTESPSC1YeStCwmHipoC31T92WlIEPtWfYVKHE5ZbO5wjUKnVlb+xkDXordS7EoF2jG5xqEnQnGLUzdHTOGM574m8ofnz7tMNfzPaUHA563v6i6RZhXWNF1CGp6jEVBCV1KUhwlNMiJOhqb7WjQ95E8EtDcU3sp5JN83NZH7XoWCkSjqi4LQqYVGkpHrribbbfz6ZJiuykTGOFknA2ASCtfZsvbTK0ex3N43ci9D/4KN/uHBwzwgr3VXRVqRNUAitMbgYGMKmB2sUaWCQU0zTij2iS2jM46FRxKvT5FAqt55Q3fD+qa95YTLVEiuF7Hv8/SUJRFm62bu+HmdQKBGmNIKwh8copyTpc4H49SdljmrbBCgtkW0rqwvlOVaNoX4iAcHkuBWsnWj0CWDRipYhSYzoa4Fa8S61zokzVNWYgJzQ7vWhTXSU3tiMNvUtc4xWi5gZaFc9v8uFcoqxkccNrfoQuMSsSTWlZgKJFPYeBGkW5pqaEn3NM74vIENn+iZyOdOJ9IdhtCnJhM9gqQ3E0W+VocJgZ+kZ/K7unJ0Skc2lmMgGgl5HnEgchSLPgXan0eLI9sTsK1YCSR+WYtsosj2ap6Ljy+GGbWPL+gifXAG/vMHX8YHvv5n4QBcc9uQjxU1d+UJZ5uajctDXnmH4878IS42FQPd4Wyzx8vf+T/Se9agb5liBiX1xS5Oi3hSNVCdzaiGGVkBn/rRXwBEkZSqhkf+7i8AcF9R8R1v/0HSHRX5qOWyJd3W7F5nMTNFMlbsntDoBvY6bXx876Lnayaw9JjcgKVXvV/ZHLIE7G32oG+ZrUrXXSwpUDry92xKHN22bgby78n+YMElm1r3shTmZgb7PlHw1Hdrrvslx+U7YFpkDB9LxKVhi2grBoImBZGqiMDkprjxljM884Fj7F1rJTDFj6vrISQTRTIsyB4YMj2g+dV3vxq3WvORT9xIP5VCabA6YbzVZbE349fueylqtWL5+Ve4vDvAvGCH5MOL7OuOuGPlLL99cZEfuv393H/8OC9aPMWlcoG3PvxC/rubPsYvfeZlvPiuxxhVGTcsXOL3XryP60+c59X7HgXgN1ZfTH3fkggQpyqiiwdfdQaAUw8dYnD/QNA5z4VOx96jGKIVo4wdXaRP1LnChOLLb4JhQwxj3lDcC80Bqp6Om1C4DsIoNKlcdBYIhVvd04SKaj4BUdIEW9TIpmBKhdPh/cn3q56iGggdIQRr1D5xMDxCsTlfREY6CPIcIhp1FAtGNpra+/U6OPixmjrXnHtFRroDC0cOU585y8qbrmAGA1S/x+QFx9i5NsWUmiaF2UpCsQy984KAn//SJZSF1c8WZJdHuDyVjbishYER6DbWUS6ljPclEaUP3vP5ltgx1gPDeH/C8HTjJxyaciCIdO/yHE+3dpQLhnIoYlRdydf5ds3e0VTcmzz9RQ4U3mtbXEGM98gPDiLKtU1QKMzlmphDDbUgd3VHklbDQ8S/LSc4hlZ5BLHqIraq4ee1Y/jJDuUQyhWH7dXYtRJmBvIGMkt6MUE1MDgnGoJiSUXUGHnbXmfhj2NBRJlDIR8KvnQM3SsNo8MmFlXGi02LJUU6bteMZCqIerAIDChuUrQcdJsRxaphDQzC1YCSz7uNtE4c7STAWV/8qRZ5V1bQYhyRwlV3RDxZdySjwoWsCR+ME+g71qhId6j6Kk4d2ymVUM6SovUUHx321EP/POVC63JTDeWz5JvynMkIzDQhmcHkoAarsEenmGe7VIcL9m61mM0UM5Gmd3xEEG3wgIoHA4KXetAUgLy3/jkbufqBgjF/j8tnFRQ5G8mFVuftJE+cpa62Dm06/pjAVZzsMC0M9Ld5/3JroOk6WWszf201khchzYRuLRTr9jxHi1OvsxHth4vXQjlUdLacByPa9xTu/7qjyHfsVfa54GksJehS0Bbbb1CFxswU9VCK9XLJYvakQEc5bOZoOpbEGaYHHb0roemx8Xi4xMX3INQzP4ltJLciuLQ0qSMbucjdv9rKkggo1N2WUiMe8Z6q1ZG/Z6swOOskR+B4Tu+S6JmcUfQuzSnKv/h4Tj6+oIv0JoOlhzX912lWdf+q/ztshrzv1f8WGDJzDb+6dRdvfecryLZh4DfE3qe63pXAxYLLJhLXnXjh0kt+7AeYriu4a4c/fNF/4Mb/9D/Red42f/TCX+Lhb30jN73v+0hOd9AV5JeFx3jgxstsfny/R5tk8TKVIEhN7ti5Vvu0Uo8ITYl+6GwJcXx9/w5XnlyVTdMvnuMDKhaNQdgV3C/KITQeLcx2YbYmgSLdK4LqjG8uObB/m+Vv2WHxrdfz5DcbOpdBf3YQfdeFs+xdIfDWitv+9fxa8Pivvoj9b0q54+8/zH0fuol64NGHBtygRh+e0Xxugeu+8Qk++cgxlj+d8pqvupe/MXiMH/zQd0GhsZ9bhIMlO5MOOmv4khNnuDQZUMxS/uEd76N/c8Hlesh/+MCrOXnzOf7joy/jhrXLnJqtce/lY7hzXT559BiH1rdZzUd89uJ1rHXGqLHhpoVLPDbezycuHKVuNNNrK5gY3Jb4svfOwYUPHGG2z3LopkuczdfILicMzlrCSHme9mET5d0MVBSB2lSK+arvUZKpbELRZQDZFI2VoIvOlizUpnR+DK0899Uj0xk47XnpHqkNG1Io8LRHwEIYR+DG6sbzOZu50bODwTlJ8AtUFVWD8hunaqSANYX3T/ej5CDcBEHtk0JEo2Zm/XuTY6N8Y4KCBItTmoXTlvrM2fbeHI1gNCL7g0sMvuFOEQ7m0iiZEP/eqHjdu0TRDDrooqIZdHCppu6nTNcTObZKCodoB6dhsl/Tv2CvSmodPluKcNQjctlIpgShuG8y6G6IYKvqG+FIzxo6pQhJ646KqbjJzAqK7oWi5VCOWTnQfgNVmNx5GpAcDzMTpF80I4EXrSMPOIpWtXixi0OHFPDhfOL5v9YInUgNhGjrao3eTmkymB2pUd1aqCeVFH6gcLWmXJJ7cnRYR4Q6WMYGrjOA9fd70M4EZNp6X/Ygmh4dMi3SHaZLJWiPaAdRY9VvfzfalWoBEwINyAnWIE4wWZtyGuwbVdkW47ps17662zawLm0/i5lJIbt7XAod0UBIQwh+XfN0lWLZTwonofAFZRXFAtF5yZTIWqbb4lGEu4q6aGmD+baAGOlYfibdlZ8vluWzZjseCU3FVjLflK+zLUWxKsVdtdzA1KAHFfWSQhepR6aFCmKqVjNUDuV6q/rE8DDt3WrqnnzuQK1BCVjS2QBdOvHf1nKMTWkj4rtzjaGzKfqNcP0GgCCK2ucTxZXCIcFcybR1y6lzadgmh8U4Iegfkmn7/iTF1cVp4PwjmQtq0p5/DqIxKReFEhRcsGRiJudqtqooloTilo7lvAQ+97wbjGqAFMkOSN1VWg29pyUluvJuMxZ0rbAdS7KnpeFLoezrGBClrFDZwppTLRAbxWTm2kaoE6xZvSA+amSIwXZNrnxoVhP3n9DgBK1TOhKgp3fJeR2HNxBIFM/JEt1dfdn8Vb7OX4fHF3SRbo2MB1/2ph/mJ77jrRxItjEkjKxwlbdtyoVmxEAl/PZvvYK0FrEReDQnBwpadFN7rpv2PEQ/du2fc/C7C3zr236Y3hqM9RIHXiJOFmmnpskch198jgsfOkw9cPyrG36bv3X++8jOZsxWkcWjK+PNfDMkrLUjwpCSh/Z2UMDlywvkm5rJQcg3iItViAMP3OUwWs63BYEJ7i3JRGFm0hjUPcfBA1uUv72f08U61VFId3VEMaxH2W3w4/XuL2bmvc89IgSQnc24eHfDyncucPLcJ3jsZ17A+osvYJ1iUqas/0wX9aF7uPjNd/G8Dz3F4//oOt7x23+DI9+5ST4suPbEBo9+8hhoKMsEVxlODq7w2XtOkhSKh284yHo24m3veAU//q2/w29deCEvOfQMN/Qv8rHNa/mbhz/Lmz51gM+cP0Sx1WFvljM5P+BD05Ncd+sZ3vmRF5AemnDHobN85o9uZHETRndPqWwOCnZvEGpO55JmfCKDRkmEubcrE7vFwO1u0TbVIIl6jfBZq76nVngXgTC1aMVbLSQ9PijFUrkkXy897gievoGPLitb2KDaoi8UeqGwAuLrBkGX9mLXnROaxadtLOjn7ciC+0JA1kzpmKybGEkuVILQEMhmWntEqBpoiaH2ThHBj9x6FF45WPr0Bn/R4NXMpCCOQuc5pDg4plQDw3Q9pX+uAMTibfd4Jt7ZvjDJdkQk5hR0Nxp0A7vXJMyWczqbDeMDBlNC77IEAtVd7dcJQa/6FxtxbkmE4tLdkEZmtpaJiLRy9C5ZZiuackkCl2Qzd8xWJOxIqDSe9lB6MXftYlGtgl+zp0LMx5LbVFENFIl3BJpfx/AopUwzBHEL2gSdyMm3QHJkzDiMvQFnlVTLvRqsQmUNrlHUfVkLmg4oz/Vu1Nx15Nrr2npf8LpHi2L7IhCIYsqgJcBCs9BO2FJv9ZhM2vTQiHz7orEV5sm/q0HbCASEGNrXTiZXI7VGe9Tc35dB+ImT9UlXLcjQ3jvt+wZP5alFl2OK1i0nUDbSkefGK/lMyUwKoiaV49nkxHj4GH7kvzYl1AaqBSt0qksicM+25LVDMzK5scTVCiYJqlvDNCHJpNSqDjvSUcbwmTYfIduTgKfgm57vtK4lEFBeIjprA+3Cf+66q9g4bChWHfkVuHBngi7ks1Z9Ka4Xn9Jku5ZLLxK9xeITUqjKeZSAtHTi7UlrhbVQLjl2jaJcEvTZDStZE3ZlMTQzv4/ILUTq7x3VOLm0fXUp4Ia/RzyVJ1DhUKKpMaUUvKOjiqXHrbynoaKz4ci3YLquYsaDcoB28Tmsf6105D3rUxevQwkJk+mgqhV2scY6g+02mLEh3Q10Rhe59tJItBMVFUTjOjSi6qqsAecpOrIOuhhMFixZZSquqIwB55jsE2tcObcBMBFRebDCrfqKciGRtWfH/AWr7hcfz5XHF3SRnk7k5lcWUlXzyo5jy07o6Q4aTUPJATOgcJUE/ozl95zyRe9U/jaFFKRoKPstXzg4fQCx0OlfsJhCc/JP/g5ukkCj6J7Y4/XHPsQ/O/c6nviKX0aj+dG73s1rB49z97t+iOVPJxQrimIpxJb7DcPzv0V0IqhiNfS71Sih6Qo3LhvB1IeKBBuytuiSr+d5nk1OHDNPjlhueuNlnvjnA7qv3WLriSXyLf/7Wet/XA0gm3NKIJn7f7/J9S4IYq8Lw6P/wyHc+irqsqL69f30LlRsvzjj9JdD9Y0vBeW4eOdJrv0n9/DYL7+YX/rF15Lk8MTyEH3tGFsk3HLoAo9fWeN3PvgSXvaKz/Ho1j6eGa/wh594Pgu3b5GqmhctP8s9V05worvBo5f2cXp3iWQKeV5SqJyiTNl3YhOjLac3l1m5bpPxx9d4MDmAuWMHk9a4x1ZwyxWmU7M4nLJxYYHk6ZSti0P6p8W+bnxQUN6VR5qWM067UIZCDMAZLfSThtaVIGvFp3r+ukGurXTi6F7xRYNpEaPAY6+6vihr2uIM1yKQwom0MXAn2B8qhXC5raN/QTagGH2twmfw9IZMIsjDyDydtlaLwTPYGhm/gugpYqiGbRuG8HBarPVsApPjS5S338XgbR/7c/dpMm3IRkkMdxGXCbFHzHc1xaJ8pmy3YeN5ki46PNPQu9QwOmRikFcygd7FmmTSsH19B1OIFaApxMfaesR254RUf/0LlnTiw6Gc+FinExsjxK0RhxdlVaTABBs4Qe/FJ108nRWNg2xbRKzFQkb/XEW5kEiBRFtgxtE2RNu4JpciIhTn9ZywTRx9QqiVRxV9sWVTaHYz9KBCKUddGnRiJbjIOLS22EriwdVuQjLW2MxFIXn0Aq+IlJarUih90Tu/poRHPWjpJJEL7nni80FIdd4298oCpqXkBc678tQUVbXNY+CjNx0pGq0RlDzAg6GBDeuZmdEGLxl/X+1JAWyN/F7mQYoQ/JWOfJORQD1syK/I/V4uin7IJY7uBS3TzHBMTNtMNJmKTcp8I2C13xLCMdbyvjqXNLNDTeTKiyZB1k1TgGsUyU5CsyxNFb2acpLiak16JY2FdlgX0pGn3SkIVIl4Y4fJggGNcMTnkWpdS1Ob7cHgtJgXdC/7PaID1c1T6nHC5X0KOha9oWmGDelELgKx/RNkvbNt4xRBWUf/bCJ+3xvK0yxTyqEi8YFnTSbraWiUmlwxW5WfD9qGYFO5t6hASzJrELY7KzSZgKo3mfaNhyDPkuqp2DvhGD4jrj44mXbF+zAXSgu0xzQZ67iGOeMbj1KJ3sMBCzV6J0HVEtqV7TZ+LVVQt4h/WFfnMwjC6wSalikciadxBTAigBvZyLu/ZMTk0SbXZLuO2aoAbLsnJLelsyXe+2HSEF9biQ3oc/HxeeGk/5W/wv8zjy/oIj36hCrHv/zX382PrwlCnnhepSnnfrbX8viCIoTSOgABAABJREFUc0HdJaZ4Bk5e01HQyEIRrJ6aNCwsUkgnhWPtvTmjo4rv/rY/4UdXH6NwFXe96t+iEceQV/YeZ9sqXnjr07zoZaf4pfd8uXAXl4WGYgpBMqZaFi5dy9f9M7ICuMxRY1EdxbTWYAUtL/1oNgp6/E2rK1nQ664vAKeC+GaHx1x6xX6qrRq33WfhtKDj6Vg+d4jVTkZzm7dH6IPop/HFepOKpVrdER/15nKHJoetG2H7+ozyiLdFTC3dCyJeq7/iRei8oVhKqQaOu1/+OXarDgupTDtefOg0J6+7zG7T5UuvfZTNesCj02N8zbHPUbmEJ8brnN5Y5rfe9Sp0Drd/wwPcv7NK9rvL7AOSaZ+6M6DIFV0NWzcOuO3Ln+SBZw7jak1xMSObwB13PcnHnjzBzsMrLD2reN53PExtDSdfdJm3ffaFLH+ow+SA49zLhLMYxt8LT7uIoAZ0vQ5iUSXFN8gG3NluoiPDfEGba7+J+HMWuIhh8wpodKAyJWPvzRuQFB9l7RJF1dWxEM/2bBSW2UxR14LYhyI7OEYEakZnw4+6Vdt4zBdqsVCEKGQL10Tgo4Z0vUDFMZUj21VcfHHKiV8/h7vlBpqHHrvqPtV/+knWzp2EqobplO1XXSuivkShywabGHZOGBZPNTH5se4qupdrhmccupYExt7FKvK5Vx4ac+X2vqTmVkqu6T0Ynm6YrhnRAfQVdcdz6SuYrmnqsaJ7pWG2LCmgTa4xhaVcMqQj4Xl2L1XUPfHDDnzzwdmSJtU0XR0tNa/clpFMoX/RRtqKIOw2JpaGdcimDpcp9Ljd6J0RByCbQjaycyFSYv0GonNxCpKnu5QrDfRrKdJrjZtHxQsRvFUHSzqnssh5jQj1XHM1X1QwNymygRPu11YzCounL7j1HJLufzbmAvmCXc0V/ekI6vWWthJeIzgjxbF+0Rb02hfgNpPrwOwSqYHiEQ2TfSpSSoIwOfE5EZF3H14vIU4Hsg0TUXNdQd13DJ7W8V6vu3OUHwONB1JUA93LInbEtVaNyVTWSWu8daCW6awZa8YnGvpPGUKoWAiXqro16nKK2Uxo1kvyp3Py7bbg0P4979wk+qbympL9701FV5K2nuk2kX0uBhM1xJTUPy9A9s+bhWmZiKMHH+1SrMDshCRZuX0FqlFM1hOGp20EEnZucOyeELogCtJdWRvyLXnfMs0T2mi4VnTjMCO4crug2MNTjr53PiuHobCXn1141v4Zv3O5sJpUxSans2XpbMvnma5qnzcB6kl5rvF+ExsCM1E0PevXNpmcNdpRp56uUl+9ttmOk/M0FvqbXapxW4JMVQNN1VVkozbYSq4h5R1cVHREMzMfRGRDcJOfgrq2mLcGEu8IZr2DU3CbCc1nZ9MxOqTon22nR7GZn6thNA43pzH64uO5+fjCLtKtFAmiHnf0z+ILGGKwRJOruBGYsrUtTMceMdYtYq4tENK/cgmXCMiXroiiGecEFRs+6/i13/kymm/U/Mqn7uaeV/87AH528yQf2TxJoi0dU/FL7/0y3GqBbTQmb2C3S7Hsi7tSeIbGo96DU7KqppsSSlItWuqeo3teRq6m8Kj3bosyNVnrwx6oKsrzBsfbHQ6cq9jelXh1M5MwpbjJ+s288WEpppCv675j6WFxLdi93lJWCps5eud0tBcLqYF1H6pFRz4suObYBTYmfXZHq0yvK5geyLjub32Ux37pxSx9NuWBX7+Fr/ree3hh/xQHkh0+OzvCzKXct3WMx/fWGVUZbrXg7HSJ6zoXuXFwkfPLC2zaAebObT5x4WhswuquimhM3ZPPu/yg4txnrsW9Ujq0wS2bHBzu8sTWGn/z5gd5d/I8ZpMen3zPzey/+xx3Lz9Jt1+we0KSR3/wNX/I0Ex51+XnkyjLI79zA9luSzlRcwl80KJ/giobzEyuyZAmKmI0Hd0IoEVaAl/RVA7lo88D9zdE1YcCoxzq+LtS+LkYqqEa523ALDbVQm9I5foNyGigVjEfpBP8vmmR1OCXHa778FnD5iRFWisyxcHik5aNWzWnX3eI9c+UJA9Bsr5GfflKPE7140/Gfw/eegn38juo+gnjg0mMmt87YqJ16XRNU3dSlh6f0rlcYHNDSCVtcs10Xxbft/NWg/mWI9tt6GxWYB3VYho5tt3LFfmuZrJmKIeabM9S58K7b3LhjNddTbrX4FI5X90rjT++UCylZDs1etRgFxNQsPZgRTk0mNK24Ssm0ASk0LDGFzIBWPLnWzdBiyDfKwchvKkNcsE58k2NajTTAw10GpRy2ErDxKAWpNpeuF+u3Z07SpSxFNfNpIivNMm2oXOl9cEPjiNBZAhtMavm6YDephFaPrgNxS9E9w2crDnprp/WJGH9FdDBzNqfUY2ssUH4C0TuuUuITbAuhcLSdGDhmTpG09tMCaq72fqyWyP5EOViS9dDSdR84NeH+63uwvSQBavoXFF0LssUaLZPcg9658ThJRv5e2zsYoFU9eUNi/OG99juENONA3VNaIKKfMOIYDaRKafTjmLdkT7VpTxUodKG4cKMkpyq32qLqo4cs+WHJPypONgisKG5D44owVlIly5SKOb9+dXc/eyU/DsAAnVXsXNrjR4blu7NKZegWHEsPaKYHIBL3zajmiYwSsj2jSlHGRiH0g51tGK63WF23KG3U5YeDpMfuWaCHqAcKoanYHKwPS/WyDodAIndk47h6ZZGFil+oTH0j2JREkNVI0Jm/DWY78p9EpNFFyTRdbJfM7pG1rDVBwI9UagobUCdL3p9KJbzDRATSQ5Ppobpiqy72Z6I+1tRroue+LNVxeCcNBchOK/pyHEuh9JQJlNHZ7PdOJqOoupKTRGyK6xvqJKpHBNdw+4xTTqas3a1ak43opgsPReRdNVehH+Vjy+6uzz3H6YEwii0gGIxBIF4IVYQDyXt2Dl05mE8a33xZRNB4dPS+bRJBJYIBZW/KQKSEQqWlUcsv/WfXsU1X32OU3WHn774YgC2ii6v3v8Yj4/3wVpBmjdU53o0S47unmwY+baMs4plGB+r6ZxN2P9x4eQIFcfRuaCpB57rCa29VeKT1Xykc92RQltX4LK2ANh/aJvtk+v0bthm8tgieM5cMpOfma0RC8Oo5i9h+RnYPS6LV7orq0djpRnobliqviQFpruCYBbHK249cIFRldFNK7h1g71xB7Mru74ZG3QFd/7dT/L2d97Nx+46zvOWLpAqy639Mzx05iB3njjFemdEc1Aza1Iap3l47yCnHjnIYg3FZ5aou461vfa84MS2SjXetzkTlL//uZxsD8rhCse+5RRb0x5/9IcvIpuCftEO6iOLnP7cAf7tY/sxU83gPHzJdz7E/nSHoZ7y2JV1tHJSNGpBRgL9RBIZQzOn/OYjyLY1LWUgUmVC7HXmN1Ql3wvhKqA857GN8Q4Jc5HPWEgR2cz574pjzJ9B1SBuJKEQC5OASFnxnyMUXNBu+AGGa/nyLgrBQhEVHEwCv916BLhYgSu3ZQzW7mLpw6f/wvs22beO256SbMNsbVmOY9pOdUT4asUW0mhU00hjUFtcZpjuSyV8Kmsj47FSIGzdkJFMHYOzFelujc00TS4JiunY81u7iny7AS1oXfC8luRhabTqnlioZTsVNtXYTFMuCP0ljOBV48i3a6qB5x3NDWBtqgVRT4JnvNeidITfK8EwXkichevF+2R7oZlCitViGUgclFLIu0qh/Abl9lJ2bmzonjOo3QS3WMvbKDWd8wnFwRq3lXgBnzTf+aZqhZwefYzrYgPKc8St54HrUv423vI1nKPoIOWLbOXPgWrwBUiLlsaCyxGRbuedXWLo07T92XLRI88DQzr2I1Gl43RI7EF9E8BcAxLW/OBWV4d1QtZHGkXvnL9uvSgz21HMcsfkSEN+2Uhy6hURPAYBrCkC1cWH8HS9VW3Pfy7/eQL4MzlsWXpEgxbE32lFek5Rd6GsFU5rJk8sojpQDxyz/Q4zES63ruT5TQmqEJFyuE6jcBpiImVsepQCJ2LveRAg2nuG4zxzMAU102Rbcj0mUylklXX0Lijcpb6Ihq9xVEWC6TQ00wS9lVBkGSq39J5K5bPNnXuQ5NwmVxSLYgG88GRoZMJ60X6GdCTXe3Sa8cBBSPsNmp8wSQjBYfGc+4PvjPDliwVxgqkG7XVhChdBlkBLkoYuABTt1CtcZ7MVRdUj6iYmhAmmnxg5ySIwpUwCnPLWtIWN13LVU/QuWy96dV6srCkWxFo1G8m6E+hjpEKvCu/DpoKq171AjfPXvgn3nqM7bdecLz6em48v6CI9FMthIU6mjkApMBU0DlHJFz7AwRct2nMdo1cwLZoUPE2hLT4CYqS9l3Y6sRF5Kxc0nQ3H5DcO8vde+z383Rs/ymd2j7Lx3kO878vh4s6QG49c5FVrj/H+9Rt48sPH2buponM2ZbYmN2A1tKiZ906+90FPNxDxp82h7joGzyi2bxZP9UBJma2olkuctCNf1YB2MLmmoR53GX71Fba2+ySFd4uoYfeER7uGjv6zCjVurcmaDmzeCm59httLwTj0yNC9qBi/eoTtlPDHK6jrRtjPDqRY6lY8dOEAeVYxGnfodUsOruzw7IEOz/zzu+k/C5MD8J4/vQOVOa687xAfu7vD9kafQy/aYm15xH3PXkM9S3jVzY/y8bPHuPdz16Knmv4ZTe0DLnrnfXiMhu6mjQKyYlU2t3yzRdRK39x85Oy1jJ5dQOeOoy89w/mdBW76hsd5enuFQV7wzNP7qPOEr1/9JL967mX8T0f/AP3BxSi+1J6bGhT6NoFyn6K7EZxVaK3PXIiSl0LbJYLW6tKPcH3wiriPBH5vcAhx1D0d/dXVnB+i7rWx16EgyXelYDRT797QN0JZ0fOFT9tM2GhPJr8/z0fHN6XWCyJDImnYyOpck8xkw2k6GhpxKenWwYUm8d7kjqX3PUl9eaO9T++6nWoxo/vJpyHPcYt9dp63RDq2LD42YvEx2L1uEAuLdOyRU+/TXC6KsNNqSQGt+l44tukiuh4syZSFfKvGGcV0XW5uXTm6E+vpRQanFZP9CZ3NhqbTWqaBIHZuGbqXhTM/W0mvKhyqvkFoTpa6b+I1IUWgijHnTktAVJhu4HlFwVlHWaHTBYQ2m7kodEXh7TSlyCkPlXSeySiXLWrPUC82kAiqma5PaRrN1HboXNK47YxirYFeQ7G/gVqsOLMduUbzDRUL5yA6tAYZ93vhcxjP49924H8HZxVpdLjK/jCgp6GZC1axtU8FNUVbmDvrEXXXUmGCw1Qylt8rluRPvgN1z4jDkJ8gmZmsv/m2aCKcEfAgTFWrnqLOobPtCyNf+NQzWLwoxb048RCdX9KO2PC5BOqFhrI0uMS7tMzRDMJ7Be+FHvaHgFj7hqd/WlP1PQ96KgBC3RHBpZ4Y9GZC07O4PDTyiu4lIhceBXvXOkhcdBWZJ+FGxFyH9VDFr5vQgM9NT4IGqbPd5iEMntbku45sT4rIvdqwcbtj4XFFvutwBdgjMzqdisbKB0sXZ8z2crJ+ycR1qFdnlOOMpfsyAR4yoYFM14SCpku4cmdN93RCZ7NtypKpHI/uxTlwwTue4AGAkEWg6/b+dFox2afoXXaR6hOaD5uIr7kzisEZJw43my5qP6LWh9A8tutruO7DXp+O5FoTRF/5/dVFeml43TDdMDN5P7XPQHDau1Hp9rPEoMS6fU82AVXKXpE4aeLrrq9BLJhmrpG2YhLQHVnqnsaq9rg8lx7O8Xlxd/nr0p58QRfpdUdJCp5P/KoGWhCxDriJFEM2cX5Bbh08HC0HMrhahIQ2QnHgH7FAb9rFpM412kghUyyoiDLl71nkjRe/gh9/1du5/rsu8ZZ3vIqjd5/my9Yf4bf+5Vcx/dZt9E17DD82ZHzUim/rwQoqTZI31FUPlWW46ZS6L0WZrhT9s4pyAZYfkr9DY+E0JJ7LNlv3Lgf+pt27oebQn2h6FwyP/+1FBo+mNB3YvaFBz4S/6rSif1qJpdZEFo3d6y1Ln5O4ZXslJ9sVP+AmF3eSzj0Ddm4vyfaD1o7enRvs7PY4uLzL85Yucv+lo5jEstof8+ylFa7/+x/n/P94N50Nx7Xf8BTnRwvUVrM76jB7col0ovkvv/wVTO4aU2912P8RzeOH1vmaEw/zgltP8dHd67jv8jWcP7PM4kMps1UYvaBgfXWP2e+vR5/q/hlBfSaHhTOpSyieP6XZS8mV42UvfpjaaZ7cXmP29AKfHOXsX9/FKCsCvAZ+4ue/h3QK37/839PfcsyWVHQhiHQXK4t3Z0u+HyhUUqCLmkd44kKjcEa8xq2PjJeixyNKQaSXqKu+Z0qvh/AIjyll1FoN5BdC6Erd1WL5l0iwReNdQ5KJjUFFxZLm8gsdS4/Ia8d01DrwU2UkK59ROJJ1t9VgNLmRgrIkpqjWXS0F/ZKKjjHV0HHkAw3Zu+5tXV7u/hKSUxepP/YZUqB+6e3gYPdkj2ogBdbOtUOckuK+d6mWAqxqpLjqGsrFFF1IAU4jyOrgXC2/s9WSq22mJeAj1UzXE8kVcHJu0omfMBlB1XqXG8qhplg0dK/UIrTtSGczWzLoGsaHNHU3RdcywtalvId0KtMSM2kwwGxV+MJmJiFFkTeMt7tT7bUTgqbAN8rHjFBJarCpobMlwmCnZO1SVjjpOEWxYnGpw1QKlVh0r0FpaGqDNha7VOI2OxRHKrkMRwlmVZxyyjTFFEJ3a7rtvR4C0JSWY6OKtrkDojhN19K4RyeU1Nu0zv2sM0ROdHiO4FrThFCb1KPyuXw/eG3HIittHWbCdGF0SFEsJQzOiPd9uWDobNSRTtTZEgFe8MuO9EQ/lQiBRUGYH9ywrJ802kSOSboL5ZqlrhXds4buZSnC0zEtd9k7c4SgHod85nAcmTtWiXe8Ufip59jbf17wLlIpsK0ZH/EjWdVSMdKRfCvbVkx7qp0GhPPiiEVlmIpedc4a5z+bP7CuXcNmK1oSh5EmZrommph04ihWG9Jdw84dFfvfL9anq+/poKsOuycUxTU1tiOTmmI358CHDU71QcHuMdh72Qx3rku2o8i3oDxc0l2csfihBUwhlBGbIOuq88YPk6vFmK1eQ+6XMF0MDkniDS4XZpgGggfQrNdhjeR1+udde+49GBLur0gF8seFcExprwtoKVWBVjk/lZj38q97V1Mv5psqUwF+rQ33RLbXovsiTpZpSbAsbXxmR9NRMklz4b5VpBMVzQL+QkutLz6eM48v6CI927XontwJxaLn7HouNkC5oCJnsO7A3h0Ftxw7x+OX18k+NhCPW4ukzTnZNGLMe9MuHqYSS6dyqFvBiW0XzsFZSzkU5GTpQcP/evGbKI6VuAMVT57ez3/6g6OMXtawACz1p3S+apfRs/sw2wk2b+gNC5yD+tiYZ//xHRz5F/dIMTiV8aiZANo7qzRQ9vzmMecughXaSbkAk0MOOg2zv71D3pmSby6Rb6fUPUj3jEdwBW3StkWGAldwchDqBYsqFcW6RVWK7nnNbJ9jehAO/HHCpTstnOlzy4su8FhtaKzmcjHg8HCHvTzn6Wf2sXqfwGtrny3ZvDnjkfedJJnC9LYp3X7JaNBgxppyEX7w+R/geflZXt//Hm7KCj584VrOLy2g/Up39y1P8ODDN5Puwp3XPclnLh1icsIxPBWqHlh4Ss7X63/w9/lX934VnUe6qC58/V2f5dfufSm/9mW/zNm1ZbZP9PjZT34FO5MOdx4/xfkPHgFkTKsa8bbXtXBTTekiIhgQ1RC4oawXSPnkOGnkrHdI0X7jkBU92OuFDdYZRVK5q6zI5q3VQphJQGXqTuDQ+CbASZS3cqALSzUUnnTdVahMRaQ2HTuWP6cj1WK62vJHQZqZfFuEi+BaxCog8YVF1a3Assk16aiR6s3ZNjBorMjeda/8zk3Xw94YO6sobj7E3lceZ3haKAvJqJJiR/mCqZTirVxQVINUqCpnKpJpg6qELqJLmO5LxVVlqFl4tsIUjfBYywaXaKbrqacJKMpFFcXhQZCta1h+pIr2iYmRc7F3JAWFT3i0QrnIgkWfcHvqjkM3IlZLfehUsZwIglZakqmlHJrIqw0opiSVtqmMQTwWON64VgMy3Sfahe4V53nbKtoTNjm4XoNKHE2ngUrjEotOGprSABpXGuqeIz+TilvQoQLOiVNOUkOxask3dESqxSnDrx2NCOgjxzrSJ+QYNl7nEhC9UBAFuoeqoVkiWroG2lJ4nmB3F4KEAooYAo+ChiIUR854pyqPSlcDmK4bVC3To6ajY5jUbFnRu2IpUxWtUVHyOYwHFyTQSL6uhnLck6m832pBaI5Ow/DRBFOGc+HDiVJ5jrCPRHDHCzGbrvw+pi3Ywj2NRiwAgzh/Jv8nYmc5DsMnNTYn+rdXfY80zwR0SfcEfg3Pe5XDRyN+6qoG5StMZWH3qKZYgdXPeQ51KBanXqvlnaQku0HO4fiwIts2OAXDB1OZElh/bAz0zzqGzxjAUCwqbwnZXhOLTzvq8z2cEtrbzgtL+otTxhf7lIdDwrY0A51tF11zZkuKrheKKus492rZdw5+SBagq0Swc8i1+OS33PWgs5DGxCPzPpNCXLRk6ma0B0n8uuz81DGd+H3fT6WjO49vVG0Ke8cVS486dk7I2r/4lIvXuPMNmgCDRIvcdOKidWJYF1BE3VJsMhpp6sM5DkL+ZGYZH9LoEoZnbHuP+H3B1s9RPPnz8baeox/9zz6+oIt0mwuSHse2fnylrCOZQYWKXG40DD+T88il4wxPtfZnwZ7LWcj8DRU8jXGeixxeLwXbaVXWQYQ6OqgFaVLQ2RSbq7qXcsNLnuHUe48zuq3gtuNnKa3h1AeP0b0Iiwls31ahrGK83eVbv+R+vmnpfr515w0k110rHOv9Ncm2oViD4dMyITAFqJ5029leu0DlWzIeroaQ7SpmnYQvff4TvPup55HdO6BclM+b7bXIXl60vOhiyfPcOpZyCXShSHY15UqDW6gpypTOZeVRE0Xnmh32L+zxiceOobdS9nLLebOGLhTpjmbtdMsL3Tua0eTSREwOOW48cpETgw3uz6/hq178ML/7llfw0OgwXz94iLXVPbamPcrGsFt2SLRlUqZYpzn+9U/x2Aeu5eN/couMqP1G13T8VEEJj/aNb/46uL6isyGIxdsvvYKv/s5P8l827uQDz1zPzfsvcvs1Z3no/AHe+ScvZrCJF8MqHxIl5zyZeW6kp1H0z1fYTDHen4h9YePm0iXxgj+/KYaCpZIxaSiSQ9EmdAgVuZfhWqtzxdZNmuEpF1FAU/gAHE//CKLPYtH4Qsq0CJEF54OCmlxeK9sTy7KAdoaCqMm9+LdoNzVTShEqiJLQS7T2EJNWfhMMLgcq3hfKQXLwAPX5C1RrfdyBIenm1NNF5BrAQTpJ6V2q2bk2bZsW/AY3dfQu1tQ9Q9PRlENDvttgU8V0RVEtSPz51vUpS08rzKShWMuZLclxmK4qMq9XsAmsPFWzfW2CmQXhV03dlyXTVE4K6wTSkdCWpqsJlW+AwzEKhXXjfZhBM1sSrnHdEV1JmkvBmE4tVdc3/C4gZa2TS9BQpGMbm7xIJTGB9+zizwPYrkVph+lIZdaUBjJxd2lAfNI9rFov1ZgixcygmiTY1HknC4VyjukRoR2EIrs90cSCPH7msl1bXNK+R/Bc9eBm4m0vhZ7nz2UFddquMzHcyLWvGf3RGyl0A1od/MvFIcSj7Z6TnG9bEfkjqbdVX9KOcS1VLx3L89cdWdNA/t8lUpcFDruyUqBnOzA+5Ej3xCUknA9TCOChK+/44t+fRj5XsSr8flVDirqKNpntEJ8LfHFWt2LPxB9Lq70TWQGzFY/o74lVIpthj2vfbyjQgzbEeS99m/pJkS/cRics2baO6DB4ZH537pwrYorpdM1ncPiCu+lA/6KLuqbQmIXXQcn71qVDB4ykcYBQPZJzMDibsnsswyw7emcV46OO2brD7J9ST1OSixnDZ3xR69e/vRPyAc3M+OtBPkDc3z3lxJSWcsFErUz4fMoKrVUm4u1aGWxrk7lMlDBRD0BL3ZUp4jwnPKz92jeKONi9Vq6TJofJutBpwvqF8poS2vcVk3fDobftPacsaOuuml7JPaXCLQ3A2gNC9ao7yu9JoGuZ0tVfRNKf848v6CJdVt2ACgpKUC60iY7KL/JB4NTk0D8jRelsHyw8JQtPOvaohPHoni8YgvWcjAMtvYvOUwDkJgqLua4dSSFepulIRojOwMNPH0Ltszz1Fb/Cyd/6flY/rVhshIdqFQweT5kctqha8TsP38FvuzvYf2ib2YkViTKuFE3HkW1pEUl5lKt7WYrxENM+PiAFRLXgk+Bm8BWv/RR//MxN8NCQwNE3U9i7Rjxz5XjB9g2ex+0txbKLCfk2jI5Z6gVLumuojHgKLz7tWHzXQ6hOzrP2Bi4mi2ReOGW2TESMOpuyYK4+KDvi1m0WfWBKPc7IFgo+99gRkhstNy5f4vUrH+OGv3ee923fzKPVMm++9c38xOmvo7QG6xTP7i4xnWU8vrVGVRuhllwzxc4Shg8K/WVw2lEuKv7G93yCT105wu6f7KfzjBSHl17s+Aev/iMOpdt8enwNf+/mj7Ce7PHHm7fwnTfdz/KtY37lF79WLqdg/+fH5CB2iwq5jrKRbAzdTeFmz5a1CDYDj9IjxME1B8RZJDirzAdimMLRvSKiQ+U1EGGjW3gaL1bzvEsF1dB4apb1XHfobsqLqErgnsAXLxaNv65bBC7QLQZnZLOb7G9jxutckVXCfa162gtWQ/PrYlMg3vAuCsCUFSrIZJ8UBJe+5lrW711i61hXNspjuS/QFKQwWwZQOKPjvZNvO08HkIan7hmqvgirdAnJVBw9AqUs7HazJUOnET5+14qINpl4mzzVisNMAf0LNXVP41J5nzbXIja28rpi1yjFdeLtAIMdX7YbtldpdMYH5PmzXUe+4xs4f0yqno7vLwgOha/vYsMm8eky3pYmTO7jpacbsfb0Qj+Ld6woZJZU1xrVKJxxqEx4FEneUE0TobckFtCUhyUKNMlr7Lke+aYvGrYFfQ6uJHLdALotHiPqrVr3J10KGtx4P+fIAXZtYR20EoGiEnQToYEN6Po8Ai22od7HvCamWDadtpAONMP8ohwjU3mefyn3n5k5yqGiHGpq/5nqLvQuSQruPB0iUBvC+288ZSeZQu+CXGt1V8795GiDskauv9CcpPIcQQPUvQyjHLqXVKT+BPF93ZffadK20Jrntc/WoXfeAz057F7XMDhlKBegWHIkUylqQaaDuHZdiUmueF5/oD0ElNbBoQ+CTVrueRCjm0K1wlsfwhWSQfeOKRae8pzynpgwhD0VBy6FaqBianZ3o23O5bjO5QB4V6POBjS3j9nrd1m7T6NrRdXre7qdY3REMTvcQGrpPJNJc7OT0KxWqCaJxzrYMoqfuMamMtWSJkLFfRot7693SUAQESnL/RoEmiFbQul5Qa2EjFUDFfMFXBKuP5lWVH1wiVij2hRWHnKxCWhyxfSQuKYFJF0maoqyr6N1aPDft8HpqHbehlSOdeWnPWHdULUki1Z9HRuLGMyVy8kt5zlnz6HH58Mn/a/L4wu6SG/yuYQ/LQtQ4L0lU8fosGa6X8SWnSuycE4OyA0yPOXR16ncLFVP1NadLRe772zPMVtRfgFUVEMJGSiHcnOGQs4ZEcqAjA2XXniZpsioaoPrVdzy829g5YKga7oWcUudSzHohjV6I+Xv3nYPf3ThZs48cJCF2YxkDOU+R7YhqMLSU5a9o5owpiwSRbEkorBkDEoLmp6ORRT6f9x3B+mmwVhf0F+UDSH3qLFTUBnF0T8p2bwpA28B1r0in2/lAc3WbZZqtSa7KO4QS3/yGJfeepCNZ5e5+WfO8dgPHGT4jLwHSXWTRarqS9CE+tCnUMZgOxYudFn/lGLvtTNe+fxH+Ogf30q50vA940V2iw5rPXG1+dj0BB1TMWsSeknFxqUFsn7JYmfKqMhpdqFQcMcNz/Cp5CiMEvpnZRz4zGiFhXzG0tee4omPHCd5zRVes+9Z3vLUS/ihG/6Ed7zjbuqe4/Ad57l4zyHuWboJt1ixMiMuuNZHTofxZb7jPK1BYuKtaVHOzraPpPdFS9XXuEThCOig/Fwy9SNQ72IQwizkNWSXa1KFRjac4JsbLMmqvqdyNQ6ntNdZzCVd9pJWwKhkYwnTHqFLtP6+yom/8OJTjtlq65ZRLEhgSTayiPhVR27rvCNSEFk6oyj6mp2TInhbetyy9OlNtl6wKveMR4oCzzgdQ++iFOKzZRWbGpD7oOmI+Cod+ybWb5LTNePFgoJmdTZcdJGYridyLywK1SyZCmVp+dGKqm9io1P1NXVXMbshJ4gPnVIS1pTQCjaR92tmcm/nO47OVoMpLJN9Kd2Nhsk+Qe27G5JeKkJSf9yrOX98v0mF8xKCidKRFWGu0uTbIWWRGLCECoXHnCMF/u/UovMGkzZUuznuQp+sJhbmAGiHqzS1S9CqpWrUXTk+xaqgxslI6BVBkK0boCHqT8LIPU6K5ji2kc7hC3VdQj72DlM9AQTSSYue192W0x6E2E5JkxBeHyXnNwj6A5KtpoKIOyV6o85Wg6oktbLutfdq8JE2M5jsl8ZGHEuIKCoIbc1UHllP2s8SJiblMuSXDMWKI9+Qoi+ZXI2AYoUSmEyl0Kv6xCKq6fsJxJwXfRDMBrQ1vwKjI+Ig4zQsPWziXkRsgKF7sUV9oyA3PKkKFKqrLWGdaa+XcJLie/eAUxQ9Gmi0XOvFimUr1yw+7sS33RAtjMXD2zE66qiXa5LtpJ0S4Zv2BE8t8c+bybGrzvfon9UtgBbpQop8E2bHLemFjMFpx/b1Cpc6stMZl17k6F4Qgag0hyq6ZEWXKeT+vninQtXyu72zLbVM7FqJ9slNRgzlCudcWZkITA4o1h6wregz1y2dx/+RJkwO3t5RRf9CoLaJ/XNY27I9F4XfeLRfaImyntcd0YRZrxtwWqaZ6UQ0A72LjZ+wagEoUsXGbbD2GU+7CgJboFj5YjH8XH98QRfppgI1h5aIa0bgD6oYw65rsTHrbIgdVChWgpDOaeU9wlVUXvcuNZQLmsBvDNZ3Eo/cCl104Fk20P3Ky4wuLDIuMjpZxWyaYdKGL3/d/bzn91/E4pO0/q/KI6obKf/7N/4KH9y7ifObi+hKoac1TRfyCwnFNRJOMl3RFMuChk/XVbQES8Ytfy7bkU1v4dYNNi8u0Lls0IH/6ZuKOJbrC+qzc20mUdfO89y1bJDjI37zbBTl0RKmhs2vup6Npy1mteDJ/+4Q6Z6MaYMHfeBkjg/J2PbxX3kRvccyaBqskQS11bf22fzBHl/7Nz/O8c4VPrBxI5f2hozTjNf/yd9h/5EtpqXABVlac82RK1inuGawzdLyhAPf9Wne+tQLeezKOgtLE0ZJh+l6F6dg1sjt8OTDh3jtV93Poc4W+5NdPrt5iMemB+hsAJuKnTOHqO6cos91SJ/Ko7etmvMQj+IsT01BSSGrnIiQZVN34AWiIJ8925PiO3OidbDeQixYOOrac8l9el2TSeJmRBodzItHm0xfNfq0mSL1/PGqrxkd0iw/Xgta28j7CGmWJvCjnbqqqHeJIGnpyMXXSxpBiptMecvGUJgEbrR3tklltL9zvXBhj79jG2cMqmmo1vtM1lUszNKJNG7D03IvCbdfke1J49LkMgVKZnJMRevh6GxZpiuCntsE9Janq8wEzWuqlt6grIrhMswQe7NeSr5jqTuaYknoHvlOQOOcR6Yc01Ud9RzlihR4nS3xPjYFdC/LLNn6htimmv7FRtDCxjE6kjI4X4vf+rQVn8u5DJWAiohcnagoXg+ochARRtS9hoDam0ocOIoVTbVoxQ1kO6Me1Ohujc0N9YEKLJjLGU3XYsYac2JMUxnSTeUdqTx/OodkrMA37oELHUOGvKByngqgbEt1iWI4v3YFDns9kH8rz2G2SZtCGkf7obCnLY5jQiltoR3Edcq7vQj1zhfkVrFzIqF3ycYphGo8LcXTYuolWZN1OefcZdv3E+5vXYOeSBOFVRH1TiaeJuMUs32ObFvF94cWKkrniiDhTYdIIWwy4WKHIi8Cia4t8AM9QyHpzXsnLf1nNKOjUO8vMVdSmtUKvZWSbStGxyzJRJE94Js9XzDHKQXS+AdB8rzANYIOSfAfV7HYFC2Ei3ud0wLKhGs9TPy0b2akaFUsPgFNnjLdB5df6Fj/BOTbElcfMkWM92wvFlX0exerUV8se/Fuk8v77CwULP+xpJfu+0SwKpRU37qrmS1rxgcECCqXLWjH8oOG7hVJTr58h47OQXXXomvD5i2a5YfFwtb6BOd4HsK5VO3XyjqyLdEzBEeXQFOhQRqQFGmAMznc5TKkY1lDw9rvlEzmyoEAfsHJq0lbbrqy8r1gv+oMJP7/Rofl63LBMFt36EKx9lnZT2wuwEKg4yoL44Oa7oUwyniOPT4fb+v/5mv8+3//7/mZn/kZzp8/zy233MLP/dzP8fKXv/y/+Xsf+chH+NIv/VJuvfVWPv3pT/9ffr0v6CI9Lv4J0ZXCFIK06crRuayo+wozlRsuJHrNcwSzkS9kGrlB07FPWisE8epeEdQwBNM4LeNNmykuvUAxOKOY7JdCtRh16S7OWO5P2Jl0ef7Rs1wYD+makle+9pP88WM3s/y+Lso6Nl8942tveohDnS3e8P7v4SU3Pc3a4ojpLQXqJ05RfccdZDsS9T07JLSIfFPRdCHbkgJoturFQCXRF3Z03NE8u0TnosHmYG3riV4tQOey3ODpyP+ORwv0TDYy8BvzBJJck+3AdL8mGStWPnqei1+2iq00zb4aPaiw2xnpjiGI4K680IKG4/+vj3Pmx+6mWHGk24bOhrzebFlTO82fnL6Blxzs8OzuEuXnFkleMkJ3a1Z7Y86USxxf3mQhm/HpC4dZHYx5cneVO1ZmPLB7hPHnVjjywrNYFLtnFrjrWz/DB0+d5NLekG5WkYwMf3zqRppa01zscsPzT3PX4Anekb2c3iXH8HTB+icdxapl+4SJaDJAOVCk01CltA1QOC6yGQpdaV4kZhMVm0MQikA6dpTDqwt0QW5bPmV4DqG2yDXteorJPs3wtGxaTqtY1CvrmK2YWEANzgt6a7kaYRKUTNCnOm8dD0zpJEI++BIbsfkCWivJVK7zgHYH+8jJfomt1pUUM+UQTn3DEp0NQVEDX7X27hb9c1Y4olkQcsokKVjKKQtZKqEeyjfBxZIkemYjR74jo97ZsmL1oRlNbti4JY3poiGiPR2L3Zo10LtiyTdrmo5QO5YfawjprXXPUPWEBtHZckxXVWxYbQKZH3XbTBD5amBocqHemEKQRWW1eNjX0LssFJUQgx4mLtl2TbEijWZADsP1E9w3MO1UZT7DwRQ2xrDPlgQkSMagrKaqFfViDY2S2Pv/D3v/HW7ZcZ53or+qWmHHE/uczgAaoQEQIAlmEgySGJQdJFrBsiVbtjWSbc1YjleeJMfxjO2R5SQ5jC3ZkmzlbNFikmhSYAIDQAJEanSjc/fJ5+y41qqq+8dXVeu0ZN9re0a68AX381BonT6999orVH3f+73hyJz8UkdQudLTuySJiePFDsVGRrkjOQhmFp7puXw3b2C+btFzTWdDAId8FCgt83ZqEicokfqUhKZh3Y085QTvBn6si3SBUBzFwjCO6xOyCy26aeOzFd4q8OBVI+BBPZD7LR/LM5bNHPNFTbUgx5xPxI0p2prqIHhtbe9I5gD5QXufizd+KzJVjZyL6ekGs28S/WFyQvaT7gaJDhGbqmohrKOqfQZUKMbjuUoNSTwfClQd+M1dhzrI0gSme1MxurvGxJ9BotDFqYPNQihW41MDFbMbjGszQrSF6J8eJwLRPaXJW5eQqMGIBXmcEkd3k0jLUlamB+ufBLyXyVK4t/fPiAYs31fpnp8vQjGSfXlyDJaec8kW0eWKm88OUY0k9kLLk5cTBP3rlt6GHL/wyRXzBc/VdzrIHXonJ5sG6l4jYFs2hhtvcpB51j5qmC8p8gPfesXHoVNwXEEphlfEWcnmMQW0ved17akX5AbWjULP5Njk2QrPceCR68YnC1ldS+Ff7gVb3kpqCJurBBQ4Az4EHy1cdOyd0cyOeMxMkY3lWE0N6x9v00uziRzr4LJjlvPie3l+V+gu/zWf8ZM/+ZN8z/d8Dz/4gz/Im9/8Zv7pP/2nfNVXfRVPPvkkt91223/y3+3t7fFt3/ZtvOMd7+DGjRv/RZ/5ki7SvRGv8HzkyUcuia5sqRkfF+QuokD5HvIQhZHZYeRKIXzZbE7yOTXVrcpwX+jE6226wjPubEmHv/SMZ/CtV9DKUztDbQ33HbnJ9rzLtM75qcdfg9rNMRPN/p1Qn6z4Qw8+yn7T5Z8/9hY6SzMe/8BZvuSrPssjP/UQbv4UbrVC7ZQcPbvJ9edXGV6Qh33n947xHx9Q9yQhDg926NATzcm/9VG2/uEbGZwTikxxEFDZ4CXevyIbyvKzlrqnqBZkk+vdkEUkuRjkgrR1NkLASCaWWk9+7xFO/5Jm+NgmV/5el/1LC5SbRpqfHEanIVudceabH+OFv/4wzZkp+kpHXDTusfQuGfKp56nHbmPxzl3e/4X7MIWF3HPh+aPkS3OOlGNOntjDesWZ7hZ33rnJv7v0AG88doGFbMrIFpLOWhdsPXGExYuK9/fuZ+GzBfUQth8c812/599Te8Ol2Qq/uvUQ47rgez75TfQt9G7UeKOYHOuw+PkddLOImVl05ZiuFTRdTXEIHVH8dgQxBaaghOmQirD471rv4oTeaJK4M443I5/ZHNp8xUPY03Vw/U2awQth5O0CAotitgLTY46lL+hg1Sdocbyfs+DZq+cuCKNIx+PDZ8g97vG2FTmJk0r8vVAAhOMfndD0r7lkV7p4zt+SM2ALeV58Bt1NQdSSfZkloUgqTK+i0HZ0Cpae9SGsSfzPRegpCN1sSVHuygZtZpaFC5rdeyRwxjXSDAwu10zXsqQVmS9nFHtWPOoDf7keZFRD0TREX+jIl448aPHcFzR8tqxYuOhSoEjUrsgkQd0SyCJuE7IxZxMnzi9hYhaDx2T03loEKhdEahHlC+h6PRDLS90EZD4WrR2wPYeyCrpCefFOUy+Fi9dvcFulTHhGBjOFyQnwxktzvqmSDeXsmCU70JipABitqk3+lywGQ1Eb7/tYJKaC08U1lRalPfS7ruAWwWRcd+PzoCswh9BtaJveKEYlE8Q/3w9CzxF0N0Vc3HRkzcpmwW6xlvOk5q2+xAQqm67bz7CdlnNv4qTRtN+p6YdidbUhv5BTD8EOLTNn6F0V/+98FPj6oRHQtUxqm27LY68Hcn/K5ErWyGwmQV14GF6S+0zXCju0uK4XKs0Jh54a3EpNeaFgugaDK56sCb76ngAkSPOc9jOjbrknW3vCSIkJiDrtNXOZbxsA0wI6ttMCFOI8IufYZyHhdRiLaSmsQc5HZ6To7LRrYaQamZmT5OYoptUwXdU06zIOj0m9cGg9rdok0TTZ80ILOfYbGpS82fSITDh0JVO+pg8Lzxrmy7DxOouZalaekGM57I7jghj8MI3GBK/3yTrMztTovZxsrMhD6rQrvSDqBuoCdl8m1sjpvo62uXNZA5t+sAad+0B3DNfDt2tiTI9WFhbPOzgvxzRfiFTe0DBoueTzJeHkR/Dji6///Nf3f//388f/+B/nT/yJPwHAD/zAD/Brv/Zr/NAP/RB/62/9rf/kv/vO7/xOvuVbvgVjDL/wC7/wX/SZL+kiPXbCReiSXSYd6nxR0d0Q/9zOjtiy2TI8nI1KY8Fs5tPCY6owrgqOHtlE7n5XSES4qh220Aktmy8KD1p52HzHnP2PnMLMoHnNiJcfv8Zdgw1OdHOez44wemIFlOeuN77A+Y1VdG346V96K/kYigKOvPUal1d7vPfzLyN7rXCz1X7OfNWz8cQaeSXHvH+HotrpUN1p6b9g8MdneK+49/tnPP8Hlrj6Fx+mf0mK87ihluPgId/TYnm1CtdWJX49jqonpaLYk820Hgg1aHBJ/ut16xW8+smcg5NwcPoE1afgnr/2CADV17ye6Yph8Uc/CsDln32QxV/y+Oc7VIsB5bCGegCjd+/j97qs9UccPL3Mna++RLOmKYxlIZ9zW3ebH//UG+mvTHhU3caXnnqOB1av8/7z9zLfK8l6Dfb2OTsHPXSl2LvX8nfe8lPwFvjA7sv49V99Nb958m6+48SH2Gt6LJza50vWn2NwYsb/deWd3P51l7n8b+9EN3Dbv7zER//NKqtf8BQ3Rgx3pxT7A+qhSQgnwGHqQqRMtBxwJVMXJc2hcB/bgBybtwE3UniR3tc0kZ7Vvr+OIlAHRz8hTWgVuLqRz2um0Lsi1pVNT4FTwW0hHG4WiiPbFoL5KBTujdBhok2YmbWE1piMhw8ooJJj8lrEeO1mGVEt32o6+hpdOykOgphbvJBb8WsSUZqA8HcksfbgtEqWZWYiBdYoN+QTT29DENPNB0uOfH5OZ6vm6F6DajzKyrG70iQHnWLPJncmXXtsrvG9IMY0Mp5XHkYnTLJPi3qVctcxWZfp0XyZgDBqwAcqiErnRpyhFN2bNT7XYsvZCaFHFhwxhCWKccWRJFKYxIFKzgEKZkua7pYLNn+K6aphtgKEYrbYg3LXhM/NmK8WdK8pDu6rRUjqFLO75pibBT73TO+Um8zsZOgqJGdquS/6L5iwfsq9MjtCEhHbEqoVR+eGTj+DgExHd49GCnB0bABpi/MGXKdFsAkuJrHYT7SDWNBnMnVKPHUr76sakvWdCutSLCTnS4Zs5unfsHhjbhFrR0ReV0BwponHHRHzuhe8xeNEIPyb2IwXO1CfcJjNnNHt4Z6faZRToKHcaov66G3u49RAk+iDEV2PwnHlhPoV0VsVGruVz4MtM/bvkOs8WxeqQ92VqW3vZptAnE9htmzSs9h0oB7oRBNKVKTgppXNW2vd2CRH8WJy6wliyLh+aNs2aFHbAjJd0rVnfEy310q1U8BiT6wZExc7aDRiwFucyNR9ARckSTeMcsO1jmtjBBWA9B5RVyP3URskt/dQDTODmWi6G+B2hXKZTUHPNbYjz6KNE0LVTvLyySHK36wFZ6oVD+MM17VUuUI3Cld4sOG/uYdGke9JUx3dmuTY5RhdJm5UynnqQbsPgMLpQ88CpGmcmYs3ulfhPX3grpto2xnHATI5Ub/zgPV/3etFyMKpqopPfepTfO/3fu8tP//yL/9yHnnkkf/kv/vhH/5hzp07x4/92I/xN/7G3/gv/tyXdJHedAVdNiFoJHKGY2KoqQmdt6fcl46/DmEuUbTWvynj8MmaBMLUPXmQ81wlT+WmK5vczn0K2xN7K3vvmNfddpHFfMpSPuWTJ2/j3sWbfPzG7bxy4TJPj49yurvDIJ/TLDX0j4450hnzsruv89WLjzF7Q873fu7r+c6zj/AjP/RVrE5htmKYvbph6zse5thvOq69TTZf23FwXYrc/vMSSjJbhcXfFBeNC7+/I3xrWs5fZ1tQlyYq7bc9B3co+tdk0+zsSuExX1RMjiMLRgPlvoRAbLyGuBZgpopyK4zCc9i/v+Hsf/cJ/ofnnuZSvcqvbz3PJz9zNzdf/0YATvwE9K5NufnaHid//wU2/tXtCVXOMwseNsYD7nvtBXpZzeasx+39HZ7cPcq3H/8wj9x+hvXuGOcV71x6gl/YehXffv9H+drh4/yPF76Op2+u46zC9TwMGiau5Ea9yN29myz83kf4yU++nr/f5BzpjPnDd32Sj++e4dWLF/mKL/00T+4cY+ehhrWPGR69eVpCTwaGMjeoqqFzeQ9OLTJfylKB4POASikJJar7sqhKaBG4Urcevg5xYGlU4FdDPrYSbKRBBaRFigNPHQKPIuXGFjqdd4DOlnCrzZzkXUxA7iJNInJwY/EcBWbOqDYlLwjMzFxGSJsPaWzh6V01LFwMnuONT4hWjOM+jNR43SK/6f/3UqC7IJSKlII0pk9pgqGIcirElotnsugZ2g15sibv0/REFJWNFfkE+jccNtcYnAQLKbCdDDNrMOOGXClQhtmRjO7NmumRTJp3247RiwMp0CdrLd3IBq/ryA8XPr5KrjT5yKWGRDkopsHOMtCBXKmTGC9+B1soin1LPTAiSD9wTI4a4VLPHKpQqflJ9BdE81CMHU7JJh6tEuO5i+JBM4XeZcVsHQni2skFYDgxoT7u6X+2w+hlFpVbVJNTbgsKLa4aUqDOl9rCvLMh6+F8xdO9oXCZhJnloyA8reSe84ZkkhJtCW2nveZxqmTmtE5HhwrgW7jodRC0jwEdGzgSFUMd+hzVyO9GBDQhk0YxvNQwPXLIgjT8u4jiOwKt8UCoBU1A3CNVKha33kB3K1BmamAcKHwzEThWSwJk2EMpq9GWMYYJeSVouYlWlLGZCd+9t+Hb5yJc8+6WxRspbjuh+F88HwvoLDgiiSbKNYp8bNvprgl6jrlPBSbA6KSWYwrHeHC6bS5MmCh4TUqfdiUppTn69kfq3OjuRsKz9jO6VzTKq0QvigW1My1CHa+ztu10rbvt0vo5XdaUB06arWVP/8kSn7m2qItTlejt6FvefHTeknVP/n7/dk0xqMiWLOPtHtuvATXX6ErjGoWZKVzfMj6WsXDBiTWqipMfQbmjeN/lrY2tW6zxjUY1imxksF2HnunUBHmQqVZs9GJQWVwbD02UgMRdr7sqZW/IjRAsIonNlQqJvnGfUa1wWMuaJICP/K59sRbpv0sv5xz7+/u3/KwsS8qy/G2/u7m5ibWWo0eP3vLzo0ePcv369f/o+z/77LN87/d+Lx/+8IfJsv+6cvslXaTbUmE8HJySDTk+JC5TzJaDSGPa3sXKQnkgCHvVVYzPKoo94R3O1mQ0WfcV+VioLEIfkE17vih0kYM7xRnBFA0zm6OVp/GGI50JubIc6Y1ZyUYMs0Xu714lV5Y/9q4P8/T8OF/Sf4Zd2+Fqs8zLy6v8+fvfzz95/m1kM6gWYXx3w8+96Z/y59e+geydF+HLXk/npsGWkqY5fL51UrE9z5Ef+igv/PWH6V2L50P+m0VnhSY0IzVsPwg+d8KR21VMTVSVy+JtezC+zZE9rZndpkIyoPAwyx2hYDQdxfSY546f99z1yQ4/s/k6PnrpDprKQM9CoyhuZFx9R4M56PKOL/ksH/m5h/AnxFPYH5mTa8vCyphcWxyKTzx1BqU91cmM3UmXv/fCu7i+t4BWntetXuQfXfwy/s3Zn+Idn/rjfPUrP8f3n/lZ/gf/DVx4/x2YGWTPlfz7sw/y0WfuwhQWf73Du97yOHOb8eGn7+aziydxTvGFX70HvBR/puPZeJOlMytY2pANZHZigJlZbKGxHZ142Sogx1EMaELRmUbI4fbKZoIi1wPTCo+cYrakU5CLsj6IpyLkouhuCBILtLZ9oSiMC37/RpueaEvZcEUoFbQFkVO9H4p9HwRJAbnJpi74pCuqBYNuPKufk2NIAqkgmrWHPHqjuCk9P74tTLxRNGEzJlA1IoUgupPkE0dTaqJPdlHL5mMq+W4S465aMV/t6W7L+9d9hR/LdxRnEoXtaHyuGN1VilPRriebZnQ3qkMTDpsEzAenxEc7H/mEmNkibIgZCc3yChZfkF2zf82zd6d4jc9WdLJg1BbU3Kd/H4XDTRm4pYUSu7SBEQS/VKnwtB1FZ8sxXTV4I3/fCTaeoWZL2higFRgGOo6M4YOeoQezNUfnpqbYBZflSFw4VHkX1ShGLxdIVN8s6QZXp3xf7tWYDRETFOuhUAFNDW5fpZTNbCJ/Z7uHmoToWKIOFas+rDGupfYkUWxaqNufxeKdYPkap5pASgFVQUQdxdQu2D96LbTEfKwCmg7FgfCqbS6fZ2YkO0YdCkfdBP/qQwXN+IR8TiyMAXbPKopdaUoGz4uNqZm35y0GN8UpQf+qZ76skng1FWjxNKVJXPsesWH2YZq0d6eIJpseLJ2z6HnMVNCB+hYmbZ5wn+kgHAevPV5rCBQ8Ewr17mZIwO0IP6K3CdffBINLobEsRPQdQ/+UA7sk1ynRZWLjcjkjm0gzNjnlyPc0Cxfkc5qO0HXcoXpockyKeGUlJA0H2/fLHhuBhUQHzKB707f7FO21UGG9VeEew0uYYJxM6CZMovpQ3ezC+pRycU61XyKerJr+FejfkM627nuuvRVYrsgvdlh6JoIsqkXsQ7PoMiUFeuYgBzfT6FoQdF86iNkDjcKVnq2H2uscufG2IwBBPpKG3EzbCfd8Wfjm2TwcQ3CHKndFjxK1YcWonSxEj/pIx3F5mBAdSpt98bxCh/e78HrmmWdYXFy85Wff933fx1/5K3/lP/lv1G8ZP3jvf9vPAKy1fMu3fAt/9a/+Vc6ePftffYwv6SK92PeoHnR2BCFrAg+vGDm6m1JgTI/oNArN5pJY2L9pqYYmIUlxPA+ysOgGqoE8GPlEJdTBdqF3VYqlslOxWo6Z2pxTnR3O2TVy7dDKc61a4sZsgeHSlGvzRf7B7js52dtlz/a4v3OFxyenyVXD0Ez5P+/7Kf79d7+Cn/vpt1LcyPiWf/lnyffBfu8p7vkuGcFc/KsPM7iokpvA6HVT7vrDn+HC//awpP0FZ4XOTvBo10BPsX+PpXvVMF8FVwpaoW1ASOMGGDbNclv8gvfvbMeenZsRGYRyD3bulzHs6GTOe3/zIb7yLZ/BWcXtP2KYLxqaP7bF7Mk1IEN5+NB7HsK/egRPDehfVHQeK9n4Uk3nQsHB3TNuW9xFF5buYI7Rjro2FNrS61S8bvUit5Vb/PLeg7zth/4C09MN31n8YaZ1xt7FRQZB2OM1NIG4e8fRTR689xqlbsgLy8LyhHtXN8i05Qt7C3Q3XRqdogxeDRKK0nTE4i3GuosArB1/gmwkTaET8pscFsLCbkuVNuYojrRd2F3X4gFdBt/ua20xWw10y1MOyXvR3gxkYzZzz2RN34KqSgNKomplM9J3KUJYTlOq4Psf+aMydYooXNMVToqLwTmqLUBkVK+SF7JwKuW4okNJ9FOPFJi4mUY3h1jA+kyRTYNXcd1axjmjUkiQNACt5VsU7dZ9ccLwWigqS89ViPuSUFPGxxXTI51E1cDD8IpleKnm4HSOy1USgzcd8Xo3cznueqCSZd3oeIapRfRV7vkQPBVsUgPC1dmxUkBF1Na230WHhgPnQatUhAGM14xsvOE+yqaKvTOS/NvddLdwtifrwv0fH9MpJdPl4Gv5bvkBKKtT4ZRNFfMVh16Zo4Est1STAr0lTiGzufhP10OhUrhC3q/ckSYlOeM0gWNdwvg2mXZ1NgzVyQq9m5ONFLN1F9YF+fxbUhQPoa/KySN22OrPB3cPbEDd4z1Qhnsu3NvQFsJWy99L4SPHZ7uh0Q4Ie+SlowIqXAS3leg805X7cb4geQdxetH0xbklJqCioOk7zFTQ0um6x3Ud+a4hPwgbjjv0fCApufmBZDQkTnL4VdsV4KXcaq9701WU0XfftcXnwZ0SOuUuSBHNoYI1NkZCGZNmRGvhePsgDI886KYXRM1xMuXbZ7J3VSfrYELxHxsv15N7I65z1RIUu0AtExhXyPRm8II4jMV9M2vkXI+W4chjLukCooVxPpFjKffh5msV2ZkR1TRnb6eQIreG0WkFAZ33mXxONg1+614Fuk5wzDpwCUnGy7o1P1WjywYbnK3USMTTRz4j9LL4yqaO0+/3uCzHa8fOWc3knhrmhuXHTaghRJPT9EBPNa4v18Ubj5kJqi5uMR6XB/TdeCngM48vvKD3E9HD2Y6n1uAzjxoq5isKn0nDpStFvSQZKeDxeWjErOSieAN6DovPx/VFvoOAQzrRCeNE5qX6Onv2LJ/4xCdu+dl/DEUHOHLkCMaY34aa37x587eh6wAHBwc8+uijfOYzn+G7v/u7AUHuvfdkWcZ73/te3v72t/9/PcaXdJHuMqE2eqOwGalIUhMfUGLH4FrYKI+KI0b/RpO4hDEOOo52my74QehYA8oQ+YVmLj+LfLub1xd5zMNti7vs1D12qy6ToKJ74+A51ot9cmU527vBd67/Bk/OT3BgO1xvlthpeoxdyZ7tsW4OKHXDj3/H3+MP/sifpXcN9u7xDC4pXvhrD3P7//oIt33fI5z7gTei54piV3HXH/4Mz//tN9G/AuOTskmIS4Kiu+HZv1PRdGXxED65oloUNABP2tRiUAlKkKDiQDh00+OOYltLWqsLSaHrinpFdgzby7jrez7Ge/7BGzETzfk/0GAOFIs/v4YfwJ9893t4dP92PvtzL6NWwH0jvubsY/zaP3kz/acKRnfXaODxKyfQuWN2foHrpw3GOG6OB+yPurzn4v0MygprNbOzc9bX9rn+wgrP/95/zrv6X8u57Dj/x9t/ip+6+TquTYbozPK9d7yHXdfjar3MT116DQDHOvto5Xj2UKQ7kHjCgoBHX1yV0j0lgEJ+Pwao2EICcbwSRDabuCQY9LnGTCNHWgdKREBxD2TTqhblPjts/aVoix3b0wFdIVGsbKlvoZ1ESkCkbEVxVxSmKtuixcp5uf5hDC8/1K03dh0L/iDMnAtNJyJ9kWdp5q1fOtajfBCgGoXPSbaN0QEJAvLYVXR2XRKWQYsM2SKOx32L8B4SlakgVgMpEqJnve1oehsWWyjmK/J7+cSzf4dMfzo7QmdZHFmKfc9sWZGPLPPlLKUKulw2+u6m+MLH67t/OmO2HCcWAWWNI2Yr3HIzd+hKCrRsSuKgV0PRqxQHjmrQNl/Z3LNwoWbvTJ7AgOhDbktB620hvOPINx0f1+laKwsq+noX8mflSIFE2RjyA40+12X/oYqq0SjtcKWj/1SR7GHzA6HIZRP5c1O2NKl6IAUxoTntXTFMbm9wD4zIvUL1K9z5fvB6DpaXIZAoWrfWvfD/V4fQUN/eq3FikUCRQAeIQMHhUDq5d8ME4ZBHue2QBLlJVzRtOd8xCTKem+ijPj6hhFpxWYrBaihgSxOC2OpBaHhGwsPXwaq2uGHIRvJ50RnF5kjRHZrC1LA1ou+JvPnF510AhlxKIo7c5chdt7mmd9PRuykny0X9yMSBc0zWs5R6HJ/p8THN/t2O479pEuUnne9DgmPlWp1VTBk2s3byVS229MWYDRFpPFEQKw2puGANzxnmK5J+6fL2eS5GnuUvhD8fBD2N9SivKQ5sWj9tz9H5xJDlyxHZ8Fz/Usexj0vYT+TYu0wlagdhChitX72Ca28D13EsfS6j7sPRX1fMF3K5hiXJdac4sKlJjNPAOBl3GSw/bVl+Wk7cfNGz9aAWDv8kCNUXGxQephKKVy9YEefnHjPRUHpxM9KEkxxu2pAwbGYB7R5Y1FzjBhazb9L3qpct5YZMyW3PgfEQ9+cgxi9H7cTW5eKSZUPgGYh1Y91uaS+u1+9G7+BBa83CwsJ/1q8XRcFrXvMa3ve+9/F1X/d16efve9/7+H2/7/f9tt9fWFjgc5/73C0/+8Ef/EE++MEP8jM/8zOcOXPmP+tzX9JFupl7TFCs21IKrE5IYZwvGqwV3+Roi+UyER3FsWOxHcfUEi7Ru9ZuLN0tz3wxKLqDon26TouqKFjozHBesVv3gvBxSqEb3rP7Ck53tpn5nFLXPFsdpfaGD23fyxuWn2djNuQT3MVT++v8lH0N33zqUX50+2HsfWNOv/0681+5i9kRoZs8/7ffxD0/usNd3/MxdK/Hhb/0EBf+5sO40gWepEob5v7dMjpMI9paMbpNij6fi1NHNlZptFgtkqzUsjHs3+Wxpafc1lTLnuxAFprxW8YoBV9z11O8932vwZ2eUn/5aylPjCk+MsRtZsyXxZLO7Sr+5T//KupF0AbUkwPqBc8vPvZmpq+vGDxR8Adf9wke6F7mX1x8Cy9cX+Xdb/84P/PI60DBfDFneWnMsf4Bvazm+8/+FEfNjB/ZfT3/60OyG/zo2Z/g7f/hL/KXP/l1KAX2IOc73/zr/MbB/ZzpbLBkJmx84hhn3vICI1vQOBMcIHTiHkd0FKVbFEzLhW16sVowaTwdeefRbzwfi71gUygRjDY+od8uC7STsJfpWkRX3a22oJYPDPdlsOOLIk8dxG5xs01iqohae1m8u1s2jcbF71/ePx+JRZfLFVUQLMXjSCh4CGeKm7+pPE1HB2RGRsBx/AsyIoeAaAaE2BayoVJLgWkLFfzPVXJKqAbC2Y4+3ImHHRC+YiS+wi4LbgcBRbfBLWjhPCw/IzNdrxTTo3ko1FRwY5EG0gX7wGooKLEtNd3NiuLAUA/F+aVaUOIAUbbn3cwDJWYiyF9xIM97PmpRUx0KiGzm0oY/uFKjnGe+mIVmyFH3NKNjWSoUhpcaTO2oBxlL52p27skp98K6Ei0GHYxPew7u9OT7QmHRkVqiSIUkTSjWgzgQL411tFLt3YDB5wvGp0UzM79jznzJpClEzFWI1CQTaC/x/ooc4d5V4fx2LmdU4z52oQGnUH0HGpqeZVIaspGmOtKw8GRG/6pj/w5pJosDuQZJLxGQ4MPuLomXHSY2mlBETgU5b3qkKVUU5ycrVGFw4I04eojPdEtzKUYyBY2TpsnxwOG/qlKmRe+mePHXfS2e+KEpqxakyGMuxZr4ysuUygWevPLhOijSBMjnQB2up5WpY0wLjlOqyJePHvsocIWGcH504zEzi8uEbmdzadjjZKLctejGUfcLFp/RKOsSTUNXbZCZC6h63VeMTgXf7WVHFvat+aoXor6ScxIpL7aUa3HYmcfMwfYdPvdJm1ANpZDMZvJsz9Zg+Snb6rfCBMoZmAdq3fbLNHiLriUXQdY9xdJjmsk6dDcc+hDf2pmAUpcKl5l0DnTt6Nw0TI/K/pxNpSnOpgp1zSeaXbq3/K10utgsHZ6GoOS7rH5OmpsbX16RXQ9VslNi8ziocZXBWaE/slRRFg3zrS75ZibouAI/NUGj5GBi8Majw3/NvkHXCu/AFZ5sz9B0fSjy434gqH2z3KAnJrjhKLxumxihfQUXu47Cz393aCX///L6c3/uz/Gt3/qtvPa1r+VNb3oT/+yf/TMuXrzId33XdwHwl//yX+bKlSv863/9r9Fa8+CDD97y79fX1+l0Or/t5/+fXi/tIr3y0FFMV1TiLI6PZ8KPrH1yDYgcyrqrkrjFK3HO8EY2dd2I33IsrGJqaRwPzpbD4heQ9t7ilOv7C8x6U3TfM8jmrBYTjhW71N7wyNZdvOykcNI/sn8PPVOzX5fs1H2yoIA6M9jmI5fP8PPXHuLZJ0+irOKxvdvRxzzf8eXv5/p8kV/82Gt46rsXyHYexhWeYk8s6w5Oi4/23t0Kl3vqlQY1MxQjcZ0xM8V8JXCg5yogJp7GC6cToDkm1fx93/Mc47edZfDVl/nCC8dx+yV20GCHoIzHeEWzWfLxwe0MX4Ajv+S4/PYunQ8WKZRCebGGmv3+PT7z+h/nnp/+k3jjGZ4Li5MBas1X/uGPcTTf58B1ufbISUoH7xncz9od27xq7QpjW3BltMgzN9apJznXjy3yTb/xXQyXJ/zo59+As4ri+Y7wMGtZbfXYcLNa4JObt/GaM+f50P59nH74Ek+/cJynqpM8dN8L4r5RyrhZKCSt80gUTara3RJm1HQFbScgzdoFL3kPSourC0phZk3ikrtcYcJGYeYOU2nxOA/v6RUQN25NGE0TEJRArShicRM55UJ5EU5zXNNDDD2xIAk/jah4FegvPjYl0eGoLRxi3LTLFWoiiJVxgBdaTCymvQZfkYSj4owg7+2NnAuXqeSw0pSidYibbgxXcnkrsouNckTZ0xhbvloK3hL3DPGJN5XFZQU2FwTTlpKUOF/36LmmWnLk+7JR1oOMxQtyjWbLGlsKdWZhw6UQkcPWh7FYtQVtZHrT3gteS9FRjBz5xKLnFrSgW5GuNF/UCQwYXLHsn8npbjjyqWO6loVAIZXWkIgAdzYVk9ss9ZJHWQM6iDlVSy1oeoGGFjnbyLlUPrjThN8dXBDRZ/eZUs7DUCaE5U7bkCc+uW2namYKea5oBoCD2XFLedPAeoPbLyDzCTH0CzWNz+m9IOLq3bt1On9NT4rWOKFLTiKHEPV4XqOXeqSX6YaQ1CtTTnxLgbGdIGoMKHz0Q29KeX5dWIfqofy+NKShgA8c6XzkU0E+WRMkOjaVsSCPdI088Id92DvycZvaOjolTZEjNMxVi/yK+LLdR0i/IxMblYHPYzFKen5dphjfVnBwu9ibeiOFdu+mIPHzxUyMAAK1UVJ4BV2oBybE0QtaP1o3ycNe1zB8Tmxlm440qXFyKnkfoWYOtMnooy/0CrEy1FVs4sK5DEV2MXIUI3k+m0IlXYlob3wKRVr7rDTw+7fD4KpP+y8gicWb8mefhbXNt9aC0dEqTiHyERR7mt175Bi74d73Yf3wGrYeNCw/41rOvZViOK6D6bqEdSyCNJe+TjqmpudZ+mTB6LQ8h7rJRNcRGndb5FSL0B+JE48tPb5j0VMjNqlzaVhdz6KqoBmgvd+99thApVFO9mc9zqgXLAwsejsPz70nUZZiXZK33/fw5OlF93qRsnC+6Zu+ia2tLf7aX/trXLt2jQcffJBf/dVf5fbbbwfg2rVrXLx48f/Rz1Te+xfp6fide+3v77O4uMirvuVvkmWd4HUsRUI+lkU3H7nkaVwPVFKHl3st7aHu67S4QrshNB2V7NFsKcFB0yOyiDV9WYCXz26x1JmyP+twx+IOvayi8ZquqXn18AX+3Y2Xs1JO+Pjl22ku9+ldVhT7UIw9VV8lIVvy4w+b+2xZ8bI/8DSPfvQsp195ldceucTPfvj1+NJx//9ynoOH7+TyV8DwWREoVktSfJfbsvnbrkfVsphVy/LnZtGS7QkqXOzKhrPz+or7/s8DvvA9Czx09iLXRgssfvWzAFz43x6mXmnovZBRD6FetBz7iGL4bz/G9T/3sDQK52Z8z//1b/kb3/dHKQ5s4hRr69k7k9F04LafuMgz331a6EIzxeu//Akar/ncz90vgrX9YDdWCZLaHKsorhTUCw6WKtRGSbGn6GyC/uotJh9fFU7tPWP8pR7ZWCzK8DA95ulfEQ9j2/G87g3P0MvmdE1N4wyP/f1XymkOm2N3W4JoDjuWJF41cl3iJuMDxzgWFtlEivNIC4luKNGJ4DBXMKLNhwWY8X2SN/HUMzphmByDxee8IND9lncYR/vxXo20iWLkQ9IliRIQr0FTynRJXBha7rjLAlrfSHS1qT3ZxCXUPlpHgpyP6D0eE0fTSx3aHJ183zbivg32aToqcXIjAp/NQvGbrBxb+oV4B4un8HQNin1xdim3a5R17J7tynktYXIMbClBPnGKgRctRWcnNOZ9OTfDSyKejQ4hkW6REN/gTNOUbQMF4kedTYSyk01bOoENDi+6Co3U2DI6mbN4Yc72faVMqQLyXRxA/7o0C7GhFVpSWyRF6tLsqMctNDDV6EYxOK8Tmj5b8+T7ok0pt0jpoGZKcteIbiWuFGQ3NgRNL/DPw8+jKDF5eZuWEjFb85ipUOXG90sSps88eqYFDChk/ew9UzA5ZfGZJ9/OKPZunfZ40zYUh89psjukXXvjn1PQT3g20pRLtfd9FJgK3YjEcW+6pIYjUqSioDUl1nZlnYygDhCuK4xOKNEk1YLAi8sIZCP5PdEAyJ9dFjjynVhEtmv5ytONPP9xLQlUjclaxuB6A0EAenj9iHvBlS8TNLXckvW9e/NQIxXsIztbMLjepAbSFkKZau0Jw3MZwsO2HtB0Nkl6ljRBDXSq6NDTxAbpkO99NpZnEC/mCitPuuT7H68lYbIna0Z7rWPzGv8uWo+mqYqH3bsMw0uik2kbZt8+p6G5Eytbx9U358mTHiTsKP6u/APP9n0Zg6ueYt+m9cUecmtLwn7bftZsSbPxZRVMM9Sg5tTPxKAAWY+qgT5kySt6lrqvmK7DkTde58anj5GPYXrCohqFniuaJelGVaPQM41bqmEqkwE913KdMo/rBipN5KtP5dqf/A1xr/FaBO3xPMZGW3mw0xmf/IX/mb29vf9s2sfv5OtHfuRH+JN/529y9C/+id/xz9p//2/ytpH+L/Yt/91+vaSR9HLPUVp5cpqejNW9ltGgCvQD5WQBc5lCh4er6QZf5YAqNn3hdGcTQRrzsTwM+Vj43sUBdDekKMhGis4WbB8ZsGv6+OsdqgtrFHs+oRePu1cIf66jWJzFBUcKvrqnwsIavHND0dh0Jbn033/H3+Y7z30TtuOY/4vj/NIDJ+k+sIdScO4fH+f0P6oZPtPh4BUVaA9WYTZzpscd3WuCGDYLlnrVU97IBHUJDjF6Lpvw+CQyXfj80/zpN474p597C2VZM/2FlzHa7+D9nHv+yKfY+s6HOfm3HqH6ytdx4esVnT92O/OPweS4px50+Id/6BvwZ2Hvzoz9l9esf8hQ7lp6Nx3djZrxK05wx2sus1TOeGZzjT+w9ihbzYDP9O/nwXc8y2OXT6CNZ21hxP6/P8apN13lC6PbyNenfPN9n8J5xb/50JsZvmGLLzlxjo++pWbzY8doxgXFVIrJ6VHPwvMKE4S12Rj6lxVPXL1X4qc7Ighb6cpoVDeiY6i7EYWWzcFUh5B0rdCNw3YMLloTBs9sExxTPHEBD+8xcwmV91nw/UZQ6mgrF/3V985kTE54etcUgyuOm682FLtw9FHx/7alZrhTY2Zh9wnFsO0Ymo4mm9jARRXh5WHVvwn+7dqKqQZIymu5d8g9JIyWTS2FulswmJlHeXFMOIwei4ZBMV/UaZLU3RS6gHDm5d4t9kloj7bglA85BY7ZqhakrlBJgBotJ+uYchs3aCvnMKJ6KBmx1/2C/rU6OCAITJsCdBB0CsBMxX5OOPrCUc8m0mzoMIY3tfB+Y4Nmy1bkmR9Cfk0VQoSi+07WBjLBocJRQdMXlL1ayJiuEaxgASvvt3uXTsWPbmKBEISN01A0z8LUa67xpcMNHLYokyNLNlHMjzWyxm1lrVtGbOKQ7xc5yNWCIIheC7VhfFrWiFbDEDjJh8TILgd3bI61Ci6VdJ8rmB6zMGzE/XOzwMwy6hMVk5NSoKM9zdEK3RTkeyTeuS2B2BQEWkoUpduyFT7LyYxNZHtN072atQ1IFBge1j5EBxiZesnfFXvy/WZrnu5NoTpFF6SmB/NC/NBdLm4bxX5EVmG20vLQmx6BWhAQ7FkrALedttiPRbJcj0gVa9FOCQQKCZO5TFyyiQ/NWbR4hRP/QQrXaknWrcFlyUPIJmKU0N2QxjzZfWYtbSkWyLY4VJBaT7EfnqXQBOUjEpXNlS16Huk6UbSbH8j3dxM5NjNpGyflozi1vU6iXYl2pYEyF4v4kMHQhGRh3UjD1Nlqg3xis6qswoV7VIT8bWO89GwLfqgQLJhPXNuYuKAHSMCJPFu2DI5ZHLq/FIhQX9KNsVrsIPfyQE9qp3zRmjW+R3Egk5nhZY//zBrHlJXv+qS87+YrFPl+znzNybPcdXgr4XcosAOpW1StMQeZACxd4a/ruQAb198EC+fCGlyI7mW+IvdCudPWGy+6l6ftWH9HP+d34TP+H3i9pIt0ZxAHiiDGqXviaS4PsPBa4xgQDU0hhbfLhTuXT0KEb1j8Y3FeDTTRlaB7U9C0uqfoXyE5WhQflOoim0PT8en3IaBxEZ0N434QJDF62sYwGZu3DgVLzzm+8X/6i9x8s+X4R2SBW/28Y2+yyGzF07tnj3Pf3OXIJz3Hvv1R6vfdzo39IVMFvWcL7viq83z+mdMc/bAEC33TU9f52z/19RQHpCTR6VERAx0/tsP097+Bf/wxx/EPZuzf0WN8RMIRsoni3P/5Jvz6jK3Xvo5sJ2PhScWVjZMc+2SD8lBuzqmWSr73f/1R/tLPfhs08h37/+EZbnzzy+hfcSx/32UAeqaiX1Z8+OBevmn54+g5/PSd7+fOJ76DNzx4jj91/IN8+5PfxbHuPp2HnueZzTV+9DNv5OVnLjN8XrPVHOEXRz3edddTXPmyMZMm58FXXePXfuYNrD6OcP+C2LLpyXSh6SAo2BiyiWa6BtsvlxAgXcnlMXPhDdtCnFB01lYHuydzuttOfLIjj9pGS0KVNpziwKEa0Ta4rKWfxPTbxGf1KqHX/euOwRVAye90b8giPD6aUYxEcFZlBhMs1CThVlEcyEZQLRqqvg6IZGgqg/sHYeQsaYLyXPSvW+GFR9532KwdrSuFLRVq6hPqHUV+0lhIQxwLiZbPGfjtdXvvR/9oHQphCeaQf6brVgwaufFNVyXruJhkaTsicoxCPb8gvuHZNAtBY1JMlNuCZOlK4wrP4nOK3g2L7Wj275BmOlImok4jayAfidVmCl0KLi0xbTQWhJEWIlODdoO2uawVKWEzTMFsIcV+d0MCgppBcFHJ5PMnJzz9S/IZ3R1PNZSJVxTRTtdBnRnDVgczNpQbOdk86BNC3Hk91CjkvYudcDnCtYqNBbV8Xr0AruPoXhYdjpkpxnfVDJ/KGd9h0TNNua2S1/fkmBS3AMp4qtNzfC0jyN6zZXJPwYO+WEhew7o4VLjlmvLBXcbnFskminrRUexo5keCw9SyVEuq0/qIN11ZH3s3fKITHnb2iQJ/VIt6e9PSV3R16O9CM+QLkhi26Qmnuh5KAqupAnVlBPNQiOcTyDc8xb6jHkgQXjGS5MeNV2sxEFDyu+Vu2yCUe55xt9VFRCqPWJS2fujQAjFF8NyPziuuUKjaY7sh3Gru8cqz+gWxLp2tSsBV/7oLDZ1OzYw/tM6YypNNLcpKUJYrNE1HM19QdGqfqCPy3JHSROOxASmZNQYK9a/J9LizSWoS62HbzNlCivK4zkWdiBTWmmzSPtPWiCtKaki0vN/mK6HYVQwvyrpaLUrRbmy7P5q5x8xdouZRhPvdC+qcCnRNoq5kjbjA/FYnwNg83hJSpwJNx3qOv8+Qjx1bLzOATXSkmE8QhfFxCpiogAHIaT9LgIh6Obi2VHLs5U0RoVarFlVr0D64uwSQISRHu9KnyVix39JJrYLBJQFj8onsP3X/xcx5+eILXupFeqGocp3s5pTzyWO53I+x5SGy2wnfVtfQu9kEcZ8LvGPxVZ+sK2zgbw4uizBw6wFFfqDoX5NNORYVccQmvDGVxp2RW3t4ips290JJkEMYB+uZx/cUTRf6N3yKKT7ycYkvr3sq2V/ZrmPy3CLlWDE6DeqPvomld30U/30Pc8+XXOS5bJ0nLpzk7H/3Cer33c6JP73Ah3cX0C87YLTVpdjIMDOYnGjIF+b08orsz1xGP36ayZpiclvD4NmMOkzMzK4iv2vGib8Ll79yidEZx23vsbhSkx00TI53yOaez0zu4Ie/8R9zOhvzXf+vr2XvK++TBaSXcXMyoJPVLOQz3nH8aS5OVzA4ZuueP3ThS1EzzRc21/kr098DazM++Pj99FamTDd6UGsmTQ5v36H41DLzdcNCNmNcTLk2WuC5gzWmRx2TuyxMNSuPCy9T12G0aQK/VQNaBFN+oWG8APm1gmbgOPqxiOp4EYtGH2jvGV6xgfcszh9xQb7+JkV+x4jZqOTUL4bkv0yBCtzkQ0XsLR7jMTZ+6mCKoO1KNt5yz7N7VtG/4UKMumxMkS/uNaBE9BxDR+I9lc3j57Q8cpcpKdQq2Uibrk4FtiT/yXFqAo0lU7egw1EkKj+Qf1fnARmLE4FwnDpMHiJFIYpfm24bEkLYVL2Kv9eO+cu9tvCdHFOS9GmlEMtGgvTlu1CtCec7iWCtR1lFZ0uKzJWnLNnUUi1k7N+m6F8V/rEzt26ywsvVuKJFLwGarG3odZgwlPuCwEtYi0/Hnoc8BRNFkVpOlGzUITZ+X4qa+ZJ8hplKkeyNBIlFTrgv2/Ocj2B6vStphsD0mCMf6WAF6Sn2FL0rOv2+y0nnvem2do1xLcpGCrUvIWjVokxuyi0xFC83DPWik7H9SsPgnNBV6gF0+3NmkwLTsbhc0328m2gmkUJCaMyyA7G4nS8oDrZ79K8r6kWkQD/W0D+X4U3rpuKCzV68Jt7IdDPRNGLxGGkYobCK/GpBoEle8iKwpuUch/stFUNW9DjFDq3ntpKGJ3LhQaiP8wXRchzcDs7odDxq0p5XZ+T7j0+olFEQj1d5EuVERLFSNGqLiEVp77eYsBvvZa8FOIoc5ChWFkG2PiReFi5609W38JJdniWtSaSzDa41gcftGZ9s96jk1BQ1J+H8RlpNNhaQI7q/6PD9skmLbKswYasGKjnGRMTbZbKGmJkjP2gbFl+L+5oLonjdiPZBOUO17Ck3wzOiZTLolQBYTTc62ZD8952K1DhaamKgHM6WDOVe25l4LTasynnmS5qN1zlOfvDQ2uxh//aMpecbnJEJgqy58jvKuVsEqJHOKJOStnk/LFatFx1+2OCdEg2S8cwXa3ytKTZyXNbSXV3H40NqsOvbkG4Ltm9RXhx+vFHsvMJy5JMtgKgcmLjGvohe4TR88RVeL+kiHZBiASl2RRwj40u95TEzT7UgXLLOdpMeYluoUIiITdRsxdD0gwBLw+CadNHZxHPikeBQkSusCTzEUkHVcnQTDy8WMA7mS2L3FRPNYvFe9+TBzqYe7T1NVzG85MLIWYGBeiiFR3HgMbue0QmNmbWplvXdU/Zf3rD5jlejr3t4+2Xu5jL3PVrwgf/xYepPwAvD49z3g1uc/sEdeus3ae6VoneQVzz7wTvR3/wY8694HQv3alY/N6fcLagHgixFgVT1yBJX3iXfrXtDMzql6Wxb9v7CAepnVtm8Q/Hv/tHb+Ml3vZq//tAvcfMbXsb0KBz7eMW7//6v8fceewduo8O//bp/y4GHd/3qn+XTP/cA+QAql3Hng1c40plwYzLgrhMbHOmMGdUlnzs4CbWml9W86ugVHn2VJntykX/3mTczf9OI0ys7XDlYpH9RM3p5TXlsxnhrKDzoMFqPm818xXPXqy5xaXsZ9+QwUQ0Wnw3IcvDyjqNaQe40LjVWggxFru2xl9/A/qujgmgPwC+06LmpPbMlzcKlhv3TWUKgyn3P9v2K9U87EUIGUbLLFOWuoOPrnwqi5igydRIDjhdLsPlyFoqKNvFS0CRB5PZvN/SvuoQmRZ9uF9BdF0KK8kn7/nETij+LqFIc00dOa0TLXCHoeyzcD/PXpWgM93rwmo9Niq4EiY7PRrlj8Zn4tEcOum4Ug8ue2SoibkM+LxZkqhFk78gTlumKQXmhKORTT//KHFdorj5cUu7B8JJs6Da6l9Ry/AenNPkE9lfFqjSfHA4d8un5bUWOrWWey4LNaSOfmU+kIowIWhT9xgyCaknOiY6odl8KRTOXtUHchUjFOURUDvRUoytFZ48UUNa7Jg17RJazsfx3uiaOLHYhTDRi8dqTRiGeQ1soRneIUwddi681ygj/Pe/VuDwTYOB4RTMqUdrTTHK8VYzvbOhczcgPwudHbUSgcdVHK9Rcg1KM726gUWJnODGM761RI0Pvqk7fMxZ/Mu0JbixB1OoJE9LwnHjfcqcjtagekBrhfBTQ2oBwmyk0fWlqzFgaiM4GqSDSh2wJI92o7qnU0Js56d7rXZPphm5kopqoIF25xvOlQOFpWppO5D/LohDu40xsS1sRN+nPKgiYb3kmQyqmWK/KdDMWtc6AG5g0aVBOntlsbFFBkNoEC1gV9CTRVrHpk+wloz+8V6RiPSLutgvVktzfnU1pcrLgvBOfpcjtltRgKWLj818HPrwrFLOeTs+NzYXGtvugRU8V648CXqHrYNOqPFsPKLKpIt+XNPHpmqSqZhNFNYDhFZcmU9NVRXdLpuezZZXC3byBrVcayk3F4nmXuPF1X7N7NnZJcq5HJzTDy5bFC02iHaWAt1BpVn9qm+yfrd5SdyQtE4fOo4pNbPAyH2eo3IFVqJnGlwrllAhEQ6ehK0W+p8n3Nc0A6qEnP5DJuutbmg7JeKF3yYhgeC4Fh7EeZo4vvl7cr5d0kT5f1FgT2nQl3FuvhbtXDZWEuDSI5ZkSZ4w6FPNSdAlVprPjKA6CDV1XM10Rz+Ns5qlMO9p25rBvtAqJg6Jyd5ksUtksfrYsutHNolmUBVIiqQWZnS1rOrtOHu4aXC7FSnejFfLNloSe0Sw25MOK193+Ar/5+FnmOwUrd+yyPcm49H0P88ovf5r3/8K93PGzNzn/zevk1zTn/tAax/9ODe/5JCA3S3PnHRS/l5RUmh94th4sGd3uueNXZuzc0yE6MsQR+slfP+D87x8Kv/OqoXn0COUi1IuOg1yTPT7gf/vwtzDcsBx5bMLo9j7/7Nm3MBzMeOd9j/PGD/wZfKPoXpHbdX7E8sT1YyjleW77GK+//zyPfvpuLp8cUT0/JHNQ7CkunLuTJ26ThbKcQGfboz884MrygKbn6ShY/HTJ6FRBOQ3FjhJrtrixoyHTjmqeQd+LHy0wvKTErjMUpQBeBR1D4E9GP+14HmyhcD96VIpnHZFLlRLioqWgLVRIuiMh1GufUek95D4TVKkaxmRD+VkMxclmDmsU+7cZGe87gphZB/60Z3RKBX62pOGmAjlsLuVecDI55K4RxZouV8xWFN0NsIWgOk61m1P0n265nTKlqLtIwaF8EtBGcahXiHOFa4NEdA2jk/L3nY0wpu2JzVxCpZLoFdmgulANRLy4eF5CUlwuTa8tNNMjioWLjr1XQveaYv/2DmYKCy8cQrQs5DMpwquh0BI6O8LnLfYV8yWhxXV2XECkxUGGcJ7ysVBiYqOlwveXQkmhlA/ezSpYJrbQUeRDl/vSaNtcXChsIe4c+OBZ3YgQsOm1xTTaU94xgs8spMJVeSlKRmtShJa7pCj73jWV7Au9kUIs2wr0BS/FuvdCS6Fw6JHBAeQOlVvc3OAv9qRh7XqyjRx/ekbxZDcVctE6M/qPgxSpKvCbdVVQrTcy1veCrtcLUvl5L3Sz6EpBKOwjPzre20lEGwTVtmi57LHpjom8hBrHq7bIlHtD3jcbBcAjgBoul3Ms1pzS4CSOdiiubBk0CD0R1wvFS65xbJR0Ldei3BGbySwg7E0/FPhTUlJx0gkYAQLmSyqsO7YVXbr2nsnmLjQe8jOXqUS/FADABW61vsXa0hayLtiO7INNEnqHc5bLXqQrMIHe5cP0JRaVtgQ9a7USkRcuAkn5vk0p3y9OgGSCKMdQDU1CkyO/3Mx94KEL8BBFsqMTOT53OOTZULVMIk0F1YJh+Wmhg0axev+maIXiOXMhz8KWco6vvg1OfcCi65abDrBwsUXKIawtY8f6p8T95cpXNJTXDUces2nKKQ25l/TyeGkU6H9xBK/8LVqJuG5VA6knov1jpNnYYSMF+n4ua2gpSLmqbnX2cX1Lowz1glBjim0j6cAL0H0iZ/8MDC5KbTJ8wSctT/pe+a3f80Xz+t1A0v8bQetf0kV6se/ICuGLYyVpMZsJR6/u6XQRO9YzXRVE3dSwd6eid0NSC2NBnc0iyteQdXQIkBBO8HxJBx477N9jyfcM/asBHUx0A5IFVTYhJSdG9Lvca8d+NoQSdDeFUhORvChEBFkAdr9uxEJ3xtZTR1g/sctfOvtrvLt/wG8e/XX+6Me/nd3dHmbPMF9xfPITZ3F3Vzz7R9dZesaz9WVzuk912HhVDg89LM4HAelzHcfSkyGBLpMCZukLihuv7dDdkKjr1S807Nwt6O3Vtw4ZnheEP5vA9Lhn+ILYvekKxqekMNl8hUE9MGTlC5ZXrl8l05Z7OtdBedRcbMHyCeilijyzDDpz3OcXuP212zzznMa+sMDytizmNoiZih3F9HRDM8vYu1vB2RFZZuk8sphCOBbPiRNIDLdZeu0Go1mB//Qi5abi8i/cgXnTmLrwdG9obAf2z4hd5+I5FxwNfFp4lSehwRFpNVUbKhKbtYgwd3bbTSQfW5quJpu6YP2lIFAzvFHC0y4UVUejdfAddqC7ntmKSoVAHLcvXLS3jFfzYHlmS8XSc1KE33xnxfATGbajODilJXirOoTuBIRV7Bxb1K/Yb713RUgpegz5/i2y5lVIM7Ty/ETnGh+sChM/E0Jqq3xONo9OS3Ic2cwHVE1x2DkhcuuVVixcEFtRZRW2K1Ok3oZn5QsV+7cXjI/JcRyc1ug59G+KGO8wzUMH2lHdl2mJFNI+8XDN3NO/5lLTEnUqLtft1CH8G8LkrO4pehtOrqsXVFD9lk2is9VQD7OEypm5k/j6uTTbIuaE4UWfCqS8I8FIIBZ3qlFMb/RR6yI4617MRCyJoLkQrp9qi8CmHwpLpKiarUohWu7KM18PIBtrrJOioLcuuQd1bfCXOnS2pAAv9uVeHJ+C6UlL76JJa6ii5SvjEW/wQ9+/cyVL943teDo3NT6D+SmH7TmyWUu5UrX8+8O2nNmcFLIVrSljg5SCi2btZCE2ndqBDW42qfAPYUsgiHzTaxuByKtPSauBB+8KoTnExsRlobmkLWhnazKd8EocsibHoLMNPhy77UjTkk9dQst37s6oF+Wz1h+1bcMbni2hacr9dOX3WE7/fMsx9koJ1aXxNKVuRcfhe6ZgsJhLMJeET23BzJw0wlpScxWHnn3Z1sKUUM6J7EGtQ07Ua8Sk5FigukIlzn38/BSgFNbP6ZoYNhy2N4znsbdpOfUew3xBMVuOwEHYNw/ZyDZdTV2qlKob7SYTXSeAKH7YcPmdGQvPaBZfCMF0RdTrkM61LWOStGP1cx79WcV80ScKVExHjgL2SCWqhoqtV3pcz6EqTb4noEkqmBVBWOowcxeaKIUysiCqpQp9rRTrzK7FGaGyqEqeh2w3E3cqD94qqlNz6mFO97pmehS88UyOKdGTnJFnsnfD091ugbwvvl7cr5d0kV73NSZw3ES4oqmcUAnGx4UDufSsZ/MVIsDIJpLQqWtZ1KphsH/rqrQwqcIESoEOm0MIQ/KezCt8x2FrGUebymM7YsUEtMiFBeayQNU9lYoTvGxGVU/Ru2mTgAhaIY/wBRU33uL4A3c9wVuHT7N7d49HD87wpd3rTH3Gmzsl7mYHvTbHZ1BuaeER7haYKeyeVXSf7HDv1zzHzqyL0Y5Lj5wWdOgAqkXNbDVEQRtZrJuucGgFEYCbD2XMjzjMRDN8IX432fCLHcXkmAjAutvi3jFfEcSl2PPceIPm2iMvIz9Q/If+y1m8JOf76O+7yJnBNp/ZOMlSd0rHNJg3XeMXf/WNLIyBXkjNTAtnDAYR6sjjf/6HAHj3uXdxeWOBvbsV06NORukH8l06W57m59doTkNz/xRvFeZqB3etCwsNLisSDSAh3Va44RIX79MoM6UJOpgPNcXIScAIQaQc6CFRGCzXT7dUj7Bx2W67adhCkR9YdEfQo/qoorMtxX8U7WnrhfMcvc5pUXDkVgz3e0DYr5Xs3w4LFyyLz8vuf3CbobPt0waYxGNK/o+ZSHMbp0ve6DTulYaE9N0i8ulMvE9VKnpssLGM04dyz6fG02UqFcrlnk/WpjH0yBWthmO8rpitw+rnPctPC/o8XRMUc/MVimK/YOkZx7gvTUjdgyOfk4Yn2sbpOqTzFcIjj77VyvlEfRGUU0R6LrjwVN1YnIMOdJ6oL6n78jwsXGyoFgyuVpQ7DQwM1VDT3bYpJAsl6aZRzLV7dx5i6QU11LVicNUlTm68kMpJsWcqyKaa6THHwjOa8SktwrGIJvuwPjSklV/XQtObrYUCt/AhOEpJOE9Aq10BzBTNokMpGO+JlWVZy5rYv6xSQmf3s11GZ2u8NtxiaViLYNVMQ+MXivYoSndB1GemMjlpeh69m2Fm6hYE2wY7yOjE0gQUGy+Ir6DRQCi4bZg+4Eh+3nFSFu0zTUjJtOWhhi07NFEDqmX5//N9ee9YIEarQ2VFlhJpJWj5r0ZEuMVusLIMwVCDK/KZdThvKjS/zpDsBk0Feidew7bATdc/hOvYUnH658VBKlqfRpGqDQFBUvj7sMYIOp2sR8NEMHG5u/oWPUv/uksNQSzsJH1X/hxF015JYVz32mteD+RcROqZDVamTbhONgAaInb0qdAXnY5LOpXDzW09lIlxKsx9fE4l/6HuK7bfUEOlOfFBhRscahhD4Fq94GEmwVrRBtMFDVpaj1XbgETufyzeoxjeFjp5v0eb1mgcUhx4fBGa6qWK7FjN9KBk6Zk8PO9B1NsRsa5ugqYgt3iv8E5hFyyqVuA0eq7xHSdmB5XGa48dNOipkSnv3OAXGsyFAnvMoaxifiTo2BrF/IhQp3bu19i+Q+0o+HlefK8vuruk10u6SO9tWLLMkk+EttJ0ZKHBQ3dDOtmbrxcU8+SHplx/fZelZwQtMnUUlpL8nCOqmLpTL4vXfDGO8L2IOqLCvRQRaSzS+9dtKFBksXSZEjQxLBymirZT7hZVts1JIRrKwY03eu46e5U7Ozf55e2HONPd5O7eDd7xd/4Cb/nWT/HawQVWPqfZu7uLXauptKFeUJiJojrqsUPLH/zqR/jXH3+Yb3vDI/zsT7wNu+pZfFYxPhECGmw7ZndhnGxmsklWS1Jwdzd1EioKLxcWLzqJQDeykI9OaE48Mme6lmMLCZZa/6QU7jsvc8LBCxzS+xZu8s6lJ3jz4rO8d/sB3rR4jn/5/MNSEIYNUQUucXEAj/+5H+L+R/4w2SeHuDfv8Yrv/5N4Iz6/w2/YonlmhcVnBJGYrcH89gqWJhxcGULmWfhEl3oI0zM13oEyskHO1kRV352AqVwr/gluJXjQMxld6rjR2kOIz9yTj0kiw9mK+NoWI58K6bhpOhU0DAHZ1ZXHFlloAqDclfvHB3S0OBDay2EHlXQzQprGmNqHzcRz7OPyM4nUlt87zDl1mYJcNjdbBmejIJwzVQwdUUFkGaYFYfPWtScbeaYrOtlTZlOXHBGitVnTkWZ2vqRax4dg0dbdDrSwsRTLkc8uxyzntrPrMZVK6242E3uz+VDT3fTMFxS7ZzVNBwaXoLchtDI5RpIffLRbazm7Ele+f7uh3JGiRL6fSefTK9C5Ips4qgWd4tbrvlAOOlsNZm6ZLxk62zXVYi7hNKViumqkkFkSNI1UIMn3PPJEE54vxWTNCP+5VMHnWNHZdvSvN8yXjLiHGGk+9m6XZqTpgZ7HAiSE8wSXEmdgfMrTu9IWas2CQ9WK6ZmG4efyVDxFW7TyhYLpIEdlnt5lTbUMdrGhGuVSEHcDz3pqqIfiPFQtklx8dCj4lQ/F8ijca14KaAXpeS635L6fr/jgWKFp+k6mWQHpNnNBwbMQXhSR7cMe6Ym6EWknTVt4QwAO9kKhXrT/zsfJ2CFXmvmqpVpSgvQHDroPWiONfF+U0FnMDMjD+85JHPymL41AsSf3rm7ks2IAV3w+baHobkmROl1TQqPMSJOfpifNWUxOXXrGtM+8l4mQbjw2akQOTfacaQGEFM4VnsnYzJnKBwezMAmL+QcBRa+DGFI34m6jrRTJTU/T3fItrSXoW+KEMwtOMPOhbsXhkGwfezeC89XIhWCweDFaMXn0+Y4BTF61AUb52NHddJR7RowaKhemCTGBU+hvtiP0y+WnXXjPOPlokX2Xy/QyJZEGup83imqoKQ4cUewpe6C4/CS3Fg/LjxvGJwzVCZhWBnWQSXBXB7RRaW2Oa6/LFK7RMMnwuSOKmtPLKjBehKHzYMGoPdQKXwarRod4qPcs+XaG7Uiz4BvF9LhYOmIVxR0HfPH14n69pIt0EXPpxGPMplLwVAtyk0+PQLkp1ombL+8yvs2x/AFJfqsWImoYEPUmjLX74gMdEcS40dcDcWAZnDdpMcxGnvmCTpz1akGnwke4eVLomcpTDxTzRQnJOPK4SsmGEaF2YSManYbBecW5haP0T805Uoz48uHneU1R8BM3HL/xc6/hA8Vr8HcEDutmRtPzlHuK+VFZhdcfMfzCU2+jX8BP3ngbmQc9V+w84Ohe1RQBdS72fEKGnVHs3dUWN90tz+7dimzcCqPKXRgf1WgnXPb5snyP3btKTEAmUfCO/+UjPLJ5hvqXT4OW8XvvBnz4h1/LB/uvpX7diGqS88TKMXZuDFl45S6rb93n7etPc32+yPt/8vU0PbhuR+jPDll/l1g53tSLvPMbP8GfOvIhvv7T/x2dDXHSyEYBXRwZ3vzA87zp/nMM9ZQ/3/1G7jixyeavnCKbkYTF1UAJqlaF1M24eTl/K5UjIC8ukzFyHIfWPZ28iJ1puaP/sVfcVEHuURNs45IFWuCaR6GxV7KpNV3QE582t3huleOQFZikoMr1axsOr6HcJnwPkiDR0Nqf1f02DdTUsRHxaeOPDhAuU8wXZFObD6SYjs4tTaHTe0eqQTZrkX9b+OS8VO5LAZsHr+VYjOsmfC9L4HaSuPvakprbct/Dfpz0yPNpKp+S+aqBCvQbOZZ86lPTPl/QFHtyzpIPvIsFTihAg7isGij6Ix+OUe7vybGcwWVJftx8UIjZ/etSYNeDNumwWjDMloO7RQyOGQhX1unw2Vqs+MwsjOsNTI9kYT2TY6n74vgzuObJZo75omG+qHAhRXO2Ks+i7UE2lns53ydM1Qy2C7MjcoKjrWF3IyDWtdjeVUuyRha7kB/kzI46VKNTM15uaFwh615MAG267T3rsoCMh2bEhGAkM0Oq3VBU6wrKHaGIiWBap8mHLcFq+TdmLoVxLMBdCU615yQi6XFNjlx1NZLvEGkxWRAO+gxMQFejEF55KPYN03WZNmRjDqGzIu41YS/JDwLiH8KLsjGMTzs6GzK1rJZk8hiFmMq14EZcS0yYpupGU5wPhWKYvs2XNFu3e8xM3m9ysqVjxZTsVIBrobJE8evenZrRHRYMHP2ITscf15vkoOIBFFVfU4xdEkXr2pOPWq/1iOyLgNuTjw9ZGNIWvT5MAyLXX6ZRtL936DkCKfKroWJyXEkh7aMAPewzFg4L2A+vmS4X29BiX567KMaNNEPlPIvPmETZiw0FSt3yfmlf8uDCZ4M07s60e3DUCtlSiX99dMrxnv41S+8GqE+LVk348D4AcaCMSs5WsvcLIOQyjy6t/LnWZNdL6iO1THAbjarAzMP+YIWSpPYzXNlyWPRENEuuZ8l2s0QD1FONahSTuseL7ZVclL74Al7iRXpU6ZuIVjft+DVGq5e7gmoUY091QzM6odvErlLQcTNviyTxfBb/a4Bi31ItZkytZrKmqReCRVVXNp7yoBWroGKjIOIewgJbDxS7D1h0pcgONDfe6GG5QhuPnWYsfTpP40VbeJqeIruR87//62/AduDd3/ooT9QTNr9uSudjfRmndmQD6dxUzFeCtduVLNEiOluevbtkcerd8KhrcoDKt+mTEXkUZAKWnvOMjis6O57RSZUS/cxcjql3w1MtCFWhGirKHejdsGw9YFBO/n/l4D1//63MF6R4MHPoX0WOY8Oxe4+GpwYsPbRNYSzFsGJ/s88rjl7l1d0L9HoVHxq9HuXhmBkwv3/KHcNtfv0L97K8D+/51dfzvvHrQR/ykA3fp3PT8IH3vpqnXn+UV65cIe80/JU7f5nd7+7xZ3/x2zjyGJS7jnIP1EVZZFVAfyJ/PKaQZjNH0zFBUKbIKyc8z1L45rpWgbtMK2iTKWyLADY+ha9Eb1sRZfrg+9ty3M1M7h3lwCF+wdm03dSTbRoklChyQbX1mPD5unaMTuTMl0h6A1uSEOxkl+bbc6fmpOYkCpsjuiQuJCq4CrRj7UiNicVopGFEQVQxDZaLeGZLimIsmQDR/zeer6gHSAmejU9FmNAY5H6VYhxcFkTbhxId03kJyY4xpCkW+5H2UfeFohBpTMVImizhEvuEwDc9EZXmY8fgsjjH7N1Z0vSBwKM+OKXpbgc9TDiQ/pU5s6VOGq9nEyj2bEAxffKVjm4xLvhGxyInOt3YXFEPFfNlFbiyLbrc3fT0r4cmz0tBlgSjE4LHvKfYUQmVBlLKaD0Mz3RwQdG12JPme7cWzxE5j8Ww16ERyMPaGWwyVeCJp8nNYdpe0zaIyoVCP+QXxCbNGfDd1jPdBkQ4upJEW0kItBpIzixRPCleovK/GMyT3FNccKpakPearfrk414ti8jVayhDc6BCgRypLp09wrME3euabCrfwZuWg97d8ozXVchkCM9WEGcDiTZJBG5ymc52r4on+/gE6fdigX54ghl56LGgXHjBsfBCBFTaNSDuidoJJSJOfGNTbJpAozFKxLexkQhouStUatLkzSC6zUgBH897W2zrRqFcME4IdLhIYXGZNNflniyI2dTJGquUNGG5IguiUnwACbwim9oWoU/PuMfmWlyhOjoV0xGtN3U7aUxWlM7LZyppoKuBpunC4KpNovFotahtdMCS73rYVjau6SmgLmsFz+iQUB70APHZ1saLQHYuoJ4yHndqSllaqs0uKjhY2a5QWrwW0wivEGpMuAeVB1c61FzoLdjYWHm0VeS7h9SsX3y9KF8v6SK9HqqQLijjuOkRk5ATU8HwchCq1SFZtAvDkU+8s2wS0yaDN2ooWlwGvqtTWMB0VYn4a1UezMXn5cEXX/OAQIQwHV3LyExZsYaqB4qDM55s36QmoPeURtsOeNi724vvuWsfelcATjii2RT+yD/5M3z+f/ghvvruJ/jON/4HVrRn2yksil3b4dt/6k+jQzE4PN9ayA1fgNFtcpyp2AmbtmoEoZwvtmNGr2Va4FWwsQsbrFfQvyax6mYWrQMFUa37msXnPXt3Cupoe9D0FfkBvPWrHuPXnzuLf6JLdxNuvkb47WYCzW+sUGeQa+i8YZdnttf4Sxvv5uCgy5f8kcf5/A++nHefexfZ+S4fvvgKjr/qBrurR+lsimgrjojXPzXBdjM+8K/+BQ7Hp+aWb330j3H+hXW6SzP+wdV3MqoL3vrmJ3jmgTVmP3c0uAcobNNuPLFIjYEiykNn14JrEzwF+VTUpUqFcixYYvEZQzwma5JAKQ2jLL5Ca1ItPcDTeqsjm2Q+Fr/zpqOYHtEUI4m3jiPwWNzFfyP3azv1mayLl3h3i8Qr1w2YsMFvvdoyfMaQB4Gz8gRepW+90oPrkdBWVOIcH+bpx3FwTFy8pZHwgtQn9wyksInOSlIYhJ/3QnNtQdVhs258arhnKzpMCUic85gsmdJJc5Wahnzuk/c7yPF0tgXd6t2QwiSf+PTcGjzZXAqMui+j/Lqv0tpwcFsnUejMjOA5LvZ880VpBPKxp9x11AtZAgBQUB44pusZxb6jWjAUB4IKouRcJBEgMuLPTEThha9bHDjGRzOqIUGQCdWiCs4wcg6bkKKZTUKAzyA49RTAqC1mq4VQWEfHFN36Qfcuix6gPlrL2H0SNn4PnQ0jtoXh/poteQlAclLw27IVXNqeJ9+T5yIbx+a0pb9EWp3XcjtHQfPshAXlyfYMqhFxuisESVfRccQIFSdSU7IwkYn882SdGESmiVccC/54TEoQ/XxPh4IyNJdlW5ClqdC0ReV94GRP14Po1ICxIlb3RtH0g8f8hhgOJC50tDBNYIjcl90toW/Ml6B/OSC8vr3/RXgcplKRwhJ57SEPJD6v8ZmTZyM6qpCyAGwHzFagmPm4HwrFaLZimKxr5sshyMpDb9NLSJuT5yROAqOdcfIIV6SCVlmP9kLvi4JyryBqrmRCZFBePPVtKfd8pLEQqIGE7+KVpPg6c2iiHTnl4XubWgTZ+dRDoOwd/o7KwXzZsP11E+prPU59oMEWmq0H5f4u9mDhBRt0G/LBkzVDb2aT0U5sjmJialwfoQUaRHgO0yOG3fs8eq7IC3m47SSX50l5XA9c5sAifuiVDtdV6Jdx33Zlq2Fzi438ewM0QVPQSOARRmhkL8rX78ZhvUi/+m99vaSLdFPFlEmVNn7bEas15aB/paLpG2yp0Y1j8TmduOcuE8Qt8upM5Rk+X1ENs2Rl13TEjzY6D+iQ4jc6pVNCW7JJK4UjL+mSEEUovRuO7oagCC5TSRgZH8LOhqJaIiUixkjgbAqPfec/5GU//t2YSvHKv/snedM3f5ZfGz3A3eV1Zj6nUJYVPcIbQS3L7bYwiyKewUUpCmIxipcmRXkpqvOJoLkqopaRx5wDXpDlLFhOxvOdzXwoMqRQl0IF0PDyr3maa5Mhu5Muj944jXm+y3zFs/yMZ/8Oze59jtXHZJGLhdx9azf4+OfvgjDm26+78I2bfObJO+iNZHPOjcW+ckT5oQEHt0nBpWvYermM+77mma/i2etr2BtdvPEUazPuXb/J7137LKfzLcau5NLiKn/71V9N51pG/3JsjDxxDItS1AGVyiZOHF7gVseP4PAyWxGu/eBK6wgQFw2XK3YedPQvaRZecIIUh6RPF+iHQHJi6G40NH2TRGUgnPxIo4jOBtXQiKVgXzG6HapTlWyqTxd0tkmBLxEBVY62KAphQusf07KhBlQNH4RpIfnOFcLNjvxzbcF7GREId/RQ4aFJfFUzbx0UfNhsY7hPb8NT7tskpkuCaaXC2Pnw+Fve0+aBKxvCUGwhgujVJ3zisEZE3YfCXY2DlVoohGKYU0yEPOxDHYVsifoSG9vLDbNlQ9NR7N/ZimZj8d3ZEpFhDBmTNUDuj8lRg648+VSep9mS6FfqYwZXwMFpsYEtduX9ole+8p56oNMERlmYrmlmK5Lc2NuEg1OKelGmPStPOJm2TWVKFb3zbSHWpePTnmboyCbivjRdl880DVDLsTc9klvL9LinXm0wnQY7zchXZzSTXOwYw3mKVJMYyIQ+JCANuoLiukqiz+Sc4gPKHopKXYOPnPEgsuxcNdgO+MxTL1nqVU95PZO1NFLFAjUn0gO7G55qUckEMpf1J35GtGY8PH2ar4TzUYMNAs/6SIOdSgy77XryfaH46DltkJISCst8iXB+5X07WyTry/jMmTnMVhQ794eMjK6nWWkYPJ0zPSb70+BSmK4OA49+HgrrmexjXovewmVSyAqifKiAC/Sf+aI8S01XCv18JM1NFprUKKR2mYg122cg7p0eM7Nkgf5hZkK5ycYK21UML+qWYhO4+DYXxyJvFNv3yR6okwOPYnApUMlCKrc0N60dJUo0WZtvtPTOZ4GuKgW+qRx6Lo409UAsHbVFEmQPcdrjq1pQFPuyPsR1RluPmrbX3hsBOua7HYpjU6Bk8yFNdVwEqfNVRXdTU+5bqoGAG9UC9IKL0mEBakwlFpBE1sI44YlrSDb1LH1BMT0Kk90OZi+DvoUi8McHFc4pGDQo22rS9DwU67nHdR1qpqmHoR7YyfGZh0aeDzPRuLJF3V37Nl98vUhfL+kivSkVBcEPOnC/he4SEtyCIlwQAXmQxsdlYVl50jJZN4kn7A3MFzPmS5p84gNH1qUC1xYKTOAc+raLjshL3VNUA830iEQ5Nx2VfKqbjqLpHEJtw7M/Oq3oXZdNc34kILkHUfACf3f7Zdj1iuyFEl3Dex99Oe81D5IvzbG1xu0V/OLX/H1+85v/Lg9/6LvJD7qJU55eYdGM1CDlDifEya/EUWhEkwmIj7KHkBkvG2oekGJTCSWm2BPawOR4KPK8Yu+XT3Dy6y+wkM+pvmSb/aoke7Xj2udOoxzs3A8LzwfPaAWP/dq9lEaQru6m57lH72HvZRb6Df51E+YHJRevHEHnlsnRILrqgu/L93AFbE365J/vc+KxhovvdvzZV3yAzXrIiWyHjqrZcAssmQkUjmpRiqrVzwVHjypSU+SE6EZ0Cyo6q0RkxkrBrRsjbiz7LecxIsMqTG+PfCbej0JtidxpOXfg8sB3xzNdzxOvW1uf6FuCFCr8kpFxbjiObAZrn/H4z2ahCJf7dP+0ptwXHqipAkqvZSHXjXCSo8PKfKDRlccXKm10XpOi1iFsSMGpJaKCsdFwWUhY9RyaKgRKjz6EelnaXIFGwp7KPYcNjjg2lyY5URfCxCFSFaKzye69wX+8IzxOkGOyprUhi5ZkImqF6GxhqrZxjkEx8b6PAtHiwLP22IzxiVL8zHvyeZF2MDrjGDyvWbjY0lfGx6RQmS/Kd4o88zrYnUb7OpeJs0i15MRi8ZiDXHilgwtKBKO63eyJEywt08JZAZ0d+d75SAoUZ8RP3mlwS9HGNYg8LfjgwGNqKeSjsNAHDng2kcmgy6Xwzl7Ima0b1LCmmeYwDkpm5PjzfTln+ThwvCft+8VrEekzII21uGIFAMK3jaM3gvRG95LowkKjUE2wah0Fak6kWFQBtZ/EaYZKE5ZsJveMpqVfxYYgikaHz0shFIWx82XINzMR4s7AlbIeVcsOO7Bk2xmmUqHwlveqF+U82C6oSaAJ7StsKNI723I9etfD+qQUdi4F1+CSFNMHdwhtrB46pnc26RyrsaHY0RS7MDmiU8FfD2RykiZWGno3hUISRZHdrbBsVy1NQ4Ki5L07O/Lz+ZLc50Kpg4PThWgocjmvxfNC/ZKC3qe9Lf1PCZe+OPAsPedaxxTVcr2nq5p6IAV0FlJCD07pdK/M1j3kTuwgczBBp+EV1AMT1t/AgfdCZyFocFyhE0e/KSE3AjAQpij5xLfJ42FP3n/djLIbkj9B/PtnGoxH1wLaudzQ25BQudHtjsXnw74X9kMdEfVATTNzH+5rn4AZ5UVzUu556kHGbb+ksIXHxxwXABX443FtC+uoADievbs0nec1rpSmUFUKl7cTTmWV6M+2NdVSCCZzhzf7F9HrvxHnld+N10u6SM8nDvqySbp2T6EMG8p4PRMEUYto08yDj+1IxuizlTgqFNrMZE0QHVcospEg6BF1jz69ypFQPkHzgm2gg52zOoxJW358TI6UsTygoAnRygvnZcEc3abI92SxrNYs5Q2D1/CvfvEdlBbqgcBDvUsS8V2XDl9pij3Dn3jiW/nKU1/g/lPXee7cGdg49HyEBiV5fR/i7UXuYaN1QlXHx0SwllIkaZuRpiObjg+ivXziGV6UP2+/DNzxGeZyh08/cg9f+0c+wdQW3JgNOdo5YGPaZ3eW87bXP8mkKXj8/WcDpxEWzwuXz+UxnVWKm/55w8I7NvmVB3+MqxY6yjFU8MbZ99B/Omf08jnv+7J/wIHLOHAdLtRHOLijw/ff907Kc11++tSrOdHf5+Pbd3C6v8PcZeTKofcz/uDbP8Lc53zkidfLYlkIjcVloVGagM+U0C+AGOTjckXVE8eBfBLEioHbr4PbSkSby135ty5xo4FQOM0XVZp4RHeViCJnM082Fh2E07KJQVscQ+tGBISpiGe+qBhc8wlFAtnIlA9ol5GmsxqI3WAeOeEB1o+8Vl255DMMscAmibOcUYLIIgLabBY2UAPzRfnes9UgTj7EZ49c0WIUzymJUhMzBZJwLhzvdFWnRvHIY9CUQtGK93CkbkX+fHSpUeFnUvWSGtV4juXfSwHRFDC42jBZMynIy+tAjTCBJuKh/4JmcM3R9ARxmy3rJDBHwfi4FBiRglLuyHeYrcF83dI/b5gfc/gYaDLXoGH/XsvaxwRFb3pSyE1OOoptxfyIRTeK4XOauivryc6DjoVzOn2WHQjyq5Ssb9lEUNXJScf0uCBvsXCerzjKbS3uLbWsg7YkhQiV2xq71lAfFHS2NfXAU27JpK9elNOZTeRz66Gco+kJS+eGCaLn9hrGpjXZIYb7J/Le3aGdSxJaPdlUipJqvcHdzOXah4Kmu+WDM478/9O1Fp3V0VOdtqj38rgJMh5ABlvI2iIuRIEGNm+bi2wixbo6WmNzh7paMrqnpnspT7QhV4goux5Avi+TKCk25bsUB/I7tpTPamrF/FiDN+J3370pGgkAlTlcZehcyWl6nvwApsc85WawX62hf9UzWZfwLjN3yTYUZMLm8tZ5JaHWES0PdJnZsqbYd/RuOPEMD/qt7pal3I2TVtHnRM2NK4Iewnq0B4tKQthkG1woSSBG1r1s6lk6b8EL9XTvDrEQHT1YiRVup8HkjjJvMPMiBR5ZLRkF0TEqCkNtqZmuGHZeLs2trhT1ksVnnnxHMbzSpn5HswYTqDw+rEkAzirUuT5eW/xijc4crjbYRjE+aagWofvr0rCjJaW83G2niQIcqDSliccXBanxZSoXEP3Wqx1F0jk03ZbCFNfufBK1R9C7rhheEgvX2ZHwS4WsGXoi76fCc6wtqKnGvRiL4UNT5d/xz/lv4PWSLtLF89ZRhKI8WrtFa7xs6lNITW+jRRHx8rNyVzFbNpT7jtmSpnfTJa5qXPCi+EwWFFLh67UKbgYeExCj3k2VkHlBz0VkKaK7KKQDlYXwlEwe+KVnPJsPyeLauWrEkiy4Cngl0czVklhJKg8rRw4YzwqqaZ+N51f58affCgpWXvBpPB3Fec6JVWIsjtJ4PynrkfPhhI9+mLIB7Zg/orzRvSOG1kzX4fSrrvKy5et84fhRrnz0FO+9cB/V+SFewxNzRff+XQ52e/zm40fIxyLGykeeIrhHyfnUqQAztXCqj3TH/PzoDB/auZd+NqfxBt1pGN+pULs5X/vDf1GCmN5yg++44yOsZGP+jzf8LH/RfgPr3THHO/t82fJT/PALDzMo5hzrHvCVb/kM37X6UayHj81el2y75ECkoJ6tZvI986DgDyFTZubAO1xugve3S4Wi+O3KnF0H5EeF83VwShDvuJlHnm4M14rBSajgPDOQIixuWLEJ8EmsGVwEwvRotqzp3ZSNw9TtmDm6wMTmx4ZwkHFfp4YzFuEADoUL/u2HPYnjfZuoDBCs53yiQkSv6tFJEeJVA6FjTI/KdMQbxWxZCtMYWiMbnjwH3S3fot9x8fWIYKxUeBWagSxMc3yLFqpAxdk5q5ndWXH0fXlyoYi80oheta4yXtA1D1v3Zcl1ptjzch4KebYXz7eBLLaQKPJ4rueLUnDN1kE1wtXOR0KB0jXs3qOYnaxZ+HyO7QK1hDQNXtAJ8e5fET5NdPDoXYfOlubgNui/YOT+iLxuA4Pzcn472y3dyGVBCBrRa8CMtVBYxlL8FPsyrRP0LhQxUU8RkO3ZiQa100EVjvntFXo3ownuNboipZgqB3pf/t3wnFg1xp/HlN94fSOqC6QiZ3rMku+bxJFXXpJm5Rwo/NjQDB16JrS8rIbJMSXceN0i5D5r0Xk0yaXJB4Q9utngW656cq/Zlfs5TtKiUA+vsPMMFaZTaq4T/zwmbsZif74iDVIs3mcL4qJTDVvkOxvJv7c9T+96SMBeAoYN7Bao3Ac+vaJahGx0aEpUiulANmvXl2jxGylf0zUdUHuZtnS2wvS3bml4Zt7uCckwQMsaEd+r6WiymSMGCcV1RxrwdlJmKs/olORSdLflwYji5Wg1qhvoblp6N0FXjuVnw9+ZHJcpdu80ZFPPZF2E+fH481HYb4IP/uxImKSFerfcBq8MzaJFz8VhBR9BDh90Fhbb0TRdTdNTDBZmaO0onu2xd4cBGrLcMlwas20GzBdqvFNc+RaH2yg5/V4P3iZdTlzbvVbgPNt/aMzizw7Tmhn3L1comkx+GJuDeK/KD33rRBPWk+62T5MBEC/7+Jm248F44avXoW6wYKaKarmtTnX1Rb7Li/31ki7Sm65Cq1bFrqxYIopoRHZoMxP0S9wwpCPWFpqQ+pkH28bW07WtECI/VjetAh7ks5pOGKXmUojHRXV4yUox4lsko+7LZzkjandlIasPCTM1rD4OsyVFMwi8zfDs2RL+2rf8G8au5GS+DcBf+IffQZ7B/Iwl3zXUi5Zi17R0FdVukp0di9cmCXRmKypxOnUTNwSF7SiKYJOHiqEboTmpA/UhF1Rm716P16KMP3XvDU4O9jioO2z+yinyAt55x1N8uLyL1d6YZ584xWQqprjljozLZXMUIW93K0Raq0ObupLPu/Ljd/LEd22wX3d4+fAKi2bCkQdGvHvpUR6bneZLeufI8fzI7uvp6JpcNayaESurIz7x/O18bHoXf/yNH+bvnP1prjeLvK5znSerZZ6slpn5gmrYCqGSfRckWgqQrL8AbGFAybXUjU+F6jxYbzZduRdU9B0PPvkomBzz2AULtUYtVvQf66TCIQaQKC/TISlaGpq+8HLnS4euLe3oNd6Txcinglw5cUgQPm97v7osHN8kckgJTh4t0h2pXe5wmmRoeH0QsiURYK6kgDTte3W24zEED+FGrrftyJSmWoD+ldAoBpQ0ctwPoy9pA4x0loBoxaYgiiu9agsy5RSL5zzlboHLhKvbdOWY4vN02InGZmJNNz4lgWcRGasGQlNTwZ4vbqjjY5pyV8S28yVN3ZciIj8Qm9csaDJQMFmXNamzCZ2tnDqIO4tdE6xeD1n1+fbcRzR9+1WNcLD3MhEbV4eKFQ/eBZ5xR6YXxYGIXqNX+fQo1EdqTLehXlKYsUbtKglPOfQ+eEHDlW/tFdEeKuFpZwdhHZtKQVwPQ4G7I2BqzD+I4kRdtYW4LQLfOoQRiWZBrkG5ZWj6wn9WXorafCz/xnZERGfmKn3v+VJApQ/RbPRczkO6lw8l7Kow+UvXPSO5fuEDyj0JTjPA9KSj2Nap4C8uFdSLjmbRCuWg9BBoiHHyoGvI9w59325Y2wwJzMlH8jnVmmP4bMbsiFCe/EKD2s/oXtcsPePQ1qb1o+rrkI4r9+HopGa6Bp3tUFD7WGgr8IFzHvzj5wvQ3Yz3ikp+/2Kx6lrXE0/ycZfApXaa5rXi4LRm6VyTRM3x5Qr5bv2rnoPbFJ2d8FziUzPsCWsZ4ljiSp2eXZC1VtdyPTYedGQTRbmtEiUtXuty1zNdFwOC3o2wTjfhuVGGg9tkgj4+LmuKcjL1qodZuEYe27N0raabWaarQmFjP6fyip3K0OlVKOWpqoyiaFj+UBFoseqW7x7POcD0Zp+VeQv0+bhfhkYl8vchNNDqUIASHNILtcJa5dq1LK1T4fOTVqgUhMHn4VrlHt9z+Fu4rS+i1xeR9PR6SRfpuvaQB4FWfJBCMQ6hsCy1WEWFblshiKjXBl27UHgLepnNPTYW4rb1kPZaCp6IQkcbK1OFdLeObJg42L3T0PRFXBYfTm09ZubRwdJONoowKlOIql0LL7Dcb/1rxyfhgYfPsdEM2W4GfGz/LmovccG25wSlKT30LOwa8a01ism6vHc2B5RJ/GY4RPmZtgp9IE0M4sLj8hjooBK1wlQ+8DsV2UQEMtemx/gH3/gTHLgOu9/9KP/z538fm9WAB1avc2m0xMqZHRY7U84/e5wshCU1nVAYO8XohHByo80jkEI88GCU52fv/vfsuRk9leO4QO0dne55Pjc/yrYd8KreCzw5O0FHNVxVy4xnBSeP7nD5mXWeHh/lsf1TDLI578/mvGn4HEZ5TmdbSbSEUXjXuo/oRpDg4qBdBeJkBcSVIDkbKImDb3qSVBu5mTESW6z8YOG8whZZSJvs3LKgO68Sj7ruy708WyoTup4413l7z8T3PrhNuPG9mz4Vs0LNaos/AF+K5dh8SQRhZh5QxDmyybiATmu4hRYSPssZBbmco+iwYvN4ctp7aLIuCHYME3O5YuseRfemILWdLUGtY+EUnVPSd40ToFyEWDGdtOkE0bUFlR96Lh3JM316pN0MY4GinIjVmr7CTKF/U8bxtpTnXc9bUd7BabERnazrIJJujydOQJLdYKBVzNcc/YsahdzXro5Ng7g+RDeWatljZorOFkSKRD4hnHN5ljobYhG6+EQmBXEo0OMx1H0plIo94Z6bufCf58tCxXNa1pFyB2zf4EsLg4ZsoxTU/pI0LhG9Vnn0Wof5khdbuL6l90zB5I4Guz6neLKbBHLVskUvVUz6JapW5KNDgt9wXyaKVdOi6jpMyKolcb0qdlVwqJCCMvGTK0ArcNxy/uM50KqlyTTL7b3qcmgGlnLLiHsNpORSKUhDDxhEwLHYjnSEYlun4t1rT1Yputd10jHF4wcSHS8ZBHgp0OPLlaCCXahQvxTdSxmzVRGSeuPDdMFLgxSyGVwWpq5zG5oeqQpHd1iykZEp5kHYr3z0EleUOz55o3c3fQjYc8HzOzrY+Ha9OhS0F5/vSNuQvcmzdO4w3zEgxUacvSTER+5jmbCEdcO09DU5LwKQ+VzjlU8TS6+VpFPvwbFH2ufJKxEzz1c84yXL7IaslfN1i88cvRdy4ct3PPmBTBeKfUc+VkEXBNlMoa6HZsDJupZNelz6esvKiJAnoFG7BfOjDTOnUMZjMsfkxoDxVzlWPpXTvy5rBGH/dqGoRikoLC4zMgE0AtLgvAAKpWbnXkV3I9K8gjV03QIFsRgnUB+FqkQKs0tCXQU+a1F0CFOZrkMH6o/teNyhv//i68X5ekkX6YLGysIQ6Rx1TwXXgjgmJ3Ce5WFperoVxCmVioXkrOBaJMjlgR+btbZXUTgSi1pBqx1NrYJnsiw2ySaqalXg0Wu2KVVCRiNS7zIVxsQhVCEXt5Z7hze4sxS5+YPLl9i2A87+nhvcXd5gz/b4gf/r65monOWnPHXgxne3ImohIkLhP0uRGekq0QEhumOopk3bVITI6LCpxYJvfFzx5nd/lqPlPl82fJI/9ht/DKaGH91+mF/4yOt49avP8Wfu+yB/8xNfjb5R8q1f8SGeHa9T2Yzr62PueGCDxmky7bj0Y3fJe552LD3nySaWnfsK4ctGoa6CD/3AG9B/6zMMVEGuMrbcmJl31D6n9hmlqnn/7gN8/Obt/Pd3fZA3di/y473Xc/nqKt/45o/z3x/5CAdOc6VZ4LZsj31fsGu7nM7GIuyMolotARexAStGbZEXEVhoUV9J5tQBUdGJI62nLcLSdIVTPVuWxij5Ns9oaQaHBacaucGsD0E9LecSJfQavE/35O4Zw/IzLgRvKeGwR1TLxWOV8bWg/1DsywWu+8H7fObTBmHqKGYCwrMhxYgKvPFIF5PjSY4TuewuuoHBtVixB3vT2oPTHNzuWXo8C8ce7jMrNILupk3NhC1U2NgCvWoaz4NOjVI2kwbIhOfRltJURVci0YW0hU8283R2IRtb6oFhfExcVibHBdkaHxXktnfdM7pN0bsGk6OCAGcTeZ7LnaA1saCmgXfc8eS7moOXVwwfL4QbHpsMHTmocp6yiaJakMa03DlUeAY6WdOB/Tth7TE4uEuQXeNi4UjSxPQvOCZroh2pBkLLKXfaNUcFnjVLFXm3odroUi07UBLaFd1YnILJvRVqP0PXinJTUTcGvSVie3NgsLljerpBjw26UjBsJOp80KA38+Ro0lKIDnHSHYEyBIRpS++KiCinx6TQApgdt2T7hvwAZuuOfF+K0/kRASGUk+Otlj1molC6pd7EZ0ictjRNX25MfSh5VDctut102+Yq3n+2K5MCV8ozCop66JM42QZPdDMHIhrvIJ+1fPuI+E+PezobKk2b6oFK52e2JimReqrxHrJ9w+KF1g0sAaJh/RXqj2Q/yHdQyfUk2uDK8UlRaEuhn8Q9qE3fFK50Ej7GZyykZR8u8SJ173BwUPpvELEXozaU6bDGQIW1JlHKtKLpm1R4xv3OFnJ+YzqprLvBh30DVp4WlxeX1cxXMkCLuNz6Q9x7oZrZUqYNcW3z2rd7tZNja7oaJhJSiBOHo3roUZnD1wbvPK7RlGsTeu8f0rtpqQeaaij/pulCvSjNvO14Fj6XpylyNVTUPU09kPsNBdVqS7fpbngBymgBxPiMxrUz6nEiPdEblVKc9US3IFrhsb0w6cYnNyRvXqRw8ov0sP5/8XpJF+mR82sLxWxJ+K42J4wAxXaqsyMCFymwwwgw+PdG/9Ns5tPGHiPclRPuq1cBsQ9FiQ0JitnMY4PgqOmJv3U+coxOSky4ruQBtWEhj3zNyENPdnzR+zny/0IB47UgNr/2ww/zS0sP09mSsfD0gRlHVg7oFxWTusBrWH6yFT2iYHRc0LvehqceCP9SeS87c/g1EQq2G2y1AG6mWuuujkrWbsVYlFhnv/YcW1WfJ3eP8nWLn+Lld12mcob3/uQb0Kuez18/xqzJ8HsFrvA80L1M7Qwf3riLxZ4oq450xjz+rx4kn4ax5/qMa2/pYlcs5cIBvfcPEzoGcg0efuzdfNsdH2Mt26ejOvT1nCU95flqjbXsgFcNXuAbVz7OdbvI1WbAvDF88p3/gL989V1cqPt0dMM9+S6FUsys5XXliA9OjxEttaJriiuCD230ww3FhVdA4rT65HEuC61K+oMYxCM3SwjvAMq91jdZfh6nCYLKm9onm8WIdjVdnQrgKDhquqGzUoL2Tt4w4WAuth3Hfi27hWMaPc6hbTij809Cy5PwLm66njzYrmE91aLBd1SidIF8fD6VJEyvAnp0VorcaAEp97rcS9nUU+yJYE4mBeG6BnpDPvFMV43cn+G8Rs/zbA7zJSXpiNF+TYm7Sbnn03Ned2FwzbF/m4gkp6sCkQ4vO5qupJ0mx4e+Sk2J13KOJie9oMw9QfzrXpg2BfpCdxws/xbEASQfBeRwpWbe03TPFUnw17spiY02rBHKeq69WUYwbrViNjDMjin0VHP0E2GaZT3LT8vXazoqOTxFGoMN90o2gclaKGKjo0uDrHsF7XqTgfeKepbhM0+2MqNSXbyC7g1BiOuBh0q3GgAl1B0zJxU0zOS4febxFnyt6SzNmNmSfBQAkBpcj0PWnKF4bQR49JkU1VUwtpAEY0HLVQOdIJK3HTATTTN0mIlAicoSbAhJAS82bxsD5eTf4cV60hkRoHY2VQhoCs4lo+gK1BbWroyFNJR1eEZK6a5t1zPLJZnVC41Z0M1Ak3EmIMBdQc2zOSnbQpo3aRxGp4PTSw+x1ssd+Y0MNyk4/jEr+1d472gukPIKQuFe7Asin9aWgKLHIrez7cjHUjj7TPYhoSaGqa1SoIRvLjoWmZJefaeluJlz7OP2Fh1InOglelWkaYSGOTZhxb4Va+O6BTpQkllgao+nbQqUFVQ/rjv5gQrNVeSLyH/qnqIaGrKZTlaOKGlOp6viXBX53nVP1oHZimHxvGW+qA+J8UMNUAjYcuKDiu0HwppthAoTRbtUGmU88/0S/44Re3PDiZ8tRPh+CIho6ZhtE1AcSIPhN0iASn1RxPTZ1CWKTJyAxjVBinvRIBymT7lMgDmXg+tbzMik99BTjcs9hEkMvQalPGb7i5z0F/vrJV2kRyFdTBVUVkbIqSj20PTkJo4BNWYmavLoyDIbSoHV2XW3iAi9TECTrRu0m2bkD3a2XXrPakG653LXUw9EtX14VFr3JUUwimLiBhuTUaPQSFTgBLoNTI7Jgh/FSMXzHXYud9g2wSt11dO/1qIxXgn1wQbrPBPsBWUR9kmAFlPSYiHXe8cGR/sHPHH5OG675Cvf+BnOj1b5yvUneefgSd79r/48G1eOY2vDkZUDfmLnDSwUM/788V/j29/8R3Dnl+iWopJZeVzjM/je9a/nHXc9wxuPXOAXfvlh9ifr1AuwFGwctQWtPb5R3HvmGk9fOA7HYXBRtZaFSuH+zRp/5H9/nucbyyRU7xbNw73nyFXDrutRY+iomifmJ3n7qWf5gc038P5PPsgTH3459/3Zz7OUT3mgd4WXlVe4YWd0dI3NSXabcQE9TP+BECkfvLwJjVwUXcXzrXx0FwjN3ciKO0zYSJMtXChc6hivjiA90Y5ROKZyAK4QpEs2KZ820dFJEYlmYzjyK13qnlzHyK/1YVOzpWyY+djT2XWwGz4rIHfa+sBFliLY5YEjHhB5GZWrtMHE5jF65Nf91s2kf1Xu9a1XQrklSGYWHTdCMxjva/yhonMWN1XPbEUK7+ieYPNgsTclRcrrGmzgoMfvWg0FSR4fD8mc8fnsSyPT2QnNRXjmOzuWaiEDA8tPRVqNPId1P/CoozNTbN6MbKo2cHKjCNg3SsRdCrKxShMgU6uEVuZjT7NkMQcG5obO1Yz5qsMtNtS9LK1VySWoEaS9WmwLpOhxHZvGKHS05a1NT7we3gBO4QEzMriexvUsptvgN7pkI5ieblBzLWtIRhDBk6hM2VRExOWGTp+V7WZU+wM6u63LSkSsVUT9TVsEE2lah2hDtisTiGT9OA7IsYFm6HC5J69AVyoJZqOzCrpt7uI1AKjunOG9Qu3libqS77ce901H8i0qJfkKibJk5drXg9A4o5ifqNGFpXi2I+dhW/4+comj0DEGGmnAhvNQH6nxJqOzIdqPhfPCEzcVZHsG29EUezBb80G/Aj5MxgBU45KIPDb4w4s2aaGSVkPJ/Rxpgbpuk0RVzHgogmOKDnQUFWiagdeuMi8FYUCe4/MUC3YT7vvD9IvIXRf+txEXmBDOFQvY6CAmVrIC7jQ9ndyVBDyQ4v7aW8EvVajdnHxPs/qENBIHJyVXIIm9dZsuHXUH2hLWKbjypQq/UMNck+0Z1j4dn4nwvTK5F1efcPgM9m/XrHwg49JXKrH5rTSqMVQmh6YtepNLVk8H44cAIoS9IK7/OmjTIjKeB7AvgizzRUV308l0OtCPUuBcdBCDNFnYelCjVGgmGplgeuMxUxFSuxyYFdhhg3GHqEkvmle8IX6HX0Lq/53/nP+br5d0ka4suK6M7cu9wK8+XJg6RTZ1wQtVUgS19TRa0b9uabpiRxYXoZTkGK+7IsWPy8IkfLrBJRJFJdJqYhAQQP9aG16Dl7FnLPBj4l+kTUQ+pwQ6yNg+jRkbSaPLx7KQT49E1FeQsmq9Ro9NOOiA9IeCMNJ/oiMB0DrXhAXXH3qWHj56nnu6N3ho6TLOK376l96KmcM/XriNH2y+iuGrt+gVFWeG2/zmx+/n5z+7xt1vvsD3PPtNGO3xizWTacHJo3sM/ujTPPrIWfTzPX7j2YdoFhzLL4goqHc1fDcn5/vLzjzLZ4cn2RgPuOPUBpc2TlAtKjrbscnxaODReckxM+Kq6/KnP/ktNDsdcKCXKv7H17yHN3TPY/C8rnuer+4/xYE33Pb2Lb7i9zxDjeJDk7v42v451s0AGHChcbc0RnICpSnQjTRd+ViS96TwalFuD4l36QJCZAIFw+UylsaDzuTeyQ/ajThyeOfLIazEespdoWE0Xd3Sr8J4uNi1YBRYT9M3DC85sVQ7cHitKA9kI1QRtQqWm/J9hOMe6SG6Doi0IkV4y5hYBZswlTbCaJMnYVft1CkWDPF+E2GenLNySyU6RaJp+LbAEZGsFMJRSKiMwh9KOw1DiNQIq/iMhGcihm8REPfIZ8aHzw20o3JbhI4HA8XuPYbVJ+Q86UYxvGzThjtdNUxXJJ49Dxzhcl/uO1M56r6WBNKZpwnhWy6guQufz5mcEJei0e2eagk6jwtdwOUtV1bNNHa5QXcapidBFRazWQTq0+FiSCV0sdwmNTTZKKBtlXw3bwI6m0G1Irxzd7lMzZTtOeGV3zcnv23EfCSLj9sraPpyD3cv5pIU2mmR3/TdgnbEzLUUtIU0VKZSrTgz8M3jOgWEHIYWzWx64b3m0AzatUbPlVCDfLA/DE2HqiRcJlKWlJVCJZuEezZr0fMoUq3OzPDTDD3VqFoxX7MMzhuymfibZ6F5cbncnzaEFWU+FN9Wfsd2wzrcKMxWiSuh7ogP+vxYg9vKbrGmjemnKvL7GzCjjO5NEUF2dhzTNbEidRmYocJMw9/dDA28JtEQ4wROzx2u1NR9jTnMZTbSxEeHFV3FyausN+0kT6aq8TmNIXqRMoYCnOf0z2mUa4juLRwqwptIE23aBjc2YvF3kmZo7trC9bcUTO4wbUbFgjs0Zg4WntV0dgvR+Gih8nmtWLhkE1gRNTDCsW/XNVzQ04BMemqNahTlVksljcFsGmmgr3yFZeELOZ1NSQfFOdRejl6Zy7rjgotUaGoi0KfHLu0PXiuZEOmWKivnQwr06VHobsXGVdbd7oa4hNm8rRNs/ttrBx8yHKoVK17uCnzh8LUWDVDPoecaOxBBs2oU/cu/C8XwF1//t14v6SJd156MkH5Ztxz0aAEWUYY8FhcebKEDd1IK1jxwtKerJhUCsYNOQsEQklDuefJRu1CkUVTt2b3bsHjeJcFhDIFRXrjE8wWdAkWAhESZuSzwqSBxUmBHgUnawJU87FGw4zVM9vKAnMl4MRZBTbDaM3OfzsVhxM6rFj2J7315usyHr93FaFqiHx/Q2ZcNu3xBUb1zjy858RxTm/Pxf/lq3Msc/rYZ524e4Zvu/TQ/+uk38kdf8wif2T3NC+NlFvI53euKzo5sKm5To7xndJejd8nQ3WoV74//wCuFZ5rD2MOyksVt5z4RJ3U3pTn5Uz/0J8nfts1af8TX3/sYZ7vXeV3nAnm4aEeNYqgOcMDEa44Zz1q2z3HT5Yqd8obu+Qjs8U3Pv4Mv/MJZVvYb6p4W//ChbIzFKExH5hHt8rc4EyT7My1+4dZ7KRQzcWYRdMvhMi2THi1iRV1Jml60Vyx3SPfhbMWkQKDe9SZxOVGC4jS9MNYJ4345JmTTiALMnORMkI8c0YUmImj5OHgqh7AkHZ8V1dI/fmvYVnejkSK80JIsq0i+4HH0DoG+ZVuqhIrFXohVj8h3HFUrJwV0mihZaWRA7k10ezy2ABWb6L4gvCaEpOQTjz6QZnkWNBzVAvRuxEJCiahyTGuFBqnQOTgtVpo6iBTrvrhoZFMZn5udkLLbkec/emHHNEXdQP+KWLFK2rHDVOIzbasQCObDM5Y5vFVkw2BDcqhxjlSGfCL3YTaVAnd6VDjOMqIP680cqiVwmZewnYkm2yxp+l42bAXz5SAYvF4wXzJki3PhkncUti6F1mFVWhNTw2QFAY9FuS2kQch9u141PTn0RLWJ62RqdEMdmAs1xASkOlJN4pqjKzmH2RhmRwMXXYX3N16Q9ByhkORQrTVCT1K5WPBNZB1np4AgsLN9R7Zv0vWI9AaAcrvNJoj3Z3W0QU81WEV+oJifrlGFxS/UzCcZvQs5uoLBsxm2K+FFupJpUbUo3z8bhcmQh+51OQn5SCiU/WsuNMqK+aqisyEBUtlUAJ+YjB2plLoRzVREu22w6Y3PjNzT8sy6EDgk0wCHV22ar248TaB41iFJU+hzrTtTpJ8cBgRspMjQrgGH6VBSmMe1UI4jUiYjmJVArljk2kN7UONxhU7T7sG1UJgfQuKVC1O0yKn37bHkI5cme+W+vEc+9kyPGXrX5Frno9AsNnEyJWYQ5S5Mcs/41VOmVzroWpEdSDPnd7rM75ijtKe4WgC21dsEp5x4DTZfaZivW3Cekx8g7Qcg67JqTNpnkwNVDJjSiK981jZPsXFJNYcC+jVMM1Sl8DlQOKwSnQhaqC/eeKh1oiG+qF6Hrtnv5Ou/lfbkJV2k+0MFaBwFR4qAMyrx1SVtTXhu5YGIa8q94PYSOt6IGMr7hsv/W1D16JeeAg4CWq5rWHxeVtFsfugG9fLes2WJ544Pr5mLKtsGG8dsLp/fdGVjjzz22Eh4Bdq1qK8zMF1TEkmfbBdb5xggPbwxSMGFzl3eqz1HMVH0+R+7h+k6LFwW6oQPXsL5xFP8/AIf6r6BegDdkWf5Cc3+lziq7Q4/9htvobOp+dSdt7FXdbh4cY3O4gy7Cvk4TAWccPf0TLP8tL1lw4jnxBYqIf3Kw/JTwt2rgviqOPBkP77EyC/xSHWSD5eKf9JTh4Sc8r0jjx4loUH/04KgdfVKw9LJfdb6I545d5yVETRho2o6IX0zLKg2+EdHN5OEHBJDodqF9xYkJZcAEB1GpslGs6PRtU5IINy6iEV7y2zqma5lh+5rlf5eebEKLfd8cjYxlRcxmxWaRHSrqfsBhVFtQ1cNAkpvW+QsHqOyoXivPJe+Aug3nPjlnHpg0rHE45DwInWoiWyRssEVl56ZRDlzns1XmFSw25Aym42ksZmuwernfVsAOxf0JGJhGQvIFomTe9mWBF663NfdTZlE5ROV7q1yX/43WVdMVzSdHSeFRi4Ut2JfBGjR5cPMg41b34TrqqkWpCjIRz5xYl1GcoGCiMQq8n2Dyzx1GI/bntw3a59UzJZLDs54mqHF9GpczwGhsDJyoeYLrUvV6E5LeVMErtHL2xuhbbjCY5cb2MrIJuLNbmYq+DDHewa6mwqvMvbvMrjlmmwjp1lw6KU5+nwvTCtaak8zkCyGetGRXRHRs8/BOyksvQKdtQ0Kt1B1QiNhYoEkf64WSbaROvjv2448k/lIivJ8PzQVE8V8xZEf6ED5CI2dhnwrS1SebNdgew4z0rhTM/xOgZkrlJPJqNi7CK2mHoArHZ0NI2swJL//fFPQcRNtIncy7IrH7hnoOKZnarKbOeW2XMdyU1EtemZHBN13hYRVxYbAzOWc1H1BipSVe8+btpiPrjXROSpOWyE2psGVaSb3ZKRlRgF31EeJbkORzxxNqVKEfeR/H25Kk3gz0vMiIu7/Y5VU2yBEd68I5OydMSw+b5PZQaTneSWOaa7Uv+XzhCcfHYyUDnvtKABrjQcVr70PJhByjvKxw0xtsFRsAS/5fopy1wWqoOLoJx3TFRFwVkOohjo5SA0vhePM4cSvZEDG5kOtK5Ezglz7uWHwTMbSOZuAgyjSl4wG+Z71QvAub3TS0Rxez4WmE1OjNVkIOALCRL890+mahe8Vm3pmpr0nctkwVK1xqzWMTPJGN7O22f/i68X7eskX6UDyFM1HPozrhRuXzVpLvGLkUmKarlq7uvh0pUUDUopiXChtrqiGEl4xfCGIUH2LHrjiEDLt2mK/Gio6uxIV7DXJU1oEqrKoZzNZdGZLUljl4xBIo1q+Whz5Y0hNQrUA5nmfBDIJAVWkCHkfLaIULQLiY2FGcCgJSXIB3do9q+hdFzuviIRoD8VIirmmoyj3PUd/rpMKpmzq2HzmDryG9Uyhm74UWwGxvPbllu77DWufCqKnwE+8RVhD65rjtTQ+vU3XcsSNYnRcxsd54LTHja5N4iQJw6oFxWwVhhd94JEblFvigCWOKxkJZ3NHlUfxXChuctrPDP+NqHUsNlqPcgKsGMVcYeHP5e9V+Hm8V2PhQkDq43fXFmarKjm9SCJg+PdFGKvWit6GE7QmNG5SNLvQ2Ml1SCEm4fgTV7IQ3UXd1+lejQ4q0UlnsmboXYbp0cDnDQVH5MQXI0e0qtOBxx8dVuJIPo2aA4fcFUJtSOdKRTcOUijMzr0Sg14PpJBZfsqnxiU2NoctzGJxOF1RdLdcG0UfRsexGc3CONllgnzWfXFFKQ48tif3fXEgdDScsDc6G575QrBu7MnP87G4vpiJWMfFjbY4EItFZaHcgoM7HQvnYzKjR3kltKmRZ+/VFcwkjMtvlfQv68Q7jlawPlfgPAd3i3jSZ1AFwWMshusFCfkx2xn5WAUhpvxvviT3UrUg5zrShAaXFM1WgVfi1W6e6TG+3dHZ1NT9kNQYeeC5JI/OjnpcJhHkugYfUOj8QAqR6Fsekep0j9fBESVcfzNvr3sUyEVPbBe4wsqD6/n0wCXBaAVNPzj5zOSerI/WqJEhG4tbjbnQRWceW4rvOh6qVUexo9FVcHqpZGJSD4Xb3HSDk4sm3WPzFQcLNfnlUhItr5skovS3hJCp9B1kXWoBAmXDxCY8mzZw3bMp9G82VEPDfEGmO7MljSugu+U4OClT1pWnmvDsBOTVSPHqcgEGDlN+4tpsO3L/uUjb86Tk3UjZTWDP/5u9P4m1NcvOA7Fv7f03p73d6+NFREY2zIYUKZEWZUs0q2SVJEOGXUYJMAqwhxLEiQbSSJpZAwEaCBA4oqCR4UkBGlgulaWyVHKVGlIskWKyzz4jIiPixevuu+1p/2bv7cG31t7nJQsWB8VU0JEHIDPixr3nnL/be61vfY0vTYGtAYe8cx6QrnmhgFVGtSENSZ/xZAFr/Nj14xr9EXD8fsiNhhXr2XRBQYTKsjdqoNrG7CZjeQ2cCAD9UaXAW3GnMSpV8oLuRHD7uYT7v0bwLVUO1Tbl0DaziI1Kj3OB1LL5E+DmSwlxGpj8WyU8/u8c3EiXqcLD5/cKE3LqL37cIZ72GbuLlctNk1FYhmM+y8EbR91l8DBTdg7W59zMuPKMpypBdg6pSZDBwXU6SVWKS5gygXWcx+zW9ol7/SC+1if00L//9aku0s0GajiiNRRA9JGuDVCPav48eUG/dCqsI9pqhUC9oaWRXwF5VKN7hiEKfhDc/R0WKd0RV0RJpSAaZqILpG463gqLgrgdClqNTmEogVdeZqWuJ74n5zjWFK0lLR7TRNRm8iASedBiWkeZsVJE2IJqQCT+0DpynNE324S3Fj5z+s2UC0g3sODfn7p8HuodYCEabgDaTdBF2GV0xsRDq8cVfJ/w5j9xLEQMDTkQy4xzn5HXww1/nJakPUMaJAo2bwDLD0rjYgWKbTK+S4hzwfQ8wu8L15eTFsk0DcbYMyRonMiB/ZgVhWXKkhu6VLjdwWw0Bdny09DpWAvEcwOqNwn7Ew9nm5Wi78n8pW2M3QNhUgKv3MjvxbARblB+X3isLHoEITl+/4HHN1acSGTERl1brLlzQ8p0jViTypLFWAOdMZJzGGYJ9a589jDVYCY9DrufD/mbsQIcpEyoEgClUBgHWfrDa6XnDsjiWq82hi7xjaudCs5CcWQS5YbGhoX3MGNR15+Q72wJxH6gIBVAPubuhOdudh7ys+m74rW+Pyu8fONd915Q39DNYX8HWH5EWso4o+94dwJMLljc3r7D6zgcs1iRXgu7Wy7VMTqgjdi+CczO2QCZ+M54xtWty3qJWAHdWz2q8xqxVV93D1r9DaUw7I8BRHLyzZEo6T93pwfXbAS2bwUs3vO4/fKI6UcVud1LYDwdgZGCUXvuhiO61tgrNixw4wElhuJAawpRnIP0Htk9ipi8dBhnikCbeLkHQHYBRXERaK4cuocjZBC0rzz8ntOUYan+2O/X2D0MCNPEhmWgOLK5IsjR3aXV4aAhRM21w7iIQJXQvPLY3dc1Y9AJSMvmcPbMIb5ssX9MQa0Eij8tlMm88esVz2l/pE3ucLBuWRPalf8dJ8DsVciUjmad4AYG67iBe8mw5BTDfY3XbJwWAabx/OXgOeN5TQfn+OChBDJ9InmGz02uIhBEgSjopMn2q6jXImFYlNA7K8bt8/anHpu3A1zvMTtX1y8Fvl79BE+ABXTFWuB3pPdlpDmWxsAsCEMtaG4ChZEOmeZTbXlgFGhKpuFYQjannWzA5k+Mb89npT8WmDYr37PahNo9PbmKkG84DItK0XEHiUFF7kUjYnuwaMDcvd+IwK/7POU2JLw7dphcBvg+obmq4PvwOk1GgQw2m3oM/iCjxKZyeo9UsxFpOiJ2HthUSE4FpCMpXZCENA1IUbIe5IevT+7rU12kSyw+r6awtpCYULPAsXCYcaKbSo3srxprQb8UbA4CdYxHBkEO8emngslFQX9bFe0NU/bUsTpAVpRyQi4di9acOCbAqz/Kzdx4s+OUDhDb+9zoY60IYuPLCCxaEchC8eYL3IAOk0kNmbSxJkCRYFS+aIIuglrw1OtCC6m3RATbaxQP3Y4Tge3CYfMYCFOKqI7e4/dwI5A0rMGiyWOlFIWe52rzBp1m8s/6lBfqceYV0U+oNwnDwtHaskuKFmtz5SQjjfMXEZNLyd7vADJNxP45ep4QFxKqrjgg2CtMRHmbumCiiJ9eQ8RjQhDR4hz5u9Qb8ig5tnaFRuQlB1NITJCRBSTvUwAiSCjF6/l/scPiX855rImo7DCnniEJnUmM4lCvE2ZXIdu0mXNPFk+q1d9h7HdIGu3d02km2H0EKQWoB8amIEc8FwnH7+mGmABOYGhjaJMTQ3zGlsWEPRfZou1gEpG94KUIvcJUXVq0kDD3EDtXJqiyTTC0gkGLlcllJAUFxfEhC/oii8fuhL+7/FjT/FzhdHulXiUnXBvM5k3dG5obXsPV24LJJVDf0HqxWQOT64hx7rA/5Wi9uWWh6Xst2kZg/pT/fPwu7w2bnkEcHXieNUR3K3LgiTYXd52oHP7uNCEcjZA6ApHhYbHncdcrpVdpcml7E9HcSnbkAMh53Z/5fF55HoHubsLsI5/pRbEmrW33iKhiqkhL819YobuYAp2D7w7WVaUeWZGZbT21UDWE1ASe23cGTJ7U2H6RnuzVlkV3teU1iYFoeaoS6huH7k6ADAK3d+g+02Oy6DC8v2AAkjaC7YXHcKzTBs/11MSXfluoAG4UDAsWpHEW0N9PQBuBzmFc0OkITYRbe2w/E+C2HqlKmD5xuVGzpjFVRNShzUW108Zwrp7vB4jx4ulY7n91FaLugevk8smI0PI+2rwBjLPyDOVU0QxO6MVLKbsHhUbytDcjuWN6ba00YwA/45pfUkWRxd0SuEZZhogbbIoHRHDv2d6jlSkEePSLAr8PLKR3kve2s6/Z+lkEq2HqMhhixxOnjjTUXWRDNpCacziFTuoHXxp/yUYLxm+XkCDqU1+fc633A1B9RI/z/YmgCsDmzYTzheek64qIePTA/kzy8zt/FnH5o9QBZGeaxHM6ti4f1zhxqLY68fIotpOOtcT2XoWLnwxYflePtZEMyJBWRtTdMlC87oVOszpsf4kNg/UAwLWBrsmd0ykbAJcge4c0CXBVRNVF/PD1yX59qov05OhZLsYDtJGYbv6HqYvVTrt5S1rTYmZ/6nRxKn/rRqCf00YRSfmYB9x32gNGSBRs7zpML2IJJfCA6PjdBH6xKsV/vaGXshU6ogjh9JWig8aVq4Dzv9Ajdh73/m2l3Ftk/9vZE46qAeRNILTFri9M+F7VNfLmkYR1/iG6YciNoSB0j0kZ3W5uEyaXhqgqbcfoHg7oj1wRv9mmIiysmhu+NwD03pUNR5C5hSUdtow7+6XADZKnFOPE5/MvEZi/4MJ0/QWnjYUVd9DNxqrqMqIF9L8rWik1kZJx6mhr5aDx2bqZHaAbweg0g22S3FjqTQT2ipZoU2H/zQrlYII/LdRttHnnH88wzHg92xsKjpNjcVived7HWdn8Oe04cP5RXqkt9KkSbO9RgGoNaKwBTDxizeYiKeffRM02ejV6jZ0/irx4D9k9EVptQsQ2KMnR4kYvycFL3ydKtrCTQ3qQ39NNJTkWc/WKG3q9AXb3eN4mFylv0rx+JZXWnt/+SDB7QdtTv9eJ0f51NNcNQLcsRdc4EVx+hfzl2Qs+p8OcDj4pASnSwcnWj8lVCbyy5nb+nJ7Tw1xQ3yqyvOU1qbcqGtVGiBaXkmk6VmxW24KWJifoF4XK5UYgTXgAqfOo1rwPRi3s25uE7QNau7Ep0umg2rjt7nm9tjrJUNRXAnKTID2nDhKB5Xdpe7f57IjxdMR4MUVztke/atAfNa9pKPojpp4aau4CgBGwiHrflXVy/m7NwvqDJt8H47xcm0ppdOYshMUI3wZUdUDlIzZPF5CGzjpuALq7AfW1Z9BRALp7AUOglaTvzIrS5e+EpFONmwqxiUALVFcVxtMR9UkHkYTqXsC87TFEj9vvnDLMaCfZvcWK86A+6cMR/9f1/O6WD1Dt+JwbFc0frEX7U8f1QgoqnFTfECfU+dg9Fj1II7NznqyRljwNJLWIBV6oy1pJpxkDLbg2Z2vXpA2tTm3sveitjpJ6qda3fp+w/IguR76jIJ3TMWoXSMs5yI0Q+7LIz2ieFEZA9glpWv6bOWmZgDJTcRIoutcC3+8Tnv4spxv3/71OahOF0yygSz5EtY3AmVeevO49J1zzVp8Dp+yLEagidqPD7U8HyKuWehkYLajQ9ozmmIWeiedne88DAkx1Inf7eUCOBrS3pE9WWx647wgU2nSjBEWxoR7nbAgPrW7jBhSGJpCOUycgcE+ETiTTdY14MpZ75IevT+zrU12kGznMxvDkd+vG32gRE1RcaaOnq4j+uGLHfkBz2LzBMa4f1EN8d8CbFqKGADIneJwI9mcO08tCl3CBm/wwEzQbRT1b5MUxqACs2usmqWi0jfLt9wyRvPfftZm6QouohNXbtF48/g4vvRVBtNAq4tZRQz7GmWTxaBIGbCw/YJMwtoL5y6DFhssovBVqyQHDjD/vFzyfRG1jngykDXl3lmBnG5YbEqav+N3NQ/xwxAfoaLGmTZaJ3kgtOlh5YsI4o8WYBZsMMyJJRx+Qj7x+5NRJRtGIStDeBNQ6Yk2upMG6ALgxInV2nDxWcykw4WizjpxmxERaRoW8EZobhwuA6wJuP9OgNq644xjGdAlFWFoSa22Tvv4SEM5GPPiXDCJqVgntDTLVpV5zw5u+CplXaptw0qnFYYBRvaZQzlxpktNnInCsXm8UfTOXi1g0CdbEWaGdTBSliF6UImLLzjFKx/B0MMsj+KAaDaOQmGuIVxccE/b1R8jjfKCg4vU6oQnIm+IhtzYqTef6R5lUOX2BnG9gSa6GKHfHDs2NVS+2OfL5bq+B2cuIyy87NNeC+Uvlse9IQ/N9YmCQtwKM56o7pu3jMKONqx8c1o8lI8jjjPkJ3bF7rbHM512RddH1CtCNW5HD0LLhbi8F61M+44t3Ky3keSjdGc9FvSkIdr90zFLoiHIb99/41ACw/mzQC+URa+Dou57hTBugO9YG+D2SjLdvRAz7CrPvNLkoNE50nKbSBLJOytQt45Nb+JKFtdj1Tep9HiZEkH0nuTCTCLQftJAfW2HSDgjBAbMAuawxnAS4zsHvHMI8wu0dwlFEdeMBl3IeBRNC7cblZ7UXHsMiwW8dQiKn1x/1GHuPZjqg62p0XY2wqzC9kPz9kgOChjCZfiJVvI/t5QYAuv5KIMdcEgpdRZ91MwXol8DyY4dhJtg+YJOYzh1mL0JeJ2KliccHU1KzJERKcAfgKe8dXgQ5QGRJ64yod/w7imX1YgEQZ1qThH7pD9Ds8vdJKSPJu6xbid4EoMgFLdW4LOxNH6ZfO+/RgK4jdUkTRuTnm0A+I/GprNtuVDtjBa5odKBBawJI1IRuXfuzS1ENNNe6hx0nTJ8Ldg9JT8PGI9UO/rhH6B3mH8trVBqASLhpamTk/xoNFCBd7unPOkzPuT49+NWAl18YUe0a+IHicYDmBTl/w3CfWD6n2h9ezIT1mzWq4w6+ipTFnesNWEdEEbjBIUwi0ERgVSG0n0y+yw/C3eUPy+tTXaTbIpZsnahR+HmJQriM2A60OAutzxunIdnjBIArG48JKa0g4qIZYTxvUd54vU5qV8YFan9CUaXvE9ZGoVFkNoHvt/g4YZiWgmuYSd6AXV8K2VhLDldhgQu4QXD8bsLseY1hgYx2GzoSfUHi6jWDkGyN7E+A4STi6DsuezjPXhU/WjsX9s++S+r4gSwEKsWUoqeKDtiUILRql7Y0AR9w8wXB6bd4viQluKEgziaqNFV/vQqIDbUDhghymkERnkWsG1Jv49TJFTdBayyqmNCdeDSriH7pMWjRxYapNGbNStGOIZEn7wWyi6gEWgSbSAlZJ2DFvIxJaTIJx9/rEL0gTL06AQCuJy3HwqoowERGoiUAD//HCMDh/I8J7v52zCP7fin53MyfB52eSL5W4VjyJkkU2OXN1/fISH5yopHoCRd/rkP13hTLD3hPmjfvIUWi3iZc/JjD/GMuLH5PYRhdgAAEu/68J0yIbWP6UAucA9ZvCAZ1RenvREyfsWAD9F4diKxlpwn1ms7prrD72hBByfdPcmxAHvyPLp/r7X3B/FnC/pRaAN8DzSYStZ0JVm8XX+5YFbvFeiWYfwzs7wKrN82Pmffy9CKh2h6IcB0/x4TLbkhYv+ExvYxwHfMTRKdu3ZHLUyEA2fEkTJGbacTy3EgqGojQCDZvk6dbX1ZletcDccLCY38HWfeyeehyAmp7w2Y6TNTa8A6KC0sA4BOkd9jfBeKEepT2wmXaTdBArN3DCBwNkMsG2zcimhuHStNX61sGBcEBUYXSVoDEGplLn1zxIbdsCNIySG/xe6Gdra5bw5GGtQSgezlDtxwwnXeonjcY7g48b3f2GK5auG3RsRCgkDytkhHwsfDejRbm39wiPJnpoi7AkymcAH3TIDUR1XWFCqT9NNdMjbbjShXpfhJft3H0W0A8C/h6wxTMxcelubWFXwAcfcRiatd7Oi3VhcN99MFYkHJBpq/t7nqlHWqsvfBepRtSzI2niTitofV78sHHluDE1RdNT8UkTGuIRKkxORBp4jJoUe35s2HhcgNp0fV5z01AtML/UHtlz4xuPsnx99xYcieGVul4oxRqnchrxR3RZmv+BGhSnp7bxDvro8zEodaJ2ohM9Tz5mgMcsHwfKiLViXWaMtBuV/Y2Q86ZMitFv+N5iIaAS0x48Cv6uzodPf5v5/BdzDSXWBHsoVMRz/U4IQWTya9l/+TzL9ifASk6OAno9jXcskfc1BSTTgNiFGDrIXVAag4Q/x++PrGvT3WRLhGAciVlRBZ8jMrDTAJU1rVDH2Ab9Uag3qecNHrtiXzVm1SCV5SX7Ycy7jZ+GcDfJcrMBapZsVCo1wnrrwxYdw73fsXlB9boIJWGHJC7pseiSJQVUABQrxUh3SiPbkkninqtf5PKhmgWjqEhWuB74MG/H1DtAvxmwHf/zwsuVkLhzDC3KHtkCoutkBZ170Zgf0pUR2IRnto5TF6ygNI252qPjAC7IeH+VzkabNYUsB6O/jJ/Xpio1p3p7awF5+Q6YH/qaS9Yl8XfBDguFAGwUzefUcWXbqTtYL2NeTRrrjdE9om0AvyeoRHs7pUQpXptQlwdw9fAOPWvofwyekUTOQ2waQWkoHiGjJmIzI0oMeOe16tesYg32pZdk81joL3hmNwNdGbxfQK06OG9yE3S7ECZaIdMv6q3ihC/N4UkoL3lpmGBMRQOU6wKAGdfj9o0pYK+oaD7hpQnUeqHNkBZ+Ahg8QzAU2D7QNQZgUXmOFM6QipczSRKM1Jhq4mEkxeIFrqVIViJ/8+aSNFCt1mZD7zLTWtyglSziWmviLDNn5twmnHtu3vc0BcfJ2zvSUZKZ+f8ve5EcPy9QGvEQEra/o4mCF7wnPVzh8l1gkDy8Ug6bF4Oiq8dqR7RK8Ldq2uHFQZa5zTXLELrdXkPQ2qDIt/GCTdPdd47fE93jfy8xArY3w8UYa48AQHlf4/z9Lo7i7lPbRyapy26s4TxOGA4YjHvwUbDaDPmyJPXru6Aj94UAWUWPjot5JWGMM5Ic/Ij4IJg/4BIf3tvCyeJ6PZRQHVdISwDxt4D6q5SrynopYOSNqj7Yg3qBnWIGfjZ/asJnAOqNTnKw2lAc28Hn4AQHMYgtLabRoyDQ6wS/N098GSKasv1yQ1cC5oboLvDSUC1kRzc9NrLGgQrYhXtJvVJpzKnpZnguqaNWgtAHGlwSoeoN0TpLV3aUOZ8f7mEYOF6E7WWnTKM6v6va6PvmUJqeyOmLt9ztIlVoaiuv+O0UBTptmPcFTbkuzse00sVYAvBgkyJUQ49nwcBQtKiWfJaNU5IKc1hSQd5FAA004Ro2b1fj9g8dKQV2mRBz4MfABkITAxzJn7aXj1M6fSCRM0HUNxv5s8DIILVWw7dsQEB3GuMZmfXgy49ZVpgUyMr2CFEzJ//SYej9zgVdUOh65lWyhoggTUWRZxrje7j/6qG6BgjOe5jVuBb2m6oPTZvFY3XJ+5VRuZ/gJ/xB/8R/3O8PtVFuusS2l1xaXB9RKoke1Jn8Yxy2Bi7y+KMPHAWRbFSbmYg8uYGCy9JZeSlAjPjUxuSGVUEYuLJ9poLxOIbNdE1HXVK1MAh23TBBaa9JqraL+mwEmtBrbxsiXSUMDFP+5ycXHOOiRVyLPfuLhcZpOIf7YcICVwBPvuPOwxHFYa5y4VV9sKFIqqGHAsAx1Hd7j4wuULmLJt7S/QW213GkpV69hq3EALcvFNhcq2+uDqyzA4n7gCtMnFt4oZtQU7VjoW1iSgtmMfcEnyXsLvjME6B0+9EDbphIeV7pfHEMtEw0eU4PbA81IJ2+yhh+5hI4em37Htq4JUIfBd17HvAK3XcCMeJQxJ1/FHXmXEikKSFQ1WEqhYyZEXd/EVxaqi3mlIZBIsPea99/J84PPj3KTeihw1ARgq7lMXFSVSTUEseu558N70msM3XoJYcnmVWoi5o06vizbHluWxWbFpDq9Ofqoz1YwWgklywRc9nobkR3HwxodpRiGni5pxm6DnV8aqpGCdsEtkU04aQ5ww5a8Caqmw/pjQRPlP6fJrYz7O4yZZ0YCN5+RVOeOgYQxFZd8aC3YRtw8zj1R/xaK/4Ps2t0siEz5vviLj3C47E7XMkJvRLV5o2WFOSgCgFVc5Ir2Qef2gF/UlAahL6U8HsiWfxq3S4UCMHBcWa56tWF5LDgtuSWPcPElzPYqteU0hp3NdUJewfjxhuK1Rr0meMpmIcZQmC6XOXXWLay1LMSyBiH+tSvCchtcmOz6wgUwX0xxRZ+r2CJLfIke2yB5Y3HsMx0O8WLIzf2cEd92gf9djeTpC2FbIQWKkYoyLc1ngapSyfXw+EJqG5LOh7rAEZBcO+QtUEhN4DVUJoRkgV4d/YYjntEKPD6p5H/V6L+saRAiM8VhZWkkEWN/A+evYzfN4WHwjmzyOqfTxY5wT1LqJrPNf0gUJoe4mmeFY76l3MdSWbBqCYG/CZk/wskW5p3HNqRsjRZnFe7SNCkNeE39b4JUcN1uzcwoJ4P9oUGtC1qhJS7XQaOH85skgNSaeDv7dqykJYd0Cl86BFoTYD3bHLa6lEFbC2ZapdbwjALJ4GbfhSFsOa3ijWunfqJJmBfoKxZXaJCbi59ikAdeYxzkoBLgklSEn3L6PgWQOQLXQHwfqxZIvRasu18MGv0rr00GkttHRSO9x/8kTiIG8BieYRtLbU4/JGlyFYx3PPa3/8QcJQO/zw9cl+faqLdICcaUMlk7iM0NI/HAcFtPqV9okPjG4eoeViQTsx5T37Em/u94WWYoh4EsndeP6ZFZW60M5ecoEc5qUIOVTAD7NSLNoD7bKIh2l0OfzGF3TadwlhqQpwpci4EZAdsh3T/pRFVfvbH2D7xz+L/WemqPYUANkI0kRmbiR/zqz+RN93mArWbwFxqjSfxkaEgtByE7GiycJBrEAf5i4j20cf8kuF1uHVjzvc/W0V2caySCUgixZt5E/UQlFvRWCcIvkSEsKUqLL5DR+/H2H+wnZtD7mN5l0eKy7aviv3UKz0fNzpcfdf19g8LqPSbn5AXUherbls8RZFuQwKS9n+cJjzu0ifMKjvdjhi4Ix59wP8WzYiauuY2CS212bBCTz6t/E1Wgn57bYhSkFrNBCq2kWdNMSMNjS36h/cKLJ9ID7LIjTVY7iR39E2fUN6iOKU+3mcEN2JDYtF3zMVV2KCjyy2IUyPbG7s/hX1SS4NA6DOF76k++bNSz+72nBzHieiFDBOjOw5zaJVIHPAsxbD87lzB1xQ81ZvbhOOf/UJrn7mTUyuWDDsT9SqT9+7OyNlY1BXoWqLLBbf3itFTL9wShmRfN6rvTYf+uy8Jj4PpdG3kKlYA0iCxbseoxaDXkOAoqLjhlAbzS1ocTosoc8Uz1fygOsE48MOu4XH5FmFMI+YPPN8xo8Tph/yAuwfBrSXHrsHBX2ubwWiqD6g/GkBoLxzE1NmkW4EUguECakrfl846WHCsKJYAZgiC4kzjU4Oi/wIf+HhvjPF/u0B21555/MBsXWItzX6JqFevV6gmGGAnQM6zCTlJUdUa4fo1YEIgLgE5+0GS3S3SQI/J8F9dcH43P29iPkTp82vPre3nIokR0R9shGkCRAWEckn3PxUxOq2whv/SjL/2qgR7dWI9ooOV26I6I492ptA1F3tUg0tZ6NRnkGbUEpIgPp3x9phqEqDnTyfseQFzSai2gbEhucqe/hboc6nAe0qZnTauON270lM1McnKOfDQJXXMxnWbzicvBdg1JWkXB8DVGyvNPGkGwws4e9l7rZ+T697m2Ud2N4OlCl2cFzXqv3BfaANmusBL/zf7h7y/jYcK6XrtEfaVbj7Kx7JUaNm96TdI+agZrx4iYn7xz7i9NuWwMzGaHfHHUyZyz35ui7JePxycP7Lq18qCOJMzJ8ytS05gQBZKHw49fhEvQyk+0F8zh+C16e6SGdhmWCE70xNEGDzgDy0+bNCIRmnRLwsZXN/4rC7R7rBONXAnlgWAhOkiY7mDZ1nUaQrgT6AElLu4jcPS+hOqAXDQiCrYqFlG7UVNr5LcCKvFWEmJhvmyOilJW82tykH91Q7PvTkMRdxWrVLuPzf/ggAZBHh2LqMRLpghRm5ct2RusFoU9JeR3QnDp0t1l2xiooV7eu29ynYLD6wPF+hJrI8TpROpIj95BKZSnGIINiCs35ErubRhywuh5nLIs3uiNQVFq5sArojopXtFd097LtVewZmbB44IrhXMdMG7NpyE1CeoCag3vtXNUIrjJjW323UbtOK/9Dw+Ky4qDcpc8BjJRiPDgoxtV1LQgGa64iCOHX9AdgMmfgyO1yAITjVjrxoF5j21x8Bd343qMuLoLkNQJ/gKvL4JRYxYt7UIlF1GSlS8jqC5fOjRXJCtgyzUTI3F920gTx9iZ5TnkqnTJNrnZ4oDWGcKj1qBBz4WdOX/A62Ue9PBL7XEXdIqKJkN4TkiYZZDL1RrKCoaLNiod7exFyUuFCsNgu3thy/Uc0OJ7D1ijz0yaXguG1x+m8+xOan3sTeO/qtD6QY9Mf63IOcYwsW6k4o1EyOXPDkiLD6faGfJCk0CNeXoj/oNCk7XOhkysTGy3cddg+A6Tn/pjtB5tk6Fd+6gKxLSZ7vW62pPUneIuwVbOg9xIKKzn22FVyufKaEuF7Q3QVSneC2bPKrLXnt4xRwNZsAS9V0IzAugPrmoElfkoZSryQXsGGCnC5L1FenAhU/12/5O4a6+0gbxd2jANc7NMsOk3ZAW4243U3Q3bZIdYIMQrqOS0hNAgJy4mu1K05b9UrQ3YloLt1rCLyMgnjboJs5VO2IMdSY3N+i31cIwSFGh+q8zs/pOKNg1I3Fs11GHsf0peQpA154JqnO+XeXXwHufG3MzxtUJ8J1OOpaG3IxK/p7Nvkx+1pODWMWagZN96y2EbEuyCsL4sLbPuSFs0FNiFWxFgSsWS/Phq0Dq8cO9YYiSe435upVCvX9iU5mO059AeVvByvkcbCuKNil7lBGs0xen3P9PfveNnk9FLDnZrWRDHgZrcaeeQPGXEjoZgqQTIHtY4ZcSQJSk+DOW8SjMTebQAFchoWg2jL12tyKkmm+hOvz5Y8C86d8xqavEmJD6qs18OaSBphwv1j92suc0niDAKm2GkQXXgDRlWNHTHDAwXU4WNR++PpEvj7VRbqJ6aw7zUV1Ao6/R/SxX9Imcf6c/z7OuAFtHrq84QDA9q2IjQCnX1cUeJcyv9V3dPqoVzEjjZZaOk4dMqdUF8PZy5RFOyyYgc1DQb0tIqoyRrPFrxQSqRLs7ypfs1eUbEE/Y4r4uHgQtX4dGYwV8PDfbXHzhWleLM3D3Ipj30cKd3ryeGm7SL7yYTBQvQG2X+px87kWp98m59E+q9ozir3exoK0qvC26pjoCVC8215HRC+YvTgc4UbVDzgdLyYsP07Z9zdvTp4IRLPhe9RbtcJSVX+/0A3nIBY7Cb9Ls9I01zPyO+3+6BdEoOodUWW/j/AoFpD7U8IgoSnIUnJ8z/ZWJwE9F2uOVDmluf0zG1Rfn2P2nGPs858SfPa/3mLz5hSrxy4jQ1boWtpi/iwgT0ucp0Vf8kBS8d3JCzYMZrNZIreRN4DoBfWGFLCM2O95D2eud5BM25GRBZ5ZmZJuBAyN7orW1Cjyiwq5QK+3CR//Zwlv/bOI3b0q39vVXuCQiOa7hHjfk0ZVkTIxPU+ZGlTZREM3G6eTKPLWy71gbjL26pd8noye1i8daTteufMJOTTlEIU0lGxYsLgODfD8zz5Ae83zt3kDWRToVGcxHEWMcwEc4Lfkrh99j64//RGtE/ndUWwmD/UysWhPOMLnz402Zqik7wW7e/y94d6A2FSYXJCKZ5QpQ+iGeQEP6rUWkT2Q1sD0JXD9ZWBcRKQ6wa+JRMcqoV7z+/fHPHYXgO2bAf60Bx4HNiMfzOFeMaWVEwy+f3/K5rm95DM3LBKGOYOVkqeoNUwUOW94DtzAgnVY8rPjtFzD6EFUXaleRhNrrwTjjsUuni+Q/tQ19kONbt0gBYFoMlisUnbUkuMBgwPqK49xxgYlNvzf1EbExiFMeQ7QEO32NxXiWCOODdKcorw48gSv9lPUSvsKLeAA7O+z+ZTE45FArvo4B6q1FZva1PSFs2/3dnIpP182HUzQrA9dZ4yqkxvKVJDh0Lrizw3uf8PSF0ondJ0P5X53Q6THdkL5W0PFD15ZsK3fw3UJyyfUp/RHzAWYnRcEPdNvVHA8vQi5qMwc+4PvDm24h7ko3STlZ8WsSA04sqk0j7G8n33nUBOgSF4gXTxApTmVml5E7E+cUtToXDS5ANor7nXrtxNmH3CatG3J9zZx97BQF5doaxmvWb0zygyb6VgLjt7jnmFT8TABFh/HvP7ECjj/z/eQD2aYPQNWb3ssPrYpqTWtWmwn3sukkxkdknXF+o0K+zvUQvi+TBxCI6iff0Lh5E/o1/qP8fp0F+meRVnmkKF4G1d7E8i5bPnk1uRT90uH4/cDVo89mjUX1ONvuTzaqvYooRzBCnAWhLYYDnOHepvyqM4WI0MPjEcoHTdXSYVHGpqDDR1lA7bFjImCpbhwAiw/5HuGVhAhGb02yzgKIrlBbN6cZPShLOgFZbb/tTEdx4Upu1JYYdQfAc1sQH+nLtQc5cIb1adfKn0iFK/sqy8L7vxOVGpAyql2KQc+SaZR1GvuKEGDLg59se13Rx0xc+ETRW4O+JIaZmGIa2hJl6n2yIvfaCFFCQBStgY0pN44k/3C5RFltdNI7n1x+Jm8GtCd1WxGNgHdsc/Th9P/9wyrt1nobR47NFdAmFS4+qJDc4N87ow6ZMJLQ28sGRVQJEoRt+i1YNorgmWc9/og2MhGyqEg59nNZCJwwalvfyrn0iEXv4cCZAsFc11BwQAcnG/jgAJv/osDxOxgxAsgX6fMgR+0QFWP9Uw7UD5rrATmEkHEk79X7UkBCJMSyiSRvx/q4g6zP3Fob6NamEr+3vaSBE27leLS4wBR//vtQ/5NdECVNMG0B2YfO3SnvBbNjQo3la9v3t/ZVrCFWqHy473arcIVxNKyEPJGrBQvQ5o3b7GArHZFCFmeYeTGP9YsIFPFY4gVv8PmDdKKwiRh+sSju5MQT0a464rC85UWn0cJbiPALMDXASIJ3fkMOBsQ1vRGTxVyeuP0ObU81vw0N0zlpG5Heek9SipppecGALxOmhYR9a0mP/cleIrCY+TRvn32/n5EvJzBtQGujpBXDcbjEagT3FbDl3YOcS7ANADXdO8azki7MAvF4c4I2Tv4PSPb6dqijjJRUG0qhJs5qsDiHnXCuIhoLx3gElJkyjPm6orzvMJwzGMxbVC1VQQ98T6QyCZne9fDaCrVvjgr5aA70ztZarEBAwfPngFBMiakhhNEa7qTAzSmgQWfChJNWGkFHVD2lKh2wCZyt7Ui6e9YqnF2DVuV5yhboypyPXsZ8zNfCnPdkB3pjCYgtueyWpvdIovsYh+p6+38gL6j5yDTQkcKXWkh6/J+asflNZgoCNeKyVVZr5CAasNshXEqqNfM4IgeqPrEZ0N58RKVIlgLouaCBKUV5UlYAibXShWcHjQVer2aZsQX/9S7WP1f38T6rYbGFO7w+ipwpBa54wTZ0CAJ1+PtI+DBr42obwZ0Z02+R/qlKw3MD1+f2NenukiPjaBv6Z5ilBYrgkRFMrYRWuDBXrmU5mM8toA/iBCWUcVZKlocZw4h0joqHQRDWAiR+bqan2sp+rTA2KlDTCfZkcINJQkVKE4ILqg4UEde2X3lIEq92ilHG1qozUqRt71PlCx6Vbyr+0lQlNScM6q9WUA5chdXLMwmVxHjTIiYJ2D+NKFfLbD/mTWAWV5gDqk2+VpU6ggzJJx8i8dPIaBkWztzsqh2FOdlcU5deNaHSFCygjQk+F1Ed+qzfWTyxcveikBrXOpNzFqFZk00aH8qmF6kzONNXjDWgATdDMaiD6h2CfUu6nsmxMbBjRG7M4/dg5qLaOLo1pCxhHKNQgvECe+H/Z2aQVMTRagNtdHGgB6/POZhLnqO9V45QMTqdTnfWQehn+cCitWo3oeTTUB35DEsig3k5NUIKErjuoS49Nq0gQ4MQA6Y4rlNGI5KyAp5xcD0Vcwot02SEE1YKqUhCgm3n6GbRnfK4jY0QK0btvFIk5c8EWrWMR/jYYOZHBuP2op7O4ZK0J04IuETBlzd+dqYXSaSA2LjYB7rNqk4+fbBvatOK/GVYHLNY+uOWHzt7pO6IRGYvGIx1h8D4T4jyS0h1OxAKeJFTnSMjSLEO0XTpRTrJvLNvulbhd8j0NwKqvXByB+lwIJxZhOL9RzG5mnrFyvArYDJuVOwQdDfjUzyVPBhWLLIDi3gbioMVUQKDrIYUH004XdU+9dD5DV5Hgub9gOXmS0w6L8bsm9uOUigm8yM6LOdlzDR1Ni6/P44hSKpQHcnoFp5yFgjzD382mE8GQEBmgufaWSLL1xj/1unheOuCLe0AVhVGTXPblh1pI2jgiNOQRlETkvqFadQsWIh2/SC7Rd7zI5pkJ6SYOenaJ7ViE1CbBMQBJu3Ers7ADJoY70VrD8XMXnhARFUa0GYagG25rlJOlUNeh/Wm+JMA6hVrHDCS0qjijcjIENUe1QWhd2JRwDXfx6DTqgGS4culDjjyPtg4IXk/cj2JjckdWSKyFaLCu7YfmQviciUSJ6o/Jb5/okVsHon4c7vGK+60F4I2rDgf+19pGiY8pT1lg8D97OyVmDH/X53x2tBr0i48tFvPsu1dn+HNBbRtc7AqeQEz/8kcPINweS6iGSROC3oF68TyY2fHpuSqWAnb/2GQ/zdI3wrHOFBO+RJrTUUh5Sj6StOiKcXKVNCLS9FAvDB/wF4/N+11An5IsbNa8In6CXAD6R5+MPSoHyqi3QZE0St5Lojpw4jaot45NSNpPz+OCVibEIrH3U86+iIwkWGD3yzIud1/bjC9IJda3sb1cWjoMn2skXGkILuyKwLE/oj+t1aEWhFM3BQiHggOEFjvEMU67kUAYhkLvQh2mKFqiEV04uUGwmXtADQgt3oGRaMQ46gy0E/Jvz0gzq/6OZ75/9BOEpCWeDN6cUKDeMH1huKSo232Nzyd0z4snnksPp8xPRpjfaaSIHf0xkGws8eW5cDeQA2HWnu86JmzizOdgDbDKRsYO0tnQp4LxSxoTl/mA2g30cKGTtGq6dKMl3GUGck/vfppY5apVwjQxltkjK5AMKK12v+ggv/0Ucxc46HJYvNYY6cUGmNnh2vBWvwPKvN4R5obmml5voEKL0riSHfkh1sfJfQHXnUm8hESrvPFG0PjQCN6KbP6xTqQmORAECPi64xuiHc6r1eE8liQ8oNzFJgydFXIWirVA1tKq2Ai4rOOnWCMXFUv3CcFqTi+WwNcC4WhZQnoxiZ6DVqc1CvgN1dn+/Xw0bGGsXsAGPiWT2+essxuV2D7piI2/aeZLpPrPgekwt1+TDx5gR5ZN4v+bOqL4ilRNvAAbMoBEqhRBtSy0YQ+J027iOQZjx3YQIgqhf7WTmXpdhg8W2fNyyQUf72OxOM84LsD6cB9Yp+4H7j4G4m6D+3RxocxnlEmkT4Gw+/N/Ei3Vmaa96r9bqgk8OSIVrT54JRqT+GvLpYePkSWbSapd3hxKxeIfPW/d4mSQ747AZhVwO9o6XmTUU3rDsBfkWrxNsnR8BbPdxVTTcTIe0F8HCdoH87cCrhQMrPZYVYsxg3yoUBH6KceYuit/u9et5gEwSLO1sACSkIuocDJk9qulwNglQlpJELQWoiYG4qo2A4Sgh3e8y+2cLsKsPk9c/b32MRd/c3y71iaGp3ZMFlyBSpMvVUC9dQGnijX9rzuLvrMvLbnRDMmb0IGbiJleRAIGvAAWREOVaCbuFyOqkJSktWhiupnDrpsleeFIBN2PIDPtjRA6gMYVd60JzvkxOKgcztLs4q1FJF1eJYMnhpxGm7WK+LvaFRPlPFBqha8/P2Z/x935V74fRrvEd3Z9RINSvSdGJN2t4w1X1lwe8mKioNs5inxgBw8m4E3uM1HOcUYI9TQXsd8/PASUWhH0KAZn1w7hKweJJw53dLo3I4ZXn6nwrwT/HJe/0hKaB/EK9PdZGetCCWADTm4SplnBy9jeassCzhCC7QOs0NyJZoFlRE8Qk36/Za+d+hBMyYfR4XOBvN4zXkgAIuOs4wCbIg7rS004KqJxLQL8iVt2Po1VXEHnjbRIyOY6gdERVu8vwFEyXyD20BO/9Jh3u/yXO0u+fQ3hgykTLqDiAX/DZyblfxNSpDv3CFk5i+P7YdGBYux6VTZJfQ3h6Igjxw99dZXObjU8SaPtAunxc7F3ZurSCq9hrwMaV7gSR1btHQn6ChVtHTJ396Xs5jqFlkmaaAvHgBWo8XP+0xeUWfbF77wPCVqcP+jI1WexXQnVRZXMmmT7RwZfESDigPFDpJ1iBMLvVeHAT9kWRxpoX1SGTz4U0kW4kGKSUMc+XKq8jJHE3olFI2QmvkYiXZM9lEmrYZ+D4W3r8TTA456wfNqm0koS7CUph7SbJrqoWR6gXMR512mUWvUW+RG9xmnfLkJTkAjmJQa3aMk5q9kyMQpjwf/cKXBlZ9iiXSnpTFL5+loAUjTxZyKInvaKHm9yk3vH6wAlyzDjbc6LcPhEXmGgjHWvir4NYNLMT9nvz0/YlkuzeIoujKGzfE2Y36qCpabOd6nLC4bq8BXPH3xzmR5toE7Uqp2T0izaI/Spic8/7YPQDcC+TpS3fCgsh3yBaSviOvur4VtOfk5O7fGdB8XGNYJqRVDbdjMexXHhILYucGoB4lp5eaPzr0GIk+I1vSAWxi6hWL7jABmmsWP81Kj30kH37y0ufrkASIE2BU/vy+qwCn32ckQh6mCdJz7a9vHeSLa3RXEzQ3UtbjQQup4wR3UaM/C6ivPVINuC01E7y/Dp4Zx/uE61CCON7n3Wc7+HN2VX1fIYwO9VGH0HuM8wphMaK+qdkod4L+TL3dZxHpLuN4q/cmCPdK8b97mNBeFgpeEnL7+2NQUKoNpCQCRMkRTHIj75dKJ05G7TN0FQmohpTBievHkoXGNvVZfAgFj1zWLVXbpLTQqIJndzCt4/c0Meqhg0lQahypli6DNfbMGhJtDW57rfz1g1cWtQq1JubEZnTJpFxwo6UkB2zvVSrU5FrRrjgB8x31ZuOUaPnR91K+H92QcPIdWguL8t+rHRN+M9KvzzUbxYRRJK/ftPpMmF6yma+3/IzZC4IE9Q3vz5SQ+eTZR13Ph01eAVsLS6AZKYEp69ReP0esY6wJcoFBUKdfc/gQP3x9kl+f6iLdAoeg6KDRSap9sbWLtarP9+TjhomUkfygD4zVOPrwhIkgGu1Ef27OLYB20saLnZaCpeq4IIRGcPR+yslxoaUfutE0yBEum1+mP6hgJnoGMgCA8RZDI4oglFG3/Z2h2ZNLo7JIRoEMbbz7WzHzH+v1AaeuMmoCj9UQvmEpqF/E7JIAIHtWm9CV/P8SoNRoAJAp45u1LpCJbisQoL0WTC5DDoQaJwLUQHdck6e6Tzj/cx0e/b8ahFbQrAJ5zQ25gaNaL1pxF/Tn9Q45IdIrl7pZFcpDtnbsUnb48ftYJgytIMwijnTFM+eNqImyEoB6FzHOVOOgiD0L/YSbLwGzJ1xYpxfmo4/sox9qh1ADu3scZ68+R5Hj5IXD/KlyS0Gkh8fG611cZCiUIh0o5SYhi7UCCoqTgO6Yhc8wdxTqoiSLmjPAodtJrIRUGF/QOIqmtRjWDQUJr41YjRJkNJrtPYfdfdrSzZ7TMaleU2xrKbGhFewmGh6iSLob9P7UTSyoYDg5YKydiq01tGqbsHnksXgaEE+Zajt9QZ9v3ynqLFBLSeRnpt7qc66baKxZ4DhzSkikj1V7PvvGW7VgnNlzZMrXqDoO04lIRBmPe+ookgfggF79tb0H0lCe+9dFpMg+30Z3S46iNzcqUr5nMTS5cBkZlAhEo1dNBd1pwuIjbd606e/OCrJd39LtxPXC/7upiEpvHdpzj+7BCLfzSFVCWASMbYSsKjRXRjrWtW4LrD4XMX3mUAkLndhq0f3cw+u6auEryQPDpPiq2zNWX3s6Js0SoA1he8FGMtZA81GLccp7cDwOgEvAKPBbUs6SA8anM4iixDICSV2uJKi7y1s9mqcNC+8AxCblQCV7uQCMDZsuOjOxaOzuByAIwp1BBzkJIkAcHdJtTfqOT+jPImQUhCYBns92c+kw7qk6HY4S3EWD/jRh9rEgzCO2C2D2oc/I9+6NgMW7XtdUu0/5f9Voa3YpgM3dLNSkaWWeu+dz0p1w4baguTiNqNcOk+tYXG680Qdtu7E9IsKyP6yInp2H7IwmQ8Sw4HfFeDD5Eu61BuTkSZYlINfqUlNJbixE6Tpc/7XpDq+DEMGVa7q97zIY194iT+GSgzobgcFY04D+okFzy/cbZ4LZqxESPUKtwss1sHg+YvPAwyuNy+4rSyp3Q8rNZ/LA7o7D5jHXg2EB3Mwd08X3ZX3Jtr8xoTdaoU5nrTCPta2nRQxMh69SayRhs3X1ZWA8iWhfMLdBAvf79ur1hucT8TIA5wfxOX8IXp/qIh0oBYNRTSQBV18UnH0zsjDSzTRMhJG6ilaSuqLIuC9c3OQ4Jqv2HHG5gVZ+EgsaCkeELznJG4skZNpItSN3kMh78SPvjshDr7cJ+zPB7CVtDlkooCjhdSNkMW6Fkz7IB2NYE5na+J6+3cV6zhqPMCk/SxqiUW9iFmHagkTuc3zt9wEt2mrkIirpYjXOzJc+YXJli6VVjURF5s/GXFz6fcTsxQg4yYLR5lY3kJrWit2R4OxfT5BczFSQMOHf5oMGEXJLqWxC1HQ9W/SLxSGAzHkEkG3OWFg5+F3g7w/AW/+iFPV+H+H6iNA6pJpOONUuIFZ15sxC36faJ0yfC5p1ES6PE441k0446i0FUvWH9LGffcxzwrG/ovIqAt6fCpZPYkapIIAXlxd1Hghy6A6RHsE4cxkhatbkkDIF0uUCPReVOjE5dEyxc0V0Lur42J4RyRvj1ZcpSqzXDmffiHBDwqifP70kLYiiTtWITOh0ZA2pU8eMZh2zwNXOAQLw8Z92OP1dwfSybEDmrZy8IDi655j7zv2vRsSKOhMLG0paADercoz2TCR9rppVVFtUm7oVesAwlWzrKYH3abVNMPFmtS9UIaMguFA24mZlTRpKQNjBc13WraTnJWV6FqTw3AEtdB0RfBOc22SouwOM84j5Rw67+wnzj/mdjedtRZ7RYCiMKyJ5vxdUa5/TQhffrRBaYPsOud/VRU2LP52qGMc+jeSZHyYNd1PaJ1abMjkYZ1DXDl6P6OmcM86VgtAmJoZKgutYeG8/M0Ii0LykktH1bKClZypouDMg9Q5xGiA96YftpdKfKi2WBOhPEsbjEW5dAV9aIz6d8ZhWLjdEGd3U8z0sGI6UfEI4UrHJ3gOTAFlViC9rjKeBSL4WU/NvNlh/cYDsHXAW4OoAueLWLAkYzwbIqkKaRLidw+4hj6m5cllo2p9ENJceYYqssbHpj/HsM5BT8fnkA6EgQyNZDJ/pJYlTlMXTCKcTM/ONNypYaJV2lv9dMhfeqGTJMY05OZe1E3FZ5QKWlJ6EVJcgNQZWpXKOBbo2IdPzsj0jCvKcn3cVxHsteIseQ/VNvTqlCZ+NDFZEYP4xEFqPsHfozji19H3C9FVEc9UjNJMMdkgA/DZg+VHE+nH9Oj9+m/Ka3C8kf78kpLt1p3RSMuCiQSm8Y13WCEtvzpaMiQnFZqlpzxbBrZiF+/ban/H6N68qdA8HdA8Efj5g+PoUi83rzeYPX5+816e6SE8OGV0wP+XtfYf2inQRUcEnULpyE+nZqN8KEVuYsi/u1FxaiAYCyGlvRrswtKC9irSXO3Jl8w2GOFtiHLIF4jAl8rQ/cQc2gwBc4atLSHCpFJdAaULGKbD6DHD0rsa+O9JMGEihn690HOPwRUVFxqlgrr68zkQ3WiRbo5MEmRMogQWnLSS2ERj3Pns8t8D6Tf5snCVMn4nahhlsBrjR58mHLdDWZNhm7wf+soVuJE8+e1wo1aPRAgbqjKB8yV653rEBkoiKgVhAmz1hd+y5KOrm0S8c3EQR0Z5FuYV+jDMPb99Tz39oPcN7qoKEEnUWtJc6ghwKQmuBQNa8ReMcK4Lc3JZJyuFIlg1LKUpdX7zw6SJAu8Hv51UbRYheycjTGt9HOLUq6048tvccVp+lPd3DXw1IAmweMsimuxtw+ruOHNuDRs1GzSagXH0hAmufN12757JbBZAdhAylNg4tkBA6DV7KHE7JjeijXyzUJRNW+aFYlWWNg9csgpYUp/0dbp7GcQ2axusCOdBsponEAiZqVuQxIDdoybGInFwUhNCNCd2JwzAnBc6mWTmAaVImENWedKp6HRCmTiluLCJ3d10epUtUTUlMnBDtE67/RILrBJOXArjCSw8NIE6NO5wWvoFuM+0lA70WT1TvsABMbLy/n+C3gv7tDovfbTOP3IpTG79XW+RChzHqAr/2CNNIfvUNNT6uKyh/vdFm1ZGH7zoi9bFR3vwp6L6iPHTj5Q/HyG4/EHK5WaALhrOR1Jag6HpikeUGycLXYAmql5UWRCyCZAT29+iF3X2GYwTZedz7wgVefnCGNAto1Ptc1PvaXiaudltBfycyYfRehLusUa8Ew9JxCvEgoFr2GFcN6ssK470Bw13QzvFkBCIQdhXQql/7KJBVBZz2cBct/I4uMfU1G5LQMvQOoiLBuvC987qviLM9f+ZsxZ+5TPca1F7YqI82BR1bQdKmc5wC7Y2J+vk7JYwNGQxhs1n2kH5BRDe0QHdH8PhflryFTFlTFP/yRwUPfzWqnWLxa5eY8vTVwBL73PxM688rReNNIBsOpoCSJO8XGWzwgFnaSki49+sJ9Sbg6ks1to9okRlrQb2usTtzurbafhaxfnPC9Xlp6zCyGYKFik1faq7GBBnocJo7QRoXDRGsac1rojbo49ShypbFOmVXmk9uAHImh67tXnD2jZKkDXgFHVpIiBg/gUA6gNcarj+wz/iD/4j/WV6f6iK9uQ2ompQ5yADR6WEmWL0jeOe/vsHVjx+/Vmjkf1b0/JDG4oeESrnARDZtpAd9cMwlhX9ji9TlVxhfPn/Crrdei/qbayqaPtDjlAvw9X+yQ/3dKUepEZi88Fg8SRoyUmgcNvpPWhyPE+UCNoyMdxrHjADs7gmaTRFG5oLDBFExwQ+COBDpsCJinPkcNJM8kCZcLM2G0kR7guLqwoU9wmhGNspbfpgyyrF6G5g9L6LD/SnP1WQoPD4/JnoTHyCLSczVhhvc7p7D7GXMxRn52canZuG5PxI0tzEHRfkBWYwqY0K1D4iVw3wb2FBMfT7GcSIYZkAlDpkbH5GRc/qKJ4SZz247gIovpdxLgNpzBeD2cxyxn3y1ge/ktQ1XEnDzv9rj6FcmtM9TrjAnE9wAMuLrWexlofCB/mF3V3D7+YTZU5dRQLNtrDYMGeJ3s0bGZ7Rt8TTABbpjXPwYLetmz8iR7e5RRH3YOBzyY5Mj/9mfdZj/9izbmkEAE0BaEyaJ3z809Bk+FDgjpRzSkj3iURpU29xiI3nDzGl9CRrihdf0I5BCSzM/ejvn+fxHAImNwfaeQ3cq+fxaEWrOMhu1ZHQjkc9qlzBb81kKDRsuE7pakNM4YZMoU8H+1NFdaOKyYNWQejpQJbjWCitFTRcjwlywuZuArcfyXQ/zG4dTm8cJcpJpfUuaid+TsxwXLNKNJ+x6hv5Uz1rSkR5HuK6IGf2eFITki7NKtQHkKR/67kxQX9Skg8xI2THk0Ioko8l5XTMOXW38XrJgOFkRpn+TqRwrl69BdeO5Nk+1idk4xCZBRskpwc3LCv1pxHg8YvK0Rr3WCZMDfFfQaWw9MAt4+ewE0guq2ypT4UYLplJaTnc/IrUR7fMKbucwHPH823NYbXhvVtceaT3F9FabqCc113EB6uc1YpuQKvVjBwvy5sqhq2vgbocxAe55i+E4we1p9xh7gd+zaK9vjXJYGlsDK6yBTF6YUCqC5ApYkTVN4Liz2nlMnkVqr0Y+15NL5ABAW0uYTaHnUMoe4ntNm24JVCUH3P9qj+2DGpJorWv7I9Mxea5Ov6mofft6GZXEhOj2HNM5CwmcEOt+ZnuwTZVsEmYURHs+MxUzT50V9KgF3Qldn/weWHzEv6dPO7UYg+7FuzuCcTrVKZraaM6QE3VjDQxH0MmA0/WJtMX2quztoQXOv5Tw5n/P60NEvQhXKbYOeT3ifiv5PACcPE8G02+xcs/rv8jrdYwV539YKtVP8etTXaQnTW8z0SdQEIDj7yY8+XMnRNZSwvQi5vRH8pYT9qcuU1EGFcpE73NR9fKP10g+YXzQAZsKj/5NeVCIkkflZvOz6YFb3FNsI7KH3aKzJ787RXMDLL+nyYje+L4pI/zZ0hH8e7PPGua0hspFTC7CXkdfSHVIGX0PLQvzUOtEwAu6s4o0CCkFmInoQmNpmZKR+FGtw1ADmEhGNyWY/WUZYZ58N6JfCkZFkSfXKadRBvWYTk7HtlLQaUM3AP7z/HlAjpCvMkhUhK6KzoytoD8u/OHKA8nTuabe+rzAj5MipjU7RgosicTJgWOP8eZh4RtOikOPIpKuV1cWPfV+SJAfWyNdT9Rlg//h/E+NqC8qHH1XcP+ft3AjG41hSh66IUjWLPEY+f3s+CXRHtONCeu7Av9gh009weJdj9l5yg4J1S5imDu0fQLi9yFeOnmaPw8IjWB2XprJyTUwe6kNqiYAWgYB6Rd8r7OvJfjfpNXIoWuM6H1n18A2eN7CCT6YpRmfi3HCCZiFc5SGwhJPC70j+7sPhQIlEYoe8vrPnpXzZg25WaLGuqDvtrMlz6LI/jk5FsrRmgwtAkJDpFiSYPqCf799g78/OYemw9q6wPewqU61p0BYAjA7j7TvFOikig9ecnw2xxlTLsfjADQJWIxY/USAu+Q65PeCeiV5KmDfncUCFKxQG8YG2Lwd0Fx5uF7ImR2A2VOXG2kTho4TDeAZAWiRbccjo6UUI1P7rDHLTkCunKvkSRs33np/guxjf2ipufyAfu7lvgH60wA3Cqpbh/5MhdON3hu10lB0QgBJkIFrdjhRa7tBf//RHu6cTYnc1IizwEnQ4z26yxZ+w2Majsgdby8c5KTHZDpg7ydAFSHXNUTfT9ZsdIajBDfwedh/rgd2HmgjXDsiTj3804bHv3dAm9TFRm0PbzzCqHSQ44DqquI07doxObVKCMuAdHmwpStgwWe/rM90HvJZQF+pXayt+9A121K2LRsjtCxgbSLnVaTIiXAJVbIpa04mDkzblQS8+vEGs/OUwaR6bc0C9yLfJXhdl/MeZdNgMdDHCvBC+SiNKzLvfjygXdr/2XPgh5SLY54Twf6MzYRpk/hcS6aUvaVnAhUAAQAASURBVPwT/E5v/g8B27sew5KpubEFdm+NeOP/49RcQtfLgzA1PtuSG/+T7+I1Vxw3ChYfOFx/zmFc0D2G+wGfEwMP6k1EMiFpSAyZ07UtOV+oQSOBL1QppymzVpD8O8kDkhuzT9jrUPD0B/kZfwh8GD/VRXp/5NAmof2iie16jj7bm4TZC+Dm84LJhaC9KaEOVLpb0l9UegEfcHswZSSaA0mYvN9imJeoclvIhqmDpJTRZHu5sbi5WBDLqKlkqSLCPCwke5wne+gci8VhUYpWjv2Qi+RmxULbVP6GurfXpbvmwkxLx0PxqyWlmWf8+R8H/E6w/EARPt1oo1fayB558TQxTabzJLPM0yJjKII6C4G4/hJTCJtbUgTqNa9NvU3olkr1kRJRnRdvLfSs+AttcRrIC3YoC6jrE6pULCujCiBDw6aATgSkRLjB3lPHuRGo9iyeDsVXsXYZoQLKOWhvNM1TF+7QShbhJsdzcvTfLHAcKJDan/HePP7dGvszcoNDK4q26Oer17UfEvwe2J9p46SiVhfUQcYjNyTDZ/c4W+5wnQRhOsPtO5Kj47dvODTXAv8ds2UzIau5QKTsJABAi8QD68/9gWuP3utjyyI1F696v9pmbOFdbii2jCZoNiGVdTKHRTg/XzfgVARURlkpibz8W0vz4zWBNrSA8ykX7g4FHSzBK8hBZACf72prVSNyMBCk0AqSV+oHkJN/128Bw0nE6dccJhcxFzOhZfEzf0E3KEN2XeC9z4lJWQvaNfnw9Yr86+2DWi3w+B2w95h+bN0acuZDrAFxeh9X/H7DkiI2JFJMrCiuVvz75kYLrQUyHW5/L2FyIZABcMrlTonnxVxOrHmPNdCdJVQbwXCsSHzUhlx/Dw7wO9KEwkTdjVoT8vJa2Hu7Abj4qYDJC6VLaRBQfeMRW+pzqhWrfYo9hULPRF9q1wN+50glSXq91PkleQAvJ4gnA9xNhfqtNYYnc/itw5haVCuHMFEHjdMe9XTEuJkDVw0Gn4BB4C+a7HMfjgK6t0b4yxqpTghVQnPlEQBM7m/R7yvEmwaucxiOApprD9cBIZZnZZwmLapI60nHI+oPK3R3EoY2kse/doh7d4CGI99DmQo3lutn61AO89Pn2NZiicWcwLIy7P1MA1WocqnYmE5cpoHlvQ5FW2H7W9aQaNNgdseHzYSlXFuDnXwRiyazWXVsGkW4ZmzecFh+FPSZKxaPeVrZcM0ZW8l0Ny4MCcuPrSkoe6G5w0gCFt8j6OL6AW501JnseF/6XQU3htwoWJgaefVJrXBNXct7LtW0ZvUD4C9T1ggByNkNXMt4HP3SYZi514AIa8RsLbz8isuaCtpkpqzZyXz2aI0BMgr/w9cn9/WpLtLdyM3l9vMJR+/xph+nRJp3d9gVn36bD3RoLLQA2Q+22nHzqHbpQESqRVcDnP0OsH7s4AIwfanFpy5WZqNoTg0ARZO2+BUXCRZlhuIlFYgY39uKJgk6tlYxpN9rUWGIgAnQDoSj2WqyYly9cQDrbSqBFCKIDrxT0iFPGHCPthh2NTZDg5Pv8D2NRmAIS3J0aknaNBhSIzEplePggkhxGwgNY5PrtSn9edybNwSuA3YPEhYfCrpTtZnbWOCRfuYhgqxUJtv0ooc6kdjmZKmayEit6+m/bshDs1JP4DFhWHiOaztbLAXNKmH9yGP+Iuaisyj9ed+MEy6UjIEuxaLvUi7WcrrmmFB1EbOXPPaqc5g/J2+UyZ+lwcoCXbVINFGd6IZr96XZ+0kE6vcnuP1wgumVFpAm7vXA8bcL2gKgOAnoSPs1VNNbI0aE10SONvI2jiSnRFqcVyCVY2WIkAYxbQ8aGmiTYYh2LIhUESSnvMlzvCuv/RwgR9amU8PMKZ/fJk78PmPL0CG/V251Kp9lhYrRhWxqdfMlFVDfFsvMQ96vocKWEiyBqFuYkaZQr1OmW0WbhOg1tfuq2gI3n+P3aK6B0PiMSg9zimnlQYPpBe3jbj/rsHwfkFShOyVKPyx0YqNUDxNvAkpHM876pFA44ADpDr57AjZvRcyeONQrhjFVO0F7xYJ3fweIxueNvL7w5TPrNWkrYUr6SZgkVCu9j3y5nt0pf+bVHccSOKutFiRq25ccfcxjXWgK0QSfEPQnCaL0ntRGoHMIM1JeYg34raC+lXzck3PB9o2I9hV589u3AvxFjWoj6OoZRID+3kDazggM84DqpQo7JaG/M0JGQfWdKcY3BoxnI6rrCu3nb9G9d4QwE4wnI9pnNcIkYVhGYOsRP14iHvPEuTe2SINH10bI4DB7uEb/7WOM80QB6L0O/kWLMElAdNh9vkeKgvpVnVNbxxnvM+p2FL3NaxH/3YeiZxinWkyb+NpxfeE6JNk73eiEufFQq+FhKUUM3QjGltSTave6iJPBd3q/6RpshXmmbQh/Nix85mVLKNa79jLHKmv+bW+QSBrmzVcCmlstcIWUm9C4DDJ0xy5bSbreJnB6XM6mwJLvrfY2IZgofMvvsHqr5tS81hwP0M0suyXVhfdvQUk24T6k2OQm52BiavQVK9C5P0luaqzBMcDA7xMmuu5c/JjHvd8cCUrVnPoOM15HqyFiA/RHZQ13rw6EFZ+k1w+id9B76JP++lQX6c0qAAtg+b0iHG16YHuXG7g9YLTsK/wxFlyaRqlezUQfDgo+LRaXHxVe2TAtQsCbP7PF2T+bAijOHaFREU5iATvMJNsV1htaEvZLKVZ4STfEYEEb5CXbQuAvC3Lih/RaQWwFBRJH8dVegLZwxG8/4wAHHL8b84JApL4USnf+yUw3yJSRSlvwHExUqwhqUIGbhiGRu4hM6/Fd4og8Jbja6UTDilbSROgMoOjahgty+8qXUXsCoCLD3V3yafllkYWrFNqxcDQEdphTiGubXLVLiK3Q0z0kVB3R+OS46FVdEb8amuEGUmvo2OHQL+jbbRtR8BQlz855rPV6RJg43UBsFFk2HeNbjzNH9EM3VrPwY7FSjs82NAksiqzxM0EVoPdHS3rM9BWweZzQHwmmrxiOZL7asSZ6e8j9BVIWB1sTccgZ9epkY4X1oX1aRtPMHjIJpucxTwLCRNRKkBuU7xP6pcuNiG3GvtcAE1GUXikfxrPNNnDGO/VA8j5PUexlDXKsuIFt3qDLwrBUm7Xn/MK0V014+dP8+3tflVxUzJ6Xgtye+8xtBbIwOLSG5vO8GZrM552OQnny1evmXpcJwuy5/qxhM+4G+jT7gU2l7wgoTC8jEzwfa1MzAvt79p762XsW7f1x8U4PTRG22/RtnCK7gmQXl53LtBQIn8NhDsj09es7uVZ0fsGf7x4FzD7yBXiIPAdcT8r1dR2P1+wux0UibwjQsB9kQbPkQg8YjiLcXtCfJVQrdYvSKRoAuI2nxUeUvCkbYBAmpKzEWlCvXL7X23Ofv5/fOPLbB0e+uAMwiRje2cNXCd1NC78lmjvOE9zWIx0P8G9vsPtoiXR3yOvl8M4e7lmbha7dw4G/74Fh1UD2HjIf4TaC/QdHEJfgd8KifvC0cVxVgItIEMimyvdZ1EyF7SOg2rl8/GYVas9FvY28T+vSwNuLIvECANQbe24kC3Vtnzy0+0xekBKyhWtQ0TZzBUiTOXlXnZoUgAmt54Qug1K8OJYk/fz/1KP+xhR3vh5h+STnf8zhwa8FUD9TBKRem/LQAJgEvPopwcN/Kzo1dLkRHDVDw6m+SyKno82K7zHMCR51J3rsnjxvv086US33UA5o0+d/+YGhYXo8UiatkozWWdahbJWqoEd/5LB6S3Dna4TwD6d/fF9+cDoAXmzdiYqSMznY5c+otxpKOBAgqdcx7zU2eR+HQ5Tsh69P4utTXaT3C4d4Zl23oDvWbjXQs9uKN4sal1jSJ43PZwVCvSsjKAk6Oh+BV3+mw51/2RbbOnAhPPtnU26y+4T9WXF12Z+wkPc9v0e9jVlkGGtBc5s0ktjs3LRojK+HvdBVJmZkBDgsuMw2TpBq8j7nLyzyXkWcH9k4EWWRd8gc0OwNjUITsUUz+oIu5s31wK7xNWGq2WO10GAQRTCHslm4MSHdsmAfW8HNj3BRWrxPXqBxj00kw01ceeAe2cYQ0LG/obOajCo6UbEF2Gz/AMAlwdjyWrOoA+qPdSyu6GfeEJMVxwmTKzZU7XWE6Ca3/CjgyZ8F5h95VBuP9iZpoQUg0Qu93iYt7gQSWLRyOlEoHrFGtuzzJqY0Ti+QbQQztUiRY0tBdR1w/r8gl9bvOa2IjsJdK/BijZxgaqLP73d/MfQdii4bZSm5Yk9mtBzA+OFS0FbYzwvCZBtMpefh0K/f8goABsUkAWxc64aEpMi96LWw4nGc6Gh7w/vDBcmj9FgJJhekgUlUN5+d3hf69/f/veDqyyVBNqYEjEClhaeJyG/e0SLOJbi9K847OsEIUzpxuL1DvwBEHaCg71N1DEjLicJRkWS1o/ODgQbI18FcOoYp01IlAJvPj8Dg4Dshbak3IXeCuyInPTTkoNNirtARrKlIQrtFHo9OGA5Q+Oaa13BsldLjeD/s77IxsCZp+tQziOhGG0DPY0q+BHclRVqtwUFSf/J7EdWKwmajEgGA9ECYJIx3R2DLVFMW34mC0wEI8wh33EOeThBa8pCrraA/YZeZC/V5gIweXrnf4aCZi41OBXtBteOzsvss7Rvrc/LH5WGPau3Qv9WhmvcY31tAJiPEJTSPNxi6Cr6KuH+ywuV6ht20QXPp+T0ApCNeVBHAzzvEUVBfu3JOGvLYQxDI4JCORuCmQX3rMJwG0odU05QU8a7UkzvTAGuzTDWHD538itExcMD353+XyNRrd4CkR127HevkzKXO+p6DCZtErjNeOTISEqpBAZBaECpgbB2NCxKBnNxECXD3n06weYQMeiUvaC8KqMNnkzx442SHWoAocHc7PP/fC+a/OUGsgc3nRridw9G7hVroVDdVr8vUs96QkuoN4EhcS/dngrVn+vH+jELSqPvm5Jr7vQvKj3ekgGV9l07l9qcO9X/5Ehe3c8z+9QKLpwEmsj3/SQ+/B+bPrMBHTti219P/LOLhv0YW2B46SxlwUqvDkhu4PiUBfCDA0x07bB56nH575ES/Ka4+n7hXvr4/fAGf8iLdUgpNaNHe4DXXDiKKFIw2KyKV7Q2L9/0p6TDk3+qGqZ2x8b+adcSdf9WC4RDcaCRpobdmwIKN9rM7igPSULplE4CShkFbKEMsxtYh1jr2UppLqorbx/7EZWu4zOsT5C4fSNieCaqN8Zz1AU+W5Fn4uIbI5kIlB0kULvhh7PA4cQh1OkATuDCuH0t2fumXTPOkHZYwqdDiokVHpIooG+/RDQ71StAfcWwHICfHLT9WmlJfFjty0ymAQtTmQikGsSr8QTtPiFro6Qi43kb0C6KIhlRb8VgEqWW6IFLOweQq4eYdj5P3AouTmcODf6cUDP3b3R363Pt9RHszYpzRwiJ5QXMzItWsGqKOgq0JpCMOMiJiAmgTtGZ0SmkgVjgnR3TojS+/wO4fPcQw5zmst4rI6D2wfSCYXB08K4kNRai1IFLXmmqPLJbKhXEsKBdQGjUbeUdF2A71G4A2GrVk0SjvM77n5qHqJma8lvNn3OSyz3Nbmj6+GX7PdOeQu5mb3hULsf6YDTktRcvmmLzg4o8IxnnEzefp4T25SDnEzPQK0ZsTSUK1dkQ/k0OYa6hLmyADUfTZE1J9aGMnGBZE7iQA1VASfOttwqbyGOb8PqaXqbekYg0LNm7dkWQeavJA86riROWW7wuxZ42+6EEbYnNiQVLf8Zr/Pi7sfLEY7+4As2cU/4UJMuWFlAne67EChrOIeuUyqut60hvCBBiH8rfttSK1K1JlwtSEqHrvKpiRpFBuUpUy7SXMKJSUtYffEekO9wagc5DOAfc7yKsWYVOjEsDvS2pue8HvZ41I+7Jic+CA/ojWiaafGe8NgE9wrxogcjrQPK3hemD3mQHVdQWsKvSPBmBdYd87yCwClxPEo57cfx8RRofz2wWWsz36u3v0VctApemIuK6BSeDvXTeYPfHYPrK8hQS/d4izAD9TRP7pJDvAyChIi5Eaohte87OvFYQ3VFy3kwDQos/39CNnyJitX6XApk1waf7MPjAoFY7TyZRpV3BgjkJl165kdhggkvnoukf4wKlpv3C5gYdee0R+19AA01cpa3Zee+k6l3VOutZ0J4CbjAgd0Yrdg4RUA+3pHtX7C05gJ/q3CsaFCak6BhJI4L5CAT3/uxv4tSTwftw8PgBFFIASpePZeYyVe60ATl7w8moJ7yOuf7rH8v/pda1OaC/4DMzOQ85zAPCahuDNf+5w+7bg6EPLHEilKVC6X3ObMmXVzhNDGhlqtvlMwJ1v8Jx53ecPwfofvj6Zr091kS5jYtKc2APKbt+8imcvA3Z3PXyvlIiRQQzNKmF3x7/GqTM+LgCNDmf4kL2SjvZpJ1YKHhcS2tuYuX/Gz2NBwfcoAS6C7rSi48hG0f8jwe3nEo7ed3zfMWUHEyLMB0+hoqvWVOxPBOOCvtVZuCqFUxh9ERWZ73r20LWxmUPhBMOaABPtICPh45QL4fQVCzskxnYbf5cZQ7QztA0bCdjd8WhvY3bVcEPC8bsc241TIjGGrq/EZU7gMCfKk4QLbbVTy7RIru84YeHS3YtYvOeQRm1uKm5u/TFdLsapy9Ztme/fW+OC3DzlolQ3Rb+n+8rRhxGb+x6Tq5iRfjemHDRUb3gc/cJhWIjSnRTNb2rMn+pNNfN015lIEYfpJuX6pBsNr2FzUxwDcogVlBe+5+J+/U8fIixZeExfFTTJ3AaWH8aMatuodmikIOBJL7aiMq81b5EbQGwPYMlUAqKcOkccujfYRm5BUpaaZ9MA32khrhQquwf5VVIe81IzcdAY6P07qI1cUpqLuc9Yc8oU3fLe5l8MAe78brGpMyQOALqTA1sz45mqdWN74TDOgObKoT+NwGmPs3/ZIjQOi2eBHvsjXYuIRhqizETdWDsNcNIGM7G5qrcJw1T5pdro+J7fZZyxqG5fAbElcj3M6Sterfk7wxLYf67D/Gstgrot7R7RW10SKT9+D2zfJEd7WPCY+iNtAK5Jo+E1YaE9uSQ/2Qr0WLGYqXa8v2fPuaZsHhGNnl5GdEcOYYrsijROVQCtuplYAdPnDv0J/fglSPat929vMH40B6pEH/YqAUGAJiJFgbycwHcCv3MY5yVFtz9N8Fs28XmiF8A9IAJu53LCqRvB9zKKj+M0wA38vvXXa6x+hKFEzRMV7XoHCQQbsJ7ADYLhLABNxKigCpIAsxHO87sCQOod0raGS5wCTM7pTmO0G3mzQ4oOvgro7w1wlzUQBc2VoKs83CAYj0fMznaI3yRNxtDIameuWTqB0nvUHKFsn9Clnwj4IFoIc7JT7YDJbcrFf6ZfRQNpkPcvB8lLg2lDuhMaBAQNIcoUqp4NaQ5dS4XLjQPeNnRPMQ9yQ85hmiLdg3ePEtrJgC4B8bZBWEZgOmL8aI7hYUR3xvwAS941ByWJuobWfIaSVxtSYR2wP9MpU83vUK/Y1JrFsAFQh/qV1/bdlNAvgYdnt3j64gRyW+HFH3e495vcwwV8z2z5GvV+ThQ9myPS/i4wvRC01wF+ELz8qQp+D+qWkup61oKqi8XYIhUjiLPf8hhmJSU7VoK0xSfz9YNoHv6QNCif6iLd9wmYaBFZFTU7rcS48dvIX6L6Xbd0gxnm3FAru8mFG/0wp6jDDUkFmNxcogoXyTU2f1pkC6TuyJHaomh8bhy0CDB7PAls1YcZF772NmX3FaLN6mM+lJ8b8pCRVw+8+mPA5CU3b4ssBhRBmnLx296nx7gp5F1IREnNYuqA8oJU/tn404cBCxK5iEX9XePyAcDxt7cYjmrs7tUZYbYR6+SKzinjHKhXiZQeByTncmNRh4SzrwOrx2wabMMn31w3YrU9bFY81mrDQv3o2y4X5+RQ8r/7Pb9DveZ5a1bKWdTpwfqxx/xpzFQSNgcsmgScJBjCWO+KVzF00hIbQ/MBQ7/ba2ocqo7nCgC2D+vMtzc7SopcSxGbEwb1/F/9eMT8A4fZecq80uSAFFmUhonH7ecj5h+6vEETcUmoBoqG6YmO4lKlG+VrqPhY0N3o+Z1pt6mPxAGibil4Rfh6wI0UHFx3yQiV3bd2P4oWMfGg9g9toX4ZCuv7mH8/9UD0Ho3yWo26NU51WiU6PQuASyw46o0GFOlGa7aZmQ99uP+agNspBUQ5uBSP0ZnDbx3GusbqbQaL2LMTtCGfXEWlsgXU61GdhBLGSZWRMOohOJ0BjE6ilLwA+JUivWs2nwBw+4WE5prrz3g/YfpCLQiftHADv+/kKmF3R9RFRS3fAgOO5s/0+VGUs9oSvfcdsL8f4V45hAlzC2RkgT3OgeaKRU21M9tRNgjQe/X2LVpODnNrTFTnMwVqnVA4RfIBUj6QAN8L8MU1hq5CmjJhc5wlIs2TESkIkjBJNFYM1PIdw46QuOZmlHyqLjZWpAM5NTXMeD9VlxWR2GtOWcKEz1DSIv7oW57PSgtUIxvI5AAMgv7tHjIZUH1vDgkeYVrhelfBT0mFiSM/VPYOqBPS0YjqWYNxDvSnEV691pMDwm0LaQPqZkQaBXESEWfAOPLYqpUD4LEb55hHAkCHzkf2nNj3rsZyD5lew/YL4113R2ycjZs9zC37Q2mSqoup1MEruzQZdcYLLWgTOd6TC34uQ/4YKJSRdgWhIEozTJwWSeCaR4SdoA6fueKBno8xJcRpRAgOroqIsxG+DYijQ/L8b+koYjOpcPSuQ79UUC0CqQGSUlsBoL3ks2R8+fZSwZsZMH+q3PcEHH0U8xTQ9DZIZd2wCbQkYPNmwv56iWY2IDxrcfe3ItzAvXX+PGLzgFPvcEAv5eKooI4TnH095XU/OeDu70TsT1zRCQUFJZQex6Ro/u76rYS7v8X1V5LkqccPX5/816e6SDfRoO/LogYg25XZwtMdO4oAh4RBqQ/bNxMW32OR0R0Lpq9SGd0lFjm2yVhhHBtg9b/e4ehfz4hyh+LusnwyYHe3Qr1joT3MkN8vqQivHmN2TbEFNlaCk28mWECKccHN39W4l8YrlsAAhnoFjvy6gnrzuxae4uLjmBEVE1oe8q9N6Gfc8Tw21X/OlICaaIkcFJYmBpQE3H5hls+boTVEAXhck+sIXKPw4xPPdV8XxxYIUfrupAh2rFhPjnSO7lgLy0GbqX3ZmDPKm0qB1d6UzcwQ8Kjwk9niGX/bvrtZcPE+QrbNW73lMX8WM/KClOCVrmFewbzWQFQBpkVE92o3aemUlnAKJximKrAU5d8rR5HBGinfI4c2Zr5LuPdrAq+ioVAfhHIlTjoyRcosuvT7hUbdaAylN9GS2T12EVJLtraMtd5no8Xdq3+/0q0AZHs3FmvfN7JNCck7dCeCoNfCBX6fqDzoj//igHv/os3v1R1XaNbFZSc7GSgvN7vMONJLNl8Q9W6m60xo7B7n9zIe7WFhYJuf0Z8CNeCZtpIckGqgWosmcJKbvbtLrvrkMiJOQepBT3R8bD3krs/8/nEq6vzDRmE4Am5rR1qeOk/weiVs7zt0dyNPthiarfZwHeCvhXSAkaidPSPDTLnYbaG8DGcjpk8qbB/yEs2eI4voAu3tafmnzWG9IdWg2jKQzXjGw5zfOdMvGuD4XX12l+XZ7e8EyAUnk/v7CZOXxfo1VRSaJseiOnxzAfeFHVKvEfVVIoKcBN0FL4J0DvWKC9o4T7Rl7EjVOHQtyo1nz8nDOGEh6AYFVBS88B1/b1B3Ga8e8MOiNDDbt/nQty89xnmCuIgUHcKDHpP3Gj6XNxWtFacj3GWDeDrwO0TA3VQYjgJc79BeMhE1TCgalSagnffYr1v4VQV5tEPoPVLn4WcDBklozmuEmHD7WdFsD71HdT2wNVpX4GIrqrohQ8jz8+J5Pdl0oDxLOom1ya4bkLUogK7Rlp0RU6ZVGXBkWi4IPb9DK5Dv8xU3JyXbKySQQ7+/B+wuPXZ3mUo7LHltZs+41i8fXWMYPYZ9hTQ6pCqiagKGJsFpc4SzAPfNad4zLDSrXpd9ZJxqdsCk3Ne2ntu/H30U889srYpDAfp+j32sT4jBIQwOi2c8SEnA7Vsex98b4UaHZ3/S4+h9YHoeskjfahAJQLO3XAn9vApobyJe/ZdbuN9ZYFgk3P1tm/5G+D3X4tAIJucCFyJ8X7RFEhLGQ8T/E/T6QXDS5T/8K5+I16e6SDcLKkALrPYQMbMFSbKye1Shl+sN2QFRhzPyLGPlDoohfkYSbmxBU/2O/9UsO4PExugOgvM/VqPaALMXQCWKatQUynkVOBLNUGSyKfaEVrxmyoIh8PpAWwHnVeC5/Dhg9kpw+zY3dKNxANxIrUgrNCDkv1+96TG94PGbN7nxfw8pE9nRRq31mPYI2yW4IHoTwOh3BjJqnxwQlUs9tuaoo4Ws44Jd31Lg60aQuhSATiQnaFbb0piY8MwEqZPLWL77BpnT3R0R+YMQdXcjebXjRK+H2uO1NzGPb7MLyvC69VioRGkNCdOLxPTTF0G94JGT+7ozPoZjq7736mBiKI01UbUWi4MXxGOXi0QTO5uIUQZ+vxxqpIh2exOyJ7fTe9B3CU6/tO+58I9Tfg/qJRTFjuXcmbuQcfHz9CkB49wfcMHLhCGnfYICydAKmlXUhlDyuTX6y6HorV8oUhsLMnjIU417r02M5GbKmsrQFrTOHGB8lzDOi31cc6VTsTGhXcVM2bn6Ei0HmxULXBsru5G0mj5yvYiilKotEXVr3IYJICqMlASMMx7AOAWuv+iw/JBFtj0rNpkw4S/ELOF47mfPeNDGmd2fENVev8Emoze+tRZeYYKsozDUsztLWL6v8eynnCjZdfdKCevvArs3AibPPJvbE/LSpy9QwqWEdBpb2+z/zJ7xUIxdqAy8j7b3i8c/J1jaDPdA+0oyfYKuMir0Nn6uXvfqjS36Nbup3bqFXNeAT0htJC0PyO8jvdnipuz4ZEi+Taxch5yP0J+S6kNbSnLhQ6sNxXFEc8XpW3eaENuIyUuP5tzTXnGhoIV2kClw/R+XAZgGTN9r4HcVYg1sZw5y1iGtGsREB52wDPDPKgR1msoc5+CQBkH1JsWo4hJQR6QkkI4aCBeAySU1Ds0t76dRGwvouQ4tsre8paXafsI9gJSo+pbNKR23dD1rteG3VOXBrHpd1ibZK1P6WuDofQ2WUtDB6JHD3L0mOs2OM3JgDxlx0NQDk6uQtTJWABsttPq/LzO9j+scDRte/RnyFX0Vkex+hGY3KA41zHlvVVs9ThWV3v3tAD+knOkBQF2/DtbdkW5o7RWpmTbZg546ScCjf5MQm1afg5DXz+UTplj3S+D+V0kDM+ezPE3UCYPR4awpMqro/H9YYP0Wf8+mlqH1CjBwcVk85fXsjl2edMfWYWgOxpI/fH0iX5/qIt31CY1GxFuwQ5gUxJdUFcn2hYdo6+k3WLhJECw+LGigbSJ541O00fWl2GIYkqK4no3x8gMuXrU+SACRUMA2edJkxgkX28Y4gsmQkPQaQkRRmsPqnQSJ5L8ZRcY80H0P7O4D01f8w/2pFjEvYe5nuQkAeIyzc11wtcDNiEm03zfkrHBpjR/pQlkYbXOg1zzg4+uFF1FMHv84c6j2kVx2PR+TV6UR4DkUbThYIBk6PjbGHSyCNX4HtQKbsHky0W614/d0xpV0KdsDio2R5WABTaUIjkoZkYScQGsoqNl2dscOR9/rUd922D+cIXpkUXK1E3XGcdk73WwOy3llSl9onNrk0f7MUj+3pw54vIP/d62KmpARGfrnlu/s1NvbNrskZXJQb2PmsuZi3PjmKPeyFeyZEjUU5NqcifKGdUBjcSNtFg95gabHsGkQUikITAeQcwQOXmdfrdEdIVO+6g3RWmuqOZpXq1S9h6qt6kI83/vovR1Wn+Hoa/W2YPt2RPtSn6UJC8jtfXLyj97nzt5elyCyYSFoLw+nXzze5ko3zhaQ6LB9gxqQ0HKiNb2gJasFeAGlGczahJaNqtNiu96WohjgcY9TweKjhN19yUin1+Ce/X3e44jA/In6Jy8L3cMoXkaHq2496pU+G4YinwZMX3pFTvl3+3taDPY8h939AIyCMBXMPxIEYaEzTgsymqdWUvjo8/er7Dvdn0WkxYjmSaNTmFQEuVtBaBOOj7ZoqxEXAtRVwObZglxwn1DdVJkeg1QaANIVDZlVuou6xMQK8CIYjwLi3qG+dVqQJ4S7A+J1zefuVtCeO+zeGlHdeKQ6oVoROW+umOa6+6M7pKcTYOMRgsA1AWFWobnw8D+2QXenhlcBbHVVYawTmrs79BcTpgHvPDZvR/LCXUL1xhbDsxn6uUM1HzEOnsFbt0yRdU3C7PEaXVch9B7h6QTNLXJzlPesCMQDdLra6r01BSdUQ/mbaqtOIQeTzeiB23cYXCdKa3NBspsYDgr06AtdLrTM4DAnkQJsxGyza+JS2ggayluoOLQcVdqJUuTs+pJmqVMAo3gq5cf3CWkDxM7DtQFhdIirGkja6O7LGmK6I+7pfO/N4wQJHounAdUu5oauiGTLHrD4mLRMs162Pc+csFwA3C4V+iCQ1z6jIbkhYXZOupsfUp7om8PNdBNfs820958/pzf87V9cIX5jSX/2He/r/sjlLJWdFuTZrc0LYvgE4sl2bX8Qn/OH4PWpLtKTE4TK6T9D0Ve6Mdjme/FHgeX7gukF+cK20PsOigTyvfqlFGW2FXGAhhfxbsi2b4qsRacCNi1qLZzIEG8rwi0l0kR7FqBgloZZ+HPAjzZ3CKKyKQscjf9JYSLyogtBQciBzAk/PCYT8tjikBuXPDotft+AoozKQ653SX+Pb5SLGWdFJJDqUgRmjnti0ZV5x+YXvtaiTtFSQ126Y8GDX9ng+f9ynhe/2NKxAiCnMKN0Q0KrgTrdscvHYZ7VtQpoR5uEKBJozVu/5H1hvpQsSEuhbtSkSi3SVj8S0HzV49VPtHj0i3u0L3bYvTHN954bE4a5x/lPJyy+5zB/HvN9aq/ogWHu8jgUQNEA6Cg6PZ8gViXxz1B7Tjus6KeHsKiN47DgMcRKMLaC7T2v0wKXXVkAACpGsqnJYaPkxgPkzxNFowOS0YC0CVBP93pT3AkO3yf0Lje8JuQ05C+BBcfhrLK9YQOax/HWGOg9arz1w+bKHRQs9SZh88YE2cFoABbf9YruIYsnIVAPbkFCyucBAiw/0ma2s01XUH/Pnhflcr9EdpNaPOGaMcwlW2zGSv3plVpgU4D2OsLNXU4sjp4isuZanahm/FnUjISq4+npTgBfIQvkkkdeQ2y8b2tM0CZgWAD1jQBOLRMbIuzL7/icbDsqtafasNAZZ0D3Vk8nlIsGfieFRrDhpMSoCZs3eEzzjxN2dyWLATPqvhgxO9lhm4SWhhcTVBuigvvHA+pXNbxEvPzt+4gPO/S3U05imsjE0brcS6nmzej619cv01YAyKmx4wRwnUNsI7D1aK+AVAmqbcPzYwFQAagvK8Q6obl06O4FVLcMVhruJrq1qP1jvG7QHu8h8x678xnc95ao14Lu7R7uqlZ3lIT++QzTN9bYbxrEqQCbik2HCPrzKZpHW/S7GmGvxeaqhlsMcFVEVUV4FzGdDFhtGjZPd9kcukAKk99zwpMcxa+xLiJM16uzkzZJNnmRsQADUJR7+aGuv0mfhyqhP3K4/krC3d9AnkJ7vUdjTYphszqkIDrsT3l/Hb8/5slwDo5L+rzuNc8CCYutUksq/xoQBUXkC5UNWZtzmCVy/LsV1j89Io4Ox1+j2LIyOmbkPR7EwAlk8OnkW0TubZ2wtSNMuPYDwOw85u9Es4KDdQZAf+ypM9oVZ61qDyw+HvJ0sdqMOPpey8anV9Gn6Zx0r4k18OxPOSw+Eiw/5Hc6nCrGCtg9n+P0NqHahzy1CK1gf0YKlznRMXOh0Jd++Ppkvz7VRXq1j5CZFsQianUmubh69rPA5IVgcpWwvetoz6bJo8bhzSizqd2V59kv6T1uozVDKdIBDcRpemmzTogjx2jTixG7Ox77M6rq623CXtXxLiRUu4L65+JWCjqdAxM8Vfan32ARx4kAilhEWKxbQXnYVBoNI1MO1CHDxsEJys+uhHxK2xTlYJHXwquOJWkTsEaioKbGf/TmLpMK8nm4gJDOg8xnBLhR+D5llMPvA9xY4eKPzGHR5NUeEN2ExolSNHQEbMFFhrKKFqvWQJjFXR496vkQsHmYXKVSDI6kJlQ78gbNapDHwIX79LeZVHr67RE3X1pimDvMzgM3G72X+qXAbwWbNxJufyTh4S/xWtt1svMsm4hhTj46i3uH3R3B7oGhUCbQ0s1xIrrpWTEv+fdygaRNkB+A5jZq4xVRr9NrTgqxklyIF/GWlPNjmolacux7PFhpQqui2tqmNJJFa+Y8wOaTx90f67TjgFbD+11PiLq1vO76Ivka2P2eBNllKUp5r3BAe6v2CYunwOZ+Sf81VNyK3FAjNzvWmPTzgvCJIoJmY5c0qbVfArGmGN0N/KwYSgPTbotI1tyd3IDsUb9Xgaffq1ezV93FFtn5RIIW1n2xL3QjMH+WsHnEJqTaIk+QfEe/Z9Fz0V4Aqy+NmH1ISobrkH3Ok6jNrH6OKK1u9/ke2Hu4XuB6wXBnRHtV8fO95DCifmmIIbB6R1CtD86rNU+3FfoXx/BVQlx5NGtSeMIywpDxi2/fRZok4KqBC5LDkYhwCqRTvrqJetsywQwJkFD48PFgGskHmQ1id8b1Q4D8/YcFGw6/B5pb+mH7vcf27YB67RFORzQf12x2NhNgERG+vUSYJDRbQawThqME3waMC0cE+7ZCOh4RgkNlaO8kYqzJoyZFQ9BMB8QocC6hbz3idYO4CAg+Yhg8haguZctAAbC7x2P2W3A91HMkiQ2W0V8GXSuhBTmAEn6nz27WLSnK+eJPCO7+FtfPh79MF5g8CTUARyeYyQui0DJyWAh2D4H4hQ2O32vhhoisx0kpa3oMYScQoJOHbcrNOz+H6/ChnidTx3R/REw4eTdhWE7RnSYW0oPaK7a6d2mhLgC6GWmO7XXC9CLm9W7zwGP5ZNTCF1g8Ccr7FztknLwbsH5cYf485HPR3kQm7vY8tmalk/RaAPUq708b7O84+OcJybm8v+fJ6TZi9ZanvfIO2N7zmJ2HDDQkocD28X8PPP+TgsmrCsOca0TQHIPpq+LyNc4KbVNuP6Fw8if0a/3HeH2qi/R+6VBXgt2Zw/Wf6PHGP61w9SWH029GbB45TJ8qUtSCSLr5pXt20lkw6UthSpFi4fIdjtsNhQ41Ob/jRAAdVUMR8/6IAqr2hiE2w0x5pms+jJUimCy6Dops3eSirWLCQiGqr3VGKtXCzoWk/Du6Sth7jFP3Wuef+eWCzCWMFbJbDV1L7IyWzdICNSDFFg8xoeokF3SpAizIhUmdyA9njnbXop8FFTdJThciEJNSlFQkNvOZM1mv9ByoRoAWjAd0Ch3ZG7UIABxSFlElr1ScZIUeuerNBkjQQtJr02MLinH0reBVcVXQQslsyLb3+dj1R4AbyS2fPxsRa8H0PGD2EjBHnHFahH2H0dAy6kLbCEYdNc9fRMTK4ejDpI3WIQ1JcrPH47OCmM3h9gFw9D1k9wC/j0gmXD32xS1CdCKjTUCOG+/LZguRPFLlxKggl2FSbCFt8mJFgIXqJBS7RnOFMQS5TAdS5qPGBIzmioRyz9r/HaZq9kvRBoQbvB8Af23npEy1YiMI+blGdiFxQ/ne1vwCfOb7peREWEnAUAOrd4DFhyymG9VQGJ/X+KXDTOC0C3S6jiABzW3AOPN6DwkWij67AWg2UdHORIu7HQvf6Us6tmzv89rRYYYIthvIGbdrkZyGJa3pXIHIDX3xHfOhJB3C78hJb65t/VIr2Vvy2tE71FecPHT3RyLLDRCiBr6cawIp7JryPYcjvScaflaseV+PywB30mO+6LD97jHCNMIf94jnLd75ySf47ruP4HYO9RtbOEmIUdBfTuDXntadkdSXOA/wazYPhqpnukEq9wcA9Hcj7e4Sv8vuYYDrHNpLyXS45sbubz6PolSp+ftEeOffqtGdsimo14Jq59G91UPqiPjxBOMDBiFJzxvE31aIZwOw9hivZ5wuPdqi31fwswHNZMT+tkXYekwebtGfT7lGTgPgAFcHxMFh7Gq0Rx2Gy5naBxbrPoDXdn8vodoI+juBQVt73g+jesNXa8DtkYWPRF2l8NaVEmXP5f1f12yEqABKsP+ecnhYcqRTHr8fsh5lchExfQXs35+jO0nce6LpSUT1QwwPG2cJj/5tzM2ufbcM3hwU6PYy0CzviZ7UzLu/E/DRnxV0d4lOT18SwLHwLqPTtVvuqe1thOsiwtSh3kVUH8esldnf4STsMOth85C0mO9PceUazGuRvGDz0OHmixGoeRO6nUdYjjj7NY/NQ6+C74TpRchrnosUVPsd9QYn74W8Fr9+7IKTb1E/MXvO9aVZJ4yhrMWiri4uEFjw+OHrk/76VBfps/MBOGogI3BzW+H8Jx3u/A4Fd4unERc/6nD8fswODkwkM76oZFTJgmLsQc8j+rpsBNU+5iTBLKpRTq9RXUIjqK8CqQkJefTuVeyUHB+seps0dEIDiHpAFFWUoF7jGopS7WMW7gEHC13gYjN/yoVubA8KyQbZItB48RDkqHCAi3bm6HlLmExZlJg52/q9kwOg4tv2xgKKDt4vC2EKh9loOH5ImSZkVAkmgDqs/i+32G5bVN+Z4s7vRC0yD4J1DholCfSQl72hoAlRuNCOU0EKKlwaFC125fsNak8nIwBfGjIil+Suy8FmZqJbv9fgDm3qTGzle2D+jB7O/cJhe7/iGBj8HCsGS8F/kDiqoUNysEpX26i+yHptOgtEMeQzYXpZKFLm2OOGhGYV0ay42VqBOyx9uS6G2Bwgafx3bj62wY4T+vcbeh9rnaLYpKGPSN7lFFyj5FjRbpu7uZpk94mOm/3smaJl9two+o78eYLxiL7ddDbivciGWScRUQ7Sf/kMU4ugAuRA3/p6UyYhRtsyjUFOrQ2SG9SgTR3tGhOguobmizdw7x5jcsli2dBxnhsgepcblO5YC/A1gYDd3UrpOBESaf1KoWfKhVPSBq0/luw33h/x+PpTuzfKZKe9ZGFOhJn/bfE8YnvXZe64C+qLbv3rhNfA7ifXA/Pr8owPS4ZsDYsIv/FAZFE4fU60GY5IngtcZ6pdocwYgJAA+L2Q0nJeY1w47L55gqrjMaZnE+Beh3c/eAC/9mjeXqPb1mhmAybtgOp+wHZYwo2CsAiorj2DwKzwVqcevxdA7+lxUiwGzSd+XEZg7eG3DmERsb8vaC9J+fJ7YFgmDHfoFDL/VoPdQ7rRdKcJkwtBc8Pn0h5Nd1tBHuwR24TJew1tFcUjng3wnSBGjnjCImByskeKAn9RQWKN+Pk1XBvgZgP2mwaoEpJPmB3tkZb8225TQwZBv2mIcXhgcsH7sr1kk2QBPv0pxasxcjLhNkxr9TtkalesgVSXZ9ySqZluqaLrmXDdHCzJGNlu1tJNXbBJmGB/yibGkG7fq96mAV7+VIWj93XvSiWjY/oS6E5F9850MKFF3hsP179s6zuWqd9rvuMAHvw7hxc/GxAbh8mFy1auGSyKnPbIQuDMIjOiJDUH7tsWtmbPQ3Jszm/f9rkBNqte/QTee33C8qOA4+8p+FMz2DA0FZoVOfrdscPLPz3g7X/kqIfS6bfrBA9/JWCYO2zue6YTL9XWdq7C9R1D/ppbgga3nxH0J5zg3P0tO2fcT8//qEN4c4/T//b7Kv1PwEtQAJc/0NcfErT+U12k709rvPw/RqQxYf5ejeVHKXN9Yw0cv19Ekza+z5G85hddsUCmU0akWGuA8tpLoWnRxs0qIs5NjEpBB62s+Fn7M7pjtDe06zPbOo77IlMnzTlGET1aPRZk3/csOEINoOZ3zclzAnW6KGEjdnxIyKLSpKiyuWQAyGN3K8opNkoZZTeax1gTuc0/O7C3tJS07PjQl0h4EygOMyIAgCGoOrkwd5EaGcHtf/MEj3/mKV58Z0q6kqK4hjIaCop0wEMOBzaIuqhGX7QDLLaMu6c/Uz56Ecta8axC0cwtPmwKSlPRrPCaJZcbE5p1BAKL5M0DDz8Ay49GxNrR/1abw2HGYnOnQr1aaQKh0aJcANc6mFYiCR1jWNwljGof6HsilXFShImHRbwhwOQwq0hZ9F4NwOotQX8M3P0dOpBMLqNeE25e1a5w3+EEcTDah8M4cwBc5qbSO17vYweECYOpupljvPwJHUt8n3D0YYJ8r/wuLyJUZCt58683Ee2NnptDLYWYt7x+bvYapritn0sRG6sIe3L5OkrHkBdtvFXUlsfs2kwzQKrczxBg9k+OWLx49V8XfQ+lfRjy1t5GVHs20/szn6kaLDA4Fp++CuiOHXb3GFqSwYMtRcAmeE5CDUasknKbWXTXaxbo1N6wUB5nwPqhNiU1sH2UEKa8p6tVSeocJlCHGjqe8J4RDA8G+IsKYR7pnPJwj8lvTbF5i5wiFzSptGGycXPD4sJSSastC1/jhtevaoIdrxokz7WxWjl0D0ZMZwP6rsL9r1zDu4h+yoXw4nqBeN3w8wVoziuMiwi0ETECrifXXIaC1ialfew+36P9sIFEpsICwPDZPVLvgUHQXPkMuuweBmA5Ap0HeofuhNdo94iOL/s7FLn2b/fw5zXCvQGT9xvI+Yyi7jcC2gvP5/RFg+4M8BcV/+ZowLCvMJ33GB51LNYHDxFgvJoALgGjQHqH7naJOI3AJKA57iAuYew9/KZBdy8gXtNpBsKGCpHe6jIIcFNxDUiA6wXT57z3x5new+r+8vxngMV7gjAFJpdAMk75TPIkiZ7bB8WzPoex4rbAZlzXVRHszkTXV8maoON3LdgP2QKyX5KWNXtha7MUu9uKlJnmNqJfOu6nHhSxuoQwc5qmScMBOnERlW5vAhCY0rr6TI35x5KpngLk5s3pum26NFtDbLp5SAW9/YzH4mlEcxvRXpc9i1qpgyntQahcdsFJQL2OqHTPvn27wu0XErAjLVICgEiN3OQVn+tqG/Oa36xsTRS8/CmHepOwP2Hhb8Ce35twO8FH5CTtu78dIb/ZIG12+OHrk/36VBfpm4cOiILFt2ssn8RCSQnFmaTp1AIqFGV2tT8oaIznqyKQcFCk+Y4/S0DxqpYyWgszjtyqnQbAOGB3BkzPWdBHIAvKqh1H8F6RXkOGkxf43hTy6q88Ybff3Kbs45oUkSbqz+NvblJBULTwTl4g5lMtLLizIMjcaUYd8ycub8lLDn0CwOLvoCEAkKkxLPytGdKFyxWUBSnRn9z4hiiFLdHtEjQTK8HR+wm79x/hCIYM8zMrLUIlAdBNwpqTLAJSqH9UD18Kpwo6yiapILt2DUV9tv2BWIlJoSnzJ614BQARok3GdffabPQLl9HxZkUXmevPVdlZgZOXhGbNInj5QQkMoSMIC8NUAdgXW0cixikLWd1IykmaFIpOKTJ5nkXPL8OUUraJTA7ZSq27m7JntTWOUX14bfMKbYnDjhUT/Ea1Nh3zdxbInh7+5kFuQmGj28xfEgE0vYCJnTKaD7tGyA42pGLxWtfqEe9GYHrBuO1D5MsmIRztA9dfEiy/V9Cmap8Qvo+LSwQ+ZQSREed6yzsolUvvf20aDPW29WOYu3zdG7VQPRTqQiSvL26k41J7HVBtIy7+SA0ZOSkINcXYuynPf3urIrQtMN9wND9MBd0ZN+nhjCTyakP+7fYhKWFOEfXU2ZoiQB3grys010TjgzpexNpcQYr3tvuoVgcXQX8nIr1qsXuDGpFUA27HzxtnLAAnF8jUCAMAXMeGMP88ATJIdoGRAFQLFujOR7y6mcO5hHHwCJsabu/QvrFBd2sEa8/ncO/g9w6xTnB7htpkMSSAME1onjQwWpAEQbozIG0qIAmq0z3wgtz63Y/ugW2FejIiNgF1HTCcVJjNOtRVwP6X7mBYgAV6EzCeCPxFzQKSyxpmTz12D9jMDAvet7GNiA8H1oEO2DxZ8gasE3DesAF/uEc7GRCiw7CrEJNgebzD6mqG9P4cw1EAfALahOOv2+Klk0BdV+WZJ+1Mz7FEnyejqaLzVW76HXD/VwVuZFjO9iEweyrY3wVmL5Si5sueCHNzUftEa8RRmTsQv8vsFSla5rw0zM0StQSIhYZUz2aVSGnUZ4eFOj/TitN6HfPeYq9Mc3Hck0KjwXLKUb/7VQffO1IQA7n0mIBrOmn9aFb6zBp1Jb3+/jY1AATzF6SrdScO01cMKLLfq/ZRJ3Dq0mJTc6PAagMcWp674w9GHH+gHym2n/O9pq9SWf+gQI8Gx4WWz/3+jNRYCLB5QFG2RKBeCdaPyIe3xPNmrbkq09JI/PD1yXx9qov0qgMW36hx8m7IqGk/dwD40Fjna6O+HN6ihXZotGBqysaahSt5rM2HYfuQHrYAH1paWJljCF03RmEkc6ZYLCgyGyeqzK5dQbWjjSEjNZJeILY+Bz6k41TQ3CYd0bPYMqQDQmHk9hGt48wLfpgKagCZQuCROdXGkR6nymvvJdtoAS6PPW08aFaCgKHfDvU2KcKLLOSzJsIcQ/LroFC3z7FCNAngFG0wZF6ChqQkYLuUTHFvbxUNnB1wlQ2lFOTrLBEQaPEmLIKSIBeJAHJTYQ1Apislo32Uc2dBP4dCxu7Eob2OmfeZx7SJiaqTa8H6YYXpZcAwoz5gnJmns2SrsOSQaTOup0DJkJ/mlpWjcTmjF4ieX4lMAiQf3c6fnp+F8uBV6DvOoCg00bTl+4LJJQtJIvkuW59VO055Xg9z0gZWz5XrE1zPEbg1RiyQTPTJ+3+cCrpj1VsE3gftbcyiYaMi5QmN9hqHbg+G8iWXMMx8fp5t2mTNNcDGbfk95OvYHwkmVzE3pkatSSHlALJqn15zkADMvs0aTGQ6W72jp/44czwHWuRHz6LAgslyqJMn5en6C9x8t/c93OCxeJqwecCpUnvDc7Z4FrF+RLFZs+IELrR873qXsJ0U1Jp2jOQg12vJVrBOv+s45/10/GsVjyWygA8TbUK25LTniVJStxAr7m5cnhS4AbCE0ZzumZhOCgDzjzkZmj9LuP2c5PUUrlDm7NkcziLipoL4BFxP0H5mhZgE7WTArvOoHnTo1i2q2YBxVyPovFyCIJyOcDcVYhMBzymA68kzrw/oShLVO/221n/n9+ze6lG9bJA2FarrCkPvgCoBKwcIEK6mWH2xx9TTFjZe0wamUledfI51+lLfurwexiYi1THrICfTHt29iDB4NNMB4dghjQ6LxR4hOtw7usXH4wnCqwm6GUeA8tkNagBhdGju7DC+WJY1Hgcot95XtnY5Te4lJQ/ZUz5WwO5ByrqYZsWMh1hLzs84/yng6LuA24AuJGOicFsbXAM7AIYCcQLsEGphgJejWN3cf5JoIx9Sdi4zepLdA0ZRE9h+mQ4KXwApYfVWheWToq8CULRN+mpWSVF1btQ5xfTQ2lFfsRFAXcOil+y2dPJtTvgMNKo6wQgDLZQmE9Jr1ZUBJ/yscs/xXtC6wCM3NPxF3UMitSjtzeFexc97+qcF9a1onkNpYEzsPrYE7IYFEPe81rt7knNVAj6hr/Qf/pX/WJ/xC7/wC/i7f/fv4tmzZ/ixH/sx/PzP/zx+9md/9n/yd3/pl34Jf+Nv/A1885vfxHa7xWc+8xn83M/9HP76X//rv+/P+3QX6buE3Qlw+WWP5YfqnrJX+sJUbQNR0DeAhYZ1tEZ7AYgSZR9vAygVBfJ9wv5xQLOqcuKXBcZkd4vIlaXeQH2e+bB2R3xiuyOmLiaBbtAqoNxJ5spVO6KTZju4n1owDbtnE3RaQmG9SeiPyuLku4R6HUuokys/z6LFIaFR7q4VFRZC4/vi9eyHspiyKQF2d6Gx0raQlwmDwGzzhLz7jMyXtEwLtyHloDiXSEoqZE1ob4HdGTcUFvO2AEoONDIxqO+tKC2LPScgRC7s5QKAPqlNoby22JrID6JoqXsdNeHERfJ/m1zFUhTPaI2VDjZUN7LQ2t7zqHYpU5fcqBZ9N0kbJWS+9f6Mo103Au48YXePXOaxRTlHoVgeHoqbrLkBdGNPwOQ6YXtXmxzlhZtw0qhQ1ogZ9Sc2TqlMLnO7KVJNGCdO7wsWjBl5x8FzckB98b1qNjQXwPcpPwdJkSMZAWfIqPAe9H2C6ylSM24qN3iXXS2ye5Ah6trE2D1GP/0Ev4+oNtZgCuA0TTUkDEtfPORrwaAibhfKOmFNHI9bCzrl99abhH6pTj4dwQGjZGWOewOcfYNIZpjyHp1eRBx9AKze8ugXkht4Q6qPPjh4JvuE/anDsCQFQwY+N801ee021ZFECtVh8b15DJx8m6Ess5eCm88SoetOtNkaWYD6PQ/NKwpfr3gvhalSHiqgWyAnHhuVTgI/Y3peGhw3GFVLxXl3E9pLIqt+4+A6QXzQkV7ydAHMR57WOmK4ahnoMwrcxsMFIb0lCNIAxDndNprjDkOcwPU+OxrFOmG8RxoEfGLRdVXxPv9whkaTTadPKuweBqTGHF4kF7yzbzb53qrVhSg2wPZHeqQomH5UI6UiUqQ4kvxyGRztFF3CbtMg7Cv46Yhu1cJPRogD1usJjo52eLWao64D5N4O/fkUqUpI788R39whJcHucgr5sQ5eEfjJBQGY0CDbd8IaLGfPMjI9y2xm6zWpmy9/yuHu76RcRPJ5Fzz4FR7szWcd+mPg7Bt6va3ITQp2CEGFMCE1plmxwY/CvAIrlMeZwzhRy1GdnA0LNm4S2QjESuBNpC/A7o6nNa+FESoKb/tpFpV+HwruuwjXU69i03CbkMtBKjO/GH++fqN4pXM94ENqgE9ytJl9TV8lUpoFQc4dsXXGGpq8fmaxe2kKcoNSOyyepfyZed10gvrGZbqdpSBbKBrpZHpMVaHkTS90nRCB2/wgquH//3n9w3/4D/HX/tpfwy/8wi/gZ37mZ/AP/sE/wF/4C38BX//61/H222//nt+fz+f4q3/1r+InfuInMJ/P8Uu/9Ev4uZ/7Ocznc/yVv/JXfl+f+aku0iUAd343any5Cl6gPO+pCvh6/eUDpwyAD0u9pdBjnALtTfk9r5tSsoULAJK8xk+3oAYmrBX1+uWXIhbvu+yXDEXwh7lgcqnKeSdo1hxpd8ekuxwWXkFTB5cfcVE0Fw9Jguu/uMb+fIb5+9ycT96NZSQaUy5WrYh2ymeXQLqN0VUALgA5UEcLUzdwDBlrFcAJMhVm/kwUGeZq5sZShIamFOLN5gAxsMLK4+BYSgIdN3/JUfKhYcExe86/88YF9Ckj29Ai2Ra3qjtEKFjw9EdF6ImEfOzWuFjxW64vciGW1Oveor2ThU2peNGK4sy733DTYPPAKcv8RaAf9inj5A0B6peSOZ5+X65RtS+FV6YeKWJmoUh+SEAXC1dSAIx6/RwXb7uP5i/1WPT46i1R7uLwUO43c9QJjcuoFgwdM2pWLOPjapvgNUTMNov8XjXFp5bEO7YlnMcQOr8vzYFx6IP+HmY+v1+sgO5EMHsZ8zmnz7PpM3ht254hZib6rnYJ+zuV3g8FSZfgMh/Xd1wMkhbdDAKSTPWx7+D7lJuw9obPmlGQWIQUP3RJ+dSh0uNv1hFyy78f5g77O4Llk4hYATefd0AEFk8T9mcavNYn3L5Dt5fogPaSa1lajpDbJjcpridCnoXk6hFt/tm3n2Gq5kLFzbHmejbMyb9u1mxmXADWjyQXn/2x3ldgER9a5ORcQ3jjDJg9RQYpTr7D9S1W/Jv9XWDxIVNeTQeABNQfTDLXX7Y1nUnu9hglIXgWt2njke52cJdEtJlmC7jpSAvDzrG41arJ7wXjKKhvPIbjAJlHpCZhnEWIT/DLDo2P6D5Y5gK9OfdZF2Jpxm58PSDKDUD7UUNRphbBJuoejhLkzS2q780xziNCVyEkAFEgnUOINaSOwEdT0K9ecP24BoKguvVwn1tj+mCD49keq3stxt8+xrBMmF4JhqVHmEXI8YC9tESKU5kguQBs3kwYTwJk79BcM1XXjUXr0l7xfN//dZoOWEFpAmq7wMff497ZLx0ufhw4/QapknnSqHtpDvya0eu/2qW836zfqFD/5+fw/9VdBXR47prbmNcoN5JSckgzpf9+ys8nQAcivK/PbFWQ+Lw+A+iPPNqbAHN3QgKTjMXobyW5m5QhwfyFAVeFrpKBBp3OVfsIn4t4UWCgFOpGN33tJXTRun3bk+JpjYIXiFEm1WEmmMbLFTALIH1sd4/H5wIPiRP/snbbsxlraOp1zG5pEZ/AVyrN+x/kS/7Dv/J7Xn/v7/09/KW/9Jfwl//yXwYA/PzP/zz++T//5/j7f//v4+/8nb/ze37/J3/yJ/GTP/mT+d/feecd/KN/9I/wi7/4iz8s0n8/Lzew8IxTq0SQKRv1gauJFQRWKMBGiIEbrxskq7pjVQpG/jt/7+G/IWpj4pjQKEda/dnbGwAJWLzv0NwWCoQ92O3t61QQunQIJor6be9TQW8bhD3IlgaXk9x+c4nZT90gPD2G+Y5npFx5xeQZ81gsCtnel/9sKEViLHU8KICBjOZbQUJItvju+l3KTQCcYKyRF+fXhJdWBCe8xle2UR5gdJOCfhjfX2JC1XEiEibIhV4SDXIxBCUCbmujS0X53kyFx9+RcmBpj8Z9TrDGB9jdcfTUhdEgCkrSHfO/DXOnwr6Uz1PWKWjirZ1b2wBGnebYmLlfWMFaEmzNy33U9EnjZZttZaqAKLQZffVf7HD238z03kA+lzZdMPGw/dyuvW0MEpAbzUNub6yZbOfVAURcQZlsIuR6ni/fRaalOsnImUT+dwZ3IDur8CFF1lDUW3V8MXqMIBfQrk95A/X7gNg6FWtKoaElc4lgIWFCcGoygPP/DS3yHv8LVgLDVOCHogkx+ooh6EjIdmbJXC60+DN6iDWZksroPalLEdbGRy1NsujmO85KLoDdN8NcMH2VcpO/+IhN3+ahYPlRxPoNl3UAxi9urvldjn+jgaVJ9styTgGOwn1X6E2Z6lYDN591mL3gxM31gMx4T/VHgCGVs/OE9eMSIFWtOckzOgzXK/43E4nWm4TuqFBxxhmR9esvMQvCdyx+4fj7/QkYFGXTvb3A9R69TFgozUacHG9x6yOGVQM5HoHeQToSs9OuQhgSnGhj35L6FZuEyQuP/b0IWQ5wz1sEdamZf/YGt+dzSBOBWUB91GHc1RhOBL5zJbH3j90CXz1CveK5TB4Ib+wx+daE+0XDZ6u7G1mIR8B/c87p1tphNwekiojBQ+YBggRXRcSHEbHzaF/VqF9VGE4CffJ/fYFYA+dfqbFc7tDXQPuZFbbLKeplT2cSoWWkpcmKro3jFBiPA8/NKOhPI2LtMH2BPGm0a0YQQ0P2FM22ianpCWJN/ceDf89ndvOQ17S+1SZU98phzuyQ6StzbaKL0vx5QPy/3eE0U6d23/9Kjvzq6UWp3LIBge0v0L1WdU55MofXC75xIrj6coW7v8lCNfPqbf01dDuBDYetMfq82KQYsEKda8kwcxhblxFry4vgd02othFh4vJEOq8Luica0IWqHA8d4ByuP1dhnAOn3zLOu2qznGD+LKLaOU5L6vJ+VrQX0IT3XXOb8j5oNMQfvn5/r77v8dWvfhV/82/+zdd+/uf//J/HL//yL/++3uM3fuM38Mu//Mv423/7b/++P/dTXaTHmj6hFsGeBMDU5cVimBVBJIvYlNXRSfiAdxoow1/SB8AjezqHWtD02mFXxZIOKIVnrBVxUo662R9KROb6HYorJ1dBix8tLmfG9TZbwIR6yyo21AV5dWPC8XvAZXuMyUqLk4obpvQxF2MmPvW9IlyeSnJDD4EytssFuBbNw5wLZ6WjURP9OKVfGLJY7Pu0gLEGQBsFKwajB0R91SOK+I9Fop1I/R8rorWwGyfqA70BpOG/N7c2ti1NhPHNARYgs2cH1BdFxrwWSUmA6x9xqLaknvguZUvJXLgdLHztLf/OjXQRmV4WBMgQmdecd6riFSyh+JADTLiNamPJgkqAWI7bDWxKhoWgOzVEilQnScCdfzzDIQeeAjD+fX+siHNM2WnFFvJ8/3vkNM88eTkodvNx6wYuAdje4zg2TIj61BqJHmNB6IwW5YeE6I2zW2zshplg8yYwfcnpgVMhoz2H1T6h0nvzcDwOIFsiWgqubYwSUtYlRO9YKPuIyccNkCILQUW66w658WahXdByaz5I4yquRVHPVbWNiBOKx91A1A4qYuMmXDi1rk+oRgrYxymbjPaG1zw2ithXpfARbRJO3o3Y3fE6NaEgnUFlnNaM0/IMm56mPypNcc50cNDJClFh17PY3ihSHiZAtXZwHYWGw1xTST0L+P5E181jHn+lzXRShHz3MKC+9hiWCVdfFsxe6HdcJYwbWsfOntFRpF4D7i6AINg/DMAkwF03igjzOo7LCL/2pHAc9dh1NZpmhD+NuHe0hpOEm90Ew+jR1AGbbYth51B1Pmsx3ADs3hxJzB88woIuKGE5Yv3BEfyoz+MywnkNIgoCSa6g079yhPWPDJA6ZgQ/7SrsHgfIKJBRUK0FfkMXHSuG3UCrysn7DSQCux/padP4lS3CZYtq7YBJwv5hzBaNnZ/C33pMXwr21w26dkASYP9kgWbt0AsgPsFd1ejOIrozYPrMESV3wPrzAW4xIHYV5M7IrWg15RqXoOJSK8INITkANdKB5kCfN6OS+S7h6APbL6E2l9q8Bt4rpotKjvsDjQAU/U3FKrjQVvhs2GfYmmCgTG66gQwScEsowNFhnoPEhIe/EvK/5+I4r9uJDYAFthmQop9p03YJIP1G1zprUGmlDIhOzt2YcPnlCiffDTicGFr9ME45XbB/P3SAkQR8+L8TYNoBncfkosLi41gmBeDUvkv2XKf/SaArqHAWMJAhIrZckyxj4xP3+kE0DwmIMeL29va1H7dti7Ztf8+vv3r1CiEEPHjw4LWfP3jwAM+fP///+VFvvvkmzs/PMY4j/tbf+lsZif/9vD7VRbqh5GEiCCg8WUO6fV+CGfLNHwyJE/QLl2kP5gJh72FcuWZdunE3AFdfEZx9XRcVc63Q4pw+0/xv/ZGKBPVmNTsr82k+pN5wPMexru8saU3RtM6EORp5nFLmEFqQSvatbgT7M4oEhykAB7RXCZUKoEJLnmCsQUuuZOhFKZZNDDp4/i4SsD916M6gAkeOMm3RzbQVK7BtsUzlGhyiDoMijN8v2jO+ugQVs3k9nytSGQypj425ptB7e1gmNDeCyUVprMYZ4HfILivJA50mxAL8nf4E2N0XTF6R89/eRty+5XD0UQTUlcKKYN8D9TqgXqvjwoEXfJ4QuILMPv3TgtnHgsXHei91ZQwsiWm3s5f/X/b+PGjXLC3rBX9rrWd8p2/a895ZOzNroFCqoKX0UJxSQCuUONoifWzUttUICVErxJAppPhDwAgDtQltQY3A1pBAPNLHbrWRVtvigMoRy4KSoqGoMbMqhz1/8zs901qr/7jXWs+7oUA43dRJOuuJyMj9fd87PMMa7vu6r+u6PcVyYHWroFgRhImkjoPTB2HzUOK/jQLdKbKW0Q7Mi3e16jxP3mnZfwH6WgTAEdHyO4mUNDaRhyxBK2lzcKHyEB0S4nOZPnSjd7hSmCZQsAKXP1aEhnqcOylAV/HaFbNXGJM3QnKjR4SZwPuO4yLOxXzlpBplRy2JyyUI9kas6Fwmm+LV95UpAI9oYex+GO+/CF5JY080DeL9ntYU4PjLelhmlKeG6lgQ1qNf8AyhKZUenna1UQRuenDZ0b3w8ts9nWgKIPdLhX4G0ishoHiBEmVLFRA3qfDYQipJ+Ro2N3cSXCXnlK8ledWhB0B7VcZ7cRmCScJ8aMR3W1mZN4QAfFtFdw6wnXyWnTjMRieaj9cS0GeXBleKQ1C2kc/NNjI+XTa2p6+PPZvriskD+ezu1NDPDc11i+qFD657heqEgtDvWzgt2U4Nk0VD+3DCY6+oy462y8kzy9nDOdlFhiH4tE88w8wxfclgmiyg+R47EfcVX8r3uFyGlllr3OUU5RVFWKdsSbIvzC4yzEYxPL+lqAY80L8sHZyKC0V7KDQa5SRB6OeefhY1RfJ5MVj3D2qyNliaNormVs/0cEOeWYbVjOIiVBZKxzDIPa2fWbI+naB6jSp73GFHMenpVgWbPDR0UuBzJ91JjWNY5RLQ71TVfHBkiZUs+V3wCe9IcwhINB7TBo5z1FUEpDh2zZVmPqHPRbTG9XEMyhjNN+K0opxOawSMmq30nTFQV7tOKRLQ7r0g9Jnpw7FMFMGImGC0C0V1NgbvttTiIkNM/sbmePIBwZQg6pB2NDy76wyEwDq+NehMHLIur28YJo9lLUp6lrBWFReMtozxa0MS/ob/p6dbFGRbhzPuKd67y6VqcfEmz9Wf8aHHyYj6R0F6tHfWg3Qvxct+YQuVqHSv1+PjH/84e3t7T/3u27/92/mO7/iOX/Y9Sj39rLz3v+R3v/j4iZ/4CVarFe9///v51m/9Vt70pjfxR/7IH/lVnePrO0iPZd2ATiXBZ2jeED2Yd50GFGOJPSq8o8tL6k6oSAvPUO1av8HBR8NkD9l71ogvbD8NnLsU1IXSfetTYB6Rm/SfCQ4N4RyiNypIJ8BsG+gDG/mMfiqB81CKzV50qlFOkol+AmYrHrS2lGYPu50mo1+KOKsgQV4/InpeK/KtWAtKJ87gpzuV929uO3ymsblm+siFikO4qSGoSxWFLrrqiAgwXvMuSp34fkYoIBEdGypQgwhFu33xZ5Z/g8vEes5W0F2Vi3OlRrfCs+1mgryXF57NVQnA5TnIdx1/kebKh9xT/MI4bvZfELQkagBcJpxiIAVf8vt4vn50DIp8dReC6Y2g4ouXulSNGCaG7b5J39kHKz9lQWWkpGj30BZMQFBtFdFdUnVFnhFc/wlDX/tkkxgTwRh4e+R3WetHgZUiVY4ij/Mpe70suAtUCmUV3QwmxxrT+IDWBb92QtWlD2WQkOCoULkaamlskq+CULNWwWM8lNtXPjn++HJMJpUTFDkJoZVcv2lcmN+MSaGSoKI6c8m21BlBdU0PQyn+y7oX9CuuB7FxV6QoxXtx/UdzLu8q0XxoxfSBVFBMCGxixUqcLnxC7diZS5PHA7bSklCEYKC4dGyuC2xnuqiTCddZBdS30jSH8vxNQ7ARlSQ5UeYyCazVAP1+SEBqCbDVINUaGYukQDUKVMtT+czmqswVW8l/7TVLcWLIH2uaa07Q5h5c4bnyM2In2c/Faz8GDaIXCclCLXz0y+fl2VWPFc1RSLaW0B4p8qWmn0uwkl8qun1PcWLo7nT4XrN9ZU620QztlIu6Rg2KbeVQucOWnuJCkEvdKYpTIxWnQewYvYFsaRgWluxCGv3gwE4lsMm3GleIIHL7+Q3lCxVqkAqFLRX93JO/UOMUdNcG8q2i37N0C0220hTn0jnSXuswTwpc7mmvD/SVpfxkJRz+4HDjCjBnivVzFjVoNvfm1LdW+JsNra4ozhRm0qOUxx11NJuC7CyDO1vms4bzkxntRYlqDL622ExxcPOS89MpOguBWgjW7cRJGSWg+6mi50g0kLj3iThT8fDLLOVBw/THZkwe2QDYqCTojxWiJMKM63UIups9oWrq3of+DeLCBTJ+xVpQj05IedznZE8bJiIqdzuah2wTqjK1GtcPO9LMlPOB8hNcluxozGBax/ZQJ4pfsRq7Eu/S6rqppj61O+u+Sna2OghbY5UvJvzFhSTI69uaax+0o24lnJPuA63VxyrCLwrYYzXajja1WevptTg9VU/U2L+kH9d1Ma4fEwlbxHkucYNZO4Z4Lq+147N0Wm95y1v4wAc+8NTvPhOKDnDlyhWMMb8ENX/8+PEvQdd/8fHcc88B8La3vY1Hjx7xHd/xHZ8L0n81hxj8jwiBy+DyDeJkUB/L5j9UCt1EEcvoLJIUFypOABUEMaFVe6VSp8yhis0bAirJDhoRBFuxoyYEfm7gSPczmbAmdBiL7jPyXj82bdn5TDzsvzA6rkBARrwKZXjYLJQ0X/Bj5SAGkbYQ68ZoZxgXk/Q56ftUWoyig0ZCv2NVIqLEQHmsqR+PmX305c7XDoLXuijQg9io9RG4Tfc/fu4uoiNc4TFoN6G9tWrAB17k5pZPKH9zZ4A+IPHG4xc969+sUD9XpETIZYrqjERf2FwXQdXV/yKB+C7lA60g8IldRnJ2YefeRWuu3XOPPtCxChBbxV/7KZ/cGLpFJovy2mIah+6FPiK+2JEyIfSFWJGJyaIOFpNJVKQU9YlldcfgVUSXFPWJf8rnPjXxCKcXx3ocS3EcpORTkQJhNTztRd0tVHKHsRVsjxSTxx6UHvncmlSeTvaakW7jPO1eBjv89m4uz0J4+5AzItxDJclxtg3c92LMAGPZ2xUSDEe3g2j/Fm0hRQAbfe5lnPQzKB5Ffm5IMKIoVAVnJwU+3HtxXyFVH6J1Y6TauEy+I1YtorMOIZFQA3R75imtBMjY2tyAvVVcc8STXAVkN1aksvX4fGwtreJ97imf6BRYq0ESV1t7uisO3WiUk0C/O7BM7pu0sdtynPu2giEL3Utr+c7uyDJ5ydAvSHaLcW56LRWwfgazex77WAVeOPQLCcC7RZgbDnQvXHFXSkXL9MK3Lc6Ee2tCx2CpcMpr/aDQG4MvPD7YfOYrIwGcFmvIfu7Td8Ru0LFiZLbxuh2+cBTnItjOVwi620FzxUHhggWj0EmKc53GkisctjBii7oVhLs8NnQHDtMp6YuxUVinsHOLXhnykxxXZDRXHPVDTfPGFvO4wC4sts6o7xmpkN3dYp3GXRRw1OGe6XHbTMSl1zvcsoC5VBSW92oMkhz5XBqY6VnPts3Jq4GhM/hNhpn1FOVA0xq81umewkhn3KWYuEKoKyaYB3TLgv6tjvpYpU7MLouVAZ/W613UODZ/03YnEA1jJVaGAEygGAoF01OdqlQBNZ1UiGMSHzVRaXyGyle7J2vlMA2JpoL8Ai7eKvfENJrJA0kGvJaq+Oamot33HHzUpHVTDyLw1DYksuWYBIyi3GiAEMbxMCYoe5+2qBf8mDjsgINRdB9BGmd+8X4uFfvq3KXnESvWj36bwufC/1fOowOFTkAH+S6pioR73xMMEHygG433/vV6aK1ZLBa/qtcWRcEXf/EX8773vY+v/uqvTr9/3/vex1d91Vf9qr/Te0/btr/q17+ug3RvFEPwXo7lsPmrjuZAp0YI0UIwLjyx8+hQkdTuJnCBTeexYZKVS3FyWN/QrJ53TF7R1Cc7wesQ+Ol4TAi8de/TBhJbjBN+D1CdxSZCpAkWaTaxA2pEPOJ7YpleSvQ+nXu2FR6ycJJVcL0g2W1tjyQhqU5JZcUYwEeKQ6TrgAoJj6AcsYoQaQv5CuoggIwcXsI55m7k3yWHDkLQUcQmTEGcGtDO2C1zfJA7CLuS+9TuB7eIPjSmqb103XNAp9G9whYS+VSzjubRRLx7e6H4FCuppHQzqR/UT4KYOAa38auj2t7HBEee7eaaoT4WfnG8p7vnLI0oQqLgfPKhTwijGa+nn2icUUFYKe9p9+We9DNp6617Ei880lBiy3ivwFmS8Hby2CUUPI6li+AI4nVo5qF2kqNwdHNBWMtzgjMPKZCOdIxdbqZcJ0HUCbP78jtxaVDpGe8mgdFC0Aeu/OnnG/o3bpn8TJ3oUZPHErTZMjbXkRsV58FQKWxh0hxRaodegmxkgjB5mkNNdTYmBMNEk22daEEyhTOCnFen49yLgYurxz4Bcd7GypOywV0pbMgybsN4MSOKHjuculyjzIisATjFUx798Vke/ZxneVdRnin6iREgYDLe76jnwEuA3h4JhUM3mm7fp+YnLpdgHi8iTK/AldHGVSXeeuSxx6qVKxg7GXpB26sHJqyNnu1NwIZAO/eYjZZOil5xGSoOk4dhzob7ZjpZS6f3STa3m2tyPy/fbFFW7OZc4alOQu+APaHO2AKq+zn9LNhNDiM9wlbgM/nu6CKle5WS2The47wrjzXKafrZSI8zodtw/UizveOkjKglaVAOmlsD5cOM4nxsC4+HYWFRfUb9QE6mvRKCuvMc3cFwrcc5hTnNKFbymvx+KUHXkww0xGY/+pM17ZGlPDa0V6Fzihs3znmSzdEeXHAnMfOO2TNbMuPwXnFxOSErBrqNRL/eQz1tGUKw3ixL9MqkBc0WMVhWI7IbEFqXBR1X57j9b02apwmlHUbk2lYKG3RVZIrmUFE/8am/QHUSHFMCVXSogv4rAEVReO6Vp+hJ7kvx3spYVLBjCCBrKYliM3vo0v4Z+3Y8/mLN4hOa6QPhk+zSRl0OxVJRniqaA3n2zTWPnQ8hAXSYS49ppaq2vBvE6UupBBUrPwIiNv57THYIwbOcq+fhbxOXoOkDn3QWcd6OnPsdkwUVNUEyh6590PP4HbJP91PN+oasLQcft2mvSb0qoitaMC7YdYN7LR6fFUHr/4Lv+MZv/Eb+2B/7Y7zjHe/gne98J3/v7/09Xn75Zf7Mn/kzALz3ve/l3r17/MAP/AAAf+fv/B3e8IY38Na3vhUQ3/Tv/u7v5uu//ut/1d/5ug7Su7kiCyXmfhrEkX3oBGglm/dhobQ6bCS5iMVMCDSyUKLMGtKGDGHx8mJhNnkilm22Gnm77Z50A5y+OjZO2lwXlGuYir2ZLZTQUKYiDBV6hHx+DIJiWdoTsnMTm+SQSoRROBcTgegIEjP6WBbES1BuOs/sfkgSIAmIIsUHQkAdOPDChw/B8443bRTblRfyC9O4sfyZ7pVHo5J3egqswkIcg7+ISIrHdGiStLO5Jpu+LPKcQ0DhCdcRKhCFw+x1VD8zYfv2numsZbMpmbwqG6xXwdfX74huw+I5cvv8eE/ceA9dppILSLzmeB4qXUe0+NTkGzcGwoF24jOE0x4EntGm0uYiQoye4x5QVgV+K4mupRy4asflxiKc2l7unSC5CH8Uogsh04dRwCXnuD0SFEqoJPK6oZZnM3swcP78uHSI+Fbu0eyefF4fqjCxWuCN8EGzjdyUGKjHexMD3af81y1c/RnLxVktzzKT84mdCnUnG+n2mnDaDz/ixlLxzjgSe0gSNzV2kk2uLWqcS7Ga0RWj405syBUtVfO1S4GLN4o8PBflVfKm18PYCwEv77GFTkihrcbOrEOh01hZ3dTM7o8UqXY/UHAyxVCMSdjk4WjHJhx2wrkGhHoO/XxE32ztoLaoVSbI9l6Yk1vpyMn1hmrSsV2VeKfQJwVejx10E61qZ32LrkLZdkws80t5jvUxLN8A2VrR7cubijNFPxP3ltUz4jwTGyi5DNpDCaqnD+Q7ygtJGPOVCeJmGSexIZME+BKYu0ycmKJ2KK6zItQM96kINLMYwOx450cnkhh4xiQmru3RBlK1GrPfMqwyugNHeaLJTzLhs9c+VQJ0DyyNjOk6rIdtaAJWOdzegCkttpfGUv0s6EMGma9PVU80tFcsvnS0zw1gFWwNvdPkxUCeWbpyoF2VuF6z2Zb0x5VMxInFWYW/KOiPS0yj2BwNQTxq8G68Hyq4Qe3O60jLTC5NvWghhlqPe0EYlynQD30M7J4Sm14lXXJREkwmx5HwnRAoR2F/HOl2gpQnYApS4Bv1Prs0GxmXchLFSpqfxb4KLlSKo0f/7H5Y68O6EKkq+VrWSZ7IOaqPgleBbuY1588rJsdWnGlehfUt6N6xZr3OmR5sMdqRZ5aT4znZg5KrH3L0E8XFG8Vvf/IgnN9SgvvUfTw0kIvr766Atrwc+41E+o8tpdp5/QOe9Q1ZMw8+ETjr4Z7c/wrP3sc0s9Dgyelxv0xNk3b49Z87/uvHH/pDf4iTkxP+8l/+yzx48IAv+IIv4F/9q3/F3bt3AXjw4AEvv/xyer1zjve+97186lOfIssy3vjGN/JX/+pf5U//6T/9q/7OX9cg/ff//t/Phz70IR4/fszBwQHvfve7+Wt/7a9x69atX/Y9q9WKb/3Wb+Vf/It/wcnJCc8++yx//s//ef7sn/2z6TVt2/LN3/zN/JN/8k/Ybrf8rt/1u/i7f/fvcufOnV/T+ZUXjix3DKUi3wQP6khJUTvZXJg82ys6BE6KvhY+nDfCgT76sDT/aPd08HANbzVhUYnlbC3f4zIpv6Y2zZC6/HkEKT36cMf2Spa68eVrRjSBwL1tR2TaKwISGDbgbgyqY3kNJZuGN7JRF2cK82mf6ApDLpxysbtTeONH7iyMoh8NXikox2B2qAPlx/pRCBqCFa9IC/tQq6dQrNHlA4gISggiY1CcNlQkaGr3hUaRbX0qG4pH+Q6auA3lyRxmn9asnxFLq8nPFYLCfqqmczVFF6gCYQEbSrjyv3+F33b4Ev/k3/237H9E7qlpR6qR6cauqfH+xySp3dNkLanzo3KgNWFjUin4jjzmFPiEwNRno7jVliPP0GdSDpVrVglhKc/FJ1sPch26H+kTirD5hgU6BsNpowxlUT0AloTSTJ64xLXcXol2lHJ/zp/LyNdBsOkDX9/IRtwciQZBdxLc1MeCmOVr+Y52IX7/pnOgYnKmUjVFOtOO+gznR7EyCppDQUFjoxObw/wVz8MvH/Afk+UsitOi+0pEuGOVZ31LkFhvYPYS2AUsn/XYynHnx8bxGgM9V49+xyIsFvrE2Rca9j/hwxoQnV/kNc2hojoLc8+O+o/I9Y1djCW5kmDY5nIPH70Tjj4k15ltRt2LaSWRKC8cevBcPGcoLknPBkZKSlynXOFg0aOVx+SOIXe4TYa5NGLFdygNd4zxtG2Ozh32tMS0YuUZ+zlE5wyzJXUgjQg7BBHqagzWLt7kyS8jYq3pZ55h4snXMlnypXxmdSzvqU481Qksn1VcPC9j++BjQgHc3BBv8ckDEW8XF1IRyLajh77347yP/w0zAV9iIJ5tVNK8KEeyqIuUnjifkm3gwgtqvo3cRHG36SYF5qBFPaxorltmnxJa0uY5S3acpbEWOdAxUe9v9NBomA7sH605P5lRvlTQzz32YCBb52kORBcxCInCSjMoyE4yspWieVOLUZ5h0PJfk5NVPe7eBN+V6MKL1qE1Et/Oe6qFdC7dK3ouzqagoN5vcA/nct1a7pdQ/MTCVuxJVQImhKa047Jlx/FmS4VSY3AZnaPinEiC9fB6SZwUOjqoKVlvovtVnE8u0O90v+NeYj3GkQCU+N6YhA+1Il852bsU9DODRgSWu5U/eT4RyZY1Q1B9t6OHUsmFapiFoL7zlL2nWIH+hZp7X+FZNzOoLfWi4ea/zsm2Vu7RAEc/7+kWmuYI2n3P5iZMX5FxfvzfWIpHMm6GCex9Upy8+olKpgfd80YqViegvAirq2NJLporktjGzrZxz7zzPnCZG/fuAMhEbc5TtN3X0hGrDq/R4z3veQ/vec97PuPfvv/7v/+pn7/+67/+14Saf6bj1zVI/4qv+Aq+7du+jZs3b3Lv3j2++Zu/mT/4B//gr+gp+Q3f8A38+I//OD/4gz/Is88+y7/9t/+W97znPdy6dSvxfv7CX/gL/Mt/+S/5oR/6IY6Ojvimb/omft/v+3188IMfxBjzy372Zzq8VimQrc59QvW2R4rzL+y5+WOZcK1LQoczWWDyVaB8dLKRHL/dUJ6TkC0JqCJ6PaKQ8f26h8ULCq88PjRpSYE0gIPjLyiY3XdkW588siEGWAHFNgGNCEmFaUZ/1ki10N2IkvYTxexlef3lTD5rc9UktHCYhPmhVfqOaJkVAynZDMcARAW/2cSnCxtdLPXhpawJAb3cjGi8DzzGrPGpAhAtC32w7kqiPMbgoFj61KrZBkGbaQMfNgT5ygnfP9vI9dfHpM6jeoDmhpyUM0EweyE84t//tf+Brzt8Px9qr3L795zxfS/8/lEgGwPzeAR0KN535Uc+d+x2Gq8bHwQ73YiURppFTOCUB6KLSEDUY9Ap9J3gpBL4zVlH4pdHAXM/C4FqtAbVYI0K/vvjpjOizirch0B7cjsooxMnGa+g3dcJkexR43eoGBhDceExWyXfGUSc/USE0aYVGpGIU8fvzraykUgwT0Ls4qZrK1JVZZiGMdSOVC5lPbf/XwZv/FOLe+pK60fr03zjKF+E4y8UAeLZ7xDBIa1hemPF8vYeZ180cPdfQrtn5L2lCI3js88a+d6jDwfxsxo7ycaEbfIkIM21UJRitSEm2aaXluvK+qQ3ifzU/FLTT2B5V5qtDbVK3YwjV9gW4pH8+LcqXOWoHpm0xnjjcaXQTHSnpRttNWCMo5gNdIWlp0TlDr/MwXisU+Kd3WjytUZZyDqFrYUeojzokIypAXwRAuFavk8PY9LodfDozqGdyH2b3pcxu74tdJXIc8+CxWm7J/MyvxyrYs2B/G6YyZhsrsjntxMZYy4XXnx1EhD5VoCXi+eErqLCetstRCyug7Daa0k28EH0Gi0ROyCD5oZlcs9QXIiLTGzIpAfQBrKXctorhvxSUZ4aVm+0FMcGOpkf+RJMBpu7Dt3LuPQK9NKgG80ArB4doAvhwLPfUX5K/N4jv90rCZD7hSdbKdBKKqzH8n99UvC4OUBvDC7zEsQfaKq7K/anW87XNc4rqqLncLLh5Q/fZGs8SnuGLiMrB7TxNMuSqh3HtqsdptkxTeg85GFO7jTmimtgrC6lztGWBMI8Rf/6RcGgLRTLu+JENNQ6aFUc0ZLRdNL8yLRBt9H6IIz3wd7waXAq9oeIBgmx/8dQ61TptEajlIznvlLpvRF4ipSopPsKVEyvx38PE58sKF2gFQ6VgnnP7RtnrLuCZbC0jGuOCsh1tvEsliT7V/Ccv0lTHDZ0WYm+zMgvhWpTnXqq8zGp8Q92hKkeqjMYaYLSQdejuLgTxn7YA+tHBFcXL2BkoPEmN7qBzx2v8ePXNUj/hm/4hvTvu3fv8q3f+q38gT/wB+j7njzPP+N7/tN/+k/8iT/xJ/jyL/9yAL7u676O7/u+7+Onf/qn+aqv+iouLi74B//gH/CP/tE/4t3vfjcAP/iDP8gzzzzDj/7oj/J7fs/v+dWfYNzQQ+mnD10Zh1KQtmq/YX1tzuQ4LhDy8oiOQkCxes/VD1n6mRaENFeosKlGBLMYxveb0Owg24YS4ETz6Hf2TD+WM40d/qIlkxIEfyhHDnls9hHFaDFASt7lO9eXSvUQGhTJZw4lTO6Jn3acsFlYrEmlbb+DvPrk4BF5i/E8Y6Biy9ANMiweUSgzNr9QCWmLtlbKySCM9JlYklR+RKGiWl4aNihWd2H/436Ha6hSUyMXA6GdQPryOVkscSQUNtuCWwzQGlQnfy8u5Hu+7vD9bJziY+1NKtVz+WbHlf8iSYsszCq1efYqdPiMKEwtUVj0ucfFRG2nyUa4ByoIOxMav+O2kiwQg7WmUAvC/ew9fSgBu4Cczx6MbkBP/jeayX1YvDyI33ZAxOPnJXeBHR6kNCuJr/Mp+G4XQstRThyDqpNwfzXoZhR7mQuSQDpySk0Tz1muOaLIWQgCIh/bFjqIOUeO6C4tKtvKeFVOKBIggVWsMLlM8fi3SSJ58ydIiYbNVUICU4UlBGnTV2H1jObaW895/MEb4nDx/j2aK6A6xaN3GA4/4sTuMFRr4nWotDmCtyPlK1Il+olshgwxeJFzy9dj5SI+h+UzogUQe1aPnUtputvTCZ2MXU6BIFyVc3n0TshWCmU13UJEgj736FbhpgElt5q87umbDLvNmOxv8R6qoy1aOzbdFDoNmcdcCj2jn0uDNn+1xW0z6lczoQ3Ucp793IdmQmCCMFUCNRKNLgkQA2LZXJFzz5cqBfc6NHES+0UZiGUQrEfNj+kga6QRzjCFYW7JlibRT7p9aI+CELCF9S2hDJpuFLvmqwgGhPW3k+AyfobPPWozNlaqHpv03n4q10qGNHuDRPXp9jyu8FBaujsWfZEJNSYLXPalpr/RSTK0ytEbEZnWD0xC9G0J/qwIIv8xOPdaxrpp5byGHKpHRvaOjdyL+sqGYTD41jBMDMW8pd3mPHw0IVsJteqydlzqOewNHB6sWa4r6VEwaIbGgFPJoQhk7EfbvojKZo1PlJIh0BpdAFBQkHUCfcb5HwNzW0qlK/XfCGLKrPEJme8nMr7r4wD6hPnZT3SiaUbxZjx2100V1ldCNWp9Q7N8znPzJ+Vh6X60e9zVe0RudkwIdoEXscgdBdtRK4aCyX2NVz7RTJUTkbo6z3lSz/BeYXKbAvFdypzxshe2ewatQpwxhaE1MraU59p/cdKsLFdp30tjzqU8budehc7YQcex9ymX9qUY1PfToHfYjtUICNXnahdxeu0cnw1O+meF9/7/g+Ozxkk/PT3lH//jf8yXfumX/rIBOsC73vUufviHf5g/+Sf/JLdu3eLf/bt/x8c//nH+1t/6WwB88IMfpO97fvfv/t3pPbdu3eILvuAL+Mmf/MlfU5CeulSGRacIQa7pPK7QuJ+Z01yF+oQUXCZhSAi++5kes90gIIzBppSJg4WiEcRzt8NZ9CHW1nPrXxtc7kbebC/IsnKefBVRuhjEKZqD0ZYtil6jm0s31wyTkecdBYKmJQVQCrBZaO7TCwXHhiYx3Txstk6oCRE1B56iZ+x6u0Z6hf9FCYw0wRlfJ+K0cQGMnMBYkciaUXwkpWg1UhcCjaO72eNezJIbjMukCmJzsXczftz8dQ/1YwkSEs+0lIAzf1gkcVt5GhKfwfPb3/cX+D/99v+RN5ePuNcfcPShXe/ZsRaXnG983OTEtnHyRBKwaDGZkPLwfOL1SI0+Lsij403ckESUHFfpkb8IUjGRMafSecUAbvYyTB8O2ELx+B2CBs5egfpJqBzETpsx8Izn5UOgHCg3EXmJTUea37zF/4Lww+snch/FcUjuq2lIgk9bCEpTnUf7TDXuLn7cXKWVtRdXlPC9Tx0BmTWdvDZSmpSV0rzpJMC7+ROjO0K0MoxC5H4W6FYTGKYqjYmDj3pOuhvYhSe7tWG4mOHeumZRdaw3+zKvwpxPnVY9wZ0lJD0hYNtFDPupYvms4uCjLiS1QUC9lgETg0VnFOWZT2LX+rGi/FiW7qXpZO49+AqH3mr2P6ITPUhZmL4sz7C5Hs7PKnzuMTe3uG2O0p56umVzWaO0w3tNsylwnWFQwMZA5aD3kMXqTkiwtgr9YpU47pGe5vLwt0GCc2XFbSWOy8SJNeNaMEy8tKdH1pvy3LM9CsLhXNaldk90BZGXnJJUI0ma8JrBloZ8GZyCrsMwc6hOiauLVhSXBOAhINKBqtPPR3Qxjb+oWynC2N8R3EbthiZSHWRs9lO5lvxc010VgZ4+y6VyNB/YThzZhSFbB0BiY1B9jmkVw9SRbRTNVUe21tjSi6B3K6+N/RmectGZQnEGebJGhOaKJGPDxxayV+QioHVv7XCNGV195gPZWSZVjQJON/uQefRWo6616PNMxowi0TGzjdwAbwSIkDng0b3sTeW5FR9xRQJI+ol6mhsenEp8mItZ69N631fQ5fLBk4eRpqhSpde0UYvlAn1Phfk3VgDjOvJUeBmAkMUrVvjmWmFrnegvcV+sT8bgPZo+xGQ+8sHj3u6NQiOC01i1tmUEvsK6GE7CTSzeK6aTlvP7iyBU1yNKT0Di67HSWm0dy86gX61Rb9hiB83lGwzTBy6YR7idGIUEksUmTXHORW2MZ4xLAJRXiZoUD5dF/YUE7Kp/LfJdPnfsHr/uQfpf/It/kb/9t/82m82GL/mSL+FHfuRHfsXXf8/3fA9/6k/9Ke7cuUOWZWit+ft//+/zrne9C4CHDx9SFAUHBwdPve9X6vrUtu1Tlje7HaYE/REeWgwy8XDxFpeQKPdJSSpicB4FghEZ1EE0GEu9epAAop/B4iUSN9EWEYUfVxmbC5KhlH+aM5YpYufDp8p6sRUyjE4CYSFCSfBmizGgnd13nP4mHUq60rin2/Mc/IIEDd1CUOTo4tDuSYm1uSblcrzCtFE0RBLdKS/WiamMGZDkSPGJ9zItGHYM/pwO1xIWyWafhLDKM5HnEXmLyo/Wi3rwXPmfM1ymWN2WYKW88ClYLpay8e8iLzYPln1WeP/eyM97Lw60+4bzt2jaQ7Fts5WifqHgOz/8fyTRdqZyr5LAKm4UAQF3IYFq93Ra6KWd+3g9u2LTiKZGj/j4t7EMGsupanSzSeNVqFRjpUPOwZyO1ofzewM6UGre8G8HzNbSLXJpSx2CMD14nnyRiGUPP+LSfcoa+YzotmCLEECUmvyTNYcfFa769opme1U6T7pQ8o7otmqFOuCycQMcavncfL1jVxipYSGZ291N4mYCMo9wpC6axKZUyO/7icIWMsaVlzGcrwhiawkK47MQmoVK86m4gOa6o9vkZAVc+6c1j37bBHutRw9Z4tFur4pbj8uAbBQU+8BR72r5Pqk8eCa/IKXs+kmY54Xc03ZfaEfijiSNvoqHwp2N3VhtAdWZo9nX2FJq7dNPa7LNmPDHMdgcKoalwk48rpZukkMni9h02rJey03x61xoF15h6oFJ3ZFftTivuDiboLTHzhxmKZ7e/ZWB/CSjn4tfeaxSJQ64Ivmuq4HUxCX2nHCFjDNbe4rL0XLRtJJklOcShGo70l5Mu0MNDPzo5oqnOJcxP0w95bHCHoXupi1gVVo3R0qQ3BsXKDmRnlAsYXtlTExjslecxmCONJ+STqZ/ej0znVRZXe4lOYiVvl5RPcmlidqUYHEpyYOrB5zx5HUPF1NMEzrn9sFS9MCiByXrrQr3oQ33px0TRK/lussz6SqcEgwLQ+2xxxXaKnQbdA+TAfMoJ18FIOOJVCCUB//pOm4doxuQk89P67UTSn6ap1rhMpO44gmFDU3KYnIVbQizjTyDrnjamSXdfx0+f0d/NITPbBc6UWlEL6BTJSpWYSM4leDlXXTdBSpo+J64PkU+dqwWROekWNUG0jqahQqijH1Zs+snYU+p9OigVgh9b1K3WKuhsjz8b0pufMASq4MpsDZPf0d5AVd+3uJ+ugw8cekoalo4fz7j4JNDWAM11qtUGXj6WsfkOoFwkZse3dS8nKcPdM/oKLercXtNHZ8NlPv/X5H07/iO7+A7v/M7f8XX/NRP/RTveMc7APiWb/kWvvZrv5aXXnqJ7/zO7+SP//E/zo/8yI/8sh2avud7vof3v//9/PAP/zB3797lP/yH/8B73vMebt68megtn+n4lbo+fdd3fddnPOdIxUj+pS7wLhX4wrP46YrJYzdaIAHHv8Vj1oorPxe+N6LiQZSW3AIaQYBsaIwSg+bk2HDqksAIdrjoYZKNJykBUtY6VFB4R16ey6G4FI5vPISjLcFfdSqZ9/4nxgBOD06cO4JPqjhQOIpefs62in6hOPx5ePwVHas3WPxxyd7HNd0Cpo/CffhCuPbBwLWNriyM6GVsMCP8e59QuEhnMVaQb6+EX64txE6ciRaiSM8n0ihicqStR58Kknv2Vjj46LgACp1ovH+mHxexfC3q/qOfF5Ti8Zc4bjx3QmcNZzemXPnRUoSMOcnBJ9In4oYcudsxSRudJEZqT9bIJlJsXaKziIuOH8upEWUnLpaKfGkxocW9LTXtYZYWXdPJs+6DW4TyKjlZ2CK6cCiGygN6pEi4aPGJjJ1w7rOXxQVhpN+IaDhrJRGTREeup9r6JITUPUweOepjWN3WtPtyPvmSFGTEAKnbY3SNcCLQvMzA7Vlu/RsTeOhOHFhKNTrPhOpEPO9+Bus3OCb3dUjMZOzrPl5DzKAU1WlEuVVynmj3ZDeqn1hMI70MlBc7x9k9BT6nOZDXTu4r9n7SpPnqFdQnLq0RYk9Hah7klSSKtoxOLBJ818ckxGuopSI3eezGSkUlvHTpmDpSQ0RgGxK+3nPzxzTKubTRRjQ/dhrtbgdBYuHISktmLJtlxWpZMZm1eA8bX1FOerxX2F5z+WSK6oR+gQYGBVOLL5R08txq+lstWI16kDPM5DlWxzJOttfkGpLosvRkG3Hv6Y4kqXA52IlKTaOKy3HNHAKy3QfLUh+TDyvJzvqWrJnFuQiHm4Xw0H0m9JbiPDazcdi5J7swyYmkfixouuokkRhmkK0k6I99EIR+hVj4pfK/jNFUDQzzdlfINkzlu92gaK8PKONhm+Nycc0apkJXVINEUaoPor1OY09z3O2Oyd6WzcMZupGgPFvrlPTEseFzGQ+ql6A//m32RSecvrIvn6s9+qBjOmtYXtQcHa04OZ4z2duyfDjjaH9Nd1KnORkBqIATBI/xGBzLfSpPSE4i4HFaPbW268EL7cKNa06y4lUqWFwGMCaTQF3seOV7U4Ksx0petIyN63XSFA0SxG9uwORBrEg+jWCPgNfoRJPodtFKMuwL7cEosDRhHidBa2goJ+vb6KCSdF8uAC/xtQTdkJW5aJaGi3LGZLHFdzrpCuSejPtz6rga6Hg6UJy09Zi1fMcwkR4Sy88fUGTMXnWpcprokZCqFalyHfanlLDEikC0uw1jKlY64md87nhtH7/mIP3P/bk/xx/+w3/4V3zNs88+m/595coVrly5wlve8hY+//M/n2eeeYb3v//9vPOd7/wl79tut3zbt30b//yf/3N+7+/9vQC8/e1v50Mf+hDf/d3fzbvf/W5u3LhB13WcnZ09haY/fvyYL/3SL/2M5/Pe976Xb/zGb0w/X15e8swzzzz1mogO2cBLvPqfhXsWF5VofzS5p5k8DCM7DnalRPjpIbqTRAW5CvHDyDP2mHOfNtrd7mIREQISvcXjyVonFnzt2KHSdOLN7o1PXs0gpXZxWImWciOqLIinCHT6iUqLVDq8nPfhL0hgdvj+IpRXJeiO92CoFVc+FBcET97HBc9TLH0KSqModLcEFwMSCMKv89GpJFJclB9tJKN9WuRNRpcM3XuyrQRqk8dyr1zkzOcqbRxR3GNa2aTzNey96Ll4TppWXXv2CUp5zs/FaHp9W0kgYmFzXRC/2KEtXwEmUCfy6PTjkjixm6nRlcGPqGeyLxsiDzeg6TFgV+NYGCaa9sDQT3WizGhUcLCR8yovpQISO7MO9ViFWF+Tkm513KVFvN3PR8QkJLLKeuoTG7j+Ql8wkXuJnOPYUlqlJCJxsj1gxQtcWc/lG0zi+prGU1zG98lYtU7m1uShNLW58hM6TAxBwl0m4tLtVZJfe3UqAfjiJXEzeeXditmrPlGAYltym3zKZVON6Kkk4SPVRDlBwPDRMUUlOoXpPMMU/BksXraSWIe5tjsvo7NLDALwgZddyiYfA7xi6RMPWjckKhGMwZKsASSELaL2InobN1BJ0sa1IiKZxcpRXsDqzQo1sdBphlem9MbjpxYyx6To6Kzh8MqK5bpiOmlxTmGnGmvFGcQNEixiFfiMoRaUOHtUCJUlDzSMEtqjiEaG+Zh5bBZoEgG9doVne1OCdtPI67KNIMPZRtaWSEFK+pBM7kE/FVFt/UT+nUT7lypVMvOLsK5lMH3FJIAj0lvwAT3vCEGw/JyvRzAkJr7doaN8opNmwYfAMfbAsFVYOxYhCVmqUBXyVPdzbCXWi5NXQ3fVcy3djD9vC9pTFwNKebouY6jly9enE8oTOe9sSxoTPhMKYuw82l6zMB3IXy1hIuvPycMFqraohWUx37JtCpYXNX7QDFaTlQNtl3H1mTMutxVqJtUuwv7TB2OASHnc3IL8N19grcYOGv0fp6MdYAhAlZN7MXrwj9oS5cQieFc7FIGDYjk2HXJGo3aodBD2wxhwBg0MisR3T3TCQQTBERCLyHScnzGZF82I/G4ICfRuRS7OKVsIMJBsX4NlpCLu9SOV03TjuUlS7dJ8zFsS4GHesCbTnkXd0iwXYjUb9vEIQEhfBC9GDZ2nvPBPBcmxEWC2lYdz518rlLfiJPV5hoOP2fTaeO1yfZFTrxJQtas12l1vIo0VggHBa1U4+rnkIR2/5iA9Bt3/Sw4fNqlfrttS3/f0fY/WT9dgjDE4J9HDF3/xF5PnOe973/v4mq/5GkC8KX/+53+ev/7X//pn/NyyLD9jq9dYwttcFVePfO2D2EsGdGwNHDua6d4zOfb0tU5lQ4jIr0cF55bxgkm8t6EEG9DguAAZF2kNSAc2Nwa4MSjVQaymbUChXUClw6aeNWPTI9NGYec4MeOiJw4xmulDcaQwAdnP1z597highQA7D8HNY8XqjmJ2z9MchJKsHst4MctXwbnEmbFFedb71H1VDbJoxyMGWTQRXSYFbbGTZjzyrU9JBCiiLZ0Owh5bCoc6+lDHgDJLQlZBMmNX1+pUeKpPTubs7W/wTlFNO6qTivLS0c4FCVUuCFMRRMK0LgVV6dl7khNBpLbsBlyxLGoCQsNOxSc6vYgzjgTv/VQHykwI/gLKBoSqjgh+5y95SQ5LEQfpztPtQblUbK+XO1QjRrs/Q+KKAsmuMyZDkcMZx/tQSye+WDaNDZ92eZvKQH0i13z5rKY5VMxfks+sTkMnTy3BRz+RgO3iObmB+Rr6WoKhfg79wnHr34drDd7GppEk9c7/5JOoLvJzXa7QwbFBh2oQ4VlFX2AJ4IM4cQdp09YnHvJQC+Ip80Wxuq05+MQQnrts4HGTjXNMBapNvvFYPXrmR691adIiwt3Vbejf1VG8UNEeOaYvSzC3eClqMEaELN/EhYWUcPjQBTWW+WN1yBXSHr4I7i3bdYE2nsW0oeszzlcT+m2Gzh3eKZauQimPdxrvwTUZaI8+zykux8ZYm1sefWdD+7hG92L3FhMKFRJwNOit8J1tFUTsnaI4NdhSLBejF/4wherJOJ6rE7HrTJ1MPUkEHa1ElR0pE/0UuoNAfYmaBwftPikZLi7iuCEJXQlBsPIxcRvnUt4Lih19ySVRITUkE/qgvK88ERQ/ce8jV7gRekk/G9fOYeJxnQEFTa/lXneabNbjH1a4/R5bSdCvB9EAZZvA3b9UZGvY3PToRUfx8Zr2iqN6pMW5KvOYcsA9qVhpT1EM2MxjLw3rTYl9XOOs4klZg/HkFWyvQndomb5i2F7zzN98xvnDBapXzG8v6QbxS3eDJo8NeaI/eULcR652pEbGIDf2GthFpJUH044gQNaGhkWNp0tdMccxHhH9iACrnQShuFQpsI80v90gbpc+Ex214pobKUWSWQLeU16OAXoUlmfRUjfM9WwrTjb9ZBSIDrVU8HTvcJkO4lG53m6Tc3hlxeW2xBWOw4+Ne01E5tUgtLvqzNHNNJtr4XuMkgJBpEfudBGPQE62DWttbDqYjVqJp7uUquTC09eiKcrPZI9pDg2nvxkWn1SihbAet3MfP3e8No9fN076Bz7wAT7wgQ/wrne9i4ODA1588UX+0l/6S7zxjW98CkV/61vfynd913fx1V/91SwWC77sy76Mb/mWb6Gua+7evcu///f/nh/4gR/gb/yNvwHA3t4eX/u1X8s3fdM3cXR0xOHhId/8zd/M2972tl+RDvOZDllQA+oVEUY/LvoxQPEq+BT3CjvEBUkmkC2l7OqVGheYnda/0UcdRnQminJAAgXvR9pDCvz10/+Oh9eK9Y0Y4PgU0CknJfyYMOAV1Zk0Xcgan5KKYRIQ2FaSjfLSpVKl13EBiNcnC0C+8YJC5YJoxPJwvrbCkYt2jE4Et8ootJVAOzZtcZmUHaNwNrVCJwSP2ie+anU+UjDSwh3uuSCnBI6reHJn23DvTaBaZNIYJQYNyZUj3MvNLY896MF4Fh+s2BxWFB5mnyrRg6d+1GPzIjXRKC9Cc6t+p0yZrplEd4moSRQJp7/riKZH6kxIiMKC6zMRKLlQOYmoaRoDficwzaE5kuABL8GPbGpSbp+/4pKlYaTTCB9TQxaSjh3Ofmr8EgJXQnnUGfD1WGkZakk+InczCSdDwOpCV8HiksBBFwTdG0mwfCsUqb1PBC5tSBS9gtlDcTTIPykVgmI5SIB/YtOYilZqCUUfPHhPc5QJwhwmy1PUIjfOIeWDliMgbTbMBxfEYboXu86UZDvo5kZQrfC5ESUXXqggUfF8nurImUeNS4QJYVg4vNXMXoX5y4L4P/oSz/4nGZ91WBT6ilRNMp1DDwo9uDQekl919DpWkGcW6xTlR2u2dwb6UqgtxjjMrBPUvDWYTJqtWKtxXqHLgeaiEqen37rGfXLKMHP4wqNfnJL7EN+YcT5GTUQcPxI4qeRWIoGXVPkS3WfqqZ6EXgw1DAdhfoQ5rS2pOVW7J0Fr1gmtJgbkZqsYpsGSUI3rh1eCMvtM6DiHH214/FsqvCbZ0eldvroKjkEVwf6WEXRx47NUbkwa0rPvQOVj4mfD2l49lvfbStxkNiYXUXrpmF5Zs1lW2LMCCif0ojtb/CcmKehVTho/xXXRlR7fZri3rcg+PmOYCppvCot3ioPnz+gHw/JsQvaooGzBn05xC4edWiZHG3nGZzP6m+Iw0xy1uE3O9mcPUfsOCsfywRyz1+GOS/x8EAeQKIKOIEocxm4EmJJZQkCYU5+MZtdta+ykrHuPnwqgUzeek7dJ5cFWwu/f+8RoQRz3l2EijfC0HbVbXkV6algDGPcH+bfMcZnzpKoBSBIoJz3+TsTBknkq74XupOVn3UO2sdhC+PFDHddCHSqjo2PXjesXZMZyem8Pcs+93yEdeMtTRXkm11WfOGwAP6pzoc8N1digSDoH62D3OQrhE9gSkvQILior1szVuRv5+QExtyZWnhTdwoAXoejRz4ntc0yodqk4r5UjVWo/C9/zG+H4dQvS67rmn/2zf8a3f/u3s16vuXnzJl/5lV/JD/3QDz2Fan/sYx/j4uIi/fxDP/RDvPe97+WP/tE/yunpKXfv3uWv/JW/ktquAvzNv/k3ybKMr/mar0nNjL7/+7//1+yRnhC1gGb0mUotzKOACwJNITiOZBuHyyWLthERYETsog2i12MWnmgEXjh2SfjFGCC5sAgBKVseKoXL9I7fOAFZFKSunwSvZUVCopUHpyVxaJRh+nCgn2m66Y4LjZHuptVZsFgMi25E7SMVZ/LYJnX4+ZtCN9RqRKv1oIWLGxqtVOc2IeC77c9Ta+JQusTsxC+h/Bmbiew+m93kJLVPD57qyoHtJfhq92Vzju8bZqOdooviVQ0uIDTlsUI9ydFBqFadhOD3QHy6z99UhtK8fJ4I2kYO/TDRmGZEY6IHeHTdiE4FkZ4Sg9rzz1dJpCk8xBA0huA90n22hQp8+HAfMzn/oQr8/V7RT8ZAefpQNsPJE5uQ+lgdEa9elTYVIN2/sTLBU+ItQhIVn3XsPCvuOLKpnL9FU5wL3ahbCNJTLIXmYisV5klsxS4PJlvLRmQ24zjTndBXosNQ1kC7LydjC530FtnWJxQb9bSDks2jB7mU1ONzEIvOcW7K9amnmn6Ynfke+yXgBYXNNm5ErMK5xrkZ3SRsGRBuK24OOlSKsq1Ud7yPVS3F3gfFai9vJNE8/HkNuBAcxuegUtAxVIq+NmKNGlwn4jxK08SCyRxtn6GUp3m2p9xr6fuMquxFOAq41qALcSPpB0N7VqHrAZ05aDXrZxzq3gS3EPtF1YrdIfOB4pWSKByN1RYf5uowdRRnOok1baDKuMKj+hFl141KItEY2GfbQL/QYM0YEHoVNAj7I0VBueAeFLqrujwkRLWjPJbqnu4kOX/8W6o0lmMn0bjGRUHdUJF0EoTziQE8iP/65gY78ySsLZOgNSqg25cFXXWK7kAljnUUc8ZxsnkyRdUD5SND83yLusihzcWtJkd0UJH64mRsTu5r1s94WltRB6F183zPtO6oip7zywnTSYspLcP+wFA46IPGAOjaHDco9N0N+YsTXC7e+fvPn3PeL8guDINSMB8Y1hl6v2Mya3FmkUCXEeUOVKudwDyuHabxmEaS6WFqJOntR755/CzTjsG/V3Dl/y080DRXBxe0QPIlLgPfkfqDFEH0HxFlbyJwEKp8MDpD+ZDExbkU5v9Qy9qxez2xah41ZSjZVyN9UBXj2HYlOwEzST/jcoX9p1dh67kR5qcAXQIkKCdzefmM5urPdlJprnXqhaE8yTxA6HphrcuU0Hus0E3j+h2rgF5J08NipUaqaASLBgH/Imgh1sMeERRI7IIC1fG54zV+/LoF6W9729v4sR/7sf/q6yIFJh43btzgH/7Df/grvqeqKr73e7+X7/3e7/3/6hxtIf7lXkN1LhvyrtfvL0ZJXa0YKpNQpKyVBUIPPlkxxkA70lG0jVxwBEHZvXYlC0MUzJm17ARZ42n2Nd2eYnYv0FOCV60vBJm0w7hgDGUoJ5YjZSQ6W0SP1MmxpZuL96wzwkuPvti7vLZYhnSFopvpEEx56kek9ta2HK0bo8ex7gOykctCZ3oPfaB7xOAnovyR7qFGJJcdEVEsd+reJ3pMDOo3103ye9cWFp+29BMjTW4Ctba4DBu+k89FhwAzi+cg/xeHBUEUzr7Ace0DIzKpznYQo/CcnvxWz5UPCopy8bzBbMVRItuKiM9nI0/ZG3HoAPm+4y/U7H0y8jtVsiocuY9Pc/eHkODhxtJt5oP2wQoK3e3J688+TwXf6QyUWDBW5w6nQoCernlEmWKSGfsCPEVvCuO+vJAFvVh6jt+uRasQrmf2sty37TUV0Cd5oMkyzenwO5+e6+yVgOzMR6qVr3V6xqYN4lEXBFvZ6FEOO+X1xqFWUkXq5ppi7YTqM9dJmAxh3saEaTcxjOcbNtPk59+Pr6lOSZSGiL57rfCRvqSUULtyUINCRZGuj0GNfH5sT370IZlHIIFZ4q2HYCGWzaW50dj4SO3c2+jXLHabPt2TflVA5igmPcp4uocT1H7H5bKQZ5F7/KCxVuHaDF0OqMLh1xm2DOTkww63yQRF7DOKE0134NEPJbGwX7SCj8zSnE3JaCsNjwg2jKZRo6uT8eK+YiWY1r1mmMi6IW43YwCdkqgYVDTxGYgjSxRPmtAF02fgQxMf5RAKVj6uvVG4GAV8MYCLQj3lEWpjGa9DkpDY0bLbk0S/nxPGZgjKAoLeHQp9T7Wy6EQqDR7mn5YxvnqTld/1Gl8p8Zd/XAj3/Ghge7ejP64wa82wb6lfyWQN2cqahYHqQUZ3KNWD8qWC3hT0n7dCa8+2KVAv1+jCw9aEMe+hdAybDGUV7lzja1mT8lsbzl/awxdeEqdeY1uDmfTYJmNzWTFXkcrlhcaVR5H7eC/jOPcEo4LKpN/HBkIjIKTiFApVAy/VOhPmeTAGWD5jQuM+GQhSJZLg9PxNmtl9F7rghq6oSkn/hrDWJhAsOg9ZjwprWkwOJg/D+rdT9Y5IfxwTXnmK1KgvrsM+VYlicG5LJXuWH8GAmAAKcBCqneF7sq1n/qpnezUPlWSf7JmV8xCqfHFvcoV+av7HjsKxUh71Kf08XH9HOs9H7zCo59dc+79WCbwzrUuB/9mbDPk6nO/6tYekAynZ/NzxWfRJfy0eq9uK6VKy2XZPBRW6BB0m+KhG6gtA4ucFhAQC+huQyt3W9bte6rvBvu6RBTig51kITHRwO3n8u3ryewXzl5FOj+G7o4BVDyEgDsiabG5BoNcLD830T/NWs4DKmiA8ddNobxjpFyo5luwKcUzn2R4qskaCwMlj4cC7U7n+PnhO6x4un9EsXhnPK4rz2FlEbbCA2l4JgV2g1YgA1IkGwIxZvjeKvg4ITvic2X3L+obY4Z2/SXP2eQY1gItVkS7wVIcxyC6WY2lcENDRfUU852HxCU1fM/roBkGQDufd7ilc6cSiMKA4k4fRMxdQHhtKpMpDnyuO325YfEoW8MWL8nnNgUpe7TF4sKU4o+hBqDXRvUUHDrBVY9Cm+5EqJGi3BDw+B9XKYl6sZCzFI1KcIIrH5J5GkW+5dIljHZGcGJSawNW88rNeRJfhJko3WxL62c3knCaPxg0lckpN53G9Z6gM0WtYdyIenDxyKeh1OamrYAzIvRqFxTL+YagNURyobETSVULWk6vQ7qZZRupP9N0n0WFic7JYYo6b6lM8WxhFWSFAF0eOsVlKfO1Q65B4CwXAZUoSkpgopGTByz/9TkIQ5njkqkaaUbRVtUVIVmx8Xg59keEqR3+RQ+7xpYONJGyqcOjc4sLmjwKdOYpqQM1l7G51SVH3qLrHA/1qRnvFCf3h5UICn5+byfVb8IVPwUfsLhuFn8O1jnLRwkszsq2MWxSoXtaCKIrUVpJqF/5u2nGt1EGAHEWU5YWIH7dXGW35OkmOhkn4PLXjKuRBb4EqjPe5BL7rN1jmLwpXPFKTIj/dZ4FuE+g6UqkJYzkAF8NU1v9+Fl8ra514i8vri5Ug8O01iyqCsKhy5PdKEl/9sMMPmn6bw2zAzqD6dJnEtbaG9oolPzX437Riv27Ztjl9b8Sd51Et3WTvbgR8GFTYIzxu5snOM+zE4SqH2u+wrSE7y+ge12AguzT4zOMycSWxIC41jeHR7+zJHxb0tzv0SYHLPWSe/NSw90kJKk3rZRyE8RQpWMrJGhFpQ3qICDGp2VxytAprTFyXZvdl3Y37ULLjNUJDs5U09IuarmLjAqXOJxFpFI4mSlhI0OO4ylc7hg27SUR0jAlJfeTgu2A8YGR5T43UottLcgqKUzdWMRaaoYbjL+vQpwWzlxTTh0LhVNan+aKMgs6jPYyi8hEYkM9XyVUm7dExCXEiih5KRTvX5FuJWcoz4KenDBOfEvuh1qiCVJWvnwgV1u1oxF5Tx2fjtF6jl/6Lj9d1kF4fA0G4JI4SwbO5kEAn8s5NN/pFxwUbH8RmRjFko1gzNjtwwUs5Bugg79nlyUUrOOF1S+B4899IDXa3CY7XIrg0W0c/M8n2TDm4eE4zTKWDYnXmqBqXHCyiaNJrkltI9HHepT8k3nQ2UgGcFvqHK0BtQuA5U6xuRdspAiVnF6H2qRQJIejZKeN7De1EJ2SjDzQZNYhl3faKpjoVcY0aZEExWwdGgfVgFOfPiyXh6rbGtBLc5jsdP7uZBA39Qv62y5ONgVkMymzokJc1QbyVQ3mhEqcvBniXz2r+y5//XnKV8Yn/bsVXf9+3SLmWHdtNFzjEoTFWtoWDj/mRiqFGYaPuSUhGN1dsbjmaN/Yc/seS1R1F/Wi8lzCKX0WoJNx9dSZoyua64toHXXIHif7rqSIRnm2+Hp2KovNI5OnbQpGvRs/7iALHEmxstjRqD6BYOrq5OB15LdoA5UUgDeBXoIKDT3TpKZZSrYpuHtFVJm6ofT3+bCK9yey6Ju2UzDV08zCWQ8KrBw/DDjLrPcdfpCiPFfNX5N4IRUWlQC3eX+HDqtTHYKgDhSnV+MfNO752d5FPVLWQ6BShPWVzoH8pZeAzIMfy5rE83U4DkriRc5bAMaD1Yd7aUmFLgzvsyKoBZzV54CzbQeP6gPK2ITvYaqFNORhCvqXPMzTQxM678wGlPb5yoKG9aqkeG7p98WGvrmx5w/4FL754g/JhJoFqGEu6U3irsJ+Yk1lwb13Di1MJ0LXn9O2O2Uua1V1HfhGE2aHBWmw05jKxSAWZv1E7MEwkKNbRS76S7yyWJCvBKGwd6hBch2BIt6P/t63GwHwXQEjV0TUJ7R9qCd7VEGwfz1SqIkYur1cwzB26VZSn8vdhIqJPpcBkFvvylP5GR/VSQb4UC17Va/JHhv5Oiz4taJ/paLcGs5UmR1QO5QzDvQmnZgLzIa1h5rDD6gK7zbF7wnsn81BJ5Gw7hd/rRVD9sMRPHfaa2HSqVgsItdFkTrQCZmlwMwu5R2WO4ZlG1sC5WEwW8442L3lyHdTWYBqFnUnQyXSAZYbZKOpH0fEqVClt3OxGY4JI4YMdOmBcc8IziU2RXCGuK7qLCf8olkwBepjHo8CTtG8rN1rUil6IkWJiA6Ie+euxC/BA6PIrCXi9cTz+LRl7L8ZmcWNC4HajJ6Ugk/PJ1572Ky/xT6aoGw3deZ2si72KiQFka5eAAazH53I+0TIxAlvRG13t3BsCMOByiQ3yjce0Dltq5q+M63QE6CL1Bw/TB7L4LO8q9j70GyRSfR0fr+sg3RkBtYtl5NUK39eHTFw6gkrpMi4wzYESJ4uwuMQMV4J5ZPIFPmra3wOFxqtxgptuDJoiNUVeLN9VruxTC1rckOPfI49771OObhY4dCoiBjY5eMQgcnukKJaKYu3S9cfvjAui7j06UntKRb4SzrG8RnjSlVV0C1kgsg2pxXN1RqDvjCXEWF7TwfEl80FQp8XruzgnUSGywLOPTjSjv6weBXrei890WKTbfbme8d4Ff+8+2hqGQHgxonOxYYoNQZ2ysJmrJEhd39JM7zvy7Yguv/O//1kGLP+HF7+Sf/r8j/Lmr3yBx3/3uYQOxc3IG8UwUckL12uVFkmvRwebSClSTjpyVv9ZAQXtQlAQHwILAloylCrZneXBS9eWQn2JgWLkU8fAWkePYD+OtRRMDaMYq0vXbtL7o/grWiHef7elfjXn8MMu0QaaQ83mOvhM0S8CL7kbkav4PEQYK9fb7uvgyBITR/BGUx8L5UJbxLN/GR+olH0JYltB78WmUneSPKcNN3Qq3NVdKK84+DBUZ8LV99mYmMX7JhoOUlKTh0S2m48BdnxdtBiMnYInj0Jlo/WJVxpt31CKNthkEpIl5UfKgKDlLmkIvA6Wl2F6FksSsjfsdPZ96vpC0yxWGdmso2lyBg95NTB0hnLWBV90g8ktXZbDoMmnPXk+MKs6HnUHLK6tWD6aCWQ46PH5WYVa9Kgba9SLc6gsHjhZT6kOt6hDOaH+/gSzlYSgup9L8DWAf2EqwV4tHue6g9WzTjy+M5Kt3zAZg/HmiBRMNNcF4SiPAx0rrKPJpSX0Q7C1zBcVhONxTYnP2BvhmOcrk55PrLSxI4CNLlpmK2M2OssMU6H1CA1B8IL2DZ10E7WKbCnBaT8PDi1vWNGcCS9+IMNknvKVAq9D99DLAleGcbQ1uMWAdwpVOYbSMTnYim3j8QJsqGTOPSrzqJMCuwCfBV3O3oDqRShQvlTS3O7xtUMNGg8Mh5J0sTZQW1QjdpP99RadOZQCbRyZ8swmLZumoGsynDWoQaOqnu64RhVhYE4HbKGhl4TOtwY1s2Q3NqyuFZjSopRnOKkwhy3+vpQFqyeSlKVKcKA9JkFuWLci3x3k+Tb74/qgXNxbdwL0UA2O5gt+nCpExzMQ9y0dtC9RI0J4f+TOxyq4LWB9Q1NcynrQ73lWt6UHQLZ1wS+e0Z420ll9XIc967Ma1Wqm1xvatw9ctnMWLwW73thFGkawQI9J327vjKh32V2DxvVih9pnYLRkDAF8Iba2pnEpFnG5gCX9TPqe7Oq+XjNHSEg+d8jxug7STS8Wgd1CNpChkrJ0Vyua//4S5zSLH56N1AkvQZUEOLGcPnpxR/FlDASiyCrSTrweJ9tTVBg9vh9ksvV6RJxtGSYaI5oWs2iQJGPXWWa3BXsM7pQ3lBfCoUWP3D0gobNDNTZKiZ7okX+6/4lehCxqbGgU3TIA8o0IbpoDcZNp97LEKVeDTmW6fib3evJEPtt0ns1VLc4a1lOsoivHjtg2tWEf3UbEoUYQgvVtOe/ZffF/F6SL5B6Al8ZOUQToMgnc842iPQrNTtYkdKSfKVyu07P6sZ98Gz/5v/3P/NPnf5T/aWv48E++kateFtxs48YSLj4F9oIShQA9lFSz7Y747zMgqfVJ9CYn0UikIhMW90YSF0m8fOJbup2xKI40/inUOXrYuzxYLypJNrMmBI7dGMgnruQwUkT2fy5n+WywVQuWjTp0/XSZeEQTgvFoWSfUCsWQKkuAG5O4IfhPl+c+aSWEdqYZJvqpexWv4fjtiuJcyt9OQ74Faz2uFsFoopKNeahUhXYtzdzO3AtAnwk2qF4Lmt/ukYKCRE3pwU7kXsXxFZ+zy4OVoBmDjjhGo8jx4s1i1We6UMnxivJMkgDTkMZ85NWqHbs/08ZqHthapURT9w5lNabRNOtCAr4KXO7QxmMHTZY5uk4zrHJU7lC5xQ4aYzSPnyxQDpbnEygj90dR3VyjtcNoTz8Yinxg9puOuVjXtMsSP1XkucU5RbcqYW/AHjqU9qgX6pSoRZ/yPvfoVsSkulWYrUpcYkKlK1/D5obHTkLC1mpcLo3jIn+8DEi2zzxmE8TDYZ7H9dMWpHscg+roIENA5PGglxGMGBF46UZLQs9jEztXeMpTxeYNA/lpJpWwBwX9wuJnA/qsYJh6bOnRhy3tqqTca6Ui4RTsQTMtmX4qFzvJBZTHwZL0TT1ZYbG9IS8Guiaj/8SCYWHRBVRPFNsbDpY5vnAor1CrDHLJLlXupRHVvGd4S4t5UOOvCt+sqHuGXhx93ES0C3biBE0fAh992tNvcmg1Z62Ij5XxFEVHRwFnBfn1LXk+sLmsRKg6FExvrdicTVCtRq8M3UUmVTktFB402DajuruiLHourkzZrDNB+zuN6jReO9Six/cGBoVqQ9+PrSa/1DTXrAhKgwjZFw6z1qhBkW2kh0W+8ug1yWUsNSb0QHQV8yKwnDySfXIXRElGCX7cD/ONp7xw6Xc3/qOst+1CpfnoisDVjwl4EHvG/Vqf58xeVtT/eZ/2zQr9znP8l0sJ53JbohRM//mC0/9uQ1EMtE3B7f8hT8Fpc2Aoli5QIsfqbqThgvwu2wriHx2lUqIRqoWpIhHGOMDDL8lwucdWLv3uc8dr93hdB+k+BEG6I/Fr+6kEL5P/cZ44ri4jdbEUsRepGyVA5nxqchKDkLixup2Jteu5DqRmNS4TT2flIN+4kccZyvPCPZZAKNu6sdyOBDVuNirWo/Wd7n24Fi/Ih4qIpmThcXFxOWBjcCb3JQb/Q61SRaBYmYRASkYfvbRJCEa29cyamNozLpZhIYgLZkT9+8CNn92Xa+73JMDXiEXlrqtNRBOi9VT0gx0qxfTh6B2rB0FolYOhkE3ZK+gWsmiZVsrYMWjMN3JfXA5uSnCdEO/8/Rcs2dZx+8c13/Dq16F/+xnV/22fK4Og7DoIc2OSk5oW9R4TwWClUK0gprZUicMsHF6VqAyJ17wToHs1ClEhBBR+5CPGqkzWjLSQyFuPnHIICEtItsq1G+kqMx3uiac8t7T7hqFWYsspJ5/ceq79tDzziI7PXu3JtplUQYKAq5+G1wfUM5aeQb5jc03cc/BjE5fYlCmK1STp9fSTkS4G8vyHmWO4Yak/IahkferDs4V8LfSUNKfymEAGYXZIELLGpwrBLs0rUrTafQVakrYUvEfR4TJ0ZqzlHrcL4SDHsr2GpCeI/Ov2aBz/PvP0IUn2WXCDCbaDcfwQYuXoRiHJozzHmHTqQYnQMZfk1h52mNxhK0s1b2lWJbQaSks/aIp5R75o2Nyf4YIwt7VKOC8RIbWKfCYIu3Wazf0Z5rDj6sGSi02VtN7T/S239i54sp5xcT6RTqdAflwkzjx2HMdeAcbjqlClzD2+V9JJc8LYKGYizxClR+4/pGZUiVK2DuOykoRC95IM2IrEZ7chEC7OQhI1EerMMGHk8c5IXuz5JfhcfheRyVgx0QOYjayD2VmW7AH7AyvB8dbQHgnNxBy1uCcl+kgaRrnOsL+/oekyutzTHgplpjwVMKebgVvl+H3HdNpweTbB9xpKj95qqich6RsUfmKhdJjjTJLFRsbpsD9gLPjLHJtncNDDeSFBe2/Ic0tZ9Jw/XGAmPRyXQlGyCtUr7CZjdmXD+uEMdVLg9gZoFb4KliYe+rOSvsooZ+Isc/mkYnNRQ+ZQexbbGWGOOFAailmHnnvKomfbFnR9htKeq8+e0vQZbZ8xdCLgspscbxXlQcPQGbzV2FphrwBL4dabpZE1E+HdM7MMNy2t8rjWoBpDttKUZ5LspbHTkCqt4xgSkK2fCKDRLRTTB0Jqi6YBUVeEBwJS7hT0c0U/M/RzaK6FADr3IpAeFGpQ7H1cM31gufGfBJRTDg4+6nGf3OP8OUXzXIe6zPCZpyoUt/5xCZTBalHW1u2h4fwtir0XpDGd260KBfBAOR/WXUMb980+rj07AE1wrIuuXHi4+jOy357+Jp1AiNfc8dlIHn6DJCiv7yBdk4LQiGjFsrfuRlTL5YKwFSs/osyRIujHCa2tR1u1g659hnJUFLkE5IZU6gtAllEJxewnv7Srmi1Nypa9EtTeNFINiA4EkQMdO60pG1q2E7LuIvCkTaSkQEKpvcdrnQSnehj5zbFdfaSiSJCv0uIgFYQdz/chdBLtxZEj2zrm9wJi78QIpp9I4B4RZOXEm1YgTpWeU0xS4vfr4C4xlJJMlBc+Pcf6xCdkNNuMiYbZyHuiGCyiZmZLsNgMiZsRZwmUot03ZI1n71MO98qeBADT4D0fy5yo1PhD9yHwDHQfaSs9csmjoFBe6xNdSq5L7nFMqrSNnHDGgFuPdCKbB6efMM5iydVlo8DI5U835OjyGBTrhGbGCkhEjrvZCGHrwbP3omV7ZFBubFltWrmGiKBLMw7Ih6erBTEIVk54vUIJkr9na9lU4zgUq7PoDxzGVBFsyRyUJwbzqknt5ZMzxBe1TH++pLwMY9mPrjDxPIX+FETJAQWPtBPUzphcg+0FTUsWb9vRKi5f+0RzKnwQogb9hDMjRWi3CpA1gTIRxJO2FlcSl3v6fY/ZjB0b46EGQeyjAC/RaLyMYwDK0EV32qONw3toVgXKONTM4jqxXeybLC0Y5V5Lex6CbuPwvUYZRz7rMcaxOa9RuaO6scE5xabLcV5xe37BRVkxzTv2i4bHqxmuEb6g2Wj6uRM3kdxTnuqU2AxzCTjdxGH2OpTy9J2h/HSZ1kUdeMcuh+qxotsP/PNOM9TBmm4b1udQpdG9So4skcueRL+r0OG0lr8X52H9asKzCbaHAP1c1jhlx3OI+0C2GQN1SSLCffdQHJuwpnv0c2uGzmCXuVCbnlQMB6ITWDeFcMPPM8oToRC6XLzgu32PajT9aUV+fYCNoNEoT7aWhnn9npdGShcZzTVLvoZh5vEluNqheo3qFPZwIJsM2IsCZkOgsniMcZw/mmNWBnVuRPRbWcxFJuO/ydhs5uiIJDcGKpv0DNmNLd1FSf6ooD/PaQ96fCVOQkNnhFplPG7QZI8LWZdOMrqJoz9qseelRNfTgccvHaIbjbresLfYsFxXVIcbMmPp+gxrNKwNXntMMVDcbGm3ObeefYJWntJI5KmV57KtWJQNH3vxFsx7Dp6/5OR8xnqVk51m0iV27vE5ZCtJhtd3pCFUe3OQZLiX9WZ9RyURq6093nhxbHJiFqBbjZ0PmLolyy1ZZlFNgQ0OOnHt1r1i9QxcvlkxeVUzf9UlMMD00hOBT2Rh71f009FRzbTBgtIoygvH3gtaGqI1DpWPlrrSVVn6YAxTQ7aR6nMEelwmyHvUoulhtEDe5dDHOTfUr0W+y+eO3eN1HaTnG/Fo7vZU4nnbAqqzQGmpFKpzmCZ6lguqFTukqRAtuxRMBvFaNnKiIZS/om1aplIQFOkeziiKtWcoQOWR5x4oDIFnhhe3g3zjx7KWHwOCaInm8tEpwQO2FqpJsZbM3wUKg2Lk3kfuaxKyWi8UGkZ/agmIIIpt8o2HIGyNpT8Rj8k9HarRtksP0nkxQxatbCte8zoI45QfLTClQZROgVUM+qNVogeytcWWmQRRgeLQHI4e5bFtdXRwkIckr4ORy4qSIF+FnKCdyQZtOtheh6wRm6/I494VNUUBqlBoAjc6oBdR1NNPJRCzwcVHBD8j7QbvU3CIG89dqjo7PBhI30lAHsXKMLSptqO4KIpiE03Dk5pl+BBcomOzLTnRvI0+31GsOIpIU1OvQD2KnNCYMSXuYEwqwrgfKklqh1oFsZbHNCqNzX4OzXWPrVUq6RZnJFvN1R3DxZtlTJVnQmGqH4d+BlOesjq98W9yUrOfSGcJZe04d07erukXlqs/pYPNZEiACrmHQ2mIbctNS+pkKxzop+kyKlS5XGh2FQVlaocGF8+jWIV1wEtQGZtP2Sp0zwwWaFFs55UEl5GGZEvoJuOmagLyrjsJNLs96C5KdCUiv7wWAelk0tJkOc5qvPf05yXKQ7cpUCGAmx9suby3oNhrqcqe5WVNMe8w2tG1OWXVMa9alpc1H390jSyzbMqCs+1EOg7nHiy4/QHzJEcNQulxOdIQKZM540vHnWdOOF5OUcCk7ljt5+QXmn4RnmOwTOwOHGgv1I5WY7Y6dUEFUtJvtiRnmDgOhzrYV9bjWhgPV45zw6xg/YwnXyqy1ejrHbUSQx2SNROS2HKsOuoOtjct2cpIst8rhk9PsYeDzCvjsbVFeUVd9axeWsg5atjcseQXRignncIddaBEQ9A2BUws+ly2ZOl26VM3U9PB9GUj1YDQKEoNCrTHzh1qUNjOjJURQAe60pVbF5xfTrDbDLXKyB7n9IcDk8Mt22VFVvXY3uCtkqSt03jt0ZXFeyj2WjpKoUspLxWaRuBl7xR2m5HPOiZv2dD1GcOgUZ2hLHuGK45uk2MeFZLk71nUoLi4nGDPCrrcowqHKSxF2aOu9mzOJrjzgtaVsN/x6otXoXLsH62osgGjHUY71n3B7TsnnK1rzpYT7DonP8vwJgSzdzYMnaE3OUwtbAz9kWPv2or9yZZ7x/uC5F8ToYgH/EWB6hS+cvjSonPHdNqyXpdkucV7xWZZYQrL5GDLMBjqKmg/nGJadjy+d8DmtqKfS6Llckm09j4dOY4yzla3hbIj41rJvhX2jvrE8cr/bmD6MEsVaTV4rI6URYUafKrwxwRVWQGtYifpaAcpII1UJ6O2I19LFfS1eHw2OOm/UXjvr+sgPaqnCRtiDFri5pxtXRJ1FJfBHrCUboWsSWLLGChrOzZYiNzIWJ6KlnI2V0GJ7VPwLl0F/VPnFTuTxq5msctYFJxFhTgqdj8jobJuRuLlulzsACO1xLQijItHFLWW5xEVhkhFMY0Pdn+KrLXEzqD9RPyoi5VDt07QYiVq+qSYV2PQ7IK9VT/ViaYTr3cI9pNDJfxcCWqCE8BO6+MofvFG0e0ZbC6NUKItZrSXM7GzYODTeyeNnbKG4F0f0WXxuS/Pg1+zl8+JiH5xIZ/ngtVgvnboQQLYWGkwoYzo9CjslOZFwTbPCb+9WPoU3A6l3M92H+oTkq2W6ULwGoSn4wMavydSUyJXdojBaqIFSRUkcpuVh76SMZuvJdGKPHcXEgtnfGo25JWCHJTTySPZdC5x1KN7gGmcdBicSLMRZWMzphGhVm5MbIuVJFnVEzmP4kLRbWF7TahmuhN0c/rQB8qZprjwIjTrpaueHhDrTj3y2ZPoyzP6s3sZK8mpKSSWrvAU51I37mcKHWzrnIHhUAt32SlsoEQoLwlBvpJ7bAuhuikHSockPiQDKmhKostRvP5sI/c7CsTbK9IoyGxFbNvPAa+wE4fuFJNXFUQLOE8SSMaKRwxQlZdnDxLsl/sN3ZMal3vUvMP2WoSgCNIbg7r69ortRYXKHG6Vs1IIauoUF49nqMbQzTT6PMdlnuYQHjYFd2+ccO90n+15zcZOyOZdCOgUKndgNXZu8cZTPszpnmnJHpYMexaMZ+/qCus0VxcrnlzO2DY5fq9HnZfpmryB7k4HvUZNBjgvhLvuImUrXH+wGbVloBwdefJL6USqBuGP20q6d+rQyGj91o7pRwtUIejqtlLkl2rUffiRnpUF1yVtobki97i72pOdZeIHPx/IHonKtd8L4sWZxZQDJncUxcBgNc1ZxWZT4vd6zHEhyPwyOP30CnejxXcGlXm8B20cQy9uOaoX73mXi+bAVp5sq2muiL+5aRXZJgAAlVRi+qs9amuor63p2hzvoVsXlPOW5brCDRpTWfx5LsGc8WyfTCD3mMzRLwuy6YAN5ThtHGXdY63GDprJ0YbNaQ1KU0w66qrj/PGcLLP0CoYm53JdMDnYUFeW5SZnu5JqidKe8k2XWKeZ5AOZcQxWY+uOZisdA90gCfO07PH7W4qrAxenUyazlr1rF3ivOF1NOH+8h+5k/3KVg9JSzDu09uxdX7Js9iRhMR73uCZba/IlbO560Uy0muVFTZUP7M23LK6cce90n/68SNQsP3GoTGIB1xouN1OUhu68EORce+xM0e2oVF3498n5jGKvJTuyYwJ0VrGZQHNdk91e051KN9zykeb0rRmuCOtMF7pbe1hfU2Rlg9dhUUHWsawNMQlBI9SMgEu0l718VnPl5x3ekdzWhOpHAjJAgvS4H3/ueO0er+sgfXuoyAIqtb0OkweyEbtcYd0YxEsmK0Gr7j06BI+xkdFQj4LEiLLvorXxSOWnwA13hqdQvSjCHH2UQ+CsdgJbFdFvhe7dSKkIqKDuXHIYiUhtF1w+fAi+69NYASChp8XKBUcPCSbXN5HNIJR4t1ez5GqhLNTH0kzGz0bUOzpceBXOL3m9klrVSxfLHZ/2KC6NyKUJ5TyjMNFOUEM/MxII9p5843C5oTyXALafqtRUqTx3iX/ngohyqHXq0qosaC+6q4iyR5Q40TMKWdTKc0nEQFrER31CQjlDW3btEb71MtKTJPjuFkI56uaKZl+lRdJWkozogdEPOPKehx3EL/rhB/egKEKMiWVxMXYDVcNY5hxCF1nThoQqFwqQshJcbo8kadsdlz6gfUJNCs2RdjzAQShHQk8YuyvGTqteSfLqQqOp+sSnYDnRdgqwwyhu8llwbClgdm/08o/PJCa7+VYaLm3e0oH26NzRP6pYfDo4KinQfqz09FOdegWAIEnliRr92wPFLDofqQFcSHLFf1zOoepHnny2kQQ7bnBDHQJoeEowpnYSlWgThwvexSea5po8R9MIhxWkHI+XcTHMRmqaGuSZmBYpzWuhXZhgW6hbeRbdSU12JNmp7cQBikGEdjgFmUfnlnYrdAxvNeRCUdCFoINmMuByRz1vcfOWWd1y8tIB+89c8GQ1o6466XCpHYf1hvsXe2xOSjiweOehNwHogMnHSzY3HdfunlLlPXtFwy/cu0lWDHTbHH+Zg4fmVi+uIctMKCdLQUHV4xIzyFjyeNRKnlM/E/Tb2RE51K2i33MJwTdb4au7Qhxlhpk4q6zvWur70nSnOg32ikaS+m4/DEgtVTxXOdQ1GSz2Mpcujkaek1oW2Dds8U7hvYJVBtpT1j3NvRn9bKDeaygWHXk+0JuM+s0b1p/YT1QKP7No48kmA0XZs12W6POcbFDYo57ssMfenwjyPA90ixIR1U4t3maSwFiF7gLItDbktzZYpzG5ZegMphpoVyVYBRuD2+vwhx3qIieb9OR7lmEwtBcVqnByra2GA0H4m8sStcrwuac5LlEzSzERDuXF8Yx6v2F7XlPMpRJzeTzDe8XyoqJatCIYfWUPFGx6jVpm9IFCEvc5Pe9EONsVtOtChK7GseoqsmpgGAwPPn0Eg6K+uWZyc0Vd9tyaXbIZcnpnON/UDFZLc6fDFrfO0bMev8kYMs9wzWLOc/zVlvliS55Ztl3OZltwuaooioHqek9d9JyczzCZxRhHkQ8M1tD3htmkpeky6rJnWnS88uBQGkZpz3KoUcaTFZb5fMu2LcRtRjsWs4ZsseF8VafPmNy+xFrNelJCaWnPKvGuNyR6jdcO9bDm0W8VS05XeIoLHZoGyj4wfQCTRzaBSRBBClI8EdfoSJmLIlevQ7O6XaeZ19LxGj2t/zWO13WQvnxrz8ELFd2+DPzNdZX8q6fr6JAxWkPttgiPXcK8kcBzmAS3AbODgtkx2NAdbG7C/idG7/SskQA/a3YC78EHzhmABEDdXAdu8zjJhlqR20D3CBQJ5XyiqqSgXylaI+t0eyQZe7EcAy9biC/x/GVx1GgO5f8yuSVwyFekn4d6RPTitcbSWmoF7SUAk+SBHV6+ojmUzH7yWJDZaKU11Dp1f7RlxlCOwVm+9hx/oQ6oMomSMNQwTBWmgel9uc/NoREqgpGNzQSUrp+FSkII0LJ2PH8JflVqXBXR+8gBTD67g5xTN9XS/INxMSwu5GdBtuVeDBP5r37iKTpxVOmnCO3GB46rD91KA4deEHq5764TtD+JddUYxLZzoW3o4Bxky1E4anOhD3mtmD2wwb5TEhTnonuBT9z4eB3R0zzy6Eftgbx2mOpEjcq2IlxqF2ZMRP14DbYA3Y3l29S2Otx/3SkOfw5pChQoV7FSQkiguplKHTttqdClxfWGqu5odJl6E0QqUgzqlZdEZiiFKqAtVCdyXVkQ4kbkPTUri2h4Loh6tvH00zDeAkoVrSu72aj3iAF6bPIiVQnwIaB3Rp55TODzVehF0Mta080DopULJSPSnuI5RSGkDmOwfhysKwsZI7YSSsRwUYrwrNP43KOmlqwUkYXJLN1JjdpoaQI6dRLElwqLIZv1YtO3zCWY6jRchxvPnbDtM6Zlx7otWK2Eh3s+m1CWPeb6Ftsb7tw5YdWWNG1OcXfg8mxKMek4X9XcOOj52ONrZMVAXfYoYNsYdGVRpwVm3jF4IA9uGp3h4LkzvFecnU7JXq3S2uJKT+8VupAAftizZJea8okm28p9aa868ktBmZPjSwnVY8P2hsM0iu0NnzqUCoVFKg0ETr3LPWyz1JySRqfxMUwcvs2gD84eE0sx7XBeUd9ZkhnH5ZmU+CJn++LJDJ173FS44Pn9HJfl2NsNNtfo3OH2BvJJD04JGv/MCvvJuaDFyjPMPLrVZKcGW3qa6w43CfLuTMS4QxBwOqvQmRNe+cZQPhY0wl9UDDMnyHuTSUJ3XoxWiqXDl2LLyGkBhdCOzKLHWSUi2Dbn2t6Sl1dXGAaNLiXx2p9t2c46inxgS5kCXHPQYTJLnlvyq5bz0yl5NYjF5LIkK8VtCCtVGXtZ4FotlRbtMXWPnvVpjTHac7mqWa4rrNVc3V9xfb4k047H6xln51Ji8laRTQecVdy4esHZYsL2rOJyuRBaUifJyHyx5Wi6RitPM+RcO7zk+GJG2+R0rfCl9hYbNk2BDv6o2y7n8Ggl1Jfw+zyzbJuCiydzvIfJgSRyF5cTJpOWoTdcLGvKsqftMryX+2md4rk3n7DqSpxXrBr5/2ZVCi0tc1TGMlhDfkfoR22bYy8LbJVx+awRIXDmU9XMbODRkfQRMVvZv2MTvtUzktzn6zAvPv05Tvpr/XhdB+mHP5PT3xwzU+mCKAHgo3dorn3QpYA8Bkmbq4bq1BF9TcXiSCdnjtioJXUpRTZZm8PBR6VLWnSIUS4IJ8PRT4JTyESTr0e0Idt6Lp/RlJfik+0qnQKpyLuMHPWh1sSGCEJTkRNXSJBgyxCgBI62HqB+JBWEvpbfO0OwFIscZuj2PK70uP2e6YfLYNVI4JCHkrSKlYLQQbWKlBzpwmZaLwF/Ki+r0XM2IptBEBnFfNJmWjF5QEoeIjrfLRR7L8p9SoJVHz+L1OY9H4JlYSbUF3Sg4ugx4YARzY4BWLfQqBCY52vhzA+1orkCzVVJRPILKZ0rKwF1rJZkjac6ESFRP1P4jfCwdSdjJHKzd0WaMPJo83Wkpoy6gJgwQCjNb33oRPr0/R/dUkiOOrEs+vR3jWNYWXGkcbmin+mEkJvgPy6uN9FucvyM6syl4DhZ4aWAOySDfhQf2wrYCqptQoLZT1TSC4gV3iiYbQ60uLxY2P/3dah2FNRWKEix+2scQ0IfkwvNNorqbDyXyB/X1ifRqcvBF5H6EkSgQfwaq2ESyAfKT+8xXayuQHEpiUC2DVUxH8eQTw1EygtPt69wE/n+2FnV5VA/kflWXJLEv9H2FGSst4djYmpDG/tsI+/L1oru0FEebem2giDa1gglR3v6xqC0o762ZhgM/TpwpWqPvhCUdNhk4pd90OKWBUyF1/7w0b7MXw+6ECFqFMo1mwI3aBYHG+4/2cedlpijluaiEtcP7WkvS166vIqpB/b3NgxWo7Vjcril7w3DXo+zGqU9Vd3RvrhA32zQeC42Fd5qhqmUt8pT8EYGST+T8aA6Jbx+Leu2N0Il6ReiI3FFuI9eEi6Ul0pPLcGPHzRmo8UasgsuHoVD73W4iwJKJ4kPgv7aqZcAr1dQi5Wg7zXdown6sKU7LvHzAbWShmt2Zmlbg8oc+uqAPy2CKYA43eiHJX6ooPKoq+IIY1vDuslgleGPeuH9Nxo1HaimLW1ToI3DPq7RpSDy3oGpHf1ZCb2G6cDQGvTa4GtH+2xo4LGW520nDtUY1MbgqiAeDlaKyoGtnczHWpDza/tL7j/ZZ7UucVbz8itXhEYY6C1KQWcFAS+MZe9gLY4uyjOZtLR9xmZVstjbsNjfMCl6Oms4XRd0a1nsdTngBk11JB7xSnmM9uSZJZs0XG4qtPZUuQS5ZTGwWlY8Ol7wcHUkc3tQ+KlMHD9ohlaqDetFwf5UPne7LCkmPZNaFvnlquLylQW+EG78tWsXGOPIMkvXZZRlz2pbSiIR1NB9n7E/2+AUlEUv1YPLmqIaKBatWJ8aJ/qEs4KVVRwerjg7m6IUWKcoMot1CqXglbN94bRbTVXKnNjb33D2YIHNHbYUB53J0YpZ2XLKhHauGAqHqQbm04b1pmRoM/xG7BXFUSmI9YPVoho0TAbUec4wk3mzumbhf+C1dYQ157PyPb8Bjtd1kN7sQxYCV+mQBgRKweQR3P+dnsOfNSnAybae1TNi0TcKNSSAMS4EwAFJi3QFG9BJ5UcHiYgYoyLSq1KAOHJRoxBQkFpXCgKKGruI9RMRvSXebfDmloBFuGvNoSZ6AE8fCIVhqBXGiue1zRVlEJPE77aZlPeVk0wcIFspfKPodE5z1bO541m8oJnd8zglgVwMprJe1HWJ/+Y9eQyieqHVRPEKyD3ylUrBt+nBB2/jES2VYCzf+JTYJKtBJcHT8rZmmMHsFblvWSNuHxEBleAZNlcVk3OfEqZuoYI4WNC1bCt7VLsH0wdSUYmdWqNafv8jgqZGP/fIR0/dVnuxBqxOpMObiIRVCrpBxkNsHOTDszftiJZHjnc80u87T/OM0FKiJWOkGz0lbM3GhEZKomPwF+kg8Rklu8twSNAuUKIkIEHYG91oQnUpijMjbzqOfbkHYk0K4LVn/rJLTam0lY6h3UzT7gckupHzVFZsS1N/Ag1mEOqWfEFo0e7lGcTkLd7TmFzGxh6686OolxgIj6/TfdAo7DQ7ia5JyakmJJaReoSCYqnCfJS5X1745NCgvE/agPO3ih1g5FX7zJOdjfau2ZanEp0haC3wUF4IT7o9kAQvrhMuE4GprSXg61+dghZ+dXTq6DMvQfg6o8+dUEsUoD2msNg5lIs2UQy6TQ4TuVH9NkcZ2dy91bg+PFynsJscUw+Y0gqX3YS16kmJ9lA+s6UsBro8pygH+Vzg6mzFuivpneb4bI981gnCmgnlZvrmc9abkuOTuVjrRUR1WTLMoDqG1V0fXE0UplFsnh3Izg26E92B8qGAOCh0rxgOBvTaiLf5haG/2aF6jbcKvQ3c5okFDPpqy6QKPOnZgGrEaQSnIHdkl0b8yxuNNUE4u9bCY3YKfbXFh5cX85ZKO5pNIcHaNsMXHusE9WQtyQFaKA5Yjb3IZT+50qLaHL3M6eeO7OoW7xXDIF7qfW/wlcUY4Y67+xMcYG5vsY3Qb5T2+CIkIVbhMyf8843Qecor4TPvTXDGY640FMXA5mSC6sP+tjW4hzPuF1OhAikk4Kss2XEuVKvjBV5DO0gl8smtEl1aTEjUirxjlrW4qqPrDc5pLs8nZOXA3tEK5zSzqqU0Aw6VHFwGpzlezVhtS/LM4rxiXnQcTjb0zrBfbWn7jG5VML+5xDrFom45vphie6F8+SFDtZrVi/usPJjbG6pZR3Nc01UFh1eWYh+56Llx9RLrlFhEbnPpM9Bpto8rQakLh1lm2GWN/7w1nZX5MFiDtZqsCE2cmoyssAxW4xqD2esoqoFcOxZ7W9EfKM96JVUE7xR5PqQ5ADAMBus00ytrSZ6V59r1Jcu24tHZgqEzVJMOm1m6RxMun1TgYf/5cy7UBLXnmU4blhc1OI2+zFBHLXadkz0psKUXvcigyE520MTPHa/J43UdpEcucnk+BivDJPggX8L8k4bmUNwlsq0EdYcfGTfufO0DSmMEISSgsyaWv0mIXL4WFFxZ4XJHxDFyyU6+yLF4QVGeSYCAUthsPM/tDU/528+Y/l/2kwBSqCEqcXmlwUzkokm3zywEn9FpwxUqXfdQSjBkWk+7pxOyHK0pfRYRKCnPu9yjG8X+x6WO7Ipw3wZQYa77TNCs6Kku9AgV+LxqRFp/8XNgfH1XSQUgfYZSAbWUl8UALlI7QL6jOvNsM5Us8oZKjV0pA8IuAZ2mORA0t5+oxIdXTkqFNggTiyVBNOqlS1stnMDJQygvR6eamHDtOvrowbN4CS7vysUmi78gyPRGkpGI/gIJuY6flcypkX8rP1p1Ll6Jgl155rGSoqynORDnnPrYEX3b42fFhCdVetRoGQqCAGeNw+Y72gEDvlcJqY/BO97THJjUuj5WVKJH+VBraSLy2KWKSkT2o0BX3ssvVdp7hIMdxNXR/SN27MzWQci5a1NpRq68gtEreLfaBGB3kP1QiXAFuD4IwVUcD4E6k48dfaOQW4S+PiXgLgtVsfgaHQNvhQ8IrliCgrbyOlvJuQ1TEp87NjaSvgNx/IcGShVPUTj0IGhtftDSrwpULoMvqwe6dY7OHdoEMeNgsIPBO8iCLaPKHM1Zhco91oM+F664m1r0xoADOxcRh8plkqpeoTqDW8kAUpUTQEpLExpXeLbnNf20Y7G34eJsCq3h/JMHnLtD6ucuyTOxUxqajOGiZFtaFgebhKBev3rJWWicRGNor/dk58GsGjArjb3WY1VGfpJJU6Ejx+xjOcM0+qErbO3Izg229uLUMhsgiA7VoHG1E6pPZyjONc0kIysGqrpL9AWt5Zy2j6bYox7VhfddZOLZPQ2+rWGA5YWl7TX9yzM643ETi3KSELg8llk8w/5AfiIDM1tpBg2+dNLx9bSEiQvrgVCZVKNRWw092GsD2bzHZBatPTyzwVmN3WbowqIzR5Y5bD3gnMIvC0FRK4udeUFzBy22ibc2DMHZZXtRCSe9cDDvUWcF+o0r6nxgsy04WGwojGXdFlwOGtto9H5Hllv6hxPprbAxuE4Lt/oi4zyvya809NuMYiK0lXh+l+cTnr/9hN4ZHlwsuLV/gfOKZVvR9BmbTUleDLRthtaey23FxaamLjtO1lOMdty5fcKDkz3sNktVBrfNMEuDUZA9s6Y7qUSDsSqYXltS3e45P5lyejxjvr9ldVnx5Hwm7i1OoR+UDPuW6ZU1zVnB5NaS7Utz0J5u31MXA9um2OGta6zV9G0GHtqLErwSa9WNoT1QPHwygdJSLlqKzHLz6gWrtmB5WWOHgv29DZfnBc1SxLx62qMrjwec1VzmFWU+MKlbLs4XtKEx4vTOEu8lWegHQ14PdI9rLi9DxUx5XOXQxyXlzQ0tlcznaDG544D0WjrUf/0lr5vjdR2kZ1twk+AWEbi9URAmqJn8uzkS1Mw0YTOeCUIay/J4QZxN75O4zHTiIpGvpGlFGXjPvhwtD5UldBJUHP2sTvzWbCP/TzZ4ueLm/+zx//EAZ0anjyx6VYfXoAQ19FooBN4olrcVxUp4tNoyBktFEP0FD2vxlY4e7eAK4VDqWU/+yTrxttvrAy7PkitH9OCObdhT06GIqgbqBYyJ0O61Rc5y/NmEhijJgjIGhq1K4laXiUgxCmlj0mFa4X9HmkGk3NgQHHsjAk7TB4R1iKJMgohT7r3XEhBnjYiLJ4/luUZ/++rUhiZGYEudhKIRuZbvlWDANLC9ohN1IiZmTyHXarTsjFWRiLLGoD1WX6IlYBx7Yk85crGVE/su03o21w2Tx8FfUgWKgB+RZBGSOhEAqzjuFSB/kyZJBPGrJl8F68xhTDazQIeBMRnQTUhgTgaqM52sNPtA7XFGKkA2CHSToMlLRaI8s0mwub2S7VRSZFxJwhsFwvIeW8pn51vP/Xdb5h/JWbzsUsCbRNchqdkd97GvgA9GCuM9YschhtRYSkHqAhzHkO4lqRONg3jd+wxWdxTZVoS4ILxzq5+eCxFhj5UrExBzW5Ea7uzaBOpQZRJPZBlH+axjaA2mCDxl4xPlZbsuMblNuvS+zTCFxTuN3yomiw3bV+eogeTS4srQ3bGXm2YmA8Mmk5bzfXje+50kKFbQ5OzYkD1RbO6AW9ZczAuKRcvsaMXJ/T3MRrO+PwMtgak4S3nUxnC5zpAmT44HqwJdBoW3VehOk20UzW1Bxd3coXOLm4Htc3SnUY2mO4DuWo/KHZN5Q/vCQih6EwtOiTe4CfNpYgXhbgzZpKffy1C9OJk4pfFe0bcZOpOHVF9f03UZVDAsCwlycg+rDFdbsIpy2tP3GcW0J1s0TMsOh+LsbIojR00GvFWwzqD09EeScSoPZB5zmSWvdgf4vR6LQp9LUx99rZFA+LjCP6hgqxjetMaFSke1kEZWWSnIc/Ih6IX24YeMfBMqDJNM1mYlXH9fWwnQTRBcO412iv7+hE6LicDZ/Rq3P8BWy5hoFVYVqGsb6jtLNpc1k8WWqhhYrisW1y45PZlhB6E0AQydoax6hsGgTgv0Hc88b7ksKz716jUWgSrTNVlCno0xOKe4ulhxvqnZtoXYhHYZD473uXqwZFmVrC8q7FZ0DlZ5Zlc2VEXP6TaDM2mAdn46FXpP7ljsb7g8nYKCsmyxTosI20N+mtGsF+TPrOg+soefOqo7K7o2p+sybG+oFluUgkXdsKSimLQsL2rqg4Y8s3SDwQQeu530HATKTW4sTy5nNOsCU1iyzHGxrMmrATPtwpbg5Xta2UgfX+7L2tRryqsbjHZ4r2i2BTeOLrj38IAhM1KBGlRyqslOM1wlImr34gw1s5ij4M50Wv6SmOhzx2vveF0H6e0B6NCpziKIcHEhHNB8BeubPgl3tl5R3TccfMKRbSXQ66cqOaJIMDU6k0R/ZlFRC0VDaAmje8RuZz2vJPha35IOeNWZl4q3Jn326KAi1AMXxHEwBmhDGe0AZQP0mQgvI8IYgxMilUZBuxh5xtHjuTxVZK9kKC+uLjF5yc6yUEEgWNmRgp/kchEDxkGQdaHkBCTWSlAntACJH12mUlKz/DLZdK78myokFRIERTFsdGCJbexxoEIFQFlRrLeLIPIL7in52nHvyzVur+fgpwp8Ky4wse19celoDsW9ZXtF7me+Eb5BvpZgNAagqne4QlOd24Bo6jHgC3SUkVcNkyc+oa86Jixh94zUj6EWYZoPQuQYwEU7RxeSOptLotLXiiqg6BFxENGs5vTtlpv/QYLQ6kQC8NUtxf4LToSweicIDU0ydDeOLxmHgNKJOqWco7i0ya7LZcKljH73xcWQBKARzR9mhvYwS5+ND91ANejgKhTbcydvc9n7aY6yVG3xGto9ab61ecax/2GNLRXbIxNQa5kr0SlJDx69McxfFfTedE4cblApEE5Bux8TI1uK57jLFcU5ia62vRooSK+Ar1WiWikHqjaYPjgTBfTcG4WbmySSnb/iefQuK0iwF+cWbwK1KjTSSh1Nu4CqD4wt6jXMXg12a20I9tVIi1HG012KB7VqNUMYZ752WKuwlUVlTnywB810f0tmLBcnMwlOjrasTybk17ZMJy2rVS0NcZyIUpVV+JkE6CoKKI2H3I9t79cZalC0z3a0y4xsLUJOc1+zfoPm4tCk+04m49YuJBlYXFmzXpXkucMYx/a8IpsMKO0Ympzi6pZuXdD5DHMpHuN4UA8qskHRHw6YjSQTw8xR7rUo5aUj5lQSivqVnGwlmhBXKOzdLdm9Cjt3IBpa8rXGGccQAvP5tKHrMtyg8ZuMbZlRzVqs1RR7LXbaM5u2bLYFvpNsbvvKPM2twSqaaw36XoWbOfILA8cZduKxs2EMiDXQK+gVdj7gSyvWjIXFX+bB9cNjvMEva2mINbNUzy3ZrkvcqkCvDRhP48u0/nTrQhKZ3kDl8CFw81c6uvMSPe+kj0ZodKXXEtxlm+Bzf7NFXW+w6wyVeezcy3kZR3G9JUstlQXFbT69wDjo7xe0ubiRnOxLMjgsC1RpGXoJIvNZQ132nM4LVp2cc533nK8Ny4s9oZeUjqu3VmjlaYeM++d7vPTSVbJpz3TSCjWkGJhUHU/OZ9jLgupoS3GwwXvFyinyzHJ8f09oSxNLsegYOsP8ypr1uuTylQX7dy84P5mxeTIdGwu9cUXfZLiLgu7eFKYOX3iaezP8fEDn4DcZl/1UNAC56Bu22qN6TbPKaUN3XUqHLqWk96SfMZ1IMrC9rCimHbNJK57xrYHSkucDzVYqAoeLNXXRs+1yLjY1k0p6GFyuatqLSqpCteXVl49kPO13mMpS7m9ptgXqfiVrRasYpg43tbJuf3zCMPG4qcPc2mnR+lo6fnFl9XV8vK6D9PKM0HVMfha/ZRie35JPOtgUXN1foRQ8urdPvjI8+B2e/Q9rLm7D4gVBXmPA4YI9XSyhKwtoCWZNM1IKsCP1AENqFCSNXEZ03fTSOhzGwEL80zVDrbh4o2L+kk+Cs+ZI0R6KYA43om82l88CUmMiEalKUGDakf5gS+FS2yqg4BWJjpCtRl6zaX3yj46e7BGlj810XKHoa4UpRr72UOrRMScglCKKlPfPfmIaAhEfzml01IndMZUX0Wi22Xl24Ts31zX5UpIiH+gR5k884ZNv++fywq+E3/R9f5b6cfA/X3nWN0wS81VnEvw0h6I9MJ1w4YtVXDUk4NgeBceEEFy7PCCpoQqzuq3IlyNCLKJiL1WKLPK8fbpnqZrgSfaZSo1d5iLvPl5rtPG0WoWKiLSkL48NenCBXiM87tn9gBYbndD5YiWUlmGigwe6BILDRMt3R157DqDRvQs89rGDakS+u4VBWZPsIctLhzMqVWqkCiAUr90KCYzVjN0mTDGAfvilsPeJYDtmYf/DOr1ncvy0wFgPkuQ5o+GgYXO9Il96fDZyqyL/f6gD5aYISV6451ZFnYMEzj6TZH2oxzGw25NAObHXLC6FLhbtR5NQNdy/2ScyaaaTweaWbPh6G0TJVomGO1gOujwsD6EyFHn6sdKSr2V9iABA83mOYiq0Bme1uMA4yDKHGzR5NVDmUp7vL3PWq7kEh5lHlRYFlI9y9Ks5m3LKcLUX4WftyOuBfpuhc8eVgxVPTuZkhaUoBlYnE7xVIiad9+ImMmhcZRlyh53oUGHU+IcVOiREwySUInqNbjSr9QLdK2zm6WtpzOVXJd4q6bauc7JuTM4B9FZ82VWrUYUj228oi4G66GkHw3JZMz/YML3Rcb6uGZoZzd0etZRkQr9aBaGoxk0s+aRneEayCJ05/EnJaS/obzHpyWYt68sK5xT9NmdxsObyfBKEsB53nuNnFg4k8NW5OKv48wJKud5+z8p1zqwkN3lc1BTUgUqkPX7QeAecS/fOYU848FHA6jOPaTT9R/ZQlUcd9uirLSaToHnoDe2lOIPYbSbJWz2gz0ps7RjWOdlKY30BJvS2qAf8QhKu7sihTwuxltxq8l6+004daipdUd3Dkqbw1M9dUuYDl6ssOc3YQQldY6uFOqI9+zcu2asb7p/soWrP/mTLy/eP8B5OllOG1uDOSkkQCjArhd9qPvGR21Bbqap4uHbzHOs1q01Je1FiJgPNupA9p9E0y5LqSs+mycmrgfOQiOpegTUMlSEvhbrjLguYWi4+tY866KivCiq+Op7QPpqIPWrpUPsd02nLZlMyrMLkLCDfb+m3OZSOvO6pyp5r8yXH6ymDNazPaw6vLmmCk8uk6hisDODtpqCYdvRtxnlncIPYZc5nDRcv7uMXA/tXN1xsaopM6EVvvHrMyWYq1JbOiAhu4sjKAVXDtf0lzZChw4a4PpmQ3W6wxyU+9+hGYy4zigvZq+w1QeztvelniIw+d7yWjtd1kN4eQBGCP9OKUNB0UP5CDV1NlUF/WYso7EAcPaoHhqESK7TYwAUVOLOx5XkIyhTAAFoDO8hgbL7zVBOePlIaQqCghdIhwZtPAkGHLGT52jN7JZb7Q9BwKkIzkN81B4r6mOArLoFQdNTQdpfDLhSeSMmojsUustsbz9ll4vCye86Rm6sDCh6bO0XaTbdQ5LE9ezcKPiMVhcDZjXuV6cT3eqgkkJKmLp4n7xxQg+bqf9YhgIU8dNHESzAlqDOpmVEMqPDwV9/8fx8fANC9ZUv9uCZfSbIQ3V2UkzEQ3TOikLPdC3aJ4Zox4uRiWgmCtXWhJbwTmouHxafdU02J+qkkb9GPHUgNrWIAHlHdKGrUgyRY2spYyRpJZnQIoMVDndSpdPrIMb830jN8aDEdaRtRt+C1+L7na0e2ccmi8ezzJHA8+PiYPER3jF2kPdqFRnpPeW7xmcIHH/JI9fA+IOterhsvT0FZEZSawPvWvUNrFSgc8h60onoSOObD2LzGG7DIWM5aQefxjmGig6OP5+jHy3DOkRMOVDLwpDIVx/DohBP54ipQwqKQc5gJ/z3SYrLGh88cxa39VCVheHMk7y0uIOs86GCxGrqDmq2GjTiMmE4LUGAlKSwuZR52+6E761YSmm4hrkTdHqETqiQX3oB5taI7HKivbLCB3qKU53C2YdvnbJqC9UY4ssXVLXYwOKswRh7MtG45fUNO9bEKe+Co7ue0d1tp/BI86d0q53G3J44oHjarknKvpQ1caZ9pqUS2GhN8sP1CqBwWYGukgc++iOt0YbEI5UMXFtuGbajV1NfXlMXA2YMFZtqLlEI7+iaQZ9cGf7UlLy03Dy+wTpNry6YvmJcN227OfL6l6XKUyul7Q3GpKM6LpAsYpp7u6gCFQxeW4WEt7h69IruxwV+XqkIf6ArbpmD/cM3lZQ0e1uuKatoJGjrrqO6sGAYR3xrjBMXUHn3UYpsMHbQC7qLAXGToThpY+dxj9ju8k4qIMU4cekqHdwpzlmFx2MVAdS+nn3mytfjC9wcDGE9e99heizi3MdIMSnvIvDTZCl78OETwWjjstY6jK0tOnszDfTdQOgn8vMId9qjLDHsQ6DlaaBOsCxHolh5ze0PzwoL11Y68GtCz0alHac/1u5e0Q8a6KajzgYdnC1nzMse9JwfgFZMD6Xg6WWxZHC159GRBNe3kmWZWGilZjTaOuuw5PhVB8exoQ3l1LXaPbc7m4Qz2eybzhvMnM9gYzGGHH6Ti5yonmoBtFtx2ZH0zxzn2qJemTU7TrgpULzz7+XzLYI0g+V2G0g5dD+gg1jXGUextKfOBfjC0fcYLL1/HlJasGDi6donGsz6eUuy1LDcVddnRdDll1dNsCvBQTnq2K41tMzZZIfv8k5xTNWf/aMXltmJadjRDRm4sl9sK7xRZNTCdtGybgr3pFucVRgVXJKdQGql+GQ+TAacNajLQVDnFicH3GlMNZM8sf5no6H+9IyzNv/7f8xsErX9dB+m6B1cHhKeWQKA9cgn9LJ9omsPQ7EKBv9KiP1XRL6BfeEGsCc1JOi+C00EC4b4OXSdzNZbuFamhigQvPgUvkRcbUeasDVZSOyJL5ZBMuZXAIl+7VFaP3tUwBnHrmyYFIaYT1CRZJnqSGI9cEMPIwd9eC6dohMumQwDsh4Aut7EF+9hEyWu55iwkFUOtA6dZpVbF0ZlGPpskpJQOmqNA0BvYXpHvzJcKlXn0UvP4XQNX3p+HoFO+U3dSDdkVwGQroRNE+7z/8/3fzX/7/I8CsHIN0w/WY5fNQLMQEaJQk2yhQnAc7ucQhJ6d0IkkWA+e2Irg5iEo9OWziuff/Sk+/MIdrv94RrSEzJqdzrHhuUdKVPJqzyShsrlifd2w/KKW2/+PTGg2oanRUCkunhdeqc9EG1Gd+hTYWh26opoQlA8eW+iRhmUIXeh8SoyiqHT+aU+xkg64F89miaY1uz+kOQHgw32R+6GFroP8fahVCnRjZ9TofZ785+Pi6Mfqku6lYRiB9B1pHrYItpkEKkioSCRP+FAhiMhzsbRPOeJE2pErNLYITZzC55t2HIcS0ItOJYqtff50Ii10nVDdCNWEOJ+dUZhB6C0xOYzXFp1ZIgVt9orCFkIJyTaim0ifk0t5OlaIIkfZ1uOapQb52Stwz2ypa9n0fR/4QhvDq3WNLgS1PThYi/2blgBjf29L12e85coTPvjxu2LNp2H+gmZzE9hmuNzRdoby/8Pen8Xctq75XdjvbUY7269b3d779OfUqbLBYGIQGIKTWIrkRFEU5DRISUAiEJCcOBIXSJGjIHEHygWKlAQi0iCCxAVRBEkINnGBI2xwV64q43OqTrub1X3t7Eb7Nrl43jHm2iSXpLJL5wxp66yz1vfNOZp3jPE8/+ffrHuGQsIDtImM+wJVePR0EW1CxiPEIkhRl84nvVj7RZsmEIkT7itB0WMeCIMWQWjtUauRvstoD4VMcUYjHuVRodcDwWlBwm2krnpGb2iGjN3jgqvrAz/54oZXz5+43S/R6tyw9JeRcD0QR03904xwkfbnYPG1Qq0dnMSOcDgJirzbGOJo0AdDMPBkSnQnyHmMGd2FIJHBK4ZjSb1pGUfLOFiyXLrz7piLkLICU3qoPD6LBBtYXTZcLBrujwuerQ5cli1fHDaiD4mKh/sl0RjxLe/TBKxTMokICr0XLvzgcqptx7PNgbdPaxFJeuFtqDyweSZF2OFdQaiDIOdecWoLuUZdctGJSNIrCc03cXbAMY1O90ycxa/jMUc972GfoaoR31pMOod6b3j3viSsHXpveZvVbL62IwTN4UkWbnRqDvxpDnKD16ue5lAQR8N4Emcd02lcFvHPWwmMGjXDYMkyxyIfuL+TyRAnS6sKKWCvejarlvvTmu3zA12f0d1X6MpRL3uGwTImKhidoY8ldjGQVY7nrx74/LNrdrsNlF5SWiMU5cirqx1PTSV0qragLEZGl1xeekNWj7P16DTNQEeC1+R2pGkLtsuGInM8pPvHOUO5GGTdWM9QBrAKc5vxxEKErV3Bqc/pu5y67qWR8Zrd44K8HgkoocG0JW6w+M5Qbjr6NpPr2AsdisEQs4BKPNOwy+l0yS+3r/b2C12kT+joVOT2N+KLXr0RK7/2OwOoiC0dReFomxwz2a3dCWrmkjuISS/WSeRV3UsxLIix/NuwnVwhPggAyhKKHgHiLDqd6ADAzNWdvM/FgSPSbcXFYy72ElIrKY9SdJR3UixMXtKzQC4Vid11ort8EMSknHBn7UkKGmlgRBEeNfRrPXOJsyYmwa2mug+pKTmjonaiPJizIG5uPFKBHKbo4vR7WUrjHJdCtyl/Ir6W2afZjOoDMx3DDEmtnhqe7kKdUX4f+fRf/g6/8ide8Y2be97+W19j/an41c90iUqK3/4CTKuwPQlll2MonoSbHo1wwifUfqI06FGKyd23FP+bf+R/xRANr19e8M8t/wTFX17wK//1H3GRN/zWv/i3z3QJ4bMnLnsTIQlVJ9rL8k0gOxWAR4/nqrN8CJxeSvGPSyhvk/jgyLFMta4vxOlGHHuEV69dRE9+51Od1aVxe1Az0r/8IjmFtIqQ6VlPMH0PMSbKR5yFrMRI/hTAqISIxzksaGowglWEUuEWsn+2E+qVUHAkTXZC8ZsbM3PDXaJdZUf5zLESJNsXU6CX7Ler9FwcT84/k7e+iszN0nSDzZMqp8j6s+OKGeW/YX2+/3x+Fl+b8ZxgGzJZqzJBkoI72gl9V1S3E81Mms78GFNjrugv1Nwsq4k+ps5Nc/s8NRIu0YS0iE/dQj4j3hcMzyJlPdAeRLw2uFKSREcpdDQRW3jWVcfgDcdWipmf7S6gN+Q7PTfnpgM3KnQvISnDKRfqSenxO6Fg4CydV8JRz5I2ohAhJhG0jQSnpEj3Qpeg9sRTup6Nngu4UAbUciQGRUghR6bwZMuBRdXztK8Jo2a1EsvAfVzg7wt2g2H58oFlMdCUBfc/uSR71vLmt58T8kj9kbheLBc9uxsjfGqnaL/mBGUeFdle0y88+XIgVAo/GOHYrxzxkElRXQfyTc+wz8meNbjBcrU9cr9bYEzAe42yQQJmWospPe1TiRo0ZjsQ9mKvOlF+MBGCwW00X9xtUSpyKgrWuaS5jkFjtSDa/maUKYRPYMI3GuLbCjUi3PwiUK9FpHjsC/EcLwPKBLLSyTtnNGITuAhQiD7BFp4hOZFQeug1ujXSW9VORJXXR3b3S6KJ2I+Et+y9ToFJkaoS8edYSTDS4qrB3EQGZ+irHKUiq3VHv7IYExgnW8FNx2lXobyiu6+wmx5tZPLz9mEt+105BpWDBr90cLS4JmMMiuuXO+7ebAi15osuxxaOcdBUVy1FLoXwatHx+LCg2PQ8vV6L1eZKKDNF5sTScHvgze0GfZvhANcLf7tZdFRbWWtKRUnjNYHmWPDFsKUoRpblwDGoNGCMWBP4+gsJ9GqGnOyi5dVmRzPm3B0W832XWc+uqdAqMnSWohpZLTraPsNYT3MsJAq7DLg8onrD4bFmfXlC68jpwXK8K+aG2GwGvnl9z0NTc+gK+t6SFyM+kzVoSif3HGCPVvzv88i4iiyuJJ22/flX1ILx9wnK/Xux/UIX6a6E3E9onBTnBEGpsh3oIU8Ru4U8zxIVZUK3Ji5r+ANHmnc11B59MBLzjWLxXgoXOiBGir3QF2ZE0Uehn0QwU+GnoL3SZCdFe60STzoV9HZC7FMRUihUd6YmREAnXjMxJYsmDnl2irj67CLyIWXFyzQc20kxMPHUp+bF9FA8qZl20F8k5NvD0/ek0Nz+zhmZnYpQ4QiruViaufoxztaTWSuFns/VTJOZih/bJAFdSXJzYW4abJeQWsPsn217znH1qXDzuWL/TfjhP/B/5Nc7xT/+4p+gvk3I/yIJfFVCKgOUT2d3GPkcOb/jQgS4U5OSnyI+O7sCqQjf/C/+jCEa/pV3/wB/6uWf41/5I/97/ug/cB6F/NV/7tf5J//Z/5GkHX7gfjNRQ0JC9yckuroXHrhyZ0ef5sbSfGdEZZ78p/Ji6S7NmaecRJnHV5rNT71QdkaSc88HgUZpAiDXRX1JxOwqNecCBBLVKkyTk/RDSfyqIpBipicazGRbODnnTE3hJBgeVrI2+w0MG8XqU1nT4wLaSwmCiTY57ShY3vpZ1DWsJBHXZ9ME4zx9kQbj7JFue+i2KaRGwEAJkRk+QNBJ+oso1BY9TOfg3EwqxxxwNZ1fPVFdkruR6eUe88nW1KWmZC60tdw/yy/kmMaVnHvTQayFjy7aABi3ATfqmU5EFC73JOrz1TSWgGyncbGkv+5ZX5zohoz65kSzl7h2az3vX29RTvNwWjDbotrIo1+gI4yrwHAToPSop2wupPERetnP0OmZO42OoCUBUzWw+bUHHj7dwmokDIYYU6Nlo3CpnTRnsfKgwOws6mDTQ0KjbguURhIT65RG2Qsq/b1X7/id18857Cu0lQI0VB57m/G2WBMmesdqlKLKCnjQfraiu+6JXlH8bolt4fArI9vnB9xfuMT/PQfCpYJdwfi6JnvZcH2z5+2nl5RXLe1YonSk2Ap/bnElgkRU5PZ+hdIR93ZByIMIM3VEFx53lPO3enWQqPqNplr2+NXAqu44tgVF8sXuTjlFPfJ4qBmShZ7RgaemIE5WkaUnlkCTE96XsraLKMVca2jbBe3CQVDia0+aeHSWOBhc6YQfbyPZ+5zxasQ95nAxoDNJF7389j0P+wU0mTQnJnJ6fYEqI3E70r2rxYJ341hfnth/vqYLinrVk+eO01NF32fYzFNkDrMSesrTvk6FrrizxKCgcCw2LS8+2fPp3SVKR/xo+OzTa569fOLU54yjxdYjrsnIVyOjiWSlY1n1tH3G+vqEMYFMex72C5SGcbCEqBhPGfsIq03L/nGBXo6odSSeMmnUVOSwq9jfLmRC8WIAp7GLgYuVeLCDhBQV1rNrSvpe3GFc5fGdpdlV6MxzOFSEwcDJ8GC2qEERFp719Yn7ZkHbZyJArRT9kFGXgwQ8lQN9m9E+VbT9AmrHx68eGJylHeRlOTgj4tDWEKMi045PvnYnjUzm8UEapt/57Dk85cSlI1uMDH1GWQ3E1cCwK1Arh9pljNcj2V1GSEEKXSPA1/XX7vmMX25f5e0XukgvH8XdRQ9SDHbX0L1IFIdaXB58Ae4PnBgPuYzzikjxzjBuUlFkI8VvLVHf7SSQ4xsnDrsK/f2B28Hy0f8pY1wkdO+Dom+iqahw5lajIOsCtos8fs/gKrj6m+FLheiYCqjuQqWX99n15cOwGmD2Eo9Gfg7OhQmpOB83geqdRvdw+lqgeqtnK0o9pOJs4krbLxcrEeHRNq9Csk78wI7RC3I41meBqM+YXUzKh0QFSoj0VECqAP1WihfbSiG0+67i+jcjpxfnOHafTfzcc6MhO5ZQUyfFlx0jP/xH/9cA/LEy8uf+O/88//Bf+afxhTjGTJzi6l745VOB7nNx7RnW5xTUYifFaPkYklD0HDjVXSre/WvfIPwziv/hi1+nVI7/5r/xp/nz//A/j0GRKcW3rErOP2c7xIkqMJ03PZx90ydHHLcwM3I/rKH4PKO/NFR/+AE+vSRkU+JlIDt5opbJSXtlsF2cnUeClUp1sv48T2jOCL4Kco2mac7cUIYPxL5Rzj2cNQWT8HfSVKhICs7SX5p8mCHSXyqaP9IS7grsQSe+eZwnOZOY2OeiaRiWmvLR4wtNvg9CDxnB50I10x6G2U9dzY1sTJ9nTszndFq7OM5JucndxR5TQ5gn68OpJvUyRZiCkopdmAWxKqHqc/BSWjtyfSNBi4A4JOrM5Npj23NjAeLyImtRhJFTEz1ceCmGk3BSO1AnaXZ8FXBrCS1T70qazytQkSEqrIoEMsZvNKhcfsZtAuubE1oHdo8LymVP+3YBlefy2YGHu6VwsxtJ+oxLL2mWJ4M9aYKb6GFCnQt5BBN5+OkFaiO2btlyQGuJfFfLkdhaVCsLaXp+oiDmkagDupEgopjJhdefVYQsErYOc2/5SX7FdnOaaQVUUOcj6uOIVpHX77aEQ44aFP1gUCsnwoeTIT4U6MTJHjagG8PuzRq+P6K+WBAWHrtwZBcdQ28lCTLZ54VtTwySAhm9YmhyVLK9e3azZ/CGg4LcetxgCMdMrkMeoDUc3qzEMmzlaB4qdOk5UOJ6Q38suLrZk1VuBgzbPiNGhc6EppOte9x9Kc1dLwFE03NbXgRCEYpOoxpLtAFlITqNd4CJ6NIRDiJuzDc94yhWml6BuS3m+/3hi1JSV5O7y7gOjBceXTqMjfiFIzSy2DPrBYzKAs2nK9mfpcP3BnfIZ1eTphfXE1W7mUMdb0t6U9BngR8/1JIy2lvKTUdZDdz+/BI1qpn3znpkWfUUq5MU787QNTkmC1xvjjivKYqRQQmlxOhAvW1pjwVjJnakq1XLqSmoth3dvuBwKlmsO06PiXbTy3THnXJu70r0IPderyKHII47pnbEzYhWkXIx8Hx94Pa45PR2idn2+F6TX3Usqx7ntXDUB8uz7YG4VDw1FeNoeDguUToyNCJs1dVInjmsCdwfFnSnnHIxkGeOm3XL687y/KM97Zjx/s0WgHw1UBUjPih2txvQkZffu2WZ9xz6kn1bcLyvsY8WVcr9GbOISbkG9qTkeftphXJwV17yldsSyPh78j2/D7Zf6CLdlWA/8B1WLqE5Y+L0BRldl//BQuggCaXVHvJdQpiSt3j210vcAppNzos/eMupz+lOOb4QmoHtUhE4BdYw2QaqORkxGMR/28H2R4F+o+g3Z2pJ1NDeyM8Xj1NxCy5ZtU2I8FRcZA2znd8kujO9UFSGlSC3elA0LyeLC+ieReHEcuYAT+giAKkRmNBI3QqHNqqYvK/ld3ff1mfLyEGOz/QJHTWyX5Nl4YdJilGD//t3VKU4M/CDJYsvJCV0prZEBRpUcv2YnGimIu/p+5GLv6lmv/kPt6/ZFcPyTI2RgJxIv05IdoTtT/xcjApvOIjdZaXnInQS3WYnQQ2r28C4UPyZf/Yfo72SYKUrB299wXetp1IZ/8jP/7j4j7cpudScEWxfnJHumOgi2cETZjccZopGdgDTa9zPL8km8TIwrDXDWmMGsZUE+DD51QwRPQSmtNBE/06UKTVTLeKEsqef0VMHCXMzOV1nFJDoInMzkMmIH6Vm337h48vPj+uAVpHsRQO7pYgwvcSbB+Kc1Cti2ogJ4EqdpldTlZKSPpOntOnlHhtWShqsLs7e/tJ0yn33YZNq+pQQmlxcTA/1nayZsf5y0e8z4bNHBd2FnmkuZzceaaAnvrvy8l/zHNqPJRWzfqMYVmcnqImG86GYOOSR7JAErg6IYjuohrPA2p4E9Q8uFcpI0es3DlM5eFvO0wi+qFEmooM0h6efbmTK1ihoC/IKfKvZ1yX5YmTcZ4RcLPAU8M1vvGeV9/zNz14SdpLESVDEk5GCxsu6DI2FPEixZGU//GNOcZusMlsN3zyhf17LcyFpKkIRCBsJkbG1Yzxm5Jue2Bv8UpMBD/eSapoXDu81h31FVji0jmgbMXdSaPV5FCcArzGXPf6xAA++UozPRR0eI1LINUvUoHHR4vcZZiNFIpXw+MdO6CAqcYp15rm+OJJbx66pOJ0KsWeM4JuM4kIQ98tVQzNkrKuOfrR0Y0Y/WIZTjuuFTqOMFPt/4MVbvjhs6J3homp5sxNxpU3pk/pZy3BXwcLNTjy+s5jbTNyCnPDFo4aYgTaRqBLtCOS7Fo44avwoyHx4KDAXPTH3hMZiNgN+MCLOXAyEoBjeL2aRpNKBxWaguHb0o+X+sy32yRLyjHg1iAvMyWKuelTpsDbMNKC+yVA6st42tF1O9Y09ZTbSO8u66si05+645PBuSdRRivqVZ055HTW7Q4UxATcYbKJUje8r3ryvMNcdN9sjJx0ps5Eik2tzcXni8WFBVjm6PmNsM7J1y+b6SNvnhKBYXTaYm0DXZxJEdJq4cYjvfZrQqEETC0VWOtxgcM7wdrdGqUhx09A9lqDF8vIQhCJjrSfLPItsIERFm2Wc9iWX10cAjm0h2gci2daLBeOg+fjVA1dlQ+MyXNB88+UdYzA8HGts7bC5Y1N3dKOl6zO2n+zIjWfwhte7Dad34tRi1yM3Hz3y9t0WDpbqnWbYRPxHHWNnMCdDdAosmOH8PP3l9tXcfqGLdNML6DIlGRY7KHZ6RtHGVKSOqzO1YrJsE/7rGX2cRIzZQbFrStwP1mzeQHuVnEaSG8lUxEx0gZALbz1YeflXd2GmJEyUmKnQUCHSvApkOy1OBaRiAPm4yVVCBdh9LwpFJRWjsy1iJkW9HmR8PqwV2EC0EnscjVQCtgV1PP/OxJk1rexbsOcgGkHHpMibzsX2d8OM9E+x7YePRfg1FaZRC9pOlIJqSuVUCp6OFTebI/e/GumHFflBzv2wVJII2slxTbZ1tpM/2xa2f0sxcfNtH/nmv/0/4Kf/1X+Zv9Q7/uH/6z/Fq4NUp3PT9QGdAYRS4TOh66AgaCO+9XFqEuS6qFGEk5PfuhwTVHdx5g//yX/vn+Kf/nv/Hf7s3a/x9l/6FlpPgl01XxPlwI5hPndnxx05UfN6iMmRaCfnfVwJZ3xC+H2ixBxfKTY/DfNUZUpGHdYGPao5CGhGg9ManoS+MZOiNmuEiiTrJ3G5leyb0KoiTFOWqTid0OcUtmTGiPZRdAwRvFWEhaPIPFoHaBNPPOkTJvqQ7eJcVJsuMK4Mk8MMMbL7lrif1Lep0fPS3BRPMuUYay0TizQZ0C7RVNzZDlScfWQ/fSG8ctueKVsyCZJjzg9JIJ40FpPQtHyIc5NvUlrpNBUJVlG9B9PbOX14Oj/5MdJvhOJTPMnPNy+gfJ/ST3NZ48UTqKBn/YR2MKzk38aVcK+7n65FYB013dcjlIHiudAzjA5YE6RQbDJisvnTX+tpHks2z45STCZ/8r/77/pd7rqa108bmvuan336TCgjFx1D7WfkkajmYKBYePILmST6UdOfcuzrgjLdo9old6hjjvm4IzzlIn7sEp+o1YSFx+8zdO0YnwqwkfJZQ3co4GgxjSL7lZ0gj4uA8xprAp0ONFc5ej2QF54hiTXNqseXnoBBPWvJM48fDb43DH2GvuzJC8fQWXyTieAVUCbQHwu09YRDTizlARtGTTtk+KgYEqqvTSAvHF1v2C5b9k3J2/cbOFj2Zk39/IjRcU70JBdx5PG+pu0zfvp0SdtnXK9OPLYVbjSzIDcEhRsM2WUnVn9REbwiXw6MB6GEqdyTX7Z0+4JiOcx99NBk5NVIVnr63uIjYseoBZQJTpMvRvpB0G+VB8JgOO2X2MsOs+0J70u8EUpTC5xq4bTr5Yi9bjEmSFFYeWgNvC7RjaLfBOLKYesRHnPCytENmdgGKjg81KijZVcvWV+fCFFBHigWA8Mh8a3vCrgcyJcD3omlpM69cO4PmUzuSnHAud8vGDtLduV597imKge6wfI8TTse7pYUy55FMXC9OPHuuOLhiw1mNVLXPc5p3F0JBlh4Ap5nz3e8/+nlDNTwlOOA6uMDVTFy/26N3lvMy5bqomPoLGU90OxF3V1fHVkWPcehIERFlYnzzMPd8uykk0TVRyN6ksurhn1b8vnvPpupRS9ePPF0qhi+WGCet/SHgvf7QigwuTgBTQm9MXO461bWkI7c7xfoJ4s9aLpnck14yikeNb6OxG80Yjf64w+cKb5C2++J88ovkfSv/pY1Uby0p5FzGpObASnGk+NLNMkWrVWzdRcmYnLPs4sDmfF8/v4Cm0lMc/NQoa4dxQ8M+SGk2PAUUT+e0cbJZm+iCdS3ksI4vfSjQhBjnwp8q7j6DTh8Q4oJX6RCGWa6y7hKxUAKr5gKwakoBbBBimefp3AVq7Eng2lhXKcJQQYqIe/KQd5CL0DPl9IPp0yLYACjZjrPVIjrhIa++aMa2wjPfHJ40Q7e/90SGJXfWYZLz+rVgeA1Re5ox4xnmwO3cUV2BFXLd2b7dOzFRDeQYz59LbD5oTx0Js5xsPD8Lxj+6L/3T2D6yCdBeMPKR4xnDkzKJ96sAl8KEjv5ak/FrisFjRUKik6OL3I9n76ncYvIxX8i3+tzePy+4t/64/8iD77mH/z67/Cn/vv/bU7/2qt5/c3OJkSCTvudHEv6tWL1RZibtOlYtr8bpRj8MBwqNXEmra3FGymyxY89YnuZ0EQ9IcQa23hMEiLPXu9WbCT1IaHJCz0j5x9SssSKMS0qwDYetzWoxEFXXn737g/Ds/9YjjU/SsHfr8X6K88c+/sFL34mfx8DSBjYme4zOdpM68h2YnU57ZceJXxKeN9iD3r12yoV2OIa5FJY2VwkpwJdT2LUxAOfxNfHjxShUBT3wpnvruVnj58oiofUuKXr1Hwk1qOL18ze7iG5Ak2OP5NQepo+zY19omHYJFZVgSQwTQj9UzrPVp5Fppdngfjcy2eWt5p+WBOeDfRXCo5GbPgU9EfhnMZRozTk6x5bOqpyZHCG7phTXnTs3q0oL1uWVw2nXclf+/xjQRVPVmgyUfZ1eF+hNwPkXgq+zEPuicn7eWgzyoTEahVwlw772s7PtnwHZsgIJmP4KKHaR5NABCnYda9wpYdRYQ4GtY0sti1xgwT3RElYLAqxZuyGDJ/i7k0WGO4q4QXXnuGxhFHSSk0m1o82dxjr6XcFi6uGcbSs1i324sTj0wKKIGE7qwG3K8hvWkIq3q0NNE3B4WEllKAAdtuLT3dnuHtYUi0GNhcn2ipnmSwcR2cIB0lFDaMUvMor+jajO+VcXh0ZnOHUFBLmdCwwWeDZpVgYjs4w7HPckKG8wr0vCCuP8gpzmzPc55BHBgWri4bTscDkXiwZF+BTcaxMJBII6yBe56VDFzI18K3F7OXlED+v5To8G8lWA0rJNMH1Rj4jKJ5tDnz2t14Qa0+96fArzaZu2bclerDE9wVhb9HP+rMYV8HwUAr9ZeGpNjJpcL2MP92YApxGDUsPjWVwiZ5nA9FrPnr1wLtyhXsq0JXD2CChP1dHHn62RW1GLi8bei92hac+l2bkXc3Dacn7yy0Xzw+sXxzYP9UcHmuyemT79R37H2+ht4Qi8v6nl6iVeChHp4mtwTSaZl/SmoIXL594Wld88/qe05jzaGuO+1LWulM8PSxo6pzMepzXvNru5Bm4GImVw5hAXEry79X2SDOIwDR4DUtH8DJt2ZQtD0fRS8SoWGxbui7D64jyWop1p3in1uTVSH+UAt5HsAcNGQzbIC50J7F3dOtAKCLqfQmDQneT3dxXbPt9UkD/Xmy/0EV6d6GwySZOhIIiKhMxmoTl+FxelPVrQR3Le0sETl+PuJXjTX8ByIh16OTlVb7O8Dm8//s8l79hRHCYqB8f0gSUh8PH4v4A8r1TMM481U+I8ORrHjXUb87OFTMlYbJmK0g+6lMBEmdajOmZCy09CHI4bkX05CsEFdGROGpCLsEf4h4i+54fZbowob/ZSc5PqALjwpIfpDgxQ5xj7LWTQvf6N+D4UeL2VmoOT4o6onqNTz7Fp59uMK8alIp0p5Kn37mkDDAsYVwnmo2eXF1kKmA7Ob7tf6LP504lek1qCOZJQio2p2bCF1qQ1CRcNX0k3ydf40zP+58fQnI6mSYhqalLWgHl4Oo3P3TtUXz77/k5K+X5X9z+Uf708z/Hf++Tv8S/NPw35iZMT3SfOaRKrk93Icex+5Zm8+Mwawv6jSY/noWtEypskg3oNO2YKTR5Qv7TRGZuCBW011YQbMN8zbSLDCs9T258Lo2cTuFVZjgXo3D+bFdpzMAsAJ58+2/+iprR75Cdg34ufr1ChZIrpRirafoiDV6xCygnKa8xE/R9rFNiZfKzN33k8m9NHvHSiKx/dnbNCZk0CftvRap3opuYQ5OsINXTtGxYS1MejdDD+q2IxoetnCvbShH94f04Td7yJynQIU1G4pkqMyFBOjklBStTu8l/fVif/z1kcs+WD5P4lFk8PTXqUYNpxBLTdHJNmmfglwHzPie+6ogbgemz0lEVgxR+y0D3UDG8rbE3rfBlb2vMtmfsLcVFR/dUzhSJYSedrzIRBgkLQjGj3tErVGtmPjQnAytxEukTsudbizmaeTIiiaxAB1qD/lmGWwi1R3lpAsYbRygV9Aa1Hll+reGwr2Ri0Vqy5cDoDJuVeEKD+LWruwIuBvHoXowsX3a0XUZ4UxMqT7CeYV+Qr3tB2TtpDJrXS2IZGDvLatOy3TTsTYl7LFEKnn3yyNOpIs8dzWMNi4Esd/iVZrkWastpV0EvTYLvLNubHQ/HmhAUu30tHP5dLs/UImA3vVhYWil2s8rx8LDkex+/oxlyCaqx4mP/9nYj9JUIxVYKqeGUo7Y9de5o3y0IReIbnzTRZRz6JZOdJQhlR+nzhI+AaAwGJeixAnPVQemIuSevR/pTji4dejAEr6XBWI5Cv1EB12R8+sU1L757x/sf3NCEmouXew5tidFi2xkXHpVFAb8OlnGfkH8NMdeYehSRZ2exuTxrVUKaghcUQHmFsoFXz55mH/wQFctFz5A7sVFsMnTueeosaj1SLXpOgzSnx66gaQr8Q2pWM1CDnhNMiUBrGFITFsogUwIrlK3gNHhFserp21ocioD1puHhUNPvCn7wxdewL1qqcmC9bdg/1aAUv/r1N7w7rmi6HGsCYzCz0DMMhjEKt3y1ahm8EdvJU0Z+1fLRi0eemoq2yfnsccvV6kSMisdThfOa5aLj4rqlcxm3T0sJWBoMvdOgI+VNQ/tYQjBkByCKbadfCrC4+Xgnrj3REBQwpWT/cvvKbr/QRfrsEw4cviXe3/mjJhoRe9kUjGPbszXaNNpffKZQqVKWUXUkvOwxmcd0ghy5o6F5DosvxLovP4bZKztYhS8Vp1/rKf5igekiT9/RrH4uaLsCQlQfCPsUw1q4s+NSxuwhU4SahJAm3ndC4rIUwDK5vgBzaI80CBFfIw94GzG9wryW6q6/llhnpSX12DaSqugLNXPn9UR5DrD+gaV8OtMrJkGdT4U6CAKZneSFbeeiVHHzl9U8plVBnGCeXib/2GLkUHuGjWG5U4QedLKLzBopjCeahM/OCOnZk1sK2rGeEleTa0x3dqJRTj5fhbNuwOcmUWhSQRphWErBOCxEzBgN6OTMAbD+ecQVKjmYSCH55v/ydX74py74Z178P7gPJf/8v/oPsVZxDs/RaUoy+dbLuVMp0RKWr4PYHio5j/1W3GdkUiEiVz075cSkqZDPifpsjzn9PDBH0JdPkw+/QrswJ9Bmp5DoHPKZwSa3l/BBoaoSEl3pOaBpXChOH4nzSCgCxa2ZtRDZEfSoUvCQHHPWSnrpJDJ1JZxeKt7/Ec2L/5Dkg66S65Acx7BO3vs28cs9TCduml5MPuzZKbJ4rch3cXabUVGaRDV5klspeFUEnYkDjC9lf88uKMnpaUwFdkLffSW6kJCfJ0sqJNS1E8R8aoqtO09IYqKsTOt2mvjoUegu1btEd9GcnZqAfC/3ctbEWfA6biLmoIl5JDzmqCDna9zCdtFilh1Pu5rnHz/y7vUWY4M8U4yIE3XmsSZgLxvaU0FWOPp9QbYcWC87Hu6XYgE4KEIV4JCLzzKgThJXr7wiJDRUpbFa+YU8F00Hp285dKsp7vTsbe8WkfHSoUsBBdwpQ2UBMsjrEdcb9k/17OsebCS8rtEfn9gfS7SOFLkjKx3D2kBQBKewhefwZkX2YAQxHrUIKIuR/qmQyYCJqFxsHn1vqJZ9Sg4NWBvwi5HxoWSoez66eKIdpcgzOnK1OLEvS5zX3CyPsN6z70qqfOT9bsUXry8l1dRLoBM+WXaOmujFYz5b9/jRoD/gjf/o7Q1Z5jFGHqrRaTmfX5TY7xyIUQmHOUqTNDlzxCxC5eS5XDlyK02HSkJKEA678goGje2VhEoVkZiLzsE1GeurE8No6d7XYCJjQpSi1+jVSDiK+FSXjmLT473m8VSx+vYjx2PF0/2COBh0q0Woq8TTfdz4RP2KxEVAZZ5qMVDkDqMD96cV42NBftUxvq6JaydTjFMOgbmA71yG0YG73ZK66lEKWcuZx9iATWmr7bGg2Yvvt9KR0FmWHx0p85FhtDgvaaVai61ysKINKIsRfR0o85F+yOiaTCg8Syf2ki+PnB5qOFr2uy36pmfz7EiZyXHEKLSboh4ZesthKKgy8VA/fLamuxJ/c6MDLjMMdxVDlHTUtsvZXDQ0Zc7QZLwLK2xKvW2WZg5UqoqRrs/oh4wv2oLxvoTaUV509G9rWHryasQ5jcqEOqkHeV7xcSdNT2rYylVP60rUaM5uXV+x7feC7vJ7Qqn5z2D7hS7Sm08iZSOBMIvP9My9jlH46VEJ4qUTb3nySIZkQ5iKQkEqFfYzGXm5mpliYno4fg36TxzP/71sLvRBRvVql5GdBMXc/iiehXYJFdWBuVCbeNPZKdm7WeY0SpVP6KzsT3cF/cW5ANZ9cobwKV3Uw+VvR3bfBm/Ehk154eNwseunAAEAAElEQVRnezXTPMwg56LfKHFIGJKYspXv+LB4m8SrEw9+QmBdKZzefnNGq02UYru5UdS3yZauFppJUThOjxW+lFGtPYkXtj0lCkuRjjl+EML0n3K1yQ/yoMr3nlKfbfMA+q1ERE/0I5t8w00nseTDysyuMbaTf/e5rI9hoyj2EyqbdA0uzhMNQUylgK5uI3/mf/6PcXolf9608hKWoiwSJjectB4EcYxUd+lA0lqLRiU+9fQdiQOvPqCrBIRXmSY0U9E6NWYi2kyokYG41GfOuY+YPsx8adtHCCk9FZUcVOJsjzmJTCenkmmNhTwl0pYwXATCwkNQfPJ/E4rKJHxsr0ULMQmZpzWkHZR3mvf/uUh5d26UbZe46Qn1mewXpyCmyas9qgkxTyFZyYZxDt5SzFz06XxPGg3Tg00pwcWjiFfDBw1PsMJb/5DnH6z8bnaarhNfEmhPk45JyzBNQKbP7a7kGLNGePvHl3p2Upo48cNKzm93qWb3lzn46FlPDIL4MWgiUYTdOvL+/YboFPpkeN9ZzM4ynBaYRqMuHWUhzhLHVoJXaA1uKDCA84qHRyl2YhaIxgsKGkH1E50sSpDRlE+QB7SJ+N7QfTSSv8+IFvJboRCEyUIVuZ/HS4ijJp4sZlCEtDaGoLDVKMmOKtI3GfrJzmtsveyo84EYFQdViJ+2iWSVE84yMF67FOiDNBj7HLJAXo2MSlDsGBSm8HRNTmgtXacJlWfz7MjJRowOvD+syKynzEU0+fppw9BkXF0faMacfVuSWY8aIc8c2xctb9mCCeA1ygT8IDSR9eUJ5zU+SFiRfyxQl50ksOpIiAo/JORbIUmveWR8LKWBARH7PZTEMkgYVBYJVmOOlnCwuCpQXbYMnWW2ZEzXhsLjSs2cheCU2JXuLcfHLXpQ5CMMV15eCAFYObQJFNcNdTnQ9hnPVkd+9jsv4KTZXY9Umw5nDKHw2EtPvyvJVz3eJeqVlZv7xbMdY5Djv6gaPr29ZHt14nCoKPMR5xX6LmPciO88o2F8LPiiyURoGzR5PdC0hdBvBkNZi9MJwO5Qsd42MinqcrLcUWwbdm/WdDsjzUNM9qURsq8fcZ1F7TOODzmhCgxlxsXliYtlw6nPWRQDt09LTk8VNNKITs/am+WRzmUcuoIYFVU5cNhXxF3G54cb8OJyo1RE/6zi8JGge3EQJ5iqHDgeJR306WEDpefy5oBRgV1ToS57tIZhX0Cn6SLEIlBedGyXDbezTkFjrzvGQ85q0XH/0wvyB3Oe1jrgJxX+whOyyO4pRzlFftKyvopJSf/L7au6/UIX6aHydGtPf60wjYzsx5W4m7hCUOnyHib7u9kiLp5H2NGI04LbeLInk4SQZ/eGKQkze5tz+0cC9Wdaingt3sdx7dCjlSj4HFR+TuicYuCn9MsZCYfZZWTa9Dj5kIsrS3b44DjTPkwj9+woP3f7XxhQuwzTaOov5CFmGymGYyr4Tq8iT98TgWJU8u+uEoRxKurcMtFI0n5NKCQARYq1D5HFm8C41LhCPMf9Qjzgu60CDUVCiU8plS54RfHWCvf4RvZnKpQmvr1tzhz+SaAKguz64izUDcnfeuLS+xyyRuhNWRMEDV2YuaCSwlyl6wBmCGQnsQPUo3CooyGJftXcfJkRQc1qaaTMEFl+ISJIsfpTZMfUFPRxLrqB1Nidz6MK0uCIH38k3yWeeSreJ/tOFc+owLQmvqRHYBLvxfnPEw3IFRpKML3QGlyh03mWBqJfyzFElzzv8/R5qWFV6bv6C+DjVlwPbBCx3GBgnyXOdSqwy2l9p2lLoi1N6LJp4fonMHUoEgh0RtaJE7I+FdqpEFYT/SUV1FlqLJF7MWuYE39ny9L8fK4mVPucDCrnbrKijBpMn8KXFormmyPFm2ye2mgnazE7JcrLUjzju8t0bChx50gNpu2S+JnJsUnoda5OzYNNqP0o+zw5GBVP5/sZBbYc2axEzX1oSvpdIfHzjZaEyioSTSRcjKgsUH+jpWlzSX7sDPpkyD5uGE8W86phbDIYZHRu9gYVhCseCqmifS2FX0SheoVpNW7pqVaCsMY3pbjTmA+WtDtnQ8xWs/cpaGISoGYBfbCok2EcNaoQ+oUtPE5DXI5sly2HtuBpV88NrMoCJvNY49HLSIekWUqyJiKYS7Z6w2HyaQW7GNnULbtTxeA1MfcoBfv7BTSG+6ecObnTi/+1qRw4zf3dCls4oUQshIZT5wNGB/LFQL8vJKm1ybG1cIz3D4v0EJ5CcIQvrlMBHrzCdRnVqqNNNBW/cSkgSgnNyEaxq7QJqbcRXXqCjSIobS0hRcKrhBKrLMxBTsorSNOEbCsNXrgrMC8aCX36yRa9GYTfv89RjWUcNeFg6aPQGt+TPPQ/7rCflbSdgcqTLwYptmvD2Fm0jfO1cY8l7394DWnCcLopqKuBq/rEthTqxj6LkCHOaqNkjYSv9ZhpOmCCnJPB4FMKbRsK8sxTZSOuy3CFdIFTkPepKdCLkbgYpXFBzgsnS39bowZF3Di09ah9TvRapkfpAbHfb4iVF3qXitx88wGAy7rhR2+eidB5OaJMpCiEbnP5/JG7/RJjAkUm+3NsCy6rHqUi97drhp3oDy62J9o+o1MRbQP3rzfSBNsojZUSylksQmpcNN1DRf7ME8f0zonw/OJAt0rOOweDW0sTJyBExHSK+jMBvLrn0jRFLec6Oxi+cluqsX65yfYLXaSb1cDm2cDusab+hhQYJeLDe/p3nvOhK4q8pM8v9qmwmBxOiltZ7N2Np7w1Mx1iDgo6gR40/SW4VSDbCzJb/TjHlXFGGXU4izJPW0XxhHBSp5dZ2iZvaleSqA3ngJ9xFbEnNTufTMXJ9Dtmoqo8ZTIit/IimsSqLgk0o4bl9x/phoz+mKN2GfU7PfNop5dueXfm6c5ociq6xsUEs8pDxXaRrJHo+fJRbA3r20DWBLoLI8WfApVGne67LfFHlfDiE0JsWvmeaFJCZEJ0g1GY5EYCpAkFRB3JeoA4F+z9VkJ1fCW0jcu/mdI4RymIJ2975aUwN0MkrKWZUBERFk8IcNIwTMesx8jibZhFnSjh5rtKikxXSQfjysm2UJ2bGsWM+Lo6/WWYGoDzOpkKc5UmLcGolAg6FfjyqxPPfaK7TG4tE31nck+JRoGPZEdPyBXRiDhT+TM3WnFGtSeEeBI3Kq9wx4x8LfzgshwZbaD8awV68DPi7XM5T7aV3zM9M49+2udhLfSq+RijFLbGn5uwKZ58mljBebqiB/mh/JjO6QeN0If73F5KwzwV5XOA0TFd32RNOSHbKKE0TUj2cOP45P+uOL6S6HgRcquz8DuH+n0SiicU3dVSnLtS9nsq7iUL4YzG6wDm8MG1drLPLjs36ObzErf23HeW9YXoOIrEvdZXHcoElplj/1iTJ17xqSnwrZWiL4uEq5HYG2Il8eeri4bMevrRcioqbCkjfEIqFHUEEyFFxweXoY4G/2ZN+M6JfK+YHLCIZ8qPL8+gRsgj/pUkTbpTomPoSPaywY2GqWf1LqH2yXv8/ZutiAudZn154nQqyfIRBZS5Y38sBT0OmvozQ/MyoI5WLP2sxNzb5UiM0D+WvH8qhKe8HdhuGi4qSWHsXEaIin1TMg6W7ebE/WdboVnUI8YGvNNoG7DGs3tYcOoXqMqx3jZ4rxmaHJP75AAjiD0ReeMOBnvRCY9eRcY2eZOqSLsv0Yn6YtY9wyEnXw1nS8hvnYgPpVhajhAHjW0VfJ6jVoG+tujSERsJi8qvW0LpZgFpHAyq1cTHWp4NNjIecp4eS9iOhCaDRpO9aPGjpFWGUc+e98PvbEBHwl1BXARJLB00474mtEtZq3mcnxeuCuRXLUXuOO5L6mVPeywYTOD2uKTOR26fltijTg1gEsmXQuEKK8dq03I8lOJSlITR0SlJ1I2QGc/NzY5uzFjXHY/AOFrJNjlKiWNUJNuJeL5/MaJGmUTQaeIiUL8QJ54QFe0px7dWwr20PID0oLn78RVx4dlvSvwgjUIYDMVaHgiXy4ZFNvBoAqddiVsOYjVrRbgMsL6Q9NB+sDzcL9E2YnPPzebI9sV73p5WdENGmY+yz8ZzGnKePt2gKs/lsz2bskXrwNPbNZdrSWr1vZnrA3vUMuH34JTCrSLDlUyJ2Q7o98lFJ4vE4pfV8Fd9+4Uu0q+3R+5+8jHZXnNcFoRaxvM74LJJYT+rM+I1uTCAvFz7rbw888fETR0gKinWpyJ3esGPS0GwBf3V+BIuf1uQQO3lf/ODIKcx0SDyPUxCPxIKq9zZ31n18oLvtzIG/7CQ1W4qwM4v/nGZ+LOpeS7utHgVJ2ROvL9ln+0JDr/q6O6XcErR1Fk8u7a4M2/2P10QThZ0thOodfctxXDtefYXdQpi0phezTSCkCkev6/F+12BfsjwSy9j3neycxP3N9szFzeuOP95CuiZhItTMUqM4gWbRH06Qt4HqoczgnpGTuXnQiYohK8hFuJTb1sIVaKpfFDwyrNXCQqUaCxSlCje/5rhIiWx2g6GhU4UjfSdkDjUkaAE/Z2aQp8rTq+kIVl9HhhWmmIXZKqSCnvl5ZiilgJ45qSr83U4IxIxNZvye+WjP6PwPs6Fri/1mb9uRAdRPiTUu2B+icK5EJt+9+qvZPgsE+FjAf4iJnek5D4znMOPzABeJztQPx1zup6jINHKnc/nVMRHDXd/m2Z45sjuLcUjbH7i8aWe6TCu1uJfD186T9MWMvmOxVtPNIrTS1mXQSUxcvJUN0NaI6l5jkB+EhrN8//A4krF0zfT4UfmdNxoz8V1sZP9kARWESpPtCUZv5/3SzvInuLc2E5rc256DWTD+Xy7Vz0313t2TcX+sUZnYkuXLUYRvyWO/M3NnjEIt9WowCErpaDPHU0rXNhsOZBlnq7POB0L4n2B7RSuFg9smzu8E0HdzHO2clKWP9UMWxiPOWEbKW8Vdi9Nz4f2rcNlEEBgNYp3t0eauqDwg2HsLaE3UkCZiMoD2nqoPFnpsNYTokKrSNvluJPlxdWOZd5zGnOefC1Wh4Om/X4nD6idXAyzt4Q8iF+4E0pFvkz8QQUPtysehs0cSFStOpzT1HXP3RdblFO4k8XUjrG1xNbCqNj7CnUxcPHRjqbLJSwpUW3Czk4upSI8VFIY6dLhGkn29G1CeLMgyaReMzQZ3kSMCdh6nD2146gJ7wp4NuCNwe4EVfFlFJ65Al054lM+35vDfYnq9blxzyIsHa4Q7jKdwS5SEd8Z8m3PGApCJ89dtbdQBFbrlr6y9HlBterovlhirzti0DinYelx25FiMRA6S14KitztC4YmY3wr/vhNazHrgdzKWmu7HK0j4/OBybRATVSlXsMuYz+IXeEpKEzp2awbrA7c7xbs7pfs1JLVVprLN3cbQmexi4H6sqVrlsTtCJ3BPevxD2I5WV81XCxa3j6sJTX1vpbvLcP8TLO1IwbwQRFgbvTKfCQuFENrxYseOD3UnO4WcxO42rZ0fUa3K2TflVz/7dd2bMuW9+OSohYOOcDrd1tes+Xy6ig0m7uVaAIyT3CazSc7QtDs9jWPP7mQ90YmTjTF84bNquXYFGxePXH/tMT+pAKT9DWkJOirXqhW1yPFsmdoM/z7rybd5Zec9PP2C12kH//8M6qlWOnlO4V2FlfJi3b9J7/g9t/9SBC/JPoSO0R52HVboZTMBV7irBcP8uI1DWe6i04oW/L3Hpfyc3d/OPDsP5oeoBJ0EjXc/edHVr+RU+ziXGwDs2XfZBVIQm19qehuAiooNr+jyB8F7Zu+80MkC0AlDvdUoOvxHImugnDQiVC8tfQ3H5C9A2THcwCM8WdO/kSfmNxrJrcZgPXPIuEzw/5bsPxMHDzOhVtMyGBygimlOFv8zNL/wRb18Sj2bj/Lxbs9NQXKA4Wc65B4wHryYA8QkvBRGpYwi9bGWjjnE395tuSbxHxGzQVufoxJHCfHUewCh0+MJI1++GybPstByOXc2DYmS71pH9Jx23RelJxvk5I25TvV7NpT7KP4nxs179P0XVMTMtl6zm4rY8SnCm6mRMDssjMJMZk48CHO7jYTl11+Hg4fadafBsygEs0kzmt/2o/J3UYFqO6SUFWd/331Key/Lv934iNPqanTulZMhbGs0eIhTUCm6YADopwHM0S6rWb1KRS/pYn6zKOfBLhCf4nc/iFDvofqVrgFrlSUDyLc1qOs/eLe42ozO8KYNAmSBNTUBMLM759sFSf/dpUsPCcf8MkucToHtp0Sd+X8TvadeoizT/4kOtVOOPEhl2lNsKC65EIU1Oybnh/D7LyTf1Zwf3ct1Iel8Idf3EhC4SIfyLTnNBSc+pz9+yWq8Hz88oHeSSz94VRiTKBa9Thn6LuMxaJnNIZubfCIAtw/5RQvBnHSUYEYPfFkiYPwWg/fDdijhL9kO7mvJ0DAJ/RcRVBXPWU5ikWtV1D6OS7eFo4s8/QqI9s63GhY1D2nUwlOMbYWn2nCaKQItoGLFwcGZ/jRw42ITxUwaMxRoy96nm2feK23ZIXHvROnGPaZPCd0ZDxYAR5sFDpB4SkWknJpVEBVcGhF7Bm8JqQwohg0dtPjngrwIlh9uF1hqxG8Evtbfa4AwsWIyQJ+lwsC3uZoL17Y8jyOxN7QxgJaKwFMKIIO1CuhpfhRSzHtdJpKRvzaY1YjYdTEvfiHq7uCeJEK3iAdpj4YfJkacSPrSReeeMxQyxFtAjGDEMH1Bt0YAqQgn0B2b+nfXsj9fxXYPO+ovz3w8ONL4noEHcU955TjBkvoLaOJlOVIue6JgFl3rKueq+rEEAy3pyVjZ7m+OvD+iwuKi0587JEgNLO3QjHaG6LR5M/bLwECxy7HJmvN4DVtl+EyzfXFUa6Z9RwPpTzTB0226fHvK/IXDcu65+FuSXMoRZgcFXYhYUExqOS1nomN5fQ480rW3dqxe1hwc7Pn8UKayzxzmKsGazyrsmfXVKIxcBq7GogLWeNxl3E4VOx3FXnp2C5a9m1B81gLbeXVE4e2YFn22MKT5z3furyn85bb01Ler6OGhWd5dWJ/KxSq/q6ij0IBu38tTga+ioQs4hZJW9Zo8ncVp2+OIjbdlZIoe/qKKkd/uc3bL3SRPmzBFAmVtedY8P6FY9+XEpSSHgwT8qu9/J1t5GnhFolfmwovXwpvtN8CLnFM09h3QjmzoxQmqx8bnr4Lq5+DHgO2ge5Sc/kf5lLMbNRMB5joJBPn25XJ3iwo6rdQ3YrTRkihJ1MxMtknulIcZ+aABpXEbYnDLBztMz1GIS4MmAgGQhlQo+bwdUX+lKg+BYzP5HNcdRa9TeiZGZQ4e/iI8ZHNjxOKnwoVX5ztJrVL7iqVdPpNZeFRuEXr3zHCo7fn348G8gPERvZ/SjGdaAETIj0uE20jcaJnQU2ihgCzCFAKajWfD+0+4P0ne8zyQVIty0dxQZkoLFGDTvs3TRuWr8OcbhqVmgOOlGG2PJwKujm4ypxpR4rUuOSKfiPHawY5jtu/U+OrwPVfUzMFxZVqvvbTVGAqcidHkGn9ztSiOIUzfXAeFeLRHqC6C7NP+7Sv2stx+mQTKOi3iFAV0hQwCVtz2S/bRqIVAXGxi1/SMAQrLiw6pVBOuQKS+CkvyGkq1V0qVp+HmYsuUwRmncBEbbn67TBPFLSX4K6pmfKFOjcTnJs0kAZi8Taeg51SAyUFvJyLSRsx/Z4Kk9uSFOXTmv7QOSEqQeijlSkLSK010ejks1JDGBUqrWHTA7kIWUV0q+f7V33/wCoXh4ibzZHOWTLtuVi2fLrb4rxwpbs+4/nHj2gVuT8saA8F0Wls7VjWPSEqQlSsFh1GBcYU1hM3Avmbu5zu5+t50lg/P9I4TV6PjFru0cUnO05NgUqihWhkUjJPAwxErxj6TOz5akcYDX6foyqH9wZ3ytGFI7fSap4+sNBDgc/EmUVlwrc+ngputkdeXu1wW0PnLEYHjm1B8Jrb/VJogj+rCVcOnXtiY4lbJ440iBXe1frE29cXFMse7zQP71cSOqMiFAFTisWkysSvGxVxTYZejahjif+iJusU9lc6Lr7+wKnPaR5roeElHYgftPCMl56iGmcP7fZQYsuR0edEJ5aXKvfJMcdweqyEZuQV8THDthr30rG4amk/XxEqJa4eJkgCaekIp5zYKwgKc5BFaFqFfy6jIZ0STSkC+n1BCMCUeZFoENMzyTxY3CLIWjhIqMjd33gmz9ErTxwMr752z9vbDXFUhF1BrAJFMYojipEHh61G3jzU3NYrXl4/0fYZq03LGAz5pmd4KCEPIhLFEJ/1UhQfDCzE2151Gj1oHm0toUzPeuG+q8Tv15FTn8/UkrDLhcMfDL4w6OteJhxR8Xd++zN+eHtDs68YO/BNhu8LWI8M95W4GNkgAlwrVpfoCI3w+8ONwtiA661MApzi6X7Fzi7nez6vB+pqYJEP3B8WDCrCFyXxRU//esE7FvLsigq/8BJcdF/SDUviyuFHzW/efyKZCgqybc/L50+8vd3gvOQf6DQhyp+1/KGXr3nXLnn9V19h2+m5e362T8/S8bMl+UmhXIYLHV/J7fcJyv17sf1CF+n5DtQieYqPcHolz+W/7fuf8pOHK4pC+MumF8eLKZREuLwBV6rZd3sqwCZUzTZn1HdCP4eNfK+KgjTFNI7qrsH90SesCah/85qsEdFikYrqWfimz2N0FVKaY+LF6+5MbRnWZ97shDyYYXrpS2Hoi+QDX56pBMpB1k30G9j8UIGyc9H5+Ld74q8eyeqeh/crssXIcMi5/KsZtknCPaWIE4qu5L9gxT5wQt1DI57Sk0DWlXJM3aWiu4by5zndC0/x3jBsg/BYE33IDMzx8tN+TbHtaqJFpIeSOIfEszuJi3PxNwkroxGB6X/tz/w5/lvrv86tL/kf/0//FHo4h+poN9FaIqaH5kbQV+UTDeYDT3g5ucxFZXaKH9BimOkX82eGKBSTmGgShjnVcnKjGWvF4m2itijZ583vQsi1WP0lCs20z64Wp4+JT63mpkxQ5qjPhf2XLLjS7k/rdnIUEhqRFJfndZ745R5cLsmuwagPXFSkML/4wfnYp6Af5RONRcnf5cfEIU8hSjIFUPhMcfz4zAm3jezj7NWuzgi6GSJMxza56MTz1Em7swPMdH67K3tG6yd9weSGk1Dz+MH1nxxoZKqgaK9SQmmQot0MsuaGLehenFmevg+rnygW74SqZDrOHHzke32ZbtWk2xgX8lzITpFhrWbXH1dOOQ7Ja/2LBeqjE8NDyRfvK1h4eAanoaBpC6z19E5EiO/fidvLFBxEJgj5Q2uTSEXRv6th4VE6YO4zuY5ZhIBMXyJQeHzQ1JuW8QcbrILwScvuTuwajZVn0bhM68lK8zXcjJi7Imk4IFwiqHPtqJc9p12FLqV4Pn66TtS6yPU3Hzk04qLiE4VnuK8EvV11HLuCwRm80ywXPU+7Bb43IhYtAlk1Ml5rVGNEVJlFQZArR7Ec6A8F74a18LiDFF7UI3olVJjgFVU5sn+/BBVR4zSGgmAi2ScN422JHgz9z1f4TzR+lAeTGjRRBXHAyYIkO3uJjs+sZ1n24p/dG+Gdn6S7iwntDwsPXouTi0rC7yJCYzm5Ws5jZwm5xxae4ZjhokrASpSCdyWIuraRzEj4jxsNoTOYesQnJxq7ELoTQHNfo2xAHcRG1TQal5kEVImGKUSFOWn8yvPmzYUkaJaB7FUzB0BhAyYLLBYpuEhH/GPO5+MlcdD0TpNft6wWHQ+PBXHU5MuBIWihLTUWt5UJEd4QC0G9y5cnVlXH/dNShKm9kWmDF4GwNZ7DTnhkoQrYSylEg9P4ny54us75659vUEu52bfbhof9llgE6A3LF0eKzHFsCinYTUQ7CcZSoyLkkbs3G0wpGoRTU+CT9WFejWRJyNz2OftdxdNhA5WEOMStE+67AlaO2Bh0p8jWPcN9SXZvJVMiWNbfPnLKCsaUojsec959/gwdoctyzLMOvRzw+5zhvuSvvP4OsQxUB7n/fB3wC7kPizt9fh9fDLiYo3tFHH5ZDX/Vt1/oIn1cSkLvxDu3nVAQfutHn7D4oYy69ISQJz9oHcE2EWLERim6sqP8jKuYXWCGi0ksKvxcovCLQ5ZeyhpcFbFJcDj+xiXDtaf4BDY/SUjb5JAw3UeRmbYhwUdSpEhiYkL2SzV/h/JpWtAyu3EEkyz1xtR4GIXL5N+nYs5VCkISKk4CugzWPzQEs6Qrlpi/rZFxXu2ATIq3xK+Oo6CsgkbK564+j7N1n3bp34cwu3EgwKs8SAKUbwztx06S3l5KUbT+iRRK5eMZJQXZP3+hPmhokq/2SrzZowEfzwXr2z/m+Omf+N8C8Cd/8sf5q7/1Lf7RzW/wzluGaOC/e4v+l67OyZdOUOAJFSyfggT4dCH9jNjzueqMLE82icFKIWu6+KW/c5VijrlXZ+Q1GMXtH3eozHP16wW2jbhamrSpKA4T379Lv2vkekUjNB9JiA1z4qirdEJsg1B9PqAZfei4MfH7p20qTsVDXtBi8Ss3sxsKTj6ru5ApwySSndxpfK5nb+/JSlR/0ByYLsxCWtuGxH3X87+Xd6JHUF4K4eO3Ass3aqZrKXeeLmgPaggMa8PD95VYq76V6nuyAJxcYiaazO57iuKRMwUoNYuLt9Jcie+zIujzNGZypTn9gYHyxznFk6xnoeVAeSvnbtgoXv4F8EVqSJNTziw8Xalz8avPhbht0mQn3dtS/Eeqe1lvzbUR7UoWicCLrz8QouLY5eyPFf6LmpAHxqWHVQdRvJGd09xsj+zbkotFg/OGl8v9zPP+4rDB6EBpR96vVhIYc8qILiNcDmIL6DRDm/HiZsf7b+S4Y4Y65MmNQhIOoxafbBS4jUviY4V6KXHyMSqsjgzHnNhYTk85sfToMkABdjngvUbryOPjAlt4ynzk/nbNYtNSvDxgTECriPOaqhgZjeF4KlA6YKtALEXo6kdNvuoZc0uWe3EtqTwmxaqjI6G16FbjB5l0hMpTfBCxrlRk8/zA/rFGFSJcjU6jDpbRCXIyXol/p38qxF3lKF2YaoxQXzpDLFMR/FhRPHeCnB5y6A0hArXHFCPeGNARFRXaBMrrgb7PcKeMsHKCkD9lhNqjbEgBSUGQ8dxLcxQU6rYQMeHlQIzIsfdawo46QzCBvB7FAjIoulNOUY+snx1pu4zioqX70Rp/6bh8vufhdgW9Jnuw8/tJdRp1SjospxhCTvSKUGvyasSYQD9aFuWAAvQ2kE2+5l1O8IpusGQXPdoESc3stbj99JpQBEJn0IVMcVTpuV4f6UcrazEJeKtVR4yK7lhAPVAtezoTsZmnrgaePt1gDwZfyzmKWSA+5ZQvT9y/XYONmKMh5IHmWJBtPW406dkYsc9bykK8z0NU/KEXb/nR/TU+aIa9xH4rHRkOBYOO0Ev+iM493/jOW05DjlKg08v87UOBfsxQiXoX3tSQB8K3Gmkyvebwgwt5rmlQr1pWy479YSsTJa/E79167GWLc4a66jn86AJXy9S12UZxeXHyfJFAK0X500LAgQ/0MF+57feid/h90p/8Yhfpm4DbOilQJs/fXmMqx/G70D1JUlp2SFZ8jVBZfJHiyz/gZE+iUp/cVmzz5e+aC20N9TtpEOxR4ZYwLuWmW706cGBF/JmekVgzylqaitupaHaZFHyuSqjFhFbmImSVYJpIfjwX7rO1WyEPhmGVosvlnZCoMArbpFCfTM08ehCUMEtj9/rPVhBhXMm0obtUs6L8LOKUAiM7nUOcJI49NRKFnnm5eoTg5bzlezlf2d7iq4TKIROH8j5F2/up2OdLYlHbybnwycpy/y3F9ndTU9UKmjoV6PvQ8r/7xr/N3/GX/zQPQfG9zAKej1Y73vvLGYk2MIssoxa09vRcsfpcsfj5id33ltIsefneYBUmTlAv8+RCj6lYddJIKB/mFMzJd9yV8PLfNURtkhtGsok8xcRvZm4aJ+/+CXEXh5CUFlqYs1WjTxaQ5lxAwwc88WkJGWa60GR3qIIkB04Ny+TXLvSoOJ/n6i6w+5amfnv2Jkcp8SufEHQn62yycYypYZwEnyE704emZtQMEdvLec1OkfpWYYbUgEz7n+wYH7+naZ/HdB963FLTPteYHi5+EOZxL0gBrII0ARPFp7sWTrztEj0jm3423VuJR+5L2cebP5+lEKMz0j7RvbwSCo/tA7aX5qvYBZlgpXCmYi/hWB9u+SFZdZaCWmbpXhwXWpKLk4A8GrCXndBC+hyd0sXWyxb/XekCvNcYE1jkA6chx1vNqc8JQfH6/ZbQW974S+xKaBDLZUthBYkvMoc1HlX3HKqSj692OG9QKrJvS+73C2zuKK4Huk9XZDcd/SknHiyxDKjGyrlJvOaL5weqbOR+v0jFjCyC8rVl/L4409TVQNOm8CAbGE4ZpvAMp5yHzkKvhUKhI8WqRwHjYCV1UUdUJ3zdqenhaKD29MnScBw1xbYXq0In3HKlBeHOP2oxOjCOlip3YpOYCTWiaXNcEgBODhoKeWfEwCwqVl5R35y4Xp349NMbaAz582Z2NuE0hd9F2j5jaDOKdS985agYm0xcOpyWIi8PhGBoUhOknEIfMylWHeilBA2pZNdnclkDISjW24Zd0PO7J3qFLr0E15VOCsHHnMFm6E60BbH0DCYyjgZ3zLjZHjk9K9H3OQ/NBfmLBrvxnPRCUPjWorKAzoPo8keDLUf8YKhqmUSMzlCXgxT4KpLXIz5ocuux1tOeCpo2I44aczBQB6idcM0vhnSutUwDskAYNe+fVgz3FWoxwlNOMJGWnJhF7HJkeChxjUH3iuHCMRQ5ejPg1wptA36fYw4Gv/K0TyWmctLQJXEnXrN7FG63Xg9cXx4ZvOHpi7Xw9bPIX3//TaEgKaEJhYuRm+s9ufXc7pdsnrVsq5bRGz59dynX5ZjJ5GjVw2okHC3mRc/15kSMMAbDfl9Ba8XfP58e4BCeCpof14RLDwtHPFn8m4rwvONyfeLuR1cc+xo7iCaqu4qSXbCT5FGhpEJ+JwCLgvn5+cvtq739Qhfpy6/vcdkC9TdWc/KgLyHeV/hXDn89wqDxpSZ/EicUV0Kxi/hMCiJfyMj79HFCCcfEkR3Oo3OdYscnl5Xuipm/ne1ALcRqcTxuWR/h9BLqt6k4SY4fM82DiSsdZyvECQkNJqGojRSkU+GQT04oJEQ2S0FICYEc1md+sAqCCOsxMq7E51kFKf6LB/AbOd7sJE2CHlJ4E8yo+fKLMNsYmi7SPDNMtmz5IWA7EQDmJ0HaRXwoqGH37YHhIWfxafJXT8FJk3ON7SL5MdCvtdjYIX/XXyjsSRGDiE8nMV77yYirLVe/KQXgh/SOtRYo4fqvw//zv/wr/FPbz/n1TvH6f/ltVHHmL/tSz7SZyS5x8zPP/R8wEBcz/WIOJQrysFfhHEVvUoGuYuJPKykCJeQGohZNgRkTMh7jTC2ZBJkqihBPJxRZuzg76UwF5IcUlpkXbc/+6lEJYj2h+BNSrgI4q6RZizC54Ygdo5p1BhN9arY0TN+vAmx/FOZ9Fy1F/FKjEM00OZDfzU5StE5NgekCfpMccNKaB7nn5FwCEwVpPH+eCGAV658H7EnjFsypsW4Z8XWcpygqTJaXsp+TKDRLoWZy4jg713ywrmfqWmp2bfIvj1ElytP5Z0L6PrHvPK85nyn8hRTf3YVYTfYbOQdEmcqNK5nCjXWyo0vC4el5Mwl442c1fR4ZgnBaVeGpipFhlKTCoZHi58mLfavKAlnpuFqfoO74ZPXEZ4ctPiheLA9cl0c6n+GSE4zVnp8fLsSFY8zQRJbFwJAbynykykYGZxletCzKgWXV82gX2NxTp6JcfLAtj21NM2Rsly27pqRY9/S7ku6bPQYkvEhH8tzR9xl+MJhChIG2HCkKh15J+M+iGGgGSV/0vcEsRmzm8bVhs27Y7Wvi+0Luq6DIlsOcwGmNJ1t5TruSOCqiMqhO03e1XNtBMa6c0C7aDJMF6rrn0GS8+Po9j8ea7pRDY9GrEX/KiLmALARFs6t4HwS997Vm7Ox8HVQhyLexEtQUg2JoM3G0UaAP5kxPuxzISyfNjELEnktxFYlO6CBql4s1otfEwRDTpANg98WGaIOIUjsLlZzLat3RPFZgIuZmoK57+kH81d0pJzwUkj6t4PY3nqPqAM86cEYoHKeC8o0lWItRIlD021GccnIvqZq9uNoYHRnuKtRNZHXRkGeOw0kCfJo2x9hAHDW2HvHWEEtHtRhoDyUXV0cp7Fsj1J1TJgLpwjPcV9iLTuhNUQpvpSPBadGljJpwORIaw9e+/Z7b/ZJxNIyHnOgtZm9Ag+q1CHidUHiKTc/QZHLORk216Xi+PoglZ1DkVx1DnguqHyGcMnSrWX/7ieOpoHeW27s1sTfcnjKOq4L2UAp9LPdihxkVXXcWpMY3Fe/ThMOcNFQBkpg5FokT70Vb4OooCeHrQKg9IRrY5dy/K1FBnu/D1kuw4kkTWo365on2sUA3BtMpfBUp7tVsaKGGL4MEX4Vtst39//n2SyT9q79V/+cNmSrQLmCGwPs/bDENMvY/pRGkgrj09BvH9j/ORby2Vbg6FctJiLj6iZq53NM2cXfnYqMQLvbuO4rxyvH8Lxj6jcIMEvutR8W4kALg9JE6O0gkazfdy/7YJgnKmBwwpEhcvHOcXlhcpSiegtBVxsi4NBQ9M7JtMqFcjAmFn8bv+SHORdhYC3928QWz8HTytgbmYmtcyHTB9pGxkpu/u9QzR51CxIKTcK7fiPBN+1ScJJ6/T8ho/vOC8iF5Rk++4wM8/VrALzyrH2Z0vcF+4JUelbjOTNoAr84aAftgKd/LeZczBn/kz/yT/Kv/s3+Bv9R+k3/h//APsW0C//qf+a/wryMCXipBdWd/7A/uZmmYZIIhQuOzB7ryUmT77IxuKx9nRBaVQpUW6lzAm5hQU2YB6xR8JNOH8/VRPqLnQB/5PJSg5HqQon6i0Zg+SiHfMReQk1WjqzTttaw724pF5VirRBOKc7GfnTzRqjlpdFrHYSr6/QehQul3pmTT139cnCd8Z7j8iznlU2AKlpoQ8m6r53vGtiF9R0zTqTg7BU3ItkoTkqlhPWsU1LlJiUkgFWW9gsLXpLAmaThmy1Ct5uyAaGRiNNNiQuKxG0XMYPLFn0LKzHieSk3/NgWZxQBKS0GeHeOZGgSoGMVlRiuWXwROL4X3m+3jfPyhU4zLJMDOvtxYzpO0BVz+2h0BxTBaqnzEJDR9sRq4Py7QC6Fq9F1GlgSZwExv+fHTFf0oN/TfevMc/+4bck6vO4pi5O98+QWrvGd13eOC5jhIp98NGauypzCSxGlt4KJq6L2lunni3eOap7slT8DDqmZoM5SOXG2PPJ0qiszRDxZTOcJdgbcWX4SEKEthvVh3lPnIsS1YVj2ldXzxs2tefv0eowPLYuCiaukWGXe7BWYKfwAWi479xqBMIK8cw0OJSuhseypmv3ddO3xjYenRmScrHGNvwYvDx83myKErJP795ojzmqvViVMx0i4ySXu86Bje1jI9AOgM7SjuNXo1EEcjdJAsQu6ITuP3hnapMblwxBfbhq7P8EvN+FBKcb3LcHcFGghlSJ70WjjqT1buhUU4U28i+JM4vOjliNoMBK+IJ0v97ESZO5zX7G6XUoy+r/Ct5TAkv/fCky0HRpXha6EK5ZctymvGJ7nu7WerL73b/Ecdz2/2GB04dPIzozOYLMh5HrXQSqKi6zOqfKR/KlE2sL05YnQgWzZ0znI4VBjr0TpSr1t2+5rFtuWkS/CKmAd05mWNIPzyU1NQrzpO9zW6lCZEaYRW5BRkgU9/8IKbb91zd1qJO05v0F/vGY85H318z91hQZmP9ENG306uC2K12N7WfDZYvvHsntw6Pv1sDVruH5V5Lj/azZOW8LbiGIWykl93jG1Ge1cTTcQuPZtVS248d7slvrPYtzno9M43Gn3Tk388sKk7CuMk1ZVUrDqFX8uLTa1H1LtS9LhZ5OV3bnn9w2dC20Jx+Y0nTp247MSTJXxaw1omKG4RiUvPOCRb0h7UB4GIv9y+mtsvdJGu+0ishfbhC8vmR3HmzbqFZnw+UlZSmbSnQgrAqTjoRdw1rJiRt2Ah6z9wheAsXJsoCirdHNnPLXoMc/pnyERoRxTB6FSojbXwVlUSzQnSnT47iSXHQhC29trSfBQpHhTtjaAywycDxacae2QWOYp1I7NjjOlFrKa8SgVInO0jXZkKES1FfCC5j1gBW6c/+1R4mzFRPhJYEI2gikQpCCW2XawGbXMuUCGhkIlXLgWWnJvu7z0RbkuUE35d+xyWPz+jm1HDsFTy959C8wrcN1qC12Kx9VDN3OfJReYf/9P/E4JRbNXZnhGEggNnkaVEzmv0+CE1RQrlxXtJJg02CTGTBeN0DqTYO0fanwvLOIcJSaKsoLIf/jwkjnKVPL/VxKlOPu3JlWUqULWLEm6iztQUNX/etC8hherEeeJDojsdvg43vyHNxlwQF/a8L8O5gVM+YpIHfrBRil8Nh481h18RTsvismEcLV4ZCYlykbHWlI8eghSkRJ2QbAm1yg+ekMm6dVVKdjUwWmmyvpSmOotP1TzxGGvF8gtP/f4DCpiCN39/uj+1/M6XEHV1FlVP3uVyvpNgM050HfleM37gUR/FhlV7CccyjfzduFRzIzou1Uw9Gxcq2U1qabhQLN56hpUIA/trpHFOz5fJCUi71LAlFH1cM4c5DaPlsKvYvGxZZAODN4zBMDpBw6tipMgdWkW6waIUtIPcnOuq46o+0Yw5Y2FY3Tzw89tLnl8caMeM//BH35LU2MbA0vHy5SO7ruJmeSQznp+8veH7r97SjRk+aBbZgAual5c7dlXJpupYZT0PXT1zcYtMisWxt5T1QHeh4JBhFwNjk7G6aDg81oy54bQroTNsvtbhg2b1XPj0N8sjQSluqhO37YLnFwcRFNqRwVu80eyPlpgF+s5iks2ga1PKabJ91JlDlx5tIn7Q9GORIugVu8827J2so/1mMrYHTpZYBOxi5HJ94mEvNnjmZAhFFDGin+Bw+Ojje253S4b3lQggLUQr97M7StrzTlWoq56wk8h2NZgzta4QTYWK8t2T+8qMgGqEjw7og7zOY6UI+/QAVtC8WVJ+/YmmzSV0bDCYy566Gti/XxJ3GcNmxNzmWC/psnqAcbeUdWyFohOXHkygqzXKRD5+8cihK2j7nLoUF6FV1fHQZ5jMk9UDWkfWVce66DgOBS8/eeD2acnxJA48xkqjst2c6IaM411Nvh7QJjAMlnrV0exlZBofUgjPwhN6S/Bhpk2F1pKte6wNc5McvCJmgdtPL8kuO0kBLQesCbi3FZ///JrqsqUfMrpdKc2biWLzmTiAvrP8+LNnmDxgryWAqqqF439sC9wgtpz2Zct4ytBJ92COlrAdKZaSxLo7VGLZmdDx8cphFiNjY6VpOuY0j0uaRSlTl4T0K6fQo8IbBbUnr0b6OkMNkpL+xe/eCEJeB7RTPP3wkuV3nhg7i12O2IuObdXz+LQgPObgkj4nPce+smjyV3W//v+w/UIX6f1WkxlFsYuYOz8HrRBh8Tmozyp8UQl31clLNzsxo5xmlJfzNKLMD5FhmcRHGsqnSL+d3BmkmA1KaCPBQHNzHoXPIsuElE0OFMVOVuu4SHzY4izyDLnEsbtSeNyS5hcYV5qLvwXv/z5Pve5oPlKoTpPtDNlJ6CkXP4gSzJMp2mspQoZ1cqfYKIaNFJCTY0zU0DxLDYMXYUp2ijNqO7naTD7Ttkvc8/R3MFFzpOBy1RnRDIaEAouYNn9Uib4j5yz/KwuKhIz67OxFT5ioP8we6odvRkIeyQqPSVXdcFHOwsUpVCZMQj+t5oJ8shqERGdwzAWoq/XZLnHiHysYa6Fn2FY++1zMqjOn3AlqO3HSx4Wei72QyX9OJReaiJDgkfM+LuRcy/4yu9eMtZ4bSjMKJSIqOYbuUlG/C3MYz0SpmUKYpmbBW+guRCS5+jl0W41K3H1g9o6fvdGnB6dS3P0hScy9/s04N6nti0ix7Rh7yzBYYlS8+LPZmYvvI/e/asn38pIwKZhn9pi352OcCnTlEbeK6asnykmQcyqcf8Xt3yWNm22lEUOlcz5Env9HaubB+ynOMqqZcha1WKbm+zS5GGQNf6jlePi+onovTZh2YE/y3S6JwJnOkTrT3JRP7j6JqmKbVFivFLaTRmHymUfJdZ6odOPiAwQ9QNZD6Jmdo/rriI+a06nAFlKEn8acwVlu71eU9cDV6sTr2y1VPaTY+kiZjWwr6YB7b1lmA6Vx1HYk147PzAXbQvjZ9/1aQn+e93hneP+4IgZFceUwOvBf+s4P+fHhiotFI43BYDgNOaV1vFrv2eYtf/31x3SnnDhoVBbJ60HcWYA2CUaViYz7AnMy7P0CZWRNba9OANzerQiDIVsOuF3B8XaBWYx8Hi+EF50sOqcgH3kYC1Fc5UKFcJ3FVhLyZDPP2CUuu4LYTyINiNFgLnqWlyecT4mW1mNNYJX3vH7c8Opix0NT46NwpatXR5wzQrNInHEqT9SKh6PQaMxVj38o0JtBkO+jlXv9pmezbqVojVIMq6AINhJzsb3FRMx6EJ62E0KxP2Ti794a8qsW7wx+0GQXPeOt0B+IiF3g0nNsirlIjHcFETishPscTUTtMqHsRMh2AvrELBK2I6ZylMUoFKpTLp+dB17fboleERvLQAlB0emKj791y9uHNSEqNqUImnLtOfY5u8cFJpORV+gNeeFwTjOkiU59KcnfMSqaxwq1SQFHeZBGxmmywlEUjq7NiSYQjhnZRU+M0L2txTWl02fOeKMZKRl1RNWO0FrUyoHTdO9riltDbmBcybRP1YlPNug5mVcogAqlYBgsH189cuwLxtJwVZ/44nELi5FF3RPXsMuT9uKYM4QCXTj57MagOwnzU28tFnAnQ/XJkfF2hdoVjCs5P9op1Ki4+YO3vP/BDfqgiV/krP7gE4f7BSGCHnV6Tir8MqBbLf7wQREfClyvuL8pKJc9/Uah7gr0CNWv7Dj+fP1LXvrvg+0Xukjf/dGWV382l2JrqVOap4yip1Ac7SDfh5mrPdaJbtBHiJHqTl66Jo3kzQCqjfOL12dQJP9x4VRD+0wKEdsk4d+QPKfDmWM8LDXFPggVpJRC8vixkvTHabzeQpXQ02iheS7HVTzI2PzlrxuCXVFVSWjkExqpmNH9OfmwSA43LdBB8RjpLtXclKDk32cedEKvXQntM0W2l6ahfRGJWiKI9QBuIUi1Hib+MJS3SsShiR7xoQd3uBrohoJQyQOz/lyDhmEBzceCQqAjF78lL6topLgftud0tZApXLMkpECRq99kDrDRXoqj2RlmosGk2PYPudOTCHOKtP8wWGr6t8lBZtILRK3oN4r8mKwGU9qlK1Xyw1ZzGI4ePSFLSaK5rK32WlPfhplGMouF0/eqhKpO4VGTW4ziPLWp34XEGZcX/nT95nNthIIUrIIgzZceJcJetARyDqu7cOa3J0Q3pBpk8+M4T2OCBd3Ai78YcL+xmJu00zOF6fzc6KBg+2P//zFpmq5FTBaOkyPPTJ9J/xasnMfddxTFAxRPyc/cKnHkeDKzHgDO6L/pzhz8kMDUaX+ikabVtueJkS9kP+wAfa4JhYi9VRAq1SRknhJeVRTdQHMjvvD9ZcT0isu/eb7XzBBxteLwiWL1mUxSxgWzY0ywku46LlTSYIgIOmTJOaiAcSOicNOB7hVPv3tJ1BG3HenGDBc0TZcTg6I9FOj1kbIacF5z+34jrhtXDfePS7758o4QFbftgn60HLuCvs149eyJw1gwOMuzl0/4qHna1SjFXNzu25JXyz3/7m//GspK4M7xvmZzc2R0hqf7Je+z1UwrqVcdzkmBN3YWvR54dnng7fuN8JITnzsEZHGNmvFQs4s1XAyEwWAqx+W64VQ4nq0OaBXZdyW3xwsuP95RWIcPmvLFyN1hwScXTzy2NbumlETVyknEO0EClJLo0dYjzmQUq54yH+mGDO80T+9XUuQZ8eHWpePBL4mj4T5fSFhN0BTlOLtsjE0mtJaUDqpzT7svZT0eLOa6wzcZKvNScHaWeMg4vC4JRRSUFYiFx77L0IORrAoFsakIWvy6Yx4oLjuGowhKfULu62cn2mMBSxEWoiAWAb0cGTt7jrm/HIijhkGjU4MyP18CuDriLtwsss5zJwX6uyo9fKIEWXVGXFgaw9Wv3HH/uGS56miGHGsDq6rj8VRRFSO/9e4jYm+or0RIa3SgyaT5CVFx3JfExorQeOFRuUcXXqwN84C2QZJMX2eErOC0EP1JzCIqi7i3FVwMmORkky0G4ZfD2RIyEw68MuK6Ium2iu6l2D5lqwHXWXQWsLlnbC3GRrabEw8PS4pyZFX1vPv8gjdmI6FLOuCDZl133N6t2PVJ26Aj0WsW23Z2zlG5J9+OhJ8uMB10Xx8pNh2Figw/XeEuHfbRYo/ybgt5xJeR9z+4ER2KUwwfD/gfbTDI/49GQKmoEYeilSf7rGK8GVE64p+ltNV3S8kKuOrxj/mchRDKryZkPb2Xf79/x38W2y90kX7x75dzISDWcDKSn/ytJ7u7aASJM31MiZvJ1SWhfoIuT+ijoMRRCe1i2Hra7YB6XbL58cS5VfIuWiXhWaIyTMU1CAVAigXm4haSK8yJOUJ9WCOUhRwZU47C+W6vRZQ2oXl6lIJm4oZj1OxrHbKzr/rplRxTeSe0m0mgOqwVrgLtz77Nppdgn+o9tDdQvZf9to2iexYl9GgQxw+QIrkToTshh+ou4ooPwl0sLP6TQpDuTn5vrGTMbzsonkRcmR/UnGgoYS+QP31AkUmhQk+/KuPi/Ji44FrPHt5miHOhOBXnE61g4ndrF/n5n1C8+vPMXPwpCCekUBo9yrmp7sWpw/YS1mNbaexs4xN1ItF8Sj0LNoNVmD4wLjQhU/QXiuruzPOOWgrReUvIv0x7JpqJOjce0+E4vuTiIqjyGeENpRzHxHfXyd5wcs3Jmii2k6mRE0eaODvUhPwDC8Nvy+dc/6Z8f34MhE6lQCTZR2L8EndcjxH8B02aPzdKtjv70/tMYSeqR54E2i8V3Ucj49JS3THrPl79OY32slMuOaNokth30m0oCdgC5muAkpyECcHPTnId8xMo4oza6zGt+WR7OYk65cMSUt5Bt4T8Sc2NQMjO3vHZMXD5A2nEfJbO/QfUJtsodr/muflLcuGGtTT/eoCig/JRmozuCsYrR7ntpOh9W/K+vUDVTgLAcmlCP/3JM/F4zj3VumNV9Zz6nFfPnrg7Ldi9XrN+eWAYLUpFvvb8AYBmzGmHDK0D/ZAJZcxpvnV9z3Vx4nWzxgXNNz65ZZX3fGPxwN3zBT96vGZRDHzt8pHXuw0v1nt+9MUzQtASnqMj8ZARy8Db9xv53FG6nKxyjF78zKk9LCR4iKCxT5Z4NJirPVfLEzEqfvz5DR+/emD98kCdD/ig2TUl73dbYoQfJp9sBrnfxtGAkSJtuie0Dfh3FbEK9PcVvathKQirMiLsVL3GXAwUpdggZvXIuup4aipCkEIdAuNoyOqRsZVxqRo1YZ+Dl/cDSOAONqBTwJEuHDFXsB6JnUE/ZoQyQBlx18kKqRNBaLHusdbTtTlhMPQ74YCroAjvS2IRaLIMTEBngbgeE43H4NM+TQJbrSODsgRkiqBHlfIZZC3rUc1Cw6gNjdMJKEhCZgWqjHDSRKXJvnaURsYGmjYnzx155risG27fbrn8qKF8tmNMbjOLfODzdxeE3mJqQZ+LzGEuAl2foVRkGCxZ5inykd2wkGYz87hvOfLCEUeDW4tF4rNne97frskKz8Wq4elUYU1gUBB6g1kNMoEIIrpVAcKYSeKtFYpLvhzEcjMLhN4wpHXpB82xLdA2sKk7Dl2BysWzX+lIsy957eVFktejrPMoRXp/LOh7y3opTarrDcOhoGwU3QuhDrmfLIkZkh57EpqTdjCu5cGQHTThGy3xbYmvI+Yuw7Tyvu6/3xJ6cT1SoxgngJHGxSkwyJqykfHSUaxFi5AfNP6HK3QWUXvFL7ev9vYLXaSDvFzzY2B20xikQOmuhHSt0xjeDJOgThCu5trgaigfIyR0Uvlz4BEa/LcbchMYbitYCEQ+eZibVvyUp4AjtyA5fwg6Wz4FKapSt9ddGpbJa3zi1I4LhU1It22Zk8maj2XUe/NXzwWc8HzVTKURG7mYwmqYA4VsclORNNL4JTEjeXKXiOCDonyMFHspChev5XvKB3ngr38kN38f5Hhdnf77pEP/sGTUEJ+Jm4VywvUNRlEepFEob+W8qCgIuRRz8t/xE9j8aEIxI9VdZFiLq0dIyKh2UNxrxo3i/g8oTCsTjOq9nOP8yCwChYSk+1RUcrZ21GNCN/tE6/AREhI81swe+ZOvdUz8+3EhtItxmYnTTpqSTHaLkATBeeJJB1j/TBDwye3EFYr8FNK049wEzk4+8YwKz372FhE6puJ4EpdOYU/TPhDPKH3xKN8x+bD7XKH1WSRpm4AvNcR4thxMQsn+OmBaPV+rs+vL+byaAfQQOH09Y/HWi9ZiIf7pwEwzmhoLnylC4v3PfurDtL6gv7JpfaWpR+JuR8/sLjNNGGBKdVWzoHTaggImCtnInEtgO2k+s+N5Aib3zRnZL5/SNOZw/ryxVmQHaSiUg8PX5H5ztaK6FXGz7SLFU0CPkfbazFOpqMRi8uI3DdNoQTt5PthGGqdxIUJt3cP6+kTbZXBXoEY5B3npUB9JoeBHoT+ooCgXwg3uE08dIEZFddOwKAYK6xiSVVzoLbRimzgjyTZiq5Efv7/maV1hdOA0FOyaknes+K2ffkyx7LlZH3n/tKKtMro+4+1+zeXlkUU+8OZhw9/73Z/wH//86xAVdd1TZiN3Dyu5Xx7SA2glCGDorNCcBo0vAyoo3v2tZ4QiUL84srk88XgSW6l9W2JN4GZ95PN9wde/dse+K0XEqKXwGx5KojdSfE8JnscMbESNCsrwJaT12fMdu6bkYtFy+ySjk+Wio2kLOmeFapGKMZ+qcGM9eT2KK8zFgDtZVBArRdXpOQkzBhE+Kh0xuRTNPtqz5d4+k/NvhLajc0+ROxGXnjKydY/rMkzu8YMmFkkw0Wt0EfCtxaaC3FjPcBQU17cWbYKg6gppmjYj8TGXQm51vjn0qCTsxkJ+a1OzLgCTVhG39OjtgG8yciuuLllCxgGc1zw0Nd/8+jt+9uaa5Uo44d5rTm3BYtlzStOZ06kUDnv01OUgYuTMS2CSjsLD7nJs7giDoRu1WDbWjuWy49TnXF4dObYF7ZCJ97rL5ilxeEoP3JROShA3F20DDBazswyNQa1HVpuWobCMg8UfMvRiZOwty2XH23cbiIqPP7pn11RoHTA6sF20vFgc+J27G2KETS0Un7dthh8NT0+1NGylJwaxXM4eDfEwgUaSpMvJ4EtBz1GIk4uJ8HmJ0kKxC5kU8COg35SUBzGxiCbOzyrTKezJJuF5xPaK2GnMZQtZZNj6RJOJmF/94AH2VdnSdfvlJtsvdJHer0WUAXoWfk72hpOzh3hTC4Vh2nzBLIwcUmGcgKLkl5sK4buSzTcfGT9yGBN40Bvqz8wccNRdMSN52QnqW092dCxei4DR9AFfG+EfJwcXMwrPPTuoLwvekBd69R7qNxpfQHMj+1LdM1NbYgEqdfs+16nQjDONxhVSEOhRkivHQgqNLIk+y0cpNI6vDM1zQajLRzl3w0p838s7KcyHNQxbOZf5XpHvIGQF+RMijuvOLijRyD7uviecdPFRl4LHR0ETVRLUFQ8psRXQmWJYCbKenc4iQJV+p34nxY8ZItlRUz6GD+Lcz0E/tg0cXxq6G1h+FolKGpLlz6C9FtQ8P5wLtomvHXKZIgStKNLkIlgodoHTC5MaLVIokZotHCcB8MQnnwSeouZH0KTnguhO1o3Tmp0SOmcLxZTiObvRRIgJrVMJlTYpgVQsPWMSMMpnHT7WLF8HxqWIlyc/7vd/X0T3Gu00+Xf3NI816mjQg2L102maESS4JjkNgXz+OXRJxKq+FO5kvxW/7+wU5qnAJOYEZmtEPZyFsZOIOVhNfojc/DXSQaZfSnSkaSIy3Y/KTwX6mT4zpX3OwVKTxWmajAUjTZke+ZLd4RQ0NDn7+JgobyQaTC6Nti+kcfNFWmMOqtt0n7fnNFZv1PzZPpvQfVmrk3WmTMHkUNsrNWcy6ABtn+FuK7KTjMYnIaEbLFnuGDozF25tLwhAtBGCYq8W1JctzWNFZj2FdSyLgdWzHq0ix77g5XLP5/sNm6rj7dNaEPvScepzvnt1h1UBt9Icx5w3dk3XZ+LwoeBwLHHHjPzaibjOS6rm33j7Cp+Klf37JcdWAl9iluiBSw9OEw8GtZAEUBXg8htP7I8iHvz4asenn1+jM4/NPS4hxcpE7p3wkD/98TOICnPU+GUQEKUIqEGmjJhIfX2i2VWCfh9zMMKXLwtpck59zqIUwdBq2ZEbz/v3GxabloeH5Zkf3hsp/nJPd8jFs5yIvy/kzzZiFyPe5YLq1k4KxdYSskAYjFBQeo2+6AmnDKnAInTybNLvCw67DHvS6DISmgrzvMP3luiUhPM4SW+9ujhy+3Z7jrmPQO2JrTQ9wWlM7rE20D6W6NLjFx5zkPvavRhQNojIME2X7Ck1zAvhZiunKH6W4+qIqiRQ6n6/4Gp9wujA46nGmsCy6MmNn6cXE0r+0cUTb/drolf0+wJTimvLuYEEawJ1PvCwW1KUA24QS1GCQuWBmJ5zh59vMK2iKeV5sfruA/1o6Xc5tnYo46iuB067Ss6RU2JH2Zp5v9zay2eeMtoi0ZZ6jVnL6FGbIJz5qKjWHXf7JVoHPt7u5d+JdN5S5wNjMOyakq4R2pk2gWoxcOrt3Bz6MuJvhHJkTkaK8SGXpFETISb92ccdcdIKAP0LP1s1ToDepNuZfsYtI+W9vGP6y0CsxNHJ7C3tmwX5k2FcBfzKoU+G/qn8/1IZ/XL7Km2/0EX69qcOtQgz+jkVvJOneTTi1EGMZC2z0Ct08tCyXZyt47oLTYhntM5livz5iX60aBUZnUEtRtrnSiJ6kZdtyMGPIjTttprjSxljThxqcQxh3seJGz4uRaiqnKAdPv2MHkRUOQUh6eHMI5+Kl+LJi7WbUZg28PSdDFdOhZCM2cvHFGhUCuVCj+J93W8UrpRiorqLHD6ShsA2kdIpXJtoA0cJuBmWmpAnasoQqd5PRZJ8X78R9LZ4iuSHyOovBbqtxtXyHdKYnOkoZgicRiv84XSeXC0e15Mln54EiUnwGpIHdfMSzCiUimGpEtqcEMulFIDFPq2FGMnT9wcrxwzpmncRMwSyxuCTeHJYpuTYhTRt+60RYaSWoKdgzBx+FY3so03i4In3bgZ5oE5F24fpn9OUBq3S2jgXoGY4I84TvQJI7iXJzcSDcRFtEmVHT4ixpniS35046D6Xc5Q/b/FOEz+raG4XqckL8GygbWrGpSTa2aOcIzuGeRIxucxMjURMxyNF6jQ6F+oMSRQ7LLXQXZKN6emF5vQq8uyvpWOV95fcA0ns64spxVa4/jO9RJ/Pw3QvRaN48w8G9KB48f+SpmmirLQ3QpnqL4VOJg9G4ZjrIaURpymGbePc9EKixKlzmNdExVq8jvOkY1yo81oOEu7lM40rpmt91npM136iwql0DChxkxnWJKeQyHjl0K0hu+lY1j2HU0l3kJsjRrBHjdt6im2H1hGtZWz/cKwp1j1l5nBB8/Z+KW4YQYETHrr4WRfUVY8bBIUvrCNExbt2yf1pQWY9x0NJVjoO+wqTBfLccfXRifvdApt5DoeKrBJes16MVIuB453wzWlE+MnSpUWS0HQTib0hKiQREjnfn3bXkpY5aIbRYKuR8qoRb/WnQn4/oc++Mnzz4/fcnxZ0Q0ZdDjx9tkFlgeb9Apxi7PWscxlOFUNZgBO61ikL2EpoI62KVCtBSJfpf0dnGHN54BsbcDqSFQ43GnFwuS2JJuKbDMrAxdWRpssZTil8qdewEPtH9hbfWXTtiPsMs7eEPKCWjrBAUNjLQBw00Wvo7BltfMxlOZaB92+2LC7lfMRCER4LylXP0NvkI64wVtDf7lDI9VaRUAXCIpIvBqz19DYQbkviwuO0cLdNK1QRtwiEXBG2I4uLluNdjeo1775YiCNNHok2sA8rVO148fKJMWiqfGTXlLzZrXm+PnCvJY00BknP9EHhekG/xlEcirabE4emJDiDKRzFshdR+qjxnaV40aB0JFORPHNCcVOR+qJlGCzGRNomp163NPtKru2oUXVqbOI0XYtklx15LiLZtssITlMtBrouwzvL9vpIP1jKYmSRi5PRMhvYDwXNmBNQVNnIsugZSvl35zXrquN4uxC0PBMKVTxZzCjC0JhF/PUAJ4tpkuNVGSmqkfFtIfTYPM6BiTGL4BTDViZM9qCSGxewdPgin4EgvbezLbRpNMMmSMOaBUKl0PEDz+iv0PZLn/Tz9gtdpAvXNKSRuTqbV/gkBk2+5KZPnNI2FcKjvKSFtqBn5M0MEt0tAjVF+W/WjJWaEwLrGnz9AZ9dpSI8k9QyXybENIlHBZ2PydVEXuYhPzs8tFciJDW9oOuL11L4+eQYoVIM+rTgfSahOs0zi+0jw0IDhu6PHXA/XbL5HTUHNnUXitPHkfWPVRK1kgSLkB88ehCkPUu+8uNCcfoY7HcOdLc1F3/DcHopDiAm2Qv2WxHFzWEsGpavI74QhDhrYfcNKW4ntDqYlMqoJt9yTfPig+AZLcVMsFIAjbnsp+kT7SBMFA/5ndl5I0pjtHjniEbRbyThUzkon/xMfZCJgqG8d2ifRIqZvMSLnefwSm6h6t7TXhmKfcSVIpRVURB5E8CGZG2Z6EeS2nl2DwHoN2Y+zzHZULZXOhW8ItI1Axw/0uKTjhSM8kBOFJTuLDrFxhk5/pASMzVs2kN3IQ1Vv9FoB9WdFx2CB/3bS+wIzdedePSOCi4FXew/GdCFx/WG8VIz/B09q39fRKO+kGCjWYg7odmJ361m15iUGqrkPI8v5R4LScRb3Yowe1r7U5DQGR2XdWm7NMHIVLLNlEnElxF2BKHvNYvPFNGEeQ1qJwW6itIAT9Qse5Liflwin+WgOMj59fkZlZ/46v1Wzem8U1EvfvLSUPdbnfZD1iwwhz6FZDMZjGJyUBoTbcu28nyYnlm2g3Y054J0Z1gvW7F5azKx5HvMYTvinw9khWNo8hl93rclRgfWi57HU0WZj3zn5XsempoiE6eYwsj/7vuSddFxWTe0Y85F1fCj+2sOD7UkY6pIddHRnXJs4cgyR3ssaO5rzGLEDUJdGE45Jhcnl7634phxyKQAKQMmC8Q3yWrvRgQy+UpCiPwuh2rq8MBse8KoiaeM0SniQvYjmjjzi40OtE85n99fAHCxaiSg6bIjBo0LCrMcBXn+2SXltQhaTEJwQRIgQ1AoFekG8b0mwurFUVBhHVE6oE3E9UaoH4XsZ146+uuUJjpo1lcNT/dL8nrAFJ7tzYH729XMfc8+aoiva3FsWY+EXYYeBfihlEUfbgtZGxHUVY82QYS3awlFIoqL1/+bvT+LuW1f0/qw378Z7ey+dnW7OXufvupUUIomgLGlRKKRRRCgSKBIAUvmBoGUIK7gInbJivAFQrIVCQQXAfmmUnJkmYs4sXBiQgyGIpUqqO7UOWef3a7u62c7un+Ti/c/xly7CqSDIoqNdg1pa+31rTm/OZr/GPN5n/d5n6frMnxnxVe89ALQe8PybC/2l4Pl0GdUy5bmpkZlAdUoQh3wTnTT9emBw9LC3qAbPXXGRs06QPYyp1lnEkTVj4ATFl99IDeefZdzOjtw6HMK6yiMo7EZp7MDHz6/FCY7MjnY5KetFAhtju81i5OGfrAizwF8Zzg0Ir1RWUCrSP+6lk6egj4KuCUPmGWPMYFnp2tePKzoe8vTJ/d0znJ3O5/W0mT/GxXBawZnKDLHfNaxWVcyA+AUoTc8dHN0LjeiVlFsJYecbVfS9BmHQ4HNHReLPffbmrIYqHJJWFU2YEsZfn7tTqQwPekxH1T4OsLBYk571HnAraVQbF/OSMQ62UYkLNGI7MhXAd2paT1M4CUoGTaOSarmFf5yIA4K3RjKp+KY1LeW/KynW4+DNV+w7d8SAP2bsX2pQXpU0C8FjQm7rBlqcb4wrXxBm/Y4QNfPdRoATCynEkAyel8DU0S9fIBIR+obcbTol5r9kxHQCzgfGUIghboIg+1mAiIPT0XnOr6mO4PFx3D7uxzZvaF4ULhM0V6KP7rPFMXD6MmtJk91FaA7VdSvI8VGColMy/Dn/p8vsEYAvmqgWMvgaXGXpC6HMAH98sYxzA35YQAsKCOBOC3ojxXx0wV1LwOE5QNHvblVwl5zlBuM4FEPou13lTD44yAtHK0nR09xPSQG/kSOqV8KwJpY2nStUImY80c5SXcqNnsu6aaDVRwe2cnpYwzR2T6z0/xBTBIOkj3hGACUrx3NpZVraxX9QtbRmOw6DuSOKal6BIlvFmhBHqJmiOnLT4Ble6LJDqJbzg7JWWaA3VPRcWe7JLOYJCLHNe0LKQr7uTzA++VRRz0y7tlWgJ8epHsxug5pL9dg9OgP39kxeA2dha2VIbWHnBBlANO0udiFrRzGBso/+pq7XY39p4skHVOTF7mKsHtX9JIXvxhSwSDn93BpuP0dnsWvMaXgCjOkIERUKtAiaTZCiQuTAH75u6s01kkAkoQHqWkAdZSpoODRP01MthHNvy9BNcD4+1uxNR2HkJWDUMt5tHsYnHQZxkHrMM4w5LD78YHH/72d7DylSGCSJJnk1jIW0tGILGrsLI1DsD6XYClXqSkgaZT8jMVWcBpVObSNDGeKu7s5Nhcwp64LTKswt4VIdkIB73biogIsyo4q6zkppKK43cz4tbs5xbwjHzxVPvDybsWs7hic4X5X473GmMC+E33voydr9l3Ofl0Sku49s56ut8frtxcrHZ+LxCIGAEVWek4v11RvDXzy6YUE/DSWuHTCLh+sMNA3BSEPYKIM/DkFhUTDx8aKJ/kg70VLJLwfNP3rCt1rtIKhFdb16qpCnwlovjjbcq9rtI7cb2vyy4Z2l5PXA0XuCSh2TYE1ojnu+kw85y8OhKjonSFPDiXOa5GBZR47H+gOGfNlK57kOsp/uadpM5anew5NTpZ5bm8WAlI7AVMUTuRIB0N2lx+7on2GmwWYecq3d+Iq4zR57piXPTf3c2GSS4frDHGw+Nv0EOozjI5yvjKRbIQoRcfugxPCOHcQ4eJrt+zagvaQgw0cXoqe0G5lmLF7PIhvtxc9t2k0fhawWy0kSSF6b790DM6wWVcoDWslgVrLwnF3qDmdHeid+J+HoBl6S14MtMn5x85FR+87YdKVku4EgNaRCLT3JfncUeYDm8FQvNUwL3uaPsN5Td9laC33+6v1UrzUo+LO1iggr8TtJiqpOpSX8Cbfa3xnJGF6lN5cFfJ1skiFUm/okyXsg61EHtbm+KCxucOawOANT8/W7Puc3hs2d3NiULg2417VmNKJROt5SX/uUYuB2Btc6iqZxYDJPP5j8eBHR9rHAd1rgk0ESgLo0uk9fsebOyv/psC0Gt0pQpPIn4UjAsFrTk/3GBXZ9V9QkP5b27R9qUH6MNNUD57DI8P2bUuxDsJ4rTS2i8Rkb6gi5OsUYW5U8v+OkhLqIsNcT+znGD0v7JncALundmLdhoUwl6OkRvTK8uXbnsuXeLYTQGBG+cYgrLDpkpb9ArFbKiPthdgZRivte7HWYxow1T75sXcCQJoLPX3pmy7SnGn6UwGJwyyBaC3HnW8ADYfHego+2j/JU3BNNQGZYaYmYK3TOesXmnwXwUb6Ulp42T4mFjniC+lADHOV5ASR8j5g+khzbmiXAhzHYmb0c+0XAjLHv5c3R/nMyJqPIHj0bh9xdvutlubrmsu/nyVwGtAusn3bJhlKZChE/18+BEwT5M0+sn0nY/7CT8OU/dJQPHh2zzKyQ6BfiCbdFXKcrlKTMw7I8OUEsKx6Q6ZxHOSUBFKOmvPUtZnSKoPYgU5SjtHaMB6PeRywHD833zCBvjdtN1WAh28o3LcOnPx3tTCRySnG1YpuKXpRZYWmydeaYMCfe+g0/tRRnB4Y9vIl1u0KmmKgKgbi77vjrjrj7Fel0CB1qXwZOfsVJgmRr+V+sk3k8f+gUUHusfHYR016eybzDGMhLPIl0WXGkmmegfh5Nt2nECKVzq2448jrxqHabHs8d/0K8kHuTzeTmYGxgENJsq6KTHkKwnYrmktZ94//n5btVxT5gxyT6SKYo/xGuifHNF9h2kmODnJ9fKGSreR4vzC9b3TXaC4gtAZdeuLrUq5R6RkakVGU729o9gVeSzBLdIp63tF3Msj2+mYpem8d+eqza5rK8uPvfMLCdjQ+I6D4Zf+E90/u6JNzxWebFW2f0TvD0Fq6QmQK5bzHOU1ZDOy2JWXd47QRZV4WUEas83yS6hEUTWNp7ktM7UDB8tGOps1wh4zssmVoLPWio9GVuKEYGYYki6itTes4Ejfic07txKllk0lS9NwTTAAdefvpHTEqXt8vJuB2c7dAKZFXjKFCOEXfGeylpx8s7UMpLLdTKBsFWB0kdMm1FuZSlOTaw+mB/c1MNORzx6HJsZnHDaKXL5YdbjBsbuaozBODPIPtzEnwjon09+LQovdGtMkKhmcDSgeywjPscrqPFvCkJS8cw2C5uq+ZnR1o24xhl6NLR9QR5k6cc/YZZmtkdnwwNKqU7kRQhNoLQ7/O0K3m6uUJ/+53vs8vvHqL/cu5OL4ocI971NaiD4bs6QFjAs26JKTOmi8i2UYRrWit1czx7csrftE9pd9nbO8XKKfYlAtUq9mqVXr+pOIkQrM0mMKjdKA95NjcMztp8F5jTaDZFeS1tEC906hOM7ys8Z3CAN1NRpeeGX4h3ZrFoy2ldWLzWcnD0OhAmTse1jWhM+iDkQHSNHgdStGMBxtEUrS1KA2c9pTVwDAYfCdOSM22lPWEDIq+fH6WZEZWElgbsTStZj0/9vYrfnh7TrMruFjtuN3OWK4aNlVFPGTE1mK2si+xkHXsYy5JuIuBrHDoqBhe1JhGUdyLDG+YxckNZswjiVkkBCQUa5BgqlGmqFpDd6jRreYhSlcotO2/Mm76172l2/tf/+f8W8LWf6lBuoSs6CSBEO9i28WJ2RxdWgR4i01emBIAFe2psHXaw/6JEl30aOtnoSmMWC66ZEGXtLh6ZOGSC8T+rTSF3SiytbTaiUdwOkaE+0KAui+gvBYt8P69gC+ORYIvFK6AYiNsX/nS062MBA4Nwj62Z2Y6BzZZvIUMHr4tejWzMVz8c9nfkCnKW3kYZHuxCxwH5bL9UYudHaIMz1WKOGqMFyrZ7klIS3uiJxZyHLwt78XFRg8CTEMmrzmCEwl08rkw/MFKUWA6AVG6FylBvguTFEWFOHU9xhAglGhJy2xgmF0KW2zkWJYfD4RM0S8N9bVDOXlfn+QnKkB1F+iW8voRTKsg7LNo5SPdUgBmvk0/a9Na4thtGYF6vouTN7pOmnvlQdkxBOo4IDpKdOor0YKKPlkd9d0JkI9gc2T/tYu8/l94Tv9pNllvNpew/DiBwB2s/m/VBF5dqSg2QeYYaoXZGUIeMQcBFU/+idhJdktFv8oIdsVMH9f8wzcXoAXQ8M2Gl08z7L0VJtBEdKtSJ8lMsi7bktZETO4y8TgsmgrD+nWcQHtMYUMhSXJHb/VxaDUqiFZNEpo37SxHWdG4jYVdkBk5ceqJco8NCylqfSnv072w/GNx60qRhmWHiHkuKaPtqcKk7IOQK9RW7v0x4W+YpedF6sLJelAoJ/p6nbouQ62nfR+96Md5GVel50JQLJYNm71NNjVIWuZDzqGfiVNJZ8ApVCZezrNZy+a+Prb6neajq3N8Z/nZXcXl6RalIm/P12x3Jd/tHzEMBmsDRT4IKC8GcUw55MSoGIYMWw+0XYYtRKoQg0LPBsIuI45zaZ2BImBKR5ZJhHueJf9tZ3CHTKQhEZSONA8VMSAa732OcrIGYx4EXI6pnr24pITBoOcDofJiZg/Qa263M7pWZChaB5ZVx1W/oKr7iaktVweeLMTl4sPrc7SOPHv7jvtdjVKRRdXxsK9YPd7Q9paqHDgcCg5RYZMOaQzxWi4bBmfo2oyiHGg2Of2LGcWzPbFQaCsuKBTQbAtoDWZn0JqJoQ5FJJz16JucUAeGxlKcN8we9zx8/4zOROJCLBoHZ/APyeFnZ9BB4QdN2FqYeXirp8wdWkcOW0n59NskjUm+66rV6L3hH/3gq/y2rzznl9qMcFUSZp5i0dNroNW45zMGHcmeNFTne3YfrsArhmVM943Cvyj5uc37cr+55KJTivzEnntWdXoGe8PDvqJZl7CzOKewM4fS0G0KWHb0TYaad9Il6MVucbFs2J1p1OhdCrhGfO6NlpRS3wuT/+Bl3qAsZc2WmaPpM2azDlcOxFNZJ0WehoX3pZy7Th5o1dM93fMZoTO0vdxLDAq3M1RPZUgWoHOW+vRACEpsI63jW+fXfPBwznpTc1fVdE3Ge89uuG/EHekrq3tu8p7nL87ke/D9PfOyZ9sUFLmj660EZAF9ZzFWwpz8Jqc1IpuLeRQ7TH+Utsh3KITLXuxHNWTLjuA1QVnsjSX/xoZhsAz3BeHfEq/wL/P2pQbprtZg1TSkGIuRfZMv/Wjly3V0VYCRLY6T5SLIe/bfGrD/LEP3MoBnhiNzqV3EFRobwe5kGNV0EJLncnEP7XnSo2sBXaPOenYrw3U+S0mIJYS9/Ln9MWFOfB0oXwrDNEa69wuFKcCVlqwRgOBzi23iZPk3aqvztfxp9wpfSfvy8EhudrsXZlV5aE/FdnL0rfaFhMpoL/p4MyTJSApOCkaRH0bmXFFfiU55mEk3wjYxBc5ILPy4T65UiW0VFxCfUh6JI9shSZwhl2KhXymqazMN9CkvMoJhHD5FXlf/X1YAFDGSHQRUhwwOj+1R94zBpTAb0zM5ftgmUjx4fKlxJWSHIwPerURvYptIdee5+5aleJC/+1xN8wUmrQUzCBDbP9VTx0KKIDlntouoZE+oXZw02irA+l3N6ff81CkhudSMA5so2LwntlzVleLif1AT05wdItnHqVMyajFHi06j0E2yNDSweR/83Auz9Kgj3B+HkSAN54bj36OB1S9kqfgSSYRILcAmB5LVBxHb+GMxod9If0X2KTBKkeTn/YJJFuVm8p5sk4rLYSx+0rEI6X8corXCSo8dqymYSad7PMmnRr/9wxNZu66WmY/ROWE87qgVMaXluvI4h6Idn7NptF1M+QoiWUOpNFwqcxNRpe7GLkzPh/HfYwLvo9PU57a0tttHAQYBFdFE8tOO4baEIqDPOsJdIYmbZXJ2KOTPk7rh6XLD692C0jp8UMwLcXTxQXNZ7fl0e4JWkfPVHhc0i6ojM57rzRyUOHT0B9GXh05jSrEQNCZIq19FTBVo9jnZaSesrdFoE6fB1GEwBKfxhawLraIMUvYa1yR23ElAl1sXAkC0dOVM5QRkZgFlA3GUlBgvt4AHU3r8IO3AvreEztA0Fp1LERFaS6tlEc7nDYuy476p2bUiUTmZNTivyawUE50z+MGwHmpM5nEOyqrHGk+VOdaHciIB9oeC4LTY+wFm2eNb6Rwop2HR03k9+cPnZy2dLiUttTfCgvYK+1IkKwHARrp1KUCr9swe7cmsZ38oWNUNm0t5VvRNRlYNqMHg20IkHI2l8wqlQaeh3qY36MxTlAPF6UGCm3KPtoHX+wXvPbrlqlowOMOiarneyzUJhQxdD/cFQ5nJ+R4D0nSSI/aK/FNL89SjVgNnZzvaPiMERbMuuT5kZKVjMRPf/r7LMAtJU+02BTr32JmwEiYVl3nu0IUMPQ8pWVWtCzjrJ9Z9vF6HTSWptk2GtqLZP2yLycPceS3FUWOJVgYv26JIibjSfVE6Tus0rhw4hamlSA2Dppj3LKqOWS73zs1+Rp55dvsCrSPtkPFPP/gKtnBiNWoHHl9suN7N+fr5DS93S64Oc16+OhG3msxzuK/JH3nOF3t80JyUDUOQBN8qkyLjbldz6CzeJhJrb1AafBWTDCYSyoC9t7DO4FFL2GYS0GQDKvO4mYbvrRjOB3nSLoZfD4v+zW/pOf6b8jn/FmxfapCufGRYCQCmSiBHSyd8BFbCzoLeCTPqC/FwNsk3O2QCBFY/n2EbRO9tYH9ujkNuSbZgepi/TIC5ECDSnR5b+yPoGHXXUcP+mUqDaUzDjm4mIN3eW2H9limkaH4ELBK4AhkQ+qNjh7TXRaM7zBTdiYBQ04krjO6FQQx5skj04E1qQQUB7TCyyMeCQnn5zGITJh36KC2YrAiTzUd14yUsJ7HcIfl6y+tjYui1nPvEkA75kTXODjEN+hxZZlcdmVI5VgFEPhdN+qj3zXeBoda0p3pi2KUIiNPQ5jjgOUoOzCiPgInljTrZcxoBVT6TQsIVegJXPpffbXoB6yASK5+LDr24H4E43H9LbDUXzxOj7qNoI708fMfh42HxBsAOUVQeiqPsxUfmn0WaC/GGRx3TScfIe+3i5zzvR/eVsehEKZYfQfwko1/C7uuR8kET8nFoUt476v4lPCmtu8jkvBMyyDZpGHMmNpcmFYiESMg10R33/c3zbh3QRYr18X4VH3U1FRkqMMmGfHHsbsSx9atFF6/7Y9dDhsVHaYnsm+nlBOhO5DEmFSB+XFNRzvv8eZzOkU0FjU+DyiqIFKvYII4tWu678TqhRZ8fjBSSkEC/fWNNjTaRqVidyIDUdVBeZKjoCDNH8Ipi1VHkDnUR6Q85IXUpYmskSGfhiBEWdUs7ZDR9Roxw6DP2h4J+ZpgXPc8/O+cjJdrvV/ZE5DBZEJZeRfLZgE1AOFYDMcLJRYNWkW6wwmB6TZE7MusZcpHF6CxIMmXh0TYSg3hjd73BOyP2es6gbUCfOImuL4NIIRApiDoYGTA14HwqWI1Ex8dBE5I7S71saXxBfF1ivHQnY1A8fXbP7XaG6wzGeqgQK8g8sN4s2c4HQmeJAcrTlkOfUedD8sGO3N2K7jv2huAU1bwjs346j+JMgqRmBmHLo1e0h5y8GjAmSLjNppg+R1lJJe3J5LmedPV4hZ/JeZciXCRh6Miwz7APhnazZL+Uh91NZ4hRrP5iEL06yHVnkFj7GBVai+1ijIrzyw13d3O6JhMm2yl0FcWVp9pzUe7Z9wWvN0vajbD9lB7diN45Ks3y2YY1c+l8mIB+XUz3XL+KlNeG8GC4v80n4ug7v+1jWm85DDm3m5msl7Kn7y2XJ3vuge6QYXMv3ZZ0zlzuKaqB4AzBa/Aadd4xX7RsbuYMxmJLR1F7TO5liDa52EjirbSuR6e1atHR6kg975gVPb03dL3YQ3ZNRohG7v/Ooq0noMW33WsJktoUXF3XkAcePX3gtGp4vVmQZZ6qGMiNp7wY2He5OCFtFgA0u4IfqnNCVHz17Bb9NLJtZfZhWbQMwbDrCjbrirCT9NqvvfeKzlteXJ0Qtrl0H5N1KUaeY6H2jKm29t4mR6kIQVFcNHTbYnqv3FQpidpGGEZy6re2H3X763/9r/NX/+pf5eXLl3znO9/hP/vP/jP+vX/v3/sXvva/+q/+K/7G3/gb/MIv/AJd1/Gd73yHn/qpn+IP/aE/9CN/3pcapPtCUWxDcocQz+wxTXAENCOAGMH6CBCCFSZYeWHBRsATd6Mc4xgjPw4TukJNkhWVdN/ZlokhC1Y8xxk1qklqo11qsddqcoWwiU2XfYmYXtEvI/k6SS7WI3sO9UGY48lJRMmAabYTuUrepeN00vJvHsmf/QnUr0g63DfAXCTJZo4DdsUu0p4rDkZP4H3UCefbeAyDGpM3Cz2ld44a6tFSzyR7QqdlgLY7gXydQExiWMdBT18I81m/GnW/IhtwpXy26eHq3x14/A8szbli875h8fGxgBilOv08+Vabo//1KFuQuQQ17X+wis17muI+WQGGox2nilDcHwcwR+cPEYYmgGlBN0zHPtQatIBC+X0JNPajfWJE9wLqZs/lfI8653FzpXSEZE3KPqggxzJKYMQ1J05a92x3HBLVo147hSAVazkH9evI2Xc1wfgUMBTxlZx/u2fyDR+Bp+mTy04lbHR3IevaV4HlR5qQpW6HIyXDyjUb7UZViCh9HL4epVUj6y6DpcfPO3rDR0YR15uyHz1EOQfJf13FxJZXitnLOL2+PVHYjgnod9KFJtvK75J5DPFZlkKHqagLCajXV3GytmxP9cSS++zz+zseW8iPMwVRMzloSPgVk1RL5E+pKPZQ3BiGVY9vLP06Y/CyXxrEeUNFcaSovTCEuef2w1PRdFeOvB7odjk0lvVDwbpyYAKXlxu2jQyCfuPRNXdtzbJo2XQlr2+WZDMBpq43ZKWj6TIer7bsEwPtB8PB6wnc2MJTVx3Fas/N3ZzgZMC0TUy81pH9XY2tHSG19vOzVoZUZ4F+I2wwRSAEQyw9xaqjP4g+yeQBMhlCyXPHYVsSew1zJ6x15Ym9/N5V3XC9X9IlpxBVpOGVSvZTl25iMTeNBDX1yQ7Q5J7VouHu9ZLoNIfrGU3lMLkXd5Wk7x+Z6pjsh/pWtO0A5UlLPu8ZOrEFfPfRLb23PH9xJkFHaR2KU4mWoc5eE08HVKulM3Kw+Cp1aL0iZqnv1BiCMlQXh6SbNrDNpjRbDga3cLioxAYQUDqSF47WGcrzhvamou0KfnlXUMx6vn5xwyt3Aq3hra9dk2lP6wTIvvq1S7Y/PEGNazmM3bpISGmXro7EdxvCTYk9yDP0l3/xK3KQNvIHf/sv8f/44JscXs3RnebFNkfZyOL0wPZ2Rt9r1GwQq8B1TtOlIqY16FZDsByel+gcwunAsM25GTsUaUjHv6iJ5x3ZwrO/r6b0VlM54i7jEDRdnpPljpNZQ+8NzXVNdtrhnUabwNce3/DhzTlDZ8kKx+yk4XR24G5Xc7HY0w4Zn96cUpYD+3WFUpHL0x2Ny5gXHeu2ohssmfWcPbnnsxdnKB35IJ4naRhkpWOzK2XWAbl/zarn0emWDz59TL1ssIVncXrP7eslnHUopNBUlUMFBa3Bzzx2b9GdPPuG1tD1Bv2QPPIr6cD5MqIbTVg6gvtigvQvql78Z37mZ/gLf+Ev8Nf/+l/n9/2+38ff/Jt/k3//3//3+ZVf+RXefffd3/D6f/AP/gF/4A/8Af7KX/krnJyc8Lf/9t/mj/yRP8I/+Sf/hJ/8yZ/8kT5TxfjlEyVtNhtWqxX/sz/6fyCuKrJ9SFrTgKs0vtT08+MA6GiJ5qo3Bj+1gBSdmLXRR3t0Y5D/j5MWeWTw9k+NgO8aCCnMxspQ2giER1balTB7FWjP9HFgccXRVi8xy76C/iRQvUqe12MnIBUUo5XkNFyZXGTyXeT+W1oAkxFQlW+OwTLjwN54jOGNIbhoxFt69jKBtEhKymTyxBbrRXlvlsBjeyoDpUOVJCUjiB1XoYJ87YVBdJFQaDm3iolVBwFMs1eRbiUDmyNbM4Lj0cc+ZIqHbyjOfiVMg4faRQ4XJiWtHnXQ2V5YdhUitoNsJ1aT3akRh5YhJm2xrJHRq3uU6IyhN7YJ7J9aqmvPMNPTZ47WhxNb3ERMl7T4ubRwfKEnIGe6wKg9H6+JDKTClCb66/8EmjM9Bedsv6I4+X6Y5DGTf24fOTzS1Ndh6hqNevtRcjHZNoYR9Ka1NzoHlcmBJe3bKCvRXhJbXQ379z3ZnWF4u+PJ/z2bbBP1MFZ8HPX6ClBqkn+E1H0IRq7RpClP7wORdX1ucEqLleHYjRrlaWOHyZVqKoDHQKpoFNu3pIshaaXj/aI+VwSI9Ekd5TRJLqPisQCPRoB21khyrnJH6Uy2P967Pof5i3BMKh47RpXsv8+ly5XtmRx4fC5F6+6dlEq4HER/PWhULa0Mm4stZmys6MKdwb7McaeOy3fuMToyyzv2vTAHzWBZ380hwOXjtQCVLhcbxnygS/7ij+dbPns4YVU3EloE4n9eOHLrpzj4vsvwrRHZQu6pq55D0qkPhwxbjdHpCps7hs6KptyJ/7fSwn6GfZa05wp60RYTQK0GstLhk1wkDBp1l0uxNPPY2rFYNDxczymWHe19icrE/zuzsoBEZ+9x3vDsZM1hyLm5n6ON2CleLndsmpJDk6N1xPUGk8mxtH0mziBegBGj+0yvUVmERvbLLIdJ3lPNO5ptyfJ0T9tlVGVPjIpl1fL6fkm/yUVPnIqtUWMMEHNJRFVeEQqRMOXznn6fo7ZScMQsQuEF0HZGftcgWnDVa5g5ZsuWR4st+75g2xT4NLwaoxIGfb5n05ZsNpVct7LnpGzk3NzNCZuc7N6Ile4Th2o1ceVQJggm1lHYWiXZCXhFtpN73bTQXkbqr695++SBEBXf+/QxcZ2je4VfeOxCUnFPFwdu7ufE20KO+SQFCmVeOie7DLOXFNqYp+RODb4O2K0RV6BZEMcUr6FNxVon80XZacewy8leZdP7OOupZh3WBBZlx/OXp1Lc6YhKzihh5tGFJysdSkXcYHD7DNVr6ic7Hi+3rNsK5zWLsqPOetZtxSwXoK5UpLSOed4RouLFeoVWkW0C9nk9cDY/8Kje8XK3ZH0oebza0vRSKN7cLTg93dP2ljJ3dIN0rtwPFrhHPbYeWC0abq+WsLPpGavINqnQnwm7bnrFsAiyZoDQtHz6F//3rNdrlssl/6a3v/N3/g7/u7/8V/j2H/iz/9o/69V3/9/85LPIf/1f/9c/8nt+9+/+3fz23/7b+Rt/429MP/uxH/sx/tgf+2P8p//pf/oj/Y7vfOc7/Mk/+Sf5j/6j/+hHev2XmklvzzRlatO7WpjdfO3Fwm6pJpZYmEY+5/HtC0BDthE3mBEMqyCuL6Nv9f6JMDlj3Hp1G2jONMuPA69/l+Ly548AfwQU45YnJr++CtiDp7mwtOdqGsaKCigFFFQvNcOSpImPE/iJ6ij10Km9rryAqzZLceJ7cZYp74/AqZ+riaVWaTAtWFBeTSDGpoTPfBuwjRQ43VInzXUC1pmaBuR8JvIR3UfKNwCuL9LvTBaH3YmZWETtYopEF2Q0AsH5S3n/9j0w30uM6SGS7QL9QvTto1vN4qNf9zmA7ZjA6MhWh0yR78We0pWKoZbbI98GGRScaewhoD3EXo5RBQF99ZUTCUUlriPLjwbR+XdRIlONoluKhSKMkiaFqwyjZnk8r/lGBjR1LwxzSh2nXxgpkhREq+hWUvAI4D2mkpo+prTPyOITjg4l6d+DgTid87SmGQF8HPHvBIpDdnRKiUa82FWUdS4vHO8TNcl6fK4wryMnP4CQBV7NswmAj/fUCIDf1F5L0XT8fSM4lq5BnIqEyZbQpgJlJNhjnNb32OUaAfvogqMTk56WNXqIdBew+EwKndFxRXZiLG4VIXW/gpWiYbyWyklRUj6MRXHqUK0V8xdBruMI7t+4DiDn0lWa7kSKHilY1LTWXQnb9yGaSPVKTU5QZEHcJ5aDDIjeyRzAkMAdWST0hug0w8VAeSrt9Nz2tC4jRIULWgC6itBZem/Eps8r+jajz4Q9HJzhey8f4TvD9q5mdtqwX5fks4F3z+55tVmKFveQo4204YPX9Dsz6YxVclbx/VGe4QaTnEpE7uKdDIHmpaNLFydqJH3UC7CPvaE/WNGi24itBsJFR5Z7QlDUVc92W6F2lk4jzjc7Q7+r6DWcf+WeRSlDhrfbGZ/enPLu5R1X3QofLCoLvPYL8txxsjywyDs++uFjnMvYDVVat3G6J9VOJpgVEBeO+vFO5D7O4IOme1XTmQCtZn01x1QOlxnKfOD1/RL3usI4Na1N5cb7Upw5fBGkKFZMzHl/yNCZJ2QGqqTHQmwElRWbQt1q9FqkD95n7KPi431OWYv++2x+4PphzqzuRJO/r7mY7xicYXdb43rDoc0lWXUjYBolZJBddcyedqzvZnCXozuFnwcZMA/He2dyNJuDGhTNr634fjiR63rimb29ZVb0+Ki4f5gRgKsPz4hZpHhyoMjFKYeoxCsfIA/4wguA3lkZksxFHuROHPakQ/VGPPgbnZK5Le2jgH7S0K8LsjsrhbOV3JK4zgjVwKG3DM5g8kBIcxB21VEVPbt9SZ47nDMYG/CdEcefaNnf1XzS5pytdtRVjw+a0jga62hdRm48r65WxEFjZwNZ5plVHbumYLFqOJ/tKaxjP+T8s1/5CmrmKOuez16fEnoDJk6dK2sC+zZn6Cz+YFGn4j3sritumwwOZiJjfBGJKwh5lGIyDzin0AcjBWFABrG/iNtvBnX8r/gZfd/zcz/3c/ylv/SXPvfzP/gH/yD/6B/9ox/pd4QQ2G63nJ2d/cif+6UG6YwMWK6pr/0bzJ4wyGgBNNozBZP4nKQxT1/uJ8Jyo2WY0ZdiK2iS93J2iNMXvXRBk1VfqbCNormQNrnPmRwufBqOjBq6UpjhbmVxlaI/jdhDkmZEUAO4OtKdCeuir5ILTbqyoz7YdMJ+55s4+Za7UiUZhXQHRqbdNhH3SE2M3wjmQEJVlE863lqlh4HCF1KMRAseNYUYmV5AU3OWPNDTgJEwu2pyyxivR7DjOQsToEZJcJB4rYuMYCyCFh+JC4rPVGJeZYDVZ8euwaghH7XjY0GAkvcGo5JryrHzIdpn+fsI9lUgDbjKe4tNwDQCqF0t1o1DrYWZXyoOjxWzlyHZ/8mhDHUCir1IgHyhp2OMGq7+ncDjf2iwh0CYCSgHKSL6pSLfJlLRiEPMeP5Hdrq50BTr+IZuHV7/Xogq8vgfC3A1Y+ckpcOi4HChWTz3iWkeGXQ5DyHpwFWfho7TsUgY0xvMeGLbRxlPyBShlPfOPhE9tvFvSHrGc1rqCehrJ+tFJ4ANAlBHW9BxsHrcRr39+B5iyjNIXZr4ZjdXJZA95hOk/fSForxSU+bBFPjEMaTr5NfipBEH+d2uUNz89kj+oDn7lTB5tPuFIipFdSNDv2rKA0hdmEJN54tKSTdoHTGtFNHjwLFtZQ6mvFO46o38BUA34nYR73MoArGI6L2R36HBE1CtpXhrT/98Rvl44KRsePGwwvVGIupLT1YNDI3FrHo2DzUA82XLts0kDr3JyBeeohgwVT8B0Hw2sKhbPrw6J8s8J/MDvRe7v4e7mbDSRcC1GcpE8XAvPPOq4/5+JlIJFQlRMas7mjbHNwY77xkGgxqZZK8nf3dTyENPa/HeXsxadLqxrAm8fHXCPmjx2c4DWTWgTaD1yaZSiRvK7e0SnXtJscw9n1yfiUsMQG/R9UCzF63wdT/HLAZOVhIEtL5OQ5YmygBjFvD7TAYL9xn7u1oaWipSnzRiKdmmAJ5BQy2Pnl1TMBwyYuXF5s8EccDxiuLRgaE7JnGGdc6YUKqdgstOGPPZgLZRCp8+OU9ZCXQKszQ0XDmW85bBGapiYFU2NEPO/b4iyzybF0vWNlCcdGy6kvP5njrvmRcdH78+ZzbrKN7a0LQ5xgTwGv+8Zj0roExD4NlxXYZC1nV+r5MUMwH1M4cqPPo+E8nYVrNnzr7ymMIJ4PQKTERlge6hpO/SMc09etkTekNWD1ysdhz6jF1e4e/zyX3K3lnilSWWknqKAv/tPWXd0Xx4gv7+jMwKaG2eydA2JmLvLG67kOfDHtQ8EmcB3WqcjWwvDGGX0ZQiI+orj7KB4DTFSTf51l9fL0VmdNpx8nYjcxDO4AfNW0/ueThU1HlPkTnxVTeBEBW3+xmHQ4HvNfZE9PPtIT9ajHrF4BV9yMnmPe6hkOeUiejUmTKzHrfPpcC5MTKH46Xz7xdeznkhrkLc22nuwWy/3BAwhMBms/ncz4qioCiK3/Dam5sbvPc8fvz4cz9//Pgxr169+pE+76/9tb/Gfr/nT/yJP/Ej7+OX+wrBZJG3f2wn5jZYRXcmIHP0NB8HL0FNcpSoBECbODKDCnstDOv4e8bkUp+IgJFxjwaKOwEczblK+mpFPxeAkB2OYCFY+VJXXhxYRreZaKB+Ie4sRHGIGeZpGK5Ljh2ppW/bmAYbEyuZ5DS+QgCkhj5ZCB4eyb/bg4DBUaIhIDXJZ1BJhx0/NxyZ7QUo5fujxWCxiZQPcXpor7+uKW9EyjPKRN4skEZQDCQWUv7/6LAjRU54QyIQjYIkK5rmCZLERyeyKZjj0Ofopz4yv2NIlfLgE2gcCw3ckcE3XUzvk+vcnGUS9e4jKPGTRwkYrq8So5z+vVtp8q0kvZrsuK9vpqCOoUYC5IQxN53IVfrlGx77Mj+FWPmNgFqsLsdiY/QMf/yP1dQdaM8V8xdyjSb5Tx9ZfOZT1yMB2JGdTn+qIEWdGQtPZN/elI2AMO7jcYwOOXLNZFh2BPnCRh+7SGM6qG1E4kOMZElyE7WapCc+V8lRIk6MkaQQwZCrVMjI/o0hRmNXZgoh4/NFSHMh6725kNeNxUuwSbLVpYJktEJMYF87ePRPFbYJ6bonmdc+TnKFUermM3EwMm+s0eNz5FhMjC4x2kUC6RxVx9kJVykZbr/o4C4XMJK2+KiTz1UR1jm61XTXNdjI+sWS3arkm0+v+OzhhNbKAKkfNLSGoGUQc3W6Z/PRiRSSs55ha+hK8X5uWsveF/h9hi4d991MzluT0WwLtA3MFy22cGL11xtxG1GRfp9h8sDdfkE57/Be450meOiVMO9E6Pc5cWSWg4IsCGucXD1M4VnOG6pMmOihled2HHTSq2e4vUUNmn6To5PDDYk9XHdiExqSFMJHhIEuEmgL0F9XEGCnIkpDXgwMTsJ13nv3ipdrkQX4TYUfJGQp3hbEKoj3dpKONbagmneczA8UmePQ54lhV5Lsuow0VzPRB5ciG8FGjA7E3NNfVUfZSyFuNmFviXtJlbWFl9TRzNOTwTbDblMnaxag9oRtRnayR+vI3esld24lw4IK7HnL0/dvqLOej67Oub1ecpPA/vWg+dZPfMrr3YKH50twCu+U6M8vOmzu8b14ututJr83YsWYOkVTboaS56cLiN/93GPWFu0V+qDRD4ZoM/STjrIW15RRuadTEWd0SDKsjMOm5MXmDOU0qlfEKjD/1j39YCXsKMKiGMh04Pp+gX9dsaFCXXScfGPH7cMcf7BUJy0hKoJXhLkUc8OmQHmLWwbs2pDt5L7vl4bsVBJemffif99a6DT9NpMskH2FetQxf2dD7ww/eH3JsM/Eo13B3a4mRMX1zVIkXHsrw72tPj4rapfcjSL6PicWAYqAnfUoBdZ6TmYNt1rkNjb3xKDo14UUbUa6oP2JhFTpThFKKe5i5bG53Jf9qejYYzjKqr5o22+KTzrwve99j9Vq9bmf/8f/8X/MT/3UT/3L3zc6qaUtxvgbfvYv2n76p3+an/qpn+Lv/t2/y6NHj37k/fxSg3TbRUjx3qaT9vXuLdFo5xuwh+SLPMTkV/75NFGJfUcGdIIweSPTPnlV9yNYUdPDW6rjo44WBBC6+sjk6TT8NzlzZKJVXf0gMd+NsMLdqaI9g/7Mkz+Io8zuHSivx4FT+f0+V3QrSU6M+jjwmT/A/q1I/UqKiXGIzZegOunqjmDCNtK6dJWEvrhSQLnpo4T5rKXNb/rkI63lZhvSYOE4TFu/FJ3tqBuXYUY1DWlGLedc96OriZpAlU0OOz5TbL4eGU49ZmdYfT9ZVGYjKBcQZ1um949s7P6pYv5cjinbx6lQCFkCXNnxWvn8CPJVELvFrEnXJHVZBCimYKYh4g1EJZ77u7cV888i1osnvPKjX72Ax+xwHFo2feSd/zYdwxs66Dg6g6Rj00PynO8iLldEFbEtoOXzQ5IxBQMxV9NsgBlg8WmcQPD4IJykJOkch1xN8gwVoDvRlHdBirxSsXsmPr1jWJMUoGq6V4BpcHh0zulXUF/LcOuosXeF2E3aQ0jXXqEHkSXlW0+/0MffBdz8Ns3lz/tpJmIEBCKZiWQOZi8dIVcMc8PuGax+mORJaV3JsKaa2PyQwebbntNfsFMB6io5z+MsR3VzLOx48x5GQqpCduwoqCjPCdPLep+cW+xxrdvmuE8yA6NocsXu647lr1op0JLl6FAfZTKuSIXCkGqnkyFpoIHRRaX0RK8xywEP0uZOzifOGVpn2e8LFouGpsvJsoFep9/XihQlVJ7ytKXb5xK0c8hgZ1m+vWF/KKjOGr5yfsfNYcaz+YYQFfsh59ObU/aHZB3oNDSGISqy0lHMe1xvqZcNza4gKyVwRynIrEhVPCAaFdClS4mdYHOH6+HpxQN3u5rbm4W4rWwy0daqKMFIQFY5QqHwnUYNGj2XCjgEhem0JMRqha4cauUJg4Y+DSUCtIby0YF2n2xE1zkHK21QlQU+vK/SmlTgFbp2aeg+MQmnPbEzmNnA5cmOV1crmn0hHYEEcsdhS3PagUoDfYA5iGtH//2lDPdFYFCEPKKsLLpYyOBj6AzDvZxr3WqwkVh5KZJrlwCcxsx67u7mAPzkNz/m4DJebpY4r/nOo9f8cH1GaRWrRYNaim76bidprC/WKykoLhouFnv2fc7DiyX6tsDZiLloefS1G2JUXH33UmasDsnnPYf+NMBywFzl2LUhbgzVV3d0+xneCqAPSvTexgb6LuNqW6I2dvoeQkf0qmc27zidNSyrjn2XU+UD26ageT1jt6soyp79Q0X0ioMCGg3p1oh5BK+4enlC/jIjVpF2qLGnEuQTg8IHg6kHhqeB6DThnYZmk6N6Bb3GP9QMtUf1qaBCikgVITqFWznMTcF2naNWvcyENBr9UqxrXawkL0Kn4W4gpDCl0yfb6byTe/p9jp/5KQ02Bk1UEecMLz49Q9nI06f37DvJKtBngS75zVevNe0jcUcKBYTKk99YfKNoQ5WeUQoSxghfTIz+m7Z985vf5Gd/9mc/97N/EYsOcHFxgTHmN7DmV1dXv4Fd//Xbz/zMz/Bn/syf4b/8L/9Lfv/v//3/Svv4pQbpPleYeByS84WiuBdf7zFQx+eK5lwnZ4nRdSV9Q0cBgEORGNYkQRmtGkX+oFBNinZPgG4EfUOv8NJhxu7FL31kc0dAVN4LwymJhMLUjnHhKsD8eWDxaUwa3MCr36s4+yWm4KVRWhEyRXUTqG6T5WQ6hP0Tkd2IjjfJePoEvGIC64Mw+9O+9SLbmL0OEyhUQQAFCEtarKX9r/zRJ32URYzOIahx4DJp5ZNf98isS/BLkhmVemLso5IixR4Ubq5YfU+leHWFCUfGfXShQcVjKIyH+XMmucxonTiC5gkYBqaIdhBdugQ5RXzGBLBBrmm+CxQbSUsFsIn9nj8Xmcp07rxIpkyvpi5FVGPypkh8YqnQnezPkJJLVYDqCogJ3KfB0HGwcwTeYyEyDZumczEOeI7FY1Qq2Qim6xrH96vPMcXaRRafOXyuk/3gG4OTSjEsjsWm6WH2anSTkWttm2MxoEKcugbRiKzaFUClp7U3Oii5Sh+dX5Je//yXwuesCUWqlgYtjRQx3dJO3YX6Kq27RtbQWASOHQRfyJfs7AOLKzlq7lOruDuVwc2xM2PWRzZ+PAcoAeimTfMDyJewXLM4seJ2L1aaYzHqczUV6PkmFeU/ZyfLx+wgHYWp6+Mj3VJTPESaS0WsHP0mfZkkXWl52ope2aZqoUruLjrSdRl11fN6s0CbwOahxuSeIgtQDJwv9tztato+Qx8MfZkRB40uPPFgiXlg/XqBKmSA8rOHE7SKuKjZDznPb05QKgrYOmQCop0whn1nsAtpqXStOLuMAUQAu66UFM7U2pf3SoYAvcZnost9cXWCtoHLiw3zooOn8OnNKWfLAy5oHh5q0eEHhVqIi02/zaWQKQKh8uK5HhRhnTP/oQyPr7/lp2e6itDeVOAVYeZFB54FTs723L9ekM17gtOEznLy1ob1vTzAs6cHXG+YzTqWj1pe3a64fpgTB803vvqSk7yl9bJADi7j4+szsUTcm7Re0iByl1IiSfdgp8gOmnDQ+Erco9gV6HSDh4UnEGDQmJ2R4mFncGXAnHf0V5UAeBP5+e+/SzYbGHY5mMB39SO2DxUP+Uwi6dt0DWzk/a+9Yt8XXL1eQWN48XxGtJHVO2uaNqe/K/Gt5eWLUxmgXQ1wMESryB+E6HKriLnKUU5mKUIOT0/W2LN7bg8z6rzns5dnqHUGzysZIn3a8+Sb19SZrJdNW3L7MGdwhtf3C4atDNluy4ApHGo+4LcZbUT2I3mdU0sHJbo0YKKgWLWwalG9pcgdRgdxWNll0mnNAqtHO9avF3BVYvsjYRUvOup5h/OG7qGQQrLXIol50lHMBuKyJzOB3Hp298KYDyee7KLlYrVDq8j1Zk6ZD9T5QGkHPvr0ku2upM1kWLe0jjBrWBQt17u5hFC1Of0uJ9jAo2cPHPqc9aGkS+5D/pCBiZAH+hORaeZ3BrcM4BX9mWj4zWyQ49zksBAL1+C+gCh97OD+JnyO1vpHHpjN85zf8Tt+B3/v7/09/vgf/+PTz//e3/t7/NE/+kf/pe/76Z/+af7D//A/5Kd/+qf5w3/4D/8r7+aXGqS7CjDCgAKTK4gvNEMN5YMwn/OXnsOFSS1waTcfNeER2wjA9fkb7idaXptv49T+B47twHFobsvkjz56k4/gKhrx1bZNoF8ILZAdYgpDikd2MIXqCKMn+xPcUVutgoTjCEt/BFrKR1YfCpBYf1WLPt2I33PIhTnPdhD0Ucfravl5MNAvBalELcDduigdBSfa21G2MfqgoyLOKrQ7BkHZNk4+7VGBiSl9cRCA7iqxdPRpqNT0AV8Y9k8Uqx9EFh/pCdyDgGlgKlCCSQVIPso/5BqM10gTU3iRAELpJkh3oDsxU2HVL/WxCEvDppOcJhVU0ehprmAsEN607GwfQb5NbG0hnZh+JoO2wSDJsGnoNhpJ9gwW3EzYeJMGEMdZilHXPerZVbJCexOcv9lBmIoWmJjoo9VhnGQuyqvJFz8ktxeQ4epR8uFTkNRoR6gTc+yqpHvvScWlFG+mlX3Od+JoM9o9jh0d26rjfuhRLnb8+1RAkFxfonTC3nRDGnXmwShiwfF8IYDZjPr1mGQ2SnH7Y7IP3gKN/NvoAW86kYSN7ja+VHJe8zj5zY9ac2AC2EpDtvUJjGtJqJ1L8W4bmZ9wtRQ9/UK0u3imAVMV4nGAdtwfxC52zEPw+0xkGnkQKYdNvuFOE6MEpHCwmGVPaC3g6QaL6w2/+/2PeHVYcLufsSg7eme43c6S97eiN5HYGpaXe3xQHIJivmzZ3dYoHWkTONAmsOlkin21aPBBPLl9rnGtxZz1Ij3xojtvuwxjJKDG6IBTEJzC5B7XJWb6rJu8vTlY8XoPor8PtSf0hut2yboecIMh3BVc3ZayZp0izj3ZssO1Gf1ewMvs2Y79ugStUJ3Brg2+DhyeReafqNQuBLOxhNqjG0PUMpTqB01wmqbLKFYdrjMslg1tn7F+qClnPSEq3j594MNXFxgTeP78DKKSboANfP97zzh5a8M7yweeb1estxVExdOTez56PiOYiJtHtEsWrVkUBnk24Lc5vvLozE8ShXzW0x0ydBaI+wy76skyP8k33CGTeaqrkmyvcXMZGowW+nXBxVsP/MT5Kx76itu65rPn5ygbyB91PDndsMg6fvmjZ7C3XL53R5E5Mu15tV6y3VQ8Ot/y8qHE5J73n9zwwaePMIVH1QO+N3QLkVDpTjpjw8oTCpF1fPzqnHgrxeVdkhipxETbtQRONUPG1d0S31hiBH0wdBTEmcfUTmQaXhODIqscA2Bs4PzdO6p84OXdikcnW3pn8FFjdeB+K8VU32TEvYUlVIuGwya1e4swrW07H/Bepe/6yMmzDYMz7O9queeywJMnDzzsK/HA70UOdnioMJVjftqxfP+B9fUCOs3QWK78ktXyQPCKzd2MTVCcPd6wutixvp0TBk37qp7Is6u5o160ZMrzztk9H+wfo03k+tWJyJXGh3KA/LIRl6SZJ+4M2VpcePBKZEW9yFp8JXN3ap6cb4AxpfS3th9t+4t/8S/yp/7Un+J3/s7fye/9vb+Xv/W3/haffPIJf/bPihvNX/7Lf5nnz5/zX/wX/wUgAP1P/+k/zX/+n//n/J7f83smFr6qqt8gs/mXbV9qkK4dYOXLU3mxcxtb1qOjyrhljZ4Y6GBU0niPLPIYyZv0pslRYmRnR33uCC5EBnAEeMIwC3DyxRua2Cwx9TPN4VKx+Y74faNIaYUqMasp/nfvOftFi+k82WFkVY/sdLcUqUawso82aYLNAMtPArtnGpd02MUDkw49G+LkuKGukQrUx8+5Vox/juysq4Slbi4VbqZSSJKA5NnrgNJq6mC45IhiGwEhQ3IxGW0PR/Yy5IqQHSUQIyAdbR9DprAHmGwLXZzsFW0rgSNv6t9VELvC/VvQPnM8/e9HECq6+DdBnVyvUTZzZN2kAyOfKd0OKTzGbof2wsaaLlJdi7xjlALpHnSMybP8KEMp0yBttpPzG6wMDvZLOb79M1h8Iq9xJej9ceh4tMscQ3AiMDpRAMfAn5FBf9NJ5Y1tBKYqSKiSPQRMG+lW5nODl76Q4wi1MMhRiS5SOiRx0pyXdyItas5l+G0MAxpqcTwSBl1N8iyZ3TgOY0b9xjyBf2M/E1ONSrMJ07WJ02tHtx8V4qSFD2nOxM3FL35k0CdbxVS8jMFGaJG/jdKTUeOvU8HcnunJiSgYiJmA1XzrJ4mThBdJx8R2EeUi5a3j7sdzmD5TjkUPb9xLpU7hYOIA404cxgZxp/EKe94Sg5ZhyrMDWgfWt3PUfGCxaFh3c/xdITMMOvKPfvnrKA2ryy2P6h0AL/WS6/sFwalJC971yd2oGjjsCnThqWbd5AP+zctrrg5zbjczTBqCA2nPV4sO59IAaB7YHwqKYsB5g+sMThlxrohA7sEJWAopsp5Aci6BYtmxrFqqfMAHTZ0JMLY68FFxRpmsIofBYJGYeFM63F66ArukGx9vWncqSc0qC2xmRjS7FvHwB0IRiLm4zdjc07WWblegdODyQmzxiszRbQuRxSj4YP+I1emey9mO0+pAbQcuyj037YzaDnzv7oJfefGE6BVhMESn+PCzS8FkXpFvtTCeNnXIUuhV9WgvtpadDE2KH3xB3Gf4PIg/vo601zX5RYN/XUERePTuPVcscWdxKiq+8+QVP//BO9x/75z/lz2DmePy8Zr33r6WZMt84LOrU95+dE+16Gj2luvXK2anksqqlDgG+aAkav55zUcv3oYzhzHSIlue7bn78BSsWDG6eSC/bKhKGUyezTu2TqMfMpFqtGoaig15hJuC3Wel2CguB95/doOPml1XUGUDDwexOYxBcbnacVYeuO8qXt8vuX2Yy5oKiue3l0KGZRHVK3QnQ6DmccPybRkC1ipSzHuYi/5d60jbiHc5lYO9ZfHWloe7mdyWmac66ckzx816Rp47ikxkVt5rlpeSBHtWHbg9zMgXHb2VAWzfWO76uQwS6QgHw8OvnRHmnvK84WK5w12ao+vStiKzns1DTdPKnEa8L+FkQNUiZaLT6MWAd0auzTan2Mnz0tUyvxYTFnEz0LfixONWHnPa4R8KiL8+1viLsf1madL/Vbc/+Sf/JLe3t/wn/8l/wsuXL/mJn/gJ/pv/5r/hK1/5CgAvX77kk08+mV7/N//m38Q5x5//83+eP//n//z08//gP/gP+Dt/5+/8SJ/5pQbp2S5S3XphCI0M3R0eKbI97J5qirUAnaFObiXtqO096sSFodUTi2bcMZVwbN2Pw58jeB91tNPQnRFnmPHLv18yeaCrIEzv/FVg/ko8YfuFwvR6Ao0jkO0XmmEG2mlsI6DvTReNfB/QAxR3Hl/p4xCfAZ9rbJPAXqGkk3AfJyeXEfyMDhqTIwuJ+RyTJGMkWjVJdmYvj7Hs8n4BkCETfTdIWJEMGEr7OxgEzBySQ0x3BOo+E+lR+SC/ULzLmY5TtOxhYl5Dck8ZBzF3zzSzl2GSLeW7wKZSvP3f6mn4r59LB0SkFur4fpc6cfr435sJr5IoeQSSeojYNpBvFev3DMtPBHTYJv3OMSAqacK7pTh6jCy/q0RSI7IfAcO3v8tRvLQCNl1Ma1JeGxP7O2q6IRV5KSxp1OCPQ6Viv3iUYY3XeATGtpU1ZA8hDTXrSeahPag3ADVJdx090i3xbxQz4Vh0FpuQrhtoF8i3yY0ltThH33rdSxfpTaeVcR2Ng8TTkGq6b0Z9v0+FQTCQ7VNnxY6dFgHN7Znl4duR2aci7xkKue9GS8hR7jPmC5jU7eoXyZd/tGlUclz57vitMq4t2waGuYEYsZ2cu6HW06zGKN8q7lMAV6EIuTyHpDt0fH6I/39AD0rcO7a5MGKAHwyxNxJulIk8hTwQtxkP7UKCfWZuikb/+uNrXmyEFb0uZ2yakvX1HGUDpvCiU91m9FFhq4GqHAhB4ZqM/c1MAO/M0Z7J14fWkTbp1/0+Q1eOrs2wmWdxdmBwBuc0s6LnYVeLXjoqssLRva4ZnMbsDWEl0evyLFWT/3u3z1lHRW49gzc836+YFf0YC0A/WPrOYnMvA66dIb6q0CmRUVJTESlEKzpglQf0fUbIorDnyX0Ghfi1R4he0e9KVPo5CpEZvJwlrZYiVgpswBaOQ1Pw/ZdLqosDv+3JS37x5il3t3Px6I4S1PTofIvzhtfXS957dsMP+yfoRtO/NYgffATdpaJibfHveEwmLTw/aAZtqOYdnY0y7HjI8IPGnoqLTFwN4DX325p8JkO7+31JvCr4xR9+DWOg+OqGVd1yVh44uAytIhezPZ89nBDWObuVONss3tpyOBQUmeN+XzEre8JS/MSfnG144TRffXbNp3enhKAIQXF3vZDFrSMxFRz9dYXrZugA+9tCHkUDAji3uXQxgagjoYy4lefJV+5YH0qutgsy62m7jEObk2duCia6BnzQNIPlZH4AxE88Kx1V0fNsuaH3htZl3GxnDJ2s17ubObE36FKGOrUNxJei1/anjssnD7RDRn7p0ET8QuGDFAbtPufQSSdEn0RM0XM533G7l0L10OasNzWLRSO2o0GhMsjm/QTq296SX3hOqwN3h5rttuL5rz5m+f4DXZ+hdeDrT6653s/JKgHRxapDnbS4QQC5a2X2IDgjMqMU7NVdpmdQqwllkvVFkcCooHBLD7XDbUWG9EUdHP0ib3/uz/05/tyf+3P/wn/79cD77//9v///9+d9qUH6CFZGLXU0kO+EHXTVCJKYrN9CJl/WExOZQNEo2RBXFrH0c3WyUczHD0vAJrGvk89zcpFQkYmpj1oKgjcdSbrF0RmivDuGL42AwCe7OyuzMNx/W3P6XdkXFeV4lE9Dkl5PANTlagI9omVWuAqKtYAU8dw++luPX1Z92p8xJEfSTAW1mC6i7RGgvfknMPmSmwR0i3v5Eh3156aLKbVSTVKQwyORJdgG9m/B2a+ONDFT3LsKsq/kELWeUicF7MhxVbdx6oaEJE+6+IWUxpoKJpNkP0Oh04xBEFeVNxIyx0FTn6dQov5otxesmqLmu6WRsKp1ZPfUUN0GhtlxANkli01X6gls21ZAfr6VYU3bBPn3QXH2c1ZA+zCyDak46d60YxSZ0FCr6VgmFxSSLZoeQahIakYf8fHfJQtApCu+EPBQbAJ3z/QU5lXex2TDOBaibwB9BIhPoUipODMJ8EsAljrSGYnlfrNYGBNXRxefyXpxfE+amxA3pQRmF+mapC7Iy9+rufhnx6LKFwafwd3/BOrn6XPGAeuYQsYUZBthn4a5zIuE1OEa51T6OSw+O3YAxiIjKtg/0Sw+k2uXbWWnRx19tnUQBIT7ytKdWIa5YvWR4/bblvo6yb/CG+dsTOuN6Rx7RXba4jorOtzKCRu5sXDmIYsC+BCpQNRAY+l3luLJge+/uhQXib3heTjl7HxHddLSNRm+s+RPD5h/Pqc7k4E+5zV+MFTLlq7NuDjdcbep+fDmnDIfyDPH7Lzj9tUKMxOnjCzzOGfYPtRo63l6uebqQfTwRSb+192mEOlgRMBCZ1CVx8wGjA1CBhi5UZ6sNuTG83q3wDnDXTcThw0FSgeWJwfWd3N05oUFjgp6kVjog6G80vSrKHZ0nUbvhcW3O4WbebSNGOvpD6NmPhCDlgHHIGs1BOgGzdNvHDXTH3zyGKUjbl0Qk+63Kgb6YPjW2RWH5QNXBxnc/Orqlu/dXdI5y+PLDa83C+aXew6fLERTnLoYU9BM7SUg6GBg4VieHNjvSxZ1iw+aVd1y1S5Rr0rwEC8ci/M9XW+pyl6KI2/w9zmsHKwtalC4X17x4knN1UwkGOf1XpjfzLF6e41ScRrM9Hc5+emWXVTcf3CKCopX5xlxnfPk6zc0LsM5jWvEu11nHvu4T90SUJ3GNPL8yN7fcTJryK1j3ZQyNHy5ocgcn314CV6GaZWKvPrBBcwcJ5c7jA4s65aHfcWs6LGPAvOi49OXZ7y6OU9zAxGTex5fbFCJhv3B60vcq0q+bx51PD7fUNqB2/2MIbHPAMNgWX7rlkwHDn3G7cMcpSOHJscfsmmI2ViR59hZGlLOPPsuJ6D4+vkNP//BO/K63Aszr6J4qTeWmMNuPWPfaTARd9kQoxSYpyd7zOmOzHiUgrbL+LWPn06pvWfzA7ebGW4wmCxMcm0J1NLT81DZAK0mvxNp7nDhoQjQGHHC0fKdFF2aXwjH7tEXbvvN2K0v6KH/+u1LDdJ9ruhmegLc2SEegfdepaCE8bUIWzjqXtOZa5eK9hzmn5JulkQ1Rvnf8f2mHb9004ePQEMnBxItgD3fCBgUzXICoH36/zGZM8kvotGT/le7iNlGsj3cfdtw/oshsctxcs6AI1PukyRkZNtFTy/7GxLrafoEkNRx8HAE92Oa43ge5MtSTUN5thnDfpLjx8g6Jv38eI6CVVNh4pIsRdxJ4hSp7iqoruXctRcwe5E04OrIzI9BSdEkJ4dRN5401mJ1GD+XbDmC+nGYN2ZJ4xzi5GPtc4Vf6gkU2zYyDm/uHws7354q5i/DpP+H5K0ejwWd8tCfQHWbZAxafLmzvXzOCLKJx2Mxgxx/vzTShXFxsoOcQHccr4GA/e1biu23Apf/WItffHE81zrIdR1tM48dnyQ/0cJek87r1C0Z90/J2sx20vlpzsW33fQwVMffL50QYf6zg4BmV0IoFHZvcDPZ52wrQFjOUQLiHpYfiZtSyNVvSBkdC1qVJCs6daWO54FJkqSHyOy5AiVraexaHJ4qZp+l2y9ZHmb7dE+lQmBIVqh2f0wKHTX22T6IW5NJDkcpTXeUwuRbSatFK3wllnzZXnz+h0WW1kcC0WPBl4pdVyhxAQqRYa7TF6k8k5SH5pHi8bMHcut4/t3HwlY68euOC4fWETMTAKkUXKx23O9quiYjNJZuU1CfNGJXVyvOl3taZ6nLnovljrtdTbMvcN9umM06mjaj3eboQi6Ebyx3pubx6ZarhwWFdVxfrdCZpz49oJTcf85JquegLFnp2Pc5rjPYAnQRiUGTL3rUMopOOGToZc9XHt/io+b1eiGWkLWwDlYHXqxXlNnAatZwez/n5GJHaR3rQ8n6fkZWDbje0HcyCIiNYneHPFezrWLzbQVzR0hgJRgZcPV70X5zMIRlQGei78YE4qBRuQxtmjzw8vUJJgsCfjUwC7z71SsGb1gWLZuu5Pl2xVuLNbn2ZMazyDr+4Xe/Pj333bLBB03/fCZhQF5mdUIVyE9bvNfiHqKgOGk4bEt2u5LQWm63J6jKcdNZSTP1SthUr9je1RAV87qjqjqawTIsLaGxwpxmkeAVZmOJW8vD65JNf8ZwLm3C5eWed0/v+IX/71elYJh5Xn1yBllg9f4Di7Ljs+89QgW4/qXLpCf3EmDVGNSg6DNJSc0eN6wWDbO855PPLrDAti3QSjzXL2c7bg/SyTEbQ8wibpeRL0ffVni4mcPeoE96YlC8fHWJCnCXietL8ehAZj0+KGZFz7YtMDrQ9hlZ5jj5+i3vrh4IUfHJ5oTXt0uywjEre+5u5zJUDNzeF+KINGhwmmzeUxYDh6iYzVqc1zhnKCrpKmWZZ78uUeuM6ut33LY15byn3RUo5bm7WaA2lrh04n9feGYXe7o2lyFdFXHe0GxKcVSKim4tD2uxbYyEh5zsrR036xnuXmY/go7H4dioIA3QluVA31sGrxlW8izRjYZGujK+Cuhenu3qYMShpvRw84YW8re2L+T2pQbp2kdJ74wkzWdix/ujDEBv5cvf1WqSXYAAnX6h6U4FoE9DfDA9iKOG2cuQmEphu0cwEXImJxWQL+CykVa9K5lA4QiMYHQiiZPn+ch+jhZ4IiGIDAtoLvXk83xkw9O+RXm/ccfAGBNT0E+MHL4d0R9qXCFMrE8Fg3JgBjV9pna8AaplX0Z3kGDF8cQnoBVter8/usEcQS9Hj3B/TCJVITJokYeM8ov6Fay/psg3Iocp1snWzss1GD3JlYuY4QicY3Lh8KWEPUVzdL9RUUDVCOLGdM3AsRAZBwRHtlhF8XkfGXUgBeUcdYBj12Sy8nud5DkeiAG1OTLzI0AeixyZc4goq8j2gcOF6PTH8+RzkcKEInUFrFyT8j5S/w+aYa4I7sgoj4PN2kkB0S+VJGS+IczrlnoqmGR4NuBznYoSea3diduBGaA/TTIQEkBP8h9NWh9BXIAAhqXs96T5HllrkgSsO653VxzXkzLH/Ru7LT5ThEpA/FSMaWmhi2f5sfCzB+lQ2WR5uHlPkW05atsVyRufqSOUbYXJ1klqM96DqpN/H8/jGPwUjLgMmV4sSMt7kbmMA7IjCI9j3kEE7TxqiLQXlnwrzi3l3ZtBTseMBdtGHr4pQ3jFHVz98Iz8UQMRTn7J0DwynP7uK+52NSoxeHnSyt7tavomQ5tIftZITH0xUM0PMmCqIt2hJETF3e2cvBrScFykGyzWBupHOzY3c5rXM1TtcK1l2xbUVce2KalXDfOyZ9fmdJ0lzx3eaYZDKkg6S7fPwWmGqHhokitFbyCAygKqV4TW8uEnj3j/3Su0inS95WY9w/eGK70gbHK2ZZKeHAwPnZ08pE3ucb0h7jJCr4Q5bsTZRjnF+lterApLL8BMR5llzyUynrlokKk9cZvhK4+tBzwGEDmL2+f4rZHkxr1FzRy2dFys9gK4veF6P8eowL7L+W7ziHnZ8Wi2w+rAd95/zl1b03vDIu94aCvcIOy52lnCwqMLJ8O1zhBaKxp2p2BrkYdhJJZeijErXQZTenyXnF2KiC1EH55bR+8lzVXPB0IjnUFfHQc27VactbJbSygi737jHoDs2YHL5Y553vHp/QlVMeC8phss5ZMD7U1F/ZWdDAu3Ob41ZCcCYE0KwXK3JQ+f1tyWERZOBn29xg+aeFuwHU4nJlcDulNwKdac9Vtb+l7WX6sKbO4piwFWDcuq5ephgesN7W1F22uoPYdhhm41vg68//5rXm8WPOzqozf5oEVSM2ixLDQBvRioauk6GB3QVcQaz7zoaZ1FzwPWBOp84NBnNK0Um/1dCaUnzDz9YIlRURYDRT5Iam+hiGeequ7p8hzfWPbJ314Xnva+ZPVoh63kWmkVqU/FnjT0hnzWQ538+Xe5MPSLgdXywL7N8U6Lk1KTkWVe5hQ2GaZNLkCddC+iFQcgSk9wGr0V0sDsJSOAWfsvgkb/Rrc3DQ7+tW6/xaR/8TdXKYpBvhB9rugXMjDpSyZLQtMKc2mT3V6wCowkS5p+ZOoSc5cCcUa2XbTbgWwXMW0g5Fo8nGstshirJgZ7soB87aWlXo6APgUF6ZFNFxAaCtGUj0Nx+S7QLUVXXtyJD/kYoATyxW8TG2qTJZ2r9JTMiZLj9Jli+X3Rxma7BKTGxZwkA6Pt3xiYFBVTDH00wpyKl/UoeUksbH50lVGpnT8NiKQEC5+JXAWY2H/tIzHIvh2eJuZ2IWyuKxUxFT+oJBMiOdAkjTlB/j6C4cmZI1N0C0lCdZWeQNvovjPKLkbgPKkzlEK5CIajh7sHjewnSUYynv9gRLZju8j+iWHxPOnFR7eS0Zc9Xe9gwaY1JcVhAsadRNnbTlh2V6nj3IOXz1x/I3LxC0dL0FFDblvwWZxsKKNJjLcRRn1kdn0m622YaYZaY9sk5UlPinx3XA9j2JVKAF2Ho1Qopp9lBwHq1WsB9N1J0ni3IzudipvyyIiXDzJTMNphSiDU6Ml+PFcP34zULxSzV0fGf2SkTROmQe1oYPOexjSw/DAcf88ogcml4AsWitvjuhkTd02X9rmXrpRtI/1cpyHvOAF5omjTVUzyFq2mDADlI2gFXmY2gpV1qwcB6CSCQCxWDeV9EFlblDUuKb2gZ3Koi1nLdj2nO5W18fL5KarTnH3lgabLMDrivLioECFcFwyuJJw4brdSdcegmJ0dOJk1xKi4cZpuU6B6TRwU3cxja0eeOcpVK+CrtxgTmBU9J2VDM2TcNxWZ8Txa7Pjs9oRl1XHYVJhSxP3+IRcdeCb7IuFEAqBt5clzx743LC92bO5nfPj8EqUiRT0IMJsJO69XDctSUka/ubqm8RmboeTgMlzQ3O5nbHqTiIKImg3EXSb35kkvnuhAzCXshVwcPcYtv2woMsf21RydUkXBo/IU+mSi/BdAmUi16Hiy2rDMO2orbMvPffYO87pjVbd0zvLe6p6XhwVP6y3fv7mg2Yln+m7RkVufZjUCsRAZQ3CaZisVo72xhLdbAeOXHu+EXccrGcC8r4lVWvozceyYLYX19UGx6wpCVJwsDziv2Uao6p79pmR1uidGxeb5kuzeEN5uyQvHL33/bYmNV/DZfYkuHfWikyCh13PQEbM1qCyyuZHFqDoNZeB0Iamzu31BMet5+uyGIRg2TcmqblIRCVntOXl8R2Y8d03N4Ay7bQkmcr7cs95XuGDQOtJ3lqwaJMinbti0JS9vTigrcbSZne3YHEpCUCxmkqza9hmv1kuKfJBZiRRyhI3k856T+YGTqmHXF9xuZ5M05XK543Y3o7Cem+1MCkvSM2neczo/0A2W5UnH/HFPaQeutguUiqw3NU/O17x4fUI8WPR8QJlInnnm5Y5dmWN0ZL8vpHCs5P60NtBuCrLZQPCactajVMQHzeVyR4iKBx3IM8f6bs79/YyskELZIeu8/3QORtyBAOxOQ9KfF48PtA8l9ioXv/1BYXqFmwuznr16AyT81vaF3L7UIH1sYY9OG4vnEVciFk96HLJTMpyV5B7imCFsaRgHM0MaOEtsnU6x8ZCY2eIIWAHKO2ktKivs2OjgYjphWX12ZMVdJeBgqAUhqqjoMyNa4VpTbIIw+isBma5W9CdQXwlD2a3EvYURFIekT09AdAzHOUbBM4GXoVbYPUdvaJXcPOLRAUMPAQqxehoBaz/Xk4d4cyGx8ovPghQ9XTzq1BNzKgN4IvMYB1lHNxmdBld9roghYndyfCOocrOjG46rhE0VljPJiFLBNBYX4+8VJxSo7kQfvHtLM38RJmY5WjVpouXayzX9nDuKeqMA0cdjAiCx9yOzHywC6q3o+UfHn/FciOtIJN96fC7R8Sqx965SdKciA3FJz20Pkd07kK+llS87DeWNoMXxWHUv3Zlxvyf5jWNy5DE96H0grMTlIjooHkIK51ITOz3M9OQnrgfQqUMwadk1k2WiyMeOsqnm0fGeG5lr3af3JsYbZN/6uUpFTgodSiJMnx3lUcHC+T+P+DIN4KZjCwlUT+meiYnPtlBfJy/9ToJCRhnWmNA6guj2wmI6caKp12EqnKZwp5WmWAeGIHMN2T5i9pF+llyEcjUFNRHTzyrphESrj10nc5SYKX8sDsYsBHuQa6cHePT/8bhKs/6qQvea249Pyb61p2ksNJZi2dHvcu7vZ5jMUxUDZ/WBzluWVcdmLsOAo/1h22f025z9Xc3hvmZ5seNitefy6Wv6YNgPOc4bSjvw0FZ4r2l3BTEFsbS7nNtahuXePn3ABc2r9RLfy1BkOe9oNwXRK/LzFu80/mCpz1pWdcvdtqa/qSiftRwOBfSazc2c8ydrDm1OkTsZFDRebj0DRgeMCizzjk8PJ7zeLXhn+UBpHHeDeLzPzg7srmcCZreZMLh5QHUGUzncLlWFWUhOK1rAVD1gjafrLfl5Kx7SyQpSqSgDeiqKC00rgL095LyMK+Jqw4f3Z5zUDc9O13xydSYOLr3m7vlKmPcnhu88es3PffJ10Qvn8iAKtYdeo3cG3SvcwrN4eytgs84wCoaHAhLjHhVgI5thJtr6WU/fadRDhgLam6U8777xwKo88MMfPkHlgWrRChudD9QXPctSdO279kRsez+o8BbUs54n37qeHHyMDgzeECPkb6/pektTlJP/vs49qga3y7j51QtMq3BPe7wNfNKdMZ+3bK5nbPWM8ydrjIp0zvDifiUyp0Gjc8/p2Z7COpohwyYrUOdkbmC4qnABPp7VPH72gNKBw66Au5x9HtHLHm1kdmK7rlidHric7aaB2H1fcOgzZkXPri3wUbPtSqpMJDSnswO7rmCW9bRFRu+NOPsUjvms49DmOKd5+eqE6DSdq9jOB2zusdYTgmG1PHCznfE7v/oJ37+/EEvGNufhds7bz24JoaRrLWXVE6PifLEXv/NthSk9wWvcLsO7XArBCA/Ws7+aQR4Qr4FIVkqHzJZOZlI2mXy3R0XIpdgbO/lmbRk+nmMj2IMkxmb79OwdFHaniG84ZX2htt8Mlvu3mPQv/lY8BPwFUzpiv1ACXjTToKQexDt7BDcTWM3BJr/raeDNHSPPx8E8Vwv4DiRJjBKbOO2CDATOLTHZ8I1DaWMQivbCOPpMwF6w0s4fW+YSiCLvs02EKNHz2TZZ4HkoNjExdMfkQp8r7n5/y8V/W05sa1RMIFlcVNTEJo7JiSE/SgDGsB9I/56NAF+x+SrMXghDXV0H7r+taQ+afDfaMyZpwOwNrYViCr8hgZxRzx6sfDkdHiuGpQAacwCVj8fDpIH2NfjUGZiY9ZjkCqNLiJbfO7KyoVAMM7j6HQrTKLJdSmRN5yLfSRHTz9K1UaCS5eJ4LcRHW0/AHSXM8eT4ExSb9xTLj0USIUWMnGPdR7I+0M81eR8JNq2TJMWwbZws5LSP6OQp76rI/FN1LBhiYqxHN56YQrVGv3oDu3cVi49EErWuNPWVyKfGz6puAu2p5vBIPM0FxAtA90mqMp1zI8foE5uvhzcDraRoso24ptiD6LwhdR2S1Kt5Eskf1CTpUh7Kez/JlMRnnKlbFSyTxl/kLHKufXY8P0OdXJnSgG57Cic/DCnZ9bjkdJ+cmJRkI6AUZgjUrwbczEyafJ06LK5QZLujred4TwYja2gaCoejBapRfPKHA3bR8/RnJARlvFbjoPTyE4cr9OR25Gp5FoncTIq0YW5SKBmEPEg376FAzwe8C/SHnMXZgd5JmI9RgX2fs21K2l0OUfy1s8wzK3q+cnKPu9TcNzXNYFmUHefJzk4TsSqwqDpebJYYHfnm4yt++aNnKGdkSDEq+qCIXvHDLuP8ZMd753d8xBmruuVmPROtfB5wvUEbYdLrsqf3wtRSerav5pjlgFn1+K04eCyqjjrrybQA9NyKB7gPWoZH9wteXa2YLVv6YLgo9oBIe94+eeDDdA56r7CFJzjxF3fbXNj8VEkrHcBrohc9cK/A1CI/MFb2e2Ta87qnKvtp7VgTiFHxeL6lNI7H9Y5cO+66mp/8ymfctdUEdJ/ONrw6LPhnL57BZQedoax6ujafZAlo8HUAG9l+uhQ9/cKJjKVyxFIJi20iNncCcLPI0FrYWfK39nRXNYuvPvDw2YrdBydsyiWm1YQZ5Gdp2FGLFGcIhsvZjnA2QKuxX204qVsy45nnHY3LeDhUlJkjt45Dn3Noc6qiJ8w7YlBY62n2BaEVGU2oQupqynkfWsvmsyXKRtRBc//dc3k21IH3vv6K1ZOWg8sIUfGo2nHX1WgVAUk2xafW5dwR9wblFQ+7CmsDs7ojP9tSZI7eWVzQHFJQVtNlNEVGM2QMzrAoOwrryIzHmCAONMlJh8rzcKjwQfN6t2BZtHSuoiicFEpdxtn8wKHPeOfJFfshF+a8rVAq0g+WqujoB8vQWn72u++jGoM578SVB7BKmPDmoSQvxHHnxdUJeemENR80Oguo3LN8LBr7KhuE3Z/vpq7Abl9Oa9L3RgB67eHMkRWO/pCJk1BjyLZC2g1L6V4NSzCNklkbD2pQjBa6v7V9sbcvNUh3tZq+gLWLRH/UF49yk8lXO20qAZJR62t6UDEmXfAxzAgg2ORd3Yt3tLCACndqCEZcOooHT9YGivsBV9sUuBOxe0d3lk8gX/lIsY8TGDH9cbjRFdAnuUKxCYR7Nf2/zxX5PkxuLCC+5/aH1ST/GAOAtD96fedK9mN09xgTQyHJVeJRMjD6e9s24gvIt4r6SmQFAOe/GHCVoj2Vc1RfBdSkZ5fXRCUgZ/9Ek69l0M+k5FPjYfuetPyLG3l9sY6sftixe7sQOUCepBSjpng4yhRcJdeseEiDof0I2GO6xoqTDyLNhSLbRmwKNBo9tYEUiiRFhu1GRlvTXKaCpRPmOE9+57qPBOLE2PsC2keBxaeK5jFkHwrYJEiMvPKpC7EymD6Sb4Q5HbXzvmIqGkbJCm+36F8uUd1RtjFJPpKkaPy7FHGw/FB+R/s48OQfpvugFLbXtsL4VzeemDTRUYk8KyqobzzXz+w0yJjtk8wl6fd9BcEfuyzjMKZtRJpkm+Q3n0thrIHq9bHIML2wPIdHNjHocsy+SIXZIPcak+c10xCtTYB67BiMw67b9+T83X1bU9zD/KWf7vmQifVbyBW+0MmtR+57M0SKdUiMvhQLkPY/DSa/+gOO2a/mFA9qkryYgSmtV7oGEbsx8FBNVeKbekufEnezJpDtPZv3suk62y4yzIRJH2dkfCmD0FEhEombApVF6GG7X6BXPb6xXN9UMHNwsOiDJtSBXmV0rmDfz3nJBVSeatnikgtIjIoXr09YrBrO6gMf3pzT7lLwzO0cnQWwPaenex42tThfFJ4sF+3zti/IrGeWd1w+3XG4zPjs/gQ3mKQ/V5Ke2FuC05jSQ+Xw6xwqL2A0KnZtnsCY5/FyS248VgX6YPj0/oT9bY0Kiidvb6jtwMe7U149LAVor8QtpMwGDrljd1sz5SIkx5h81tNvC9F45wGVy71Br/GHjHzREVLyaXDC9I72fVnmqfOebVOiVORWz1gf0lCf15NfvDWeYbA8Pt3w4fqcWd5xtjiI/Ai42c748bde8ovbd4VJHyDbaLFSzQAP3ipM7QidETmUU6hswGjpAhAg9BalYF51nL7f8Or1CSdvr1n/8AS8IpwMYCJNl9O/rljPHfpBHrqbcCra9r0mXi24mc95+p3XvN4teLrYQC0SvtFesMgc1gRmZc/T+YbWW16yZBisdEoaizlx2FwCh2zhcEGhbCAWmvfevmLdVvigJNRoKyxw+eTAPOvZdOXk25+/c8+uzafOT19Z3ENBf1diVj3DYPCdTJHHQeQdyitiFgil47PdOdEp8oXozbs2k6RNFdGLgYvHaxZFy1nR0Ho7pcF+8PJSvNaVzDlEE8R2s8lgBZfVnp/9la/y/vuvuW8q5mXH1f0C38l7lE9dmgiXyx3mJHC1nYuu/VQGtovMURUDt6+X5IseD0SvMIVnty1RJhIXDdt9SYxSEBf5QJZ58szRdhkeg91p1EYznGq62sDWYjwy35FHeNYSGwt7Q7QB3RkhskpJRxa3si8mnfxF9Un/N7F9qUE6pPa8UcmST4Bev4LqFSw/FW2sq7Q4VNQy1JnvmLTAIzMmUg4mbfrR7SHiaiUDjilFUdI5wySlCLnBn2QCKEtF+RBw0aJCpFj7NNyp02AiRx14JkOF1V2YhkpH32aRuojVYnsqTh+j9rlfaFY/SJZ9GTTnYtNWPsgXyHgMwSpCpY/Db5mAcR1V8icfA5rkjnKlgPDyJgH4NyQhthUd9eisEvKjfABAIeesfp3OS5YcZHxibbVck5hkByFT3H9LvhzzXaQtJNVS93JNdm+Lpr5+BbNNTFaXaeqdNKhZKWx37Aj4XFF4JmnLm44gkyf6yKgepMDIPhbQvH8ssodRLnN4LJ71wnwm6dNy4P5bOfkG9k8Uy0/C5HYj105eN8z01In51v/2l/nu//E7U6E4DTYHcWnwhUqdjFGnI/+NenKdmGLRoKspIKd6qQlZsgIcJV9JKoSS65slqdMov2iVoX7NpIH3pRRQUafBr4bJJnGUHKkoUhe7l+6H7hITHoQxDgXkD0zrFj4viUJBvokpvXPsZMmA8OhJL/MXaai6kWtR3ss6yh8U5V1M/vmpmK6liNHj/ZfpKZjMVXKOxrU8/ry5hMN7jtkPLPlW1l/xSU62Zzq/IoVRNBfJIhS5rme/pCjWRztUuceYLFiHWbIKHAeTjWSeEKSzN3bZXEpu9Ysw6aLjCDAD4g6yzzDzQfTXjSFmAZ70GB3JczfpXJ2XUBofNfPljk1b8vp+AcDXzm7ZDTlfu7ghXChu9jOGYKaQnoPL6CtLm1jmvrN0h4wHN8fWA22ZcRhyDn2Gd5r5rOXR4x259nz/+hKiQptIXXdsb2dkpx1Da4V97S1F2aN1ZH8z48N1xXtvX3M/5PiosCYwvziwv6/46PUFMcLj8w1aRb7+/iseWgmBWZYtvTcCggaNLTz9Ngcd6fc5dBpq8Y4fOisJjBFiSLaPSjM0ZpIXKC1hN8NgyGvPo9WWh0PFeb3n/dUdv3YnBtWZ9gQU/WB5fH7Puq24u5lLOFGEJ4/WbJqS01nD6/0CsxaG2NeBYQ7hdMDWA661aCNFAq3B7DR+5XHJLsyWbkoZ7TYFmQ48nW+4ultwOdtRfWvgdjOT1wSR7JTvbIhRcfrWLYVxrNuKGOH2exfoXu7pl7/6iPLdLfdNzcvPTlFOk180zG3Hw+0Mk1JFfXKemZc966DpkzOJv8+Zv9PwcLWQx1mrJUckwuuN/GxW9Dy5XJM98VNI0W1b0wwZr/cLQlTsOznOvsnQNuA7i+o0+Vt7YvJkf/vZLe8v7njVLMjTeb/Zz2SQOHUMYlRU+YDWkWzZ0A+GMnfcbWquhwUf7C35WUuRO949uWexkH0/ebSlsOK7//p2SXCGX33+RH53PfDJ1Rm+sTxEpBuiYfX2WnT+tzP8wfLi6gSTeb5yeccHHz9mdbHDmkA/WLpB0lX7Q4bJAibzWCMytRgV3WAZmow4iOxx42R9tkEkZ6rTuIWfChOTeaq3Gxnu3RXoB4v6rMSoNMuU1Fq+jPgqovtERuy/gFBVKpPfnM/5t2D7UoP0zfsKkyuqa1j/mMc+GOafChM7ey36ZJMY32wvAQITe4wAhu4kgayknVZBPL31IJro0fVlBEGmj8cSLh4rRtMF7D5S3SSgnFrvAFoplPf4egwz0vil6NEnjW6uGOYJhClhLrPd5z/DZwJKRgAocebSVi82AiImrbQTWYcejudrZNlRAma6pZ6kEsDRzaR/Y5hOHeUxY4gLSny+gxlDb477+WZwzfgeFMyeJ3CuoLwdpQQCvJsLYZVMl9gBC/Vrko0f7E5TMFI/AvIE0lxiXvUoXSGxbglUG4VKeuVRHgN8bpCy/V/f80fe/SV+ZfuU0gz86v/px6V1XUB5m1jgpDvu3w9U1/L3w2NYvydDv6YXBxt7kGHW0WIwKvjFv/0T6CJOMpPxWvZzTXT6qKcmSWGG9Kc/rr1J+z9ZbUYWnyZAqBT5NjDMBKgyzlMk+VEAYib7NrkNmWTjWEphMp4X7eJk2amTxEd5GWQGkbxMXt9arAqHSm6HUdc/dj/Ge0QPIlsZ5z1Gd6WhOrrihOyNojKDh5/wZPeG+hXMn4dJ+y9dFHFccbWedOtjN8inHITp2ifpmukklXT1yxY9HK/p/NN0Y6T96udyz2fbN9Z9TDab8IbcTdbZeH+M1q/dSh/XfJQiSM6lHKMAdlCzgflSBjnvXy7FHnBj8XNp+ygd0TaQX/S061JSPBU0oeCTm1os3EyUhNJVw7opCUETvOYrTwWgPzQVF7M9H96co3UgBC3OSCiWeccuK1jVDb2zzPKOm92cVd2w69Iwng44Z8gyT9PlvI4L6nzgrdMHem95ebNie1eTzXsBI71m2MpNddC53IdFAB359OYUpSJ1JUN1J7U4fLx8fcLqdM+yEA/tbVdSWsfNdsZXVve8eFiJnrv0gBfmHrGRjDaiDpb+IJ8Z84CKCrs2cCbn3yQGXdsgya33M7QNvL5fMGxzzp9uWGYdi6xllve8ultiM/G19kHz0YsL4jajfrojBE2eOa4f5vjBsL+vqFYtvg6Yg5b98Qr7OsfNLehINPKfqjweIBNnENdaCIp4V3P+4zfsTWAImutmxtuP7tEqihzpvqR3CmrxL1cmcrI80PQZn9ycwyYjf3yg/MqG5rMFce7ARA7PFxxYoIwMGvb7jPVHM7QGbi2sxNGkyB23D3P8fS7qwuVAzDVtn2F2RuwkHzU8Wm2npNhtV3Je72mGjE1XUlix52y6jNx6emXY7Epcm3F2sWUY5PrMTvdkl55Dm6OzwH5T8tkPHvGZfyxDk8uen3zvM5SC1y9OUL2GmePp4weMDuzanJOy4VW35P5uhjKRJ5drzOPA89fSUfh0fYI1gUdPH/BR44Lm5n5OUQ7UJ3veXqy5bWvWB2HQMyPhWpnxZNrzwaePoLHyXaYgtBB7Q/104P13r7g71DxsxIHJJs91GoPfWnxUDBHckwN11YvMq+4lS2BQxCYDK8mso/tinHvqswOHXUHY5Owfcs6+8iDXXknYlf60mjpJBIgZ6F5hD/JsHn5L7vKF377UIH35YaTwwrhVN5qHb8Dma5GLfwbEsQ0uoMb0Kd0z6deHWbIr/J/vZODoB0vOfkXA+vylIE2fK/ZPVAIeMkwpMeIhWRom7fkQCGmgLCrRq6sYcbVhDOnxtUENgcypxHT6CaArL+4xygugmL0OrN87DpVmhyNjOkpQRmYvlEcdr/iMK1yt09/DZJGY7T2+0GkAVu76bH8EbmNHYZQIjXZ0wKQpHzfTAym2PZBAZBpmHIug0fklahk+ra7jlIA5/rtOchk9wM3v9tgHS/4gDj0hP4K90a5yLGBkqA+moccExmzLFBkvji1HNnR03hCtsZq85P83X/1Zfnn3jIeu5H/55Af8wsmPM3sliZkqgmqgOxUWuPxeiSvHYgHQAmBH545h/vkBReXh8ASKOzX5gpsBXv2BgfKHOaZ0DIt8kg69Kcsa2eixezBZhIajfWd5L6DFlXp6/yjVGgu/8bqNw7shDWm2Z5LKGhOYn4rNEKcvhVE+E42ieBh18se5jlG3P7q6jHMfcMwOcKWaChHtjgVH1FGcVMJo2amnNfX0Hyjuvs20PnWSnYhPuZ4KxFGylm88ug/42si5OHh8KRIv0wuTPibL+sT2jw5Q4/007p8vxQ//5fvJZQGR/QxzKTSLtXzmUB0LG2LEOMhuAuu5nQo300bRpldS9IubEMTBsH25gNqheoVqLGHmBZiYKAOR25x2n4n1ntWY65yQRWIZQSOhKAEK67i9n0vqolcy0LfPUSYwBEMIirp0rLcVnzw/R2lxXanLnkOfY1Tgw+cSwW5MYHCGuuxpe4t3Bu8MNnc4r7nb1cQgjiAxKDAR1xnwCrvoxT1mW0gBYQI2k/jzMdhoc1/z9rM71oeKzc2M3/6tj/ng7pxf+/ApKgucL/Y8rncoFXm+XbGoOuZvd7RDxqHJUToIo7pytNsiVYoBtbUoZ4irgbgMdE2GMmJx6A4aUzj2h4LZsmV/VxN6jao83WD5+RdviR1fHlAm4IDMeE7Khq+d3vLR+nQaPs2Np2kn6yoy6+mcwi8CalCJVIgCxgYlna48wN5Kuuw2gzRwGhP7fnM3Jysdm13FXTcXeUMRZMBXAUWgWnRoHShz0VkDzJYt2dkercRlJC6FBVisGsqLDbu2QCkhaobBMP+xHetfORMpTiEFWPNQoXaGOJMCQN0UaA/92hILWeeLupUhUK/Z+JLrqxVXrPjGV15xXu/58OqcuuoJXqPzgSobqE4HNklOtJw3PGxqtpsKk3m+8+yVOPmUM5SKvD1f8+n2hFdXK37+47fRJvDV915zUrRoFXnoSn744pL4kPORnUPlODnfY7TIWJwTi8p2n3P+RH4eomJ9qGi7jNBaOqAue3711WMuVzu2dzX6IrD94BEhC1RPxSnnyeM1txtZ3yfzA7cPc8Iu459//x2UiWS1MPpDk0GZArsWkrIbtxkxhSQ1XUb3upYu4nmL6wxFPeC9Zrgtj9+lTtF8uEymD4pQBu5eL9EbK9a4Fvws4CPEkwFzLcVvmHu6ZcTsDXHzxWSTfzPkLv+2bF9qkD4Oao5a7eUPk0Z7I1WuTlaF0RwdPlRKRsx2woif/t0ZwcI8MWDBHgEfERafjQBDQE57oijvE4ApddqPOLW+p4HBMA79CYiOCmJtpzCefmHoF9LW104YRNPGKc1xWEF3otOxHG3r1HC0XxxbYEGDfSMwKSqo90H2J0pRMczFUWYEsMXDgKnMBM59njx4R/93FynWaWDRSmt01PePvvGjnIDEtLuCCVSPbKIeoExM7BgmM7L948Cr7eDyfzT4kmkA0jRgOAJ95ZmAlnZyfUNKIz0y44lBT8z5KFnSaUDQdEzhR+OA7T/bvMNFseP3vfUDrt2C8n5kihO4NNLRyKJcRyLc/QQsPlS42RuLcQS5/ehpLhru5UeRYa7QB6bjvfz7MuG71bXo0xUM5ugIBGn+YdyCAGXt3wDTXaQ5N7QnisNbkZPvyrWYCi991ELbRmYEDo+s/HsK/4EjAz4dQ5JhTZkCEbpTKO6PMixSM2kEtpPDT9pXX0oBrAcZOjXdG/MQqTtiWrF2nFyT0vWwCdiWN7IfzYUi3wSi1nQruU+yvbxOD0GSWWcam86XbcM0F5LtYmLU42TJqj3gjoWVTvMNSjFlHhChuhKJnPbS1Rre6ghXBWacZelkLeyfaoaFmXT8ozWmhFmJlGckBWwT8ZVEjA8PBbHX6NVA6Ayq16iFOE6EoKDyxEER1gIK3cpJUqKK+E2OGxR25rh6cSKdqos9u8HQH3KKRUe3z3m4WhAD4gFdDrz95Jpce3ZDzme3p3K5Qio2bKDrLeeLPff7WnTjWaRatOhkB0kUll+piNIabSIm87gkxYlRsTjf47ymLnt80CzLll0ndF+XeW63M5ptQXnSshty1tdzfuLrn00DfSEqbrczFlXH1csTuR5OYRYSdIRXnD/e0B0y1MxLaunMY+qB+KLCrxwERX1+oGsz0NAfRB7jKwM2kC865nVHnfc0Q8bDIA/S6OU8rZuS06Lh+XYFwL7NOZsfuFnPxUrSBrJqYHNfy4CoEo2wXwZh1J0ilGl+RkdiEdBZwAPBafLZQL/LUaW0fbrrGt1osnf2rM63bJqS4MV95WTWcP39c06/do/VgV1TELzCXVfYgyIUkVAFFo93lNlAQDEvOpSCXZszOEORO3xQlN/Y4L0mAmU+0JpAZwqRanxQwY/tmFcdm53IEFeLhrPqwGHIUQrKbOD80QZN5K6puf3kFHRk08rzzM4brtcyXR6joneGqhiYz1pC0HS95VdfP6Z7KGSO6NmGu67ifl8Re83JuUi5Prk654c7KbSyeS/PpbnDlI5Z3TE4w8P9XL67Bs38ck8sBuZ5x92h5uZuQfQak3uKVcus7Gm6jCJ3ZNpz/njDu8sHrn68Z9flVJmjtAMv10sZJt3lXN+dQR54670bXl6vCIPBv6gJRZAAqE5D6SlnUpw2OmLHQVMTGE56mYnwmtAZ2n02EUojuZSftpgL8XEfnJGB03xgd5qzv5mxfLRj+3ouTHxnpu8ymiRh7RXD6Rjj/FvbF3X7UoN07WSIUryMYVgJo+jLI8AZLeOCTUyeGwGUuC5MwTXhOGg4gn6TQKlOenA9RBafeZGZxIg2MrCW7fzU3h9dLXQfGJYW0wR8AvNjwqHyYuNYbMRXXHS1in6mRdermAD2UMt7Q37UpZlO3CP0IDaBRzbyCC59kl10K4Xt0iBkrqfE0S5p6EcpS9aE5B0v58pbNenkTR8/B7xtO57P4+Co8kdP+rHl70pFf5IGTZPPu09BRMrHNHQn16M9U5NUYlgIKBydP456nFHHrI6pnTC5gUgnQFhZ/8YDsVslS86DAKuRXVUBfvVv/Tjhf3VH9pbn//p//neYJxDWL45yh9ElZJwJWH6Q2N0UqqN7YT2moqBnchmSggrKm6MHuRnk31YfxImRHsHuuEbGQVKxyUzyo2T5Z5wMJI6uQX7hMYOZ1phypDmKgCuFkfNRmHOXLAHHMC5XCWDNN8f3jp7/cq0j+fp4jUeNu3ak4kHOj6vk+pkhotL6UCFiDykcKCW4Ri0dHFce2W0iqVsk+3L9OyJP/sexkJPOk+kj1a0M5PpCk68dKkayvZICMxUBpvW42kxDu6O0J75RZIJci9EpxlVHlxspYOPE0isven43KybJ0ujDP31mJ8RAyMRZyFXHomTs7Jg25SjcQftOYoBBALpXwrSmIJnhoUJ1UjRHG9G9Rh003iuWT7csz9e8uDrh8nTLna3pHkr2u4L5ohUJTNlxAzLweciIEfYv53zv04XIQjrR0DPz0/nHQNdmfLY+l8REABXpe0lXDF6TF45hMBMznpcDXSua4+a65uztNfs2pyoGlkXLuq3YtKUwi7scbQNPL9dsTCCzIjW4eLrmlz96i7zuef/yVjzTnaHMBpYXO07qhk8+eCSSDKfInh24vVkQe6l4Va/AJu33ow5rIn6dS0Kr1yxODtK10JG4zVBO0W8t20vF7iDFQ1n1vHd6x/evL/n6+Q0uaN6qH/jo4ZRnyw1fP7nlhw9nzOpuHHdhlvdcB0XfpsEdHdFNSoIcT6pTxIPFpATO/LKhv6pwWZB5A62JlZd5hmcHihRg9T99+oJPtifENMD63nde8PGrcznG5GZjnMKdeMxiEKcT4O7/x96f9NyW5Wme0G81uzv9297eGu892iQzIosEiiRBglGJQY2YMUCoRqCaITGpb8BXYIIKIaBUQmSpsipLlZBRkZFNdO7hnZm7NdfuvW//nnb3ay0G/7X3uV6IggEZaSHzI5nM7DbvOWc35/yb5/k9mxlp1rE75ORZR5F1PNxLUT+bNnRdlC99Mac7b8RUmzjCXUZ76lBvJzwkBapThMxz31gO04zFpGaaNqQxebX1htz07K/PMb+3kSCoKuFyuucfPP+Uzmt+vH7GYzWhbi3lLhcT6mNOsJ7pWUme9jybbcltT3p+T3rpmCUN2zZndnbNzx8u6eJ1kK4ct9sZrteUVcqkaMkXDW1tCUaOd9taPr8/pavFn6CtQ0ez7DKv+HBZc3WYS+ARgR+9eYbWQUKGdMBoPxbz6bzF5fJlW/cWVyZMzw+oVSVa+UPOanmg7SzOK+o6EXNw4mi2QhlKZiLtaqsE1Wuyi5Jml0GjUXHi3jUWZwIucSTWsVtPONwnElSYwu5qBp0mfVqKH+NJB8bj73OwAacV2ZuEr+Xjr2OS/jdkWv+NLtKHQm+QUOgobygvNOkujFO5IYF0QPnZWsygyd5HrnecZEdzWjeVL8j731FM38L0rehiCdDN4kRpCPIJgcPzZIyFHwr+YOTUDPz06z8woz47ewDTCrPaFbHo6aRw6Kay4sqvBvOhICRDG2k23VF2IGFKMqmUZuNIBBmOT/7o39ONh5Fg41I16nVN4yMXezCexmZjwDvq96at8eETob0M0hgY5BHqvW2ETHZ3rzST6xAlBr9e8PeFyHJcLhjFdhUkofQ9bN+A2QuxmDUjei+etzjV7DMTueDhWMSr4z/dRI2BR32mxuvl4WbO/+mrv4s9ldc/fRdIdyGGBcn1MciWHn4/sPhU4+P7XX9fpupDATtMitd/2JB9kTF9I2ZLE02FwzVzlANJ8zX0IWOIjg+yzSH++fhnBd2oqM6kMWmXMP+5JWg5rs1CdNr5+hi2pXu5T4b02KHZGV7z+1N1pY5SEKGkyPsZrgtvEVKFP0p6gpYCHY6NzWBgHUycY0ppVCkMPHKQa7xZDCZpxeJT8FYm8cnB003U0TS9NHFyb0k3HarzKCNY1GAVPrX0mZatQx9kam6gePBjqNBQZBul6CfyHtoZcZslWvth4wWyETn78RAKFc2jsb41tRyv6kwzvfLUZ7GpDgoTBkKSVPbFvae6NLjaHO9RBeSOLKID602OnnaEiSI4TTGvebrcilb8ccb2bsbusCQkgXfVCTp3qMxhEs/JtOTLt2dswwRQaOvkPMXnCI1BzzrsqeN0XpJGPfFgdNMqUJmESdHSpT1n8wNvb1Z4r1msSg5lhrFeyCkm0NQJSdaTpx2bxrJeTwhBcImb9UQkMXFSH3olwTpJS+ekoeyDZrOTTilLe758EGlJVyV8+eacdNLCpILMC2Fkn9DeSUiESr3wzieObNFIwmkdC5bYZGjj2a0L9LzF71L5DEkCwQa6QwJa+OoXsz257fn9Z2/5fHPC5lDw6d25JL9qx00lZsbUOCZJy+1+xmMn7Hmz6ITHfrD4RY/OB/0U+McMPWsFw6hlA/LxD97xwWzNQzPh5zeX9I1BzbyE4jQJs7zh5w8XJNqxjgm07fVEPtezSBeKyZtknsmk4eziwKFNUdOANZ4ikamyVYKZvH+34HGboZyi9UDuYZ1C4fEK0mcSctDeFYTUY0468ly48x8s1/z03RNumgU4ObdKAdajv1PRlSlZ0aGt59Cl/NnDC96ul4QoB7LGo61nUrQsTrdcPy7onaF3nvtqyq7OCAGqQ0YoLR9/+4ovo7Z8ezulXgg60/Wabz25Y99mo5RnOmswxpNoR9tGQk2ZYCYdv/vBW8o+IdWO++q48vzqcUVzSONrqqmbhLPJgU8+eQ6pjwSeqDd3ivt2Pq4J6zqRRGDj2R1yOafRWN0kCZO8HZv4dh9xoU6h5y3N7QQKJ6jS1khqbu5YnhwwyjNNW7QK7E2Oe0hJdhof6TfuiykqCai7BHtQhFnAFR7d/Ne+lH/z+Fo+vtFFureCYBskAl0hhdfkVgxwfS5UlnFa2Qkto50LJi8YFQNcjtNfP1BWgLMfxRTOKFNAK9KdQ8cvcB/xfCbqywdiiwpKCsL4c/N9z6v/oqdZWrLHAZ8RC7RUoxs/FqTt3LB7pSU9cSvFaHUmunSXypS1L46vdyB4EI+D8NTjF6OJxU0fxgm6/AZjMa2CojM6srwDROmOi5rbAQs4Bs5E7bG3g+RA2O/Ky6Qw3UWZDfH4dGICrS5El27645Q26FhQa0W6lsJuch2pLP7IegcVqShSrPe5HGOXRnlJoth9qGiXYt56+s/cyLgeqC7DZD/de/7+/+aP+V+e/hEf2Tnf+Q//Pb770RWf/OI53kL5YU/1XHH2Z4Y+j9P3eNi8USw+lYm0EFUUk7dD4S3/qLh5Of2vMtbfP25rBnMyxMYjQOB4bSJvc0Q2mk69l3wr16nuRULRzoQ3j5cGwOVigM7WR+Nzc2KEqesh2Qoz3Qx0lIRRzpU9xoYtYdTG3/+hY3p5YPIfL0aDbflEXqQQBhjDkER7fWyQh0ZVWOiBpBuCpwJNTNeVRpExzTNo8Vi0c0VzCie/OJpp0//VW+7/81csPo/NplF0hdBaijsdPSEiJxkaP9NBiBs000pScIiT/WQfz4FhRDSOngwzfIbE19wPGzZGssxgqLaNH/9frkE4PNckOznnGqhPNPk63ntaUZ0bmlPP/LSkrFJ0pKt0lZXJb2VRqRslL14H+t5wtVmg/tUC/9Jx9uEjvdO0nY3a8YTVpGKVVZznBx6XE37vyVu2bT4mMf7Vu6dkiwZrPN4rnNNcXS9Rm0TCU0C0771hebqnqlNWs4qmszy72LBvUnbbgiQXSUsfzZgfP73jq8cVZZWBU+TzlrqUYljFKWWIrPMQYFK0pNqNU9lUO5ZPax5qKe43ZU5iHW2UDTinefewRBnPD15d8W63YP1mQXLSCOPbZOjHhNoJLSPkMuFXiRSGAN5pBqb7MHGenh9IE0duRQZyf5iybWTiX+2EhW8ST5a3/PnPPhybAhWLteDjheYVHCzmvMYlMjn3nZYQJhNIn5S0u4xsWVM/FOhG8+XtKQ+lpHQ2m4zJSUX5WEjjBryrVoTW8PyDe16eiYm0O9nSOUPTWzLb47wmT7rx1x7KCWWV4jrDD15d8fOvngheM+85OT3w8Uc3FEnHL2/OactUEJZlIlr5g6G/S0GDOm+YTBt+98kV1+WMZVazSitenq05yStuqymZ6an7hMdDQbkpSCadyDSyjra3bPucrhMcaB112WrWUTcJedKLzEtBm6YcUkeadTxZ7Jif3aNV4PP1CbNMZCgnT3fktscaKfZfP5xQb3LZWqSO3nqenGw5ySo8ElxlFyVnkwO/uL2QMCUgTXt2dYZWUlSfnu3JbC/oTQW91zz78J71QRrGvjcoFTBG/A2hTDiEKSpz4JVsH7wieNlEbN4tJLBonWOn0uC4PIZ4pQ5XJqjUY7I+NjkigZqvKrresCkn3G4T7Krh9HRPeuEkeKk1gh3VwM7is0CTSZPJ1OHSQDh8PcfJfy0Ixq/nW/9/e3yji/RhijsUEro/TgB1DIIZ1v3DaqSfaEztBSeo1SgtGKe2UUsbrHwZS0HI+EXezmUibuowBrgMP3sopot7R3EfCy57ZDgPODjtgkwAlRr/7jAxdpli+Znj7ncN3kK70u9psRmLAm+kWBokK0TW+6BJVwHSbS9ymBhl7nId6SyQbd1RSzy+BvCpFiNrF+ijOe99VKWJkfbN0sTCM7xXDMvUdMAK6sicNm1gcgO7l0LiEXLJUT8+hDkNTUCfKUKUYwypkj5hPD4D2UboLnI8F58Pk3Yhndg6jM3EgMazFXzrf/0z/merP+Fcy9TtP/p3/3f8L/6Df5+LONV3ubj7h6bEJyrqrAVFWFwfQ3acFb364+96lj/TI5bQxsl0upF0Vd3AzX/Hc/7PNUkl58klgFJHGki8jkYpyXvTcxVikWjlQh6aLRWO1+kgp8BDtonT6kPUkfeyRaieQHEjv9YUUpQL4SUe68hwX/2FxdaL0UgMUtT3BWMD1uegMnAt6IIx+Xf5WRDTqz16EwZakJzfgOqJAWNhnM53U2koJ1fy/9lGiqzH/+Mrllsv9zVHo2ZSiYRraA4Go+bQjCfbjnaVSMBW2dPNY9x8CEdvxHsF+nCu070U2T5XYwja8HsSTBRRqqmJWw05B+k20C7k2p/cSrFYPtHUK0VxH7d4SuQru01BOuloDykm60XCcNCy8ClkRa6Nx9UWH/Wv4ZmQUtY/PcNNPXre4pyWYrVLuLpfYhLBFP5X22/x9HLDIqvpveb3n7/lL6+ecXgzI2QelXhs3tN1GtVpli837LYF81XJ5qsly5cbHncT+tYwm9c8X27IrOP2bi7hQF7hG8Ov3lxgUsdyXsGs4lBlokXepejUCTaxTHCdxiQyKb6vplxM9rTecLWf87CdspxXfHt1z+3jK6pOo60fWdfOg510vN0u2DxMoVd0NwX+vObF00e2Syns18PkHtCJx1hPs5PEVBclReQOZcSAuS8zKCAESKzjpCjp+jnFvMF5jXeKukqZnh8wOozP4XtD6BTpoqPbpyJXeVugLhtCI9KfECA4RfdugjppaXYZqleERc/FSkAFiXYszu9IteOX2RkPd3N++NFbfvrFM8y04+pmyatnD3z2+pwPXt5xE/Ga00nDJO3YNxmPD1N04kW2Yj2zeU3dW77/8prWGTFfEvjnP/1YoATLlsXJgYvZntec0K0lUKl4uePj0wd+eXeOUvAvPvsA7zSh09hJj0kc2yJnX2W4XjOf1SMBxxppXl4t1nz2eMqiqFnlFYc2pS5apllL2SbM84bb7YwXH90xSxtS7fj07lw2KNenBK84PdvTtAmb10tCJpSWqrNUuwnNNpM4Dw/Tk4pvn92zSitBUbYFv3f+lm1XUPeWr7ZLvndxC8Avbi84bGXqfXJyIJ93pNbhvMZ5zXxSj2jJvpdk1izr8V4xLxrO5gd2i4zteoIyAd+ZKBPyJEVLkbVsaks6bbHW8WK14ZfvLuAmF+lTL1snWoXf55hK05/0qKJneyP6/UGyJc0fvLs64exiy/3tXO6FzgjRqdGCbM0dOIUpNf1kkFf95vF1fXyji/RgwMVCckhK7HOZhEmSoIL0KMXoJjEpc6F5/IHi/C/lC39A9skPjYWAk8LxcGmwTZRoMEzj4toxctX7Qort/FEmczIBVscCMVHjJDUkGpxUHO0qkZTKncOWHp+JNKZdaM5/5Nh8LGbKdMvI4/axKPMJwo8eCvgoJwix2SBAu7D0hR41+4O+upvqkVE90G6EdBG4+QPFxZ8eCxkdpSzeqlGzK4WSHP/gY6FoFNVcpEBJGajO9ci/Nq38+ek7KTzLc3VsOBop3ARZKc+VRePvGPzUSRKrjemtIxs/klSCUpEAEqe4NhynqpFJLlxwxR/97Dv87ofH2MobNxubBKHjQH2qRwnSkOimW9HJi6wqTmmjhnr6paafxBCm5lh0J1voZ1K460rz8PuBi3+hxm3EMAnwBrQ/ng85rsdCXLnwawbpoKTwH4pLYJSxDL8muvLh+Mp7STfyPoa0UNPC/hX0/90tfW84+48n4yS5m8oG4PAykN2JDCvdMR7z4WcP0/qgGZvW8kJT3Im8ZAw1guhJYMQ4Kq/GplEY5UO2wVGPn+79kRqjQL0nmxmMtkFBuvayuWnl+fqJlUCnImJGYxM8PB+81xwh2wnTShOoHNgujB6NX0u6bY4ymIHrPsiuBnLQsLWRYl4kSP0kPu/EEVqNSwzzVcnhkJEuGvrMjBSR4DU+aFSvUK3GlBo+PjCdNGzXE4ppS1MnFHnLSVExTxsOdSpECWSD9e7dCe+8Ah14vNjJWw4xdCsXHOL3X77h7WHB7WbG919e8/n9Kel5xW5X4A4JKpGkxavdHKMDk3mD0Z6qTgkB+jqhrzQPnWEyE42wrw1KIwx4r8inLZO8xSjPIq/xQfFmt+Riuuf3L97yZrok1Y67esJyUbKvMiHGxIs/mfZ4p2laMRKqRuOnDtdYJknLoU0lgVJFSVyrCUHh1vHGtSKVIQ0oE5jMGpxXdLVl50Sq8GS2476c8sHqkZ+9e8KL8zXTpGXXZpxkFYu05lebM2zqSKbSHHmvCAHMzmJqRf+QkjytaHcpKmr97awlzzr2Xy5InpVcLPYssppUO1ZphQ8Kj+JiKpNdHxS/+9EbfvL2KcErlmnNRy9vaZzFJhI9b41nfSiYF9KkhKBITc+hzdiWOddbOVe71wuY9+jE8b1vv+PNesnprMQqzyJtSKzDP6mYTkSn9uX6hJNZSW47mMPzmLJ6npdcZjv+4Se/hdumBB3Y3OasUy/m5qJjUdS83S2YZi0P+wmJdSgFy0nFw35CuSnYJzlp3nO7mfH23SUhEblOWNYUU0EWagIvTtZ88OozrqoFVZdg+oS6lYFK8JAuWma5nJuHekLbG+4fZ/jOEDotzciq4TqZ0zrDLG9YTUVLXliRlJVdytWXpxTnJfdfnHD24aPo6ltL8JpDRItuS9kKaC1IzNDLFN0dElRMZO0bQ7GSkCPnNFfbBX6bogOYncYVAXta09cW32n0RYMhNoeLBq0Dy2nFqqi43s15+PQUNNzvTtG9DF1UEgg6EJaxCKmNSLgA1b/HWP66PKKk8zcPeXyji3TlwOfQWplg2fqoG7VVGKdv3nJM3FRSOJz9aDCKqaOMI8R1ekTpbb4lkz29D8N3AEGrY9Q5jPrtAaWofKA+MWRbH/naatSru0SRHCQy3U0tpvakyHP2UyM65MaTVIwBS5OrMKL0BpMfQWKCyz+s6UuLcorn/1lE2EWznIqSnKCkAFROpt629CR7Md+1C9kKqP54Q138qUw9053o1LuZpp2JxCPdh7gN0EdDYpSkpDtPuj02AtnGj1NyUwtdxifSOM2/kk3G5iND9UQmzrqFdhE3C1HjPEz6vRUZRPlMzlWyjxroIPSM/NGPpBefSjMxkEJE/y2mWeUDT/+R5Tvp/5xP/8H/nh+1Ff/b/+Dfl+dIRGZSnSlcwThFNY0c98NLWH4iHoch9GiY+qdbODyTIvj9YjUpBefnE3Azx9N/Yt5jnh+vHyHjqLjdYfQVDBsS1JFrLtsE8TKMgUGx6B+edygiRS413CyDiVHRLIWoM/uip88th18sCEmI24OAqWTrABGHaWDznfhjYsEs8iPwMSBqMJSK0fV43RNPqcvk+NrYxIx6//g+9y8UszdhfI5hgj9M4weSkKA0leBBA9Qnsvmwjdz7KmX0Z7hc7okxTTfq2t8PvxokcElJNDUzYifzRzd6EQYDb1DQnJijpMwej7dgFo9SncmtNJt9rmhSwYYWn6aUH3UED2WVEryi3WacPtmy2RW4NhYbncJUGjcTxnY4pJRRRpKlPfUh5XRSEoLisSn4weUN19M599spk6LhfHqg84bCdrLOn21Jn1zzy4czVpGP/vaw4KsvzkkWDdf7eSyughSgRU/YJqy3E5JE4tgPm1wme+tU4sx1IJn0dKXEt09nDdvKorMe32vcwdLaQO0KyB27aU5AJCiPj1N+3j2TD1UdMImX1EfA5D1EVaDrNYtFJRr3XgtmqVco4ym7lBfzDRfTPTf7GZvHKemipastZtmSpDIRHc2ExtM7zdnswHY9wfea/SHnLbAsampn+bsffsHn21N+fvMEYz1v2hNCr0mnQutoW0ua9kzynmadE4yY533h6e5zdKfwhUcXPdY6DoeM5GnJJBct/mlW0jrLthOCilWe8/zAV+sV77444/vfe8PvvHjHts24LWc8HgqZViOyjX2VYbTn9lZkQLN5zSxv2NcpadKzKGreXJ+w+mjNq8WaXZsxsR3ea6ZJyyxp+bMvXjKfV4ToNUmNoyhq1mVB6wynRckf//JjTOL53J3je4W2UlSrWpjwwQam85o84jk3h4Iib+l7g9GBprPsdgXeKaariq4z5FnH5nHC+XfuZVNzn5OcOU6mJZrA528uuPVLfpVcoFTg7GTP3f0cHuV6y1YNRdaS2p7HqqCsMrxXfPDkgT5oXs3WzG3Du2rBrs1Y5hVWebQKlH3C64cT2sby/GLN4umOadbSnlju3qw4e77BGE+Rt2TLHqXg7mFGVnRUUU++PDlQNUK66fdiCA25o/aK0BmCh9pJY+xPOtGdm0DfRJawAveQYmrZmrk00C962rzlZj9jnjdk37kHYHMoaLYZJu/xZYKuNaEy6FJjGoWrc8g9of5Gl4B/Ix7f6DPULhTWyvRsWI8rB7YVyYNPolwlFqlDIicgjvo4RX4fITfQUUwNZz8JY7Egf0fRZ5CXAXPwMHxRx8KhfGLIH3zUfxNJGZJyOqRKqj6Ixgzhmes+jFPQoBW69TGYx4v5NBYAykNxH0bzZLdR8LoQGkgGu1fENFOho+Q3oldXXkgwzWr4fyNFrIPpO49pPbaKut2ove8LYUwHJdSKAaEXDPhYddkmxDClKHUwotfvpjrSahgnov7sSN/QvZw33UsjZPdHyoiJGDui7AJkcmpaCRYiTq6HSbRu5bkPT2Q13s6kMB6kFIN2PbRhNIAGDRf/MOe//Z/+e/J6YkKpCoBVJJUc5wHDqHxAJYIEHLjg++fSJAwFpK0iZnJYyIRBIiFFbvksYDeGZqnI18NmQv6+FpnjKCsaf0TcBGgv24xBQqS8HCsbvQguiwP0EMatktCIhukwET8ZqM6EBmNrea3bDywuk+aiei5ZAqOf4L1AIuUDy18qNt+OAV9xY9FF06Ww1mVq7BJGMko3jSzzoYh1jJNu5QPluSEpRSZiS0j2ct8aRBIzNDQjKz7eJ6YO5GtoFpH172H3gZi8010YNw66C9jaR3NuGO/1QXqiuzCGXOlODNQu06h4z7pUU52rcQNkaiE1eRMn+Pb42TH+mzjh747v21aB2TvYvVJU32mxuaB8XG1lytspHq4XMnyK1w4a3HmHyXqW84oPl49s20xW9Gkj5sA47f3u8pb/6vXHTHOZSPbRmOmDwirPpi1wVvN6I9rvN7cnZHnLi9WG5x/cS7KncTxcn6IORgJ4Fh3F0wP1IaU6JCJzCQqsx5wK79X3etSdB6/YrSXZyg9a4LOa+aRmvZmijWh2Z2clWd7S55pDmTGb1rxcbPAoPr8/pbqb4LRI6QbW+eZxQvBaTH0BmTDqwNX9kjf1Kfmi4dvndywLmdRfFAcmtuXtYcFnby4wiUdnHdNJw7O5BBidfFSRmx6tPJ8+npOZnuvdnG0txfPzizUXxYHcdNzVU7QKzJKW63KGVoGbzRzVyWdhf9Jjil504MsWYsCS8xqbOCaFmAKXecXbw4LL4kDdWy7zPfs+wyrPDy5u+IvmOb+6Ocd7hU1kUqs0ZNOaEGB/P2FxLojLxcmBrjdsb2bs0gJlAvNFxc1mznJVsr6V1zlJW97uFtTbjJ89PkclgXTa8tHqER+7S60C14c506xllUt37jcp0xc7Luc7fFC8nG5oveXL3YqqS5imLdePc6pDJtvTvGe7meAbQ18Yfv+DN3y5XbHeTJlmLY/thBBgvqzovOH3X77lR/oZvdNcPS5oK0EUKuu5ONtRdxal4Hc+fMvd5XQ8nvebKXWbcDKt8F5z2Gc0TkzPv1yfj9Nv32mUCWR5x2pacZqXfP/yhm2bYbXn9e0520aL/KtTOK/I0o5DmbE9zNBZj7aCRyR3mFRCvdpdSnDDB2Mg9IrQWVSA7Nbi8oBPAtQa3SiUV3SncPZ8IxufwsNZg2sNNut5ciLIzbY3bDdRsrWzmEpjDDiv0LXGFw6Venyh0HnHYtqQaEfS7Rky2b4uD/k++mt4or8hw/pvdJGuekSnpqPxzUvhAANKMRbH8SiNhV8sGJtFDChyxxW2t0BMXRwoIUBEOQaSaJD01sSpsY+pmVKgJ3sHmNEUZxqZUA6Tt+ZEXoSO8pIBsZiUfpSR9IUmTIepqxqff2Ccoxin83SgnBThthJt8vx1oM+OshBbB9LXjJKXkdUKHJ5Z0b4v5TmSHaT7QLZ2gjKMxSEg060Ayd7Rzc1oogtaUJF9bsbXa+Mk3HRRkhMniiDnpbxQJOVRUmIrxoaDWPTZWt5znx+lFsn+qFMfNOfKS/GcbRgxlTpy0n0C6c6NhJhmaYVosvW4RGErkVdUl3Z8rqCVFKABkoNi8wct059GXnUhjcBQqLr4epWXafP8i+M50q38E5TEOVdPFOn++HqHh+4H6omcK9HfR4mHi1ugQV6kj8+n+8j+7kRzPr321Kf62BCG46TeWynQdcRADihSFSVBulWsv6sYkmAHsg8wstF1vD76uGkwraAqBynK8F6CiZ+f8dpI957qTLY2faZRQRqCpJT76/AMLv7cRRa8PNdAwekmWggz70/prTSe6U4oTbaSBNahIc22RCTkMUG1mxiS0o/GXDF9ynbCWzXery6FpDoSiIo7uW5UH0BJIzpIz46IyOGz44gXfd8HI5x/uRcH1vN+l6NTJ0bDTPSmmIBq9Vgc60SoGIc65c/uXsnPPFgJzjlvaJaWZ7Mt+y7G1N8uMKkbN82Jdhy6lHlWU3ZiVJ2mDSfTkoviwLrJxYRoe0lRnLZ8+NHDiM6b5a0YAL3CpB73mBIOGfQKN+9RJtD2KarTuKjTxfrRtNg+5BxUwO0SeiPBOod1QZ33pGmPu8vZOcWV8eS253RWctMbiajX4mvobqVoxsrft08r+uuC89WeVVFhtec8O1C6lNzK+P1PP3tF6DQ6iwbU1uC8Yec0dZNwMitJjONuNxUjbG9QCi5me6z2TOL2wSpPbuS/tQp8uVmRJT1GeT48e+Dn2wz2FjPp8dsUlTvRK2eOtOho9ikm9ez2OXneMbEdVnu0EgzgP/mzH0LuWJwe+HD1yO++eMe+S7nZz5hlLbOzhqvdnN4Jb3z58oG3X51y/mzDZldgree3vvcVaXSkT2yLD5o3hwXN0vL4MOVRTXlyvuUPv/c5z4s1B5dx30xpneEX15d0ZYKORl3fWHjxwCxtWH2wwTnNfTnlt8+v+HRzTm47EuN43E/YPE7QNpBE/bb+8Yz897cwAaUCP71+QvVQYCYdNzcLQi/XiLGerrb8y3cLUAFVG1h0nJ3v6J3mpBATaNUm3D3OJH200+InsB5tAk+WO5ZpzTI3HCYpf+fsNetuQtmnfB5OKE1KMnMs8pp50nCeH/jl9mzUod+vZ6haJiKq1qSXFVWdysYlKFTqRnJMahztzNBsM0Im2yOlkPs1d6RFjzGe+r7AZUJdkamLpD3ruJFtOksy6Wi3Kbwu0AnQZFx/NgUd6Bces2pYzise3Bw3cxTzmmqb41XAzsSQerieYmbi71gfpvjDbyJHv+6Pb3SR3hegzPB/8mU5BK70VgxrpiPSGo4F6lB8DNrnoWgd0HGDQXIojOA4+Rwm2UMR4VI1YhmbhaZZaNKDHykr2oVRFz3oxW3jx9cxmC5dqkl2Pe3CYhsvfPXU0M2lMB3JHwk0EynG+4LIqZaC1rTHKaYg/ER+M24Lotynz2IRbaG4dfI+33FEAlqoTwzBwO5DmahPrpApcAj0k2TUtA9yn2DAa2FzD5PFYVMwcMHTrSfdOZqVJVsfA176POrf61h4JtEUm8p7090xsl3F6fwwoR2JKUrkPEkTNwp6kN042oXFZYr8rpPGKNM0S0Nx09EuLLoPMTAH8rU0T97Iea1XcmE0p0G45hrUv3vHoUmx/2RJP4U+NhT5rRS/IOfl8AG4TFjhtpTrc/09mRpP34YxuRUlBbQfpBLh/Ws1NmmReCPmQ9ClbEySHTGNFQ5P9ThFH8J7MNJ0dRNFujkWld1Urql+Eq/vJw3scrl3Ekg2oqcfJTVKnqtdxE3OHMx9bK50fA3hOIEf7x+taGc6XpOAFv+BN0f+vnYiV3u/SZH7TY3NjPJxE6LEmJruRLqlgsbUYvbsCjWmpMrvSeHczVQkwOhfM+mOpJmIBVVecKfaSYE4FOIqgD1IE9EujDQTrXxo+FQdNzEcJ+jDJkX1jLSbfiIFY6VTkrxnVjQ8PMzwlUHlDlojeDxAWwkNquqEvkqYn5QsJxXTpOVpsWPdFqTaYbVj32V0XrTYvtf02vDmccX3L2/wQfGTN88wcTL72MxZXe7QBN5tFjxfbTi0GS/mG960J/zyiydQG0ypKU87QR/2Gl30hGWLKxOSRYNvLNm0FRa7EtZ414lGV+c9IZrdqsccPekx1hO84vxkz80Xp9Rdjjppmc1r7t4tUTqQTDtcp1lc7qnqRAq6yGjHKymMgIvv3NN7zRf3p3SV5fxsx/n0gFWePmi+9/IaqzxW+7GAbb2J/9/z2eaMtrd8fPrAxHYs04rGWVpvuamm3JVT5mmDzgKfbC6Ypw27NuPlYkMbtxR/9flz1E42neE+G5nzadFhoplydSYO8oHN/auHM06mJYc25XK654c/fE3VJezajJ9dPaHdppI6O+s5eV4J2aU3OK8pko7b7Yxs2bDeTElSYdZ/cnUhEikv30HTVcXL1ZqT84rTFyVf7E4AeFfO+Wq/5DQvWTcF2yrnfLnnxi3wTrFclXS9+CJ8UKTG8VhmdJXljx6+jbYeV1lUrVHLjtmiZrcuSLOOs0XFuw9TeDdl9eGG3z6/4qf3T0guHXWTcHm24/p2weXpDucVhySlLyR4C+dhb7n3C6gMh9MM1xl+78M3vEsXzJ/WOK/5/PWFIA9bzd1uip4HiqTj6mHBf7L5LfExKMjyjg9OHznNSua24V/dvkSrIAFdmwK1tRIu1SvMs4qzxQFrHGWbsukNbp3AvKMsM77z7IZ9m9F3BpV4FouKsk5p9ykDdQykKVFFj7MBKo1uhcwUTMAtvZBfPl9gKkXeQf28I71JRtBFMArVG/o25/FWGOhMHNUmF/15p3C95qBTVKNpriZIenEA/TUdJ39NX9a/icc3uki3DSSR4hLMkdM9TMCVkwmlT9UY224PItUQ/Xic0MFIihmCXIZ0SRO/yDFHbaxpjnx1mbYGmMaf0UjRufm2op9KEEm6FTb67Kofw3gEHReYvGuF1qEY9bLNQj5witujnMCnRKRckOAZrWS6HJuSdi4JncGIiS4ZZSvHBsOWgXYux22kwSiZ8pk+HBNK3wt0ytbHybTLxIR6eKqxlYQT1ScyudUtI9llmGAPkhPRoiNyiphUKmZNkWQMU/ThnKkY6BSQ5mp4DFKFfnLcnngLzak0LbZS4GH2zgv6UCuapWZy0xO0wRUG03iRLRSa5tTiEkW+9rSzaNqdawlRAibXHUElvPq/GPpCNi7ZOuD+D+fYS8Xycxf11XI+Aa7/LU1+I3KY9nlH9tXxw3gwXRIL33YqybbD9Hgwfur+WOwO15QaEIf2aEg0bTSmRt7+MP02dZQFNBBSqIZwL3Uk49hSfi3ZD2E/+VhYmng+kp0caxNxjei4QYgNXn0qpuaxyXVRshTvLQkskuClgZVuuuMXy3gdRCyiNMnHLYnL1SgtGclNDBsOOYjJwY8oz2HDMjS0uDBO1AdjNUG06oNUK0TazLDpGbjxMrWXa2VoVPrJINsK4+sYEJBDjgLEL10vnWqwUqgrF422iCbbGM96M8XXcfVDpEDUmvqQkhQ9LiZh2qJDa0/TWco2lbj0uuBxPyFNevb7XAgQTqaAbZmQTjoem4K73ZRn52tu1nNM4jCJY5a1rOuCJ8sdLmjOJgeuDnOeP1lzXhz4YnPC+oslOnX88OUVmzbn8TChbDMmZyXVLgcnhUOWdfjEjaY73wpJJZiAMohMBsQ0l3hubhfyezPpvg5lxstX9xzaFKM9bWcpy4zlouTxUY6P8jFxOfOiZ4/kGQKEQ8KtX+CCZplX3Ozm1HVCiJKRi+Wel7MNVnu2bcYsUeS2w2jPuin42dunfPTkTiamzlD3CS/nGx6bgq92S3aHnLftCt8ZricLkqTn2XLL7378hh9/8VxCbAB9MOha0e4tadSge6/QOrA75MynNd86vad2FqOkefiLv/wIZg6lPZN5Q2cTPvroitv9jGnS8vOrS/pNBp3iq20GJogRd16xvp2NDRRBjRKMtrUcuhSdNlxVc3ZtxiKraVrLIhfc5SRpaRND1SVcnm6ZpQ2913Te8O5+yTbLOJ8feHKypZlZXNB8e3XPX7x9zvxZLd4Jr1idHYSK443IfbqE9f2Mm+mMurUyue40uzrj6eWGx/2E+pBCEIa/MuIlssuWNO05fV6SaIfRnvt6wrbMub2bE/aCtPStRrWaSgdOLm75arvE95rvPr1GEzh0Kc+i4fXHN89Ik562s3yxPuGwzdEPCX7i+Ohb1yTGoVXg03eXgr/sNOlJjVMQ9gkuc3zy9lJyAW5z1GnD+n5KOunQqSNYT9gkdDuLelqK52FtCTaMqaR+4lC1wewMplQiYctg8oUYYX0C9VOHOWh8Fj/3ejF3+wB4hVq2BKeZriqqMiU77/BBoRA5W33331gi/ebxNXh8o4t0YOSRD6i5dB/GKSoKei0aUpfGgm4JaCng0kcpWKdXjnqlhUrxEEQCAWM0+xBCM8TNB6OkFhgCdawUOt4e0wZdBk/+JIg84iBaWyG5+LH4ErOfinIILcWaEu74u/++YvUTkV3YOspB20EO81+LWbdHBJ3IDdR4DNKdp8/F6NnOj3xq3QV8KsdP91HnGSe497+tOfsrP3LZj2ZBFYOE4O7vBJ7+ERR3Xgx1RpHso3RIK+5/S6ZekytpioaHyC+k4JfjGRuQaPQUCUpg9kZMmgPaL4zHLJA/xIapF8nE9FreU3UuAVG6P8pJbCPYvGwtzvhglPgVYrCPMlCdGimMU5hc9/hEpuh9oUkOHp/ocYotAT2e+etYLMeCbAiMmryVpoMAyz+TVFefyfUXjBBiXB7JQxyvK+IWxxspgFUQzXXQMHsr5mGQaXm6g2YVQ4ei6Vm3x+I+GFCdPO/wUP0xeEdHItAgL6rOJSnT5bEgf09OY+r3/rsROdmwqUAJ3cVWCIVAQ71SmCa+tygH6QsxBo+ZA1q6LUn4DfjsSOVxyTGgSvVg4p/jveK4TwSjOhw/QiAk0gjYaqiUxfQclEix0oOPJlU1Yh+H+5vkKAsammK53rU0ppFe41JpfsZcgFQ+R1x2nIjJcwd0p47Femwu7R5sNFUGwNUGnTvhIRtPMunRy0DXGdrbAiaOdCI0kdQ4jA6kWi7sD+ZrVnnFq8ma22bGu/2Csk24mO15Otnxer9injR0E8M0aTmdS2DNMDWcpi3bOqdIOrxVTJKW3PTclDNWeUXxnY5Dk/JXP/5A3lLmUUmgWkuYkN5YXOpQUe4gGlsnRre9JHuiA6bopUC3Epvue012WrGc1Ny8W+Fawzu3xFUWnTsWy5JXFw/cH6bkk5Zs1bM/yHTVJI6np1u+vbjnoZnQB822yXk8FOwrQRL6xsg0euKYLUtS07PtRPedainEk8hoT43DnyoObcZnD3PCXcbswy2tMxRJx+V0zzRt+fLtGdNVxf5+gj1xvH44QauYVlkIOz6kHrdQmNRxOisx2ktapddkaU9ue371cIbzig9PH7mrptjzmt9+fsVpdqDsM/JnHX3QkmrZpbw6f+QLdzbq2ss6pW0sadJTLGuaOmGx2rN5nKITKeDbJuGrX1zKZL/R4BTJt+7ZRFNo21na3DBPG+o+oXWGrx5XZGmPc/KZ3feGs7yk95qNyilsx0W+o9lmzCYNk6KlqmV68sX2jMvTHU/PNrxpTwH49KvLsXnAeg7rgqpMsanDZj3WelbTitx2fP72HHeXU+aOap9xdr7jB6c3nKd7HuZT7pop73YLEu1II250syv4889eEnrN2ZMtADeHGZuy4POfPcOcCdLqsM/Iio6z+YHTScnbyZLgFbf7GYuixmjP3/7gNa93K24f57TXE0Ed5vIhkGS9pITO+uhwl9v7bLVnUxbYaUMapULtfS6yxSKIbK0Xdr9plEzWk+G7/bidNA1kN4Z+Egv08wZXWmGqp45+l4q/odPsuynKeuxUpHJJ1qN14NmT9ddOkw78hpP+3uMbXaQn+0A3hf2HgelrSVSsT+OUsRb+M1HHGjTsP5K74+Qn8mHkMlj/wFNdGCFzKKF72NLEVbxcBYPOdiRyGMbJ3DA1BGiWZsTTpTvYfiiFd1+YiPjzI6UCN1BbIjIy0XgbV/g+8OH/HdbfTulnMLkLxyksUNz7Ma7cpWosgutTKRxtpSjufDRwalQ/4OEYdbtpF2LaaGDATnqrqE813SKMGv+kkmLJJyJPGaQm53+qKC+kIO3mUsyJiVKOR3EHD3+7Y/G5jUzw+Pv1sEk4SgOGZM1uoiKCUo2BR8k+jIVsN5EpPEokEwP/XDlAI6bdLmI4u2Oz5tLIiPegOi/H+CANkq3kPFZnhmQbKTSxgHv9P1a8+C/ebxCIuEjGybYUYQNRJrD40rH+djTObaJu24DWUaIyjRpvYtGqxkEqQcHm2/KaZm9kat/OZbo7FK/5feDwTBqrMEhBYnqpaaQZGBCLI3lEHae+yquo/Q54RNdtGvE0yPGS69cn7xX+JpKQevmZw58ZzmlfDPfC8f4YZFgqQP4oMqn35T1y3kQTnj1GCU8Xv9frMOYTKCdoNuJ/j9kEkf8/JgD7o/dheJ0SlIXgyyKC0Vs1IlQHpv6v/VyO/x1MlLZFOYx8Zqi4IWDUmg8JuEGrMTRM9wHn1K+RfLo5YzHblgl0GpU6gvEEp2kfcwncmTjmz3f84PyGX21OeTnfsErF0HdVzem95ie3T3Be8dMvnkFQ5LOGep9yKDPuZ1NOihKPYn0QaYNWgaa1ZGlPmvRcTvb81eYps6xhYjv+/POXBC9F5nxWs76fAQG17MiKTgJqnMI3CXgtmnSnOTwWpHPRrvetkZCj71zxdr0U3rsOos91ivqhEP9Mabk5pJhJx3wmXO1dm7HeTNncixFyOm3wQY0x8L/9wRX//IsP+erNGW9vVnzw5IEi6XBecznf03lDNzUs84pNXZDansxI8M+AUix7mWDmtuezh1MJ4Ul6ctvx/RfXPJ5O2JQ5Shl2Zc61XzCf1pjUkSU9nJWczSTd81Bl+McMW8q1jJWAGjNpudtMCV4zm4m5sWktXWr41qnIdFZZxc++fMr3Xl2Tm5635ZJNXXBSlFzv5yzzisz2pFqi7dsyIUsl1McbRdtZAjCdNoSghLjTa6GQAKYWzrsK4Fc9ndf88Mk1vdf0QTOxHRPbcldPJVipMxKm1WvyWcuz1YZUO2pneVLs+Wq/ZJfnnD/b8J2V0Ef+8uoZh/sJ2arhfjvlbHHggxd33Gzm1LsMnTrSvKfvNVoL8jO3PQ+7CfXthKvbiWxTnCLkjslpxQenj1jluaun/OLhgmnaUnayYXncTejruF48GELmSeetNFpB8YPTG35lz7hFwsFC0GTTlovFnm2dk2jH09WW682cqkyp64SL1Z6f3V2KNGl54H6bkJ2LzKg+pDSbHJXK9qmvLaHXtD7ltkx58exBcJXAm8cVatrT98IuDwb8xJGe1rjPp9LkJxK0RxwE6E6GIvI5pLCVwh8KtIJ+7nBTRXZS05YJet5hrEfpQO8080XF9s2CkHi65Jim+pvH1/PxjS7Sd68ULGD6RgpdIVtI1Lfu5Uu6nR1TAU//UrP9FvDv3NP+l2c0J3Ei+zt7+KPZiD70iazah9ZZuWMhuPxlS7u0sRgXxFtSivY7f5Rv46BAf3Vs88RQFjWx0Vg2FH26CzgDthxyxhV9IYXH5MZRPTF0RVyVJcdiGY5FRDDynm15NJQ2Sz0WkEPgj63CSG3ppqIXH6khQY0fHmd/Ae1MpshDQZnuPbYKlBdxvdtJ8ZUcPOUzQ/5wLGSCkuL6xT8yeHssYodjsXupmFxL8Z3so8nRBfIHmVDma2G5D5jHgCRBDnjNQact1I9AVDzHjUeI6ZPRWJjLddEsRGPfzqxMqh0sP+/RrZgJi3s3ctlBrotX/yiew+Mvy3R4mMAO8oxYYMvvy99Nd3K96E7+/FCoZZv3JDxR2nL84TB7zbitCEZoJdsPNcVNGCflLpcCGCLhJkqhXNSmj9jFYYgbr+mB1x8iXUiFY4KtqeXPeiP/7ZOoSR+kGrHoT/ZDQBX4uGFxWSzSY0Ga7jzdRItXIY47JKfgSPkZzl+9igZSJRscgrwHWxF15yEakI/HWCg3gX6ix+3P0Kx6qzB9GDnlMt2Sa9ygRkmb7iVhNyljcmh3nPxL4qtM9Qc0qz04km2UykTPQnNqjxScoMbjO5xL2VgxavbbU9Fld5UVcsm8I806qq0kH+pKIxbExQABAABJREFU41c96aTle+e3fL45oUg6vtic8Jk/pW4Tiqxlnjfs7qfQKYIVdnhrLaE1eBNY38zx54rdpqCYNVSHlBAU80WFUoFEe6zytPuUrx4ueDM9GeUSWdbRxeTRed7weJhgjZPkRa/Q0w7fSTEenILa0u0nMOuxuRhQv7gWpvh8UXE45DGYSVIXqQx0CnqLKxTrcs6uKLg42eEeJfnSTlu09pzOGt69PaFvDb+wF0wnDYuzDV+9PeXz1xcAvHx5z67NeFwLQaburKSjZoJAXBQNZZvQO8PVl6dxmxYNixPHxngJlirT8YYpO83zlw/s64zNriDLOoqkY7OdUGct07SV1Nde4VPwiRcpWKNpthn5qib4QFWnWOtIEse2zJkkLXWfMEsE51gNTYPpqWzPfSkF12BefawLXGd4+mQj2MGDYCOb1sjUPGrIlQ5yPqaB4DR+KsmWp+c7doecQ5Xx481zkrTn6XLL02LHtsvZNjn7OhNz8iGHxpCdduSR2e4jg/0Pzl/zD3/x20wmDfOkpnLSNEyeb9iVOV1luWeKj5hLk/fYxPFsteE8L/nl+kzIJgHOnmypE5G0TLOWd1cnQu0KikOXsikLqjqh26UioamtyD4i2lAOUKBY1SgVaHpLaw2f7U55PBQY7Xn14pZdk5MYx7os2G0LTk7EH6BVoJi0dL3h5n6OqyzJvMVYP/pB1MBbbjShU3RWkj9VZaQZM4Gb9Zy+MYReE3rhs9tDLNATD5mjvSmwsShXWskgyxDrjoCpFa6IlCgD/dNW7o+goNX0r6eYpzVp1omBe59hMrnHli83ACRtxdfuEQD/1zDmDoNG9Ov9+EYX6fkDBH9c0Q+kkcE0p1tBtIF8ifcFTN5BvTuj+Tsl4V0Bicd9MR0nhkO4jjfyATyYRYOFbO1pVjaiDo8FfJ8LO920cYrWhWP4UMIoOUGQzqORTpIYVcTqScE/SAvGlXsksqhOLkiXHWUOg05XOUg3MkkcyB2m9aOcwCVDMTVUkoxR5dnGj7KdNsa2B0NsPOTn6DaAUSgN0+s+ymlk2t3NNIvPpRkqn8HJz47x7S6NhlJDZHTLfZU/HIvTYRswkHDkfcm/hxCaZhF17sMWIjA2F7YRkk1IGBNih2J+YLYPxXSy9aPGXvTqBuW1PL8aGjvROPeZIkn0OIkeHrp7T6ryXhOEkvPpDSx/5bn7W5rZF5HM0otmnPhhXJ/Lec/Wwke3dYgprMLrHihEBDg8VxQ38n5EjiLFenMiv084ylfGYKog14CPMgtGEyRH3X+UYWgnxJnDc/FNmO5IUBkm9H0WG8+onbfV0ZSaHOTPDfdKN5NAIhUpSM1CmiVvdUQoql8rtruFJHKaFs5/5Ebj8qBxHybs7yf/7p8Ka19HtObQ8PaZIttGShKabhY3Mio2tod4D02Hxl0MtZKMK0X+8D517+IxDWPz5nJpstuJZBrIxkWINYOReXhvwUAfE35tJQ1ydq+pUwOpBx1wm5RKJySrhhCiZyaVou5H757hnUSP+14RnGZxeiA1Dqs8f/+3fz4i9ArTsekKamfZNDmNs2Sm58l8h1YBv1I8n2z58f1TQCQvX+2XXDwR9OEqryi7lI8WD/igeWgKVmnNv/r8FUoj/HIv0gWA4BTprCexjtJkJLE41yqQJj2bcobKRA+cZh2ns5JbPaN5zNHTTs6tCoQHwfe5RnO1E6kEDpzTnE5K9k1GOmvROrDZFRjruWnmTBY1vTOczQ8i4+gN5yd7UtuLedRpyl0OE3mveaI4NClPP3ig6iyXsz2vH04wxvN8uWFiO/Zdig+KRdqQm559lzJLG6pJQtmmfPX6jLOnW84mB3qvyaxjPeuFPAKYUuMK4Yg3+6i7ThztPiWdtyTWcX+YUtUJt49z/D7h9f1TYY4nATuXmzjPOz67OaN/yAmJR6We++0Uax1tkwi3+2pK1WtMjJ5PY+EGjHrl+pCy3RckSS/Hwiu8U3y+v+DhZMKr5ZrEuHHSbKyDReD5YkvdW6ouQanAVTnnjV/ibzOe/94NLij+9O1LrPGUdUpXybqub4xouZ2CecdsWvNQTtg3Ga8Wa1Q0wYag2N9NUE6x7eT7RntF00x4NB5rHOfLA35Rktqeqkt4uJ8RNqlIeILCFD2XS0FDnuUlv7N4y9tmyT/bfcQkb3m3WVBXqaTWAnhBLGoCZ/MDVZfQtpbZvObFS9lSpdrxZ9cv2N7NUHtDyL14PHqZPOjcw6nIUQDaXUq2aOgai9pZQhLo5x7daOGgH1K6s55eQx8lue25x+wFcWoPegRT6Fo8HKHTqMxjr1OCCVz+7g03j3OqTU4yFRxrmvYxwMpxaFK2m99M0r/uj290kZ6UgaT2qF6kJT6JhXXkbff50URna/nzBDCdor7OUU9r8p8XJFtGrrdM+o6TT+E0x2lanAa+PyVLDk7YyUnUT6tBJhD12Z1MxvtccfN3Axf/UqZ0j99XTN8q5l+5segcDG9Ox6IsU2NAzjCNT0p5X4PUwCeDHl+KG9MdA1+Ggivd9PIaCh2L80G/PBTBOqZoymR9iJEH0RMfOe5R57738b/9KPtI9pr8UfH4A83pT7yQZ5TEuzdLPZJt+kQKzHYhsg6X8t5EeZhEqmjuFdJGcT/IeTR0jDp1l6tRAqT8MAlWI7HEtNA8MaNufmg6+kKP2vigh+mq/CxbelCG6bV0Ed1UnkA002C3fpz8DxHxorGX4zU0EatfBJqFbECCOZovgwFbqjFFdgz80YzSp2alaFcil8nv5P26SLoZtgi2lGatPfFM3oqkyVaxgYsNkImkG+J0f0QrWmSiO4vkICB9hGxkuA/Hd3hdjDx3hvskyK81SzGP2uqoh7/+2/KxNH0rxXwoOSak9nETERvfPofDE838KwlsGVJKB8mMfm+CPkiDZleebioT+MEA2hd6LLK9FeqK7iDdOrqZHk3iLjYTg9SqOlOsfumE9jDct9FELXIxNW6rTOtxucGWbkQ5SgMB3kmh385li+Ky2ET3IlUaePVq0gvzu7QE65mdlxy2OavTA3pW8+FS+NWLpOZtuSA1juv9nMz2PJ3u+Gq7pO4Tfv54idGezkmU+e3tMprxhArT15azix0hKP7g8jX/+NPv8/Rsw75JabC0zjDPG9re8lhNeDbb8sv1Octc+OFln+DKBDtv0Yk7Sl6CIl+JPs05TZL39I3Bt4Zk2rGc1HSLijztOdQp3mveXJ1gEk9+WuGdHhGLz757RxVDb1bLkpOi5PXDCcErrrdziqxjPq05VBk6Jph6ryTZcjtlW+WsJhWJdlxtFniveHG6pi5TXjx9pO4tN5s53in6OuH5hxtya9nUBYl1zPIGrQK56Xm9XTHLGr7YnLDbFWR5S9MkPDvb4LxCWc92n7PZTjhb7em9Jr1JxCgYw8pUownLXky/vRbmtQ6024zWBH740VsmUSLxdr+IyaENmzLHOy0hSalMeUMqE2nfa9pdip/K32uqBKa9TM+Np6ssjU8oprJaa/YZNuvRdynt3HD26kC1zwhB8a3nt/igmNiON7sl65s5GC/kltqSLRp+8ukLTNGT5R1tk/Ctp7egPd/7vdd8enWBf6LI0p4usvCLWcPHpw98b3HDH19/jDWOV7M1rbf84u6C+23Bei9G36zo+PbpNZkVGVLrDJvHCfms4cVqw+1hRtsZXi423FdTMSvvMoLTohXvNLo0uE5xm8341tk9P716wk/ePaWLE3eALO357vlbJrYV74LXvJxu+HRzzu12RrPOUFaO36fXF3RVwsvn92S2Z3G+p17Ixio1TnCNgK8tGPFlxE8j2jIhKXrCk4r+IcduBJvcnfXkZxWuTKT4dgp1OBqqTanHGsWWinbpxfNRa5nUa/n8e/f5Gbg4ZFCwOhePxGlecn2YcznfU6uOz/9/qpb+mh9/HXrx32jSv/4PU3mMkYJ29/2eJy8fmaYNX96c4R5SQRl1elyTmdMG95hx+sGak7j2bf+wxChP859dHBGMcR2e7gLtTA/ZQ6Ne1ifQToX3DIbth0JwcdmxCBskMADEyPtn//RoILz4c5l0d1ONLf0xPj340dDWnAiu732t7yDdGYpTbwZT31FCEyLNxSWRS72QQkMm20O8vOjRfTTDgfzdZC8fEElERw7Ei2alxoIpGIOpA0kfRloLyHNe/FlPuzDUK8X8jUS152uZrLYzaXCyTeDu9zS6l0ksCNqvm0bkYjsQdqRwHd5rUgoXe3w4mT4mhzA2MrYJ6O2RHDJ704/myj7XWEC3gcfvW+avHbbxwsCOWmlCINn1gg5cmvHXXOTODwX+IBcZJr8qHIu6IXG1vDRiHN4zYkCH9zvopX0i72MIaeoyRT+F4kaOw8C6F9rJsZlMN+BqUN8p8bczJneyAdK9GhM3g4rJrVqO7eF5vGaibCVoSa4lSBNRnQ8bAsYtUDePrzfy3W0l159LIKRyrQ2s9qHJHZJnmxVMr8MosRGDtzpuADrhx3dLxdbqUedu94rpTbx/QgB9pOfINkDOs5jG5d5KDkOjJB6E5ODZvjJMoozDRTXDiOw0gmxUXgymw58x7fHcDl4BgO2HCfmDJ9v0kSbTU0QTcrqPaaYasi2jVGmQGQ2SHQDfGszGirH0g0qkKK1mf8iw1vOlWrErc/6tl1/w+c0Z81nN756/47PdKbfVlNNJOdJdfBDDZ2Z7/IVMCss25XK+4/4w5f5mQTZveF2uWC5K3t6s5L2XstLbxIIjeFhPJpyfSPHZKsNjNeHJy0du3q2gU1Qb0WiF1NOToGIqqp86lA1SjO5SrqqE0CmqzOEbgy4NpAGXetwugVbL1L0zXH16DjqgG83DQ8Z9vpBQntOSPOlEU7+ZYhJHG+kmynh2VY4rEw6VZZ43TJKWp8stuzZDq8DzyzVNZ0mN6JCN8rTOCrKxMyKhaDU7N+fdxJEUEnTkvBa6SOJIrBhAp0nLNGnZH/KYBms4FCm903QLmeSYWkEfPwOtExZ2UKjUE9q4nXSKX7y7ZD6r6XrDalIxy6VAXxQ19+sZLy/XfHp1gWssOnPkk5a2tfRRamSjNn63KQibFF8rwqpnvjqgVGC/E5HzhxcP/OpGAo7ut1OSvKc9pNwdpiyLmttyhtGeyUlJHhuDprNkSc+LF2+w2vHF7oQwU1jtWaUV2zbn1fkjqXZcTPc8VBPmeUPnNTeHGZ/cXtDeFuhFy81mTrPJRP6WuthQiM77zW7J2UQ+BN9uFwSnKbc5v2oSXGPBKX5apULNaTVq2mOLjifPd+Pm6DvLO+6aKYcu5cPzB54WOwrTsUhq/uj6YxLj+OnVE1xv4jZK8Zk55+xkT2IdXWVQZw2LokYpuHczvvrVBTiFOWk5W8lWZlMWFBPZcNQ64CJRiEZj5h2uspIy2yp0NJb2U4+edigVmMwbDpsCvCKkgfS8olln6EaNm95+Kl4GO5OfFwK4pYNe8fJbt+wbuaazuFW420158/YUW3RUecJSPfCbx9f78Y0u0n2iaKdapmoPmhuzwtxL+pdR4J60LJ7tqNsErQLOacydIf1YXP6bMidNeqouY2iQm1WMd1eKbiIR8d7A9MrLqj6SOPK1H+Uj+YMU9N30qEttljIJT0rR1o5yAz3EkTOysAeeOCDaO6KWNofJRor38iTKI6LZZEDimVYKvnQXRtOa/L7oZ03tRKtr5HnGRiNO6kdN9KhVltdn2hD5255upskfhoCk+MetFN26E8kJTg66t4p050n2cHgmJsx0O6RMxtetYPnLwPq7chyKO5FL9Hnkbr+X5DjooYUookbKyoCjJIYnDaFNpg1RtiNFXLaW5+sK0QtSBtql4fSngr50uSZkQmwZiCEuF6qHFPqDMfg4ZVY+kO4c7dygezH7ulyPzPchir64C2w/EolSWxw3PIO2fNiOhExkLNuPogwj6s2DhmBFz286cDqSVIiSmACzfzwTdKYCr2PD5RnxoMD4b9PItZxUg+RHfsaAbkz28dhH+gleJuwDWnG4PoaCM93KRL+bHQk98oSx0XWw/Uix+tQTYgPZzjX9BIpbz/6ZJlvD6U8c7UKPfoqRXBQL6iGVd5xqezFqZjGs6N3/tMW8zbj8l3I9mFbQi7YSL8NApgnmeNxMFyVQpTo+jz82asdcAfk72Vawq83Siuk2EbxnsxCM5mDYtY18DmTrECf3w/UZKUw7+cj2uYcbwe+oVYfWAa09u0OO+3LK/3P/XUzes9sV/PHhIz6+FMPezz97xvSk4gcXN9xWU5ZZzaf35zxfbvj89oyuTPiiTJnNapZne6o6HWklT15dcYiyjmnSjgbCdVNwX025uZ9zd3sOF7WE83RSfIw0IAVqaxDWvSBV1aM+nu/uuE0JOkGlgqMzew1BMHNh5lB7QUsOn4fBxs+HUqaNh/WSQwCfBtKnJc0mI1s2dLXFJI4862hziXdPtJBaNnXBw/2MXZHT7lNMftQzYwLZrOFb5/ecZiX7TgqfbZuNk2WtArWzrDLH6aTk0KUinfGauk8kgGqfszzZUSQd765WMvzRyDWjkfdpPSF3owm374fGBGziaFrLB6ePfHF/SttYfK+5vZ2Ag09uX8nrzTxq5SjXBWpnUactvjU0laWtC+x5TVdo3FwoO+UvluheoU3Adoov3r1C64CbQldbPn5xy2e3z9gclmySBfmZfIg4p1kUDVZ5nPHsm4y2MNTO8mK65U9+9i3epo5wkGtWzzoJPEJ8AyfzEuc1aDG36lqjTmTCvLzYy7S8tZzND7TOcH8nHf+uzdjVGdZ4Xr6453Y7w/XiL8GICVZZz+J8z3dOj4m4ANs247PdKV+9PSX0GpP3XM0WOK+4nO+528zoW8N3XtxgtefNZkkIiuWkIgRF6xxPvntHanv2TYYi8MHlPd25bImqLmF9KCTYqDVQGkLu5Hs5j3q/zOEaw+SkpP5sgc88IXPivwoQnKbaZ+AVF5cb7u7nhE1K93aCcaJD708kDIzKkNxbeLCE0x4z6QheoW4z7rYz+l6zmNWUbcJ2PSGftrx4/oBSgWnS4sv3UvG+Ro+/FrrLv/6n+P/L4xtdpJtGOnTTBeb/1NMXBtP68Ys+KIsKC5ZR6636QDf3XM0uePbb1yyymi+vT2XV6GDzuz3Lv7I8/q5n+oUmOcg0M2lF4kGQIsPESa8UZyIrcTGQZwg/GYrlIWa9m6pR3jBgIgcqhR4kHEpIFroVjfLsrVzpLpWCqJvJ6xmMsd6Cirrg6lyP+LkQvzi8UTA3uFSKO0ElSrGblH4MePE2fs/0IqsYcILKQ7vQ4/EWvKLQ8IaiZzCF+kJjG3+kibjA7I1MHatzQ7r3YigstMhG6mNCqtfy7+whvjeRrY5a52FSrftA8MfpejCM+vPhfQ9FtI5FmMs0uvOiNTcqTqEd3dwKBcYJvaZZGWylx2h4IdX4cQrvDVHSJMVJfWrHn9lPzKjhNhGT2c2E6FO/7Jl9kmAaKYLHgjpKPgZc5/pvBZKNsPXzOwmcSryEOI3hODZO0mFEesF75J54nmx7NKe6TI0kAZdBupZjOhy/8ToKw3k7SlyUh3Yl58Y8ShOVbSKhxr23OYqyJZ8cJTXEa8TUUJ5rZm8dt3/LjIX9zR8o8nvAy72T7P2IDn1f241S0gCq40eyywT3CeJpCAdL/6RDeSum7CDbkpQYKhb/qnKQjsQXyQN4n0lPiOFJUTevQqBZSiNa3Llxih+UmMb7TI1BZaYVqdPm24qzH3nJWYiv1ccQsmACPvWYU+nCXGPFCNZrMRhaR5F1PDyxhNrgKiuFYJ3wyfo5atqTLyQxdGJaOrfg0/tzXq7W9F7zrcs7Uu14qCfUveX+doFOHI2zmBjs8+V+ymEjRlX2FtUrwlLMqn6XChL1PoM0HqfUo3qNT6MsK3VisGs0vtaYUuPzgOrk3vW5x27jh54GGwty3Sn5fPHRpDtsVyotoSzxHPULCVfDyiqjvSvkOjyk2LwjTXuM9qyWJV+9OxVTofFkE/nQ+O2nV/zk+glF1qHngUnakpmeie2oneVXmzPeXa3E7NcrVJSOfP+FkFb6IEmjVnmmiUgezvOSaz1jmrV8a3nPuim4frzE24CuFT4V5F6/dDxdHkhtz5u7lRyC1GFmLUrB+fxA5wytM5wv9uybjFVecVaU3FZTfFBcPy5Ijad+N4WJo3i1o6lTnAvo1BMajX87IemgXzl8ET/Xao09DBkVgZCKzOL86Y67/Qy16FA3GaqCOs34e9//JX/8l9/lqraETrM4P9C0lj9/fInSgd//8A1/74ef8vn2FHemqTuL1oHc9lxMRCP32BS0tWG9nWCznn6poUwITrF9nDJZVKxmJU1v2WwnKB3Y1yne57SNRSl49OAbK5KQxPPf+vZr7usJV+sFVZPy2fqUx0fBcYagxsYGQNnAbF6TWMfT6Y7c9lyZBXbiuN7N+XD1yIulaM7/+BffFpJMgG3qSArxVJzNDtR9wrvrlWw/tFBUzk93fLBcU/YJXz6eUFcpLvoPlAqEnaV+WGAPCkqDTzXTHz7SdpZql5PPGgJwe7vApB6/bKVpO6SYR0voLLpVhCFHIPdSoMcPq2e/c827uyW+tjSZBFedn+1YFUIvetxN8E7T7xp+8/h6P77RRbrLFSQy+WrnMvkcpsDH4CGpPpQPhEJMgk/+eaD/0yfUmWJeyM9ql7D8sUX3sPhUj5PcvoDJbRiDhoaCKDlIkE9yCNhICOmLgQkdIg9dUZ8IwWIw84Hwr5UXvfavmRL7QLqRCufhtxKZ6McJnPJgDzLpJBaNQQFaZDGD+W2Y8jEUl1HvLemjEBwkpR9De0wTpGA+ODBKaCdRP27LnuY0PTYeapBtqHEK1ueK3UvR4i0/k/8XAom8hgFP9/ADMdSgkSpfCUNdQqbEWNlPpIgcDLBetsa4oXB3R2Y7gVHzeQymUkeGd8xGDyoGTE003qgRFWlaH4uyIOFGmVS5PpHiuVmKjGGQyQ/hU8EcjY39RHP/25r23PH8H8cgp1qeO9k7fKKZ/zR5D30Zz6E5TqXrMyhfRDnQZU/yIOQg2wxTRnkP1ZPjJNyWsbhMBoOnGotjlw5G3YgdjCbkZB/lK4t4TOronYgylWzNiNoE8T7UZ3I+BvpAGiUyKsjzan+UKA2yK7rjz1BR0lI+h+qJQTmY/A9vud9MsZ9MorkbHn6oxw1LcQP1+VHDPyTOJgdpbseQoNiIagdP/x8GUyv6iZzfwXg8mJHfZ5y7VI1N5KDvz7Z+zAMYTNvAGNjUriDd6vE92drjEP9H/uhla5XJZ4uJONHh5xEGgziEFPInJV1rmU5rQtHycrVm2+Tc76aUlWVSNDy/XLPIaj65upCJaObwt2KErHcZ9yrw1btTlA74xvDzhwmL872s2NOO+92U+aTGZD2XJztOsoofff6CL3uNOhj0EDbUKynoOkWzzbCrBofoxYmc82A9LqbTknpJE3VK8h3SgHp64HxeyvSxsuA1ftlSTIWAAmC0p+8Nk1yK1a43eK9o6oQk65kXNZfTPWWfEILi/jAVek1twEe/TWno94Y+CXBxoO8NJvHYtKctE+p9SjFveKwL+s4Q0o4iHouuM3z/qaSvhqB49nQNwCRp6bzhyzdn/PRXzwm95vkH9yTGUXcJbx+XtNcTwf0tG4q85fPt6YjeQwXcXD5oVSPyn/vtFNdrmQargEmdvOfaMklarqoFuyqjjsSd5Fw+7+su4e5xRvCKZNoLm3tvae4XqA9K1FZMtmQe/bykP6QUq4pqXRDygJs4fGplE1dqVt95YLvPqZqEukwJpSX7cE/9bop+SPiTP/4BnHRChYljz9WsIl31vLk+4UdvnjEp5BymiSOzPZfTPT97+5Tr2wXBa54+WTPLWowOPNzOsdOW/pCiEo+2Du81D9sp/SERGdNJySxv+N7qli/3KwBmSctP3j4leMXJ6sC7/YK7aIbUJojUKzul7S0Puwm+M4ROoXrN3/v9XzC1LdfVnNfbFVoFzhd7brczdpuCL4Bniy3/4ssP+Hvf+yX//IsPAVjOKz5ePXB1mDNNWn76ySsoHJdPNmzLHKUCt7cLbr86EU144VDWk01btApUu1yMwlNP/1TkMbe3C/b7YgxGqr1gKJ89XdM7zf0nZ+itRs8C7qRHHQz9aUtoDWYvTa3fpkyf7ek6Q91b8qKl7DR52jHPG9aHgvvHGScnB5KkxxuNnbb/DRXSv6FHYPz+/df7PO/pEb/Gj290kZ5uHCyExiEFQTiuXnuAo5YYpJAdJlzt7Kh1DjYi84aCLhcD6lBMdVMFwQiWLT3SW3Qvv6eiuaPPoj5aHSfQw/8P0g2RkBzNm0MqJ0FW+tWlJd36MVxnKMRsxThRHdjePuLvvJHiTzvRIQcFxknE+Zj4GI+DTxSmFkmKvHmZRoJBd57mXC6ppAz0JsEnSigVXo6ND8PxDdQr+fV+JsVcvdLkaz8aSoUwI6ba8pmV9MqYgjkES/UzyO9lsj5MiociOCmPU13t32s04iRahSOqUL93bIdJrHaQ7hyEgKm8DOdclE5oKfBUHygvE/pcMIyDVnD3keLyT4VZL2ZUTbpz6Jh0KYxtQ3sWWP7EYLpB7CybneGYzd4F7n5PwoLKDztUEpj+NMUVUgCq39mhv4oO/VYMRe0qGi31ewzyIUI6PU6rhwJbqDaxoHVDkazGe2G4zk0rRfUoI4pJtcrLNTQgFG0pHoF0w4jgHDTWY7MZP3mSHfRTosSGsQkbmgvdQ7d0TL4y1JeB8h9fkObSFOw/CPRTePLPAvuXmvKphGNN34WR2w/SDHl73EZ1MyVbs2FS/wyKa0PxMOhk5LgkezF4dhM90oWGz/QQpUaDBGcwmifVIDsTCdLqEx//XIi+AEVdiDb14Xfg9MeywdKdbL/mMVmkzxVJFRjCjqpTxfn3biUEZ3b8Ars7TPmd83esJxOuDnOM9pxkFT+7esJiVlO3lhAULgaqpDGwxqQOV1nstMPVlrJK6R9zNpMenOKxMZydyMTzx18+H011YepiGqjHl6IBVokMC56ebpk9FT75L371jJev7nlzdSLnMXUS1LMomSStBAlVOYl1bMqc9pCijCedtjTrjMNBTHPKxS7XK1pViI594sgWDYtFRdNaDk3Kr+ozmiqR6PnEk84bklMnqMM3UwmEsfJZWl7NwMjGymWG0CsJWtpnfL7LUcazeZiyqRfSVDaav7r/gJDK+zR5j3eafNpKqM5MAqO6h5zrn12gWjVShWxQUCq4nVKHKYc0YCuFzqPZfEifXXaCwHSx4YzXYbdPR8PgJz99gd3JdauWnrDoqbsEFzRNJ5Nlm/d0nSWbN5hlRdtaksShn0oYVVsl9JsMXWma7RztwWcepk6GK0nAv2h4uJsJWrIV3KeedhjjWX20ZvvpiWwAaoMqej58cs9DOeHucYY2nnzS0ryesV1ZXjx7JDU9bx5X8lofU9lAAFf1qdxPrZBK+tLA1PHtV9c0zrJMa378yUs5FpWhmxt6p/n54+VIA9oDZ0uRw7ycb7irpvzw2TVvdkuqJmHb5Xw8F931XTHlq+2Sze0cvWj5s7cvxbwcU2APbcamLAhBpEaHQ85nbUJfW35y9wTXGrTxbLYT/tX9DJN47tMpFA6dOh53E/Kso3eapOh58eKOadKy60QW9bCfSMPTatzMYzcGtgWPX+VoC9nHW6ZLKZrv7uf4zvDuk4tRNtctPX7imKwq6iSNIWYBP40kqdJweCzQqeOhmVFMG5QO3N8K0ahrLWcne6zxXJ7u8UHx5vq9SO6v0eNvStDQX8fjG12ktwtDEUNrgopyUnVct4vkgSNGb/iCfu+/dQ9qGIz0ouVNd4woR59CsvfjJHlALg7TOpfIB9Y4xTZxWhflGbaSIhkfue2JEmlMJ8V5faYjPlE04LqLUeaVFMqSlKrGyehAjSBIwTYaXWNRjgqE2FzvPlCkW4UtgyQuGilsTeuPseg2mgujCS4Yxe0fBBa/MMzeOnyixuJYR4Nlu5DOfzDwzb+Q5qCbC2Uj26hxepzuvUwxe5Hs7L/tSB6lyKmeB9K1GpGDuhfj6kC76eKWw6eg2vcm+DFcxzQK46SIJgnjZN90UZs+1eQg8oW4XYBj0apbP0pVbBPYfmgo7qRAXP4yjObTECevfaaxQeRU7VzGxS//UaAvPMm+p79IsPtAfSKbBVPLlD57lJCr6WcJ9VkQk+w8Xqd/OcfG968CmOooPemLowZdrvdj4Twk7I5a6Cq+Ly8NDfGeCFF5cHghcqJ0IwW0TxFs5dDgWPk7wIj19Ek0Ots4dXfjwFsm6fFY7r/TMftENgZJGaVBWjYjKMivDM1JYPa5ol0Oja8Y7k5+Hnj8gR4bOFtJwmuz1GOxLZKaMOYKTG6Ecd5P5AUXd3Izu1zRTxXlU1h8Ecjve5yW69ceXCzM1XjehVwUjk1+f6TJDJjVdqZRLpBUQjxKdwHTy0R//plBd2IuDxa23wqc/wUj316afpHJ9blhX6c8W26Z2A6rPV9uV2z3BeUq489+8pGs4xPPawX6YFj7iTCXC4/OeuaLiiLpOSsO/Or+jBZkStkrehJBO5YWPW+Zzhqa3tL5wMnJgX2Z0b+dCFIOcLkXtvPTirPFgbvNlLvdlPykY9fk6Mxxv5uSR2a595rECvat7izWeJzXVPsUbTzFvMYaz25djE2ysp6ARh8Myh/vP5V42tuCJsllExaDWk7P9nACbSc3RO80fWtRZw1+k5LdGtHzzr0YUoHQxuvE+RESEHKFznv0dUo/9cKv1iH+2YB6sOg00L/NuA/C7w4aWDmhtFjZLvh2uCFAV1rkCQa6WRCJi4fkwZJuoV2K5MpYh/diVvSRh68aTZg4Js/2XH5PNh5f/Pg5amfZNXNwkGwNYeJppo500Urwk4f0rJZpeQAbCS/pSU2bJ4ROYyc9NAb9mKAbGQZ0M4PPAu42PWr+vaK8z+RzWQe6c1nrunXGZ9un0CkJQbKBi9++ov1+zd1mKpKLTqM2Cb7UqJc1odfoxHF+IiFSs6wZaS0hKOo+oXOGm27G733vNbWzWO3xQfFYTchtx6EVr0TTTpkXNbOs4Wc3lyjgdjOTcxsUP377TLwIqcOYuHk2njTr6VpLf7DkF3I/zTNJEb3tZigFk2nN989u+ZeffUCR9Pze9z7lX7z5gO9e3FI7y1ePK5zTFAtZf3WdYb/N0Ymn36V8fvMMbGDxfMs0a3my2PGru6fYjcEtHOGDijxuG2ZZx/p+RrWZi3yr8GCC+BOA5C4RU/qjJrxO0IuAX/VgAnpn8EnA5x69TnCRRlWrQPAam8t5V9pjjWeWNqzrAq0CRnt+8/h6P77RRbrLFG1uxnRJFGNwj4k4tiO1Y5iGqYgNFDlKeSE6vmwTRiNon8PuW4HVz0Q+4bJjwmAwsh4fMHWTO0d1asgfnOjVu+M0OHglVI1niuJOXl+zirzrUo1FlumkIMjWosd8/I4l3cYv+U7kKbYOVGeik08OMsVO9ozUi8EMKmZKKewnV8ef4WMKonbS3AyNSlBEGYH8jHammP9KZDyCbpQpsySQqlHD2841Q0LlUDgPBU5zovBaJCwuM6M8wpYw/VyIJ9N3clyCluJTd7LN6KaK+oxRR20amSr3hfwDx01JMFKYDabCIXCH92LvmxMTDacSvKSC6NUHLJ9ygXwtxXS601z/oaG5dLz6T9Q4EVNIcehyjQtR4974kZee7qToyx4Fx5nufCS3KMpLg0+gvvDMf6XJosRCnhtp5jT47Hh9uSQ2mN3xz/iEeL5hoKPIeT9O1ofNj1Bx5IXrTv5tWinKu4in1PG46uiN6JbyHOkjmNj4EY2AdFL4D81UOC5h6GZw8ufJ2MwQ5UlE86lgLeVY7L7lmbwRiktxG0i+lK3G6U88V39Pk66liPaJSEnSnR8lbINkxSdH0svQRA2GX91D2gX2qcYbqM4t7VxQk/Ov5O+5RIHSx3MQ4uGM2yFbumhQlaa1fAonP5f7I1vLZ4ZyAdN4Fl/KX053cv/m92q81odNgsukyK/PoG0td4cpTZvQtRbXGGzR8Sd//h1C6tFFj0k8H13eY7Vn32a8+eoMdGC+qDidlOS2H03wIqmAyeWBcpuL4Sz1cJdxuMlHSZqpFd2zFk46kZDYQL6s+fj8nrq31H3Ccl7x8DCjWxpS2+Nrg0sd1jqmmchUdByPOa+4e5gTNgnMe7SJhutULjylkIaj06g+as6BcNJh8x5fJzDrUZXQX/xKLujBWMjOisSl8GKi1B6mPY1XmPOasEsJnYTKED/3dWWwO4WbSDHuPJCI9MMnIQ5rhsEEuImXn98riIFQ5qClu4zXsT2IR6dfOtzcwcHgJzIBMlsjn7NZoHoiGwP7LkXXKf0qyPmcd0Ip0fL75bbgs3thhLOUzUi2rKkfc7on8lqUU7S7VCRHjaF9yJlcHChvpvibHAV06wTSgNLi0cnnDV3e05cJ/alC1RExayHMeug0oVfoVqMbCGlAVwafe2GxOyWT+FaK9H0jhmatA66VL4kw7+nnwMGi5x1Kwe0Xp5hSs7UB/bTiu09vscrzdr/g4WHGclXykzfPSLOOxDrypOekKGMirBzHfZdze1jEQKmEtJCJ/3JSczHZi9G3z7jIdvTBcF3NsbEwPcsO/Oc//QG7+ymPacd6XzApWrJEEJGHQ85+mfL8cs3DfsKn6pzffnpF7zWdM/zWk2vq3lL2CVWX8v2TGxLt+OX2jNNXFW92S6xxbKucqku4eVhgZx2+kHvQpj1VmeI7Q3M9ARNIXxzoW4vvFTrxuBB9JR8faDYZ+mCkEeyUGEc9+IVIyJSXcDJUEE9I9FsUecfJtOTqcUHvNG83SwAO2xxf1f8fqqN/w4+/jkn635Bp/Te6SDdtIOQy4crXPmrQhbrSF3os3oNRIgdohzhyNX5Bp9sw6snHwqeC1c/VuPo/TtGjydOKPGWYPielFPgDFi6oX5e0JAfoipia+Q8emNqe1hmcV7jOcjCexDpqr9h+viK/gWQvr3nQ4PbF8LwQ5kKX8YmiOhcTnRR1YUT2mV5SO00TRqKFrUWSMpgOB557N5XJvu7lPef3gWzjoumSkURyeC7T8GEiZjoJahjGq+nuKBVwGXTx53XTOPXNRIeuO9h9IFIJWwk5ZwjYCUYxfRdlRFHC1M70iL5slorplWf9XU1+x4jtE1MvYyKr7hXtAuoz+dJVnSLdayY38uL7Qo0bEpDGpVlqLv+lY/eBheDEX9BJwWgaH6khGpTCWSmG+0LR5HKcsq188fQTTXUuz28PA+5Qs//Yo3rF9LVMlE00afoYxGT3Ih0ZJCbDRqi+gOz+KDXxERU4BFsl+1ggh/ekMTCSWsbNUhvzaOKUvZ/K79m9FNvJgaNcLBb3Qzqrf88QqgKE2EDI9Fu2OPWJQv1PHii/WGLOGtK/mlDcSHLuIDdZfxvmr8OI5LR1INkHnv9TaWzGwK0gyEyfHDcSw/UxGEy1E4nZyL0PUnivPpEAL+WhePDkaynQm7mmXcYApujTcIkaG0yXKbnm3dGDYippfG3p8KmmPhHtebo9BiUBPPyW4uzH4ZgbcJDU1eQQNceXCpxmnjdczvZY7dEEHuoJ/byUaWTQOK/55ZdPoDIj2s2vOuo2kXAe5fn88XRklLdeYXRAJ57ZSUndJjQhQ5lANpfY+Czpae+m4BS6EKNkvU/5WflUdNG5FNpKB758e0Yxa1CNZjGr6J1mX2dUu5zJoqKuUkKcFDNxpEUnGnAnDHNqw8CvVP2wspLjHfaWYlXRmED7kBNMwE0d00XFclLzuJ/gnObJswfeXJ9webbj7mEm16HXmPOaNO3Ry4A5lc/MtheJSQjQX2hcbUUf7qTgGZolv3LorJdwpk2K3cr0UvVKitV5T7asKDcFT5+ucV7RecP6bkY6a2kPKRwMqhE5i3KK/qQfp/C61riLhnTa4GOCbD5tYQrVzRQz7+gPVpJOpz3UBr1o6VtJvOwbK4FxxkOvoYnpvI2QQsyiE5xga1BJDC0Icv05p6WgNgG9tdKs5AGfxS+umJIZ5p2kgj4k0jik8YZ2MomXDZqK2n1YTivMPHC3mZKm/disNb0w9r/aXOImUugn1vPl48m4/ZjMxNA4mTS0vcF5zavFGh2/ZGdJS9kn7OuMYl4xyxq6uSExjrNcpD0z2/DlfsXb9ZJm9yEmc2R5yzRrcUHzmBVcnG/ZlAWJcXx8cc8PFtf8xcMLlAo8lBPOswPbJpcAqEnOO39KumiwxnGSV/Iamozb2wXXtwuSouf5asMiqfjSrwDD2fRA6yxhBvNc7ilJ7nV89sUTYaB78F7RvpkSbMCctPQ7kTqZncZlCQpp/HRrCTrghrWkIkpmA7pRBBtd7QpM4ijLjLY3GOM5NCmzvKV1huXJgXKMl/7N4+v6+EYX6SNukGgatADqODXuB9QgI/4OpOgCxBxZyxSnncvK2kSsmzcyCZ69E1Oom8jPHnS2A45xpHp00MwVxb2nXknRnxykAG5OZBrXLBT+Pz3l7r934MnJjtvNjCRxqP9yxfoPK5KsRznFyc9FImLrAesIh6da4tJr4Zc3Cy1x7pWwwofgmmwjdJjBNDtOOIkBRXFy7oep63uSiT5XMahIdOj9RNGsFNW5NCuzr46T+6COE83301eJUgHlINsGigdYf1eRbKWoQkFzKoVluhVJhDRJ4K0eNyJ4kaD4RJEewihLEJKIYvWpNCS+kece5DtSZKoRKThMnoewpnqlqU+hfOmxB0N+A8vPnZiCD3KuB2RkcpDgI6cUzdIKTSgm0w7XnGkibz5SRJQP1CeK8omEWiQPluImegZ6TfXE00+PIVXVU4mH1q3o87NH+dkuO07Rs4coW/HgJ1B+v6GYyYq5A3aVJXTyolQigTbBKdRDik9EugSRnNNGSssDuChraVdQ3Ea8Z5CmytZy7AYykNwvUF2CTwPBBpKdZvVzIQbVp4r2f7Bl+R+e8ESDN4WE/6TDtRFwE83kNibjqthkq7iVMSJ16ibx3tkfsZ1hIgXxoFG3VUy1jRi/dO85PDVjkzggG49GUNko5WtPUh69KH2hxm1NfSrHZ/uxQfXikxilValCeTGT5/e9+DQmmuQgjXJ5oZm9ZjQw97lo5iW3QDwZXNR8+OSeWdJyfZiPfOzUOr53esufX72g3GX4xqA0wlTeZMPQn/P5gavNQqQPHlSnCcsWpQJllZLlHV1vsMZx8eoeE5uA+8OUIu0onq952E7o9qkQURpNUIGQe9o2JZkL5o+9pdpJZXv3bkmxqmmqhHTaUmQd5bqI0+vo7akSTOJxMSLdntT0DyJjGR560RLuM5RT7L9cSMGYBFQSOLvYst5Mue8NXW1Jip7eGYppQ9UmaOvxTqOMlxj4aDb1QXE4ZBSTFge0tXwVKhNgIkVsSHuZRibyd/OJBBStXm4o65TVpEYTUArmWU1qHP1qw5v1ktNZSVsbFqcHqjoVL8DBQCzI+6ct+axBxa1Gs82wJlC+mUtDmnuqw1ToODBq7dFAp1GzThqbXYI5aVFapIRpIQg+X8i1XuQdbW9o9lHD3GjwBh2Qyb9ilPSYRI5re+YxlSZkHmqNbiTtt18q0KKB1rNOCn0FIfM4xWhg3P5yhZvJMTx5tiVNe8pNwcFNwIuUSJ0AuePF8we2Vc5+m+NSh9aBv/vR5zw0E37x1RM5/irgUscv7i44n4lPYu1ztnXOB6ePLJKG3HTcNVOu93Pe3i9RCr51ece2yekai04cLy4eqbuEV4s1uemwyvPPvvqQWdHwdLoj1T1/cvMRRSJF/KHM6IPmcrLn7XzFyemBWdZwURx4s1tS9gkPpfDe/853vuQsPfAvb17x+vaUzz6/JJm3ZJnIgqrOUrcJm/sZOhXdn2+F5R5s4MnH93JNNjFPIIB6ndOvHG7qUQs5321uUJOerOiYpdJ8N4cUKjH99EvH+Ys16+0E38m2zLfS+E4nDW0nQWTTtGXfpEyLr59xVBFihsy/5uf5zST96/8wlcf2fiRuvB9ENMTIH6kNUnwP6Lbwng54wM0JSSUWfQ7Sh0gNiVpxMWuqsfgfUiIxgTaTL/z9CykCV5+EaPgMTN9I0T+59ZSXmovVnrY3LKcV+zojq2D6Lwq0h/6VFJLpXjYCIp04YtwGtKCKmmxXHIvwbONHeoVuBXsmWo2jHEI462qc9A8BLu1c001h/X0hKuT3UetcwurToal579hHk65M0X/9btH98Rz0haK4gfxRNh3ewOoX8udsJRuI5CAr16DDSGIZJ1Rx2uwiI9tWYcS3DSzwEKe/qIFrLiMK0zJONoNWoAQ9me5h9lYag34C6++YcXpdn8H5j/yvhUQNcpEhadT0MgX2iUxlg4mTQqPoU5nMTn/vgd1PT5i+ge13PclaY0tZv/fFEYVYXMv7mr92lJeG3Qfx9xLwBXTzwPS1ik2DvM90k6G7bJzCzxrGNE2FaOUDog/XfSDdepafedGqmnhugkyhbR2OEqaZppsdi3OQ93Z4AcWVUI7yR/nhLpdNVflE5En9ac/T//MMkPtM0JJSXIeDojrTbP+dPSf/1xlDOFTQ4h8giITL5cIcHzCWyofYRB8bonTnqM8sOjZQPpEtkK0CfSbnSTvw8Tz4ZJAWhfH6Ha6fdOcJpYrekSOxaMgScJmiuJPrqZvGQmfC6F3pV4rbv99hr1PO//J4HAe8KkEM6gCulqTLL//0Bc/+1hXn88M4jXtoJlzOd6SrNWlMW7o+zFkrJNUw7yWIKIApepT20uRvZ7T7FJU6fFC4XqNN4O3NCpMI7g2gnHQs55V87swN87ThZidIwdQ66t7ivGbnNU4PH4gBOk2WdswL0ZtXXZzA6iCGN2+wmSSoqlSmAX1jhSddG1Qn791vU+m7p47paUm5zTHrBKcD6786I6SBNgvouTQd17cLWAunnXgsQ+bpMoPqFc0mFZmGCezLCQSFmXT4XuRDwPjedeoIO0kGLb1Gac92U+B7zWNjsLGw3NepYBsJnEwrwTBGGc98tWOStLy1S/Z3E9zco/aG2uWymvKKZNZyuih50J5+nYl0xStUP0xZteQh5D2qEMlYNunoM0e7S8lXNX1naMtE8JDWS3BSrzHxvZI6zEwm6iZ1uF7jSovZWronHTrrCQ+ZGDsdUtDLx700RR5UbQgLMc6a1OE7+aw1e9ks6FY2EMoElpc7mlaujcmyoneGrrJkk44nsx3rB/ExfO/ilsdJQdmmFEknFJWgmM1FiqG154Plml2bcVkc+MntE7T2KAVXuzmf7i/pS8GBUjhOz/Zkcdv8+DgV5KJXfPnmnOWpFPlX5VzSYlNpTq/LGU1nmaZC7Km6BK0D2zbntpwRvKZ3mm2d0zlD5zW56ZllLVZ5FknFdT3n49UD+dk1tUuwytN6Q6odqRaJyx+//oi+MZyfSvBX1xt8UNyuZ/S7FF30TGYNvTOEDypMUGM41iRtWe8ndIeEej2lq4SZPn5/Th1qb7l/vYLME5wSw3bRk2UdzmvSKBkCuJy1XFUJv3l8vR/f6CJ9SNiEY6z78GvDNNfW75FU+vcKywCEMBZ6A+cZjqEuLlEjptAnapygDpNjlxyxbbqX15DugkhCgIHGEjSRSKHYfQiPb09Aw7Onj6ymFbVaYP5HD2w+W3H2Z4rqApJS9JBdYUgjUcRWMrVsJjpOdQNme3yO8sIwvRI2ue4D+5eKybUfNb19nM60c9h8W4rD2VeAkmIo3QUmt8fAojZGrxNClKuosegdNPBDCFM70ySlNBQuV6L9HWQcA+UiYdwwuFQaKJeBS+MK2RPNfFJo6V6mrgRJRpVCOzYgvRRAupeGQXewe6mYvQ2/1ky0cz1eA0GB6aSha07kebppvIb6I+nk3b8N2Z1h9lVgciOEkHTjePhhQn2mSNeiQ1YOusv4vmbR9BmbveZHp6QHKdqKt3qUjcxeM2rHbRUJPSnsXoh2f/7FcSsQtGAFB5JLcvAxAXb4NdG6SsOkcPJdhnZSoEOUj6hAOxfzqumO6ZhDCq1smuR6Svby//ljGBvSZK+YvvPY2tMszdEYGQLZoxIai5Pk3Orc0CxlszN75zC1p10YkkNg8X+byXUYcZdJKahKkWkROfTRwKzFhNznYcRREqDK7Uj3Ma3IkCSRVUk9Z+J16oGIDh3lQz6MnxVDE6IG4zG/zpbPtn7k4gct4VimC/ig8KlsnPpCQWmwB1h/W+EzkX71Ezl/plF0y0GaALtDzvT7EsCjlfyst+slF4s9NxsxMOZRv7s75CgtCL92l2InIknp7nKefuteXmdnMHlPX1smJyU6E2TdTT1jYjv2XcosaflsfYpSQVjQteG+1ailTJV9L7IZAiwXJQ/3M6g12XlFH8kyTW/ZHBJmk4Z00gn6MeIVs6wfiRQhKEKvCU5MiKYWqkk/71ELx6vLNVoFXu8zfOExe3OkBk07/C6l2Usojq6lKXIT+czO7gzN0wCFI8l7uoOkcKpGo1ct+aQlT3v2VSZSHOsJjYFGCvtQOIp5TbXPePXkgX2Tsa8Ea+icpikTqn2GtgFjHT98es0X784IB2lM9KwjL1ryk5q+tbg6RR0MYS5FlusMN+9W6I0VA2+QoUNIA2ZvIiJXri9jHa43OKdxnQTyNJGLjpItGK2gWH1nhCMexEzsjDRRXerRM6FFubkjubOAFLou//WGVJC3SrYLc2nylAkY4zHW097no/zTZx7daMx1yqZayt+d9fhccbHak6wcdzthun/w/J5Dm/L54ymHvUisHtqZpKy2mkOANOuZ5I6yT/Ao3hwkeGg5aTjJKh6bAms8xXnHNGk5dCnOy/T73X5BmotB1HVC4/nWyQOfb05Y5RVfPpzIuVbwsJ/QNAllnvJ8ucF5zWzS8Ga35MPlIxeTPR7F9X7O3UbCk6om4bvnd7TesO9yNk3OSV7xer/i0Eqq7OVsT256HlxB5yTBVFtPnnTc76fUVUpetGRZ3IC0hsM2l23V1spGw0FjA4epUHh05njy/JFNmdPUKf3BxlpBBn5BI9QlhTTEKuC9pu81xnq+vD0lXBX43LM6v/r/Vib99T+Ga+6v43n+Bjy+0UW6j7QGQLR56cBFl8fA0/419nHUnw7McpeG+G9FfSm/15zKBHn5K8GvjSErg4YsBBSiQd+9UjS/VWOsp6ssq3+esf6DluRdii1F0lE+O3Kpp2+h3aeCLHRPKJ+APofpf3TCfK6oLkXysHul8JnIHha/kiJhiJZvljIp1C0jKrKbB3QLm+8Z3MQzeW1J9sKgdrlomrM15Gv5EJi9C1E7ftTiP/5Ac/ZjmeCbOtC8kiJYuyN/3Oc6hgRFOc9Ej5KApDxG0o/x74rxC0o7KdiHQr2fKCY3nvJCk20jxq4/njcxwBInUnGNFuU7kgIZRhKHyxSzNx6fHhsJb2RCO0zDfRKlFyFQ3EqTMb0KI7UGJcz3+Rcyka9PFUHJLVY+NRS3kD3KzwoxXMfUUNx7ukKNUhtJJFUjGnHAIBZ3gd0HismV6MHb7Pglqrw0hp5IKckkYl6aFCmug44FekR3BqPGopsQ/RNepr3t/L1GYAgrCsPr+/UQKN1Lc+SNGjWSLlMjL9804j1wmRnPjUulmV18IcmtPlU0S4ONnHKXimkWb2QqHSfbqg4kVRgn281KTMxD/sBwnyWVZBLUJxrlfHzvjBr7YUMWjI7HWY2Ju5JRwIjIG3IGuqke6Uk28vJlQxakwNSx8XNxY9aFKOGKTeXkKK1SPuCtZv5JxM9NwWyiB2WrxsZg9lre3/oPe1azktu7Bftdju8My7M9//YHv8IFxe+cvOOXu3PerJc4r/n9529JTc9DM2FdFxjtudnMKZ4eOCsOvJhsmCQtjbO0veXmfo62nr/wz/nu2R2f3J9zOil51yzYbgu08aRFx+T0QG77kQrhg6J1hu2+wAeFWgs6sastfpuyfYgIwVXHY21Jcvm7WgW6m4LWeqYnFV0n7HOvAl5r3KLHLURrmy8a6vuC+52gRpcnJWWR0tUWHmPl+piOPgq/7AlnHl9LBa8rTf+9inBIMPcpXWHRi5Zi0nK4muEPCWVjKY1QWbJVI3rdKqNvDPbU0d0U1LsZuld8uXuCOW3/X+z9eexueX7XB76+y9me9bffpe6tqq7q7up2242xO5gQM5iMxTqTGCUSf8CgGRax/GGxKhAEDuMkVpQoAYSMIkUCIZBAILA8nhnGiUyAGRvaGBvbdLu7uruq7n5/+7Od/fv9zh+f7znP7WCHmEx32uM+Uqmq7n2e5+znvD+fz3shL1p2twX5vCGZ9SgFedphVOBffPEhJu8xxxXLaUWRduJYcr1gNqu43SaoSqFXFr/oyecNVZ8TrGh7dK3pFw67jhOFD5W4dYbvDe1WnHic0YTGyBRi3kOjIRd6jMqccJgzh9KBvjWE6LmurdCLfKT4ZAc1+ijQPJuOzkzKQ3orSL2fBszDnVgTGk/XRveczgjIzR1h1jGbNSyKmqdfOmV6b8Pm2RymDpymrxKu9FQoWLXh3bVEX4dOozqNrjQuk2tKaVDzjuODLZsqZ73NuV0JfYPSwqSnvJnwBKA0vP6xF1xupjwrDyTR1HjWy5xvvvuUD+whzy4OwCuq25yf3D2Uic2RZlHUuFiN9E4T0p6PnZ5jlafsUh4ubvlgdcjnL06pNpnQhaznV3z4MfeKFY23/NzNHV5eLsaE2Gdmybe+9phzPeOLT85Y307QiZdt37NrWVU5VZlCgN1NgblOJKzrJIqjOw1HLb1T4DS/7Vf+c/7vX/yEULqynhcXS9RlhreB5LRiMatZbQqcllRdv01Ij+poMek4mFYkxpGZns4Z+mMpRK4uvt5J/1pfflmD9PpE02tNFj2/lY8ASjOC9QGcK/ZAe+iY7/1sBYT2Uy88viTQbg3bjzhUrSmea0nGjP7e2kloSbKVSPvp/5DTLhThLtx+wjF5N2X+KIyhPt3c05540guL+9SG5uUE3RiCheJbr6l//IjyrthnZbeyScv3vXDLEwFmLoLkbCWj/e19zfyp33cVo0jWG+HBogL5jaN/psf9Hug86cYLoFFROKvAZxq7MyOXH2D6PDBYSdZHmvIOLL8URqC95xtLR3KgAb3K07aNnJtusndTqY6NdITV3tbOG+mcunQvRhwW8fV+lbbyyv8PANRLt324BmwVu1lG0cWJgGnCvisfgf4oOjaKbqbJbmXf0o0nW/s4CRCriMlFTzcz8TjvI+x3d3UM0WH0vZ9ceJqFZnEhRU91ItSSgy+IEFa3YKJjinwP6KIgONKk6kNJtx1AtvJSHI2OOnH9NoqDh4LL7qJ/fiJaiW6ipQtspbhItz525bV46Edh8CC+NPXQdd4nlkIshmJOAEA7V/STZKSn6H44xoyiyuE60L3sDyHuj45uRi68kjQq0xXpdg8ZBKLLGNyHRiFzvC90L4mxLpO00NAPzwA1Xi8q7KdpPpHjR5CO5LBtwicfKFL7e4Xo2f9q18YnijYxmDqgnTg4DT7zw/OHmJrrjfzW9ECA3odeE6/0ie04SCt+8uI1NjsRGg7d9a62/GTzGn2dkM0aml3K4qBkPqlxXvP+zRE/9+wubpOgih6deI4Pt9yfr7mqJ1xUUzLb8/jiCG08NnF0jYXEsSszbuupgCsdtQsmEHpNVybiP66kgxtSsToMaYDa4E2gdZrOCBVDHzZY6ySsSGtcYwX0BYWygTQGrdTPp2Ip92SGqRVNKjd1sIHJgw19b2ivCiikk6yNx/dGhKcecVS5yDG9ws17VKfxq5Td7eBBDmYTu/I60JDRZZZ00pFPHU2VwLQnVIaQe2g1JnHkaUdTWLT2lBF0Zic9L58tUY1Qf5yzXETevU17zo7WIhy8t5ZCpTd0vaG8KVC1BBopL8mpIfEEpemPe1RjSZcipuwG9xQj05rQK3QmFqGsE8xJjastBOiCIi068cSf9LhO41ap2E0uOthZ/PkMZwLGxfRTNxSgcr32Bz3Hs4qXTw/ETafwqMyJQLVXnD284eozJzRvOG5DgVm27HYZ9qhmUrSsbyYcHO9EoHoYmOQt2zKjvRG3GTXryO60zIuGEKBIu1EP4aPbT5Z3kEN2vKNIOpreYpQntY5tk+G8xncGM+l4684lVZ/gg2JTZyRZT11ZlBWqVTGtuTvfkGrH516ecfdwjSYwTxteljO0Clxuphjt+cTJC969OaW6mDA929F8acFVPeGzL+6gdcB7xZ2TNfdna6zy3LY5rbfMkpa06Gi3KXfv3NI5wyRpOS12bPuUL56fjAVTMW1JTrfUTcKyaDAqcLstpKBJPHSK/9t//6vwWSB/uOV4vuPGTAjThvK2wL0sWH8wISTAkQRMMevwXpHFydrVekoICmuFnvXW0RVfuj6mrb8aLetf/PLV4KT/Umml/7IG6e1c7Pt2D7QEmwwCt0hLGYSDpgnRhlCAxBAx3s4ipWQmL+bsSlO/3aFUAAyLz0jq5wBaB2u7ZilhR6sPi4I+mEB6azj6jHRRgpYXne7B3nqYOFSjya+gfG8GeaD7VVtOF1uutxOxvlsLYJYdiMC7jlaSWgBE0LE7W0gHePh/4RDvHWts5bGNeEnb0kVhpsa0e5pJ0Dq6lUR6kIX5Yz/Sf0aXijL+extYVJEH7oSG4g2j5aNdhZHHPYA9iDZ5bt/N7gs9agTqwwiYiGCqh6wMoxPIQNPRLpCtZBtN4yM3nD0vPU4Zgg7Cs24GDrGAL+PVeE0IZUi6oronHhNNO4sv14l8tp8o+ky21RaabO2pjs1IbzId9NE2MV3J9WWrQLMU8bCPXuTVsSa/8dK5j538+hSS9f46lYRcWW95Kk4x3TRSsIYReR0oLnpclpDdemzlMVVPSDTb11KCkutlCGPSvTi/DFQSuQ8GK0uFt2IhZ1o5HjqC4RA1DMO17qOYehBMJ7v9pGXgdielpyv0qNmQe0vH4mEQW8dzZESfoGPxpp3YyAWrwHtsBM4oNQJy3cv15CLlbNCdQAQiQZx/nI+BTZO9HkF7ol6AUUg9cOalyNnrS0wTRkqZuMgwZhJ4C6YKY3EronNPN5NnjwqRrx72z6F+Iv8UL6H+woIn91KyomNeNFxsZ2wmGUYFjuYlqe2ZJw1vza5ovOWLm+PRW/q2KNhUOV0vPtRvHF9jDz1ln1D3Ca0zGB3Ej1p5Om/ovOHu8QofJAVzNq/FwzzSAyaHFSEopkXDJqYstmWCzyQYSBnP9KBhV80l3Ecr4ckGoEqgcPhNSsh7drucNOvIio56k6GMH4OCnj0+YvZgQ7kVUWxIIw8j9SxPN1RNirWOozevWFcZ1S7DbxOhC3SKkHmKw5rFazXnzw84vrMeA56KTPyxL69nOPahLioJ+NbQrFJIPWZtUJk49bhcrpvu+YSbXpw4ymwPdLZVxsGdDUeTcvyz882crjNoFVhXOccz8ZUv8o7dNsOViYgptwZikqvqFbo1+Mxj1zJR6u+GVyYGAb8VrnwyG9xdAuggIDz1wksPinaTxQAmJQmYvUx7dNYTXqbxXaNGq0ndqtGJyVvxV7/dFujcCR1uZwiJeO/7JqVqE9xhj3tZ0Fqh9tw5WdP0Ai8m0Ud8oLQ0xtJ3BjJxAtA2UK1yqm0mVBcNtJr0uBJBrIY7iw0exeVmyup2wvKgZFsW4prT6JGDnaY919WEq4sFTzgmnbTYaNeYzRo+9dpjUt3jg+a9zRFaBy7WM+pdSpL3hCAuQzZxvLhdsGtTKYJzT3lboO40PH15iLaej5y9BOAzj+5xfr3A9+J0lGcdHz85BwWfeOsp57sZTW9ZlznPbpYkiaM9L1Be4WygtSEmkDqq2xy9MyLOLQ3ZazXJgWNtp5i8Z140PHl2DLXGrA3ailbDHQmXvWksrjMoFehr4dXXVUqS9bjW0HSaX/HGUz53ccrJfEd1k/2rwOjry9fU8ssapNefqLj7YM3trqB8OUG34rXc53DnnwmYaBaK6lRJKiIC/GwJzVFg8gzy68DmLeThOHPolbTZlRNBXH4VRn70wBHO1vKyn76Iv1ch6Xo+ghkXYsc+vvyLnuWdkmt3CInH3lranYQWlNcFh88FDKcb6ZTqVrq93UzvwZDaTwpsjJ5XHnTkQKtmzzkH6Aqxfxs6jt4y0iNUD9r5CA4ZiwKIfPsQolf03hLPdNDm8t/9JFo2OjWGzigH+bV0RrWLrjq5wjtQIYK/6IiT3+5tEFUQQCgBS8Ldv3lbsfxSGIuK4soL8IraAAGKenTTsDtHuxTEa5swagWG5VXhqcvMCND6iUKtpehKSrHtA1h9JHD0s5Bt/Dg67nM1Fl4oUL0UTgM9J2jY3tP0U2ICJUzOvdB8Ig3DWQGRyy96qhM9UrGUg+nLHt16mqUl3Ti6maFZvLIfCnb3ZQPbhZZ/ZsleD/E/oWX1xSB8le17+W2Bh/+9R/dyvrrIdQ+JADA5Z8Spxp4G083A1kPhAqqQz+oe+mRwXYngPdVj6NbsWRevf3FCKc+EljI5j1aKsXjzJkbMa5nmyPUXxdou3nsRrBu3F5XurVUjYGmJXHMBYUPBOoiXhXIjf57s/NglHwpSZ5Qck7CfUuguhma1IYIgNd7TygWqmTjBdFNGzUFQe39/U4OOol6fBg4PyjFpMQTFxXbGJG2pekvVWS43U6z2rJqcm6pgdTNFW0+Wd2RpR5H03JluKPuE0iW0znK1mXI833GQV7ROLOzef3JKPm+4N1/TOgMLyEzPN5495+luiVGeqktHl4gH8xVPNkuuXk4kFKyXC253W0DixXc78ZiNwR+3JIsW12t85NC3tRWQ31qOz9YcFSWPrg+puoTjeyLQaRIZ83uvcJ0hKzpWVzMoDU0SKNM83lgBcofJHDZxpNahVOBmM+Hu/RuM9pR1Spr0bMuM+4crkrwnnTXUTUJXCb/XFA67aIS2M+kJrcFhRqu7APjUk5zWaONZFDVNLw4e213OZlOwWFSEAF0vz5bqhfDGy01GUvTUjfDis8Oa7vkEf9hBAHWeEpJA6BUhDTLdCQpuU8Kyl4TUVpNeGNoHLf2ldPHtTtMvfDwHGn2bEI5bVEyXVT6CdACvcC8LtIbuqMOsrGgArDwTh4lOPw24xmCmYrFpih7f6tGhRHWKadbSLg2zuw1lndLUiQghywSdOWazmrpJODnakkTfcG28aCTWGa4y2MOa04Mtz18eoG4T7F0B6H1nOD3YclMVMnGIE4ubF3MIiuKo4p23z3m5m5PantemK7ZdxkcPL3h/fSSgOyiaaYI1nm2XMUtEOLqqcrrO4BqZOrQ3OaSebN6QWofWnkR7ltOKnXX0TkL0Hh7fcFZsKfuU83LGJ998ypvTK55VB2gVuG1z/sUPv8Ps37rixW7OalNw53DD66cv+NGf/QhtKhP3ZNFyvNixqTOMlnCvcpMRdKBYNNQ642y54dHjkyjM9ZyfL+X8Fw510JBnPYl13JlteLZaspxXlHVKtc6ZHlS4qP1odikmEaejL1ydjMelr78G6S6RWvlVWc8vgeWXNUif/XhB908OmRiov8ljKgHoyRZu39LYBmZPPeGS6GwiI/GBl+oSKK4c6cqK/eCDHf1M414W+GVP+nqNf2+OdmHs6qoIwIfumqQ/Sodv/SE9coxNK4EtfaHptwnNTx2zrAE0zQHoJxkX6ZzDn0o4/HzLo9+UcPKTMXAll9/TjjGdVL1y4ZsmjILAgXISkj0XuJ9IVLnL9UhPEDAoVpNuoUa3lXTV0xxZdOzmCu/ulX1VjGYP6Vo61ARi1HogW3tcomjnkZaTK/G0DmBLL2PuIz267aQ7z+ahZvLSjy+SZiEcYXIpVpQTUaBLFPmNQ7ced2Al/bSMiachoIJ0W9ulid1XOfajaCoKpqSbLKDQpSLgTXd+tLO0lef6GwxHn3F0U83yXeE39Ln6Mscc0/JKcFAUHMdGhu5h9TGHbsTyLN0KWBf3FCk4spt9N317X48BWf1EsTszoIxw3WMHO6kCtpTz1E210JcKja09BJi8DHJsJoau2GsFlIfDzzY0x+kYOrX8vEaFWHSEvZhXQKlwvk0b6TN9GJ118uvoNGMG3vhASYH54452bvCpwida1h2pMj6V9bpM0U6lkB22z7QBu+vxiZwoT9Q6OCCeo81D+buDL7i9dzrEFNWBZhXG/Rg79Xrofu+1JgPw1h1jATncR+OEpZRu/DANSHaBdN3jMk2fSwDTQC8CIk3mlWlItQ/26qfQHIgewFZQnUL+YMu9maSNehTXScHz2yU3m0l80QaSoufx+gDnhSJwdrrmjcUNP/PiHiGO/q1xOK/ZNSnr2wnsLM/PC56bgJqIQf7p2YrzZwd8MZxgjeNoVlIkHes2p+4S1mVOlnZ4r7npJzy9PJDkUq9Q1pEtGmZFQ2ocz58e4RMHjcYfCLXGe4XvNKEXm7tBRLqcV7SdZWsyThdbVmVB2Vray0IsGXMHlYXMUbuM0GmS45oi74Tm0xmh4AQB8gCJdXS9oW8MN7uCRVEzL2ouPjhCL1uM9uRpx2ZTDANSEdptEvoZQuW5yqTD3cWAJAXF2Y5qldOuU+y05+rJMd4GdKfxyw59m3DbGu7du2GWtdzsCtSdkj7yub1T9KUo41unUQetWFFe5rgiMLmzpW2t0EWeLgjWY3YG32rhqfeK9shhLhPcHbFgdEtE7BrATDpCpWFjCRNx+PCdgdJAElDHlQD1WuwJgzW4aLHqI0VLR4pjOu3kHAygxoO/TUlPK9qlHPvlpMYFRWIddup5/eCGR7eH5IkEFyXWcbsrJGip05iFUJnMpMN3hr6xPH92CKWky7peY60jeJnkiPhRRJcq0gXzSUu1yfip6zdQqeOdN17wU89f485iw7ZLeTBbse4yLnYz8QhfFXy2v0PfSJF3utjivebw5JbM9GyanLJNSKzDxFHurklpOktbJvy6d97l87en3J9I4Wi15zff/wzvVcf8D4/eodql+N5gsh7/do2O57rIO17ezDnIKj72kaesm5zL1Yz+RcHFBxPxowdCGlBTCQzzc7H+fPTolBDAH3QkuWQUZEnPLG+42kyp64TKpdxezNCrhE3iwQAqSJEcIJ232EKE3koF1pdT8oOaq81URMZfX76ml68oSP/3/r1/j5/6qZ/i/Pycw8NDvvM7v5P/4r/4L7h///4v+J3tdsuf/JN/kh/4gR/g6uqKN998k+/+7u/mD/7BPwjA9fU13/M938MP//AP8/jxY05OTviu7/ouvvd7v5flcvmL2r71x3vpCADzd00UH0rnLFtHnroL+Ew6YKYTIZ/Rg7uFUB1UD+jA7P8xQ/dQHSm2H4JmO2XRhJE/bTqhNQxjclCRMqLYvKFoTh32uCY8ntApqE/g+KcD3/yxD7h6c8LFeob98TnTp3D5bT35uwWbDwW6acr8Pchve7qJlpEkEVi0IfqgB9CxCxRTKU2n9u6HsRtu4/ZWJ7Jf2drTTySB0TYCmvJrP/LH26UUKMVWnEMGvrHuA30uXVefKlQvQH90yxk44WrfeWxncoy7mY4OLVLQDNSDpJREUxND0nQnfze4wgQlPOTle4FmqUm2geZAuqvJLoy2esMU4VXApHwEa50E6wy0BOX9WNSMILDQY2df+cDqQwaXwe3bBpdLxzi/HMSFQnlJ1+Ii0iyFJjS+7yJVpM8V9/6xYntfsfzAxYlK7MCjsaVje98yfd6j+8DsmaediahXQqUG7nmQgiduW58bmQwEoQp1U/m9vlAUV452Yrn5sBm55C6X6U83zUc6TzsVrv3mNXlcpNtX9QuisZDzEakcsUAcXH1UpCQNXXPTwuypKK9tE+jjv4PSEIRzbzo5Ju1cNAeDh/7qTc3yPeizJKaHym8/+07p2AKYSlO8eGU7Br//yFsfaDYoNWpOQMLC5O/C6O0+dM37PN4ro9PLQOeRH3ATuc7xct2uP6QxtVAoRvFu5KsP95vLoJvLcfeJgHQUmFJA+2DH6LNAeTXhs1VCCIrJrOF4tuPh0Q25Ec/vie3Y9ilWebZdShetpFpv+JX3n9DGuFcfFK9PrnlSHfIin3N3umHdZljtqXuJX7faw31II1+8ahPa3mK053iyo3WGRV7zcHbLeTXj7M6WH/3CW/jIBLTG03aW9baANla8kS+uFGgdUHlP12m8l2RRCdwJtL1hVeZ4r2lri7+NNBSN8OAjjUMnHjMRwLx5OSM7rjDGU94IJUcXPc1OgpPyrOPoeEvbWVzQXF/OwAR8Z/jg4kiyJnTAJo7gLTZ1hMzRXeeYZUs4bGGT4GcOWo1uFc37c4wXaki3MKjjFjqNnVXC379TE0rL8/eP44UCutWEY7kZtNWoRCgaapWgO+GDJ1tJOK3fW+CPW9a3UsUrKyNPU8bCNPfSZW+B0uKt8P9to/BZwDd61AcMtJdk0tEbOWb+XMKgQu5FjLnsUTfJmKegXSyuDzpcJ8FJ909vuVwL4M2SnrJOUauEcxaoVYI6brCpY1K0PLo9RGvPxcUSVGB5uEOrQDKVGyhJesp1ITdCaWAmnvSkAT/pUE5JKm5tmR7vmGYty7zispzSO03bRV97HSBzZNNWOsmTmuOiJNU9n7s+Y5Y13JutOTnZ8ZmrOzxYrDgvZ+RWqE5+UvFyNR/TcJUK1E3CGyfXlF3KxXqOTjzppOMnX75G7zT/bPdQ8gVWBT+hX4cAr792RXFwyxeen+E7jbrIcBMJfyLpKfKO966Pxnuj26aYThFeq8ErbOrornKxJk3k+AJ8/I2nvHdzRNtZ6q1cC701bK4noiuwgXuvXVN1Cbc6OuNYj0q8CIRrS98anNa4NlohBbFmDZ1B7zq+JpevCif9l8byFQXpv/7X/3r+4//4P+bevXs8ffqUP/7H/zj/4X/4H/KjP/qjv+B3/sgf+SP8g3/wD/jrf/2v8+abb/LDP/zD/KE/9Ie4f/8+//6//+/z7Nkznj17xn/1X/1XfMM3fAMffPABf+AP/AGePXvG3/k7f+cXtX33fkSRDmAjSJdx4FI3C0228tRHGm8VkwuHt4qslg7z0CVt54rjzzgRAJ6JE8PyfcfuTUWykg6a7odY6X23ehAk6tshMhwIhslPT0nXXt52IZBuPY//xts0B3D8RY9Pxc/5/o9oqiOxyvNGxuXr1y3ZIBws912+dBMwrRdrOgXNUkeA60fxnLROIic4yPd17IgqF9Ao6Wz3AkK6mYSxVEcGFeT/CdBMdfTkjuuP9J1XPegH55VmKVzuxaOedm5f+QwQwtiBF2GqADZvxYu8m0o4U7qJQrW4rsEHXShEQu3p8+jnPYgfI3974Mbbyke3m1g46EGwJwmSo+d65DGjpNuvu2htWRLPM6SXwplevaXpjHSr+0KmEyDR8Lb2Y9hTugsCZjuZgLhcbB91F6AZNAUSDz990UuXOVGka0dzIOB5WGwzuNlI1P1AHVFOJhPtXLahm4rfv0vVCB6Ly0BSSoc92UmR0BxacWmJYHewzRycUFQ8jxH/yXkjahQMYGXqoFsizz2MLwmxSYwUoG5P8xqmDkHFayh2nwdryunzQHmqKa4ldEsF0Rnc+xGNraSg1J0fueiEEI+LGi1UB50DgG3l/rv9qCW/Aq9h/ZZi+W7UDeRqFPQGHekqAxdfv9pNl6Jo4Ojb7b5wCjrmC7xyrEx0h5m8lK45QQD74GZky/35dBPP8f0V92ZrrPak2vHF22NcormtCla7gr41KBM4O9yQmZ7M9DivWbcZPig+9/KMPOvQWugyi6SizizXdQHAthUAsGtSMttzcbkQUOyUcIcbCVG5TGd8+M4FAD/6hbcIXvHB5IiwTcB6TObwXrFbFzKZSoU3pKzHJA7XGlxrUUamU76P91dlaXKLc5p82qGUeEMnByWZlX3Z1mKvd7rY0nSWm82Ek+WOFy8LmvMJ2VnJ5LCiyDpWGwmAMMaz2+WEgcLhFTQGPe1k5N9rym2Ksp4s6+iAdpNhpy3zexvW5zMO7q65reeoJECvRKAXBCj3JqAzoX7QGNo2h9xJqJQNsv9ekc8bmioRSzwdcI2VgKPzQoStpbi4BA0uD9hSwVWkvaReLCqNjdeHGp+NfiJVn2o0IQk4DSGLws6tXGyhkn93nWZ6WLFb59hanjU0AvT0rd13yhX0hYSkmeuEfqlYnm1ZVzn1pRRBu9wxPaxI7osg+TadYtOeZpvJOcw7XG9YHO7YlRmr6xkh5m7o1DGf1uQnG5pOznt/m6EnPcFpTOZQ2tNWCSp1rC+mrJlyvZyQR7/vapNDrSF3TBY1nzh7yfurQ3Lb8bMv7tJsM9JpK9cBct7zouVnnt7DWo/WHu/1+HdJ1tN0lmUUr2oVWGQ1V5MOrT1Nk7Bez9B5z6984wkT03J9NMFqz5vTK86bOY82hxwttxRpx+VsGgWvLW8sbwB47/aIe/M1zzcLapPijju5B2pDf51CEsS3vuhZX0xRveZnnn5IHpmpaNdU6jCJ597pilkqBd/nn9whbBJx+dKgcgnf8p0mmXQiFo5OPiH674dOgpR88bUpHP36sl9UCF+9kuUHf/AH+a7v+i6apiFJfn4u1Dd+4zfy23/7b+fP/Jk/M/7Zt37rt/Jbfstv4Xu/93t/3u/87b/9t/mdv/N3stvtsPZfX3es12uWyyWf/D//5+Qui11R6YBv3nFxrGrIn5sodpOXZbuE45+N8eOpGr3Uk3JPG2mWIiZtTsTTegB+gxhPHB32YrPmQNPOBBCkqzA6iQxe4KYNbB5q5o+8OL1M5O/7PHJ5yzCCIhWimDWD2TMRBw5+0H2ux/0ffN2FRy3gopvpsSvZD5SCSmKx26lGDRz2WHgL6BUxZNDi+DGkc/YT6VwrH9NXU7Xn5sbvByt0FpQApurEjCmR47i1ldacjy/FMeTIB1QXKO9Y6cBqRVdI0NAws+7z2GnvXuH3q4EfLKBr6IYOXVVg5B0PoFBF0SEhjDaGLlJOBnrDKD5MRbToErF37HM5jsNxHa6zIWhH1qFG7YNp5DeyW6HIpNsY4JQo0k3srndhpGus3rIcfL6jPrZMzjt8qqVQjOdDAOQ+qMtlaty/weYy2cl2NktFtnolKTVX0b5wfwz7QkW7xaEQkL/rMxXB8isFQyUWmW1MsxXLxv19kN84VCdFomk9QSl05+knhvrIYuswcuoHESrIeqtTxeRcQHKy82MR1U+EsqMjUB60AK9mHgxFzFAMDvSj6ljLtCVea8CX+atrF7h9W7P4IIzbMdzbw7UwAHpbBzYP9loLsXeNVJbiFVrLBBbvh7HAHNJovZWC2SXyu9Ud6JeOYD35Yc1yIqOkSdKS2Z6mt9xUe7pG24lANEt7ctuzzCvuFhu2fUaqxZYxN/0YtPLB6hDnNEXakVqptBLteO/RGQenWw7yauTMKhU4yGp6r7lpCpzX5Lbj2e2SIuuYZQ3nt3P6zuAqi04d2gZ8r0YrulBayHy0DJQCAKcEjGaOJOvJUtmO9cVUQnUMBOtJFy3GePpeS+CQCSjtpUjwkN8tOZ7vePrsiNArknmLsZ5p3nJzPRVvdBMkrKlOmCwqypsJWOk8+saI8DlxQg/xCKift/jeEDqF6rT4UMf72tRiBOBzuRb1ohUaSWnwuRdgdSnpvToGNLmpxxw0uNYQGkNybUf7w34aQEsEfD8NY/fdt0YcYLwivdE0d3pUqwmpl2IgdlaxcQqsAr62qNTJc6fX0Oh9Gm0rBRI2gFeYrUZ3+4C3YemWjuLeDoB6lxK8RlsHL3PZ9w9VIlbtFcx6EReb2PCI+6tSTzZtRci6S4FXQq0i9UloOuK5f+90RdUl7Op01BWEoKibhHYt0xXlFHomgmPnNe+cnfMzX3oAKqCtJ8lj6JLxHM93JNrx2myFJtB6yzKpeHd9wrPbJQ8Ob7Hac11OcEGzLTPp0sclRNekJOvpaksxayhXBajAr//453i0PeSqFEeYrjdoHZimLa/Pb3i+W3C1m1KWGSpal/LBhD76nhOAncWWin7uWby25iPHl7y/OqRIOjZ1RttZqnUun43GEkoHfGXRudDIlApMYoLoNGsp24TNpsBvEnRlRPNQawH7jRbgv2l4/Ef/DKvVisViwf/Wy1/9q3+VP/pH/lO+5ZO/+yu+rsdPf4yPf6PhB37gB77i6/pfs3zVOOnX19f8jb/xN/g1v+bX/IIAHeDbv/3b+cEf/EF+9+/+3dy/f5//8X/8H/n85z/PX/gLf+EX/M5wgf1CAL1pGpqmGf9/vY5ipEOwGxn7d1NNcwzZS4OpzehmkW4C1Yli8jJQH6vR8i0pxYmjL9RIYZFQHOHmJjvhBO+90aMTSBRDDkt+5Ul2ij5TbB8oZk/C3m0lSLfZltL1Vl6RbqA+0GwfSsFQH+gxVXHwi07K2A1O9J5+MHQ+w8AljmBT7dMfB8DcH0WqhhWQmt84glZUp5pi60e6QD/RTC7l7wRMClDLb+RlpYKMtl0Qjns70wI2jaJLNd0sijVLT7p5xW887Du1QYWRr+wT2N3R1LEAChb0lQCopCJ6cssDLPGMVnjj8R98q4MUQEPnVzyzQ+SYqz0dJhYAA+2GOAnRjQej8F3kz/tAs5SXbFJ7ujNDs5Rz0U3Ul4FBFQNyAlJYpFsBadkqus7UYfQhHzq3pvajJaBwxgP1kVg5XnxzwsnP9tRHEl6SVAFb+dECESccfYjrMOIt7hNFcd7TLo1QYBS0CxU9xDWL91qKS9g8SPdc7U5+P92IHeLgL687Rr/5oZhqlqI5MK1MGWwjx0MmBlrSSSdmtDB0mQR1Lb8gv1OeKvI4ZRrSfoeiyFYCesXfXWw3h3tSil81dufTjRtpXEC0ZhQKVG8HShEjzW3010/2lCyCiFyX74WxEz50+Ae6lgpSaCsXRdPxHnfRdtXUe02CreT3k40UxEm1L+SGgqAv1JhJsPkVLXfvrFAqcJSX1M7SOCvc9HLCNG05m0mC4a7NOMgr6j7BGkfbi2PLeT3jJNux7TOqXtIQL3dTLi4XQnfwsPEKpr2AvcSDCaxuJ6zCREbjeS8ezWpBXabM5rXwddcZpugh63jy7lm0NZQustKBJO0xhadpLL4xmHmH2yWoEKcmJqAbLQLgXtN2Ka1O0Iknmbf0JoFWqC4h3oraBF5//YLz1Zy2tjDvsKmjKROe7g4Z/PrTtOcjJ5d85vldTOrQJtA3RmgIKghA14GDox2bTUEy7ei2KTr3MU4d7GHMsXiSjRQv5RV+2UGn6Y0SHnAAvKTDmo3FJx7VKjAaN5NQKmeDdLorQ7+RtFflxFnFOHl39DPwicdbI85cr4BFpg7WVsC71IGQRtoMQKVRzkhCaK1hFgH6Wig1nNV7Aagx6LXFZX70mA8+Zn8oEcbiFfakpqkT1NMcsiBcdSX+7up+h7vJpDCpLOY2QXUSxNXPghQpMwmwal5IuusI4AE6hTlt6DuN6jVnRxvmWc1758f0ZcLR2QarPU1vpEiMwD64qHvScHe5Zpa05Kbnm956wsR29EHz/uqQuk04nW1ZZjWtN3z++pSbzQTfi2VjMulYzCqs9rx3cUx7WWCPavoqIZ83aO25t1yzazOuvLhHhK3ENE8PKqpdyj/4lx+T4s8GoQqlDt8birs3vCjnlF1KnnRUOsG9LAgzh06lyAiAnXT0JuCWAbzoNP7Z+ZtjcWqWLfN5xd2H51RdStVZemdoW0s6a9itcimSksC6TDC5Y7fLcbVBbS36uMEcNvjbDNVobB2NIFwg1Pvm3deXr83lKw7S/6P/6D/iL/2lv0RZlvzqX/2r+aEf+qH/2c//xb/4F/l9v+/38eDBA6y1aK357/67/45v//Zv/3k/f3V1xfd+7/fy+3//7/8Ff/P7vu/7+HN/7s/9K38ejHBwNw+EU9zPAslaxoDStRUXi8UjT32oRweMrlDcfCuYSiLru0JetEEJiPHRgm94oQ8e48NLvZ9IuFBSSqfaNGL1t/wS0jkevLuB8g4cfl7cSII0nLBN4PhnQ+T3hhEkDB3T/LIX8We0UXS5HkE0qGj/Fr4sAVS2M0TO+ZBaFoGX0rgEJi8jIH/FJ35IarW1xw9d8gjabeno5gLEdbdPYewLeTCMoUGJikmPOnaK2TuNxN8bfM+zlWL+xNMsNbNHPeWZpLhB7EQm8dyN2wKDVeBAVxkCecThQ0CRrQKmcrEAGX7P003NfluD8I6rO0LNsZUUFMorslWPT3XshEK6lanJsN1DQTS4/OjO0yxs7KyGSImIfuytXEM+inaDUfjY2TKN2PaF2J2dPpeCQzmke1478WyfW2wpSDGkwkUf6Be6F/tHoYYE8muhbfnBsrKHYGUb86Grv+pBRSeV2PV16d5bfbCU1NHNZuicJ2WguNprBso7JhZwMfU0UlBsHZh/EPn5U3FAGuhPfaQ6mTixmD4X0ahPomd8F7C1H0OVXCK6EdMEmgMjoVs5o3vScP51nPQoBzoEAYA68ofVl4NwiN3wGOA1OAcNxai48MT7S+3pLHurT/mMqffPAt3Jfg+TleE6D3a4t2JHc2u5nkxoLwtezOXCDk6up7ToWO0KQlD0jVyri4OSzaYQRw8TOFdLdOJ4NGk5nW2ZJi0T2/HRowveXN7QxxvNKs+2T7ncTblezXCNEfC3tSR3Koq8ZX0tQEUnjt0uE7AUABUw2rN8uMLowPX5nMmypsg6qiah6wxZ1mOsp9mmqF5hDhvcdYaaOsmXiL7rEAdbIaaiFj0Uss/LeUVue6ou4enlgYzxa6GKdIuedNIKJ5yATgK76wmf7e/gOo0yAddp5osKa+SkJtpzfjVnsxVKjEejYwdWJwJw+9rS15F37hTqOkU3ChBAqpyinzvMcUOa9pJA6qPz1NZgrw0+C/RnYn6fTVu63QSzNrjDgG6Ej24aNQrJk5WcS1OrkT9u2xjIZSQlVJlAmPXotZXi4aCVIujWoneafuqlQK8M5rjBXadoBa6PNocm4Jc95iaRd0i0obWl2NkGa/BJoL/MsVspGHSn8GeNdOhrg7pM0A8r/DolvzBjkdvc7Uff97CzhE5T3N/S90aoWSrgdwlBB9xNKqLjZUvVWXbNgr5MCE5xcyP2n1WdYK10iwkKlXqOjrdM0paTvMSj2PYpT1dLyirF95p/96OfZ9enpNqx7nIWScM33X9G4y3/zy9+A9msYTmpWFc5N9WE48UON4tTo4XGaE/TWy53cs0nSc/htOLpVjr5zmnyScvRWUnvRJjcbDOKacvxbMedYsttm3NnumHV5pzdPWdznLGuc26rpdguBvC9xqSONO1RKmCNJxQtzquRknN7MWO1OUC3cq34iUPZfXIviAvcbFYxzxuskqnAmimhtqiil9App/D94OKjxlDGr60lNuu+4qv5qpFI/lctv2iQ/p/8J//Jzwt4X11+/Md/nE996lMA/Ik/8Sf4Pb/n9/DBBx/w5/7cn+N3/a7fxQ/90A+hhtns/2T5i3/xL/JP/sk/4Qd/8Ad54403+Ef/6B/xh/7QH+LevXt853d+55d9dr1e81t/62/lG77hG/ie7/meX3B7/tSf+lP80T/6R7/sew8fPqR5p6ItIHSadN7ibjPS24RksxfFzZ45dB9IEsWdHxegl63BzQLZtWH7RkC3isV7KlrxCRCaXIhn+ABWJKM32r1V+4tw8JA2PjpM9DE6XcHmDcXyS37sqruUsRDopq8AhEwAYxKFnfVJDLKYRgGQJXqSMxYAfa6wlcflmt1dRXE5OHYIYDA9I096EDH6VDr+KKgPFZOLQGgCdidg0PRC3QhabA1dodGtFAlBC7VmsF/0iSIk4uYy8NyTbaQSDB1wGKkH0vkOI61G9AB6tCAcAPcQb6/8HuR5qzBhT0kaKC/i8LIHYt3MxAJK1qm8UCe0gxCTSHUbWLzXivuIVTCG9sjDUndhpL90s30xIudPAL0IUfXoIe6tGguuoAVoXnyz5t6PuRHcKy/bb2sB/0HLCz0YsVQ0TaAP4sYjfG9wmdgxynWlRtDnYiGDEq9uvMfWinYuHe52ppgoaJcJuzNDtvFsHyRSROyGZM+9eFoxUDMk+MfbV2geCbhEj+BdtBDyG5MLR7M0NEsBzek2SAf9JozHzdRQH+q9psPtJ0SDYxJqnwYq4Uz7wsdWe9GoTJdi9zbs3SsGmhZe1mkHLUB8RAWj2N3TMal1oK1EXnDcT+WGIiWMHvMSKiX6jnYpP5aupSgZuPqDwHagXXUzFXUSYZxGqGXH6XLL0+tcuniTnsVhyTedPad1ltYbJrZl3eZcVeKEUdoMr6UA0Km4ZDinefTyCN+b8b5SxmMzx/FiR9kmHE93dN7w2ukNH7x/SnbQcHTvFqUCzx4foZxicrbjIyeXvHt5wjRrSa04xtzuCozxbDYi2KwuJ1SZl85Cp+im0olPip5OScdZL8XVpNdC+xB7UgXWS3qk9bjrTDrItaaaJNyupgQPH3ntnPcuj9HzwMFULCS3VUaS97Tr6LmdO9ptSnBKusdOs76dkOQ982lN5/VIgfG9EQpOLxOF0BrphCeRHhDTg33q8dNYXBmNnwjS6TcprhMnGD3pBTA3QlnxacBcJTKVubXoXtEve2zR4xoRo7os0mGUWG76NJBsZJLqTfydiUNNe2jFqUUfNfg08tlXCcpKyFOXe6GxAOlRjdaB9F5HdTEhTHqUEYoLleHgo9dcP12OhaE5t2O+gk/BboVL6SYeJo7pvKHSAX2TY2uob1Ps1lDf79CVIbnVYrtpxP879GI1Wj+ZYe5UQiuKKaNq2N8kwE3KapNIYZHIe9VeJGxnKeq44UN3L7gqp+TLDc5rXlwtKdOUlzcL+kY0GUrBvZNbEu34x4/eEt2BUxzOS2ZZg1aeqW15eHzDrs04LXb0zjDPas63M5SCrkkx2rMrM1xj0daR5j1NlVBXKR9/6xnvvjgVdx4F5UZsIdOiIyk6ym3GPG/YxgJh02Z8aH7Np5++TttaXGNGu0x9m0BIcLmnaQvCcTPyxVUXJ1IKPvKxp1zsZqTGjYFPbW/ZNSlqGthuc1yr2WwKVtczqIzQWloFM4fbxM6alukGgK7ULxUXwl/Wyy+ak355ecnl5eX/7GfefPNN8jz/V/78yZMnPHz4kB/90R/l3/63/+1/5e+rqmK5XPL3/t7f47f+1t86/vnv/b2/lydPnvD3//7fH/9ss9nwG3/jb2QymfBDP/RDP+/6fqFl4KR/9I//5+g8Hzmr7TsVx4dbLi6W6BvhOAqPXJHewuKRJEjWh5p0t4+U391TtAtIN5Bf7S0OdRu75ZFD3L3iET0AJVtF67bInzWR5zoAc+mq7rvKEk8uYAmG7quIQm0MLxq+GyKvNd3su9Py91DeEdHhEM6T7OTGFZ/mCJz7gKmF2rHnrhu66Bv9aqrkAGybZdy2IMXE0OVVXuwWm4WmnQuotHWI3GM9AinheIe9C8YrncxhfbdvG+aPxce+z/f+56NV5GAzEUF4VwjwgYHTPtA3BOyabqA17G0kZRpA5DaHseurY8ATHnyq0b10iVUv29DNLc1COsEj/zsCzGEZQm6C2vvID1zpMXUTxqnKMC2xO8f6jZTi2lEdG7YPoTiHxaOeZN2jI8e7OUojF3v/26YR+8wBVGYrcehJNrFbWGiSjUOFwPXHc/Ekv4gF0W1Hu7CUZ+aVqPu4L0O3eLAojcd5vA4j9z5bCb8+u+0p7yQj7adZChVK91CdKNJVpKxEelAa3VWENhTGwrTPY1cxdvUH/r2tpEgo7whFzbSDziFOjaKl5jAVGcKIXp12DetQXj432G6OdqIDqFf7onc4vz4RsXKyE9/8gSo0FAjjuhNFN5EJhMsiTz0eR90xuhuZFi4/qXCF0Mz8oSQKftPDZ/igOMpKfuzxm7he3BtM6ljOK77p5DnrLuen3n9AcGoMlMnTnsNCgnbKLqXqEhZ5TWE7nq8XqOjAEm8HqjoVS8Ne4zcJ0zs7duscek0IiN3ipGGzi3aEsyHMTW7BbpeQLRqsEevFpk4w1tO3hiTraTcZKpEiQq0TwqIXHrhCRG42jL7gIRGqA9G55MGHLnjy5Bgq4ZGHxJPOW7oqwWQ9rkxIZsJhDyCFSm9Q2lPkMpHYbTN8Z1CD60kj9oZEfjmt8M/xCOgtoiBzErnEMVF1cbal7YVGM9BT+sbgN6mEOaXSMccr7E7ua/egFieZAOHRZKSI2O1eh9Mf9ehpJwULoHbS0ZYJnnTV1VKOuW9EdNhvE1SrIoVIQF52f4cxnqpMUQp8r8gmHXnWcftoKfezU7EIDphK47IgHPNSirqQRsqkU0zubkkTR6Kd2IDuUuwQMa8C/dwTUo8yQXQJxgvVI/fQKbGqTDwkAVpNyB26MpgqZh6kUmyoXo30qeLhhg8dXeNRaAKrNucwq0iN4/H6gMQ4XlwvOF7uOCxKUu1IjeMwLXlaLtEErPZ84+IZW5fxk9cPyEzPbVVwcS7TJps6juYlrZMkWGM8WgVS4/BBUXeWppMwrHadYSYdR4sd2zrDGo/zihAtKcs2oW4SsrTnk3ee0TrLuzcnrFcFad7TNhZjPcbIhCCxjqpOUTpwPN8RgmLXpOLff52jKy0UpIljeSL2kT6oaP2oobRCa+k1wWkR1kbth641PvfondwrPvOSaLtpefxHvrY46X/sD38v3/KNX3lO+qNnP8bHP2n//4+TfnJywsnJyb/RyoZ64FV++KtL13V0XYfWX86TMsbg/V6FvF6v+Y2/8TeSZRk/+IM/+IsC6K8uEi8uL8X6zGM/KNi8W2DmAVd4sgtDc+roJwpb6khVEbBQHYt3c1IGDr4gYTkXnwo0h4rZ4yiW6xjDfQaKSYh0CJcrVCkiUuUFrEDscA9Whzd+DFsZSl4B21Af7YH6AL6HhEwV9sASonAzHYCNWBimq8DmDSXi1kgTMHWgjYBZRcDczc3YxVY+gsbouz5QUr5MgBnEt3xyEegKob0M/tjNQmg3+26sJEt2M7F1HACxtwr1ilXiSP8JAjxtRRRoynbJ+Qmv+E7vwSHIedAuxBGufMYbNQLNfvxvte/ihz1otqXDZWILWJ4YigjQXKJwmYn0mhBpNZ7iSjrrEoCzpwfpDnQnwHd3144dZRG4wu5Mka2iVZ8XD3Pl95SXy0+mHHyhR3eB2RPP7Knwy7uJRreGbmHHfbZ1oJoMXXj2lCG1F0x2mR6pR7b0BKtwRnPwbosrNN1UU51o2nmKt4r8Slxw+hi2M3D5R3DLHsS2cykUZ09dFABDP7G0CzO6xYjzjIDg+gjsTu4LIIpCg1CGQogOOiKIlTTYoZANlHcU02dCAyMIsJ0929PIgpaXujcDBU2NYs2BnjLQ24brWA0uRMi1NxTSIQLzgV8+FCnyQaKfv+w/gIuAX0ch9lCMKQ/FtYhjdcfogBOiYFkKPBX59gE/dajEc3yyIbc9qyZnmdX84y+8zXxRMZl3nF8vmM9qjPJ8/vaUXSMd7XTacTaXIJnGWTZNTmp7ctthtOf59VJA+DolOy0JXtFWCWysAKRc7P3I/ei9HAIcnG3YrAsWhzVlLQDdRapJaA0q9aSzlrZM6KJAEEUMspGgmnTe0DWW0BpJjYygDGT/SaJqeNajdpagA8ev33J9NaNsRTiqly1p3tP3muPFjheXxxycrlnrgiTpJckydssBQpuwc1q6uTaCmIXD94r8oBabvFYClvrE4LcJdmNweRjdVk7O1tyuJ5A7XKupYihMf5ODDqiiJ3jpJoepgFXvpCPdRuvQ4BXHix3Pnx5i7te0Mf3RFeBmDtVqVNHj1+nYVc3u7/jE3Rd84fqY2xcLssOaSd7StJaq1yLWzXs8Fpf18vyYdnStZb7csihqXlwsySYdd5drdm2KOWzxl2Kg4HNJWPV5bGbsjHDoa0NyIxO6kAT8Ty7ZLAJu6tGtwgyC2MJLWmql0Svhxus2pT3rUPOeBw+uANjUGWWV0V3lJGsNGykK7FbRnHrhsjuFOm5I8556LcfmS1fH1GWKjtSlx50mWzYcTCvq3pJlHbe7gm2dUu3kvKeTjrsHokP72PKcdV/w+c0p86ThIKvITc/ZdMumy1imNVoF/sW/fJPJnS0+GA6nJZs6o0h6TmdbHl8dkmcdx6/tmKUNLzdzmjqhMx6tAweziofzW969OeHsYMOziwMebw94Y3ZDkXTkxz23u0KKw1jImtwRguLe0Ypdm/L8xaH41zslgFsF/EEn1KVCJjfOK7GxdAo7bZkclszzhnWVU1YpzltM3nNwVkpQUp3STSyhsjLlyHu6eo+rvr58bS5fMU76pz/9aT796U/z7d/+7RweHvKlL32JP/tn/yxvv/32l3XRP/axj/F93/d9/Lbf9ttYLBb8ul/36/gTf+JPUBQFb7zxBv/wH/5D/tpf+2v81//1fw1IB/03/IbfQFmW/PW//tdZr9ejEPT09BRjzM+7PT/fMnkJ3T15YU4fSzx3+x1r3jq85d1Hd2kCTJ4a6pNAP5FQnW4aUxi1jMZ95I/aOnD2acX2NcXqow7dK84+rWK3fS8kG7isA82hPtTjCBzkt7pCSTrjZRABZ+wqDiAi3Xh2d0x0TpHfT8rYvfKRQpHsKSKSpBg78/Fz2sH0SeRVK0Uz10wrN3am01IA2bB0kxjk9ErQywBqVZCOfT+R4iS/2VvRJaUfCxUVIL911AdmpAyMCZWKL+PHDy4X6WYvpDVtIN14Gf+mIrocgH0wwMgTF7A32N8pHx1r9L47OiRIDl7nAw99VKbFcwHQTU10dtk7+Yj9YBRNmrg+o/auNyea4tJ/mah39ZahXUYP+BaW70frwU62a/mBrE863D2Xn8yxpdBCXn7KULyUfRmSOEWwqkk3gfLMSqEVhbO6kwlKXwyJmoEh/GmY9HhpqqA7cdcZPNyztcfUnnZuxPEkcsshfjeJRWEYOtkhFk9SKKVbPzrpjMmxiSK76emLSMVJ9sVLfQTZTfRMj1OZMAguG4+tJIlWRNBCoQp2f21OzqFZGghhDKWS6y8e2xDAAZl0uV0K2qlo8+hHWhIhxLAnmYARArdvWXH76BkLt0Ev8qpTzEDFQe8748Of7Z8BgaCUFIpa3KTSjVAK0NAn+ymLFPlyrbmTjrOzFds6o+uF0hGC4hlL/Crl6O4Vi7Th+YsDbq9m2Lzj4/decnErvslNm/H++V25Y3tFmDmSWcukaKjqlL41aBM4enjLtspAQfIko1uIkxWJx0+IVn0JplK0JxKh/s6Dl1RdwtlyQ9tbiqTFBc3z6yVdbelqi068WB9G+82+TKAxHL9+w3pbCD3FvdKxdoqQiNdzaLUI6DIHJnB8d41SgdOTNatdAb3G14a6M8KTb1KY9tyuJ9JRPggUs4Zqm6FNwFiH6w0mcbRtFJCmnsmkwXlF21r61mLTnq6x0SJSiRNH4cUFRgWqJsGtU+lMJoGQOR6e3LCZZzgv/u/r66kUHJ2S425ENCrUKumqP39yiErEuQQbsGsNXqEasbL1a6F/6EbhZoGzpfjad73B7AxtX9A3U+lKAyGTAmh6sqNc54ROS9Kkl66s95rQGhbHGx5fHkJQuMZAKl1WVRncWcvwQlIr4fzrTtEfOBGyOoX/phJ3KQDRJwHSgJp3hJi4HdKAju443gbM2uLmPc8uDigmLV1vsNbRTXpaK9wzvTPU9z261BivUb3C9RluU5B6KIPCTLp4DVk5TnEqc9XN5NHtFMFr2p1BzTtM4jHaU3eyXV/cHHO5m45pvDZ1Eiy1SwkeVCIFldlpynUhNo5lwbfd/wAXFO+uTvm2hx8wT2q+uDlh22YoFZjN6lHnkCcd796cjKJrbQOPnh7zJDmUY6rDqKUg68kXDQGorgsevYipvQqC8eTTFms8u63QuKZnLVWTYHQgzVruPNigVeCmmnB7O2G7yfGrFF1rOO5IEjc+L/rWkBQ9+bKirFL66xxVfY0SXn6J8MW/GstXDKQXRcHf/bt/l+/5nu9ht9tx7949ftNv+k38zb/5N8mybPzc5z73OVar1fj/f/Nv/k3+1J/6U/yO3/E7uL6+5o033uA/+8/+M/7AH/gDAPzET/wE//Sf/lMAPvzhD3/ZOt977z3efPPN/8Xb2BXCGe2LyCnNIfnHC94/W2AjuHOZCETtVgBKeUdR3YHp02jRpqA6lQRMlyoWjwLd3NDPB47Gq+sTOsBgReiju4TwviOgNrFrFwUdppHfcakE0AgQCqw+GkhXwkvOrmU/Bku/AfjBniqTlGGk1rhUutl548aY8swJCC0uJaGxm2mSyP82SBcdpaJATr4zRKwL91sANQzdbPaUnASCEgBbngpAH7rM9YGmm0G43nf/B6s80+1/a6D+KB/AanZ39XgM03XYUy4KNW6XQsDpEHozUA1GP24YhapD8M7AYd8LccPIeR+6pCamnw6iRxGsKnwG64cahWbxvnDB+0LHYxRYvufGEKiBeiEHLERqy76L3M0txz/T8OLbMrqZIbsWMCe8aykEghLNwvXHU6Yv/GiVmG493URLemu3PycSnKWpDxXTc0cwZl8MbT1dIetvFhrdibhZnEgiH38A47VoFXQvlpF9MvDdFabzYze9L/RIg5HwHis6h0iBAmhnMHu6d03R0R3FxKmTrFNHDi0o5zF1oJ/si3E3MaMDj3ZSMAat9qA93ofeCC1JqGVS7I40stjxHmwvu6nG1F4EsUUMF0r2BZVMnvb398CNH3joBNB+P41RPk5e8lc0Achvg/DjbQw1GrfXynVrMkeW9Fy8f0SZRcHjrKXIO5L7W+o+4cnVISiYLiqaxvKZp/eYzyt80eK8puuE7300K/FB0TrDrsw4WW55/oUTXFBcX6fYXQSJw8Gd9uNovfzCElMquqVUKloHPvOF19Cpw2YuelgrVqVw0820JYCA3caI64Ub1LBw+fSA6cmOvh/8Yw0mjvR1afCFR1fSjT47XfPy2QGrTSFhSCrQlon4lkcHlBAU200+nhRlA+0mpfEKG3njzmkmk0aOwbCPJtDEdM+2tRjraHYpadFxdnrLs/OD0c4vSXp6Z2jqlOKkpDRifTmb1qybnNWmwPearOgihQRC7gkp6MyRFj1F1pIahwt6TIfNbc9VOqXvCqEaRmBv270Y3s3g8WfujjxlIrfY2wCFx0zEB7/IZc+KeSMc6Ghv2DQJvtNMDktePj0Q8Wgl58NU4v8eFJjLVDrk8xaOHb5MCAdirai8Il02oMAe1cymjdAxWks4z0SMKEY2BBs4+vglFy+X6LVlcbrjZLaldRYfFFoFbnVgezmR/Zg6dOrIzgSYbp7OUYuONrNSGFuPv8gJqSc9bOjKBFt09I1MPZK85/7Zis6bMaTrxXpBVSesQs40bym7lKZNKGYN86IZE3tV6jDW8+bZFRPbUb9muT9Zk+mef/jobf6Hz3yMX//xz/FrTt/j05dv8N774mJE7nnztQs6bzibbGmd4bYpqJtEqFOdxhxXfMNrz9l2KYu0YZY03DYFT9ZLyiojAH1rOXvtBhe0eMc3Fu801SaTlF0VsNMWq6Vbf305J/SKi0gFyhYNJvFSeKdSiM4nDU1rsdbRO4NvDD2w3qZC2dKB7O6Or8nlq4HRf4nUAV8xkP5N3/RN/MiP/Mi/9nP/U0r83bt3+St/5a/8gp//ju/4jn/lO/+my/yJw6Z+tA4cvMuLSzW+yNu5orwfaI6FKuITyC/EvjG/FqHX/JGjPtSjK8fJTwtg9wOOiC9voihwoK9cfVKCK0ImYFjXWqKlG03xItJUci0hQlEIqZwAXbtTtIvA9Kli+4anfADLz+kxGCXZCsi1lXiudxPh9Zo2UJz3bB4mpNvBpUP+bv64Iz8v2bw1j91p6YL2+T41cegMD9/Jbv3ISXcDt34iD+qh22qaCJqDAN0hZVUFyDZeQFik/RDGd3j0DRbhaTdRBKXHLmZ+JUmqwUBzsOfEu1QcYEwTaBdqDOOxFVy8HTj9yBU3mwnFj03Fys0LzQIiHzyCMJDjN4ggB35+d8eS3XT0UzM6hAxFUX4rnP3Fo57Bu34Ir9qdGOnQ7iQ1NWg12iVKi1v2VUdx6th9jfxkNBx/puX8m1N8CkefFV76wZcajn6u4+KTiWgmzB7oD0E7QUmX+uJXGEwDpz/ZibvQTq7RoVAbu/5G0cdzaVuPcYF047Bb6WIFqwhG0y4t3pg46RiOvxr/kR/bW1/aWq5Db8H24s+ebsRuUTvGZFEbQ7SmT7sR8Hur42TH0GdSgBBkwuNymJwLpzhajdBnoIKIuQdBdNASIDZcK9WpkcJ8t58UDJoGl8m1003l2p+eO9avS6LscIz7VCYi/WQPugOM97049YhOYyhKBoCuIs6qT2H+wb7AGGlxsXvvLdjPFzy5SWHWo1UgrBO6kOJaw2TesCpz3jy9ItWOdy9OxT+8U5RWQmNcq2mrhHTS8fLdEwEXZzXFpOVyNSO7W9JsM8x5svfxzgN2q2GXstIzDo63TD9yS1mlhJ3QL26fLCGmWWrjWV9M2SSBpOio6wRtPL7fc7R9r8Fp6VgGUKmnXBdo6zCpY3pQsiszDAhtplcilNRwfr7A5D2usfSdwk7FG9p7hUmFKqBt7NgjvKR01tLcZujMYayELA0OIUYJV3qkNGlx9ynyjq43ZNMWoz3nt3OKqXR+uzKhUxLikBTCA7fTDldZtrucfpcwOaxYHtRUnaVuIgc7IJz6VpMvK4qkp2wTqjqlXafo0nC77GCTiJtLFnAzH4FpgBhypExANUJBkodXBOg6YK4tYW3pCoeba2azmjSRaUfXyUPAd1q6zK0lO2iY5C23T5bohjFpVE4UqDbSg4JC1xq9znC5J+ReiqPGoIoel2uaKmGxLGmzjr43dLUVq8TEcXk9R22s6G+8EpCpOnZtxsvbGd06w2wM/qQldBqdeN48vub9qyO5Fi8z1MRhFlJ4fOyTz8htz2de3uHk3pZtnZHOK6FydIZnt0vaq5wn9pj8oKbZZoCkGjebjMXRjrvLNcus5ijb8S/8a/R5S90mGO15sV7gnOZgWvFjV0d0lQRIZbOWTz97g6ax0oE2AXLPdFnReUPVJXzu4hRrPFWdoo3n/oNrFllN6wyfOz+Te3e5RqvArkvHawodoLR0cyPcdytBXrsy4+17F6zqghDA6MA0lbAle+RY304IpWV6VNL3hsN5SdMb8qwjn1Wsy5wkcRxORYOySgrSpGdT5nTWE1rDncWGL/xCAOnry9fE8lXzSf9aXHyiooVcpDsM3dpBtNWIbd3mrYA6rmnf9HinmSwqdrcT1j5n+UVPu4igoRZOerqOKY3tnhIgXuoCLAew7ApR4CsPJAGf9piiJ/3ZCbPnYc/ljULNdOVisE2gn4tyPtnC8vOa1Uel2LClgLrqTB68B+9CeSbivNWHozVipeNIXmN3UcG/g/S2JSRmtOKDCE5bNcajg3T3gzbYMobflNIJTTee+sAIBUQjY314pdsu3fXBqWaw/bL1Xow4WijGzwc9eJGr0cYPBNB0UxHr1ocCtAYrwG4i/+9S+XefQTeDo5/R7J6cYgoBS/kNtHNGL/XyaBBjSTF2/Bnxz+8L0DcKPzNMX/ajDaGIGdVYYFRHQl2qD82XCUXTbWD+tMclUugNtoa629stBiPA1mzF4Qdk3+/8RD0CY1P2zJ4nrN8UULt41AnfuvWc/VTL5kFCceVo55qbdzTJRoq12fM+ctKhOgs8/j/1HP/3+egUZBrZji52vl9N+ZRrQVGnCr2wo4uOj0B16Pwqj3RmVn70jq+PrHTFI71mAOgDoB3E1kkl10FQ0EZA61OoD1OSkrGrnq7DaH+ovPDoTaNolqJ1GETZo67BiwvSvlseIHL8m0MVi85heiKFVjuLtK6oMbClOLWs3jSjsHkA2slunzQr4UYC2AdKjAD9WGx6+R3TDhSceC/0MkVDC+gfnYq0NAh8AnzjBlUlhF6zON4RlorNupBucmslYr1LebKdCIDSAT3vUTpwfTWDmxQFdLcJyUrTv13hO0PTWHT0rzaVlowAItUsCYSZk2LvJqH64EiK3VYs1NtFwM0lfOjO6Zp1lXHvwQ11bzksSl6u59RVCl5FD2mPSR19Hbk+HrSVwCC/TSD1dKlEwwenoBG6g24jrztTuJiqqrQ4eDx5egyNwStxsEnTPnLJEQpDmZEuWuGWdybaRSp8UBgtHu6DlWVbJvStJYkWinnW0TvNO3fO+cLlCbOioU9FbLp+tqDX0rVUCtrYvXZ5h1aBdZWNXGHV7kXxmEBZpczzZgyGUnH9OE3IvCR9bix2JQJWN/Eka00/CXCnxh950qLDOU2/SaNFkTCFVCeAmjpjcym0pTCTd4qrLCpxUlzE1FmtgmgQggT1+GjhOVBz1Mt8DGBTDtJbcb/yqUctO8ImYd0YJkcVXS/f7SpRvIadpbPCuSaR67z+YMGXmoTXT69RKpBlPcmxQ50Eus7SK7Fm3LQZ1fMp2sdjk3lcmWCKnserAyZpR9skPH82g3kvQuJI9zFFz+tvn1O1CUeTEo7hxWbOh4+uSHVP7RJy0/Gz5/fYziVdd7ObyfOoj+Lc2AnKklgUA2+dXPHaZEXlEj47u8PNlw4JAXa+YLfKuXtnxdtnV1zWE551lrZMaAvDdTlhljX0rcGmjvfeu8P7qaeY1xIgtqhJrEMdBtbrQq7RdSLC5E7zbiU0tWJeU5cy3dEq4Lzmzuka5xUuaEovlpHWKLZVxvpmAjvZn11RoKzn9GTDMq/YVhLUpIuep5eHv0jU9FVYQnxWf4WXXyreNr+sQbppAzb4sYOu3J4fLRZ3YjmYrBX2RUFzFLBv7vBevF9NFcVzAeZPetqZRl3FsflawHuzlAj2PlN0cxFsDo4vRz8jnN/B1lD5QLNIBRxUUjgEGxMgJxqXmrG7PP+CoZsLGE9XcPgZefFdf6oneyHVv08F/A7Wht1cuo39oZeXYqtJzy3dmzVhm7D+cIGpFbZUdIsQEXYcHTuNqWRfp88019/oJe0vWmhllxqf7EH//BF0Q0GRy0h6SL30SbSDNBLMNFpwASj57ACshL4iwEo832MnNASmz2H7QMDnIMgdgFcXky77IlJ/agGFwUS+sIHy7p5TLNMUSKTpQHEh/Pz8RhxphLYy0H4ivdaI3WOIXtv5jR9pFyoID942YfwsDNx+RXHejZQG7YF4Xr1VWBfwVovDTCK0Ezy4iWXysiPZGm4+bFg8UpjG41I5hpNLx9XHLbOngaPP+JFqUh0ZXK7IL2HyAvjpnEFQ6o1CWegm0R2o8mgHm/s2ev8L+PVGkV13JBvppnfLlHZuRjccIugcKDEuM2NxOXip21omKD6V6UdSCvDuJ9Kx9laud1MzHsP6ELLbSK9qog96KsXYcM8k0dJ0ALjPf62cg+N/oaN+RI3FxXANivg4nkcLfVD0h2rkmQ9TjOE7+XUYz7sKjMJTb9WY9uvTPe1Fda88aOLxsWUsajTQS0GQrcJoSxrU3p5UdwHdSiFqjef0zg2P3z9lV2a8cXrNvcWam2pC1SZsbif0zpCnHVUAYgT6O6cXXNUTHnMkseGFQ73W8PpyzbObJVnaU9UJ+cs4FYrb7HJItppgdCwQoTlx2OOatkowV4n4nO80fWKwRsYEL86XTBc1H7w8JniFrywqc6STjvZaOs3oIKEvGnwvrireKlRlKH0haZ6vHjcPGEgOGh4c3/Do4oh+l/Dk6TE6cSTzhuaywHWakPW4xmBSP/Lc+9agrZeI9qnQWbQKZKmkmtZNQr2N9EvVY4ynqRI2lSWddPzMZ18nPapFC7DJBcgaofpstwU2le9sVgXaiphxSPYMiQerJGyoE29v1xkuN1OaXSrP107AeTJrCe9PpJMeaSdocYRp7vTynHXSjbdzoRatGws7I4mjMeBHHzdkeUvvBPAuJzVVm9CnPc5rcQGq5LVfb7KRLkKkBM1mFXWbUGQdB3lF2aXsmpTt5USefZnn+FREs+mdHU2dUJcp+aRlkreSSNoNgR6BD73xEqs959sZk7Tj4nbGy/VcQqSi60iwAXXUoEzgaFGyrnKIfvDBBnGXycUFZ/VyznYSqUSpl2tg1qBVoMhkupFoB6mA882mIM16Hq0OeOvgGqs8d/M1+b2O2iWkU8cnjl7weHeAVaI32HYpWgVWZc5HTi+YJQ0/e36Pz35wT3jsiWP5oVsWuYi0AbZNxrs3J3S9IbWOw9OKadowsZ38npEJhEo8No8Th1I6HFVpMKXGTz32qMbe7TiYVtzuCtrGMp02pElP9WJK/yIT55s08GKT7h9IwPl7M/qDnuyg4UMPhIKTaMd1KXSiq9sZ590Ces3d+zdSTG5/UZDp68v/Bssva5DeF5oQAc5gxwcwCOxs6ekm0hmuT8Vf1JUJiXWijm6kS7p5oNGdGcNyXKJYvSWdhcl5DMppHDss3UwoJNJdFACRrSSJUSgzAkaGDmBQ0OeGdO3pC01ae0zlyNYaHV0QNm/Ezt4apl+w7D7kyJ8b3MB3jTzo9CamRB41hKts7CCaJzlu4gkHHf4g0KzlJazPanynUfGz7YlD15rbd4B5L9HZtYVWU9+VF3W3EHeGrRPgWt5VJBvpmA5hPpffHIuSToIZdKdYfFEzfdnjUkkXHXi8Q1Q60dzaNIHNa5r50yBd8CjUA8hW0vGpjxEnFw3zpzFcKhZT7UxAiMtFV6CCdNPTNWTrvRBYKBaK+uCVziqMibNoqfaDVqguRPCoo/+4FGmmlQLMdAJeQ/TJ394XZJhuPNfvWBaPJOSpWShmzx3dzKJbj+7Faz9YAS4ynRDQLFQm4VSbLsSwHM3Rz/Wcf6tFd0r26VaKJG8hiXSWgU+fbmW7mqUewavyii4VKk51HAsSFN0CgknQx1b82mMaa1LudQ5yDEycQgWylYQNDROUpBLboOpY+Nw+EbA+TFraBXSLQH4ZC5opTJ/LuQoa7Av5fn2g6D1sHoo1XH4j15fL5Lwd/qwIvIORrretoLj2tPHeGzzRTc3oNb8XmRJ9+6PANALXvcNQ7JrHImK4LkwXcwByxfxZT58pNg/NSOHR0dI0GAlbCgYmF4Hta3rPYXf7CcCQV6CconcarQKz0x3lJuNyN2VZ1KMdHEBzk9OQj1Se8uWMn3w2I7016Cz6dF8kdGvL+8+nmFqxTcU1xljAwe6eI1nL885UctzlwpPuar/KIPWSnqlgcXfDNGu5M9myrnKUCiyKmtPZll2bMk1bbqqCuk3Qs07oLusEuoCpNb0NBDTKetBgby1uIu4gw3p9GkjOKrTxvP/shLBORGjpFWFtaclg5rCTjqZKODtbsy5znNMoLSP9oMVWsm0tNhErvbYz+IGr74GgcJUlm1fsfA5BSShS6mkvCprUY4qexcmOrjfy+0q2w3nFfFkJRaHK8F7Rdjkq9bBOxK3Tg0k8SdpT71L0ZYqfyCQ1mED/ooAiCP0x2iYGG1BWnFV0q3GtRueO8mLK4Gmue0XIBNCaw4Yk7SnXufCYc0dl5bl8PN/x5NkRJnMcHO/Io7vPdTlhXYl/u2sNqyvpKudpNwpLl4uSMnNS6DnD1QfSfS0T6W4Hp3Bes6sy8lgI+VTDzvLe4zOIIDR89JblvOJsuuWRAmscZZUxKRq2uxzfafG63+ZjkR6me2sz32nMtBO3m1nH62+d8+J2waxo+NjROT/98j4fPbng/dWhUDpqS5JJEfXRowsAPjI95+8//QaqztJ2Vt7lQc4hQNdZ0rTnoycXvPPGu1zUc754e0JiHcVMwPInT8Xe1GrPxLR8+unrPDi85azY8mhzyNVmyovbJcTJRHLQkGU9949XrGu5qW5ezL+sIHVTj5p3dJuU7KTkejPBGM98XnEy3XGxnYkd5qFc0/msEWvRALOoQZg8bDnMK27qAhc0vTM8eX4kFqUKzLzDpI58UeODnLNX08+/ppavhxmNyy9rkG5qEWEM4+XB+k5SN4VvVx+Kf7q/TaFwLA5Ktpscs7WjULK4FKeQbqajcCxgaun4uVS4tt1URxGigARJcQxcfyNMnyj0wDv0jPHnQwdQRJGKbOWojwws9WjdFxQcflYoJKu3Y8dyIyPW/KUI+fpMAOrivcD1J0A9z/G5bHt/4EZlvW8MybLBHQT8KhUFugJOGrQRj9lunZFcWbwK+HWKLrW8bDyYUtMfOJSH+U8aORYxeKcvpEOe3wSmTzS7h4F+4QTsbjXX3+K5LaVLFY4agtcs/1lKceXFEcVL8QKBxWMPIVBcenRnuH1HfN0HkGZ3sXnpoDxTI92gXUqHM12DvpFrwEfA1E8YOfo2OtIMtAqfKNpZ7OArFUOF4pRi57n+BkMSQf7QbXW5IrSMQs1s5Ukqjz3vsKWMjdu5Jt3C7q4AtfmTPopboyOP2U8Nhoh676WIWb4nnJGgY0Gj9+mxpz/pePmrIuUmdv67WbStTAUc+kSxvS90rnYWQUQLyU6PHXZbCnBMNwH9wT6tUxCCcN5v3xa3mm4RqSEZmCZeh9WeRhIMtHMJLuqnMu0AxlG6HlyC8sD8sYRldXO5f9qF/M76dYNtGPcnu4XmQFJ5B+eQgfKSrfgyN57yVI9AfKDc+DSuU0PI5HeHVNHhnxGkR3rS0K0HcFH4rVycSMRnfnkitqW2inStVoqWbir/nexk0tPOIkBnP2ESYeqeK+UK8F4sJMttJoEvTrOql6ACpw9v6PKW1e1EurytFsvETNIL3XHAtVLMPPiGS9aNgITbzx1JkVGasRk3eWrEaSbIegetQXOvozismRbN6FzSdJa6TWg6S2476jZB6cDzlweEmO55lTruHK/pekPTGNJ5C0VHu8kIjRYQC9HP2eFSL9tvA+lpRfd8ItvwdEKXBI4+dMPsXsO6ziUV0msBO5XG1Rn6oOV2W+CcFscSp8FI57NvDcogNA/jscaxKy153rFrjQQYKWg6i816+lKEf+m8pasNOnM8uHPDus4pywy3StGLFm08wUtAEk6K99CLGDS0GhW58wA27UmsIz0o2agAu4RgvSRHThz2xuKzQLKSialPoDvqpWO8MoRjh0kcfZ9gjhr8hZxLpQATeOfBSzZtxp27W/75ew8JvWZzOwEPmydzKDyu1Nw2lqOTjWyT8diiw7WGEJ1sTNFTVhnGeNpdyvXljNBr1MTBzpCeVXiv6Bsr/u064DpDF99tOvHiKrOQm8c1GrdwrF7O0XnPalPQbVKUU6THNZO0Y307QWmhfLhSmgxuEvUDifDH+k1KMIH0uKLdZDx6fAKN4SrN+P9cLCDATzf3OTvY8PrdF6zbjHeW56y6gsJ0VC7hqpUi5P5ivRev1gW/4/VP8xObN/j0szd48/Ca83LGv3xxV7zue0M2a1DALGu5bKZc7qZM05bH3QHeab709JRH2RE28skP797y4eUlfZAC+9luweV2hg9KtBEzOeZqlRDmPejA8qCkrFLqOsFdZSinaJxi6w/lWV54Jvc3qGmQyc7VBLyidDPIHSbveZnORx2CMR6TeNJZIw40uegsdk3K1WoqVK9qECJ8fflaXX5Zg/QhOGZI1ZQUTvHTbg4in7YFvxZbr3TasbqYCZdx3qOCHS0O022gm4Cy0SO9FQ/k6kTRFyZ6kQuWyFbywu60Yv6+PIyTMorV0gj2ABfpKqYToNikhuxWUhpdDKpJYqKi7gKHPxedTCJfu7h0Ai76/Rj+6DNw87GBnyCdWNXGZDMd6CqJcNazDnWRwd0a3xmcC+AkZnzyEtZnGgqH1wG9NfijDmotCWdB0S4Uk5deqAQZ0R1EaBXZKrD+uJNOkQI3l0Q/f9hhrhOmi5ry3SUuY/RV7yfDlEPtbTCNdHKLF9Khbhew/JJn/YbGlAKgTKRYpJvBijKO76d7YaiOgTKDzeMQkjR0Pwf3lcEPPNmF0UnGW83scWB3V7zhvVWxYzyIIR1JqcaETBITwb+PIVKyXe0C6iM7WvclldCUpHsbRsvFdOslBTWKK1Uf6SiJoZ3rkcJx+pOezWuCJr0Zum4CpAcvcNMyWmgu3/dxf+QwByvTgCFsSXjmkuw5OA1l6xATUGH6MlAfCKXG5cMkYi9+FMoTMblWwHV+I+sozzTVmXx2+TmN8jJZEEcYsWfs5sIB94lcx91c1pNdy/lol4pkG4u0Sr4/BDoNxS9BtmXg0Y/izEz45KOHeRDaU30ixcfs0Ssdl4HyEvW+Q6iRctHWMpV91C5EoCXXnDdqvGYoECtGLV37YcKkOylgxqTSKt7POnCxnbE8KOFA+FiJFlHe0aRkVRdsTODk3i2dNzT/9IigEpkGZODu9ph5x+OLI/qdJX+WwCKgKymq20NP8VLTT6RIcqctNEa8rmtN9iKBJwlX9wqyE4lNP5nveH6xJJ+0XG5nvHF8zReenkGvUZ0m+IBziknSki863tvkLCcVq13k3SaRThdATXpCacWL/azGJALO7J1q5JMn1tP1hqebAwmA0QIu8sOa+lpGhtp44Z57tReotpbWaXTW0+8SksRhtBNaQtrjvSLJe7pd7CY7jbEel3j5jQB60eJbw5PzQ3yvSYuOPvEyRcyFR886GYOAVCF2kTaTNqXv5Rx2taUNyZhw3Qah+dBpVOYJCaINqKCfIk0MJQ2UYCXIqW8s+qCVQKjcY3YGdgafez7z7msUhzU3uwlZ0ZEmPeubKcWyRr27ILs1VP/7DcZ4dnXK9S6VaUBlpcDIPMELnz9JPYmV4sZ3UQmtA+mdSgp063FtgNTha0NI4OhoS9tZykq48sGDj/73emVF52A13gQp0GIxuq2FIx0G/YJGnH3yPibBKpLcoRaxWWQcYdbSbtIYPCVtd2UCXZnwrD3gaXdEtmh4dHmE0uIElE9bFpOae7M1E9uSm45n5ZIQFJ8r7+GD5ni2493zU2neeSXbDzTnE5LjmhfXC16qOdNJw+p2SZb0fMuDJ/igeFnNuC0LAdB1xj9+8RE5bNZJoQG8dnRL3SeoqWgCNgcyBp5mLds6o92lEqAVbTmD9ePUGRPYXE3Ra8kLME4RThpOjjecTHfkpufFbs5JsWOWNGNXv20SvFOUtwVoSKctg2hKz0ePo6+t5atRO/zSaKT/8gbp3ioMr6QjhhhXP9gYuoAtFcUTQ/lGoA0KnTo++vAld4sN/+KffyO2lC5pXyjyG0d9aCKtQl7OxYWAxPKOcMe3b3nK05r5/3uCjnzxAfyJ0DGMXGZbBbHSS4VagxKQZDoJIkq2kG1kzO7SoZMoICRb+dFffBT/eMDD4c8Ftg801WvxLakjDq01WCVjuMrgj1sJlDDiUHB4smZbZlRnCXba4joDE4/PPGwN/cKhcwnx0G3Ks/9Dh75O8UW843KHPU/oZx5yj9pJQAqdpAnqm4R+2VO+uyQkgXS7707qbj/xUC5yu+PzJVjpambXsH1Ni1i0gORaaCGm9aNNYrDQWzkO3sD0hSRDrj8kHOT8Boh2kZJ8qUaAt/e8jjzlGxHrehutNZshUCkmVMagnEGEOXTm+whAh9CkyUtxaqnuSAe4m8i2dZO9D74UXpLUB1GIHMGqLeWfoajwqbiaZKtAcxCdW0pxK1IJKNR4LZggILjP92ASBrGmFFvdRKEP9UiPCiZytEMgv5Jrq52pODFSpOswevsPbiqDINXWMH8/RM99uXYPv9CzuyO86NXbCltriotAdiMd9aFw2D2Qe2jYH1sJ4F/dU/QPa4qfy8lu4vZ2jNzefcKsbMcgBpWudaS3DB3zOFnpZrIuGCmfIpweQ8JeocdEsfGrnXflGAv3we/cK3nGSHEkQWUu21/jpguwk3s/2YqmxW5h93RKPXWk85Z7RyvqLhmFjy82c3pnCEHATmId7SdKwvNC7jsVSC4t5oklmJgNZCC7kuuin8ftV5HzP0NA5EFD1+f4eUfyIqGbBsgdzTZDrSzJhxyzucTNl1XKk5sDDg93OK9IjaPpLb3T3FQTUuN47a6MrowR8EWVYouOSdEyzyXcblNn1I1UUNZ4bNqhFKw7sXR86+iKn3l0n2YnXUYVQ11UJx3swYrPN2bk6iZHNdNJw+3lTDqTZUJ+2AktYFdIZzvpqY3H9Zq2EeFpKCXwpcg7tPZk1tH0hrLKhOpihIriey2Tg0UnHuqATZx0oZsE34tYNc07AV1e0XkVvek98/s7qjqlWWVyHcaQLFcIODMbi+pl4qk6TRL32TvxDPedEmvEKLKtVD5eJ4l21G1CeV1gP1lStoYcqGuxYgQoZg0qWjVa6yhvCrT1dJ2hKUWsTGmiXaOh3VgWD9ccTCoebY8JMaAqBEXbWfJEeOG1TWivc+jVSF/StcZlnrxoUQqaxmK0FF/EdxSDBsqIpaJzoovoOyPuNJ2GA+kMZ4uGMFe4TmMzh9FyzIMHO+146+SKb1o+47Pru3zx6php1hICHGU7jtOSdzen3FQT1mXO/2v7MYqsZZJ2fOdbn+PQlrxfHUsIGiI2TrVDK49RAascmz5OpZqCNOoyQhCvfWe8pN5WFldb7pyI04tVnoezW57slkLf2iWExKPvbDibb7i/XPH45oCmTnG1TJbToqPdpejUcXiw44olWE86bZnmAu6b3pLZnovLBbezgoOpFNOJdXStODjoTITa7SYlOIVK/L4A+/ryNbv88gbpiYT4mFZenIPTy6uAMNt4iqvA4ec0toHrd1I+t3nAz6We0+gXTS0v6+1rNnqAe4rLQBJFbuk2kG7kJZxsNcoXo+f14IqCUpQnCu2EZkCIYT87L9uo5LOuEGeWyfPIRbbSMUwq2e5mofGpgKNuGu3ltmHsmHZT6d66DIonZvSCH2wiXR7wEy/dDhShV9BpzNpQ3Lnl+mbJg08953I9k3Q9T4zQVqhGEYwB67n+1WIp5qcO1WgRN0Vqkak0LoBu5KGtJo7gke5VkC6bGsSiEUwPQlOhCu2BV7NU5NeBdi5WfKaRF13aRe51J/vhbaC43GsGXAbtAezuykth+cW9T7pLBuqHHz3WjVYjmBnAarNQkZYkRYHL91Z7Ax99WAYwN1gVJmVARas9n4i15OxxDB+K3dUhlGg4BskuHgMtAUDT59Lt1Q00R6D+rRX5Dy1xCfgJYmEWhX+qiXH1230KqnZQXHmqIy0BVtswCnmHwqS48FSnGnr5bH7doaJ3eXWW7DnlnVCLsrVQOYB9lzlSldoFYu/mxblEhJSK9UOLT2D6wnP6U2FMZQ1GUVwFupmmz1Tsju/54y6Xaze/gK7OaecCuLMbKbDp9kLQwTkoREvNoUgautaDQHQoqLppFLCynwoA40QjwBhQpvxecN5NQDvh3O/uyGTOZSL+VX6YjMSpTbefcA2Tm8GLv1lqtIPyV1YSwqOkE/voc3cAJFb9sKWsMukoOkVvPdZ4jhY73nr9Mf/0Z96GwnHvV52jCbxYLagvC+E8e0X20sq9OHf0wzlTMtXqLnPSa0MwZox417Gr561hfTuhmDX0jUHrQJoIeFxdzIWwrwOh05SdWOJkJxV9a5nPK+ZFQ7VIaFor3fH3TyS+3CMFuw60sdOazRv8JqHuDD/b3RNwnHgCmlBbssOatrTQaXHuyTw6Eb9wGYBFD/RlJY4qiCd51SUSXGSko9l3RgB3r9GpE4zfKzYrCVvaBUYP8vXthGTSYa2jbRJ5llk/Wk72raFtMrnpdcCknu7RDL/sJdho2hMuM0LmuY1uPKo2BCtFJypgKg1xGtgeO3l+RCtLcR9RHByUuEXFrszodyneGZRTIkg8gkeXR2jjURpcY0inUnC4dYGa9EznIojtG4O/yehF8gFT6QDoRNx78qOSs/mGq3JK3STsdjm7Xc7B8Y7NphCqTKcpy4wuNeL73RjIHGoi6bNsDea1El9JEeacFh/wm1yCq6xcXwHpsgevcL3BO4WO3XSb9/RY2m0KlUHNOhGp6oDKew6mFS/rRFLEjee2Lvh09wYfXV7wybeeUvqUn729x2ev73JxMwcVhBYFLA7L6Fff8Q8ff5iz+YZdm7Eqcz52ds5NU2CU59ntkq6xLBYVWgXKOiWxUpSVVYqLLjchKE4Pttx7sOanH7/G5WrGy37BvZMVn3txRvCaJO85OJEwotx21H1C1SV4r/G9QmcOLjK5vgOoy4SrzqCzHps5ThdbLtYzmSTpgM4cy8MdDxYr6pgsvNtm4uzTanEbCpDcKyVkzAbovgZJ6SF8ddxd/g1X8f3f//38l//lf8nz58/5xCc+wZ//83+eX/trf+3P+9nnz5/zx/7YH+MnfuInePfdd/nu7/5u/vyf//O/qPX9sgbppgmoROznNv+XFatnCw5/ylJcxc6vUvjIVxXfdM3sWWD+RKGcYfOaYnoeuaYd5Nd+TBHtprB8z2FL6X4P6SC2Ft6ydjG5MfqAA8xe+Cjikxe6aaRDnpTynb6QDqGtGF1EXDKAdXnxizWddFNtKX/PdO8VbisRGR5+LowguM8VQyiPS6BdGOpj6CdBBKVpwN9tePr8CFX0PL88IMtb0AG7NoRKE+7W+N6Icr224wsKINiArgxqbXALB4XDZvJS1+9NMQ24IkiHfdbDtMNfZXgjo9EBIJnYpUzj9MElismldPnzLlAda7yBtIkvswjk26kIIp1Y5oKKTiROSVx7A8nWoV1MJo3WmX0m1pMqRIec+N1gVaQvRIu8sLcqDBp0G2jjxGMMuTHSxfZJTKGNyZgD8Le1FBrDCC5o+d0B3A+0CHLAQ34pzie6heYkMHmmUD+ypF0IGLe1gMfmIBZ9sbjoZmq0QNy8Du1Mk93G9biAbeK2e9FZqKBINiFSJxTlnVS0FnEqYcswimxNpIwMAVPFtWf90Iw+4vWxdOBNtBYdLD33egPZhn4iQVWm3c88B/96HYuvoSNuWtm2upf96qdSsLgikF0NIVYC3OXP4324FUqLdoxWoq8miJpa7Z1/YrPJtFLINQuZcAQlDkH5lVDciqvYJfeR7+7kupB7VGHLMGokiqtAs9zbQ/oEVNwf4bcHnEZcSp5OufvOBS/Ol5x86Jpp2vLsZon3iknRsJhV3Lx7RGdT3jq7xAfFG5Mr/tnyIf0u4dG7d+RezCK9rdGYStPPgkzBUo96U2ziCPDg7g3X2wn99RKfBNIbTdCacCUalTD1hF1CGbucdBp/qETodrxjmrV0XpNoT247Nm1G7zTbzrBeFdjU8fD4hptqglGeozdLToodzzYLUutoe0ORdmNs+/Yso+wTUu3wKHqvsdpLF7TK6Ocd/kYCWkLqUCi60ortY/QzBwmMGZJFlQoSXtRZukiR0SbgesaMMZwS/+oA7CzLhyuUgl/51mNum5zzzZzlouT6akbwitPjLTfbCfUu3T//vMLdpmgd0LcWX3jCzmLr6OVvAioV6h+3Vpo3zZ4O5JWkjUpSraGtLapThNRTGk+9yjFFTzJr6boMVWtUaXikTiDA/LDkzbee8fjmgN4ZrPHce+OKprekxnG9meBXqTQbluKakkbnm/WqoKss3TZlfTGVCWtgFLve1jPSeTuKYV1lBVRbSe3UeHxrCB7C1BEuc6avbZmkLal1XKsJTSxw+sai42RCx8j65jbDTHqStEdlkf6ROYJTEpYUFBjPwfGOppWXRDFp2a1zXJfyfJeS5D2PL47Ii5Zp1rKpMr7l/hM+tLzisp5yVmy5bQr6oJnYjkVS03nD05sDoX4Gxc88vo9NHcfzHQ8Ob3mxXrDIa95eXJLpfuS737RTjrMtlUt4US2Y2ZaJbfnUG4+4bgq0ClyWU5LE4XzA9ZqLq7lMrp6mo+i7OXHS+Lo10jwoRafhswC1JjSWDnj2eCrgXMu5++Y3n/BofcC/fO818aaP5g7JvCXLekKAk/mOy82UXksBNF7rX1/+Fy1/62/9Lf7wH/7DfP/3fz//zr/z7/Df/rf/Lb/5N/9mPvOZz/D666//K59vmobT01P+9J/+0/w3/81/82+0ThX+f5UM9EtoWa/XLJdLPvUf/KdkPsMnivP/oGI2bVjkNef/6D7L98I4jh+oCsKRjaO7CJJNO3QmxbFFOqNqBFnZyuFSHUGzWPTVB2a0x7NVGDtytvSUZ4blex2EQH1sRx61TyJYj8CtPpSXPsRRuw8jzxX2sejdTOgH3grvOV3vY9tHSoCRkJf82scAF9mXdO159usU2aWmOfGERQ+1IXtp6D9aMZ+L6u32agqbBBbiwetrg+o15LJj3/TWEz7z7C79JuXw3prtLqMvE9RGXlrEqGmzMriTLgaSwMmPJbKtcZ8Gu7+ghumDcNwHi8D6cDhXMqVQ8fwEraJXuiK/kQ53sIwJpEkZxB4wdjNt7Rmi6we6yxB4Je4e0cPeKLpCj3SPIYF28NP2Q3c2AuDhXA2TmiG0xmVqtGnsJkq68qlQXwZrSJfF3zbifd7NGK0IBwtAAZcxudJKNzhYocRk17HQnMDkeeRPx4AtlwqATW9FBB20GoOQhtTYVznmwuUW55ZhgqF7+a6pPbb0+FRSO4NRZLcOl2l2dzRHn23oZ0bsSmNHuTwTJ5r8xo+6ABMDnQbnGvEnV6M4e3I+pOUqbt/SLN8Tb/YhVXV3V48UpeG8verepJxMDsaOeiJgesg1GO7JgSomCaPhyywnh6AqV0hRAsTJVrwHGzkHcj/KMRrCnfpin4Lb52qkPg1FgxQyitVbiuphLz7Qr9itUQmgXjxcczQpaZxlW2fsthkP7tzwwQen4netQSWeybLCe+lc6tJgallnuCvjAt9YghefaVcmqE5hNwafBXQtoNEnErw2OdtxMt+xbTKuL2dMFjXLSU3ZJoSgxHu6yllMalwQdxrvNctJxdOXh6RFR2od243E1ivrSYo+AmWhnfQ74TXrxPHxBy+onWXXZrx4/1goFAGUEzG6qeWh4Aov4DaLlBqk+2wTJwE7Rv7bRlcMowM+KOo6Ee57LV1ebR1+l8h1EOl77Axq0Ylws0pQxo8pp8W0EZ/v1oxdX2UCbieWe6FXmLXFLXqZOHqYnO0oz6dQSKCSvkmF6qJFeC20OrF89bmXQnEy8KykyLV5R/Aa1+mR5qN6TbCe7KDh7sGauksIAa5XIpjUxtM3RnjomRORp1P4xmCKHt8ZikW9t2u8zaCIHQInotIQiMFUwpOWeHs3dvpt5mjXMjJUiUcnHldZTExtJSjmByVNKyDYddJVxwudNHiFTR3dTtxj3G1GMIHJcYk1nt0uw3cGnbjR516pwP2zW7QKXG2nTLOWi8u57GerhU9/WnE0L9k1KVWdSOc86ziZbcltjw+Kjy1ect3KTTu1DT9zfZ/U9OLkYjus9hymcr9pFXi0PeByO6PprPDpVcA5zWxasyuFbx68Ho/ZwItPjOMgq/Aonq0XbD93iDttMZcpPhF9iinV2FxxUy82xRNHOmvRSq7d08WW6+2Eu8s1E9tR9nIP7lqxzgThuxdpx7rOub2aonQgKXqM9pwl5/yj/+P3s1qtWCwW/3rw9BVe/upf/av8se/+v/Kpj/6ur/i6Hp3/U975lowf+IEf+F/8nW/7tm/jW77lW/jLf/kvj3/28Y9/nO/6ru/i+77v+/5nv/sd3/EdfPM3f/PXO+m/qEUJRcGlitO/V/D8t1gW92vO/nfP2P3qFPO3juP4W0DNEHAyvPBfBeRBQSgE3AwhNSJUU9jG0xm9D12JlogDkLbbQXQWEzQPDaqXF3sT7xvTSkfZtNKpLS4DzYGOjhPSzVQq0Cf7DqDLFPg9vcPURP/lwO6uwWUwey4vrPxqnxzqDVgHLtecfRqCCXSXmptv1uTPDNUbHZQWP1WszmfoyohCHdAvM7SXhwqtxsw7fvrzD2Ooh+Lm+ULS7Jwct+ygxn0wxR13+Ls99llOP3OYSnP7TiC/0Bx80UURrwAaW4tbDkSRYCpFSn4rgNPWUB3FzmohxwAl+z8cm2Qrnet0K6mfKoJ1Ihg0jUdrRQjD8Y1d31dK2sEruz7STM7deA5HcB652Krfd869ga7QY1c2xOsp3Xl2dyzdTP7f1sM5F9C+nwAI0EaBbfbUH91KF7k9gK7fc69VA8WO0VoyWUtgULJhXH+yDeTXjELLIVhqmLK0iz3He6BN2TJOM+L6QTrMJtNjMBPIerevWeFmt9AurYgqvVA6xCFHtnd3RwB4frufOPQ+kN04QqJoF9Jht12gWUqhC9Acg/05HwG3iiJM6XIX51IIDF3yvohe+FbRmEHHsS9EhonXoH3QfqDEhFGnYpoQNQeweVMKoOH7ugvklRwXufeF3z8+J2JBAMRu/F6Q7C0EL9dsc6DGQC5daUIj13uwQXy6oxvU+mbKJO1YlTn1kxnhoOPJy0N05ghGC4Wg09RViu+MJF+aQPHOmiLtyJOOzAhAaZxlmQpov20KLtYz+nWGTzSmFk0CnaZ8OufJkQAAkzn63nC9ndBsMnTq2ClI0p7WGTabYrxptutcKBQqcDLbsihqdm1KCJBZx64Rf2qTdcyO1iTasWsz3r85wmhP7zTTu1sOJhWTpGXT5GxqAUJdZ+ivc+Fn7wzOQ7Zs0ANwjFHpbZUQ8p52mzI9EN6uUuJOEnoBib43IqT3irBNYNKDDQLQo6d4QJPkLceLHesqpysTAY1BxJJmZVFpgMQL3c8GzE6cdHSraDYLVBqEThidifpJGK89n3lxAkMaGNqBn/ux20xj6EMS9UIKVgnGI9kYtaF9MeFJa3jnNXF8ef3sirpPuNlOSOc9OoboGOUxOlD3lqpJ6LXQeiZ5zc3tVEKNdlZ0SybgWkmQTYtOLA7znjY+m7QN9KWlWyeYw5bZrKZ3mqZJUFaEmEnek2cd06wlsY6Hi1vKPuHt+SXvbY/5wvMzEYt64UyDrNeUmn5pqMuUJOu5f3ZN5w0XqxldIwXYs4sDplMZyb18dhA1VoF3vvExl+WUjx2d8y8v7+K84tve+IDCdDTOcpBUPCoPeWt2yW1XcF7PuFts6IPhUyeP+PzmjEXS8GS75HIzpa0S3rp/wUle8vbiijfn12S65/HuEKs9s6RBx5Fo7RKWacXciu1h4y0v6wW56Sh7ud6rOsWngfy9LGpnFN08jE5LwcQCOfUkRSeuRzFw6vmTKajAe89m0mCwYuGp854PPzjnqpxyeT2nmDZizdnI1Kh1msXRjvefn/xrQNLXl2Fp25af+Imf4E/+f9n7kx/Z0jS9D/x9wxlt9ulOEXEjMiKHqqykWKyiSkWqJWpiNxpCC1xxxV0vhFpqJa0k6M8g0IDABRdCQ+hWN7mpbjWFZpfIIos1ZGVmZcxxR5/dbTzTN/Ti/cw8UqQAUmSlkogyIDIj7nV3czt27Jx3eJ7f85//5z/z53/1r/5Vfud3fudP7Xm/2UU6UpDZRoozbQP3O0nym5Qd+m+85fwfPGXx0/3K+0GOoELEtPs1uTpM5PYpmb5Q5CsJhtkHubRHGuUebub7Isgl3JnyQn6BBwLFwVR2mLJItDrIf99/WxHKSNSR4z/Y61pTE9BG/EwRUhFVrMQk2c20UFFuRdpgu0g/VYfgmmwnE16XDJIA3QzRUwYwK0u0keXlWEgOIy+TvdILGWIft6mirD8LT3W8Y3c1Qjdapue5B6/EXHQ6SPhHVJiP1qiPJ5gWZp+LPlm46XKsTB+JlsNEvZ9I8ZJtIzHIGNQ2gdGFFGu7U0O+kZ/RzRSuluImT4Xr4VgN8TA1NUMUSYtVh7/fUz9kYwEY2Yz0U8MoJXqaFFzkCi3BSQczVNKT2/17CK6WQjam4rmbarq5YCBDJv90s/Q+Gw7BNnvmdlAiTQq5FON72omrI3YrRbUbSYMw5NAfBcJ8wFzmlNcKXYjG3FXqMC03HQce+J7vLq8pHbNVTI2MTHmbY838c4er9CGwaC9NOkyAUjBPLZhiXK1/RkKyZ81HA5MXntvvmRSwJI2u3QWGiXkIHkqEGCIMpRyfR/8oyPO4VEgPkfoqYPr9e5gY+GYvFePB0BulAO+mSgqRpDnfG7HbEzmG5U0ydvJg5NUe5h/HA8Fm35yRtiLay6RVpvLx8LwHzT/SQBxSUjN10OxLomkQRr5XQp8pIu98dIlVgRc/eoJyCnWXcb49lgZsoxmsJXskmtOYLh7FtKNbFQ8DhjKwvqvpJx1rVdCsC6pJR7MpeL1P4YxKpsdeEacOc2sor6Rxap4Iv7nKHMtdye62olq0nD1a0nvD3fkE31ja3Yi4LzaTedDngcZmfPVyjHrUcjrfcPHxCdFG5u8tmZYtvbO8vZ5LQWgii8WWpstozkcQFFsm6CNJ+xyNWmJUlMXA4w9XvPjsDBXE/N5fV5hFl3jmWqglSWZ3fLZi0xS0bSb6da+woyFN1LUUlQ4ookTcj0Rrl5WOobHSbOjIfTKfsjNEJ2ZTykDIUzN1mxGzSCwDtBrdpeMwFa+OChIKtTf56iEV9E0iM+Vp25NF8GlqviejBEUMRiQQOiXEBhmAYCNh0Hz89oxRLYXrdluK9CQqHp2saAZL60RTXecSXnSxmrC9r9g2Y9R4YHQi8qV9w2Vzjx8MbjDYQhofZSJlLXz0fNITx1AUjsI66jxy6w026/BOczzdUtqBm+2I9X3N7fUYbQO3i5r3pvcHOVK7y2XLknnKo4a4UAc5Vr/LeNEfScPi9WG7EZ3CVz1GR6HnkKO3hk/+8F3CYuATJUFHwSg+u5fitBlE9vOt+S1/snpE7w1WB0a245PVKbshp856tAqsGkF/FpVMpXPjuWxG3O7qw6botNpyvpuQG8/FZiKaf6/xQWON4BnHRc/VcsxsJAz07z66xJ3Je+WXufgztgbGDn0r2Enda0KEuKyJY0+oI4tHa/EEdIasHni0WHGzHjEuO3zUfHF5jFsWRAWjozWP3lnz8nrBsCrAK1Zvpuhs9b9QGf1v/Pi5cNIhhMBq9bPHoCgKiqL4p778+voa7z2PHj36mT9/9OgR5+fnf2q/5je6SI9a0h5dutlPpw2LakfvLeu24J3pkuO/8ilvf33K+h+cMf9EbvTBIiZJLcWMCvEgZFReJrPRKLq5plgGtmeW0aWXNbiC8l5uyNvHYnoEGCpFHIvkRLtIP9EHo2fUMHnpcbVOFA7FMBa5yvxjuflrp+hHsnpXKUhoKBTFfTzoh5sTudnbVoxv/UgKJlemaHvi13TCUjwFK0Waq4GRZ/dcjGXYKJIWr8AG+SeKhlP1ijhxmDLgdpbpyZb1GzGUhdqjgqKatOxuK8xYbn5hZzArQ9fU8LRn2Brqc4NtH8guwGF6ut9q7PXdrkqFtkEKvVwCWZSXkJ9+LrSO6vqBejN+4w/v277Rso2ERu0JP6SiUPmUpJmJvEVvPDe/kjN+LV9/mIqT9OWzh0kyOmmU91vj5CnbR8bvv9c2Yq7UA5C01HrgEHITepGvqH3DNshUuJ9CexbxI49uNO3MM/+hlan9TKgu+Y0mpgt2PxfZ077pkwmvFMq7R6KzVwHGr6Gf6kMhuw/rijo1c1vRj/fJc+GLRCcqRZqlQkQ7LfKX7IH57guFRqEakRkVS2k8u5mmvoiHAt8Vin5sGb8e6GeG6jYcJtgqyPfZJshrSOQVYY1HUIF8rbn684rxSwjJz6AdycypDs3CfoOkvbz/99/S9AtpjPQgDZ3p4+G4iGSFA9ry0FCnon8fXKXS76kC7Aeee1nSQf+u5Ov3gWpSnEeyjWf3yD40hxHizHF5P8G9GsnELAvYlUE97vhz77zhxxeP0J1ICMq6xwdNt81xvUVtrFA2dISNgdOO3Hq224LYm0MBHCeO7z5/yxdXx3S+QFeOxWyHOoustyX+qxHFjWb7qGDZjQ7X0nYjZJmT8Ybp+y2vLhaoO4u3Cr3T+KmjmEmx2N+VcNIxHrW8fbXARMAp7s4n3KkJyka09UwXO/rBstlJQFD1WBIuw32OzTxF7hicYVxKwf7i40cHkojZaEIR8Z2Y7tARvMIpw3jSsm3kJuw7g0eRVYOklqIwucdtkvSlHgjOoDNHjCJnKMciWbi5H1PXHbsmp3i0Q//+hPZRkCTmWY++KCScqJA3MdYe3VspvJ1IiHSvcFOP2Uk4XTiWIYdP5lB9k0lzNZc/zwonGwMd0YWT7ZzLpLBTUWYCg0ZlItOJXrG6HkvjhWjgsYG3rxfpggoqD3SjnvaiFvmKAirPeNpiTOB+UzO0gmnsk9FS+PGW6DWT+U6SPq1nvZJCfjHacbupOZtsmNQt/WDpgbttxbRS7HYF33//NQGFVYGL7YS7tmIx2rHtc5w3OOTy3CVUJAiNpm1E/05CNPpe6DB2LDQgHxTeSYMX84ia9rx3dodRgdZJmqwPWkKXvNxYdn1+2NYAfHVzRIiKqug5qbbc9xXvL24PCaJvN1NeL2c4rzka73g+uWPnco6LLe/Vt/wPL7/D+r6CIBKhs8VaKD/WYVRgNmq4XY65upomPr2EeWWDDFiUg36Q5i0awUvqtUE5hV3K/e0uTNEpTGpoMl7dnKEGRWNHqGmSjUZQvWbVlJyNNjw+WnHOlPGoY142tJuBL/8X6qNvwuPjjz9mNpv9zJ/9l//lf8l/9V/9V/+L36P+Z0L+GOM/9Wf/Kh/f6CK9WHp0FWgXWvBxf+eI1/9BzqRueTpdsR1ylr3m2WTJ4t/b0f7vLMv/9h2ZvMMBn+ZzkTKY7sFEp13ENmIazXaSJpptU/GRCo3R24fnFt65/NzdqWAcTRexOyHIbJ6aA0Vkr2/VXiay+UokGcU6Enbq8HOiEemF7SJ0smbNmngw92kna/tsE2mPlKD/EvXD7GQCqAcp3nwZUWsrN5JKElftUkxMPmQyQaqCRGHXsmIPXjE73bD5YkYceeEgF6Ilb9YluhTtJ/Hhpqq8kiZ65Lj/nibkAbJI+dpiGkCpA35Peyny9mSO/TS7vhC5yO5UmhmTpBo+l/dDpW0BcOCkKy9bkWFs0IOMORUcpEwqTSFNLw1Ye2QZnYcDBztfy/tn24ety16DvG8s9lp17aUAtA0HeRFK2OH5isP0HSXSlmhSQZmDWe7lJvL1Kk/Slo0Sc998YHG0ZbWb40ceszXYjaY9C0J7AcpLKUp3j3QyNcrPA3n+A2LQCUWmeRyY/0Q2LiEjBUeJft52wur3SbpR3fiEDYVgdSK56ANRZl/k+kJe/zCW869Yejmuc5G07I+BCpFhZOS5doGoHwLDulmaNmYcpCRDpb6m94bxS5ExmU6arGBFnrSXnO2/XwWRil3+Rfks2Xe2qB/KCnnv5ci2UsD4TF67CvHQ3JkkcduHJ2W7ePB2+Gx/MqXj6lPDFklhag+SF59BmMEwsvI6HOR3SZtqMvoT4Kg/3PxDWxEvS/5geAeUsKpvrif0PofWELOAB5gNgoS7qGQq21rWaylElRdMXhx7fu2jr/j4+pShtZTzlu+dXbLqC15eL8Tc97SlXeWoi4pYe5ST95hWsW7H9CdysodNBmMPQYl0o9f0V5VM/4HYFizXOXbekS3aQ3riblmJwdJYVk7zgw9ec9eJ2/fN5Vz08hH625LORuxoYB0VeebITxv6CwnviSm5MyY9sgoKlQuCbnWzNwrEpCvnIFcJg0kT3EA1bdndVeKzcZqiGqTe14HVrsSmJkEb4XDrX9kxHbUsb8bo80L0/IuO0Bv0nZCu/DhIgFGnBZv4uMGayNP5khd/9BS1zFDHHeq8xE29FPSZpExOT7bsdoUYgKNov4c3tSAjS9GEh84cBiZKCyUleiWx8+lnEREpSWskxK4KMOqJWeTk2T2/evqaP7k/Y9fnrLclQ5Ohrefpk3su7qYMTYZPxyOznm6wVEWP80Z48NuMl+sTQYQGjTGBadWiVWTT5dyta4z1fHJ5yrjuKKyjzAYCirttTdtlGCMT62EwmFy051npJBG0cJIMuyvwaaKvzSBSpgi7taTfmtKha/FJvbpYYAvPuOroOyv8cxVFDhYU//67n2C158XuiFVf8KuLV2TK8/HmEd+bnPPp9pQ/vnzC2WTN43pNbQdyI1uZ15sZP7mR6eorNWO5q/BOU09bnsxWdF6SgdshwwdFQLFtCp6d3tEOGb2XBNvNbkq+VIfro24VYeaFzNJr/MgLISgidBunUFcFKpOtjdlpfB3AK2JvUFsjTeDM0d5W/Gj1TPT5XrF6U7NiQdztU+V+gR4Rfl6c9O985zv87u/+7s/88T9rig5wcnKCMeafmppfXl7+U9P1f5WPb3SRPlSa0scUGpLW81+NuH8m0osP5rdshpzeJ0xT3rH8P91w//vHHP3kYR1jBtGJ+1Lhk6lO9fFnmMnaC3Zu/EamgfvwpH2xuH2kmL6QiaL2QuUwrWim9SYeipZ8zcFkFrW4s/epmJD0r/leWPvA094j6FyS5ygvcoioE3O85fD7+vyhgMw3wnPOl4pm5olZoJ43dG0OY5k+HR1vuPliIdzzLEKvsYuO49mWizdz9FGPuSnk5jkJEhO9zPBVxDQKPw74Y4fKvRAW1lL0FzcK3UvDsi/E9wSRYpkY5UlXTJTQJO3ktflM5Bk+VzSngqyUIlyO2+jSiyExPEzi9xpyomjLhXstZsiQMHrap01zti+2xbTaT+QgZxtpyJR7wC0qT0J8cuDd74Ns9l+DSkFDstFFIa/TtHK90qmQ3j6Tnzd6y8Eku30v6bGt3HQ224Iwc6iNlcn5qRNdo9Vkt0ZCgFaB6gb0IJsAFAfM4V62pULENnIuLb8dCV9KUVzcy/mpHahGjsG+ce3HOoVyyfHLdrK5yHYxccFJYV9Q3XpcqenHinZhDjr2fP2wTSqWInmyrWH9jj1M7O1OPht7SVI71+JVmMi2yBcc0kUv/61A+dZQX8p5skcw2jbJk2qVGrz0sTER/cfjw7YjS585VyVZ2/4zngzFtv3ZZFrtIu1CHUgve7OtyJ3kGrE3r4opOKK7PQf/4TyorgPbp/qwNVMe9G0Gj1r8zhIvSqKNZGuNcwWYyI2fSjHeWuEvF57YWMzaEGxGGHuUE8b23lDpGwtapq4fX59KGA3QLUv+qHnG994954OzGz758jFhnaM7mfAppyEXGUf+aAdK6BE36xFmOggjfGcP8efRxoOhmrGkLPpdhosZtk5GTxMYf7Bk9WaKucz549X7h3OboATXmtKSRT+uIRMZQZk5stmG15+eUj7aEeI+HCfSLQvYWjmvB3UwYcagMHnAd4bgxcR6wEfeVTJ57jTBadqgRIvtLSqlbBrrqcpe5FedFQRlq+GdlrCzPDlec/52fiBchblIaqICvTEMmxxTOVqXEYpAtjKEvsSfDAeDbHSK0dk2GSY1ai8V3GYC0PIKdZ0Tsyi69FIK8BiUoGyBMHWHRjEfCT7SjzTqGL59eoVWkbf1lHen99z1NQBtbwXnGBRk8OrNMdp6bCkT676zTKqWPHPcL0coHcgKx688f8X5dsK2z8mNZ7UrcV4zLjpORgOF9ZzWGwKKt+spnbNc3k0IiXee58JHd84Qo6Kuerbbgtx6phPxAHR9Ju+XjvhBMzSiS9+9GRPzKOdljDw7uuPl1RG+tQSn2UQInSF6hS5F359Vjr/z0+9DhLPjNUPQ/Pe3P2DoLUoHflqd8nx+x/Foy+V6wuV6Is0SMJk0fPfoiiejFS4YFvmOxmdUZuCur3FRAx3nYYJykcs3c/bm4RcX9QE3TBVg4uj7FKo181JQp6LaNBq5bAXsyGEmPdZ4TiZbXl1IyJb3WUq9jWTjnunjhpvriZQOXsHOoOc9Z8frg8l7c/1zkJX8Aj+01v/chtk8z/m1X/s1fvu3f5u/9tf+2uHPf/u3f5v/5D/5T/60fsVvdpHuasWuNIcVeD8Dnra8f3bDti9Y9QXzvOW+LwlRURrHclVjvrfhfF5Tv9ZUV4mJPVEHWYDyMv30pRYdbSGFR3kX2Z0Kkxr1wP7ePFPMvgyHSWM/laK5vAuymi/VIWH0UCTuiS5JprA39O0L9H0BKsxReb225aAdjml6q30y/0UpJoYRB8pAyMD38vXdkWC3lI7s7itsPcjatfLcfnpErAJ6q4UA4xX+uuSytWKa2lMANJjbDH8y4K3IZvzZIHp2p8hflXTPeyg9Kkqxtdfqu+qh0DEDrN5PmL5urwNOzYl6aI60lyTMYSNhUvUF2C0pbEoKh26mGb9xB1LIXte815fLnwuzGqW4+8gctNnBSly7ipCtH4yFooEXJvO+wOoSd3sYCbXF5+DyfZOQXlcqEmdf+UOlvieNaCcM/NF5xAwRNcjk3tWG8lazfkcRCuhcAa0iLryseycefZehHNht4uQuoV1odC+/iyuT12CQiXBx6/CVmJyLO9HJtkccsJzrD6RwPflDfyhWHzwCYkiefuXYnVqGWkuhnrYXIdMMI5kMbx5LwM780x43MnQz+bz4UuFRh0IWJeSV+koa3D5K2uk+idWXivraS6E9PCR9DpVi816kvDBMXsQDx14FCVPyyXNRLOVnNSea+pWm+7UtYT065BXoZPwtljLeaRc6Tchl0r2XRYG8r+2xZvc4Sa0KiBkQ4PT3wefSrBTLSHU10JxmspHzHBr2/aZtGClcJSZRCU5SuJHHaFl/4xWxCCnsTOHGEbYGn27UKClIlI242T74R+gfPhUqNvey8tcIF/xmJOSTlSUe9aL7jQqrAx+8d8kXL88IY0deDwydJTpNLALDeU3UkWsVcb0YG0wesPXAqOq4eTkHr4RQUQZMKUEv7Axm0YnUZNDY2rFZl5AH/FgK6lgk86UGTEAh/iFtA25ZEErHpimoCjHC5qcNfSfNhzKRrB5QViQmalBgpfAmSUD8BjDpGqJBJYSgsoGy7una7EEuoiNlNtC0OdoEYlQ0bY4xgUEut+jJIP+/NZR2ELOeiQ8pqxrqRUO3GWNWltBrLs9PYe7oy4BqDPpeUEN+lLYVX9uu7YkmtnDoZwOTWkye3BSHfA/dioQiFkku0SfaVvo5bZNLo5p7rpsRH82uKWeOT+5OuLsdEYOmHHeM5g19b+W15nJd6tcFDPKBv9wuQEVOni45qnbcNjW/9+lzTO4pyp4QFFoHRnnP5XqC83JdrLOe17dzvNOMRh2TcUs/GJptcZCg5MXAuOxYNyV54Wi7jF0jQTwxKPJ6QAHtuqCeNYyKnlszxvcaWoOP8OXrU2libGB2tOUvPn7JXV/z44tHdE1GNe3EC2UCfWe5vJmQl452XXD2aMkHs9t0/ktTtyiFaPY6n1FnPUpFfvez5ygTOTta83u37xKcxmSBs6MVnbOMi47eGzmvFQfyEMDRYstmV9CtCvLxgF/JdlpvDHanUF7Tvd/hrSFftPRNhttavM9wW8ObfkaspcDXi47JtKGwEux0VO4YnOGDxS3XzYi3VzOUhvMvjoUqpCLB/QJO0uHnwkn/X6N7/8/+s/+Mv/E3/ga//uu/zm/+5m/yN//m3+TFixf8p//pfwrAf/Ff/Be8fv2av/W3/tbhe/7gD/4AgM1mw9XVFX/wB39Anuf88i//8j/Xc36ji3RfKiZvHdXrNa//gyOax4Gws3z++pTsq5L7Hj7/5R3GBsZVJwim3OF6i+kUz/7qC8ZZzxf3R6w+WbD4kUxUs21IhX9ypyuRWeyNj/uiZh+VXl2nxMek27Vbmc5tnmpmXwbye08/MwfDqOhn46GQ3hNo9oZUAFKDgBIjpS/EIGsbocJIo6AOU0WfNjzTrwK7U/0wZSwUwwRIlAEyeUFulx2Ma0TRA8Z6IO4yzFYmRtEptFPEsRMZTGtki9UYzKzHrzLKz3P2IT/tswEGRTHr6e7LA9PaVRBS9LPu0oZhmbYAI5GE2EaRrx/wgwmYcGCcT3ciregXkjIKUshV1x49RG6+b5l9lgoAT7rbCq9aBQ7IwPHr8IA77IQQE3Ip7lWS3PhCHaZWB8xlkqtEs5/4p4mufvi6aGD8Slj5e+lUthV5EF4oJ82ZJbtwaBeSnCRSXjtGrwO+1KzfyWhPIVhJjCUoQhbQUdOdeeoXRkyplRTa+XYva5HGUNB2hmj257FQc5ozg2mFH96dyGsdxpryTm5ePteH83H8JrA7tYJSHORr93Se+srTHJkDZrGbaZYf5g9NkVVEJwX9UCuaE3PQam+eaerLSL4Wo6dt5HOyfaxpTgyj8/CwDUjSsPELkdkMI8XuiWwVCLL+jzaS32rqi1Sgvi8SCfNVjRvtzdccQrTe/B885tYyfiENVbaTz3m2CzTHhpCm7ctvB0yrsL065AKwtvQTI7z9Uvwh/SRH6EDymd/r5PNVTO+DSFH0AMM0UT7mUhjkY4mVzy5kIzWMpYCya9HyYiKqDAeJjUJJYVWk9bnWhKjonaEYd3TrAnIp7BfHG+71GKUjx7MtnbO8XU7plqX8DCfBSXk1CJ1iXRBqOYbdRS1FcCokXeHpdklXrdJE3CsxyAVpGsMyJxYBnXvcTqbUxazldLoBOFBeem+osuGQZuq8ZvSk4/58ihoUbRHgETxerDAq0Aw55xfCu2YnoTcyVk6VaiKWSJiQrDeUFROpMpHpTDTxwWny6iEx1HlNXXUMziRDoKRmais4Q6UjVd2zo+DLjx8T8yCaVafkfdtlNPcVOhX+ZpM6PB3JLjPcKMi1NSgIgm7USvCR/WDk2PYaFxVsDOszCK19UMkVXuLkE0dcBfl6GiuvddxT1T3zuuGs3vCTi0f8zt0HgmJ0gjZ898k1lR2Y5y0uav74/PEBkTk7XeO8wejAo8mab0+v+Gx9QmkcT4/P+YmSRuZJveant6eYGHl1M+douqP3RrTQLuPRYoXzhhAVN8uRTLdNTM0PdE0mHoTecHq2ZNMWkubZWoppx6jsMSowrVtuV7XE3ptIdBqV0Ja0RqRFx462z/hqs2A35FgTCKVjWnXcbyth2ycN969+60v+4O0zXNB8fn/Euimpy571tiRG4cg324IsFdv1pKPOe67uhZefVwNlMfD2q2OigvutOWyDHn10g48KoyKX5zNu3swOnpNhk0MeMcP+nUwN101OtlH0XQ0jj9lY7FYRPtryaLHGB02bmoFJ3uGCxgXNsi+xJnDT1tRZz2KxBeBeRfwqff6W2b9g1fTNfvz1v/7Xubm54b/+r/9r3r59y6/8yq/wd//u3+X58+eAhBe9ePHiZ77nV3/1Vw///nu/93v87b/9t3n+/DlffvnlP9dzfqOLdOUlwXM4rln/kuO9/yeieTWaqGWyfVvUDJPAralonmScTje8enUMdaA0jtZb3p3e4/7CiovvTLi/r5n8g0oCkb5mJtDuIU7cF4kt3SPr+1LW9yF/SGZsj1WKiFf4wh6K8L2udl8EZpuffT3DWB8wkK5UmCYeZAQg31/cB/qJlpj4lDqpIuxONHffkQnr5j0pDkwjsphsoxiMJpRpZN8YYh6IWmG3GtdYaDVq5ImNxp7nhwCG+k+KQxPQnXnyK4PrCjDQPnPYe4OvomjWF70gpmYDzTtSpMSf0dsZtIJ+Bq4S0kt5JTKKTokUg0RjASl8TQ/ZKqCiThQQDqbBkCvawnDyRwO3383wNRz92KfJOSgXWb9jKe/Dg3wpyERMRShWEFU8mDsP2M0mTdE7eX+jhaGUwrhKZmHBG+6lJSJ/2T7S1JfiVZi8EnJKvvJEq+imgixsTuyhidI+CimmkqZs8x4Ms0Aog0ihNpZspcnvQMVEScnA7B4aM5TIm3wupmZhlIs2m4hMv2eBYQbFtUb3UoCtPlCAEbKO1BOUd6LFzrdSMPtcMSzEEN1PdAorkvOxHwvjXiQ/cl5HA3EQCk+xjEQXGcai+7dbmaz7Sh+kSZunUuCUt/HQ9O4/ayoomjMhs2SbSLdQMMhWxDzfEryi/qjl9nrM4h8WHP0xoOT88Lk6EGCilkLcVA4/UWhnxYtQqLSFkq2OdiKHmn2s2b4TceOI3hrslWX6eaS88wdp1fSlQ3eB138lx42CaIYroYKYncaPAtUrI0QYg4SKFQHlNaGzTI639CbHjWVSSu2YLnas3kzBp5u7TkOCoMBpKUI6oTApGwSfd1PSupJyLlO66BX3L2ZgI/WiwQXN2+WUobN8+P45d01N21uRIgSFV4r58Zb72xG6DAfiRmjleoBGTG/THt9ZqrGsi0JQDG9rwsijc1kP2sLz/juXNC7DB30gvOw14njNbtIxrjvKzNEpw/3lBDUo1GSgqKVpuNvWbLcFRJgutkJh2c1kourShia9r2pQxOkASjYCtna4rciqdk0hfPW9abHsaZNMoO1Flw2IqRIInTC5vQ3sguLoo1vuPj4mRBg929BsczHNBoVZiwfH7DRuLE1d/koGFqYRI+Qwk0LbrC27Uc44kWxAJvquN4RMEk5xD/hcc5UnZF+EMkqDYhAZj44Er9muCrbLklf9CYsnK5SKaB1pEyv+cjmh3eSyBdARXXrqcUezywleo03geLzli8tjPnnxmKwacJ2QXvLC0ReGbZ9Lg7UriEGzaaU4lmRNy1gHmsHSdGIMNXmg3+WYkZeeTgWRvhSaXZ8fUm1H6f3ftDlNMj7TaGIZsJWjnjWU2UA7ZHSDPciSZnXLbsi5uJsQo2I2aXgyXnF1L4QZIgSn+ccv38Naj/NiuMwy0d1/7/EFtR34R1++h8mEcjOb7pgWLZ235LnDVmI+bdocvTeydul6lQcuvzgSydFZIw1T4RlNW5pdTrwpZKA17ck/lglVdxywG/HhZEsNS52ubaB+OuLNvJLmvVcs60CcOLJ6OGx5jA5U2cCyrfjlowt+dPMY3xtmT1YsqoabW/3PXS/9/B7xf9WU++f1+K3f+i1+67d+65/5d//Nf/Pf/FN/9i8bRfSNLtJDJsOGN3+5JL8Cokv6ayGpZDs4/uN9tadw5YQ+THiULvBffvot1t9xjB5teX9xi1KRbz+75NO/dMb9zjL6LKO83qciqoMuV0gOqXuupcCwbUTfSVEeMpngjd56wTamYap2Ikfox+rA3862CS94oll91/Po76eLuJfpY7sQ46p2MTFYxUBnm4f0xuZEH8xx1SWMzx1vf0MKiz1e7urfCuCR4IosHDjnIIZUGi1R5SNPLALORsxWE/NAd6SwO8UwC5iNxlcyTVMqoicDvhYzTOgNamdh4ohOY7YGP0l/Vz7whlVUSR6ioIN+LmZY3SuujjTjV1IsPoThCDlED5HRZaLFmIegI+Ujzall8iqQrz1v/1KGaZOJM4rsKL/3dAtDvg4J6yiGs+ZUMzr3B/SfT7rr/YUULbH17bE0PPlKivNuJuE/dpcwjEEmv8W9TOgnr6Wjs00io/hIeesZxoZ2IQdehXhIP5WE2kj/rIetRXlF9lpCQHwhUiDTyjnkk4E12HQOdYFsK7//fuOzn+xHJecQMaJ7aE8D6rgjnJdk729Y/gC664qz/580ALZLzWIl8qF8E8i24vko7j35fU+/yA8kHNMGqlxeT3NssJ2ETbVH8k8wiXCT2O/NsT4EDYVMMXkl037tIkOt6Sf6sDkqlgGX0nx9DuPXkfCrW+E1W8/3nlzycjVHrTJMKybq5kyaOlemJuxOZErn/05k9g8qss1DAm5Icpk9nSdYdeDRTz+T82D7FMYvZMOyfkeK7vEb2SagjJwbUWMb2J16lFeEPJJfyeZimKRrhVOYrciD/MSzvq/QNxl6EAmJ2uWslxlm/9+NIroMPe2JXhB9KGSquLaE2tP34iFRTjG09hAgQymkEGs8ISqmVcvJyZaf/ORdSNP9OBs4OtkwuMRCjyQknxZMn46oUcRdVQSsmB9tpLlPLPNBifG00wdW+NBYPr14h5hLYNJ43HA23vDqbk7zZgwjx/F0S4yKq/sxk3FLMe3om4yiHpiPGmZlI2SOXuQ8O5szqjuZ4OuImnrKuqdZlUSn5Pl7gxo5ZosddT7QTqzIKqL8XiZRVPrBynEadcSg0ftC+T5HTQd06eS1ekVcZ9ysFkLBCort+VikNlkUVK2OBywlPMgPgcMARw0KX8tUPdwULHuZ1u9lPJPFjvVgErElEnLZBLlK3lM77ygKx+hRz/22IgbFsMkZthnltCPPnCShKjGufnt6RRcsb3YzajvwJ+qMbOGlMQmKInOYcWBeN6zakq++OEO3mlh7hnsxtJpczLWldVRZz/VmfGhmnh/d8dXtQnCOq4qhNinMyDAatbRddij2Y1ASWw+SsqohpAart4FtLDmabTibbPjy9SnmuBNSz23BemRYKyGrsJMptq89lzcVajxIkVwPbNscN9H8hXdf8XtfvoveN667TJqzSctismNcSGNZGsfb3QSlwNrAYrxh2+W8vDqSVFQVUSrS7kRKlFWOfpujZr0YepHBASNPv8uh07zzwRWTvOO1nrHqjeQObC3NuwMmIVBVwrL6MoXgfS3kyLSK8E6Lzj3+bY2+zwg3GUMZKB7v8EHz+tUx9Jrrj48PEIS1qRicwbD7lyui/uzxp/74RhfpQw2rmaH/foOxnviPqoNmFaVQIdCPDDqt37VLGlMtRe7obSBfWkw/5UpN8WPFpx8co97dcfJkyXBquN+UlD+sGJ1LsagdNOM0uawSAi5XD5pXlSQaO9g8lQ92N+Ng4DuEnljIm4S7ayLFl4HxK5k6k+Q1PpdJLSiyhq8ZJUUmkG1lBReNZvrlQ4R9OzfMPpfJY32ZEI+dJN9FE9EbucnrrUEFRX/sMVuNmzvUzkj4R1D4oDBrQ8yiSGairLdHL6SA2XzH4+8lWTDatM5v0rQ+KMKil4taa1Iyn5BffCH8YLtRhCIm2odMPvOVhNhIAqyY8PqpSB4IkjgqqZYcuvU94jFk0M0NJ3/o2Z0ZKXqnitUHGvNYM/9cCCTFUjYP7VwzeuvZPDXUlyFNpKX52Wvo9xO74i4hF1MxbgbxROwDglwtRWS+CWwfG0bnXkJk+oByyXuwp/IMYkws70B3cmOIRrF5RxNDQE0H8mrAb0cQpMDb00Rc/bXfxcHqueboY0c/MWgbE75QDJBhSCmcPlK9UTSPhd+sP6/IV9CEsSAhjUy790hEVyrq64DPNd1Mznk9yHHvjotU8EcwClfvb16RfB0wQ2T1rqVfgBsFimuN6eQY+lIwmiHItila2J1p7E4+S7pDztc01XalvN/9ZM8iB/fFmOLDFYMz/JMv3pUm7FK6ls27oD/csJht+P7inIDiR7ePaf4fjzj9BxoVpYHQTjYMdvfw/pIIPHszrxsBQRCp+62X6RRoWD8zh2TT4j6yfQ+GY48aJCysX8iGKFppTvWgxRS41gyTgF0alLe4qad4f8vuRox+unKEyIFGwsbCtchYlCJdWCRtOJ/0h2FVcFqK2ttCispBEW3k/nKCqRxl1XN1MYNCuiN1lxF3ltWmpCoHjmYb7tY1/XVFNFHQeSaiMi8GTacw0x63zcQnEeWalE8F48fGPngwRh6SAZCoWDInVl405Y3h/KenxDyiJz27Jqff5Jw+WnI22tB6iwuaJ/MlfiZs6v00144lLXRWN9zcjYWOkZ5TZYGzsxU3yxHrZSXDgqThjk7jfA4mUk8b6nGHVpG+VzI5tR5XeMp8kC1G5VCdhP/oTpoRfzyIDKNJxnoAr8jvDL6M5HeyqYpKtqmhDIIUBbJ7SX31RsysISqycS8T5qDIa9F9o9N2zyvS4cVfVLS9wn+woSp6+sGiJh1ZJlPitss4nm4Z5x2PqzVbV/D3P/mQ6XxH22eMqw7nNWU+UOcD311c8sPrJ5zfTaXIBMxZw6TqKaxjCIamy3gyW3HfVjwarXnRHKGNbFc+fnuG7ww7BfOjLZn2D1CGqsWaQDdYipGjznt6Z9m0IgnzvSavB/pdxpNHS7kvDpZXN3MI4Je5oIGBuLNQevJJj8sMvrWyScoCs9mOzbYUY35QvFzNWVQ7jhcbdn3OkGgxxsgmcv/7LduKZshpneWjJ5ecryds0wbgl5+95cu7I/LMkenA1hYoFem3mZi4EyJS2YgqBiazRqbt24I3V3P5DA6actLRXtaMHm/IrGf1xZx8rXAjASyI4TTSPXaoNNiKyxzzpsRl4j+anq5ZXo+JTtNd1HI+1J78qOV7jy94Uq34o5unXFxN2b2eyPbnF+0R+flM0n+Bp/Vff/wCvkM/v8f0q4AaBbpPK3wZefXvR47/ULF6nmNbAE17As/+Py27JwW7M5Ex+II0jZawk5gII+UtzH+q0D+qgZrKQf+h3Ji/Pu2sbiBfiVRk/Z6sr6KWoi9rIuNXMZkb1SFldG8MVUGK2eqNF5xg0q76Un6HfdGQrwNv/5JGD4ruCOafPJgQUVKkEwEP5W2gOX2YONaXguvzCVuoBymKKT0mhSs8TNIjdmWE9bux6FbhAuhOM/1MOv71cxi/FHRitgv0Y8Xylzx6Y+BRCxelNA+FTIBwOt2UkwFtp3F5QPeKMPK404C5s7IOhkP8uemgW0DUkfUHkdFLwV7WlzKN3sfLD7UiSwFHKiYyTtLuKx9ZvWepblNy7ABXH4h2efm+oZ9Kg+UqCVuKRlFfhYOJd58k60uFGhCz7PAwWd8HMe3JIHvZhhtxCNGpL7wUskPEFRo3l6bQDJF86bGtprwXuUhMr8k0kfVvtCymDfeXE4a3NfG0x1zIzTRmwCDPt3keye9ksr5vykIGKk+BVsko6XP5e59DSA1GcSvF8u5JFDPwSUd0BlflBKMYXUhxMdRCjKmuZStlG5nSq10ArSBN6avLDkKkn+cMY4Or5XOkB9g+V4djptI0XRo0SU5FJZ2/fdiKLT+SBrC4lwZ1OHLYpWHxE/n+R/8wMvq1JZ+8eARRYS8zRm+ksJ98Be5qzL0d849Wj+XcfT8y7ffmZA6hV/vQo32xDbIB2WvA86U03/u/157UKIJOrynbSrM1/wm0J5ZuHulO5Jz2dUTdSPhNyMQIGDIxb4dcGhLdaZrzkeAFAwRlUtANosuN6kE+U8g2bx8v369z+azlgaOzNctVjR+04P28TApM4QmDpkm6qG+/f05pHD96+QR6g7GBrrecjDeM8p6LbMLuTtb0MQLrTEgweSBcleh5z9HxhiobuLyf0G+lACOle1KmMJ6A0C5MRGee4/mG3HpKO3C5njAqekJULHclk6MdN3djVk154Ji73uI2GcoGqlnLLuSEq4Kg4MpUUkDvw4LGYqbcdjlaRwkn/prRfXSyZVa3PB6tebGaS+Gf0H9d0qjHkIJ28nDQfeutIcwd+t6i1hZ10hFIVJGNIdQeN1ZkS/kMm1YxnDjMUpCpe2mdq2UTRpSQIlWI0Xe3KslHg1BQNpk0PKnrUGtLrDzMZSrt7krarBAkY1T0TQZOY+qBTVtwsx5xWYyZVS3Pn9wIDaWxdDcV5AFlAvYo8OObR3SD5Wy+ZplX7Joc11m2UbF2FWXdU2QOF4Xk8nI1l/fjvkB1muzZliyT7czgDI0X6ZA1nsvlBKMlIMp5zdVqLJ8pHXjn7A6AR9WG1VCIJyGtcU/nG+5sTd9aQqnBy+vyvaG7KzGjgWzc41oxOW82lRTNUZHlju2uYLWqeOfsjt4bFqMdV6sxKm2S6nzgq4tjMQyXA81WrqeLquG42vHx9SkX2wm7JidExd1WGO7KRpluN1aIQSZiCpm275qc56e3fNGcEIPi8emSk2qLi5qfbHJ261IK8CrQadkQu0mQa4EFe2/g1pJt5PrncyQwK8Lm4wVZL9s0N3fk845xJZjL1+sZL5ZzVve1ZAFkAb33Q/zZ4xf28Y0u0oeRouqlKOgniuxc0j9DBqMvPNvHwib/8j8uiUa0rXsE4j6ltHksBY8vZcqZr2WlFQxMXwQe/a5j9TxjGItx0Xwl+ljtASfc5/0E3VXqEEe+T6fUqbAKOZAoWtqL4W6fWCnPyUNYiiIVgvLzTv8wyPQ4TUnLu3CgaNhWqopsK1PCchPZnQnnurqR4mX9riJmgfKrgmEs6XlmKZMoX0Z8LZpaADfzFJeiMd//7NEbdZgumkFkP9lSpki+tagigI3Ye4t/2qKvRaYR50J+CVm66Y3SRK1LU/tOSxLb2KO8wXSKqCOzTxXVdUB7T3OshUOdGiXtI77YB9jI8QCRN2zPjBTUAdpFSu5TcPa7gircPtaEAvQK4gS2TxSzz8UF7CqN6SPXf05z/MNAn2g/atifaxxCivbry1BIA9YtOEiPsq3olodxmjAnRKirFO2RprwVo2p546jaQD8xIoHIIdzlrM5LtAY/dmIuO3LYWyvM7uZBh+5Gaa0+iIlx/YNeCjuXChQbMTcyEXQzhxo0utW0f77B5o6wzYmdQa1yCDB5KcfHdJL0uX0k8pfZOqTPirDQfSYbDwkR0nQfVNh2L1eSqfPywwc+eEzGWp/SVmOKytapsVVemqZ8xSGRtDlTqZGOZLeWkEW2T6RJjKeK1d95j0cXkc0TkfXsHj2EOxX38YGz7iL5vaKfwea5Yvq5yKPGrweGkXlIjU1Nr2y41KFo/zrBaW8e3n8+85VgLBefOdkczCLFnaI7FgpPsBJQpZyiP3VSuG6NoNhGAU47QivFhsq9rNrvc1TpZWXvNEwGSamsPKbw+N4QB0V+kTE86UX+kQU2u0IKl0wKfEyEVhNag5n3nC4E2fbJnzyTlzUoKAPdJkfbwBefPYY8kI96ZqcyBVyuK5xNVBSDbPi8Zr0rWVOideTx43vOvzwWPfW8J7QGO3KyXfPSQPhec2dqRnXHui1ou4z1UuQ1dIbWRP6jP/djfFT8/S8/pN8UmMrx/INL2iFj3RRM6hbzbdHX392OJHZeC64uGmm0rPFsd+nn9lpeT91jTWDXZ/zw/gmus9jCURQObQJGB4yOrJciJcFEzLwTg2cnlBwetalhQqafK8HLmrUU8/1crp3KKeydlam5jrhaJvG6VxglA4xYBEIjYXFkkWLe4LTGZ1ZY5plPnhgjhJilBCdpD9XzNdZ4lrcjUDA92eCDZnBGprb3NcurCUePVmLqrRyz0y1V5iTO3hl2fUnfWbb3FTrzjCctRyc7noxWvFgvpPHqLf1gKYthH0yMGjnUJNJtcj5895LceL64PmZU9lTZwLotUEom280uJzgt4UiVo+syXtyfkE96jssdufZgIbiMadnig+aDkxu2Q871esRuVeGvS6i9cPFbS2jEb6CywOPjJW8u5pjME4LCWkE+LpuSwRnBTGaevHBYE7jfVhTlcPAljCctXW/56u6YL+MJzx7f0QwZz07u5Th1lqARSEJQ5JOOobXCbE9Mfq0jN7sRT0/veVRveLOZ8sMvnnF2tpJzxUTYGvLTluGmREWFasTDYDeyuY5ZxHSCFPV1wG71Qf7i84gfBfJpD8Dt9QSA6BTj4x2Lo63o7VsrMrhfxMfPZcr9C/ra/2ePb3SRrr0QI7oFHP8wkDVB6BKpuRyde8ZvpbjzhVzQvy5hUAHyW1lRZinOffVtz+iFYfJiXwhrqpsgRcgbCVJpF4rRW5nudkegP02T1/BQnO/Rg9qLlEAPX5viKZne2/aB7y6GuVToIAXG7NMk5Uh6aRWBlCRKjAeihhQT8YB5LO7lZ6zfk98p20gaWj8XUoBqtZiSnMJuNJOv4O77gfq1ZvRW42pYfshhqtxPpFCpbmJKvJSC0Y2jMJQN6Eam8fVPSnwpDUY7Tpi0RU9cZfK1MjIULWQhUff2MjscF9Mp6ksvU+lCP2DtSoUd4tcmmzK1jhpWH4hkwu7kmHdHIgXZc65tI1uP6QuP3cm0NyrYvRPYvifFfMgCdm2kqXlPfl6+ftAv20YaQbToTfc+BYJonn0pXxe1MMPH504m3FbRTxWuTE1OihXv5gZf7LX5cPGbcqEejqV5yW4yCVPpFPl9mgQjr8+06nB++SoxxZcZfuTJjluGjWDO9PMdftBkNuDajOAVrDP8IBrcCLJmR7YQ9RX0UyNF6EYkLa//bctwOvD478mBKK8dzZk9BP1E9TCR9qU6pP/6Un5nu+Ug8znIRr7GH9eD/HdUQGpWqmt5bcWtFMyml+ZbRZlwuwrauWzCxBQtTZrppJH2GbgTyO8V+Qo5f7PIzZ+PmK1i9a1Mwqi2Dw30/phKQiwpB4FDoydyF/EGSECSfP36mdxoRy/ldZe30qB0C2na28eSInvQK9dicPNpYsvWEE0gBvkcxaBwr2uYShqjrXrCixp/JimekiJsRe4xCEEktCU87qWxN0HkHpVHG0E1nn92LM8fFGSB8fO1aLaDwmYed1XCxtANmj6WkIxsOshEb08aUa2h70pULxr580nOHsEU73OoPDGAmfdCeek0qpRzb9mmE6Ax6IkUH8/fueLLNyf8v//ku6AgKxymlq74/H7K6XTD8WTLrs/Z9hlnkzW3bsJktoVxS9tnlPmAD5o6H6if3HG7qVk8uccaz66XqelfOHvFyHT8j28+YrMt2K0LTo7XXN9OsLlH24CxAdcbQfk1GSx6qnogz2Ra61sLnUZ5uWa6sfh68rVsrMIHDX6VoVuNm0swkb5MW7C9Xn1rUCMPXnTWuyZnMm6ZPbrndl3jvfDc1WggNlbuZTYQssD2tgYTMHnAWM92W6JNoK46truCatzhgxbE8KzHN5bl9ZilQkzGhZPU17pntOh5NFrTess46/ns/oQ665mMWqwO5Nbx9mbGbNKgTWCxaNm2OTFTfPbyTM4zHel2GZvSUZU9mRVyzWjUCaowciiMde7pNzlf3B8dGP5Z5hkVPR/Mbrlua67XI5SCatLStDVqY4jTyAfPL8iN55PXZ8SoeP3FCVT+oHv3WSDLPJsbkYaYac+o7piUHXXWkxvPclfSJvTjbPE1DbdXvH67wJaSIvr+7E6eo12gJ3LB1TpSTzq2lyOckfCtEGC9rvj+yTkT2zK2HdOiZZ63bNqc3Z3I1/plIVr0iccsDaaRYZdpNGzluu1r2TDv4Qp7MEBxtqPb5uS1UNaUjuSTns1NzW5nJAUXiPsbwy/aI/wcnuNfjxr9m12kmyZQvvQsfioyh2FiRJay10QpRTdR2E4K2t0jneLR99pgyLYSEOQqKcRQsP2Ww+eW4x+HpEOPB2KEkFdES9sec2A6K48wt9N/+0wKOtNAn27y/fgh/ChaGDJFtk2ToF2gm2tULnKFwaoDjnEYacpbT0hFqUhY1CHmPaRAHV/A9pmivJafbzop4vYmlfxeunVfgR8Fjn6sD69NOcXRnziufyDmtvFLMbeGRFqZfhUYxoq7XwZfpguLQgr9rcan9bYvwW5Sk7IVPXsM6mC40im0QzmF7gy+VrhHPXSG6sJy9FNHuzASlJM2HiJviek1ytZDKCkiJcjvkhRByfuarRPHvJICbneakIEd1FeOqBWTlyJPef1XDLpT2I2hf9aj1pbuqej1dadwR478Qoyo0y9lu9BPxOy5T8kMVnTigpQUJrnpzWHa70rYvhOpzhX331Gc/r6Qh/J1YHdiuP7LXnSZiZCjjjvUSSBsM+La4gZ9IAsN84erX3GtDxdD5UF1WmQQRnTJ+yjw6e9UkrYJuMqKgTnpP/cG1GEcDxuLqAEP28eaxZ9E1rss0Yki3ZFNaMmYEjZTwE2aQO+DlLST98SN5dwXyRWH1wEPUiGfP5yvWWKbRys4TlemrykhDhDH8j6rKM2R8kIKUl42G8HIe5FtpVAeJqlRUHKO738Pu5XfzRfgxp7q3DCMOTRGxW3i4adQJTSg1GFbsDtTVFcckldlk4a8j+l7/JFIWqIRE7Z71EtA1Ww40Ch8pQSvqCDuDd3HPbEzjMYdu01BnHhwWrTLyGcXHQkjMWOHAsx1hn5vdzD5sbOEpHNmIpPjohpotzmZ9RxNt1y9OKIzkfmHd/zyyQWf3p1w9XIhk/agCHkQ/fi+KAgI89spjFM4LIxk+hu94A9tIYzn9x9d89nLM7QNjMYdbZexmOxoB4vWkXen97TeEjeCgGUk+vA+4R5t5rnfifRmcIbgFV8szzDlwwnknUaXEaU82y5nUnZYEzi/nKFtYJwK+X9y+Q7TouXfffopt/2IP7p6QkBhMvlZeeEYekvcWbrWYFIwU9/aB/xkY0SGZCP+/UYmptc5biTH2G0y7Nrgz3ry0jFcl7hREDLTSrY5ulf45AtSAfxdwX1jsfVAVUpzst0UBCdcdpXLUGV2tGXXFPhB4xuLCxIw5YHNrsaf9gzrHKWBXdLqTx3ff/81AcmCOCm3fLo84X5X4YKm9ZZPvnp8oARd92MpsIciaYqFrd9tCmmEnGZUd/S7HKUDj0+XB5Sm0ZHlupJgocKJn8ZpXG8JCWlp0nnR3ZcUC2F7N33GH50/keuSMwyNxeQBioAaD2gT+eLlmVwrTGA639FVkmY6uIRFjMJxN6UjJAmX85qr5ViGVzqQWc+HT6642Y24v68ZT1oY9XSNkHCsDVxdTbm+mfCddy9Qy0zCoyKEwmOA6eM1q/MJ4aokZpHsqOXlZs7z8R0bV9C4jJd3c8F8evl8+CIQy1TYVxr9qpTrzdTLhjCPD9dbpGaxjcItPFpF/uKHX/HlcsHVVrSA4asaNQkcfXjLalNRFgOrf1Zh9GePX6jHN7pIv/6B4ewzRbaO+FKzx+pJEqAkMWZbDrrfPdZPYt/lZlrcibnQdFIs2LXGl7JidKUUwkE9TC73Uz/bRqpbkUf4QjTS0ZOeMxKmoFvoZop8lSLG+4eiVw8p2j6Zn7q5PoQySZS9OpBNIOJqfZjqRg25iwxjLRKX+wAxUt7LdNcXkC8j5Q3cfU8Kk5M/hKgiyw8Vix+Bq8RYuS+q5j9VguqbyLQyX0eK+8D2iVAqVu9rTAuLn0SWH2qGaTiElPhKbuZHv2cploFuqunmMP5Cs/rlAbXOwETyFwUoGKwEg4RxQLWa8pOCyctIthXM336SmW0Dw0jkLt1MHQpk5eDuuxrT7LXPkdELJWvKRFqRQlIKqD2Kz+dKCDaZ/Ht5H3j29zxv/m2DK0HfyQ1Z2cTbfrKj+P0x/Vwavqtfl2AaN3eoVqZqKkJ5oWnO4PQPhN4y+zIQjaSC3n8okqtsrRimch6e/+Y+lEcm9uW5fI0bJbb6TyqaDwboZOPhC6HIjN5AvBBU4z65dPxKzsV+LNjD7XsQx476bEuzLWCZUSwfkiKz7Z4UJAWfhBnJOdKlYnef9FlfB3ymmH8aQKlDOqjac6qRAB9fJCzmPtQpFc/KPRTtRB6SRHv5b58/3KBUgKGSeuiQ8Jo//Pt+yo2Wojy/k8I9JM/FgVTkpDB3lfy53T40sdlaGtjmVBpVIS1AtJr2TOgl8svIZ2HfyMdEqIn2QdY0eptIDS2H6874tTDyUXKutqeKMHPYqwz3pIe0PSLJCPweTbixMHbMjzcs30xR9xn6pKNtckIr5m6VO6pRx/Z6hBo59E0uXpk8FftlJJxXxLFMcckT8ztC7AyxydiNLKrX3N0vRL4CKBT3FxP+4edzgo28/91zvvz4Mfq0E0Z1ax6O7byHi/Kh8Y4KfZcJjWbsUDrQb3PKcUfrMuppy6xuJY3ysuTyshK996znR8nguQ/o0VlgdzXCTAbcztKtClzlOJpumU5bcuPFuHhbsNOBR4s1hXXs+pwQFI9nKyGReElQ3uwK/tLTL3i5XbDsS1ZdyY+Xj8m1p+lyJnXLbNKw3pVoLVxviiDknKDQ4wHfWkl8HYRypWyUQt0Lb1wlf5CvA8oG/ATwCndeQRnQu70PQTYTvgrolSVUXqQ6uZgb3U3JWpVkxy2LhdBvbs6nok3PA+tVxQ/eeyPa6T5jeTkWc7/XhMkAg8ZUTvT10yC+ABN4vZ6xqHZoFflifcS2z+k6i/ea+/taitwgmvLTkw3vjJe8WM95ez5H28DF6zm69ISgWUx2+KjJqgFjArebmvaupFy0tJ0UppOpBAV1g2XY5NjaJcpLoK56fNCMT7cMzlDmA99ZXNH6jNfrGZ0zrJ3mO08vsCrw1f2C1c2IydGOrrf0lxXLYSJm5nT5yQrH0GQyVU8atX6TM5hAUQ9k1uODYvV6Cs/AeU1WOrbbkvG4QevIYrRj3Rb0mSWsMz55fQZHvWyAUfTrnB7kPNCR+p21IDy3OW9vZ7y5mRGDZjbd4ZyhKnsm79xxsxzBVrbHbpMxO9uwcprqM8F0hlI06qDE+7ASdnq/CJAH2ldjfmpP2W5Lnj2546jc8cPmOWatWW9LofzcF5jz4V+igvrTeQg3/k9/zK3+9J/iX8njG12kz371mrcfnfH8v02fWiXT0X3KpArpZEnDFykSFK4QM2C+jmzekQJ9mCDkhdOGuMuIVznNiaK85RCZvjd+rt/VmAHqS/mZl/+maDBiHpn9SJFtZfU/1JBv5PtG59Ih7Kfh8CB7gVTsZOpriMd4KJaiSdi9wEHOE40YE/NBONWml8n7XvZhBolan38iGt29+W3+aSRfBXyjDkE9zbFIhlTQnPxhSPpcJamrxUOSZncsHG8/FUlG+dZSXicUYORw0xrGsP1+j7mWi1Rxo8nWsPlBx/iPC05/X8yf2ptkGBU50TBSBxzeMNaHotD0okOPRmQY0SjK1/FwDOsL8EWaBKeCfM8997m8bttENs801a3n+iPL/FOZYgsRR9z3IXHhabVMxbYjVCnT1T5HDLATj0laUdOKVKZ5EqjONee/IR/HvTzDdGlbs5H/b+eyaSmvZRtgOtG8t2cynY0KfBVwUyheSshNeNZy/D+VdFM5ripxt2efPfDzXSVbj92zSLbULH43w3SWSS5ypYM+MJfjGffbJjjQkKKSz8OQiDV6IJFQHs7RYMDucYWp+HaFBCJFozBtxGcGU3DYduzfTzFfp81VBb6VP9vr0A/T6iD6/31hvjfHymdZXkpxJ+dcSEm9uk+vJZl592hFk5qBqNPmaiwd8T7MylcxGX4hu9cyzW+Sb0U9yJ1iCsXS7b7hl2bK1XIt2U//24U5/N1+FauXluF4QCUNM2N3iELHa/Ta4EceBs3yVsx2fuJQg8G1krSYzxv625LdJkNVDp0FwolM25WVwhIgjj26cIRVTn7S4L0cYH9TSENtImbe4+9S+NBWJrYn7y25ebEg2sCXL87ARNzWMjre0bycSFHUabzOxH+ipFBFR0IZiXlgutjRtBnBRyZVy+ANfW/pcsvjoxWvthlKQb3Y8Wi65q6pWd7VPDoVzrVSkX/jl7+k9VZMpW1FaQd2Q862L7jscgmhKTPcLuM8zHA7i8490/mObV+IVMUZbq/HKBO5aKf8YP6G/+HNd3g2WXLdjLjd1EzqlvW2pMgdrjN4bfDbDJUH8kc7ssyzPR9jJimxNdF2bOGwVpItbebpH/WY3JMbaU6opKBX6bqUv7vhbLbmxZtjYi9a5TjIMMket7irCnPc4RL/fbisuHtV4yc+EZ0UUQlX/w8/exedJ2OuiRTjnlnd0ntDjLC8GWMKT123dIMVE6eK3O5qBifvhbWBX33nNT88f0JRDRSzhsEZus5y3s6431Wcjjeg4HixYZgZRrl8uHzQ9IPQuSJgTeDk6ZKmy8gLj64jbW8Ppsl80uOd5oNnV7y6WRCiot1JGmlwipvNlP/pq4U0GzGd59XAF9fHAAy9hUGzuh6Jz6YWapC2ogsPvcFbaRry3HE83nK3rQmJLX482lLbgdfrGVsrZk/XCiKyKHtWy5rYGzZXI6qjRgKsTndYE4S6kzTv262wXKMX3Of2tk4ytIG66uj6jEm14/p2QvRpe6kg9gadexaPV3TDA6t/mMZD+m6wci/NLjNCKdcaddQR7wrMTrPdlmS5bNt23BsAAQAASURBVHVy4zl6716O8cUYuzQMxwP+cfcvVDP92ePn//hGF+nZ31pwepxx/n/e8Pj/UhLzByap6VMRoxSmF03y5j0OenFZOwXwkoBZ3CjMd7Zk1rMLmu57DbvW4j7PmH7xMGEjRrojMaEuv6WYfxK5+Pc96Mjx388lkTSKlKG00E1Ew743Pu4ni6aXKdy+aNoX39snisnLmKbHHJItg5Udv4rxYc0/FhNisRT5BDyg6ySQJyapQTzo5ZVPU/t9rLqX6WqZAnqiVpIG2UmzM3orwTz5JpKvpbm5/Z6lvIXqKrJ79EDMkcCgwOZ9KL7KpUBOFIZhCk//ToZ2Xqbl7uvvhWizs40E5eSrwPJ9Q3sK9bmYSM2+EPPSiGQbL0FBO3lvQ5s2DlXSiBppWuqrQHOkGWpFvozcfSiu+vZYzLXFMjL+SqRJ8h6kKWrGobkJWSQWnqgNutf4mcOsLL6MzL51x+rjBbuPesY/yukX8rrK6yTvcLB9JvKe+U+SUXj1sObMdpHRxcP54UtzCGrqlcJ+XNGPU6DTfmo9cEgA7aepARtg/hORU4m2P+BKw/qZZvw2pII3MduDpIjCw7EvVoGhloK7nwq21HRS3CovrPViFUTr74XL3k3FSelqfZjOt8eiE9cD0my2YIeH5oIkU8nXD14DOe/kXBzqB5kJUb5nqGV6Xl496MVlJZ+2Y0nm5Cs53nu9uy+kQZJpvDoYs5WTJqJ6K5r1/ffvHsMwk/NeDyLx6mb6UKhrJ9uG6iYeNnObDySsZP5JPBhh9yjU/e9otgaCpJcW9XAIz7GjHmcyQc8VaUJYespxj/tijFs4opdpnh4NkiZpA2FI3U268auTjnBbgA2S/pkH+psk4o9KDKhbCepxKY1zT3dSXkmBngXxjCSOOiayuxgL0nFv0MwDES20ixR0NH9nCcC/cfqGP755zOAMV+dzVCamv5uV6HIxEVM7RkXPzXaENYFHpyuGoDmdb2id5fc/fU+uYZmw0NeqYFJKJHvXi5kxP12z2ZbSJKTLcmE9ZTYwyjvGhcGNDEPQfLVckGtPZjyv1zOaLmNUCsoQBUpFRimcqZoLhtL1hn6Tkx839Js8fR2CxfSaZp2jWkP2zppuVaBLx3zccLnLpEBPTWd2a9EngZc/eUz5dMvZ0zUXy4mEAX02hfsRuohCsXFKNgqVBxPIs8Cwy/CZNFZowCt535VMv7vLmous5PjJChc0xaTDDYbV1QhTOYZo6bsMpWVa//2n53x6c8KXywVlMWB0YNsUhKj44OyGq+2YEISuc3a6oh3EQLprc6qiZ1J2uLY4TKytkcnXblWx6zR21uGaDJ17RqPuEEbUukxkTL0lyxydl2Nqq4HxyYb7qzFoRIq1KQ7GZ6Ui1YlMp4ddhk3FuNGR7bYgH/dURc+uKWi2OXfps2CNx+jI67s5/TaT1N2nS5SKzE9vWXcl13djJtOGfrDkmZPk2V1G5xVNZzH1wKjoud2M8IMmdibdewWfGbxmWBWsX9eoJy3F1PG9d89ZdSUfza45byaMs55Pb49ZrisJmQoZR2dr7mwyPncGdZ+hklzQ7KQ28I3FeBiOHSZASMf75WpOYR1Nl4kh+9nA8WLL/eX/yuLpT/XxtcHQn+rT/OsxSv9GF+m+0mRt5Oj/OhLudvNQhIipUKZm3VR0em4kJBdXI67oymPPZRe+e9+RB0XTZvh1ht4Z7AD1eTwU53qQovfox1Kczj8Vzfrp/9dy9RuBbCfPH+EQJGM7kcX4QtEcS/GQr8UwGiwYzyG4yACzL2QCrGIyC0YpyLQXXf0w0jKpfqxonkZJonQiLzGdFDHEBwrIfiIp9/R4mDTvp6+HLUGQ6XY/VULIKJRMrZUUm9tHCjOIPOjkhwHTCUe7vpSGJBjoJ5p8ow84RRAU3fwTmdbuw3b0wQCaNiDptbYLnYyqmvIu0h1J0Zdt1aFIv/kVzfRzMV4e2NWkBiQZgrWDYAS/6DN1iG0evXGEXLoZ0fsrhlp+9uZdMcJGLdzj6uqh2AqZwT2RkCezNJSfZWL6qWD18SKh2jI2H3rGn4v5tDuC9tlA/WXG2T+Was3n0jjtC2MV5X0IJk1+fcS2cPFviVzh+Hcttou080Q7SeeFq2RbAlDeiJTKF0kTrZSYWQcpnMfnke1jzeSlT9VGel/KhyJnz0G3bcSl5NOQiZY028n7Mf+kY/08p75wgsNMcpDNu4qz35f0TV/t35OEp3TCdVdrDuG9e8kIJElXkrXsz0Ht5b9NJxP1/efkkECbfo4ZIHhpdE/+cMvFb4wOTZ9t0vckkkzISajO9PeJv1/dyCbtwLqfBkIWsVvDMJHmQ4VEfjEyTc/XctxE1hMpbqWhu/slWPwkNeBJRraXyMXHHcfzDVefH+Mqw2TaEKNiuy9KcjEEApRVj/ca+8EGf1NBISuEMBgxhW4zCZ0pPF5rySBYWVlCtEamjUlDni06hqtSUkpHIrEwpRMG+/5Ypmh7Eqs72ij/7lJgkULkGVGhl1bClnLBMgLc34yJg+J/vPoOxbQjeI3KvaRI7jXxGSgrkpI9anFWN9xvKxbjHc2QsUs8bQKEztICSkOZD9y+nkEe6FYFygbqaUvXCbbQO826Keickemo0+jcEzqDLjz/8Pp9Hj9aEqIizxzLdUVd9UzqFk1k1+cYHbjfVJzN1xJxvx7Rn4v5L2wtatYTNxlxJBtE8sCQQoiGTc5la3mc2N+XNxNi5jFPBrY3NZSB9rLmq/uSYtrRdDk8afGtFIN60GKqz4IE5hgxsB6frVjvSvxg8IMmn/YcT7aHYzWrGzatXOTLlOTZbcWP4huLygKT+Y5Me9ZNyXUz4jsnV3INbeW1Dc6gdeRqKxscrSOX64kQWlbpQ5NF1CxyMtpyPN6yOG54tZ5xVMkFKHsklJz7XUXwmrxwvDO/J9eecdZx29WSmmkHOm+5UUKBsSaw3RWgQa0sjVNymw1gVhb1SMgvwyZH31vCI8942jPKO7QO9IPFecNispPsjai5uxvJxNtEJtOGcdUxKxvumppdU7DaVLgUKDWvG7Z9zv2qpq56illLmQ+EoOkGy9XVVJrlTYYdDwSnKBYt3mvKqqc3AedK6A0vvzxN034nBKM+oy57NtsSoqIsej46vuanV6d8590LPnlzhsqCyFtG+nAN9hpUr1GDgBWq0x6tIs2Qsah2DMGwu6lRvSIEaHvL0XTFF/zZ4xf58Y0u0k0TsCrw8n+vWPzQYJs07QsiKwEwu0A+QMg02VLTHUXCSU8x6vHbnPi8IV4WjB5t2b2YiB6t8LAzHP34gUceMkVMLO3tUyXph0YdisLj3zPoIRykLL6Qm/nNr0B9rpl+FRidi5xAu8j9tzXlDVQ3P8tnBtLNKh4QjADbpyKtsNsk03lXirHhl3aolxXFvUxW9/pZN6hUlIu0IutiQgOKsTIamdZunkqxPv8scvdLMP/pHm8oU8OoZAK9N5/KlB7a5xJgUiylUI4GyjtPc2IOzUW2hrPfC4fiEuRndHP9gLH8GkbRtvI8xdLjc011qYSskxI7t481Rz9ODU4iJgxjTXU5EDLLUKvDz8hbIe7008Qo72TSOXrrCJmmOZID25ymnzMNzP9EJpR6SEbFZNI1PYQb0dWbVrF7V9bR2b0YN30U7F7xwqTGByZ/6FnfJj24FzLM+rmiuFdMv/LkG2mKVIBYfk2uFZH/8YosbQlMJ03XPuF2b1QkFZ57ecgBF1hCtpPzrJ9IodnNtWxuQjoPKjkX9szuYiV/V107lI+40tDPDXbr2TwxZDM5vt3CYnchBYRJw9pNDbaV4l5LDhbF5qGZCJnIeqJ5kKbIa4oHrrs0IfJa7E6+NtsmWUsmMhSdpC39BGL6s8UnHSh5zzL/oIEv70Q+Now4NDb76X6/kOfYPpbPqPIiJdqbS2XTpdIGIx5wjiD/vQ9+cqVoSFXyKYBNTZ38TJ/D+Ht3VKmIMscdWe5YryqUioRNJlPXaSd4Ra/ZbGvyaU+/lqI1rwZcb1I+SPp9dcCvBQWoKwdNnhjMCjUdoIbYWvyrmpjwm2oluLa4kcJonzp8eGQResF0RhOhCkSn0DtD6NMEN4+4Sr5P9YJ1ZS1M6agC3XV1KPaFNZs+9E5BIyjN7j4HG1mpSJE5OmdZrSrCYIhOUUw7CRhyhv6mYlcMlMfNQWIxKnrawdI4kTpUZS/a4mrH48ma8/WErs9YHK9Y7krMKHK3rVCIhML3mq0vyOYSXLEY7Vg1JXXV0zqLURGjg4RGmUg26XFtJrIMkOPiFd2yEKb9zmCPe25WI4brEj0oxu+vKLOBblNgckdddxgjTco2FAybnGzcczrfcLMa0QeNNjIg0FZY6DcvFnIf0pHJvDnIJe5vR+T1wLRs2Xa5aMsVhEGjswAGpjOROm13BdYK1/x+V3GzHmGMGCtz69ntCmbTHbkR4+2uyQ/npRoPVKOOEDSTquVmNwLgtNry/uwOgNr0WB1wQWPGAcZbNJHL7ZjBGep84LTesNxVXA4TMiuGyMEbeZ6gyKqBodOU85YYFCEo4khjM8/pdMPbweB15Gi+w+jAl29PZAo9aHCK/qzhbL7mdlPw7NEdV6sxi5E0gG2n2LbShBFh2GWY0uG2GatxybvTe07qLb03XG/kd45Rkll/8NFbrpoRm7Jn1+b00dJucugMahHxvSE7bvGDxlSDJP2uM5bDWApw4ynLga4Tc+0fv3nC0Fo+ac4IrZXGooxQBNxIzjXTaMxW4ycBSs92VaK0SG02o0JSVAcFY8d03vDR8TVlt+L3/sXKpp/PI/w8Jul/+k/xr+LxjS7StQcyxfv/faBbyI1a+cjVr9qDttSWiu1jxfSFTKuLW4W+KIi2gHc8s/fuWQK7FxPCyGMuC8LUodzDlBklN+m9xnn8Kt2E9lPJDG5/EDj5/YRhNPK7qQCTrxT1RUirmaQRBhY/lf/vpwp/oqiuI0OlZGXvE8WkEFmNbSKTFxzSTUGSEK9+06OuysME2eeJHY5QTPqJwedSCInGNpBvoDkSyo31UgipAKNXLWexZPNM0c1Fh734iUzffS4F377xGEopZPKVFFHNiaa6CmwfWVYfib57+qVM2vqJQQUxhe61zfk6SXJCIngUSfM7gN3FQ0FvW9FD7yf/0xfhMGWNRkg7pgu0xxbbRIplTH8e8IUmXweKO5EvgHzP9onFVSI5sVuRMbgSgtWs3xMj5n6LtmfcZzuh6bSnkWwF5bURU2MqkusL4ej7SqQcppMp7N4YuZ/gdu/1TL/MDkFByos8hyi0kO5Inp/aQ6+5+jXN/E9k8wPgctg9jUw/l/No+1jJMUrGTNNGyNXhd4tGUd56Vs8N6+dyDI5+EkViZRX9XDSSuodQWCYvAv0kl6ZRyfl0/hs5k5fyeoplxLRJk4y8Tl8+BP5EI+9Zn0K07I5DUmiwHCbQIYNd/kCSKe5SkZy2T9t3IosfS3Np24fi3bfy3tsOmqn8+fKDQt77hB1tFyIp6sfSOJqkdVd5mupHaUr2ptbZ54FhpOjmimGiZRsRpYHI1w/XGlfJZ0B5kUiJWVPkXCpA9SJD+XjYCu35x/1gadqc/rYUM3Lm+fPvv2LVF7y8WUiIzlc12QdbrPX4oPH7MLC1TAq1itysRsJSH/X0b0YSUqMjOgv4uSO0WtKHe4NqNaSI+fxCvA0A8ciJnKJw9JtcZCtAaKXQphXfhYqgrw3DVM4D5RRxKt2XUhFVBmJuJLJ95EBHuRSmdEeQTaUykenxlm6wuN4SA6kxifRvRrRloFi02MzTbTPyWUe3LDBHYuqbv7Pk/nZEMeqJQbG9GbHtJ8QiUB41DIOhLnu6wdJ7yxAMSsG0brnb1HRNhraCocwqx2y6Y9vm5NaLudEZrPF0nRBDxnXH3aYS3N1RS4wScpRVsvoJXuMjmEIK6axw9KuMYZNLI+SVpJSqyKYtOD1dsm6EzapVxEdJOVUTMQ37oOHjMep5y3jccL+Z4geDTUE1amegCqxvRsQAKw26EDPm1WZMnnk6IybeybwRg2WTsV5XuK1FeYWfDDJdrqMYHlcy3WXc4baWTVbQJ3oIEUzlmDzaoHXgZLTlvq0Y5T2X6zHOGT72p+gkoRmcodnlGBvIc8fT2ZLaDkzyjp9enjEpO16vZ1T5wNPZkttdStbVgabNKcuBed1w7jVukA9/8CnQajC8uZwznrToScQoaS6qUcfoqGe5k0Z3Vrc0Q4Y1gVdvj6jGHRdXU6bzHYUV/GLX5mgTqKYyCTfTjuVdTZUNdM7y62cv5fzxht4bPpjfctMIFtI5w9BZkVchiEeAyaxhWrXcrEcH7wd5QBeyxdne1JjaUdW9eALWOfWiocgd67cLMSAb0PeWeNQznTUsL8fklxlqpYUNnwALdtHiB9kAxJl87XpT8kcvn+HWJ/8cldKfPf63fHyji/R2ocnR6OrBBGl3kX4WYRHZJtSfaRS3IwlDaR7LlAQF2EiIihiARY++zyXePihOf//heUwK9aGE5Xua6RdS8F//uVSU55Gzf/Qg3Yi5YnsqN/HZ56kQ40FqkK9DwvUJWjBfJ1NeJ4W8ClJEAgfu+gG1FzhMls/+vjnomoUFnRL0DERjDs2CL/aTQUXWRIrVPj5eCjGfK4aZuM5HbwPVlTqQbc7/Xcf0xxmmk2JROyhvhXIyjKSIMp2wxffyhKwlkVrMoVgcRjoZeuV16GHPe5fXrXySwFjw6TWMziX9yZUaV2pUCId0xmzlGSohv2Tb8JAUauT1mF4OWLQqbQGkgbE7qSinX/Rsn+bkq0i2heIehok60DwOxzolwtktVE6Llvk60pwKTUYnOVF5LbhAlEzN83XEjeHuFE7+SH7n8oucqCLX/3HDfLpj2xS02xxaw/v/XeSr/6Ph7t+Q31vVDnthyTfiCdgTTGafynFvzhTFnTx/3qfGoHqQ9mzPFOO3QmUpbyP1pXDzV8+1YAO38s/4paK+FOzl/jX3E30I96nPobj3bB9ZQgbtkXnwEyQ/Q0x6ftvIlmPfOEQjAxXh5ktTVywDl7+m0X3yQ6xh9S2kgE2scruTQntf3OsUeBQKaLPUpGmZpDenMHrLISMg5NBP5f2IBppFMpAqaRqGSaLPRCnUV++LfMwXEe32WxT592AfGkY9JEN6Mqvutf8hl8Ld7iSLYX8R2H9f32X4xlKcNHSbnP6y4kfxMX2ToVQkrjNiGQmvR/QL+UVN7oWNPB24eDPn+PGKshjYbgtCa2HiUCYQNxm+M6InLwKq15AFTKsJsw49CfgTJUx2QO0MsVB0rRF5RS+SEHSETkMWcTNPzAK69MSdRdWO0Bqqz3OGWUzpyDIBtFuNyzWq1RJUlkKEsFEIMzoeeN7GejFXJqJJqEXT3G8TO1VH4pc1uVN0WwOnHe1acIDdNqeetMR5R1X2nI43WC2fk3ne8vn9Ea/fHEmIkVPoWc/Z8Zq+7Gm6jPlijQ+ay8sZs6MNq6UUi1nh8EHQgm2fMThDnotGud/l2HJA6chisuNuXVNWPdtB5DrRabpGUlhJU92YELSrl1OYOKpiIESFD4rtfX0o7LUJGBO4fLmAU4cC7s+ncv0LQo4pph1Mob8r0eMhpciCyYSN3vZSmBoTCErROyOowywINWjQQpC5LohloFcQvSavhaffXdYooF8V6MIxGnecTdZYHWhcxv2u4r6tmOQdLgpmMa962i7D+0xQr0qaBmvFZPlmOROpzCAm2dfrI3ThKcqBps9wXi7+R2MpoI0ODF703tErstLxzuKe89WUYTCMJx1VNnC9HpHXnuu7MWGdsbU1KgvMFluejEWTX9uBcKJoncUdaS42E2KEWd1yHyuskQa4LAbKzPHk8YplV7Lclfz+1TNy69m0OVUx8KO3j/EJ+5kVjuhkqKIzj9tmuKDoi4xp1VLkjtWqEupMBtpGsqqDCP02pzOWGDR2NNCsC5quljDcQTE86ihGPUYLwUdl4YGalntoxdgdnMbmnnHd8Xx2x01b80vHF7hgWK8CL/4Faqafy0PWfj+nJ/rFf3zDi3ThoOdLRfMIqgsxas4+RlK+0rSsm6epaITiRtMvZGLkR4H7FzP597lQFzAw+5HF7vzhprwvWpojzfil3KiiklW/oOQUyoc09Y0id3gF/ehBxhGsfJ1NshNXqkPYkSRpcii49xPGYOX7y3tPcyx6332h3x4p6suYzHbC7d6b1iL76bRMX6NNmwAjU2PbpsngIPKVaCSifk/Q0J5kpIT6qCH8OzvRxQbFrsnxf1hhG5h9GQ5NRHEP26ea0Zu9OVZ09Hb3UKzb5oFIAmLIBA54PduJVEl3gWFi2D62rJ/D6I3IFYr7h+8dKn3YGoDQbPqpQfcy9XUR8pWXaW8lOvmYyZRwGMP9R2ntn46p8klLnTJXfL439ibfwJ7YoaE9VgfN/Z4yEhLPO+QwfiMFxOiNvM83vwL5d5a0ryc07wZUZ1jvStzrmvq9NX/xuy/58e98n9N/DCoYwOBKaaiiSvIWwGXyO7ha/n8Yyb+XN0Ia2Us3XC3bnuZEM/3K4Y9swnKm9+pWfl7WiPdgd2YPOnRXJgOnSpPoLtLNDWaIZAlnqT24Qs7rvb583/BVV+Hwnvg85QCEvQ5fzLzucYe5zrE3ivW3Pe99dMHLt0cSNnZdcPp7otM3w/51qlQcynuHTpr81AjsTkXbbhsgQH4v50vIk9a/BXLZdOh0TdhvJ/bXeRWl4YlGtki+DrjqAT/oS2ky7n8pMHqh2T0WLfvkC5F/DRO4++XI6e/xEJhmI6NRy3I7xg2GfDTQbyzdfYkdD/ilZAZQe/RVJtrxwuNXYia04x6H5fZmLNrzQUEtBBGdexgPosFeW7KVYFGpnWQWLDMZbAdQtRecZxbILjPc2SCylCivX9mAHTuJXk84P20DPp1npnK0Hwb0TU58pyX2Ik1xYw9OYRqN7tN1+CMnJJOdEYNba/BJVqMGRSzDYeKodCSsM+qv7AMrWkG21bh1JT6ZiZxjzVLkPX1WsLoZCSpx5MknPU+Olnz3/bdcbcdCv1hWnF/OUFoMiG/XJbHX6EazWs4lACoL9JlFVQ5q6HcZzkpAThw0pvTEoDmeb8itI88dZT7QZnlK9JRETO5ykQrVXgrpoA5Gz+W6wmae3boUEo+J9INmfrph1+TkR+3h/Ou9FhZ7a2j7UoKgZgOqdhgbGAb58McI61VFWOa4rU7XT0VfBcLIy/OreJDN2a1hyOQ4ZHUPH4/pn/byXkwd7AzZy4rVO5b1xRjywPxkQzdYttuSm3aKygLjSStUlbRdKGYdT+dL7tuKEBSjomfVlJRVj8sNRgcmVcftqqZZitFXF57xVCbfhXU0Q0amPVnm6dI0/Hw1JbOeGMEo0bprFcmtNDcxpb5mlxlL4JUJPB6tsdqz6ktCukGulpXQjNK2aBgs2gS0jqx2JTfLEVnmqUv5vbtlyfRkw7YRidC47lAqUlpHO7JsmkSmseIHKcuB55M73ugpm22BziNDa4XaBOTFwJMnd2y7XDY9jZhYqR2+17iFw+aeqhjIjSfPPOt1BccdIYUXeatlMu81IDjJ+66kHTL+p598hB31GLflzx6/2I9vdJHuS7AR+jkHycd+2hsURMnC+Bkcm90BStM9cuAV8/eWhKBYfzkjThxqbRnGsHlqZAJrHoq3YSIabNEGq4MsQEWRWUjBJ8UpEbojhX0rxcruVFHex5QYKAXOMBLMoUpmT5luJ2OalimhbSHfJgNXIXrc3Xd7Hj++p//vzrBdkqMk5CBIcbI32x141VolOogUWMUy0E/1gYKjnRTuygvSsbwNuFIx+b9NWH6ocN9pyIuB8bhl9V6O3Ri00weCzOq5YvstJwYar9jcGfpTT37con4yZvFTaVp8KSZN0wmto7qNh657qDX1Rc/mWcHmmUL3UlBmW5l+u1rJJBxSCFPElfqgac+2IitytcHliiJCtzDsPQXdTF5ntk3N0X67ER50xHvKyKFgT4+QJXmLElINpHMpPjC0D8zvQ/MFjWRxsLscoWY9NBZlIpn1dCNhEK8GWYnvzaS2idj0/DGZPbWTf/oZZHsiSTJGDrV8bb7hQPDZU36aYymw91NpMX0mHv9++aOTHwB5PpGJRKJPDWamDuennOdCOohaHbTyxJiILLJFCIm0pBNC01Wa2+8rpp8ZbNkSyaXgLjwvXpzyzrvXvHpzhA5KvA1HJoUlcZBamVaKdJvS+oZJwlv6ZDBNAUq2lWOzfy/3+M79Q3dJqjI8SJH0kMK7EiWJmOhISiRpJun5j/4oUZjelYjv/fWluIPyRtFPHjTuutNsNqU0MLcF9tEOokK3Ch+zQ3gRQeEWQgxS0x6PQt9muCvhijNyok+OUkSSiltKKQxj7RkWPdzlhM5g5j32s0qCdkCKtzzI84wTEzyKwS70IhEZUggWUYnMo5XzFETmEXtD/nwDQNvJtVFNpUOLRx3+umR4d0f1xyOaRzJN1+MB9bYknHVEp+V63GlJGE6m7HIt5+NeJhRssltoGJ63mNzjUlrpntE99JbZ2RqjAkMwXCwnuEF0zlpHqmlLc13z537pK3Yu42I9YXU9Jk4E9xd1JLq0YesNbW9QViaWRIUpPf42h7ET4ktrMYVnty6IjUX1CtVZlJNEVrvS+FIRK2lAVOVYHG1RKtL2GXrc0aoUMqbg/tVM3k9kcr5PYN4bdPfvg74o8FVgKMUQHAeN6wrIAnre4wr5HQ6PCNmdkc/5YkCvLMPCY1caVxl6Z+DJgLnJJPl2YzEnLV0Q7bMqPNFr0b0nVOFgBB+4a0SeYo0nG3us8bgounelIutVxftPrrlravLM471mmYyvR2drfFA0Xc76tiYbDTTW82i65sXFETYdi81NTb1oaJP8qHOW75xc8Wo14+JuSpZ5jqY7LsMUP+/RwM3lFH+ieaum5MazbouU3GrQeIJSuG4fMKLIreffee8zbvoRF7sxzZDJ9qJwPJqsOSm3XLcjOm8xKtB7Idy4QQgwNBrfGjbbjN/ZfIvxpOX56S1v7mc4FclqCUFqViW7WylAVB5gaynOdsSo6MkltXdTkk23jPKO2BWMRoLP7F0mvoAiEL3m2ZNbjsodt23Nl29PiIPmvfeumOUtlzdfu7D9wjwe7ul/2k/zr8PjG12k5yswudxYdYcUM4NMQXVCMQ71w824n4GrZa1u7y36ww33X82IpayLMZE4c2xrxS6LlJ/llLdAEHnB5GXiJiPFy77I0UOKDM9EetHNdMImckhYjDZNvy/ExOhzMTm68oHtLVi99DMdjN88TOC3z6BfBIpnW9jkXFxPCf/mgNJw9vfsISApatj8R1ueH9/yyctHlJ8X5Ev5me2x6JWLO+inUmC7UlHeSnGbbURjLKFL8hpVgOMfRfhRQTetuPsVIVx0jx13Z2Kiyi8zWfvbAIOB2tObiOoVP3j6lj/wz7ijpp8H0bx6eR+278pxffIPvUyjM82rf68kGqgu01S4guWHitlnIufo5jJl3Tcho/OHol2QiSJ7sY0YB/fYy326ZUzNnMhfOOi5D4jKNKH2pRSA7ZE0CgoELziOZCsp1IaJyCpM+2DsjBqyrSfkmslrz/0viVbRTAa0Cbi7nIhlBygb6ZqMf/LT5zxKU/BgZbuxxwj2oweZ1D6R02dijMw3gc0TkyRIHttFNo9lKrn8UDN6LYSbbiqJh76E4gbKe5EX+UKm9UOdkmyzh+faU3H2U2FFklMpmXA3x5IHkO1kuqeCOmxKTKL3hJEcf1LBPPkK1h8AX4woVvKZjJc5vg68+uIUvKJ6o+jHOm1cUhMcBM+5eyyNW1TpeIcHVKOYY1OjPpJzvLhPn/vUVEWTMgR6+Rq+FnYUk1ZethGyhds343us4/41Rw3jL9WBdWySdGdvZt5/fsPMQZsuGJWn2+SY4w6bi664v65g5Kg+LuhnkjZofliz+3YvptBeoZ7IZC02Vgo4FdGlIyQNr7IRnXu0CXgFppQiYZgH4tihl5ngEksvmlYnvGeCEvPonu3tNHSgRp7QGkzlhNSiYvrZmnZVQGcET3hVQSEUF9damSwraJ561HggK50YXg1i9HPyOzBo8jt1aIZsk7YjCrwVj0QoxIwb1xlDJtc28iDBNUspTDefVXSPHPmsk+RREwhe43aG6fGWfjLwk4tHuM4QNik1NKbzu4jYkZPJsNPYNwXuaSfFcuYpq55mIWZM14jZMAyaGBWqcsRCE1VELTPZhKS8BLORgin0mru7XO4rrSZUglKMOyW0Ho/o+ccepQOQYuFLh3pbCnlpOuAReYvbWvEDaKiOduxuRTevbBRTbuWZLbaEoFmbGrWx6PuMcCQfFhfBXuS4xx3ZeGAwe659ztBY8sc7+nWOyTxua8kWgnPs7kvq4x1F7tAq4rywu4/nG9rB8vpiwXS24/5ywvh4xzJN1Z3XWLPHMcHt9QRTOOqqZ3zWcX9fo03gq/NjqlFH12VMZoJE3OvMSzvwZLTis/sTdn3Ok6MlmRYT7HvPbrjb1ux2BTr3HNfCRD8pN1wm/OHvv3kmiM2yJ5+JMbZ3hu2m4P/18XeZzpoDhtJazw+evuV8O+G1tyyKhsEbbrYj2k5O1Pl0x50fkc8knTZ4xUfPLjkqGlZDQVVImq9LTS/p+h69bGaKk0a81DpQPtnSNRknx2uWu5JfOXnLT4bHFNaJJEhxoDoBvL2a8ZbZgZH/recXXK4nnN9P8bv2X7hu+rPHz/fxjS7ShzEHmch+jX0oitNUc4+DCwrMDtrTgJsAOpLHNA1yoi/ZX+iz24zhyOFlwCmM5hspjvZ85MNK+2sFdrBiytQOWdtuZJLoc0ko3N/A92xof5i+J+2tk+cwA+gg8hQjEAK6J478qKVvrYSZtBaVRcpxRzRjmf628lyL//uIta85yxRX/2FL8Y9LVHgINYoG0TGOEwHGIig2JRKbPclCZDDq8JqLVeD4D0WyoP7EcP6X5cbhK1lJ6/sM82yHf1uhW42vA//kn3xI1BH/WDYXw8mAMhG9sqIDbjTL9y39LBkNB5h8GmmPFcWdbBuqS2lAil6aij0/e28qdKUYKIUqIwZc4eXvSR2yZcgSFWdv5pTXK03b9IuIVilB8k62DXIQEsGnF302iCZ8+8s99iJn836gvJTGY/ZZ4Pb7mt2ZFfnEIEmhrhYagBss9lSKtG5ViO4UaBsrko4gDUI3T8Vkmgj7Aklk3UiQVncE7ali+rnw60WyYuhnHN63YQy3vyLnjq88jDzmSgyum/dAOwmYqi4TXQhQ+4CgKP/IlkWMmkP1YO71mWL8VqYlezNw1NDNNOWd3JyzjUcFffh8VLee6181LL57Q/c/nOBL6I4DHPXErSW7tuT3sg3oZvqAXHxIio2HVGCd5FGBJHFJn6E9etE2HAroA5ozST9cLe+9G0lR7Esp0CFtUkr5nJpGgor22xRfyLlxkPfor28tSIFQ6kA2chWCMawcxkb8fc7k6ZpR0TMELRKWgEwpPxgwlaNrLdUXmRRYswG1ssLRtkGao0kvHPRMyYsfNKqSgn06beieCY/a3xcwdbC2hKNeislBC3Z25NB3OX7sJEY+6dN1KxfMuFYwSZjGIE1vDPvzI2DqgW5ViMRj0Jh6kOfzEsbD2Mm08KrCLHq8jahewsHsuYHwwLPfy7i6Uw8jh8nFgBhBYuWbTBJPTRRjZuWEVmM9DqC1WOsZbkqCFykQiCY8FgFvzYFdzj4lt/CwFQlOjKA6TfG9JcN1jcoSC32bo+1DkRm9EoNuY2Wz1ZjD3+lWEqqVU/iJF9rO1qb3a8AXWnTiO7u//IvmOJMNJEGLjGkQU6p91qAGLdf3FC2vsojSgaxyNBcjzFSMtMW4Y7Cy8Vh9MSfOhYevT1v8Mpf7RNq4hGkP6xxVi85+dVdj8kDsDf06g+mA1pH8uKXfieEWJTIZrcS4abNAmwgtZebY6CjEnaMdISg2u+Jgtq1GHTEqtI34Xsyt203BaNyRlY7cenym2S0rlA2sbkfk4x6j4PxyRj1pOV9O6XaZbHxGO252I7a7AtcZvvXsinJ+x+c3x5yUO/748jGvsxn39zXPH9/wS48u+Gq5wHlN21uaTSHa8FI+wFU2MM47zkYbQlR8cX8kCEeneaEjHzy7Yl43HB/d8NntMTdXU2gMofAEJ/r5TV9wuRlT5wODM1TjDpNSTEdZz6v7OQDr+wo3GJ6cLLm4m1AUIidbN3K8/t7H3+H0eM31zQSTe9mI1ANKRfp1IQm4ucjDfGP57MUj4qDJZx3DTcUv5OPPNOmHxze6SN8HmUQLMRWzrk464iZpTysegnACVG8NpoPNtx3utRATUJA93eFe15BJyqPyGjcJrD8Q4+nuaQQdsWvN6LUUT+1RKjSM/HnIIOSB+rWsHNuPOtb3Gdlaka1EZlEs49dILCKVEXmEFEV7ffSe9x4yJTLDyjG8qQm151sfXLDtC+7WNVoHupmivEuJm6l5MJ1MM09/u6A5keK7vJGmYk8WyRr5HlcoilVI5BmNq0TK05xo2mOYfiHF8R4VqULaAOSB/ColY6ZiyJ1XmFYLs91p2XBoOU7VW83ojWb7ROF/fY3rLZ6cuz8fhO1sI4wd7/+Hb/n8+phVMo6N/iRn/b7CjwLluZbpdSfSH9uI7KU5kmZimEjhNf9YgpF0H7n6C4rZJ4IcPP5R0tEnfb6YIOXDvvyWYvKlvCeHwq99aPz6qWxvhgkUL3LapwOqNbRnAbvSLD/UBzNlvnJ0C8tw5IS2EZLOMDOYTGQK+xW9vTeCu7RSvPg6ki+VmBw70eWu3leUN8m7YOSfy7/sya8lnGlvEu4n6X141KOsNJ1xUKidwc2lMFMbAxp23x7oZzkhh9FL8Tjs0ZzAYWrej9XBK2H6yPaJZvxaihif/BNmiNSXe/49Bx+CLxQh8d/DUc9qU2EraQ7GrxXNcXlI7PRlQkym5iRkMjnfo0XzpTTMQ52OVZTvc+m/TSufe9PLe9CPFc2ZEHN8Ae5MmrJhEslW+oHPvpfEaJLRnENAV9TyPMUyZS/IQFuer3s4TtEkWdKQpFtT2aCEzvD8ySVf+WPKbGBStFxuxsQoWm4/lulY9GJg1x2CQGwMYeYoX+R0zzuUU5R1z/hoQ4xwczfGjIbEpm65vxnBRm4HutOE1GmpZSaR9BPRj+ssEPKAcgn3NvbSrC561CpNhkHQb4gcBPVQJLsmkyn7Moc84juDStr4atrSrER/bY86KW57hd2J8ZmYqFdf24bIOa8IvSGYyDAYfGegsWRHLT732NzT3ZVSaO8M9EnDXgaa6xo96w+outCloCINdFo2pEnew6BE5lKIcnmfZLk9H0szlQd8SgZ1TSZSoxQapVVI/HWLGg9CCNPINeuol5qktZjMo48c/TYnyx3+ZkSYDhSzTqRTmyQrCtL0YCAEgyoHFAq3zqmOGlqn0SO5ToTekM+cpIjOeklHjdANRuRAmww1FUSkPupwm0zMw1XSrK8tuIz5d+7Y7griJkMNcl8xxx2LZ1vuV7Vcn5wmrwZCUOQL4dF3bc7RTKRO47oTI2yXkxWObVPQtxaby0Uyzx0hKNrd/5+9//q1Nc/PO7HPL7xxpb12OrGqTsVudiApUpSoNNKIGmPGQbZhwxgYvrDh/8uAfeGbgS/GtjSaEWcoaTRkixSb7K7uCl3pnFMn7LxXfOMv+OL7rrWLAwMSRlKrhe4FFE6dsPde4Q3f8DyfJ2Uyrdm4XJqvrKfrZFIeoxIUZGtRJsifKQhe0fQpJgmEoEms5+jelm2XUtieB+WaxShnURc8vzqUTY3T/Jl/xOGkog+arOjpvOW21UPqqrprFlqIUeFbS90n3G5K0kRkLm8f3PC795+y7nOebeb4qKm7hI+X9+R9TTx2JHx9StjWGcsqRymoOlgvC2kIdWR1NUJnfk8WQoFNPOe3EwCaJsGtU9Ijh3ciJbtdl0xmNaurMaPDiq6zdOtMvCRpkKbZa2mobZAevbZQ/GqS/ov++KUu0qMWY2SyYV/cRiUpgJMvhdqwW4krL0jGHcc4mginDeE2FfZtUJgHNWGTEhbp3uBkHjQSbFF6VOLpVcry7ZZ4k8kF2kTwCnfac3C8YXE9pjnRA84xxb4tFzeTONafHbDxcPhTSDcBV0jxs5M3hESkHHtyxCA5QEHxUS50jYeRbZcxy2s6b1hcjzkaUhVVHAosLfzw3cQ5XUlhraJIWJJtwGV6kIFIod6XGp9FzGAG7EvF9oFMDkVXPEzZBxOl6SV0op96tBtoHK1i+oXG1DJ11+5/9HmpIIXbrcL8f8e4QrH46w0nh2tuPj7Ga0ifZ3wcHkrz5RQqiElz+qXi9jeE3NNPxXR68ImmPpTiKF1JMVdc3/08NWw0Dn8CIFKeZq4FQajVMGFnv/kYfz1IYZRMboUSE/dBT+lSjh3TMpBVEvppZP6RFMdooJL3qx8bNg80Ou/EiHbcMCpbWTE3FruwxLUlnLSyfq/vDIh2owh/Y0n8cIZHDLN2O2yKHOQXspTJL+1+Snzvxx3nfyXFdHD6Q8/Fb6W0Rx497who6LTQN5QUFt5G0hep8MjXipDC4n35NV0M72cbaUdqz4rfyUrKi7inE0Ut71U70YzPHO3USMPXiPk3ajH5+jRy7x+nMGjR+3KQkkTucJYDpjHZDKSaYZjpc5kc7zZYppXmQA+yFbuF8lIkTjvTtenk++seto/kNSUrQIsGeJcnsNu+7TTrbhRxCZhG7X0IBPZa/R0m0meDvGaQUu3wkuMXao/ejL1GZZ6vr+YcH66xJrBuc6o6o5w0jI5XXD475NG7l5zdTEVTnsmk1awMLon0s0EOYSPVosBNDFni0F8XuJEYrauxxd7IrcCPglyXsrDXTfuxR5WOuEykUO4VYd7DZuhStgZsJI4l4VTVhjgShGJ60OA6Ixr6oFAm8Na9a55xRFF25GnPps5oV7LyDxNFe1WgvyyFXb+R5otBOsXQiPQzuVbFb22JFwVmPUwpB+OdGvX01zlokWNlB400tXMpQlUvBQtBERbp/rhWQ8iSuZVCXq0Nbu72EgTUUBzXVqQiILz3XuOGRE+vhum5GabJetdEKUzh8Ddi+NWtop8EaCUC3mwNYVPiEpEqdYvBLDhMRDEiD7SjHrdJoErASEOkdBRijwl0rUVnXn5e6jGpJ3hFt82ZzrdsYK+f953BlI7QGWJrCJWV4/mog2VCzAJkgeRBw+1rMYGSe/J7DfWiIG4SFmqEsZ6+teJpKO7kPUki5JZtm9L3liLvaLwVfCRwOltza0tGWcfl7YSy6OiNoWtSqlr06jaRAt7YsEeMLm9LbHZ3gwhOWPHd1opxWQeqOmU+qlhcj0i05+ubOVoH3j684b35FS4YVn0mMpvBSzErG7ZdupepaB14dLDkQo+xs4Amcr0YM85ajsotz68O+Xx5Kt4AFMVEit4i6/c0mvm44oaSw7Ew9dvW4jszbAn0nqpTzmpCVPTOiIm0tiQj2Vz43vDGyQ3PPnogxyVQbzJs5ji6v8R5LeFHIN6HqOT4LD33TpcclVvONxOc13S9pXGaOFzPf+EeEX4unPSfx8/4t/D4pS7Sv0nl2IW7AIyea1bve0ytmX0+6IdHd9KX7nS4uK9SGHmUCbizAn0iozF73OCucsxhJ3zSwxaberLE0ZW9JLvNO4yJZHm35+zenk0kJe/JirZNcDrBr4Qi0t+OiUlEPWi5fChTsRAVXZ1w+E9z4jDRvzNwDrKXPt6F3hgYfWW43h5zMfakl5bEiBGzn0HIRe+ogiJ/tKH/2ZTiAkZnYR8jL7pnKUBkWi+/H104Oei1aIrbqZVpeC8pnz6PhCSSrDX5pSSBRiu4N7sV3e7sq4hPdxpxaA402TIM6amDQbULjF8F+iFp7egPMh7+n19yfX8MztBpg1pZdDcYGBtFeRlJNp7J1xCSwPnvGE5+CCoEfKq4+Ds9j/8/Riad5k4rrEL8ixKeoZgSKUzcT0l36asgRbB2ccBcyp/5gZTjM5kEZrdSRHYHkdlnagj2kdc9eu24+l5CtpDQnOgVp09uWFU5y8vxPgI8ZDKtP/wnOeNXPSEJ4imwiurEsGYmso1h87Gjquw449FKIe0TkbasnqQkGyEcnf+2bIswwGXGg29fcvbpCU+++4pnZ0fYL8VUGLKhmDgIRKXxhTDu20No5/IzdhKkFoUrZPqYbKGdK+rHgutTNhCdxv0kYXQW8InCT8xeMmRbOYZ3D1cMPhI3vK5497mAICx3Eiv03XSdb2wR+vHduW8GSlGyCXuJ0+IdPWynIOx8CEOYUsjkczad/NqPB2SjhuJC7Yv83fXE1jtaxqDdz8RAXmXS2K3fEilUurpruLvTnuJAbvjH0w1aRTpn8UFxMK7ovOHy7ICYBM5/eB/jIMwC1ZtujyI1lSZM3f69iV7RbVL6VYl+q+aNk1uePz/Zmwf9OAjKcOz2eumYy7VOXafEmSNsErnOdQZ/KLpsrOibd00xiBbaN4bOpSRlj99dn0zkq+enKBuo1hkH92q2SEz7+sdH+CySL+QY6aZ3+v/9uVQM/6XgJh7qBHMkzO70ZYZ/qyY6TegMptbyGopBv89wnIwcv/b+Sz4/P6G/yvdpqkoNha4yuKlH9aIVV81QzASRbKmtEWlILR2XKQRxmI866vORHJBBNPF61uGrBF040d87jR7CnNzMo2sNhx2httjh+DStIj5oCOsEvZXCmV4DBjXt8Y0Vesu0J24S9LgnyRzNTcHoeEu1ytE2YFMpkI0JdOclKsLKj6HVpMc13U2OnvSSRmuDNFvDI3biDTIradTcxKALJyFCzlCvcvJZQ/N6hG9le5FNWoINdKsUZSM+aLQWT8K0aFkOBWi9zmW7YAIvuzlp1ktwlPU0bUKWCiltlHdsKsHMFuMW3xv62qJ3iE5k8u6cwWSevrZkswbvNE2VEoPixcWcdNSzaTKMCWyXOZ+5kz2b3HcGtbTEPJAf1ayc5vuPXrPpU27qEo0kqna9ZbNJhL5SG16rA8GXDtSZYtIyzltaJyXVcl0Qek0xbum8IU97qgEjqXUkm7Si0880Zd5xf7Tm6e0h81FF21uWsYAMirwTPn2Em6pEHbVoLcnC06Jh02Tc3IyHz0XISvePlpyWGz69PGFatFwuxlxcTuVi2WrMpJfzwMT/YArVX+bHL3eRHgAD9T25wdaPHSd/ZLAN5LdaituBnLJLACwugO9u6V6O5AYWZZIRUtH9jX6WUH/fEVOZgESvCMuULg/YuejxcBqVOWzq9heydpVRzBuaTYYPmsPplis3IckdwQsnXHkFVxnqqOXxfME0bfnhl2+QbAM+U6zfEKmGRJMrxl+DyqSYKS8i2wcSQGMqRdSG7mEv69/hoTo1TCQj9VWJKgO6Fz65rSO2Drh8Z8rbb3IHioYiWImSX79hWH5PEDn3/5lgBG27I54ElIf8VnHxNwJmZffTxfpIYWshwygf94FKLpfC31YRn2pcqfa6fBR8fCYrRSIwdhSThqZOyT4uiEr0zf3Y0E0U+XXg+EdSze2mpg//K0s3UZz/LUdynXD04SDLGbYQxolR0vRqX7jvtgxRS5G94xDvn8c3JxSBfbCOT4U3nmxkIplUkWzpUS4OeEeDrQd6zwRs7jh/MRdN/1FDd1VgzzL6455H/7Uh6sD2gaW48sLijjB+6Ri/FCb54gPRjrfHMg02sjXHK2k8JaBrKHq7u+ftc5g+XNE7w+tnR6QPKr7+k8ekDTT3PLrRuPsd6bMMU4tUqzhXbJ54kpWQVXSjBoqKbCHyK5h8HTBdoL/RdDON8gZfBpL7NZvfcay9Ql1nmFoxegHpJu4n5Dsd986gu9tw7czdavc+D5ryvZk37A7wwdC7HrCKSjYaUUtBWN0z3PuhY/nE7jc+O4SmduwxjlGLzl538jwkHOtuEycBPvLvkjoOuvi71FJbS5OXrhTbh8MhY6CdyTHkCtkyZac9k7xlkrak2vPhxUOZgALlpCEZd/SbFPewlWmt06jGoEY9sXREP2zDnELlMjVXNhCnjuAUL87nwmdOEY11OjRMrWGf+hkUatRDlaFvEqKNhNRgrhL8aYfyGp05KRy7wdyZQXAD5aSVIBbVatTW4A8cR/dWXL84gMzz4vkR33v/BZ/+4G1CFhm9kCbP9/Ke9+Pddmo4LrNhkzMK6FbBwhKURU0c/f0Oo8UI653Gzxx21BN6TXpaiRZeQ3SaT57fZzKr6U2GWllC4TGlGGjjPAi2sLHEyoKNmBuLHwXZiuSDxCKXA8umnr6xdN1g8m3N/vQPTs6FuEnITyrRyieWoCPqVib46jpFHYgpSqRzCs5zOOyJrYTSmFoR5t2dfGbeCfM+9xRlR7XOsOMe5+VimuaOeiHUFQqHPmxJM0ezlGlr31jhsteWg9M1qfFcdgfypHvR2+s0CMUFoLKoNDCeNbSdJUk8TZOgZh1pKbKprk5EtqJAmUCSS+gVwAJwTg/SEY/SEAMY64lRkSZSbCdWpuDeJVyfTUknHUQkD2J4aBMIaFxryTI30FikMXM2YqzgBtOyp6sSKe69RdvAu29cyLQ6GCZpy5dXR4xPVlRNysGo5sn0Bq0iqy4jt45VnfP4YMGiKThvEpLcYUYdbx3d8PT6kMNxxcPxii9uj0QnHzXvHlzjDjWNt7xYHNB0iUzPB3ni6dGa1Do6Z7ndFiyWI66vJhBhu8oxSRCp02CgXSxHaBPYbHJG45beGbm/JY6mTdAmYlNHVyX8lSdP+fH5Q86uZ/jG0DapNBZRoXRATzy+0+IlafU+Wf0X6xHl4Ph5/Jz/AB6/1EV6uoFkmLRJoIzc/Xfx6Du8n2isZVq6eSPi1xnkEsWbT4UOMPrUYJsR28eIaWbUywQlczx6T9bRRkdWVwJYDssUU8pNZb3O0JWhHxlZQcG+I+8uCqaPV2y8llCRPBIay+cvT+VYXqac/S15noAkjK0M7YmnPRI9vGkUbhoIB73oLFtNKL1MaUqPHVa7Zli/xlRwWmrU058VJFuZFvel+QvEDkHjiVSlH+thja9xOZRPLYefeIiRbBX2xYttBJVIhPyFxXQ7Ta4UOc0h2FoNBa2wzLWXSWdf7qQpkdG5xyeK9Zsa/3Qk0ykTya8UySajaEV/XN+LXP26ZfJsKPIzKbS1k02AbUSvrB08/H2D6TzrR4bNm5Gjn4AeEl6jlkbFDUSTnSHQdEKB2U/Pg5hV73jaksC6KxSbE+hnnv5QTGO2jnQTTTfWZOvA+rGmPJfCbvqFYmkK0o0w+ZM/GXP4IpKuHT7RQhX5xgZo+yDBNpHRy4ZummDauA/OGr8SI7EKccB2xmEjMEialp4Xv2fRreLwo0h7oFiVB/zO7/6M6jjhwx8/wVgx0JqNTBbtq0yY+J3IEqIBuzEEO0xNe4UbiqnuUcfBpwnLJ5rJCwhG8fB/CHQTLdPXWBC1pPvWv13jA2x0gd0qyrO74yMkQ6Gs7nTfMJA9JpHy9XDTieyZ7bZmj8jUrTQnu9e9wx1GA5PnkfpI0mB31JXde9tP7tCVyUqm73tCTC7F/h6d2H9jm/KNRmGvQdc7BvwwqU9g+0iOKdMq+qlHecX6szn1G1sumKC1rP0PD9fcrEuq21LM65OWvrUoHUnGHZ1OeOvBNc/PD+Wp64hKZfKo00hwg4lMIbxuD+lpTdsa9NYQE41pNSELpJeGfibpoOZRhbvNiUnA5h7zpBONq3L0m1QkDlpQf3KP1fiFQbfis/BFIOQBZQLXLw5Qjab83LJ9z/Hp2SmmhXSlqB5EshsZjrghJIphMxByoTv5UmQkdmXojv1eghKjEtmDDahEeNSH0y3XC9HwExVUWnCSwPrZDHPS4KuE9DwhWEt41BC9wq9S9FZejz5thJRS9rh1ip10aB3pG9G27AKVvNcSThTBD6jUB/dvAdg0GdOioXOG6UlD4xJuRwVtm3A43bLcFgSX7g2h0UZYW5HgmIi616ADgvHTUTCKuchU6iolBg14uiohn7REYHRYCR6zN3RdQrMpSA5aOp9JsqzTYk5W8MHhJQ8nK15vplxczKRZ6eVewcSRvErpH0j6ZZJI5DxBiUTzZkQxbplPKhLjednMRdqkI2hQK0t+sqHThq4bzLMqynNWUrwrZYgRnNe4NhFsZSGaa1CMpzVVlREjdMsMOxGjWNdZjBHttskdxnr5fRIk6TPsJiqySXp6ccQHDy7oO8NXV0fkac9xueVnN2Ner3Iubie4dcrpo1uezG55Mr3hrJrw7fk5nTd0vcV5zednJ5wcbLg/WnNZjzA6sKpzOmf406dvkBU9s7IhTRzrbU5ZdBwcCfXlIK85SGu6YFnVGfP5mlWd4bzhYFTT9JZp0eCDZrEtSFJHlvasvzygeplLAvDEUbcJ375/jtWB15spZxclf/Th+3LNymQr5ipLMu5EXpPsSBVIUNVBzzSr/s2KqF89/p0/fqmLdNNAHMH2LdGg7zWsg5a0G6vhhsteXxotos8tZFLcPxtTnItJb/NbDdymqOFGQSYYsvU/vM9IQTsv0e80xHWCPWqoVjmxM4yeWqZfBbppSTuD7Vsl8cbANBBHnurjOeQBrcDcqwleY2xAm0DbG0GkDfxjUw2UhSSia0VMwCMs3m6iRPtaSrqfqcRU4iceXRvUexsOy5Zx1vL862OZEg+m2b32mp1ZcicDAZDQIZQYSMtLpGkYhJzBqn2io21FlpG6yNFHor/VDmwTCEbRj0Xz3U0GMoQWnbNpB5OnF3JKN9ZDCFJk9FoK480bivYo4v7KBv3nE7pZ5OATxeLbcT993clXQjKEQ9WiAVdeCkufCY8+W8nzev13PQc/SiivAn2m9uhMn6n9dkX433dkkKSKtLOB1vMgUpwLJzu/jaQriNoIUnMuU9OoIN1GdCcEkh2OL7+NFH8EuvNktw7TeraPcvpSzLm7lNSoFd3EsHxPMfsC1k+K/TFsdk2GEo14tnD0Y7P/egl/CbhCU75UQxhVZPwqoILh2XfmfO/oNT+ZddibfKBqyOemBtpJshb2e3o7yK3GkWQhzZpy0iSmn6c0R9KkrR9riuvI5oEZpB+RvtTiryjBflYwfg633w/0RsGFvO/aMbDupWgOAz41v2YopsWTYZ0certNSRwoKrugKVuJZCIqaA9h/olHu8j5X7aC7gxi0t4X+k4m48lGuPXZzV3R7VP5zF0xSGda9oZ0FYR1v+Pe7zX02V3qqQpiVp1+IeeHK2D00nD7l2QlHa4KHr17SWocm1Y6ktmoZmMCXWfpW8t0dpfAeFbPOF9NpChVkXzU0Sxzog34oLh/uuTs6RG/8d2nfF4cs13ldLc5KgnEiUPfCg4VHeke9TJBbjV+U8BMAmFAJrE7jF8y7sRgPDTK2opRLTlq6BsLlRV/TuEIlxnpwwr1kRClJp9afC5hWVEJK3634fGZTMwxkagjyivc1JOdS3qtL6PQZqxMvl0nqZkxKLJJi+ssVZdydLChD4auSqBXexOrPq1xlwWHb9/SzC3N8wnxKttfH7nXMBk3rK5HYId0zlwkH/0ik2I/qn0jZ64T/EQSVPW8o5y05LZn22Ucjzdcb0eUac/r5ZS+l+IyTYWlPipbas9ej56sNN0jufhGp7ATmZTqwjGdVazXBaeHa84uZoTeDNPpQOwtWdpTJGIUvV6PKIuOJPGMTjpc0NwOwUgxlUJ6uSj5sX/I6nKEcho1lmOPrYWRpNP2Bx6TeZqNMEuTQm4Gy9uS6UFFVaec3xyg0kA5aag3Gfdma86ioteBxYsZdt6gTcR3SrT1mWyWnTPUdUI67nBONrtJ4ejrRNJzO810MDiuFwUqFb29GhCD3kkBamygXWWkk47g7o5H3xnMoF83JvDxVw9FgtVr+t6wTOQ9PR1veH96yet6xm1T8GIz25s7Xy+n/NrpBSfZmrXLqVzKl7eH/OjZI2JQlJNWbnnA6dEagG2bst1kTGc1m22G85r/+dsfs+pzfnp7n9eXM/KyY91kNHWKTfweVVl1Kbe3I0IjDP7WJEzeXjLJW242JR+cXPLx2T0+/PIxOpHNxF/9jc+5akqeXR7K+Q8EEwVxqpDjdp2ia/G8Pb5/S6x/QY2jv+Kk7x+/1EV6N4W8B18Glt+Wbvv0B3qvMU7XMm3cYQRl4jt8souU8pXGF7B5z5FMW+gN+qTFrxJCr9HzVow7u2nxMOTT0w5/XsDUYcc95ZlIOnQXyW4V9QONG0eyK41+rYVkclmiOsX8H5V7ZKRPFbM2cvM9mQT6uScojXEKU/aEmGAWsv7sTrxoKRUirZj2OD3oqltNmPV0dcLSGdYmFzzbIhGG88B83skO9sE78U6vLYWJFLCCr1T7CbjyUpx3Y42Pej85B/l62wR8qoeCXabVPrszwYYoRXXUUhzmi0h9fBceM34J2SKQ34rZj5+OpQAuRSZz+NPheWvB70Ur085s6WVCP5LJfbqW6bwaSDl9KR/a5q1IP5HJtStl9bwzC0oBqHCjiKmhvecxleb0j2UKP34l4Sc+EwoOyNet3o2k76wJZxPWb0kRr1tDcwrNsZJwm5tdYaJoZynFTSBdOjaPkr3OPBjRbOcLz/wTzeJ9zcFnQYKJErj9QDP93Usuzmc8eHDLV2dzTv6JZvG+4vjHgfK8o50nXP6W4f4PHD7T+8822UZu1iV/sHgfgJO/9ppXP7lPshYduqk16VKmx6aRgje7hWStqU8FHxkTQWyGVDH/NND+X26o/vQY7RXpMkoIkBq0x4Vi+lSm+NHA5HNNd8A+LEl5aRD60VA8D/kGPht09upOvyw+hr8odbkLZJIiOV3I/6+emIFPj0z+ohh5d9sQb++m46YbJGVGJC8KKdJ1L58xSPNA/Q0qVJTNwe3vdkx+nMrEvJbn5BNpOJQT86p2YqgdH1VslzmqMrz69BR7r+ZgXOGDwuhIkfXEqGh7TdMlbDYFNpVCZFY2tHWCTqLIBFRkNG1IrOd6NYLC8+XNEe8dXfGjmzdFj91YYjakTjqFrgxh3otpstfEmYOtIRbgKylys6Kn7w3aRCAQMy+hQ0qKP9cZGR7kwlL3tRVD6kdj0lt5rwmgerE/+HT47IIYcFFDsvPYi6GzNqLlngR5zg8akaOYQF8lKBMInZgwu0qMf4n1LDYl84lMDM1smCqawPFsy6+9/QX/w7N3CEERrJxvqhum7RG6Xsx7rjO43hC9xjUKgkIvLWHiodVyvexlsm7u1RgbmBaNJE66hGVTMMlbUuNonOXXTi/48PUDXCtkk9PxhmcfpNyfVDyaLPnTz95CrS1x4sjnDdYE7KSl6yybTUFoLOeXU7QNEj0fFF2VcHC6Zpx1XCwmKB2ZlTWPp0vOthPGacs0lXXOapOT5JKYeX01YX09ko1W5pnPt9xcj2Xb1GlCUEIa8mJE1UYCrfpNSjmvhXjSC4pTqShYRBNo+kToIwPjfjpuCFGx7o1IOBtLHxEXtwl01WCUHSSkBEneNNbv0YP5uKPvZOISek3wGt8aKVSVNI19JddHpQN52dH3BmPl+wcnabtp6ogJHI4rzm6m+N6wWpR8mRzz97/1IffyhDZY3n54zX/x5V+i6RKu65LOG1Lj+WpxyPJGkIvppMN5vc8FuF6NAMizntOjNW9MFnzwxjlfVsd8uHhA6yyXyzGP790yz2r0gKnURJ6t5vS9ZZR1fOeN13TBYHXgZ6/usX42Y42cHx85g+81ygSyoqepUv74y7dE4jbkQ2gb9mFXAK5JmD9Y0bQJ/9k7H/GTxQNeXu+ik3/1+EV9/FIX6ZvvtdRdSvHC0h4F4thz/h8Fjn+Q7G+gPpNppQ+KkEF2o3G5JtlKcqfJPOnARzeJZzxqWdSWaD3xJiNkUiXoHmZfROJXMg3THvoypT654yUzSELyc7XH6dUPA2GRc/RDM+i/4zDhkxOvm0i8tpr2aBUJLpEC+FL0iL6IlC8URz8RiYmkRYJP5Xl0U8Xi23IDNJUmu1U0RxHKQLpQ++TMpJYiyeUy3d4lnu6oMj5Xgy74DqO3m95GI5N008rUV8U7GYlPFZuHhvw2DizrgGkVKmo2jxS2lmLfp+DLO91vcSVfv5ff7IrwYdJeXEfyG9G576auO4nD5Ck0B+DGohdNVmKeJYjZNV1LgVqdKkZfabZvO0C00zGJ+FyTPdrS1Qmzg4rlbUloDX7OQJ+QBoMhydUlitV/sh0MVA2tszwoGs7/5AEQmTyTz9Rnium/9PhMsXmoh0YMaTCMGEIPf9qQ1JZmLp+nqSG/9aQ3rYS82AKfSuNR/Wcr+i8m3P7ZCdML4B+dcF/D+e9GRl+LibE5Stk80nSPO85/J+X0h36f5mjaSPhyjJ87zLTjej0iHPak71R0z6eiFT0Wskx7HFBOUd8Du1Xkl4r2UKaCbhR46zuvaP/8Afn/7ZDN90XWVD2Q1NhoFLqF8iqyvS/HUbqJrN4Ss6nLZXOSbgR/GVKZnrvBC7ibqMtv5BefQ3AimdC9ZBxIGqscP5MXge0DTTCyBfB5JF0omkO4/y96lm8ndNOhwNZy3LVzmeLvjrdd46fcnRQnWd9tQ745qVEhcvxPE0li1XeBUypAcSkSnOpU0ZxE8guoq1SmwqkcG+F5yeYdT73OOTlZ0nRy6Z4fbjEqsAzyZmgbWTdybsco+t2oFNtlQVp2jMqW9VBMfHx+DzvqcHW+b9YB4qyX9Mhtgt55VjpLGHnU1pIuNN2hol4J/UNXwiJHASOPTgJuk5BOO/pFiu5lm9I/asm+vgtHI8hn9xewnXtKjqSphiJg1iIDDHmAPBA6TXFvQ1snsgGIQo0RFKUUeMYGfK9ZLkpiZVnboVEIiqTsca3h/HJKP1BGXJ3cSbRKj+o1ednRDfprbQLtdYEe94KPzII0Y70Cp7CV2pu5Y9BoJQ1R3SfMCzH6XiwmHE23jLOWm6YgsVIkV3XKZ1/fg8ZQHC74anFIOaupVEE5rZkWrUACvCEERTFqULPI9fM500dLVosSPaD1nDdcrsacHqy5P1rTuLtbfIiKz66PRVKyTYmFMOljr3nrrUt6bzi/nlK3CWqRoJwiak06r+kby2RaY02galJCEIpPN7K8ef+ST5cFNpfvRxKwiWdZ5ULbMZEkd/ig2Gxz8kJkM0XW3dGqMr9vpJreYk1g26TUm4y0FAZ7Yj0xwmjUUDcpQUfyoqMhJUYxWbrOiOypEexkvcpJyiHZNipMIjeQrrO41qAnW77/6DUAXy0OqeqU//KjX+fe8YoykS77aLTl6LjCBU2qPUfZhnsPVtSnCSfphoDmNFnxs+oe1+2Ij87v4XpDkfbM8prUOF61M27aknHSkRvHB08u+WR5ytPFnNWyxA7NT7vJ0ImnD4bcOi5XY3xU+JuUdKnpDgL/m//oTzhrprhg+OjyHl0njZ4xgX7Qve82CXipE3TqBcGatbw7v+b3n38LrQOH5eL/T2X07/kR+fkYWn8uLPZ/88cvdZFOZYkpNG/10GjSlwnpUoyk5ZlEq4upUe2nhNkL+dKbXw+yGjYWb+Rmmh/WVHUKJjD5SSY39iO9p0u4kSJbCKUkJFI8FFeDTMLFfSGLlmKgPhXSTLbQex21dhIMY9rhpqgUk0dr1q8mwknupHjbTQSTWzH19aXaS1aCVaTrMNBS4OhHIjWojxXLb4sp0C4NzVs9k2cW28S9vES7uI+M39FeTC+/7s16RopTKfbUoOvXbB6LkVA7mH0ZSNcB20SKK0c/Mvhcsb1nB7lBpLiUbcf0edhLBfbhT3ZgJvtIdaLRTqbbSRUpboJIbFJINyJfaQ4V6+/2qNSzet9z8A9LwkYN01GZoiZ13CeMAnttOFia00hy3NDXiegiv5Z1/aIT3aqyEX2bSHCKEwqEyyEYTXMC2Z+MqO9FtrcTTAXdTWSaQn4baA7EnNuPIF0rUBL2o0LcB7aoEFk/0jz/T0fkV8Of+QFD6DUuy3GFaNy3DzTlRSD5f00gRmwT6EuN6UT/fv+PIsoF0U1bQWVOfpTiRnD2Vwwnfx7kPYhw/KNA9Z+v2VYZ9VqKv/WihGmPm8LB0ZbFzUjM05tENK4BolX4mcdHIA08/fqEe1Zwi4cfB1ZvabbzyOZ7nUy9lgmr7w0+iSKwSkRTmX+RkS3jPgRI5EXy2o262+pkN3fSlKSGegQxlQLalWLy7EtpaiRdVO+n4T1SnNlK/u72Wwk+udOym2Gibisppm3D8NnKcxGpi2wGvhmitN8qRbmG7Ayku19Nv6PLxH22QXYr15rQG2ze0zeWZNpy+KTi4stDkpOGZVWQJQ6lAkfllkVd4DrD0XzD+KClcQn1NiV0Rqa8QaFnHe5VyW2Zo9LAcjMhvbSgIe3lWtGeeDCR7GkmGvA3GzEytkYawqVF94r2QU9yJce616CCFNPZucX1CrNOSRxEnZAHsBs5V/OLDDcePg93dy7vguN8Du2pJ7028j1HHjVw2dmKRENtDHHmqAcDZPRKJvImEiu9n5RHG7CZTNSTg1YIIEPSqrD/DTjF9YuDfdgRJsKjGtUavvXeK2qXcHY7pdkKKYQsCFowDahag42QB1hb3LGT/IDCY1N5fsmoZ7Us2GwzoXyZyNnFjGLcUl+WUHiS3JEkjmLesXw+49nZEZNpLbKPKJrryyYlL6RgTKxnUwmpJJpI3aZoK36FaNS+kH11ccBLd4hOhLftGovNZdOSpo7ZyZqmS9A6cHC65nw5YVy0hE1Cc5URx55k8Ft16xQ76lndjEhKYaBPxg1H72+p+4RPvniIyR1FLqE8Zd6xXA0TWgWKSF9blpsUesW2sdiiZ3kzIi17JrOabZVxvRjjByLKZpMTvWIyq1kvCmgMyT1PU6doE0iGyfl2OTSniWe9kv+3qYRVdVUqpmkVaTcpadmLZCkqxkVLl1nObqf8xjuvAGliPnfHlEXHXz7+mj5qMu24rQv+zr3PeNHM8VGx7Avu5ysumwkf39xn3YhW/t50zbIpMDrwwcNLQlRcbMd8fXvA8WRLZhyrLkOryLIv+Hv3PuX/+bO/THSaPkizVBw03J+tuK0LPnz1gEeHCzZthvJ396V/8Pl38V4zm9SEMJh8daRrpZwLXkueQWuhVyTzlnRIfT0ptrxcz6jqlCzr2exMPb9oj/9ACuifx+OXukgffWUwuWbzFjB2dBq6QyAqmmPFvX+xK0Jh9Epx+91I8UpIJcWZFL/NvQA2klxbukLWdfY83d+Idl9/V1zKFPqbhBRgb1Y1nTQDthL6gwp32ENXSCqoK6WoUB66saSfuXtb6lVO0MOKuPCYjRhIR8/k7N7F2oNM8nbabAn2UXRTiGlg+hOJiuerhGQb6Edqr7kVragE++hOCgoV5O93r9cV0D/oZMrlNflXqUxHFyJN2F0X+lKzvS/C4fErT37tyRaKbqL31JR0E4dEUNF97+Lmd9N104hWOFsFkirAYIzs5hKAkg5mzJBB9nVCcZGwfluCioA92m0fApVx1wwg/19cwPYdR7iVZMT83OBKcHNH8VWyl1n0xz1mbfHlXWqpz4TDnWxkYhp1pJ8oqlPhpl/8lqF8LVNrnyvyG09zaERvPhQwphUTYnMix8b0maOZGzmutHwezaEmXct7NH7p8fmQ1oli80BT3AgByFZxz7ffJYOe/jBw/juytZh/IhfHfYqoj0z+71NW/7Ei5h6d+z3azbeWbSXM7vrrCcx6aAz+oYMXOUR49PYVl8sx3a38/uXvRU7+hZZ00yRIgI5CNLgTh3IKXWv0yjB6f4FaZHv5SjfSQ5O5a3plQr47v1CIPMbIe617aWyre9KgmkbOwdG5MNG3DzWtFf9Gshya2H7Y2PRiPDYt+wbU5cM5nPxFCVi6ls85+UZ66e5z68ZKEI/FcL4PW4pdkdpPRZaVrnbaddg+Ftan26YwMJJvVhKUFp+WuActk7KhalIWdUHVpSgNt+uSm9VITI8bg9ag7tf4xhLWCeqoQ23ErKBaTT8NMHJgIuZc6BmqdHTvONR1hrrKMN0g1yqkAXEHEq4VdcTNvKQ5gmjYj7wYHTtF96gne56i2zvkpyvkXNC9FOQqDEOH6fB+NeDue3wlgwa9NagjJ6hbE2UIcdTy5P4146Rj06d89emDPULRTIXkYlJPWQiiVo8ifSfM6RhBJYG86KiGKXE5qyVNckD6/eYbLwlR8dH5PWFVV4lsGGyEwg2BMxDzQDmXDrrLJKVVOTWE6miKmeiyk0HDHm1AD8xzawLTB2t80MQohbdScPrODVc/O2J9nu+3BkniSWxHnjiWlTQmRd4xzjraOqHbpJK0qQPVNqddZqL9H4yU2gb6gbASvMZvE5zPoXR3N5/KYDaaZZigHjXETDOdb1k/ne0bJd9KYa1UxC9yNiqix5FEe2YnG1bXI7abDKVh2RuCU3vpis2EfqMST4iG6byiaRNs7uguC/yhJs9FOgVQr3PKoVFRKkqyqQ04r5kfbGWSHxVF3tEPciE/MOrDsAGJEXnPiyH8KA3kmTQRWkXW21xkPMA/+PS7e417cJqTkxX/8uoNbjYl3kkxnCjPF6sjeX59ylfLI65XQl1xneXB8YLXi5lw3U3g49f3uH+44p2DG27agu8dvOY42fCsPqL2CV2w/D8++iu4JiEddcxGNan1vPz8hOfPx/L568jT9liOn6mD+5JN0FUpsVcsvNr7MVJ7N0l3fYKvtRiLtaGvEsFiJpGDBxVhpKi6hMR6sr77n1Q7/erx83v8UhfpthGT2fRzjWmlsFZhuJlHWL0lBAa9EuPh9LO7bradR1RQjL8UpvTy+w68JvZge5GJ1A8CyVLSM4MZjKpKbtg3vyEc3jDypOcJq3fh6MdCS0k2g1bcS3HmRwOTeZi27VbupheN7KbJyFKHK3t6INbi2tedIiR3Omg9TMx8BjtTZ7KVhsHlMimc/jQRqU0nEy+fy9S9umdEOxuksG/nEdMKVq/6nQp/naGCIrsSXrZKRA9YX5V7hrTPBtmJh/UjTXkZKa53pk0ldBsrRsYd2rE5MMJIz8SgJfpxmXhrJ/xz2wo3fXvPkK5FhrPzAXQTjc9h9FqkNsFCdiO/Ssoq1IeK8ko0qEk1FFaDRpo4fBa7WHAjTZKbeszSMH5xl/gKlmAGlOTQiGkn72VIIQwpsaaF8lw2GYcfxX2MfXkW2d4X/J8EZon04/YDjW3EoDl5EXj+9yP3/hk0B/I8kyqKUXRoApMqoELgxe8ppp/LmLI6lel6tHcpq7oT6k47tzz+AyeMeCMs+vbA7I8R3Ufu/UBx+ZctISj6zhADqCTiWiMr5l3SZKuJMcE/amCVcLGY0N/kotdlINo0kf6+TB6jBj1vaTNhP8eTlrhN8Glk/XSGeQBEtZ9M92PZeuxSgXe675Cwl5/YalcEKrphoKcHrjkBbBW4/cAIkUYL070bEm1RonNXAfrhe7pSzl1di+7eVoNpNJPnAwPdZmjsgD3BxQxYS9PK1mJnlHW52htIJfBLZFp2FbFbjZ9FIhGbub2e9uTxLZfZjORFzrWXhE4fNdtlThyKFDvqIQ3EE0fsDebrAvWgxQ5TxO4qI47iXopjz6SA6057obtsrazITcRspdHtDwZp2vgOi+ZPevl3rZagtkomvzs2ffb1UBgOxvAY764/IfkG1ebNQMjiMM1WqKUQhnZJptEZZo+XtF1Cs0n5q+88ZdNnhKiYpi1PPjjj6af3ISpi5rCZx3VGtj1EdBLEYFnPhQdvlWBwFdiip1oWpGM5iB4eLPnJ2X3eOb4WXGOvhaQyEGtQUuQDTA9qOmeYlQ2LoPFpkJTWxtDrSD7rScueR/MFMSoWTUHVpBglHpvN1Qg76vnOwzNCVFQu4cuv7pEv9TB8MKTf2TDKOpZVznaQiWgVMTqy7VIODipWmxzfmzuaSiq6fKWjpLCuUuxcdOjBaUzZYxIx2SZZT7eWUD0/85ANzU7mWL2YEgtpRLzXeGfoN+lAbIm4JqEazLT1NoVOQybmVddYkYGmjr43g5zF4bYp0+MtxgSKvGN1O8IeNcSoGGUd140Uvaf3VyyrXEzHwNHBhsW2oF3mKKAbQpO6RJCI3TYRw7IJmDQMxb0cc/02IRn1xAh54mi6BKMD3uv9e7YzmCodKYqWTZNxMKr5zQevuGkL7hdr/nz5BmfLKc7JJiZJHUXecVDWGBU4yBqu1yNmZSO+ERO43ZZ8++CCl9sp/+XHvy4NxLjjjcNbFnVBmt5tH5bbgr/3zqekxvHy9oDuOufkjVveObjh2WrOo8kSqwIfnt+nyHo0kWnecLkZs14VdFH0ftHLCt3kAbe1gm3Og5ila8UffPRtkYbdpELdssW/ZrX083zEn88k/T+Qaf0vdZG+m4rZZqeRvqNIBCvhOt1E4UpF9UAQb7Jql2LdH3ckT1P5HguDOwlDlPUwhauk+HIyAJFCOwABJp9LcW8azfXf7Dj+7xNcKdNsPeAekyEIJl2LiVEHoUTIDWMoB5RMHvSspq8tJne4mcLe2r1EwNZ3E+M9pWUgcxCHwnUpRaUUkVKY5jfy7+tjQ3MslJJ+Cq4QrXGwke1jSBKPnzjSUUd/YlBfF6jzjLjOyaNIVnaGsNlnw6R20KSjpDBUXcCN5P3qJgbtpajZrcOVl3+/i4A3Q5jQ9qEgvYTQwr6YB2lMTBcZvR7e/zYORli1fy+ClXV5MAo3kirLNjtmubx328dQPBeiRHcYhtAnNaAihUqjuyjm2Ilh81sN6T/L99Ke3SR8h/zLloHmUNON4eCLQPVA5BC2gtGZfL67IlD7yPQ5XP264ugn8p7Mf5hw9VuB0z/+xnujFX2hsG2kmRtWTxTqoGH+qcEXWuRJrUxD26km2QZuv5+S30J57olWcfuuZfp1oDpOaOcwfRqwjZBfTBs5/WPY3rc0v7ulv87RZYdSYu6qnd4HjKCjhKzMO6FglI7Qaa7/Vx3Fn424/bYC06OcJR72hNuU9KTh9GDNy6fHUsn1mjhxeCw+k61VuhzOVSfnVDLQw3wq/68GU7Boi2VboDuFGorpfjJQVc7EX6K8aNt9pujyIQV18o0E4jAUlUqK/n4i2yA10Hd2FJftW3I8HHxyt/FZv6nEg2LuvBC7CXo7VXsc4w5LCpB2w3E4JFxGp3B9AuOe2Gkur6YA9EcOe5FQeUWtCpmYKTmXjQmYYbLaVCluDvomxQFu3sFxS9xKeIuKIqlOlxp7Y3EHXsgZTia8ofRC51kZ/CSgK42feJF4eIWyEVyEjUH3mmSl7jYPRrYRDISdIJRCPHdFuyuQQKxJR2gtZmHwRcRNAsmNxT1u0EngO8fn/PGzt/id957xR5++y2+8+zXPlwfEqDgsK55864xFU7BeF7jzgjjy0kQaMDbw+uV8SO4URnfvDEnmcL0YW/vGEjvDV8tTlFf8rJewpaiQ1MYBZ7crui/WE7phIlsPRV86bXGtEXNsr9mscnQSuKlKNpsC32tia8jmDc5rDk7XLG9G/OTZQ+Imoby/wY4c3dwIfrH0KGfYIs1Okjq6znJvvuJyNSYGxWTU4OqEYtqQpY6VKzCJR5vIwahmXWfUsWBUtlR1Slr0ZIljdTsCNRh7K4MqPZiA0kIDmhQtV0Ph2lQp5bilu8kx457gBD4wntVsb0omR1se37uFe/D8i1PRoE8ced6zuS6HwBxFMJrDeys2VUZXpejEk5YdRd6xXhdcnM3Ipi3Ba84uZ9w7XgGS3KlV5P7BimaUcHUzFhmHU6TTlnabUk4lFwNAaXkdRdqxrTJs2dPXQiJqekue9pRpz1oLUSX0mqSQLJLgNLOy4fcefEofDYu+5CjbsOwLZmnN//Xbf8jLds5PFg/4K4fPaGPC1NT8169/jWfLOW8e3rLtU0K0rNcFxnr+5fkbHJVbvvXonEelmDFGpiVMNUfphqUrKHXHj5eP+CfP36N6PcbUGrKIUvDR5T2224yLT4/BK8Jxx4PZioOs4euVMNjToqdvrXDwt+nArReKEQpip4X0VStiJ8W8z+X4/tZ7L/j6X7ti+tXj38fjl7pIDwl0JzKhbE7EUOjyoUDeyvQ2XYtDzFZSwAUzTIStQn8u0/d+JFM0eymmTVdASMWIFlJojuTG7wopwmwtiL/VW5r6FE7+SUJ1XybUrpBVvU/Y69Z9ovaJhwwTwWhkYtxN5Wa+fT0mPze0RwGVDAxsB+lCS3CLludY3Qc3DYyfDlOykcgGtBe98G5ajZLiJ11HiuvA6m0hbXRvdESnSK4SKW7TgEIKAfNJRhzMnelSChufyf/nC5mYd2MtshSl7oJmorzv2kmRF1JFYFgdp/+jJiNhj9bTfoeDjHeyFUT+INIFkb6YbjDqRZk4m1bkLmYrE3lbyd+7kTDY26lMsPdmNg31By2sLXYrMpK0Uxx+HITYogbMZCbNxf1/mJJsRZLiBxZ7cNAcKpJtZP1YD0FIsH7DUJzLz+kmEmijnTyPdC0bnG6s5N9EKTyzJYyeabqJFPwyOZfXe/NtQ/WG5+EfKNIfaHyh982OFOeRdB2IGg4/8azfFEPyi9/ThIOOzduW+38YGJ8Fbr5lAb036ZousvpOj31Woh82hMYKU7oWwkZSOJyOcJ0RJyJT0BNJzNMri68Mm3edNLmdIZ62UgSnYmR8fTWjOK6obgpUjxRKM+EB55dqj0LdffYE2SbpHqIejNQHkfKMOyOxk+2UduCHz7M51KQLmYrXp/Jn+YXGFZAt5HjrJjKpDynswolGF8M1YyL/Lmj5N7MvxCi882FEBdOnu23Yzmwtzd9uQ7PbKMmxI89XDRKa999/xbOrQzqvsLlgXO24JwZFWCfQa/ojR/4ioT32BGX208AQJEXRX2TEw6FLn3cSdDT09flrSz+KojufObpSdMxmYzCXlv5RC7XFbDUhiYQ8Ut7bUF2O0LmD21SCfPY8fKFDtdZimuG1Vgo1vHdR3Rl7QzYkD6+0GC0D+MZKIZdHCQ5aCQs99gaSwFfLI37v3Z9x3Y34S+89p3JCs3ly74rcOD67OOFwUvGtt57z9neu+OnyAR9+9Bb00FdDsFDpIQ342tIMBBgQTXte9DS95uBkQ92kGBNw2hCjyFCMCWKUVJFXi9l+wqutyAti0IxGDaQ9q34kUh0bKYuO1aIkKRxp1tOahHYpmRjt2GHLnixzHD244cWHDwjF8J7qiFpaugCMO/xg9NVapBup9awXJTeNRadeJvPbjDQTaU1iPbfrkr6RBM71qkCbSIyR9UoMxN1VgT5s8IWX86zTmJGjbYaJbFSMy4aqTtmej0gPG7rbnOK4uvMDBOid4Wo9oloVmGlPDCJv2S4FXZhPWvKsZ3E55ubrA5HZAGnmiDBQiTwPT29oXMLlYkwxkpTM0Gv63pJnPderEX1thQTjxJzabjLycYvRkTRzzMcVqzqnbS2bPicGJdP1zGMTz2aTU5QdjRPpUxgwkL43KC3Y0BAV/8VnfwmjB+lInTCZV3xwfMkfVN/i5XpGjPCD+ITXyynzkUieHoxXvFzP+NbhJTdtwW+9/zWF6cm0I9c9t33JVTdm1eU8X77BZlPw5um1BCa18n6+dXjLSxN4MF3x6c8ecfnZEaZR6KjE/3EicqOz1ZSv3RzXGUKvsbk09Vkq27JkSG51uRfyzIvR4IuBB79+xotXR9BIFsKnnzz+16yWfo6PyK8m6d94/FIX6TvaiR405ztqw0676pO74jDuCzYpyqKVSZGtZf2d3wzT2WR3s5UC/+Jvi0lH/aNDKXLHittfAzcO6DaSrESSonuZbB/9NLJ5qKi+1ZE9S4nHcsNXtRSZOy12NArloD2K2Fs7OPGR5LyN3Cx9IeSS7SNon3TQaHQtk5D124HylcZW0kC0M3ltO0Z0SAYjXi9F7i7FMXuWskvj7D5ooLHUi5yklcLD52Kc9Jm8nuISskEupBGz6a5o3E2Y+1KRbu7kKC67M3SK7lehkQK/uPaoiJgtDZjAMEG/S/TcpcT6VO2TI/vxXwyTMU2kmeu93CekUhj7VD4LNHvNd3cQ0FcpoQzoXlGcSdCVGGRlkm3auG8yfKpxmR4m93GvUa5PIf9UZDY+kc8HpDFLqqHwS+S59aVi+0DINNMvI9V9hX59pxMfnQ9F6BCmtHmk2bwVya7g8T8Wj0E09i5OffBAmD5it57L30zFtLmB5W/LzZ2gefLdV1w9e0y60kyeB/xAISFGbn5N8+APZCLfHBTc/J1GWMpJpJw2VK/HUHq0FxNUdlJJoEhr0A8aWcNHIGh0ownKyBpWR9yrklAEWpAJ7bQn1hZda/yRYzvSJB8Z+WyGwtYE9tjDndQlv1CAvH+L3xaj8ORPc9HAI41XcyhSNOUUxfmgUfmG0XP9ljTuPhfDabK5SwyNZmjqj+701SpATBX9sDmRNzzurxm78KtdsFVxMWzGhhq6n8ivuy3B5y9OefLwipu8ZJx1JFpoDzebknqZwqRHBUXzqMcuLL4I6FwmqL437BJx01cp3Sygb2VKHr1CNYbmSYc9T0kW0BRiEnejgULlgK1cT/xIJGB2rWm+mqJsJIYEkigG30ECEgYJiKnVkASq6Y49qlOSCjo0KyGVLaFu7+RLlB69ssRU8K26FVJK+7Al1qIJf72dc/bsEDPt+ZvvfEHjLb/55gs2fcrXywO+de+C1Hi6YKh9wm1b8J//tR+Q654vtic828x5/uJ4MI4OLlUFSeYI65Tu2RitYFnN5FxNA9OTLVrL6+p6C0rRblOZStoIrZY0UCPJo6t6jEo9tuhx2xSbOta3JURoFxnJpCP0RtCavUzC3TLDZTKJjyZi1hrdq31j44xswcajBucltKgbdNpKB2JliYVnfNDivB6kHJGmE29UNur2gT5RRTHR5g5jAvlpJebDkw1Nl+ATQ3ydE4566l5TTORiaW3Alw5rPV3m6b6coNJIk6eY0nEwqjl7Nef9t19ztpoK4/tagrZs6WiuC5osAxMZ3d9ISqkSNOguTVsbGcrUveWde1e4oFm1OatNgWsNrY48PrrlajNmu8kIRgpTYwNtnZBOHYn1XC7GHM+2QjuxHu81eSYnmQ8KnfeSLeCEmT+ZiWTJWml0zLhj00iS5996/AWZdtx0I15sZ3x/+pJn9SEX27EQUibXfO/gNS/qOS/XMz67PEGryJ+/fkhXJ/AIfvvwa0rd8dP1Q15XE0aJNAhPDm7Jj8RY+mIzY9NktJ3lxpQoFXl6fQi9wm6kGScqJg/W3J+uuKlLqialzDvGs5Z75YYPXz3AOVivC6bTmqZNZKNWyHU9JAHtFDFRvPrJfSGflnJjUOP+X10n/erx7/XxS12ku0Km0qvv9hz8KPlGSiSsTxXZtUw/wz5o4469nAwcap8OvPVBGmIH1rJpZdKdP0vgR4dEI6Y/n8LBJ7B9aNCdFIK6j2S3A+nFQPVIzKfRyPO5+h1Zt0YFxdeW8Qsp/rqxIlkOU0LJmKB4LppykAIiZOxJHarTjJ+Kwy7ZyEQQpMlQg4GrPJMp/M4sWlwHSQJ9KEbUcNoSN4lMiy5y8oWiO4j4ImAaTXYtN5luHpl/NDQ97VAI7/X8UqAkWwZijfy9Ga4X67fh8KO7Nbl2wC5AKVEs39aMziLJJpKsPf3YYJvdlHWYgtudTlymz/nNMK0cdP1RQXkZqI/FcKk2InHxiRpwk5H6RKNd5ME/h3TlqI9l5Hn1lyBb3k1ArYNuqoeti0xKbS2FWEikMalOFHYLzVwxfhUINuI6QSVipCG0zV0zqAKkqyEop5TUzeUTvT8WZ18MwU6lJr/1zL7yjF4rTCfUluLG002E+S8T3Mj2vqb4P51ztS1pPknRNwncawjrhKAhP6zJrWPzmw1Hf5ARUrU/jpMtHP0k0I0VwSiyZeDoDzL0//6KTZNyOK7gAVSvxqAjZtLjeoN6lRMPHDZ1JINGlUyIBFZBcEqKiNKRlz3NRYmedYIPdTLJxUR0p1l8OxCzQHpl97IKux02KkOxLLIU8VjMTtYsX8zIFnFvct5JodKFlnN1J41K7mQpdssej5gthvMouQst2iMqe/YTql2iqXg/4h6fuZN5uFy2KM2hGrwOsqWqj4dArcF0HS2MB625UmB0wEXN66sZk0lN8eaCm2sp8lQScXO3L5ijDYPGVuOLgC8hvTb4MpLcGkIC4aBH3yb4MuAOAmrk8J0UBO7Q4XpFzAKUMtGNraE/coJZHIyA5B611fJzR5KOytoSE9CtfGa6VZityNf6aUAZtcdjoqNIuTqFPk9xo0ByYwiJTPebBw5WiWjrvRjFSQP+JuXD6QPen1+Rascnl6d87/SM82pMkfRcbUds+pRvH1zwo8UjFk3Bm5MFR3nFcwX+JhPtUiLHUdtrKDw+CahGY48b3E2OHTnWrydEE7HjHpN4+lelaHsTaVzIAjH3Q3KnEnOpklj62eMl2yojHXV014VcV3oDOooEREVM7qTBcZrV6wnmpGUyqakakW30lcgYYlSslqVQbIDLixlJ2aOTQHa6pVoVXD+fA5AcNiRZL1NsHYlOk09bdBEwWkJy0sRR1Zlo1r1ms84JTnNwtGUVAKdJy556nZHMK8wQXtV1kqAaHzTYJOBfloSjjqvliGzW8Oz6UMJyGosd9/hliu80k3sbqiGoJ0YYD/hEbcOQdxfplhlft4ckheMsTMWcOqAxj4/WHJYVz2/mNNuU+eGWprMD5SWSZI5tlclGr7EUx7eMSkvXG5qNkGBOphsuFhNcb7Cpp1tLQq4xAd8kuKAx1pMP2QPTouGHl2+ghmAhawIfrh5xXZcYHTnIGmqfoFXgJFvzoxcP+XvvfsqHNw/JbU84UISo+AdPv8vD2ZLWWV7fzDiabplkDasu41UrCeSdNziv+WtvPmVkWz66vY/RgWdOEw41aeLptinbr2Z8Vo6JCv6j739K5VMu6xEfX5zSt1a0+dc5qzik3XYa3Wqydxf0847oleAxtxbdKQiKx29f8errX1C6Swj/6n/zb/r41ST9F/+he9ArSJcJzYlMTEPpUUGht4buMKAmPdymmFrTnAbyS7m5u9EwaWvZkwtceac795kUCqYFBl12urybDMtK/o7ysieKRFD3a/Rn5b5gy87N3pGmImzeVDRPOqEndHfTfFeKoVMSEkW2Y2tpLsZfp0PhMeiSZ4rtk0BII7rRFK+lcNglg3YTKaI3DzS2hdM/VFz83Q42CeULaTB2cpXRakgGTeRrXC6NyK7o3SHWduFHwUhQj0/uft5OKqA8HHx6J69IN0MQUCHFc0gURx+7vUnSjcz+NVk3TKFHGjvQSaJWVKea4jIQjaIfy+sU6YQiXUVsHQZ5hGLyytGXIkcxjWwsfAr9SDT+UcHsUzFnrh9rsqVM1HdYPe3E+IpSw3OX7UmyhdF5oJso2plsWWwj/zXzAZM5SI9UkCZi1zTGwcOZ37JHAyZbeT3bB5q+sCRVHAJ8ghhCh2aFGKmPNOkm0o/h7HZKu8xQJzJl5irDnEoUevdyxMcXJcrJe7177EgvPlUSLmUV3VSRLQI98K2TS/7sp0948OQad2rEFLYsid6QvFmh6oT3jq8IKD5++mBv0jqYbVltCkJQuE1CE8SEGNYJ5B4awd3ppZW8gQAqDfSHjj4okTBsDcd/qqnuCXFo9rkcI8vf6uB2RPm1Yf2GnOvZzVA4p1KI7/CNT/7eU1Ztzsunx5TPLMl6OFy1SGLyq8HoOFwtXcHeAGyGvADxquyKc4XLZDNkurhvkqMazK6tbHaiYb/pifpucv/B8SWNs/TeEKLi6+fHlPNazJPXBY/fvqTtLVfXE9CaOHaDiXPQM/cKEvm1O/FEGzBbCTXbmSHVUGuqywy7VbT3e3Rl8OOAqqWgpPSYsoerDHWvwbdGaDyVwc08ZmuEYZ6I6dPnkZiL4TN0mqhkQqwGn44cy/J+6E7tNf3JSst1qFd4G6HwqEWC7g1h5sSjkXtcUNxcTvgXzw7I71V0reVffPq2SPkG3e3j7yz5/Z/8Gib3BKd4fXYghXQSBJ0YFGbaCUoxKmKnpMkYjM961pGkjjBWnByuuXh1QKgykTw132BPqyjNDBBtJFrBh6bHNc4b7h+u+Pr5MXZAQobailTIRtJpy8G45vJqwmy+pS5S/LMRiyJl+saKzVczTK9wDwOjUUs6rlmsSpFjNFq8R2mgWhYSzDNuRZrRGRb1SN7U4YbSd5YkddRbmWArFZmOpRkoxh3LqzHppGO9yUHBaNawXRZ7dOF8VLG5LjGpZzwR+cvBuOLyyEKEw2nF9WJMcCIdiUFRjFoOjpZcLCY8PliwyAvZAm0ytq1hdFSRpQ6tA8ejLT5oFk1B3SYcjbYsmoLVIseknnWdc3UzQZvIbF6xWJQErwede8BVIrsEGB1WvLie7+VJOgloFblej/DOYBO/lyodTCtpWlKH0ZE86fFRc3s7YrvNSDJHnoqp0+jIpRmxaTOKpKfxlsfFAo/itpPn848/+zXMQFj5W298yXfHL3k6Px6K+chbk1se57fMky1X/YQvNic8Lm95kC75ujmkj5rf/+pbxKDEx+MV5J6ybMkOHN3Y8MHJJS5qvt4ccLEeU389IWaBJ++ekxjPTVlyWFScryccjbZ89eKE1aspB4+XLJ4eyNDKK5K3NrxzfM2qzTmer3n6b1ZG/erx7/jxS12k70xdIRFZSPNA1sbRK1nhRkXcJKh5hyfFVJpg5WYKwv9VEeKgE9+856jfiOSvEtJb2DwJTD+TAmmnafcpclMBCGqvTVZBJnPKR8JFzvGnURCPh4r6RPB+dtzLc1uk6EVC+7hn/HFCP7rTfGa3ivq+J7syjJ7xFxB+wmyWxERbweipHopK+Vnbh3fmu91mIBm+dvNIMf9BJlKTuaDuigsptm0VCKnIViT8iYE9LjcxV4o0xadibNQ3gwa9jxLuoqQg133ElXLF3dHBghVUpOnkdej+G4SJRO1Ngj5T+6l8uhFyihswiMkwJVd9lMnowAcHhsRRIciMziXIJ6kCqpc3wjYDfcXdaeHz2wAxUl5G0rXH5TJxFw292lNZ/DCJToZ7ph+SVGXSGvdmzskLmapt7lsptAdJRxw0zyG50+6bgd3vM/na8kKqrWau6ccweaHZvGc5+qgnu+npZpbRmcTe1383cFB0dFXC4fGG6zORMPhaeNk6KFSjeOO/cbRzQ1JFiEPKZjp4COJdKFU31TS/f8Lj/+MzPjmp2LYpXZXQrTPyWSNTss5i856nt4fC9O0MdtoSg2aStqxVTtilFepI7A2qdOgkEBPRicZeQ+5Ff7uR0BlMhMqge2kcjj/0tDP5HJu5wp4nFN9aktzIpMhWkfpIkd/K36sIbkj+vNqOKNJeGqPh2I2aPf3FJ+LlSJfShKZrYCVN1S7sSyboar9d2SE+77Y58ucMU3dbSZOowl3Rr3v579VGDKIPxytumoK33rrkcjUmz3r8gebFqyOUDjI9qxLR6YLouW8tPpf1tq41IY/4UcRUmn4iE+OQB3RtSK4t/dzTTgNmbQfJUBg0+CKR8I1FZZEskesiThGmw+fTDFPzwaCmolzb0mlLt04JqSK5trhx2J9vCjCNBFzpXg3HtEI5RUijrOG/wUjfUVV8pzGFw29lwt5WCUnhaGuLth6VB6LT/PDjJ3LdcHdbBZECimYfL+baGITysreyOAn4KQ5qEit/evH6QNKYS48pHXnRkaeObZPSblLU1oKNqK0MUULp6a4LOhXZFjnKRtxGLsyj461Mf62nby16Enl0/5YXrw4hKqwXjcvq1RSG5s1vE7pBZ55lPSHR1I2R9z4AncY7RbNKoXSkZY/vxbyqbEQXjpP5Gj/o6etVTrUqcCMJElIKTu8vubiYkpa9SGq2qeAXlwV1m2JN4PTBguvFmMR6kkT07mnZY42X4KHU8d7DK5ZdTucsV58ek38g+uhXqyll2jMtGi63KcVckm9Xy5LoZEp9u5CETpt6XJSEU5N6ZhPRe5/O1izrnER7ilFHtc4IXpNljuC0YC5BUJoD5Wc8aqGAtrMoFSnLliLtuXZjvI9cn81QiefkeM31ckRVZRgrTPmd9n+zKeQ8Szxnt1PByGaes8zzs3iP0UiSYB8cLznMKzZ9yrbL+MHrt/hn/bvcn634O/c+Y+kKjI38ePmIn12e7D0Ff8ITjk5WxKjIrGNSSkJtfnzDOOn4enXA4vP5cB+MfOLvkaYO5zWP5wvKo2termd8fXmIq4TkclOOUSqyuhnJ9bHTbH56iE4ifuKxC0P3csSnz8dCd8m2/9r10s/vEf+DmXL/PB6/3EW62qHupPAefWmpv+tgncgNb6MxT7Z0W/m9e9ARU0/bGHTm5VgaLijds5L8paW4kht91HD4oYQQBTtEn/cywapPhJG9fSRTbil8Fdky0h5opp/JNPrmNwLprQIdSa4S1LSTYIlao96o4FUpmumjwOiZxmfQnESO/1TvDXOmi3tGs+kkQl7VUni4kdBa+rFwmo9+GoSfHgS96LNhqjvITrqZyGG6AzGytHORzQSrpfjsIqaJpGuZ2HcTCUnKrx3NkaWewPrtQfZxHMluZUotdAsxcI5fBPrDAZv4Kg4ygrsT1qfynkat7qQFPqKau+Lb1B7lNckmglZs7xlMG7n+jhFm+Vbt6TGmjZSvHD4TQ6jLZCIXSzFcypQ0sjO6ivRhKDhCxOXSce0SYHfbAzGtSqEeDSzfltd69NNIO1O0YXh+SlGdyM/qZnfMd9NEbj8w+FyaIYDiypNshbbSj7RofDsxx5YXHv1atPoqwM23E7JlZPyyH+gsgWLWsLgZMTvc0g+YMkpPOu7oa5lW3/tDjc/14MkQaZTpZORpm0i69LjR3WanPI/8wz/4bb79O0+52AqPcHYio+jeiaHR+yE6PsJ3PnjBx08fQoSnr47RNjA9qFivCoIz6MyR5I52O+DenEzTk8sEdw/So4Z2IbhPhqmmaQO3H1hGr6XATAeEafzvD6hOB09HlE1GfSwFre7lPNUeblYjYlAkN1b4/0MAkhlIQs2p/OoH6ZithnOpGrYL27jXgUcj53o0uwJeDeeiNOHlpTRofSFSqJ3MSfcMjd5Q3KvIZT1CEzEqiJwI2GzFLNdWCe0iFx30qEObSLfKhGPu1JAEHlC9wqwN3bH8ufLCu4+tprvnxBPg5XyOOopxsVdSmNpA1JEQoV3mYCIn718zzRs+/+IBthOChC+DSFcaRXSWNoByGqzgFXWnhZ8eQdWaYO9Sif3U422QwcXA1o479KEbWM+9RtsgrPfcy/U5F9mCUhDanWFIYUY9o1HLOG85uxQjQkylOVFBkdyvROrRmv0EPj+sOZ5sGactqzbH6MAyFnDQ0GwybObwq5SqN1RKnheVgVQoNyJ/kmvU6P4GgGqdEYPib37/Z/z06j6L6zHltKZtUpLMcfb6QCRT14lo9Idmxd5oXCn3CQ+0VwVt4YmdHLemdITbFKxgK/N5Q1cl2EwaC98aJkdSZOOhDxofNNVtIZp8p/FOs6wkgCx2hmRAUO6QhF1v94xzHzTrJiXN3D5p9HBacVRu+fz8hHFesVqUfNLf4+Rgw9XNGPtoS5H0dL1leTvCTRus8RTjljRx++tCUvbUbcJo1LJeFHS9Zp1ljLJOCs1NTpJ4iqQXipT1LDZWmpSoyBLH1uW43ohhshBtet8bVqtib041KrJZ56x9AV6jM0cYLmDXizFp1jMpWnxU8nyyjtZZGJqLzlk6b8hSR90kWBvoO8so66i6hKv1iKv1iK5KiEGTj1vm4woXNf/49bdli7DKISiKg5on8xs+7S1/480v+dOzN1idTSALZOOW6+2E2GmRl6WRZCDEdbNAf53Tm4hqNF81FnWWy7XGRpJG4e71xGVCnDg5l0yUnITLHFMrQqf2UtiQB0IBhG8QF371+IV8/FIX6TsWd0iG9beG4uOcdj5E2U89yYdjeOgwh5LaVa8zdCYTPTPtCJ2h+LN8PwGVaS97AkVfDEYgA85IUVhciswl2bBfg3dzqO8rjj6USV9zDCf/UlEfQX2qUO9s4fMRqRIEm3lRkmzlBjF+qmkPZAI+/1jt0YHZMgy4OrXX27ZTtU/slHW9FCW2EdykdnD1Vz3zP7d/ISFRBdg+8aRLQUdGrUhWYlA0LXsuuKDmZPqKEqmHKyzpynN4E3n91xNB312p/UZi/okXhvhwvchWAX0lMpedyTQMaD0YtMi1TNR9pgnhrkD3iSIqs9diKy90mtv3DIcf+/0E2u518gqfa3Q/PH8LuhEjqCvMYCgcGgJ31zAEq8gX8oTrQylaVQB83L9u08m0PFtFjn8cpYD2kXQlk1aXi7Y7DFPqZCsF5vn/UpL/8lc7uo0Unau3DKaT91/+TO1pJ2kTaQ4M2SpgG9Htl5dQnyQiw+gi9VUJmcd5w0FZswojzNoSzlO0jpz8uTQefpjw96U0eyh5LbvNRbboMZ3h6vsW95sbcIYXqxlVnVFMWk7HG8ZJx6eXJxSjjjztuXo9I5u1fPSzx8wfrKiaFP90hD/tWN4IHkknEo7jvhqjHwg/GUBvDe605+hkxfXVRIx7UYqUGA3VsSFbxH04zua+YvYz2Xic/XWFO5djy43EbG2dpI8mWzFM669KkaI5OYd23hJpmqWhjgbaQ9Faq0E/nlR3UqdvSrtUYJChRWwlx0M7k8bNFQqXadxINjzFgICUzYm83mnW0HlD42RVnmhP4yyTtMXVCU5JIZsf1jyeL0iNp+4T2onF6MDL8zmxsoQIOopRU98afB7xY09yntLPZciAh+TW0k+kwYkB1Fgmk/J7zfRkK9xxr7h4fcBFGNJ/B/kKgB+wrH7qKL5OqB/3otNm+DeRAS0rwUiMxWGrGiNprBF05olbS3lSoXWkWmdoM1A3eoMaDa7cmRRx2EBW9jSX5d4HoU3g8cGC03zDe7MrumD5annIxcVMzJPXhUipeo0qHO+/d8bTyyNy23OYVZzmG358+YDeGdpKgmb6xqJKx3jSoHVgtShh5qXIjRIoE3rNZNowzlueTG84m0xYtTl/9MXbHB9uKCYN1SonH3f7ZEgUhNNW0kCXom1vD0Uvv9+8DJKa2akU/6Os4+z6hJg75kdbFi9mzB4tqQct++xow/JqDEZwiotViV+l2Gl3xwNXcT91V5cJPVDOKx49XPDVyxO8l6aoqxJcL7jKZpPx/ptnlLbnfDvh8/MTQlBsGkH+aRW52ZR7wtDFcoIEGQ2fs4IQFdsqYzpuaIaQpTefCNWlqlN8aygSR9Ul1E068N81r6oDbOpZfnUg2655y+nJisurCcWkJUaFG+hF1UY2Z0nuKPOOuk1w3lCOW9rWMh03EmTUyrYhSZ1kjASN1WFoEEDriPeazllmec2L2wMORjVF2pNah/Ni5C6ynnHRsq5yksJRZB2bbc7NpuThwZJVm4u+PgIm0HWWn754wJunNzzfzNmsc0gCOpF0XJw0zSjQjRhHd1tlFZBEZ6cwzwuCjcRsdz8aGs77Fe11gbKRfF7T94b04RbXWbjOUA9qOJc0V+0UQe20qL9Aj8jPZ5L+H8i0/pe6SG9OItYg+vAAi+8P2s5h3WtvrbDRa4O5KGmnQZzReSA/rmlWGcf/PKGdQXVPpmumUUyeD+i8Qu2lJEHJpHlHh9EOyovI5pHahwKt35FiLNlGupkUnLvk0vDViJjJTVbXeh9OhB5Ch4akzOV7iF50o7n/Azl5ywtJDd08ForJ6IUUdX4ojLWPuEzoMSqAmXWgLMrJz1i/DT6LTD4z1Cey9u8HTX6yHgy0w5Vkl4662xygJLreJ4aQKu79qd9ryPERn+t9MR7TgT8dwWg1TMzZvyfaS1EE0I80+8QKBtZ6EFZ51AOvWou8xNaRw08d/VhTH2lGZwE/BNUA1EeG8UvRmOxkLe3M7CkzO7PwXi6UymfdHBgp6FrBarpC0Y30Xp6inUxPfcq+MTAdZAtHuujoZintod0XcvWRXIDVWc7BV4rZU7lA18cG24I9E607yHNxwxZCWPwa00uj0hxqZl8FmrkEB6Vr6McGCLC1VCZju8oZHVWEuaZZ5kx/nBC1THKTrcgTdo2Q8rIxSLbSlGwfpFz9L2r8jSKJirJsWX82h/sNxgRabyWq3hnKomNTZyTjjixxuFHPu/NrfvjlG8RC5AxKR4kur4YJ3kmHCoq3Hlzz/OKQ0GiSssd5TTbqGOWdSA62KSoYfAGxV4PZNlBcR/KFJxhFGAV8bkXGUrM/b5IIi18LxImj/Cwl+Zs3LL88IF1ospuhKb2vMAMxSPeQrBXNPY9pzBDKI14DP0i3dghPFRjwmYrVW4KwlONHcf0bkdFztWe8m062QSHZyaGg84a6T6l7yyRvWXcZk7Qls47DkzXOa7reMi0bQlTUfULjEs7OD4i9QueedC7IPFWDOxGZnF0YwOCmQcgrTm7Q/ZET7bgR6UY6a3G9wW8TVCqr+dgrlBbdrw+a9qwkZIFoI2Zt8BMvkhIbqN+QYCTTyPHs8wgDlrF+3KM0MokeeXAKU1tBua4NMYuC4HRashxGmqSQKProFcEZqA0xF3Rgs5XilEzwit4EPn76kI8jMo2vDd/61ksmbzR8+eoERr2YkgcMqAua7z18zTRpaHzCHz1/k1HZMiqEbjIpGlYqxztNVacyAc4d47Ll9ma0v5dkZc92m3F/uiIdNE6aSJI7Ls5nKBM4OlmzXBeMxw1NmtAuMmhSaTiiTERNrbA3Vpj9s0DQEZ0Fmjahq1I2SU6cOJSOLJ7NYOSlyUUY8KumFKSi19S3uaSjKkR2ExWmlKl0t02BSPruhkxJs3GxnkBUBK9Js57gNaHXqAweP7zm2fWhXA9UZDJq2NQZzhsSK6bQZi068vfvX/LxF4/EGGoi1gaaOsWvE2YPVjivMUkApIDfdim+ExnP9Wok9JlM5DJaR5omEUrLmz2jrONyMebyekKSO4qs5/ZmRHSadNIJM7yx+N4wPZBU3r6xdF0GOrK1g1zSROyA4TQ6UDUi7UkTx3qT471QdYwOTNOWw3HFoirI0562txSpMOcP8prMukGaVhKiYpx1bNqUq80YHxTddS6NqtOQeabTmuc/eSihXYeObN5wNNlyfj0lruQDU4ctXInRWXdKNlFDvseOIKXfqgitIbQGnXvG45btKkeVgkltt6PBf+bkXEgDfplK8jBI4urt/5TK6VePn+fjl7pIP/wItt8SE1d+DUd/YgVz2MPF73WM396yeDajfCE35eJyJybXaDchKaA+lu9lOgk7Uk6KcNMj5iIjASW7aPOwM5EZmdDuyDDZMjL6w8jiXU17FDn4VOQwrrxbzXdD4p99WNFtUhptiUlE13ofsIIG1QvG7Pq7MtlrHvWc/nNLeS7a711o0T5FLwBWJoGmjcz/m2LPf1de5BZRKdHiIlN609xNc3ePbibPN10NxYqXAsTlapDeAFEKPpnkD0X6MA1evaOw312S/1cz0UL3dw2NMORF+5pspXAmytqcGHGF3uuld1N1mSAzTF3lMygvA1e/qbn3x06m55nomLup2UsTTBeHzcCdjnhn5Nx7svSdD6AvRLMtU9Q4YCvjfqoaEgXqTjZUnVrWj5M99lF7mbQW1/LZ2I1sNG4+kPTRqGXKW1wP+v020g9x83vefBzez6Ep2WmApVAUokz5lWjeu6nBjQPtZYqbSvJteRGG91S+ZmekRQmtJqkCz/9TIzebcYdygotTKrJelDK5yXshKSwnNFcFetKzqMZSONaG6ljOn+fLA06O1yzLnK5OmM4qlILFekoE9NoSbeTl148IM4857Ahes7wZcf/eksZZ2m2KST12kWFawSamS0W6lgatG4vfwkxbfCpFus8H/4VVe/55+jKleuKIPzhk1Nx9traR98KNBgOxFeOpaSTYy1YK9F1Ggj+SAtsncpznN7B9IIQkNzTr0UB+qUk3d9eM3bFvOjl/szrio2ZVy9o/0R4SyKyj84ZHk6WgB6/mXJzNpCCrrDyJNEhRVln8eUbSqWFbltBPh2RPGyVZMiqCiUJcaQ1m3JMXHX1p6S4KmeZ2CrwVoymgKk3VjWUSPfayUncKTBzoJhHWCSoVvr0zsmEyW5G41I/EVKo2Ik+Jawsjt5erhF0BBcLCVgMvvJOVv64MHPRQOJLC0W8TmQ4PSZmPHl8zzRreKBeC9PMJf/ryDT757BF//Xuf8fj9JX/47G3ceSEJlQcdX319Ktdjp1GZZzKrqduU908uOUPkECKNiUKGUdAOvotkLGFdfqNwaSAZd3x5dsL1dMQ0a7hZjdBaGnBtI4kO/J13PifVjj+7esxqwAR2z8aETAy26ZMNzeuRFGajQYrWWNpVhslFk68C6JlDHTf06xTlDOlRLVuC0jGbb6nqDN9rwjqVz8crVOmIQeHdXeNTZN1ei25TTz5u6RpL2yQiMSl7TmdrrtYjDkY114sxo1HDzfWY0bShd/LZtW1COZHt19PrQ1TiYZOQHIk35cHxgmVZsLwa72U1KgnSOEUwScCmjjcPb6n6FB80101Kf5Mze7QcNOI5VZUxHouJOk0ci2VJOWkp046qS6k2GfP5lra3bLuUxHp+451X/Pnrh0KRGgK/1KjDGi/yo1EtjWeToCdiOp2MGw7ymj4YXm2mVF1CmXakA65x26UclhWzrCHVgv8EqLqEpkvo6oS4EgoaIy9ejLzHbRMWrXgZwhAoFryi6hLG4wbGDQdlzcVyQnukhmGAJMiytoTSozsriddBkZY9/VVGrA3bdSKN3rjHz3qoLKpV0Bjh0ydB8gEUhG6QHM1afiEf4ecxSf93/yP+bTx+qYv0q9+MHLy6YycXV1IMdROpyhYXE7JrKdCteFh20kPWTyDqyOilTI1VAXYjconqVO0LOMKdPnX9XiBZmmEiK3/txoHl+4r0Vgpr00JxJmbRYCE8rglA2CTocb930NMNhqaVxW4V85/JNNc2gerY3DG7Mxi9TEg3QWgzQ/G4m1hLUTas+AdZhW3inp7iU+hK2TZEPUzRx8N6P5fJ806Pmy0i5TkDsm83HWJvNKzuQze1e5xdfhP372lENL7ZP57RHsL4xUAViewLRu3inrCym4hqJwUZDBOjQg1kk4gJMmmPWtGPtbw+M6AEp4Z+pCiuAtkiYHrZJoRE4VP5fmHQlod0CCT6xoRcTK8MG4g7SZAK0Bd38pzd1MO08v3bkwH5GKUB6kfSWAQD7YEiWUfKM9m6jAZtv0+laK+PNMtvBU7+pWL1tsJuYPxampKbX9N088jDfxLIbgIxUQRrUEEKxsvfkNdka+jnHt1q7FYREs3xD4cEXS3v566BUyHuOeRP/7cRZYdN0zoh5J7j92+4vppgz1Jmn8H1LIfphq61PHhyTdUlZNazbVO0iqyXBfmoY1XnWBNotyknxyuW2wLv9YD2s6ijltBY+sfy5vleC5Vg1LOsct47vuLd+TVn24mwqIH5x0OGwPB8XQabx4os6/dNsU+Hg0TB6t3A+Csp5NOFRf2tBe2HByL92t5RdASBedeQJRvZsjXHQ7Pa3mUtpEto5yL9KK7EcG1a8ZeERJrEdCHnXki/IYUbmjfTivE4CZrTyYZ1l9EHSbYMUQqMq3rEYV4J0q82RKMHOV0QzfEqBS2BQSGNdMcBPVBy9tPytZVmy0boNXreEjpD+3KKP+2gEA03UaGnrSQxzrcUiWOSNXz2/J4U214+l2BAHXSoy4yQBnRlCEnYU4oEzaiIOWKyBJRX2K3CnqVyzRm2HP0IumO/l3wQlKBf04CfOpnCby29F7169EqaFAWvLg44s4EvkyP+9ptfsOpyRkXLd79zxqbPmKYN/8m7n/BP0/fYLgvCIpXNVVCENEBnWccCFHz09QPeuH8DB3B9OZGTuTWCucw8VJZulYr0CpFk9aRi3msm3OgxBIXvNDjF+M0Nl4sx/93NB3z38WuOiy1nFzOysh8m6EK46Z6NYd4TSiU0GKCcNFSXI8I2QWWebCwSstWyRDmNGvV0NzkxCZTjlsX5BDuSglxPO6bTWuQoFxNiUNhRL2mjEZouIU978lJCx8Z5y60rca1lNG2Y5C3Pnp7wztvnMmlXkc0mF4lPUFjjyRJJQ23bhNmk5uZiwvRoy0ZH+iqhjwkv1jlp2ZGMhgm9U0SnORz8K1WT4pzms6f3iUHxvfdecLMusfOGuk2ZlTVbHQlOi7wrpDivRYrTJGwuR8zurZlMa65fzUhnLZO85eFsycdXpwSv0Ua8HaflhlfrKdYEboJmsS1wnSHLhQF8OJU116rNcV7z9vyGz+tjemfYDjXto4Mlmy7jxXrGeptTFh2p8WTWs9nm5GVHc5vKeaYjh0cbbp4diJdmCKwiDUyPpWPvnWwkNtuctrfMRzVLFWlejLGt2ucImI3IUM1WE/qcvleYRtE/7DGZZzRqWC1K9G1CmHgh4exujrUhdBp70EICDx4u+frL8l9dKP3q8e/18UtdpJcvhTqyfTPiR57mxEjkeznoNVu9R4cxFGLJVnSqvgjYjaY54u5Gm0ZMo2jnAz5vpyWLgIbsyuz11ZKGCE7LlKN+5IlJIDtPULvJ8XhI3WuGSckmpa0SwalNHcmV5fCnUFw72pkUnd3E7AusXUHZTWSSbSsxHe54zCrEbxSK7NnOUctkuJtBP40kS3lNyQZiOtQ5g/wjZOxRarqWn7WboNtafl470Zgukt8oTBOp7gn9pJ2JcS5bRW6+D0d/PnQuUSbRpgu8+l87pn+cc/BFTzu3MgGNQ/G4Q1yqoeDRA8llmF7bJgzGviCN2FzjUxi/8vSH8lx29Bt8JGpNNPJ1QpSJe0QkyLSzG6v9pD4YkQgxBLWY7q7wClbtKTO2EQ21NAqDpr4XSVQ/VvhcvsZuB6zk8LqCAazaE0baucipqnuK+J0NVW3ZvidpjURPdml49bcDdpuQfHvJ6P893fPi5wPWsp0pmnvCyzYXKdPP9F4itDseQCQuu/fG51rIGGtLzALH79yw2hQsPzzm0R97QiIJpqf/bcLt/67kYFbx+tkRj55cMU7FkOWDFHT3ZyvmeY0LmvREftgib/ji+T1oNapXEnpkRXddHDS0lUxn+zqhDwkfLiUlT6eeaS/m2d02QffCp9+8Mciv/mgm58AMVM/eOFW+0neppB7cDw5IdgSdThrR9giy6x2J5c5kroI0kT4TglP5taYfkKUhFYrC9ffsPhTMZ9C805F+ne556LbaFeWCcU0q+byrB5Fx2vLs+pBRIXrbbZ9w25cUqRQRX90ccni44bqfolMhXmyuS5SWZNC2SfHWQi2hUUQwayOYw068Nt98xKhIxx2tU+hVIhjakUetrJBCGs0yjnGzmoubyX6ijBWzqeo1ydOcbi4T+mSlaK0UE3FILDW9xt4MU3kv579pZCiyQ+gRB5Rsc8fHjzNJWqXV0jgMa/9YGUJl9kmiALHXkrZqDbddSW4cv3P6nGVfYFVg02c0PuF/9tYn/P7zb9GNDUXWs3g+k+dQOCk+twmP3r7k+csjkRvcJoRUkIs683CbwrwT+QKAldeplAxuVCsbJ5V62TrUlsX5RBobG/nxp28OFK1I4+Q1pR8sqc7G6Fpjz1P6E9HXu/OCrvDYSY/bJKgok/Dl1VRwmmNH9Bo97gnbBGuCbDKiSHCa64JFZ4i9nMO2dJRFJxrwztC+HuGOWoJTzA+3LDYl79+/5JPn9ylTmTaPjiqutyOs8SSJpJ/GqOg6y2TcsKkyjAlYG7m5mmByz+q2JB31jA+qvzB172vLk4dXVH3K9WLMphINuesMWdHDUDNeVmMxh2aOepuyCCXGBtxWJvxl0bGtMlxnmExrGhvoeivPYyxbgsZZ6vWE1a1o5bMi4AftuVJwvRpxOKnog0ZrMaOu1wV16gleYWzg3mzNbVugVeT+bEXtEvl3g8G46y1vn1xzvplQJh3rLuPJ6TV9MDy7FumRzRxtb3n3269ovaXuEw6LisOsZtOnBBRX2xGdF0yqAhbbgjLvaIbNrWoHY6iKEpjVG6EgrRL8LGCWFlzCciYNa5g6TO6hAJs62k0KIy/knlVBOW4xOqDNL55xNBKJ8d89J/3n8TP+bTx+qYt0V0D9rsMsDfkr0Z+beYd+WhDf2dI7zeHHnsW7RsI3ellh92OIE0c/i+ibFP2wwnwyklQvDbtExF2SIVFoJqYekGvlUIw2sip2pdx48vOE5u0Wc5WiesXpnyjaaUq6ieS3OcGoAVnoaWcykd7eUwRjhM/u7+QsOwLJfurbiORjH0E+GN3UTpKRQm9lcpxuIt1YNKTJesAJZqKzTSrBIK7ekkCZbipSHLQUmKMzj89FY75+IyFdB4qbQH00YAyNoriS77d9CH4UWI09OvNc/uWU/FJjGli9qwipJv9Zzur9gM8SCQEa0lltI/p0QRrekXN8yhBuI4W8TxTLdyzHP3EyIR+K5aQSI2d9ojj8JKCC4CBtEwZNupaf42VCu5PnZKs7Lb9t5CTvxppkG+hLMfD2Uyk+bo/BbmVSB5LGml0p+on8Pl0NRWI/NHVaisDuAPLFHYe+OlE0f6nGfFlgapmqd1XCb7z9Qr6P9uSm57PFCY8mSyqXcLUd7b/3bnOz4+Yf/shgusFsPIAxdC/BUNGqPaEEdr6CKLKCscRPX19MufffJkLpCMNnMRw765cTDt5c8va7Z9wv1/zZq8eyJr+cUB7UPH11THtvwTRreLWZ8nC84quzY9BiBDUnMqoyg5GqvilQNvDekzMejxb8k08/EDqHMxwfbqjzgnzB3vi7w3Xm15IKutu8qGGjEbX4KHZNZnMEbhwpztS+4ZOtEqhKinU/NE3NEYxeCf1RyDpQnGm23+5JXw8oVIugD4dAn10ja8+lQA+DhFp5abpGr2Xqv0/MnQRWbc6DgyU+ajQRLBwWEujiOktwiu1NiUoC40kjNA4TCb1mO5j36BUUQfxqN1aai4hoxxWoTIghyUlNWXR77GCfWfRtShzLoELVBnXQEb3GeTHn0WnUyBFXCSoXsovPI3Yt16H2niM7t7hRRAcxrvoyiIxrSCZu32pJn2fD9Unet24u10gAxg4zTMqD24WziD63fyA0Er2yhE50vjEoCQgCilHHOGn46fUDFnnO/WKN1iJTmKcVZ82Uv/P4c/qo+e+++gB9IN9P6YivBPHog4bKEtMgXgsd8atUGgaNFOhR7cOWYhpQJqCT4VzpFVFpQfqmYUBaIrjessfXFr0VhKipFf1yRhJlC+MetqigcI0kiprS4XuNsgF9k+DGknSqih7WVrIFOmkMVpcjlBa9cRfBTHpiHNQDnZZNYRj0e0HBtOdwtuH+eM2zxZyj6Zavro5QJnLxci6DnnEvjeBViSkcYZmiZx1hk7BoLOWspt5mmMSjhpTWctqQp47bmxEm9TR1SpI6TOp5+uU9ypMtZdmy3QoFZzqr2GwlWClWlu2AnqyrlKP5BmsCV8sxSkdWVS4Ul9pyerri4vkcNXKExlAe1qRZz8GoZlkJmSAbd0yLhlWdc7su2TQipymLjiLp6NucNPEc5DXz05qX6xntwEcXuk1G7wzLpsBHxbbOyLOeo3LL6dFg6E07/sbJl1x2E0a2Ze1ynpsTueYEjdGB62rEel3gO40/0mgVsSrggubxdMlXi0Nm04oi6dm0KTdXY9lQbXIJFLtOCPOebpsSey3etNJjS8fk3po3pgs+ORNMozWerrfEqAhhZxgObNZiGs3TnsvVGPjFK9J/9fiLj1/qIr155Dj8aU43gfp+wFaKcJHJTeA2Z/zUsHkEbixr6n4shIfkrQ3FsIJuW0PsDBQyIQo2YlqFG4ludSeFSJd3aDYVZf0bEjFd7SgJ9Rs95jbFbhWzL2SSOX7l99IV7UQWIUE5YWA5K66/rzn4WRR5QqL2E3HlwTSBdBVpD4wUXkoMcdmNvAd/Qd5iBm1sIoQV2yoprockxZvviCwiZJrR86FwXw6x5hGUhZvvGEav7gg3O/yjdpHr34yioW80qofiXJH95g3tHxyzfcOgnZA0xq8CxZUwrYme6p5Bd8Ir31FkTBeHye9Q8K7vtOjJxqNdwJUGlWmOfioM7fzWYxpP1AnX39PMfyayhBd/1+DHkL8yRIsw7t/1mINObqYLSxh7mVYNMfYsUkLhsUvRO7sRhFFPOhGdanFc8d58QdWnpMbx7MNH2MdbwpNIv5LpUT83xCSQXCf0Rz3KaZJbiWhXXyiMh6u/X6G+GJH9uCBkMnVtD+D/8Ot/yrPqiMZbGm/JTc+jyZLzasyyKtg8n3LaDRIP7vwPyWZ3HCmIwv+2laY5htmXwrZXIYKWTUFbaLSPPPx9w+u/HTn9w0Ef7CTxVbuIcpFgRX88+9iwKMcs2inPxkf4xtLWCdlYtK8AZ5+ecHHaMCpbKpfw3cev+cmPnsBU0h27TUqWd7Rdhi4c90+WnBYbXDD87ntfsekzQlT89OlDjlZw8dtw/49g/aYYPUMCvhhO8mHLtZPw6F4ay11MvS8j2Y3ab0J2zHOldufPHes8WcPt32qInWH6YYJp5M/SV4kU53GQNw3BOjA0xE7ShsUfIc9p/a5n9GhDW8+E8uQZ5GFS5Dy/lATHe/M1p+WG98cXXG7HmEIi4Nfrgvj/Y+/PmqVLz/Q87HqHNea4c0/fXBMKUzeAnthssi22JjZFhkIhh/wLLPKERzzkP+AJg8EjDo7QkXVCOxwKy1ZYHbLEboJN9AA0Gg2gqlDzN+8x51zz+74+eFbmBi1aJikSagaQEQhUffXtnZkrV671DPd93U6xvpE4erYiYRHJlSJEomULHtzQE6xkQCjARk7kMjbgWkNlIjarDB15smHNrjbCBx84VC1FEzYINaLSEAf0RYIbO9TW4G3AVsJk785b1EYGHvFKdPqmAtPIdaR6u+bsbE0atVyPhnSdwetA9zLHDRxuJMWjvYrozgM6kuPhUwnvCkajtlYIF6XCWwdlv3nxYurcrVO+Wb9Du4m5MhM+ah/wG9/4gONky209RKvATTNAq8DD2ZIXt0e0pdwKg1OMj3f82tnn/IEKvHxxjN9E6FHbf/9702opk0ylghzvzGFij6uMEFlqLRPtxkArxj95AvDrGDXoUBt5Ttfr0UMs94wuxPg4EN8rsMZRrPsEUa3wMzEBK+uhMqhJK8jKIIVYaOVkF/SpNAJh2qIiTzyuqS9zin3QTyQn9vXFlM0kZZQJKrHrNE/O5qzrlG2ZMMorBrE0MlUZ8+jdK27WQ87OF7y6ndC2VtI/I0fwGtdqypsRxaiXqxWWsycLNqUkg5I4zkZbbncDhsMK5zXrZc5oUtI5TZcICzzPGnyiqNqIpjS0lRUCEFDVkpdwdT1m+nBNajucV8zXAyYjKdCLdcqvf+kT3r89xxqZijuveTBY83wzxfTTc00A7dk1MfMix3nNo+mSdZ3yhckNN8mAzxczCTzymrOTLVVnudkN8EF4+9Ok5H98/SVGScVbwzlPt0eMT7asrgTx+Kv3n/H//s7PY6Y16bDhNx99wLpLOY23+KD4vds3OR1seXozY9XluGVMtDS0DxraicOsxZyNBmU8NmthkTN+a8Oj8YovjK65qkf8yuNnfLg4pahi4qjjwXjNh6/PAHj34RVWeT6+OeGrs0t+eHuPMPhTWKQHfqZJ/7HHT3WRrkxg+fWWwacR8UrMjHjQ84hoq6hOAu5ELoJBW9Glm0B4b0ST9gmPMeilOVAMom2P66slZW+/Ij9Mm2NJ50OBLRXtMBzwiLowmGKf3ClnUJcpdvcN9UwKAltIkTH92B+SIGfveZbvaiafiq58r/nWnWh0q5npp4Cia+tyKRpAJpASpBIwtfz94GU6fKC/tJAuPc1YE6yCUl5/finHwMciW2kmUH65Yvx5IhxoK5PzNpdCx27VYWoGIifofu+E4W1gcKFohvJ8QUN26w9NRX7lRGff9sa8NvQ+AWGOQ488bBXZdXuQopjKU49Ft2v7BE0X6d4EvNfKw+C5opla6rdq9K3oVM1WE8oU299g7dIQxo0k8l0NOPu2YvMkoj7xOBs4+SNFl0fURxF+Guim5hCVXW8SSDzNRY49LSX9cBVB5rFzK5zp0hBiTzt1ZC+l8ClPFHnWUKoB1ZkUPcHKa/+//Q9/TsxmXuGnrdAycjHzffXdl7x3PUB5e5CvhF72snsEs/cD9ahPPe0nl6Pnffqt0izf0Zx8v5N0xlqoOi5RPPotCdWAvXa9N6hahS0czcSQrAOj78Vsvt7gN7Gwn3tz0mxY0GSGeTmh20Wsb1KKYkp33opOc2tx/USyWKcoE/hPv/IDPt/N+HR1TGI6zvMtqemonOUbb7/gs+++w+yHsH5Dkyxh/kstww+jw7S8OpGhYXYtJl3TwPaBHMegIH+lDmmfvv+zfc4BSo6ZmL/l37P3U6qvlrRDkaV1mXwvi4cevdGH60Ayl+ewOwiZNA37c7sdiSZ792KEuucxn2lMS58JoHj17Jg33rrCeU3VWZ6tp3wyP6ZqIs4mGxplObl3wyc/ekB8WkpK4aBDbftCMwrocUOUdLS1RSnoCksopJCP0o6u0r0EwtPVhuA0rjWUnSaZ1LSvc1QrrOb0lTSizQS6kZCj3MiRvrS4FNpZR3evhp3FXsUHLCMefBRoRwEGHbOzDT83nXNdDnj28TnTRysi69gVCfpeiS8jggO7Mr0HQOH7hEjVKsyslqj2KiIEcGOFanqmOhBKK5kWWUcISszNW42PPL/9gy8xPC74jccfs+sSplHBRTXhF2Yv+ezlKRQWPJijBmM8/82f/CJKe1TsUEnAV1ZoJdaj4iCbiCCNrk4kpdp3CnZWVi2DTgx7h4bNQ+akiM6lePWz9o4N7xVmY3GxDHmUFwlI00oA0tHRjpvXE9mS7B9WeO/KBpSR361ij0k62QgYjzmXxFMb9/rkACZxghPeJoynBVUS0TaW4bTm1XJCnjV8/uqEZCCoS41MlDunSdKGxS6n6zS32wF5Jlp25xXl8xH6tObNBzcsjrL+zzVVGXP1esrsfE3TWJQPLMqMQdKw2GW0tRWMow4MbENjDWfDLZ9enKK0ZzYuJIioNbhaCD6zccHapLStoe0M211CFDnyrGGxGDCZFqhJxYfzU9rO8Hi85H624p+9eovvb+7jg+jp40jINLFxeBRvTBeM44qnmyMi43jv9hyAaV4yimqWdcaujblYjhlmwtWfZQWrRuQvLxZTXq0mHA93jNKadmaoipj3F+d84+c+56ObE0JQfGf+mLdGc5Ztzk0zoHaWbZ1II3KVoPstqL2M6M7au+1HrQlBo487ki+t+OLshsrJd+SqHOK85sl4STWwLKuMxhnePr8RmU0nxppxVvHe/ByrPc0+Y+Bnjz+1j5/qIj26jIiIqM48+QvdT38Fq7Z7CIMXCvUsFkbyETQjiG8FseeOOwlF6DTqOgbDQRrSTAPRRor1buRJrsXcpXrmtql7M5rtMX2lQoW+WEjg3u+7fiImRdj2DU/2WuQJPpKJ/vyrum8AZApjarj61cDRD3RfWIHTAZRoopO54uaXYPBUkV0iBUgjlJQuU5Dup9N3wTym/+/eihnTxzKJdSnsHnuaiaYbBmbfF61reQ+G44p6ksoFpgx9oqm898FrKfbSuaR07vnQXapwBIavHc3ojllu6n561ptGD9r3Xu9fTbVQY+q9iVOMqbbyVFNDm2u6TKgoXaoIWp5TeTG5tgPZOkw/6XjxH2nsRYyphN/uzhomsx2dE+NeVUc8Pl7waLDim/MvYstAdqkYPVXUEyXnxlY+r/RaET4VuUmwUH/FgQlMf2BIfj+/8yMkcl7c/FkPkeARk1vRuRbnivLnKsLtAGYddlpTjmN04ihdT0cwfShLow+6Xjtsef+zBww/jghq//lJk+W3kM4FE5msPes3RaM//SQcgr20Uxx96CmPDcV9xdGP/MGc22aKdCn/ToBnf0mm6mHSoRcRx9+TQnT00lP+WktyJG7rR9Mlndc8vz2SNMFJg+tZ0d3AEzoxUx3dX7PdJYQ+ht1Oav7bP/4GJhXDoNtEPB8f8fb5DRfrMZt5Tnwsuv69jCR7FtGOxejcZRy0z3s5iakDx+85onVLMJrnfzERMMqafqMlCjWRNIDrNeimby5NAfp5RnXmKc9h9Ikwz+OlprrfYZfia6nOFMlcpsfiPbmbyhePPGEsKB3farZvSVOvvEIX4lt5/t49gobxkxWbzyeEoRQTL4qIUBtu1waSIBi/oLArudl2EycbvVVMrWJUo/pUUEUYddjbiMbKlF3FjtAaGVoFaRBCa6lrIzKWUmOWhmYcQPeDh0oMjsEGmi+V4h8wnrCKsYU6bJWCDXRDcJnw19HIpLPKeDxcknypo3WGz56eYTZCoYjf2dKsE2GuO1Bre/C/oMAtEylwnQh1zdr2IUwyVQ+mb4SqmKAC8UaOv0sModA0I8vz3RFWe37vxRvSPNfilWDgDkz01SJHad8ne4pHIngZ6hAUtjcYdmUkA5zI4xsjCY9HtRTDaymI1LSRwrzs9cbWH4z2oVPoncFnXor/XpKlHBCD70ObfGe4vRrz+MkNLz49RQ868mFNVUWHRN6AlkTenraitoagDV1lCDbQei3vdSQFfFlEJJOK7TbFRg5tPE8vjyU4aiSNnNGeYp2x6LSw6p0m1IZkWnE0KrDGH7j82aAme7zBe83Ti2O0CfgeV+kajdoatuOE6bhgvc3YrDPUpKSt7MG0urwe8nNvvwRgXuWczdYstiJS39Wx4FxbzdGoED571FGtE8ZHG3Y6ZrtNmR6vaTvDZptyOpUpdVlFvDm4ZeeSwwTeGicJqtrRekPdWcZZxePBAh8Uj4dLlk1GpB0vF1MAyjZiV8XMhgWjvCI2jrN8y6pOGcU1sXbkkWwcOq/ZdbEw500Q/bo3nI83rKqMT56fMXy7YZbseLmb4LwkreajmgII64j6XpAmb92XaY0if7JltxSja1tansZHfGV2yc4lFG3Mqki53g45GhSMk4oH+YrP1se8up2QJB0hwOOjJXUnRby7Sv9XVlH/lh4/EYb5vxuj9J/qIh0P3QiilRhAk6XcrJux3Nz3QUdBQXrT/4jtjWVTAytLGDrcyKFHLV2fBKcL0xscQe1Tvvo1N0iRq5z8ewgKl0nAR3IrRtXi1DB8LVfs7QODcoFmItPvZiKTq+hZ/9G1Utx3eQCvuPnVjuPv2L5A7s1zHgaXHYNLwRje/pyWqf9Okb+WXyPBLDJRD1rdpbEqRXkGhZapUZfvQ5D6jUElk3LlYfZewP9oQtfTTZQWY6WtJExnLxtwsRhZ9xKEwWUnBSu98dRrbCFmRjFnSnEjAUOqNzRKoNHgtesbCEU9NTRDRXVkD5+V/E59Z4j0IgGydaAeS9G++bKsUPRbO7TxPDlaMktKUiM34/vpipfllItyxMerE0bHO4Ie4xK4/TOO8XuWqLzTfu+DSAQFqJh+38gmoRCso0vUwT/gjeL4Dy3rv7jDjGsqmwvDulUEpyV0og+FUTaQD2u0ChRFgqsN1FJVqk7B0NNthBvpErj9eTnG7Ux41JMPNdmNZ/71QHKj8Ymww69/oZdImNCTguDoRyW2SvERVEeWaOcpzjWLr2rcSQuV4d43RVrkEitm3rQ/R1JFu05QExgNqoMJ0lpHVcT41khBtLKoYwkEs9cRqyyXaWCfUOmdRMEnaUtkHRun6HYRH3//EeZcNhLNo0bweQHqJ17IJYnHR/1U2coxjjYcKCq2guokJto6Hvxuh4sUzVizflPScPcUHxWkKW1GQmixpXy+6S1sjzyq1mx/qRJttlOYQsPjkrCJ0a2iequBrSG5NbSjQJdDN3Wkry2ti3Cj7pDo605asklFuU57TbPQbtbPx+i+oNuTRFBBkkV7M2A8rOEImm2M8gqVdSKzUAEa2yMTPaxiKeIrOb7xqOFoVHD16Yw9KlF50Y+rnhqhAjgb8AOHn3kxdd9EqJWFrZFExP5atm+GlINoKw1geinJnl2uOXpYktqOdZNyWwwOFA6XdfirFOUV9x4ssMZxMR8LX3srjakrIqi0TKcjL/rqgcgAUNIMu1GHLg3RWhKLXRawWyV+hzjQ3qZsj2OGUUM1zwRdG8BnntPTFf/Bg4/4f372c5S7RHCEScvJcEvrDa9vJ2KY9JqutlLYVwaVOnwtODvlFfp5hjsWjrnZaQlEY1/gA0oRGsXguKBYZ3IdHXn5HiNNYpdLcy0DGA0mYPrJ/ezRiuUqZ7fMuH9/weXNWLwckSd4oDS4gEhu0h55WfYIychjYkc8rOk6Q32ZY48rtA7kac2uimmxaB1Ik1ZSS5HNRTKsSeMWowO3r8dcz1Pi4wrvFPmwZrfKMLFwhkOnOT5ecXU1ls2GV0T3C5pNzKIx2Mjx5HzOq8WE0bik7QzVThj0qyblKClpnGFXiqyt66f4R4OSnU6Yr4a4VjOd7cinJVeLkXw2TjFNRepirOJ2PWCQ15xMdnzz9Tt8aXaFtW4fNUEet/yH9z7kvc19Yu0ouggfFNf1iNsyZ9fErMuUNJb01Lq1zIaSE/D2ZM5NlfN8PeWt6ZyPbk94Y7ogNR1FF9F6w2I5YDwuqeoIozy7NiazLYvFgMGk4penz/h/vfoqv3LynG/fPGa3S3G1wVxHuIEQlsy5eEZWlyOUUzinOTtf8QsnLyldxO+/eIM/KJ/wf/jCH3P//or/9unP8/XT1zzMlrwspxgVSGyH1oHdUlJnF2XOw9GKqotIH23/dSqnnz1+go+f6iK9nToGSygfOtJLIzptBfEGwg5W70rwiO3X3yr8mMFPAac1ydOU5mEjiXjjVlaglT4wtqONyFf2E03CjxstexqA79nYNbSzwO6BAkSqUM16/XocKO/LP6evLe1Aio09KUZ1oo9Mriy7+xCvFfll6PGPgS6X4nxPqskuZfq4e9jrlrX8HpcHQuJQrWb8gaGZQjMRjbnd7Yuw/vn6xiNd9LKXXt6y522btr8xBblJ28ITFR4XKdKFox1qulRRzsxhc5Bf9ZroflJuaw5hRsoHyhN9kB8kq8DyC7HIV2684CVVHwqT9seZO7TkfqKsXODZb2rufUs+l/Ezz+5tT/d8QGsDT98f89HMcfrGnNUu497RmnfGNwyj5oDCa3OFreD42/bAMQ9KHaZ+ppH3Hm+lsIo3vp/mq0MhL8ZO+Ywmv5Vz8xdaQXbGAbPWuMJgj2pC3tGtEszaUKytGPVyT4g9ptSE05rQGBQQjWvBoJUz7FaCeWbv9VIuZENx8keyjbGFYAIHrzlg8Gzp6DLN+u1M9LP9a+wyOabH34dkqWnGmmYomMdk5fvPKhzkTCd/YOn+szXLVU6UiPxgnNV4r6mWMU2TombNHU408/hSXM22kKh5v4kkoTJ20EFojJgD045BXgvdwSv0VkyFKCEbOa0kwMeDTnsWdWlQwTB8Bdv7lqgQA3F1JEZTUweSOZT35LyRVFvR/++/s/tgLeUhmlvaB5JOaLfmQHvqXIYBfO5hY4k2mubIE6JAfGuwr61cG1oOpJAwEoNkeZ3LpNr2GuUUkTQMnYQJNVKwqSgQGi04QKBZpIeNGk7hnZJ/zhxh1EFhCAMIWd+pGlAq0C4Sbp/n6PuVFJqTBtdpzLVsD93A4waO5CLC7Yt2JwZo06o730sN5bu1BMm8zgk2oN+oOBnvuPnjs0PK6CSp+N4P3jxMklXmMMbTVpb40Y63Tm4ZRg25abhajhhlFQ+PlizKnPk8kfAjp6SgDYBTuNMWdkZ8LpUU6O3I9xsxOb+FfgQ4+OzD+5B36KxDD4MURWnH9fWE/8vVr/Bn3v2cb3/2BN8bZV8vJ5JomvQFr/Fo67GZo/YJNnW4TYRKRSut7xWwSiR34rQV5ORQfja0GjtqcN5SLDPRF/eeGmIvm75xhy4MeqdFRtOH7jTrhIvbCVEs54pJO25Wwhzfk1OaXUR6WlBd5WJW7Qt8ibSWrZ2rEsrUSlMx6HCtIUtbVuucOBFW/n5CnwzkAlrvJOin6A2Tv/TlpyyqjM9fSUiI1oEoa8nShrq1DAcV6yIlH1dUZYzfRhyPd6wjhzWCGbxcj2iKmNmoIDaOuo4Iu4ims3ywOOfJyRxNoO6kOE57slGcdmjtcbEmBGgay3RcSIqoCXx2c0y1lRTUKOrQKrDcZdybrPnh9T2UgrPRhq9ML/lkc8KH23PWTcI0qQB4XU74bDHDGk/byRa1aS2RdQwSmfjXneEPP34DHXls5Pjak5ccxQUjW3FTD/l0fow10gwsLkfo2PHZ7pTTkzWawF9492PWbcr723vs6pg/un3EqkgFNasD4WEF2whGLd0qYX0tXP/4tORoWDBNS16XY86zDX/u8ec03vDe5j7H8Y6/9PgDlm3OZT2i8ZbCxSzKHGsd6WzH+WjDO6MbXpcTjrMd2aTjw3+jVdW/gUcI4H8C5JWfJY7+6X9MPzCoHEwtUevtQAr0PRM5u1DovpjaF7emDzmZfqBZfyHBJYHsk1h+JkA7lWmTLdUB2wYc0G3e9uv0/RpXyw079OzkaKP6qZukjfpYpoGmkkLdZfJD7UmL2xnipT4U16aU1bbSwlnPrzgE83TZHbvd5Z7mzJG+FF1tsoNg9yYvQzCG9l6Dbg3VmUO38lpcKmtzXUshvkfTFeeCa5x+GA5UFVsF6qO7yWTQdwQWFWSiX49lCpcue0rKWFOcyw3V1MJRD70Urxnd8ctVB8lKJu3pMmAqT3FmGFw4Vm8ZNl9vOPlmJLr0nj5imtDLduS43/8mB7JJmyvs0tKdNVI4PXC8ezzncjNiNKgom4jvXT/k3aMb1lXKfDVk2iefomQL0fV8blsLDtBFCq1DX+wFypnGNBw2AUH35sVIHYg8p78dcf2rnuTKUB878OBWMZP3LLqFxc85iX0uIplezXPCiRTo2bSk3CS4YGhaS/ZKk19Ks7NPSN03Nz4WWYJ2UJ7C5NNAdSSNh4/6Y+xAeynS98Fb+YUgHK/+jObkj+78D/VE41LVp6uKxCraeRabjJOjLYuNJPFdL4fEcUd0KjfEtrJo60XCUEoioKo13bgnYjQa1Wq62tBsU0gdo7EEmbw5XfDKjGEEm0FKdZ1j17r/HiooJEb+wdmSrxxd8j/8yVdxiaHNhc7kYgl9SlbSTAUtn2P6AZQncj43k74477+ze5mVdrLNMrHDrWK6M4lcb0xAHzXESUd1I7ztYITc5DNHM0WwhSb0qZsWJoLaIwa/iPHjTn6uLyyDlRh3nfiDGVQZSYZVRtbheMG2EYsZMAQlgTEqEBBMH643PMNdkTvo6DTo2wSigG80ZivmaV1JbLjdaLo8kCwUzST0U+u+8Os9Ni6BdCANLArsVtNmERdXJ0RBGnpH4PvfeVvk4wH8tIOtpTaefFQxyWXj8s7JDUdxwZ99/JTff/4G1xdTmc7GXgKOAuhWvmsh9vI+tDRF0dzQzBwkHh+kYO9yuWb5cSeT+D5pNKi+0Ym9yGgyx717S94YzPle8gDXGeoyEulKj3g0iSN48K2hqQ3KSsqpqjUhEQpLs4vkc+lD7QCyUSXJqEoSPFGgI9GIt0fSOIUg5lgVezwC5wk7kaw1iSEe1TS7mK6w6NjRbWJU7JidbCVVs5TvUrlIUZnIV0Jr0LcR3KtEFtPr98ezQgJ5Vhn5sKKsIsE9dgZjPGdHG64WI7zTWOsYjCu8Vwzymixq+eDqjK4znJ6s2ZQpTWWJ0471fECUy9S56zTGwsnRlqt2QtFENI2V7I3aEA8qylpzvRxCUAyHJV3acvlqik4cn7w4Ixk0ZEnL8WBD6w3Oa07GW1ZFRhy1kh/gNJH20uzVlraV5NJ//82P+e71QxpnuDdZy/2ltSRxy+vlhGdXx5webSi7iMfDJS+3E6ouOuAlx0nF3OWMsppVIbz0280Aoz1fv/cafXKJVZ5pVFK4mPvJCqM8PijyuGG5zXl8OucoLTlNtvz20y9wuxjy5Xc+5TTZclMNeLGeEFlHalu8H6CNx3cG38q2yNcG1RunVdZxOt5ylouEJzUdiybnuhzwcLDi3eEV76/v8bKYkNqOJ/mcB8lKmpAipW0sLpam5ZPNCW8N5/zOs3doVu2/Tun0s8dP8PFTXaTv9aJ79JpWd9g2FaRgL+6J+Ws/MdrLXaJdkOmpFeKLzzzpKyNFspNJpW4U3ZsVobCoQUf0Wdqv3MUc1I5k8miaPvCkl8ighZfs435CGwXagYdBR/JZQnPkyaYVlUkI61i09HWPStS9bKFQfbqp4vlvymtNbuX1n/7CNdffPafL5e/t3nBkr8zB2NactUR5S7yNGH9oSBeB9RuKrk8glfcXGH0Ot78Q0GcV/jrl4jc86StL/bjF3lgiyakQ850SGU/SF+TtQJHO/UFOFHp9fjLnwLveH2sJEpL343LZIEixH3BKjKSDC5nMR1s4+8cR8VqMrvVY0Q4U9USTLCXhLSgwje9TSYWfnn9lwTQvudkM2N3mfHT5EPrGjMyhY8cfzN/A1waztazegfBmgW81IShO/6cY0zO7pfjvUY1B3qt2ElZ04Of3cpgu7RuYRgr92fcM819tUZFj8L2UdC5oyGaksDtN99EIo2D0g4SjMqC8pss0bTbGHMHuiWdTWAYO1m+JJKk5a8mfRgxeSlKpmIqlYBu9EJmKrcKdHCtW2J4kpAJipu7JQekikPyhNBq3X4NkLhsbUwmfHFS/RVCM/1lG+Ctb8qxmvc4YjUp2RSJTuqylW2ZwUhM2EX7USWql75F2VoJYuElwpcUMW0bjkreP5kzjgm2bcjLYcZLs+L1nb6KGLWHqMZ/m+OMGSoO5jXgZjrm4naAThy0iytN+Um7lc7GVSLhsIVurZCXFeTMNZK8V9UwSd72R4xAS2D6SIszGHS41UnCtYkYfG3ySoVtgBO1A5EPKAbcRwYh8Jl7Jcd49AJdaTCU6bttB06MPMbKSUdpjIk+ctBS3OXYkDUE8bggBOmMxkcc1ok22Q6HjoAI69rimNzM6dRcQlIoswb5K6O7L78ErVK0xlZwEd3SmQLzusbOGg24aZNIuWhygsYxGJUudoZywvoMN+DdLwkXab47kHFOdQq8sPhbN9zvHt8TGsdxl/PAHT/jhqEMtI0ypiRtoTp1cq2uNTzxmp6VhaQwuKHQvuTEVqBtDO1FEK32QLQUTiC4jMc2ftXc4xES04HQaKk1qW75z+0hQjPP48P0PsUcVVsK+rJPPu7ISJhV51LQBp++SSemPZy+HLOYZJuskBOk6IX28laK9l5ipwkDck6+WEfnjDbubwSFsjsLQVBmogMocNnF0CrJBzWI+YDwt0NqTxh1LlaMUuNJCYfC5F7tKJ1ImPWxl6l5bkmGNNY4HZyuutkOqJqLrNK8vjsjHJcUqo9WWdNCQxC3rVUaTy2TDtVoK9NoeGkJUoNunx3ZapEGpZnayYb1NMdZT7WLSYUNiHdjAm2e3kvbpLMudJZ1W1KsUFTsmeYVWgWdXx9KoeUWaNRKE1ljZajrFukz6hNSAjRz1NuG3n36B//itH/Hf/fHXWZkh05MtkXVUTcQgbWitY1MlOJdxsRiTZw2/du9zLqsxx7MLvnv9kFFas2tiTsdbms5yf7jm65OX5Kbmop5QupjjeMuraoruC/Z1lzJOK744u+bVbkzlLM+LKbNhweSk5KYe8On6mDxqyOKWsol4djMjz2qOhgWvL6eMJiVae46yktvdgM0qk82AdmgVyG1DZlouyxGRdryd3/AwWdCNDEd2x//jxdf4wcU92spyMtvytXuv+d6rB9SrFH0S2DYJL4sJ/96TT+m2NZ//r66k/i08fhJT7n83Buk/3UW6t3IvFHMRfbS6GB2DkZtUdtVrift0TZdB6Atr1SmCFhOVahTVo070niYQlVrCiNZRHzihaCf+gF8UbbRMNE3BYZrXHHnsrg/zQKZGbeblBqUs7VTW6k0lExXdQXXqSG4M9YkjWhtMqWhmgeKeIl4jaXbnNW2T0E0cr57P0AO52e1DSYo35O4bT2pUZemWCd6K6RJg9sFeriHHbo+WPP89uPrVTG5ktUyLqTTd1OETjUs028cw/lTec3Fm+tRTkU/Ea4e3iuJYthmmD6NRXj4LF0OXarLebDp+5lm9ZVi9ZUTCoWGVWAavIF14kdTsJFFUOaHESNPVM9CVTK/leEtBsv6Cx18NyR+1Pe5MjgkKVK2JXsbyc2+VRFnN2Rs3vLqaSmH2ge3Pl0BrFeS9D8Ddxc/rRt6XBEtJ86edmFlR4LUYQU3bG1wDsIkYvpZGxfeSpfHHUsDGW2l09oSVeO2IdorBZWD4UnP5ayIJGr6Q7dD0Q9FZ7Y2Ruu2Nef1GUblwqC2Cku+Fi3uJ1p6vHavDf9tPk48+kJ91iWL1hcDgFSSLcECNRrtA0cScDresXk5YlpbzB0smacnT2xn2Xkk7TyH1Mn0sZXqbvrGmc4auNkSPdjyabPjF2Qs+3pxSOYvpb1SfrmZM45Jfe/I5//Tjd3CLRBCAO9FhdxPRArtGS1qkAffLG8qXA4IJxHPRMzcPG+x1hKkUu7ccutQ9mUS2Ti7WxGu5RuDBzxqitKN5OSAMHB7RXQuxSbYP8UoamENmAvKzLhO6i4slCXb/vc+u6YPRpMHR1pMNGoz2VI2swEwu+D2/jpk+WXL7aiLJnacFJlI0RURT9Ouy2ggRAohPJAhNKdG26z36L/fo2+iQeBlMoJn19JaEg0HUJ3esf+j9D/11zE/7pkIFFpcjkvOSrh0QraWAeufBJR++fANTadr7DXopEqaQevHvzGO+v3mTfciRAtQikmFGj13UhcbUcv7pTqRQ0f0C1xlYxYfrZHMUDrKf/ZYsWit8IudxsIH4VURz5DCdNIQ+k9WerjTPfvBAvgMmEHLR7u8N2SHxqJ3Bp73Gve9pVW8aVXYv7RNpia41PvZi4Mxk4q4TR/pYJqGhNVBq1NBBBKoQQphuFfUnY3QsPgCl+4TYSYvpJ/p5VlOqmKqMmR1vaTtDcTWgSJ0U/k7OOzXoiIcNbd3zQVOP0oGmspwdbyiaCO8117sh212K1oGjUYEfKebzITZrcY0hiVt2RXIwePqghBYTFNNJwWIxOEyw99K2EBRR3LKrYrnFWE9kHfVqgE87rq7GJJOKl4spPohEqysjTNoxOd2QWEfVWrbbVMg3kccmjmKTii8BIPGERrNrBBkanVRY43ny5ILr3ZD/8fMvolqNzhqa1qAUaBVYb1PiuKNzhiTq2K5T1o3hv7/+eR49kiTj2DjeHt/K5Hl9zF988AF/snrIHy0e87XpK46igtLFvL+5z3GyJdEdL8spAI8GK7ogw5sPX5/hO82vvfMZWgW+9clb/Cdffo8frc748uSK78/v8+h4wSwt+eNvfQEdBTaVITkuefrZlC9/4xmX1lFUMes65YuTa75z/YhdmXB/uuLN0Zw2GH5U3CPSnn92+zbvTG/4KJxytRtzuxpwsxhiI3dINy3biHuDDbWz/PD2+H+5SPrf4hEC4Scid/kJPMe/gcdPdZG++vkOPRJ8nd0J3UW5HlG4hOWXhUVut5r8EuIqoLfgjeL254VFbGpFaEXW0Y56LajuCxUN0dqgbw2mlGmZbnoJiwL/Zkn0gwz960uqDyc9HUGMpD7xxDeGduLRjcYftTJ9OmoJKsI8z0S3awEb6L5YYrXHdRm20MRzka+UZ/3k/lUiN8HYMz3esv3hTG5GRhHPKtpSEG3tMpECNfYoZw7oOW/UoajbSzVERqE4/mOwtaJLFOu35Xh1IymIu0HAz1rWRPCwQmlPu42xc0t2qXCRoZ4qokIK0f9v/KTyslEozgz1FG5+CchakucRk08C8cb3gUZ9U+NkChsVnmjTyz16U6ogJcOhgFZBpC5h2mBjx8XlFJu2uKsMU2j845LsTNIcTdZBEIzguhQ8oJ3WVH+uZrON5fuuEJPUuBbjpPWYrMPNE0kkrLVM1Aspomc/lPeom3Awk7pUGoPzb0kabjkTzfQ+wCkqwoEK5CIFSmFLIa7s003v/1NFM5SmwJZ3m4wu2hc6P/YlCCJPcX3IlTQFfWiWloZm9YXA9EcyTfdGHegu+82LrQLTD6VwW35JnmP6oXwe6ncnnP7nl+yezFkVGasiFV6yl+REiarvi/RJ0xdAiuPRji8+vkYrz7LJeVEekdqOP/rsMeuzlK/NXtG0lvdvz1ktxXD65rsXvLid8uh4yecvTwR16kUOpivN7rEnrBPx0C3NoRm3H8acfq/l+hcj7MqQv+Zghow3muIcyvteCqXrGHMdo6oERp5kXPPO2Q27Nmb+8QOc3nsN5Lj7uKfM9KE9qq9pg70zWdZH8rl3o/6DqiR+frdOGYwrjBYpQujPIzzMb0by+XVKmoWprK1t0hG8hsSJxhWolynogNkaOK3xJvTns8I1YjzO3ijYLHIhSeyn3YoD43u/0fO9H8WdN6itJTSSEusQfXVzkUPkaUcau1W8//Q+X/kzT/nRi3P0TSKFt5WGXhcGP+mEOpJ4uR41Wgy4/caLKPRyN0c8qekaQ1jGNNuY0/MV5ihQdZbtLkE/zWlHDrMzdHnfRETcYV8DtBOPqbSwyVWPw0XhhkLFSS4szVFAJw49aIkiR1P1oTCItMVMG1yrZRDX9EmeaUu7TqTBA+yjHc0mxnshuOizCldZinmGTh3RsMHnCreKRS4zEZa5W8WirQpiHtajBj+Wf9dGiuxZXvCykqZrU6Q064T8bEfTWLoykoZBB7TxslXpDe0gMqoQFK3XTPOSqo24mQ+J0o4sabldDnlwuhR8Z2UZTUo2vWxtXQjyME1bijJB6cB8NyQ0hjhr6SpLXaXoVIzLtRePROgEDdmlLeMnK6Z5ycvuiGFWM4oFq/l6OSGf7QAkA2BYEVnH+fGaXR0fTJt1Kjr51Sbrp+Yx0+MdbWfYLTPaIuKjZdZvowLpaUFTWZqPxoTHlVzudGB3M8AOW3a1YTiuGCQN6zKhc0bkLZ1hsc35yvklWgV++/JdrpYj2jLiPXOftx9cA3CSFvzh5ROSqOPL0ytcUPzj97/Emw9veHY1w0aOt89vSE1L0SU8OZ/zj5++yxdPr/mDyyeEAK9fH/GpU6jjFkxgPC14Y7rAn9xwtRvi++thpB2X1YhRXPNguOY821C6iN9+/S7ngw3juOLjmxOZtqcN6aChbQ1Z3rBbp4wGFe9/fh9lAqt1T8/pm9yfPf70Pn6qi3RamVrGa017r4Vao8cN7WV6N1EbdHRD2CYRnFeip1wkmFKRXcg0eB+eorwUsqoV6QkIRcUWiuKh741XPQN3EFDPU+ppgI8n2FIdtJ/eAFomxdFKU99v5UKuwL5K8Jln9o1r1kWKX41EI/pCSBzRWlEfC9Vgr4EHwTyiIH4es2QI92p05OkuUiIVCOXdqTCYFZS7mKAjgpFCeT/x20sipCiW16p+rCFth6KftxtNN/bEVxpfSjiH/iyjfVQTjxrCsKEKOe1ImonNgxq1jKTx6RMAXaMxVzGmEXJMehuYfKqwlcLFvkdWqn6lLS+si/u1txdtvreq53/vi6SAjzS69YfJJ150koN9mMa45fxLC148PaG8TlCpx28j9KBlucvQ2hPHHUncsVrmYCR0xTdGpp2hb2haLRpvBWZrUPdLTqdbiiZiVySs3nHUNxmq0cQLxeCVyCEmH8ievT5SuFwi47WT4CCXSBFsas/6TUN+HfBWGswuF511l6kD31sOpEzd20HvS9j7IfqV4v4c2ePuolIoNPtNQzIXuYOtpKFQQX53carIbsMd1SYExp/0U0wFba+//84fvIufdORHhSRltprJwxVlHeN2grGj0IwfrpnmJc8+POer37jkSTbnvc19vv/yPoO85tcffEbYRrzcnNI6w2aeEzpN+lpQfS8vHpJfweVwgB0FfBLwCoafGGwlhXJ5FpMsBNcpGFJ579ffiATTuBO6U7LsKUa9dGf1c+I1CRbGHymSVRDz7MshH0+HcvzvBaK1HHuvZWMSbwPZDYcNVJdIENnBixApkRvtILsyNH++oLUW3xpM4ig2CTZxDPKa5TgSmUrScTLZsakSIutYrzJCZ4jzfmoa4M0HN8TG8fR2RllnmK1B14puGUPea5pNQO0MyYMd66shygoa0vU6d7sU+YbLgywK2j6czSnC1uJ7I6o5avFOEWoNuZMgH9fTVV4lfHTxBt/485/QPDJcF0MuX06l8c+daOqdglK083Zt+vMn/Ng5qaTwrjJ0pfBJIOws189m2LU+eIb8eYPaSBKuyHA0IQIX6PX8cp663IuEq5UGoz1phfjhFfW9ToYUTuGcIYqcJHj+uA4e5DUHMf9mw5pilQnSstYyDV/KUMTsDP64wa1jVNZhUs9svOPmdiSaY6cIk06CkHqc4/R8Qx637OqYt47mPF0dEWnHze2IX33nKR8vj/Fe7l1dbWQQ4EVesjflHp9sWCwG7N/0+LgAJASoKWJuXk+4NSJRSYYN9Sahvs7R44ai6bcTkcTeA1y+mjI+2aG1p9gmvHHvluvtkLKIwXqqZcr0bMNmkwk6MnPko4pik0oK6dbgI0fbGW42or9ergasdMZkVKJUYJqXtM6Q2A6jA2VraVp7CBZal6mYObVnOKjYbjMmsx3LqxFY2YjsqUbxWBjv1TYhHda4Nwu6IkJtLOa8JJuV+KBIog4fFDcrYb5vqgSlAr/y+BmVi1jWKZO44gfPHoikB1Aq8OmrU5QOfFxYVCef2+ubKbPJlp9785UU162h9YoPP73P9lFCCIrXL48wW8P3nw+l2R06SD2T0y2zvBBeepXQeMOujWm94Runr3ixm/CLs5dsu5i3hzcMTc2yzfnDi8c8GK+ZxiKlaStLlHaUdcQoq9iQsltk2Lzl9sUUWoVPPTrvePXsmOB3/7+qo/9tHz+TuxweP9VFenxrMLtIsGyDBhcZ0h9mFF9qUBuhaJgXMc2pw4071DZCVZp4o3FxoDoNfVCRaAvbWYfZGbLXmt2bjvjWHNIM02vBgslkV4rpLgPbiCGTAMlCCfJtAq6fljZHnvSoElRja3CdTEJWf3hKlweMBrO2cvOspAhTLbRvVkSfpRJv7jT1sSfayIQKpw6hIy73VIu0R/h1hNpQPh1JUE5A7nBwKHK1A0IfJlSEQ0EWlJgmRaojJBgfS5MSeoNZtFHozxLqe0ZWr6kUNe0okH2YiFE2CThi8ntbiibDnTU8fHhL+4N7KC8ymT0NJt7IOnxv2t2bQn0kFBXlZXqerB3V1PRFvZFk1lgfCnu1sYRxy/ZGmLx2ZXm9OEeNO3wcIHOcncpEp20Nvq9+yzoiyVqZyKkg6YmfDulOWynMNwa1sHSnLS72GKe4vBnja4PeGepxR3ZaUMwz6iiQvzZg7uQm0SYQr/ZmVEWX9obdUor10Uvf030U1ZE6TNOLU9UX79JgdYlsOtrhne+hS+ixi3KMfATRtjcGKiUBRjFs3uiLmqMGdZ0cTMzpdS/liNRBGlI8kAArU0vTpFuoZ578lWY385QvRtiTmuGwZL3KCZuIwb0tdR3hioiqibhxGjVq+e7nj/h29aaQOXRgGxT//e/8ElGlSBbQfv+U00L4+E0/VCbA6j8oxJz6R2NMb3B2iUhMTAnVmXQv2TU0Q9maRWtQZt/cyf97u9+qKXaPZAuiSsPRD9WhKDRVIKtFqrLn/QuF6C4DYb+dkC1Rf775/fmq2D0QTb9ykvYa/eU19x+smdc56zolBEVspZBYqgHHJxt2ZcJyl5EmLatlLnHsJuA6g+lTJK0WE1tkHWdvXXG1GtFUltGwZpjWXC1GdLtI6DAvBqjUEw0kQr6rUugU6S24Pl9AOTGuA7jcoSatYCKRoCRlPclJSddYXB0f5CqqEyrMdz98g3fevCCNWgbHBdWzEaPHK1bPJ9LUWAiNeHpQ/c96eiNrOOi33YmENmkHqpRmwp02gkNcRYRxh7mOxOw7cNBquY4XMuTwaUCV8l66sTsU0kLQQjTvG3PAUDbLCD8VqUnXCB7Ux0ooO0BoDcU6E1Z8Jwgw3WjU0uJOG3zS4xUT+e+u08wZEFqDij20GnaGrlOo0qBUYPViwqbWIvvymrqx3D9eU3eW3//oLdk8eEU0q8jShs0qw2YekzaUnRSDi8UAmziiQYM1Uhx3naEpIkbTQoKJ4o7l7ZD6IoehIzvbUdzmzLcTnrx9xc1mgPcav404e7Rg1QcPPTxf8OxyduCmnzxcslgMKH4wwx85Tp/MGcQNVRfxzrFIRv7k84coLdfItoiwWUvy41Nx61lXUoQPEnnN5TYnSxoWpVyXm86QJWIYbTtDmjXUTQTWY5OOJJG02dnxlm2R0Fxn2OOKrme8j2c7krOObZUwympul0PG4y1Ge1YmPchfYuP4bHVM1VnWq4x3H14RZ61IyXrjsGwqAslUNgH1bYbbRFztplzbCbPTDaHRpLOaah3x+uMT0mtD3sk1BwW8s+PhbMUkrpjGJX9yfR+lII46TtIddScBWj+4vcfPH19QO8txtOO2HRApx1U94uunr/l0fUzZRjy7nBG8Iktkq/aFoxs+NzMuK4u1nsH9Nav5kC88vuR6O6SJO0JV/xutqX72+Df/+Kku0kMsRYvLAlYHOqfZvdUb2HQgRNBZSK4MzbQ3tM0a2hmEbUT+3FC80RG2huxCES8j9izx/LkRDSt72YtMz+1CmM0u6c2PHeAV7SRgLqVYKh93RDeWdiiGVNdputuUkHjwEigStBT1LhacYjsSk5ctJV46+izFNFA8kYAVUymasxaCFPXdyKGnDbTCqAbQqwRvpfCO5qJL3SeR7qevtvQ9RjDw6jfkuQDia0N2A90woGvVF+YeUwgjXHWK6p4jnhvswopZdiDyluxS3fkCnDQ9VRETOsX0bMvFYsxJB/Qm0dBPRX0k8hVTw55D762EIHmrcKnui01NtPO4VPdyl37g1KMeQyxYNf06wZYcjvvsfM1qk/EfvfMh//TFW5TbhHTQkKcNv3j6Eqsc7y3v8fJmio0cTRmhH5XQGgZnBfo8MMlLNlXC+rMpXsH0bMPyekgYd9y/v2C5y1A2YEcVi5/LyF9p0lsoTxXJXKQkcLe5aLMfC53K1KEQjHeBNlO0g97g3Jve9lsOb6F4oxPJgwJbAyFQzTS26AkYVlFPoXzoGX6m2b7lpbiJA9GLlO5xBXOZstVHQhTaPfEQBeJrS3IL9Uw+x9HnPYHHKNZvQDaqaWKPsY6mteTDmjrqNaadBiOJrA29/jfI5DbEgXv/2OJii2kRJv+PMe/3ev099nP2WxmrdxRkcj5QybS8HUvxPf2hnI+Ln5Mi0G40m1+sMVcxyVxRPPAc/UCz/Go4TG3dqMP0Ou7Vu4HkVqHmsrXYN6gulgI9aGlkm4k03MsvBsafyvZD7T2F/XZH1YHhy3DAqFZHBu8sP5qf9dNEj/Oa1klTOBhLs+69kIN2hcSsT2Yli8UA3xlG05o46kiNFPbDtCYxHQ+PlgBs6pTXF1Me3l9wpUe0OpL0zMIKCjFrCZEHo6TpGji5HoZwYOljA2EVHXTq8Vqa8UYH4rwluddQrFPiZ4kgXQ3Y64hP2vuM7m1pPhqDhe0HR8Q9XlbCO3sddqUlK6DRB7xsUEjxu5OGAcUhDZnLGJ8GfOwltTaTcDVd6d6UHsTX06jDZF436nB99nGQ6WJhZJJvA8m1oT7vCAqiV4nQrgoj1+BFjO7RiX7gRFveWUzZb836JlVdxtLseQjGoO5VuNtEZEjt3rghPPPxtKQoErxTMI9xA0fxcsQPbnOO7m14vRmzuhpiNlYkQ5FM3rtIoyNPXVu802TDmra1xHFH28p5s7oZgoZkWDM93rFa5vjaUCBbUzfUVMsUHxQqdrzz+IrctjzbHKON5823L5kXOd4rHp4vuFqOMJHnF998wfdePKCsI6K0I/7qEtXKJHi5lb+/LmXbo21gOKgoygQdObrK0tUWEzuSpJVNQIB74zXP50e41nA2W/NouOKHV+e0rcV7RTYsuJqPuX+ypGhi5ush+Ui06JtVxr2zFRdXE0zsMEcNWge61uB2EQwrqjbieLRjsRPkpFIBHxSrlxPMVIy0m1ZOjC8c3/C9myGfXR8TggQNaRXYblLirKXeJIxGJcOk5sVVjq416l6JW8fMr2VyUN0K5cluNfWsJzTpAKkjbGKeVcdMZzte6TG+b8iSuDskLJ8Nt5xl29406tEqMLQNn+xOaZzhbLDhwWBNalqeXc74+TdecbEdcTbYMolKtpUY70PaMcsLVq/GvFpOKC8H4iMLP659/FP08D+JSfq/G6P0n+oifR9b7WNP92JANleU7zQHw0xYxIRJS3vmCNsIVRjCVlZ5diVFuFkbbCE3jfo44GYtyfNYGMIe6lNPeqkp74VDmqWpenxhDM2RpIG6TlE8EgNodGNpZw7VKFSlaXWMqTReQ7QQfJqp74pafm3FMOooqpg8bXBesXo+IbkxxNdWDKyxoOBQEC8V7UjTFZFMkVohfrgEfF9ku1x47ePP+uLCix6aEHqzoObR/yQEkFe/oQ7FivysxzQas9Myke+kCB98LlpR1csjTCn6+/pUpCf5C0MT9QbdTmMHQiLwXrF8V2MLDobS7LbHrymZMMdrh0t0PxmW4tzUfapoe1foBrOneoSDBOH+P9Zc/mcQf2lFuUsIrYTobIsE32p+9+VbjLOayDpOBjt2TcJlOWLTJCx2OVHk6DqZKvnWwsCxvc1R1rO5GGKntVycS81yPsCkjjRruF0PhHGtoKsTGHQUXwqUKzHXJUuD7vpwKS0FabIWA69p5Ri6GHb3BZFpSwnd2ks7gg40E0V1LPVA+kr0xrZwbJ4Ytm8GBp9D+aaiyyT8qht6Bs+E85+91jQTUI3CVBBepgczr5gNFee/p3CJRncSWDW4kM+ommnqiT4YZ3frVDT6FnxQTNJKzGbGixa30czeWnB7MUbHrtdVB8ytFDoHXn4RDnx5lGwKWit+CBUETWj7Da5Mp3ty0o81LcU9acxCq2lmjuTzhHgluvB4oXsfhzSjplI4JWZRaoNv5JzefbWFnSVeGOrzfqo86FAqEH+W0mUBHpe4ZcLyK4qjH0oScFSKbMn+2ADrMFm3sNxlPDpa8vn1McfjHbHtuFqNcD1CsaoiXG1Ihw1dY3j3ySW5bRnFNZfrEZtFDl4xj4ekeUPXGa7DkKNRwSwvcEExmFS8upxiE0c8bGiKGNVpnrx5zYurI0wqScp+EjB5yyCvOR1u+ez7D0UnnjrY2sO028VynPwipvaKyWxH/DwRNGIUJFwoCZiNYVdMUPtk0DjQZNJwRhtN56QJCHE4IAy9laYAL4WOT2QSTpDfHYzCZdJM6j5dM1gOsjx1UuNXsXDUHaB7P0faJxh3klbqxg4fBdGmN4pghXYTNLQjL0jPThEvLV0eDvKZ6Ea2mN4grH8DyveprAbCSZ9A6hRx5OiVg+hOGsDoqObL9y55uZnQbSNpLGyfBgs8fuOG6/WQehfLFD/z5OdbmSgTuHo9RVWa5J5skMqdyDVaZWjKiGYbE48atAqUi5Q2FzlE4xTpsOd+r1JM1tH15s/Pr45xlcVmLV+6d8UnNyc8ni3YxCkvXs+I85a2iPj+q/skSUe5i9HWU0unRblJgUA8aKnriHKXoI1Mv/eSEZRow7tddGDle6e5cAajPZOJFJifuhlta3k4W5JFLbs2xkRCZpnlBfXY4pxmW8RMjgo2VQJOkSStMNq9wlcWO5RwpmxYE4LCaM+ToxVP50cUq4zT39csv5gTf2NH3UQE4P3Lc0ByCPSgZbvJScb1wU9DgKY1DIaNpM4C3Cby2aZO7nvDFl9ZuvOGZNjQvBzAUSv41la0/E1rKDYDRpNS9PK7BOcVdRUzGFR0XnO1GfHrDz/jXrLi8+KYR9mCZZszsDW5bUh0x5PzOQBJJIFKt/WQpjO88eY1ZRMxjmuIvXw+mSMfV5Tzf5MF1c8e/zYeP91Fem/yMjtJnivPPcmopiki1K2YnGzW0m5jCYUAQuRJn8US6FH3GnMHu3c6zNqg1/YQVOMtpFea6iyQXkkhteelh369breKZtr/udtr3APRQmgn9bEnuRSeOds+va6XF/gI2jcaWGSUS0kwbNZDTKXIvrymTDNoNGariW5FhtLMnBRZCsygxVuP3ch01CWBeNEXugj/+PrPCloShF5Do7E7WeuaSmNqGD6FaCMEE28V7ViqX9NI0ZdeycS3nkJz7CSJbxjIX2p2X2rRy4hkLqSbaCeTRkJMiAKDd3dUZUz4lTXrqwHEnmRSMd/FsLOkF4bpx+FQKO5DlLrkDsEmpBLFPljJtBx47s1IiqfsjzOqXwpESYczhm4Ti5ZVwYNHV3Rec5zt8CjSbMc4rni6PAJgOii5XoxIZyX1VrS+eC0r+FzWsF3eYRInsphFymC6ZdlmRNOaZhMzOC0oi1gCfKKA3Wh2DxDJRgvVTBFtA9uH0qx4C8v/qEQ9yxi8gvFTkaeUJ4r0NrB5ou5i7vuiRSn554tfE5SdbhTFA/FM2FIRL8FtZfpoWsGIBgX5C0kn9anH9wWZ3SjKc08z1ESlNET7wC/lIVl6TC267foNxb17S1LbYrTnajPC6D1aBvEDTEtWm6yfFPbmu5Vh9sNwmEDvP98uk2PSjESvHxXywQajCCoQbUU7Xk8hWYt8LF7L69o9hObEkX9uKZ44ma5+ZUvxdCDNcirkpvTKkCxg9yiQvogED7oQE+jmix1qZ4lOKtTNAF302uJWIsfrJw32Iia8yAjTDj3umP+agdpgl4Z4JU1PdisFe1CK26/D6DPRuxZtzPnRWoJYiozIShPYrhNZ7acddSnbr4+e3ePJwxuaTsyN8UCmh9VtRsikwF7eDvEjRdlFaALHQ/lOuVbz1v0bXpkJZZ1zuRrdYQS3FjVu8Z1mt0tRKvDO11/wyZ88gmWEH4nERi+taMQNmELTGcuqnJC2sikzhXzXQ5/6qVqFqoQWo2oIaU9j6SfjPpaCHBMkjKpTBC/Tb58IhWVPgvFxkJCrKNA9qGFriU9LJoOSLG5Z7HLWNwOhW6VCxdpLlZRTmKW4pX0EdEIWMhuLS2SiT6cEw8idHj+o3kAbyXtzmfxzyPqNw6CjHSkojCSaqiAIsVVM20fc4xT6XskgbTkaFGyahKrpX0vusHknEqJG8eLFsSSORp4ukRRKpSDSntcvjpicbalbS71HOjpJptVpRzKQ4ryuInxrOH+45HY1kGm9gnKegQ4k45q2sj1FxXEy2TGIaz59ecp7z+4TpR3P50dU6wSCwhrH8b0F823O9iYnn5U4r8kSkZ/MTjZsi4SuNvjaoiJBfmZJSwm4zqD6KabSgWYXo6z4fAZJgwuK+XpAcIrBcSOEGxV4tjjiNx5/TNlEGB14enFMkkkacaMsVR2RxC3H52u2ZSKNXKdRkSNcJYRJRxp3vD2+5b3unF0bU6wzkmcxm/90g6stRRMzyGq2vbk97EP7ALyiKWIxw/aSp3KX8HF1hk6cDH1aRXyv4PFswVcnFzwrZny2nPG1k9d86+mbhElHlDjaXQQamiKS7xywWeScna9Yk2KNp7PuEKiVxC3ffP42yRsdVjtumiHzOqcLmvupcODfGt/y0eqUEBRlG9PENV1jWZUps7zg+88fiLyqFWmrD4o4/VPISQ+Bnwx55WeT9D/1D9VIkewjYYhv3wzU2xgqQ7RRsDU0OiG+sRLk0yhMjzgz5Y+tS61MVADMVqaetpDJXDMGU/RhQEnANIIEa4cQL6A6DaS3UhzYne6ZzYpuGO601qqX5ti+AOkLfd1A8jQWbGOhQMskydQK98MxPGrQhSbaSCPRzTzxrcgddAe8SCXCOgiqz6cBij6mPPMkt4bohTlMipKLHt2WcLix4uU9bt51RHNDO/aYWnTKAMmNRnfyflGQXsg0PVqKJj99GmMq+R3VqdxIZaopDdD626foNPDgV25YpzWLH5zgL0dEQaa5XQbLd6TROfmeSA7aPQax1wYHq4i37kBD8dGd0XQvncivA/Hv5FR/cc1sVHCxOiY/35LGHZebEb94/pJ5nfM4X6BV4NtXTw5TocubMVHSUa8TdCy/MJ1I3PZunlNVEdSG2emaoolJ7m25mQ/hMpUwq0nLbp6L+Sn1ZKOKZhrhnqcSQjWW4nD9hUA8V+weB0yh4EVKN3YU3tClimQJ+VVg+UVFfa+VZmFnOP6u6PD30hjlYf1EExWC/cuu5fPfF/RKQTOFeAk6geo8EC8U8bynHG1EnpDMBY25L5xREoi0eUMm+slKppWjzwPzn8vROuC9oq0tm0VOOqrFbJt27FbCgY43itEPjbDxe+mV3QWaocK0oruPdhL2FYy62yYh760Z96FKCtJbOT/TGw6pv8lCpAf1cWD2XcPyqwH/6fCA3By8gOoUxp8GbB0wjWwVCPJ+khWkczneUZHjYpH4ZBeK4QsozhS2ivtNl0J3ERCxfQTNowb1dkVxm5JcGzbvClpVtyLpWPxCR+qlQSkaIVp8+fSKi92Io0HBdpgcqC5KBTEzD1tuNgMi62gbS57XNJ3BjBuaPtzl+HTNZpey2mScH214fjEjOE02qng+P5LgpMRR32YQeZmAdhobO6G/IJKJokzgtIaLFLU1h9RhnwSUgm4oE23lFfWxFzmMFzKM6pnWPvYEq/B2vwkTWZzdyYZQdxLIhlP9VFz+nqqEdkQqWnEfBwZvrmk7Q3gxQG1jocvojOsiEqJIaYQ6NekOunORPvkD/tblIq9TnZbnjgNosEsrxXcUCInH557QJ9rK3wm4sSSgqlYKfjd0ggdMPJNHK1YvJ+jrVBJYA6jzivA6k+vWImVtYzYXw8PUn5664xaCLVROESrTe0jumtrdIqO+nKCGns3nE/zAMT3bsLodoiJPnLdUmwST9F+MAKNpwWIjTUKeNbikoyximWY3htMTCbWoO8PlzZjgtBSofVBTntY8ni1YVRmLTc7NaogxnmRS0zQWV4ve/d7ZiuUuk/tEEaGskJsGec3t1ZhsLISV2WzL7fWIdFzTdVr05KuUds9hXyTk97YsdhldY3h+c8RsXPD+8pwsbtk1Mb4xTE/WLLY5J0db6s6wuh2iY4dvNVHWiRnXa0LmGR0VWO15VYwJQbGtE/JxSfrLGx6OVnxwIZPz2xdToU7ZICm/g06M3Hkr0IiTSr4XpSGknqB7VGbaYYaer5xf8s7whtfVmEWVkUUt99MV92ZrXl4e0Wxi9gm4OpPnQUGUtVxdTPjK26+ItePT+bEEFyUtRRVzPNrxT169zSSr+PdOP+FPLh+QHndY5XhZTumC5igRQ+w4lsC4X3jygs5rbsqBNGFjyVkAMNpj+vvVzx5/eh8/1UX63sSJ2rOAIZQWuzS9aTNAq3ADT7SSeO9oKTdR1a8t95PvYAPxUguqLJY/D3ovO+hNZL2G08UQTKA+gWirDoi20BMh5AmEnBL1k1Q8GATH1+V3tAhTc5h++zhgtpr6xDN7Z878k5n8pdCv/ldaqDJ9xHd94jBr2xcJ9DoU+ef0WvCLLukRfvutQ3X3z815R1vJz8TXhuZMjJDlJpVJUqWpZ4F6Ju832shr040kIqKhnjrs1vSvUW7MzVT1qYZ3fO5PX51iXqYHGocQU8TsJQ2OYv4VaXB8BKOnd8hL0wSakUE3kojaDBVtrilPxVB4/ouXPV7Lwjah3CTokTzRnvN7VQ2JteO2HmK1Y5KWhxtWlHYHPrXvJFQmpB1VGZFOKozx7CrLcpsTAmgdSPOG+Isli8sRKij00h5Qae1lRHfcYZLA6t07hFwYdtRj0PMIlwcGzxRRYUhWnnqk2b4BzaOW0CnSFxHRRiglt7/ouPe76iCbCZaDQZkg+vJgpIAt7otmP1koqvN9wi347d54C66S89+WgfmX5abaTEXXbkohpMSbflLW6/+7lwMmH8r5rxuICo/uLF2mcHGMqftNlQ6HptAl0uxFITD/upxDBDj5rjoEQPl9foyS81bOYzk/u77xCNw1IMkikCwQ8x9w/D2Yf7Wn0vTGYwm4UmS3Yo5ucwk9crHgKX0sSa32mfzOyYf6gLWcfupwsZLXHu5IN6PPIf4zC06yHV/64hXfX97n06sT1IcDaRqjQPraUtcDXu7kJn56KjHiqW3ZNQlZ1DKYlEzzksvFiKPHS26vx5S7hKJPstx2qTC4OwWJR1vHba+PVTrw+noCAabHW6o6YjoocUFRxRHlLsYvYxiCsgHXa5qjuGM0KhnEDds6ZtUa1NqKKXIob9wj53CIAwHhru8L2mBBtXIcdC3HKvg7I6p0+/3330mTqM8q3FykC/vpuanuzl/dwOb1iBB5okpkMCHq/TBtJEbNxOPQ2KUQb7qBeHailUz399dF3UgT0Q36bVAL3aC/Tk1aCQLqLzu6UYCmm/apZH3ToWthdaOAWrO9OUJbcKMOpQNn95cAXDSG45MNJ/mOy62E0Xzh6IaLQj6jm+2QbZ8262uDoBhVn8nRv4ZVRHe/lgClvuBavRqTnQrBJbKO7LhhmAitpO0Mw1T0VeurIYOjDTerIWkm3oFsVLPcihH5dCiUkdvdgO02ZXRWst1mbMsEHxRFGR+Sa31QOKcZDio2r45QD0puVgPOjzY4r7koIva0maaVTUH5eoByCj3dctoPLXw/nZ+dyFZgnFVc1FKaBK9I+mmvC4rL9Ygsabl5OUU1isv3zvBHLYOslqTlsRSnvk+ADgGitEMNQWvPqkhZ9oX/cFhxNtpyvR3y/utz7s3WzLc56XFJtY1RqwhmDWEboUcNad5QdFoM1womD9Z89eSSrwwv+Nb8LV6tx1jjWdYpz/UR2zZGqcCb4zlPi2M2VUI2qHnj8YL3P31APi0pNik6cti49zQljhfLKUeDggeTFWUX8fJmymhYkUeyGXk9n/B/XfwiSgcudiOero4o64hyk4qMprTcfzhnWyUMkoaLiynxsDnIi5QOjI93VHWE7/YIsD9dj/AT0KT/O4JJ/+ku0oO9G2J0GYRpi7mKsQWHCU9ybeiGIv2wG31I3dtj62wJlOpAbghWipR9gaBr+mTRO/OYj/p1a3X3e9qhBKA0E+Elm1LS/2whN5FgevlBbzLzUW9Q6i/cQclr3ptU5rfDw3pX9SEqugGLEqMlwo62pRS1e9OpLeV3urQvWHq9rK3270WeI9gAiSc+FqJD/nZJ8/mU9uMRup88+kjet93JKrkdiPlsX0QpJxz5Aw2jUQfdsOr6SZrpf2YuE3foj1+AdhwOcpBmJhO37sxBpVlFBtMft3jRT1cjRXUqqaaCLBRyycuPTqVANkH0tpXBHAkGbJyVFE3E1W7IF4+uqVzEhzcnvH00x2rP9c0IpQNx1kq4igqiYQ6KybhgtclkUjSqqbcxUSboxs5pFq/HshEp5Rh0kw7VanwmBZWftuAVkz+IsVXg+s9pkteWZAnprUg89ubjZO1Jvg/qe5ZqponXd+mq0cpw+Wuee98KeBTzr4q0pRvsC2rZZHQpDJ8pyjMo73mSW028kNeWXYsJcvsYwhvIpgnxVaQ3MHghn11UCEu9PJGE2ubtirCNmP7AYOogZJpY0Yz1vjY7MMltecdm9z2+19YiSzr6oWLxFQmt2T2AwUt577YVmUs5k3RQ6PGmTl5jM5GwMJdC6IOkll+CyYfynF2qOP5+YPWOnFPpDeSv5bzZPFGkc5mg76e+wYiMZvRUaC37pFuC/LdmdPed0y5gCpECuUQx/71zHvzHH/HfffpVyk3Kowe3vH5HNELuNsGNAslxySBtyKKWdZnynT98l6Mv3nLzesLJ/RVGe17fTBiNSh4M19xejWERw0iK5eA1Knbo3GOsp7lNZa2QOWF/64DrNMvbIfm45OpqjNIBbQNKgz2paK4lnCwdtoyyijcnC26qnFfLCdUyFc36EJHSxZ5uJxg6Tmq4kcLap2Jy93nfpcVeGOwGdKFpjt1Bf51eableavnc3v2l53x6dSJYRxP6IYWW60QiMhiCEq/E1hK0IGcB2omYQNU+ydMG8nfXbNcpobSEysrGEGn6TC0yGpmsi0cm2H4wEQXUMsLnTuLZjcblYiQmgOqnkNErWamGiEN2QLhfwVWK6ZuZXR2zWWUQFPPbIbfXYzmnKsP19YQ4b+hag/k8Q/U5GdHa4DMv5Bl7d130mYedlcCkSYe5lRtZ2Q1I7hXsiuTOWBxkIHJRxPjakM1KruZjTo82KBVoGktTy4BhXcQHA+ckrzgdbrHa86P5kLfvXfNqNSFNRF6yKxPqMkKbgPeas69ec3E5AQXzbU4IimxUU+1E/ncy3lJnlkWa0xUR8/dO5LPsYQhNKqAApWH0oCZKO6pCtO5RFNAqcPv0iBB7ik6R3FjakccnHrWxzNcz9JlsL9tdxORky5PJkqfLIzqnZdrvEqbDgpv5iDfv37Aoc57fHKFU4HS65c+cPOOD+JxPrk4YfS8hvwpc/PtGmhIFu3nO/YcLfFC8M70BoOhi3t/eI9aO5dVIvExJQmo7Yu2YpSWVi3iSzzl7sGHe5vzg+h4mk/enVMC3BmfkYq10YJA0vLg6QulAkkiA2XqdsdmmRJEjTVq265ST4w1lG+G9ks+tVXijyKYlV4sRrjFsqiH56Y7IOkaTmrKNWK5z1rcDkb4s9L9a0fSzx0/88VNdpLdjh561Yh5aGfRNLNKQ0BeNrRQLcS/N2Js1Qz8d0C0HY1wz8SRzLUX3Puq96tfs7d2Ubo92Q4m8I72W6bZuRfKiOw5aeZDiyZYc5FP7cA674xCIsp8KJVfm0BiEVym67Ukf/QV+b1rd30hAZDnNWLTPe6276kkZpr6TEthKsH3BAF4mTVHWcj7Z0DoJfiAWg5XdKJqzTqLTe02qcr3WvsdXogNtfmdmJYAt73Tj+yLfFDJ5U05Lg7KX6iCNjjcItjAX2YWdW0wpE8zqYYvJOnSToVdy480uQO+pIBXEK5l+7UOsdCObhe3XHG1l2fgckzi8U/zefCgX1c7wfhNJyElhIe8n6UpkCKHRmKFntclE14hCKbBph+s06/WAfcemakPQAXfkhFPtFdHCCPouDtz7J7L+Vw5Ov2VYvwXbNz3Ka6KtSFiC7c/FSApc12vxfSQEkmgDptIE5dm8oTj+YaA6Et22ciJ5sVs5JztRnZDMNdOPJdFUZELCS3dSZ9DlcuMypWL7phQSbuyYfdsS7wLxNoBShA+Tnl4S2LyhGLy++4wlNOzHkYWSuGpqKfSJOKTPxhvP0ftSAM9/qaOeyYg8vZY00HgjUpTqSJHeirxLOVh83WEKTf5SaCvbxwpdC1py35DuHvZFUC/7cjMp5ocvAs1IYRAUo3yfAsOXkm7bjMQHISz1XkIV5DNpczE0E6AdCF1o9r7no+W7dGegk0D2pGU22bLaZYRpg6ssWdJSNZa2M5yNNsS/uGRZZeheurDdprhdxNopmCxBBcK4H1MXPa4whqACbWtReSdowJ3FVQanA3pnIA7UN2O0lelzd97CzkijmjnsPKJdDbmapFxfT0iGYpjDK7hOIfEi+aj6tE3j8MuYqPf3NJNAVCh0Y+kGEl7kc4eqhJpiCinQo6U+NGS6lXP9wxfnhMbIAKVvjJQHN5BshBB7Qq0JiSf4/vtz2qIXET5zmK3FWzmvArC5HApFxUkRDiJzdHnodfPqgIoVNK6w4TH9BnBu5fho0dbjexkIkM9KipOeCtOvdNyoQy0S1EnNvbMVWgUWuwx9G+OnLWEXQepl2+ERWWUtBvIwlMRp1Wna05b0ZSQBYyPx8ri8b75jjx92ki1hBR0ZLwzuRBOcoms1JnakaUtdW7rOYtKOprbY2GG0Z7HLCF7jWs3kaEcWdbRe82C4xmrPbZWzqaWZfLmcoBSkUccgruXa5jTOBaKxY76V66SxQiTyTnE0KpgOSl5fHPHqh/fwsedrP/+U73/6qP9c5Vz0scfcRkJJGjkuPj7pT4hA6BTdQr73HDvswuLjIE3euEG/TukmHXZhCZcp7VHL6fmK1S7jo+aUr917zXdfPBQ51kXG5qFHm8CqyoiN43iyY1vFbKuEf/r6baGhdAbzH865vBmiKsPg3hZrHHbqMdozihqKLuZhvuSqHHKabum8YXhciH/KK57OjxhnMg2bb3K+u3sihvh+8zE5KlhcjFBRgNIwmO3YeoXvNEUTCS1sk5CNZTvivKZrLE1labVQca4vJ8zONuyqhCjq6LKOKO2IrKO47f0PCspdQtVjK9vW4mpL6DR21PK1Nz/l6f+aIurf1uMnMub+d2OU/lPdRqmxBBiJEUQu6tWZk4m13ifWBaovVgcTHqpnhcOhyDGVFDV2y8GYtC9ElBNpgW6lmNf9Ol5+TrTqpupDgfrieS9HoSeZ4Hu5jJPfuX+OLpfXHC9lWg3yZ82RYAn3iDrlZZrYjTzBSnHkI8iu+ueoetnM6u61mlqKddO/ZglY4i45cdLycLbkdjug7izlIiXo0EepBynQd5ouExa6yzx+4A7r6m7oCROptk2l8EN3CNPZM9lNJYZT0ZWLQeugM1f9JqHXjdq5PZBqukGgnUjR7lcx1amneCA3Z9Pe/Ww6l/+3pTxvvJJjEe1g9L0EbcRIHDyYyDEal5j+Zl9tYwbDGjNpMLFDW0866E1OUaBcSZy120VwndCsErrKEm4STN6hs04mm2cV0f1CyCeJI319R49ILg3B9Kg/5DUOn0F6qUnnAVvtP2PVJ9wqTOWFqmGl2N0+0FTngvoLRjF6GihniuIcph97bAHptUwB98fi9LueySeiO/dWnj/eeGY/cjRTTzeWi5vqFLMPAme/rzj/g8D5Nw2mCdRjxcV/0pL9H1/2abKBeBOYfeDZPJGCWzkxffpISDvRLlBNpSHrUgkEsmUgXXqStVBE0oUn3gZOv2U4/hM4/S5k1+HAJt9/f9oBbJ8EivuShRAMbL7ocAk040B6C9mVnGfdQLT3o6eSkmoLkQiBpKc2UzHjRrt+Ol/IZ1GcGoKCzSNLcaJpc2mO9rQhl8pxMz/my6pmGlvC0fuBs28Htv+nR9j/8zGn/yjn/n+TYNKOtjMcDUqOBgUvFlN2bcximxMlHV88uuYrDy/48rsv+fKTC9nWzHbEeUuUtYwfrlGxJ3QKV0TSIHol4WGZE+Rao+FeJVKQXFKBfRLQCzGyhd4g72YtLpPimq2hfT6kezmQcJ7Eo0st1CLXrweDQtea5rSjORXzQzf0BwJM0AHdT7ZVJ9e7oIM08P3GLhgp1FnEqJ6PbtfmMKDY06NodW887Q3qhSZ6FctG6XWEaqX59oP+Qt0poosYs+3lKH1Ak3IibZEmWGFqRfWgxR13Uii38hzd2Ivs6qgmjDsxhHqETe91X6BDSD320Q6bd6T3dwzHFfNtzsvPT6jKGPOwkM8kCpiFRe8MptTonjefHxcM31jj3yrgUSWppF/e0Zy16HGDelyIaXXcyfvYWPldlSK96l9DUGKmzDq0Cb0HT4rwOO0YDITrfTEf03WGOGmxSSfhakVK1URcF0OuiiFVGxHbjqOk5Hy8oW0Ny22GVoGuitCRTJvmLyY0tylunlAvUupFSreLuf3RCa8vp5irSO53pWbVpHzjneeSq3Fc9bJGaartTmHXhmgtOnBTaEEXnjqaI99DGtThM/CtwZ20UqCb/gQpDcttztl0Q2QdP7w6x1qPNp4wdFTrhBAgsR11Z4htRxw5hmnNpkwZZTVuHbFa5GJQHrTsrgZs1hmLHx3z6oMzlmXGNC7pvOE/vfcDLssR3/n8MVUVYazDOU25S7iajyiaiGYXs0+AvXe2IniZjNuBbGRIPOv5AN8Y0lxkltY63nnzgi/Prqj7TYfSQkFzpeV0umV6uuX29ZgokjCrNG+obzJWlwIxUE5hcsEuS54HtFeZbNZ0wDvFBzdn/5rV00/v4+/9vb/HW2+9RZqm/PIv/zLf/OY3/xf//u/8zu/wy7/8y6Rpyttvv80/+Af/4F/p+X6qJ+k2dnTOY+dWJtlZILkRo6RMwhXV/Q7ViebRljJNi9ZS6O4n6/Vxr2100M4cyZWRQqmfELk90WU/RUeKXVv0uMG0n3jHIr+wPWFDaYGEaGSAtZ9++1huKsBBJ9yNHHYt5Ih2GA6hMj6REJfdE5na7+UR1ZknXohpbT/J7vqwJZBilX7Lj4dueDfFVgDzmFfphFFesdpkh1CHdjeQaVUA/dYO/eGQdhiwG4O5kRtue97JSv4iwRbCejf9jc5beW6XyuuQGzcyle2bEwlhAl31iLwkEO0Uvucg20LRofFDB0bW7fYmFg9BJFsBwbuJvCha9wSYvqDqeqmPd5qmlMCiapOwrkRnE49rjPY0nSFJWoqVUHSqPs1RbS0+d/i54NBc7kmmFdY6dp1GNQZlPDqSYrdeJajKYJ8m/URZobea7Bq2D2QNX94PwuLfwOB1z5W28h5ccpdk2+bmMCDoUkkEza/FvAdiyM3mgcGlnCODC0+XKZI1B6/BfgJ80MB2Ae3kOVWn+w2TrOQXXxKKjmyDOGyYzFXM58sHpP/hmvXzIWd/IIXZ0QeB25/XTD4JLN/da4KleI1X0hQeKG2+bzaqvvlL9pNqdXg9IAX967/QkVxEBAP5hRR7ygnVJVhFlwotafqBmE/Lkz5MbLdH8nEIi9IdON0Ti2pprrtMEW8CzUjeb7yWFzl85aiO5EB5K7/btAG1E4KQ6NmFehTteixoLnQTW3hpTHp52IOzJYnp0CowL3MU8PL6CFcZglN8a/uO0DtqjW60mDDjgF0ZQhTYzOSz17HDvE4Ipp+sP0vgQW8kDhBuE3QQZCBeqD1KIbxvpSQFdL8t7I2cezpLiLwY84jwtymmEmO6y6T4tqXtt5D99DvpC/+gCBHYuZYGup/Yq0ryGHwsxabf68pNX/vrcGjEw6TFbS26f326lg1PN3Viwms1beLl+jAAvTMor3DDjnYKatii5jH2YUG9SjArwUiiJLNN1/rAQu8GUhSmD3ZMByVZ1HC1GdEuEyZvL1neDKEy1D7h+MvCscuilovvnePTQKUSytShOo0atIzHJXVjaUsjDYC7kxN2eUBvDWWaMJ4WuHlCSDx20OJfZ6jU44oIO604e3PO5YsjVKNEOlT2514kzYZbJIQzR9cYRqOSprUM+nRObSTgajoouV0OaUrhm7vG4BtDf5llcL/B9l/CVZFxnBY8uzrGRI7ZsODzyxOSpz0DPtpvgSWsrusTp73t71MqMPrKgvr3Z3gLzz465+K0xE06eJnLOZU62kRhNrLJaUfuELbXjj3JjTTazUmH2urD1F2tJfXWjR1mbYjWigZDG1IuP5b7kM88OJg8WTG8V3P7YoodCf5W68DqWtJKV1rSSstFKqd+p2VztOfhb2LZfjjF7WLIb7+akh1V/Nb85+V7pQNZVlFuUkKfTmuyjvUil6Arr/Gd5nYzIBmKtMlGDt8pgtKSFlxZlAqMs4pB1NB5zfPtlC/cu2bbJLy+nuA7zem9JV+bveaHi3usMyHiAGzKlOioD1e6yiF3uMoSjxrKTYKJxUOi1hal5Lv1jScv+dG/XLn0k3uE8JPRpP9rPMWEsaNLAACRPUlEQVQ/+kf/iL/xN/4Gf+/v/T1+/dd/nX/4D/8hf/kv/2Xee+89njx58j/7+5999hl/5a/8Ff7aX/tr/Nf/9X/N7/7u7/LX//pf5/T0lP/iv/gv/qWe86e6SPcvcwZF1N9IIF5Jked7bWH9SMIOTNahL+JD0VIf97r0HmWYXkN1FqhOFPlToac000BU/VhhqfYX5N58qfr/9dIE00DX/71ggkzGgxRi+2YAOKxwXSqToG7kUY0iWhp0PyXWjdzsXCrG1OYokF3emUJdJmjI/Y1wr3n/50KB+te1n2S75E4qU94L6LOKpohY1IYka3HvjakfNygtmlMVoF4nJIhMQqQkUvhFlxHtscKdtnAdoRtFl3sxm7VKiCcO2vuywta6l0j0q2aCxNPL65T/F8yiEGpcIpHw5jqS/y8V1VsN8R/HuEiyc/aSoz2aT+846ORVELyfnsegAuk7BdWm/wBKg4udTK2Nx++juBtpgMxVLBNIHWDQieHNetqLnCb2HD9asZgPCEGJicdIhHUTEqoHjuFHEbsHLdGzmGomx7x4KOdDfQzpQuQnfnBnzuzSu01LtAvoqMeGBZFd5FeO179ucFng7Pfpk1th/r8vaHYxodVEtxZTy3kI0rhEuz7Rc6wxTaBLFD73qI3GTyUPoH7SYG4i1EktJIVWQ1Ak0wo+Hwjf+7zi4j+2nP5OhGkCp38cmH9Fo2vZqCinUO1dgq3u9t8Xkcy4RBJVB5e+L9z7aW+qekpPQMWebiiNTLIUPj70n2Mv9XKxfOb1kWLwUr7H+2TQ3SNP/lKjdxwQpSiZyutEtivR1kPQ+Fb05i6S1xZ0T4jqw5sAlJPNhQry+2wFuzOFCpIGSwi0eT8J7jXrr66mHB9t2dUxxTrl3vmKi+tjkTkMPEF58XZHAW88ZB00BnfcEg1amlWCrjTJrRBpurGDxNHOPEna0cyFNIKSbZ1d9wmfNojhzGiRmSTukLjskiA4xH4CrQuDuY4kJdTIJqsbyndsn5Ww34bVMyE9uVOJaGch6c373xMajd0JoccftbCIDr+nS+RC53MPQydTxFYK3P0QgBj8tINKE5IgZtTc9bSMgG80qtUiFUodUdLRJBH1IpVpuBO/hstlq+B9gGGHzVriuKNYZ1TrBDvekltJYz1+tGSzSxnPROcbac9bk1t80Hz7d78omwAtfgghEIGep6yUGEG1h27akVxYaYizIInTww76kKqzt+ZoFbj6kcg+dC8NqnWCHhXy3c6d4H6d3C+C6k3KOlDtYuJMJg5J3LFa5tjYcX+2YllkbMqENGtwsWY6KGmcoWosw7RhlFR88vwcm7YkScej6ZJXmzH+JiG61qy7Ie7dBhX312Pk3rGnjulG0Y7lu1SeA4uYZWHRJ57Bm2vq2wHu8wE6lgJatQozbHHzBPt4R3OdoXeGbirBa8lc0048o7eXNLfDHnkpkqAuCZjd3eeH1iS3iupM0c4EoWl28h3b7lKCk0agrXLUcY0rLarV2BuRZAGozEMjk2ZlAlh1GHrolQxp/EKGL9VlLgZlp0jGNeVNLr4KDTqVqcjx6YayjkR6pgOPZws+uzgRaWbqSSYlWgc2vTSybS0vXhwTOo3JWx6cLQG4uJ1I0mllqNqID1enAPzZtz/nKC7wQXFbD/l8dcSmTNHjRv5+4EAhC70HYp/gS234vU/e+lcpmX7qH3/n7/wd/sv/8r/kr/7VvwrA3/27f5ff+q3f4u///b/P3/pbf+t/9vf/wT/4Bzx58oS/+3f/LgBf+cpX+Pa3v83f/tt/+2dF+r/Mw2WeKgv9jaJn79q+YM76v2SCoMOiPnFP3U1cXSyYt2bKwejYjiRR1O4E8dVM7yQreyOjS0VWsC+EleeQFGm3d0EYqpeW7BnCIeoviJs7DW0zhm7WEd1ambIFkaz4WEJdZJrf3wijfrLYFyBB95r3nfz+/e/cT10PkzDdT5tT+R3RRlEfG9QyIlpqqrcU4bFUd+q4Rr1O8VEgex5RPZAbkmnufr6byAQt+F4LGoUfYxgHCdBxyPTNBlyvmxXtdX/BUSKBsUXPYJ8J8i1aK7p7Dawj0i+sZQX5o5yuMFQzeX8u7UkkfaiUhONwIIBEOzk+PhFkZfmdGXokhrSQeNwywWWOtjCokZwM5rjG3yR0EwdZR2hlKrdH1DFpUTqwWAw4Od6wrYQiE2Ud7kWOPhP94u5LYG76xnEgHZNyQvXRW5n27psJF0vzYhrYGxddLDKLNr+bhlczw/gTdXhf+5+bDEpuW4PrFN2so3M9RWLcmxK2vTktvpOT6EIKRjTUp04i2COIko7T0y2v3jvHG4QnPPLgNOppDvdrrv53HeffFJPb5NPA8l1FdqmZve/Y3TPk1456YvBW3qdLFPmVx9YBWwrNpUv1oai1VaBLpJi/91txf87KdD+5FZOzLeV7ui/QheF+Jx3avC30IRXg6CO5G5fHWvCgt3ff8/3GSbve/No/fzOUojzeBjaPNMmqb5j83XXCNHLemkYRb+U121rRDiQ9ts0VgyuHX8dctxNQgXxc8frlEWbU4HR0uGapyOG9nFcoYckTDG0jKzfdKJojkZkEIwg5tYxoTSxZASYI3SSX611UKFwbEbQ0jJiAKi3xQtNORXeu8g7fGCmsrRRXnv6a12+29uekj6UJCL2spZt06GWEPq1xvaxE5y2+k6C20BON6BGMPgmHPwsaGDryscgt3hnf8k+evsMwbVg+nQj+cGXhqCEbNLQfjQ/eiH1Tkd/bUm4TmQKPCi5f52ivccOOkCpYmf41S6GcjIQZXjYJSnt0HHj5/jnZ115wNtrKtrAzHA92WO15Nj/inWmgctIE78Pb6pnvGwovjdA8hp6UFDTUb9VQWPDS6NBqVOzxXnG7GaK0PxxfN3KoxBGnnZgzA+i1FV9Nu/cp9d/RRkOjGR5v2VUxadxiIsfxeMer2wl51gjRx2vKJmK+zVFKjJmbMsEFxbtPLnh6M+Pt2S2Vs1xfTImX4glyFtRWwnnSfpoOcs9oTrxcVwvN9gutnC/jjuAUbuiovz/F9v4oU8lW2iXg6wyOO/ynQ7Jt/119VOEmmro2UFg2n04h9eI52Bi681YY/dmdDAYk68SelnSrRIADDyr8dUK4SWUL+sYOng5wqxgVRCrlLcRzQzf2+EoTYjFd+85ArdFbg889/qjFJB3UQgui6dNvI49rDXrYYqzHGE9dyJai7QzWeIqNTMk/fXVKcNI4hCBa86K0JGlD0aQ9P13CrHxjePH8BFRARdIMKB1YXw/wQVFVEVfL0QHpqGwgHjQ0+4GSCahO01zm0gReptLcNUZ8E04RVvG/ZLX0E378JDTp/4qj9KZp+M53vsPf/Jt/85/789/8zd/kn/2zf/Yv/Jlvfetb/OZv/uY/92d/6S/9Jf6r/+q/om1boij6F/7cjz9+qot0tBTopgG0OkyUg4Z21qEajV5a3MhhkbVktN4zzaUYdokUAl0GdHeGNVPKU0RrKZT3hk/dyHS0vO+FSrATA9JerrCfRuynUaqTnw1aboDJrVAz2mEgXimirSK9jQ66TdfLW5pxPxHUd6vnqNfMHyblnfDh9xp5EHmM6qey3ty9buhlKLlsGNhZWSXHYJ+noj8dOMzL7NAAVKcOXepDmqWP5fjpnr3s8oA7aXrUmBENfKUOUhTb8+nDqCMEK9OuWoORFf8+8r46d0RLg0vECMY6wtSK8vMx3gb8kT/o+nUjGv59MxIsEKRYI8DkozuT7/QHBh/3BuBbBRiJ9/YSha5bqCfpnaFYAxpMbajHEG/v5EguNTQj8I9Lrp8fQeZ6Q6pG3a8wn2XoL22oSkt6028eNupgEN6blZWXgvCuUJdjFpWCl9xPkNOFl3CjY00wd83nYdKpOTDofR56lJxM/7Xx+EUiSZGpTEl9EiR1E4XSXsyIqUPNKibDis0u5fnTE9RYOjxlPPFlTFtkUjS1GrO2FGeKwUU4yGLGn3naXKMbuPwVMe3Gm/57UkMz1Ji+SQimT7tN1eF83WvEVSdUDm9E7tWlvfxn2BeMTkhJQjKSAt7Fgk5NbjTmtWL9GIoHgeELkbNsnyghw2TyWtOFTM27XBJOo8JLoV1Liu1eIrKXvfiexKS7cEi53T/qsWw49pP46siA9+ilTOuKUpIsXbCYrcEPJMHQeysTTAVsrTS8Hmg1ybJP9txpopUQZ6pHLX7SSaDLIhb06nlHMIH4KuppJgFdatpjCSgKJtCddfK9VBB6DE9IvBQsA3eYxqkARB61iOQaFgLp4w3lLhFteasJUcC1GjJZU4V+GxaMeADaEWJ63AcbJSKtOX6y4GywBeD1Zswm2/HO6Q0/enGOPmrwlZVrLggJxPQNghb2tI6drPU7zeR4S9laaRbWkrQcFHRHHSr2KCAdNBIZrzOJoXdiqjRnFZ9dHXMy2TFKKt49vmHbxtwUA2bDgt/7/E3+4hc+gEFHaDQhFQO7S3t6SaOFbtMpQiqNT/QyoXtUEZzGXkf4NGAnkobp1mJCD5NOtPdG9MxKB37jyx/xTz76ggR+eVC7GB97kVT2zHbl4PZizPhkx2adEacdZWs5GhXUnaVoIrzXlFXE0aig9ZLqHIIitR1lFzEZlLz/e2+hOsVgvUcV96SyWmFWMdW5fAlD5MmeR8RLOeeamUdVIl+0l7JZDKk/yBKVk3Ru+3BHu0jBBpLnEd0wUN73QiJ6PsAPpSAPtg/B0lrkTxqiVzHNWStFsg5EG0EGM2vpighSR2g0/jqRQjzzcNLIpH5/LXWCV8YIDMAnQY5p5PHb3tybOEImWw5KiysNetwIMvE2lWugCfibBKYNJvHUZUSSt8RRRxp1uKD42psveb6esrwdou0dm/x4uOOiHdM0lnjQHu7jbW3xfaqp0ko2XFZkNSZ27OY5bz654unFsVwfMg8qUK8TCbza++yGraSk7+SeG4xcxx+cL7m4msD2376s5F/14eh+Is/j6fjd//sfsF6v/7k/T5KEJEn+Z3//5uYG5xzn5+f/3J+fn59zcXHxL3yOi4uLf+Hf77qOm5sb7t+////3df5UF+nR3KKs3MhtKUVBl0sioQqgRw3RVUZyMKbI5HVflHe99tuWoi3f6727oRQZ+5v2vjCGO91vvBBt6577beoeE2fCIR2zy8D0fz9Y0WA2Ew56eZdAe9RjwJZy07GVFBrKyYR5b161JQfk3b7o3pthD6hFpMAPPTp1j2HsctEcByVT9ORFRPuFUi4i81g4w50ieR3Rjj3R/QK/SIluLe2Rw9ZKgmnU3e/WLaitAmLBDa+lONYNBxKNtzIZb2yf3tf0K10jsha8NBXxjemLYzluqpWCrD7xRGvRO+/f655Dv08i3XPfJz9Sh2lpl8nGoR1w2ACIPrfXTHeiUQ4DDrhK3fRbCye6932BfnhPTsyK7UXWH2uLi2H7lpObxXFH5OTi6hJopqKVzZ/rQ3G5n8i66K4oNLX82X7DsN8IFGe9/KZGjk0l0hfRXAfShaeeKbCB+NbQTCW4J5T6wK/2kQR47Zu4UFrO3pizrSSpT0dSBM1vRqg+2MT3K/umjKjPpHlSD4QMcvxNi632khUYvBSph2k8+ZXn9s8rKDXVl1qZNpUyXY3PSprrjPjG0L5Z4SsrprJNPwXb9AFbfVhTdyRbC3QAJ2vjrohoeiNVmEsDMnqqaIfSCIH8bHor2vnbXxDpDEq+86aGyz+rGH8iGxjtgqAuN+HwPU+8NAa23suQFLpP4d0+Uhx9IImtykNUelZvGfKr0D9HQNcyDVetQgdF0IH4JpLzamcOWQr7aa1uoRt7ooU0uO3Ew1EjijCnUKuI5LUUfOYrJdUypht6kktLlwWasxY7bAmtpltLkU0sDa2rbR9dLsZ61UtZ/LRD7QwEKZwIUqT5zOOHUmh2nRHE3TRn9elUNOlbK41pKtcrl3fom5gu5//D3p8H25bd9Z3gZ621hzOfc+fhvZcvXw5SCqVAINlIWFhWWVgMZmx3yJMcDoyrCAq7PFGAwy4BNoM76IIisPFQjo6m7YBqF0gtYwqjdovJkhAhQSqRcs6X7+Ub73zmPa21+o/f2vvkKzRhI0hJd0XceJn3nnGPv9/39x0afrYuVUDlPRceOGSULom0o3Kand6Ufpxxcz6g18/opgWnsw5labAnaZhk0hQ5yjiiWN5Lp5bxtE0UOaKkwiI0OLSnu7Egz2NBTr3i5u01Hrx0wIvHa9jcgFNYDywjxrHlUv+MTlTw9NEWldWc5THew7RqwTySrAwr9rDeeJL1TJI3i6C8T5yg8QOLuZsKnzsIeL2HLI8xg5JOJ2d62gHt8LnBLiNcHvGrjz0CNaqaa6qtEkqF6lbime4V+kSmInkZ0R8s2e7NePFkjXmVsjUSOlU7KRl2llTWcDJpgZe00TPfZjFL0XdTcfR1q2t243ufOFyixYWq7SHT92R91E09YQLt2vUxKhMGH64r6uM99EjomsWaawAaSimqO1cjFvdXIhCOxAK56jvssMKHlF8VcjrynRIzjYhvJ1J4e4VbK1HHMVyZYycp8Y02drPEdcUV56W6LgDalVDMrq8LCIKHecTlV9zhLGtzdmOIN552p2AxTbn4wCFaeYoq4k45wueGbBFBqcmsRvU9650FDw3FrnFWJpz5nlxbS4NzmvGyRZpUom+KK8YHPZTxmJZl9+IJt++O0JFjMBDUbzptEyUVul1y/e46JrZUSTjW2qXYMcaiYdGJFS699kLLGZboE0nyPplJvkd7b/4pKqQ//PVVX/VVTBkz9scM1cZn7X2st9zgeb76m/4Mw+Hwnr+9853v5Pu+7/s+6XOVUvf8v/f+9/zu0z3+E/3+k60v6CK97DvSMylgiiHonKZAUe0KDsUWqx6VoyBP5Wauy0A7ie/ljNcj9brQ1CXBKtFTrDladw3aQhWe54Iwsh4bpqeq4X+jpMCzLaQgDZMRb3zwY1eYmW4u8qbmfNefawm1nWMV0ECXrD6fM8LXBSgHNNw733jy0ljuRXNFOfDkexXRmYheqoOWWJ3ZwCN3kprqrnZhaHGRp3XbNCEiL+XV25YgnDVtpRiKLdryYhDeIvsinik6ezOq46GIpRDkTVWhWHFSrCgvzZayK161qoROUzc9L21GVAUqbHOXiEiw7IeiNzQ3ZQ/MkeyHusHxWry5daCbeANlB4wJIt96IhH4/tFihULZZDWxqJvCaGpwLUE8ypMW3RdEJBWPJXm11kdEM2ideKFehKYryoIwMWgJRFwpAsvaklH51XvWHv2mgPmuId6e02nnjP0QWhanELQTIAUbSSCVi6VhoFLMfn2L9BQ6hafsJIxfn0sxVxhsZcIE0bG+MePSlTOePd6kLMX6K14Igp6eVZQ9w903wMbvSDORTpR8sa6k921ujDk67uPHiSBWQLHm0Ecpaljh1wvKDXEt6HUylkXM8okRPvIMNufkhdBqjHYSrqUFWXWzGIYlRRxhlqY5d7WV/Wcy+f/WgW6oMbWI2fYrllsxw+c98x0VKGtyDJjMCyI8kX0fZR5dn0fW078m7i7JzIfGXdG75XBR0MEkQu3SpbiMVNpjMvHljidy8akbaiZyMNZx9mXfoddySYnMRSwZnUaBaiFTweh5sXvzg4pcy7me3o1hmGMXMe29OUUh6J1XCiotiG7soVLobimJhYmlWrYarq/tOvQkElS9AjfvUCWOWXfJVnfG2qsXHEz7tJKSk2fXqZwUDzqSyU1xsaT1fNKI9W0L4r2FCLOdYZBkXB1vsNebcG22xs27a7S7OSezDr12zvHhmpyfsccbJ6i+9jx08YBEW14cj9hcm1E5TTsuOZz00L1SjgOnmB93iLqViO3mCZ1Bxs3TEVVhUJFDR44Lm2espUuOll1+69n7hQYTiV973KpoJSW/c+eCbI/UNzaPulTYq12iXDWJ1bblsYOK9EwmB7bjwClMBa7SDIZLxqcdpnd6Quc7jLF9ESz6lrjzNKFJg5LuIGM+buOWUSNg1BUk/Zw4sqSRxXlFt50zXbS4fWcNZoaJASyCtgaXHNsv8bd6qFZNL/S4xDPfkSkOgdphpmESev9SRMjBhWtlMayIptKM5tuWdC2jXHbwUcgd6QoP3xsRLWtnGl69qhTxkUxwqg4C9GxUeCCaRsQTTWE88USjrKYYidFC0bUBTda4liMaG0y7pEwi1I0Oar2k2i2IjmLsViFJoSBuQ7MaldIcHPflXrrQuEpAjBeubwvHPBVQYjlPGIzEGvEVw0NG8ZLZZsKL8zWmZcrNoxFRbNkayBTo2myNqwcbvPXBpyidYZqlLPOEqtJsDmR6cvtoSFUaHnrgDqfLDlkRcXAyoDvIWMxSzo57bG2N5f6XyZRnuDaXoKpLYybjNuU85v5Lh0yLlMpqxkc9VK9ER9K0eCf3VB1LuvCVB+/w/HM9Xk7rwoULXOZhnuFxXuff/BkXsr/fdYNniYj5t//231JV9yL3nwhFB9jc3MQY83tQ84ODg9+Dltdrd3f3Ez4+iiI2Nj6zJuQLukhPjzU+huWuJR4bkiks7nOoviB52gp/uY6QrlHcmtPsooCqtsAGq8HGszqCfFMcV3Sgcdi+FNd1gQ7ghCoHrFBXnYe0zOCWUVNblKkFnCrY4Any0DoUFN1kUlRD4FqbVZGmAoqtSxpPcNSK+lWPIOPx6qQo+8Ge8SUIiS4Mdj+H53q4viU5M5R9cY7xMnkM7h+GaKkaK8s6vl380qUQruKamygUoqrr5cZhBMU1eUhd/fUhdijNQ7QIXt5O4Mv0WJFvOrElPILltjQNxVZIh62bpkoKKAL9tLGTrMCyamJqCgkKOndXdKa6SG8fOaLcYRPxe6/aUkC5SKYYLkGaHQ2qWDU8YmMovtu2JS929kWO7nUtBc61djNpcJHYQ+oC8jYsrgg9obwe07vhAxfVB0GiUEAAobWEUC1JtQUlOs57nIXKjvj/t1sF45Ou3HwVEHni24nwYNsS8W474r9ce/F37kqIj03EHWXz1xJcrDh9k0RljzZm7PUnHM27PHO0SXa9jxtUxHcSZhfkOy23EqKFUM28EeS57GrIffCfjjgcC8/Sty06hMZc3jsmtxHHk6740lvNMjfEkaWoDP5yQJteHEDk6e9NqaxGR1IUVqcynq6nLVWXZsJVJEEnEklhXoQp12JXtlvrGNY/EouOo6foHATdiAXCZKV1LLSWfKRkMtRMjYTqYgrZZyBTopUwO9BjulacSZwC46TwKhTZBXGvcIlvhJE1lWNrOOPwcICrjBSPc4MbVMLtbjmqQYVaGmzboQvNcH1OXsQ4r6hGhs3ekoOTFuu9BSezDstMGhqCfR9exv/eKXTsiCJH1a+wKiKaGqJAidJBM4OStNGTcY/SGc4Oe+jUMh+3SfYXxJEly2LsIkZbRXxDjreyK/oS17G8Zv82LVOS2ZjKGS71z5iUKYMkZ3N9ysmkiz1O8dtKBHJnCcmJIXr1mMXdHntXjthszXlhss7l0SmRdtyZ95lmKZ1WQdK1HJRD1DQS9B24b/2UwW7O4bKLdZqsHVFZjdEeoxy3pgNOH9/C3LfEVYo4qbBWo5VHKZiP23KtrdkDymMHVjjiyDby+xndbs70pEOxZkXv0RYKkd0o0QoWy4Q/9cqnefJ0h9u31+T4CSJXH6h++GBN62KWx4Hrbrwg6rkcdMvTFn4tQynP8XgDe5Y2DjjKhvN7qVHz4C5TKThOxNWmUpS7JckgJz9L0WGihUI+a7g2uFNJY7Zdh+0hFpcE7dOpItuzRBONP5HCX1lF2RfgRXISvFA1EmlITaao1iqKRBqXaGwkWXUREU0MxaZss9ZdQ74hfvEmUyvxeaFo3VUsXmWpKgXHLeGLo+WYXkZUw4rkRopticZIxMlW9AlLjStjVCoTL1oW065kinGSQqCb7O2f8PrN65yVHTSeXkjZS4xlTS85THps9OfsdaY8cbTNVm/GlW0RFz88PMQNNIUzfODpB7h5dw1fabZ3xsyyhJapeHB0zLXJGotJm3khwRXtfsbxWY+N0YzDu0N0aiVhNS2JdAjvih03PrKPv5Rhp7FoPmKPTZ0YMjgl5/VRiikUV6/tYOJ7qR4vh/XY5ENsDrY45Dbb7P+Bv37pC67yJL/4y/+BTqfzGT8vSRJe97rX8d73vpdv/uZvbn7/3ve+l2/8xm/8hM954xvfyL//9//+nt/98i//Mq9//es/Iz46fIEX6bYFWtOkKmbriJCn0qTXE4oHMqLrLQkssuFiVioZ58UrtFRZsf2rka46ECY5NtiOp+g7WgeG6DQi26to3Y6aICIdCldJCqURTUXzgGIbsUrLUkjODNFCQpDSEylAzXJFE7FtmnFvjf7VwUwvLZCrjieZCJ/ctkMjslCNpZnXoVANF1Lhb4cY7wtL1K22XPQ6Fk5FgV9TQlBSfOsgZqy/Wz0ZEBRdEJrkTOzXbLTiWCurKNYEudG5VFA13UYXinxdiruy7wP6Ik1A1ZXJQTJWZNtSoFd9T/uWouxD64yGH15/x8b/Paw69KmemrjgeFNzi5WD6SVNtNTEcynIXETjn++Qgli7ML1owXJPxGTt2xqbSrOSTDzp2NG9ZujfcBQ9RbYuVoI4aUQAFm+ZUcwkic+MI6o2FH2xVaxSOQZP/8xC6CXTBBWQ4cGziiiXYrqelnjHiocfisvpVEb0ulTou0njka0r0CE63SeefE+4nyKaNpShuK2P3bjwcJKQ7C3Ii4jnDjYZ9Zb4jwxh3ZPcSPAR5Gsi1qybNF1APK8FQioE8VRScMwi8Z3uVKjrbaIFLDYTjs96REkldmJKLMaU8mJpllQiRu6XmMRhnaKdlhR5TK+bc5bF+FKhYo/ayKl8KlOHKozooyC6Do4vZT9MVRwst0G/doxzmmySsv6BBFPKNq6F3VUn+LsvhIJUhb/hIVsP51tKk0MQLWQfegV5qmiNMrLTFnph0KW4q3gFzorVaDW0jHamTK6O8Cpi/5G7VFaEdXQsfhaLCFF72MqgNGK35hTRhTnFLGF83GO0OWOZx7hKU1iDGZS0opKHNo8o1g3PH2xKhHhuBHG2GpcqXBZhQ3opxovt60xLnkRI7XQp2J6DZcRZ3iPulrTSkvksZb23YLxokSQVlfbYSSTUwkIQ1LLv0b2S42WHYZoxKVLWW0s+8vwllPZEqaUIjkjxVkaZR/izBG2h2LB0YovanREbS+UM662F0BGsYb83wXUVp1mbk0WH9a0ps25KKy3pt3IWZUKiLVkZo5WnFVXcOhnhrWLWSSnmCSbyVLMY5WGZiTagcIqsVWHSCm9jQZw7FUk/p1gk6JlYTya7C6obXRa2BW0RoPtKYSaS7aDbJVp74tjyviceIW6X4sSRSD6EWWpxuqkkE8MlHr0lYvV60pF0SvJZQtXTRMcRxaJLFaaPbJSoWYQqw/6xCttz6IVGF3J8eQ1uJ2M0WnBpcEakHfc9eMK7HvtSCYpaL+FI/PRd6iH2eDzRaUQ1qkRD0RYalEtAhQRXswzHeiL00KotIuqq44mmAbRQnnLoiE5Fi+EN2I7DHCWYpUwgaFnJNQlId7SU8zNLEIcfDYtLluRaSnl/JqJILzRIXyWo3SV2GVHuFQKijCPUqJAsi8DhNgstuoIg5rU6glzqA2/lOnXzmS0Ozvpsj6bcOhixuT7lvuEZhTU4FFuDGdeubZHvRcSRZZK1uG94xs3FkGmZsixiDo8GsIjkdt2tZNKTljx5e0doVgqYGQaXJkzOOmjtcYWk05p2xf3bx1w7XCdbJLQ6BfdtnXDrbIi/UtFuFZzNI/ZeecidgyHeK5JBSXHS4v4H7nL9Y3sCJo4jqs7LrwTs9/v8+D/7Mf7ed3w3m34XrfSnf9LvY13lCYas81Vf9VW/7+f+nb/zd3jHO97B61//et74xjfyL//lv+T69et8+7d/OwDf+73fy82bN/npn/5pAL7927+dn/zJn+Tv/J2/w1//63+dD3zgA/zrf/2v+Zmf+ZnP+D1ffnvoD3nVfuJVBwxAW9LPijUninwlI7lsyxLflc6nQdBij85Uwy13MU1hqpygqsmpIt/U5JviS+7PTENNeKlQ1WtQwQrSZPK5avcXM9OCKidSBacnunGZMVXNZQ9fSK34116/hO6gQlEa+OxVWy60uhAfbh8FDnLti2yk+FVBHObiYMN2qx1QNgkIEV6+JzmVoljnKgj+PMmpalxp6u9beyLH0xVn2kUy7i1GjuRMN9uxHDnat/S9nPmFCjzy4IUeJgt1E1L1aBCt5FQxv2wZPWEa2oiyNNzVevvUjU2UrRD12gqw5mOLc4VExHcOLIttI+LMVBHPHNHCYXLH5P6kSUQtBop4qvALRfvQ43XNgVQcfbEhPSXwkz1+rCj6QruJl7KtOz/fEbeWrL65yec6ei3CCXaIT/u0hSq0+MPvlLjriaDCLRGZxnMJGPJGENuiLUgWd1tozcqbOoIqkVRHjMfMNDrT4k2cC60iWxeXGK+FLmRbwtnVBTinKE46pHci4sc7jCLH2cOaYiDoWdkP4VtT2e4mF/RfWaGP7L4vYrGjGjQ7Hxm6t8VyaPygIisjnFVUL/RwO7l4eyvPfN4SYR0ICm01znqyZUKeJXgP49MO3eGSRXA+cLMYtVag7qa0DlTT1NYrWsqxmq97bN+KYPJM/PDj4yg0eypMMqB9WJKvi/BVmtyVl7tNVFOYx7fFc14OhNUxWLUUZ9OUdJRTtiK88vgX20I5aDmKdUuUWGbzFqwX+HnE7cd2aT00YXBhwuTFgVC/tmSigQLmUuRRyr7pry+YnnbE4xswrUpsBUczbp0NuW/9lGUVM+gtKSvDZB5LsmghN0lVKnwi9Bav5VpRiyPNxIgdbCmIpleC6paZwQ407ixh0Y9ZzlLRGrQttGVyoMqQTbGbcd/2CVcGx0zKNqNQqPeHS+Fqa8f29oQkqoi15dbZkALgKBVBuLG8fudFrk7X6UQFsyrhaNmll+R8+Nn7SLolWnmMEV640p7ZVAJ88HBzti4dU6HxkVC8dGKxlVBfbN8K/avlJB3YKlTkcIUhutFqfL3RnnycEp1J2JCLHcXdNkpLwU3bEh/G4gSVi+CdSkPkWM4TWBjKpcFHDl+YJokV5aFrceuS7kpmUGuFxLsDSWShV1Dc7OJqek3HQccSHUhyaevhCZXV9No5Z+MutqOJ0grnNEkqjUIaVTz2/EVM4vjw9Aoq07jUifVmobBdoRfphaSsVmuV5FwY8F1xfLKJXFOipQREqcwQT7UU9jHko4pobMi3BR3XRXjNmb7n/lPfo32EHIdepi7piUyiihGCjgT7SZyAZS6L0MHtxq6XJLcSirHcz/VSNwFWbhajOxV+HIvGIuhKdKaoRpakXVI68Ik0EvU5VB61uLmMaPUKNrtzFlXMq4d3+Nh4l9N5h4uXjrl9OCRKLHFs+fDTl+Wc156oVTEYLZiqNi6LSDslJ8c9dOSI04peN2Ny1iHeEZ97bRxZFtPq51ircU5RBnSpdoq5fTZkazDj1sGI8bSP6VQcT7tCgasUpucw/ZKr17ZRqW94rr74gy2A/6DWt33bt/H3vuO7ucVVLvLgH9jrLvyMGzzHbz/22/9Fz3/729/O8fExP/ADP8Dt27d59NFH+cVf/EUuX5b9e/v2ba5fv948/sqVK/ziL/4if/tv/23+6T/9p+zv7/MTP/ETn7H9IoDy/r/E0v1ze00mE4bDIQ/8wx9C9SVQp+zKSVv1xNtXlaqx6/NbOeo4aU7gmvdd2yTWfON4JnHY0VKipetC0baD48pI3r9GZ5WFfK+kfUOK/6ojF7b6hr64IMJHcamQAidaqKZgrdqh0FFA4JnCiupS+797s4pAb8SbaiV29EbCYiRYSD63zlXDX9flyoe8dl5xF5e4SYLONPFENZ7xtuNoX5qS5zHxxzugw4TA0EwPilH4XlaQF9sSlxuTSzFfrFsRGnlBXWoHnmLoG/Sxtk4UOy95/WIo2yPfcJilontTNSmUdTOmvKCi6elqalH7crs4iII7q4ZGW/nveOZpnVlme+JNXOsNatFgTaOpkdFo6ZsoefeSVljEp558FCgyC2gfO0Fuu4rlumJw3VK1NVVbXF6iBZw+6vDrBTp22NzgS013Y8HioAupoz3IyDNBR9c+mBItPChCga5pnTmWmxpdyHE0uyRFczRXTRiRWytRkyikAIIuxMGmGllULsehzhXDZ1b0paqz+v5VTyZApoDOXYcpPflQM7kctAQDz8bjq+0xu6jILpd0no1FjPkSlD+e+Ybn6jUc/OmCwdqCyWlHxrbQcJurTJwRvFNUhcGfJaR7c/Ljtgghc01rc0lVaS5vnXDzdERZGrjZJh4H6kCdeXAC0yte4tutEvpIV2gL/WfCjVFLQ9e9I03aS7UGMoL30qAF5xmvFbXdV0OHaGgRoS7sa6Z/es59myc8+/wuqtCsPW4aHj8KsjVJQNUlZJvSHNjtAqYRyfYSazUmckJRaFkRlR21UMMSdZAKV3cm4uRypwTjePi+uzivOJz1ZCJhDa2kROM5vDNCTw22a2ndjBuLQQm1CgVUW4pSfCjOa+F7cKtyqUy8UAg1pTKocYTvWTAOfSx8dLedc3nvWESVzhApR1bFtKKSa7c3cFmESgRt+MpXPsOsSrk2XuPkqE9/tGCxTNjbGHPz7lrDIx8mQkN46mCbyFhevX0XgMNll9IZSms4PO6jtNjs1i4qrgpobeSwlWzTYpo0NrsQvn/imn1IrjETg+0F7++FFqrGMpJr6aCCUtPdntNv5Rye9rG5Ie3nVEWEia3Euc9StAmIfUDlWQpqrxeyL1Sh2LhyyvGdIeSa7t6sCbQ5/Z2tpsj1wakHTfDHF+/vrZ0xg1bGi8drXN484XLvlKWNeX68we07a/hKoUodrgEy5XBxSIptObEr7ARXoELSpJWTxt8bT3psBIxJPW5YwsIQbWZEkVgT7u+ccftoyNpozvHdgeQs2MCBD+5E1cAGO2I5V1w7TBEWctzV/vqBaUK2J9NXZRUuFb2Dipz4/ZcKuyYORy6L5P4ZjldVhQTYpaD+jAq8Vw3nfNDO8F6hlOeR0QEvzkecLjscXF9DdSqSTsmX7d8gszGzMqETlfzujX3sRKhx6Ug+YBRZFodddK8kbcl0T2kneRnTBN2uxDFraaBTocZxqDNC+FfXyrTASKL1aGPGbJ4y6GWcHPXxhWa0O0EpmM5auEqjjW+E35RaKC/9So73RXBGSie88Nf+EePxmMFg8MlKpj+S9e53v5u3f/Of5yv4aiL1mVFDPt163P8mGsMtf/UP5PX+MNYXNJJee4MTil8AH4XiW0GxUYkYx9a/E+5cjSq/FJlVrka+VRCcSUBLXcjLhYEGZS0HgqwnhzHFQC548VR48CgpGtp3dIPw6VI1nOkaNY+nUiTVxaoPF7RsK6SjFpAPxa8XR8OXr5LV5/ZaHGL0UgeebC0YWnG061VzxXWhUHdaxLk0Mvm28HxpCbq03Z9xqHpUL5lSwIpuoayiuJSLf3KuaB1o8k3h3TuDCEdD8WvCKL0el1orPvQ1XUVZKfyX+1aS6ULh3bmlGn65LqX4zkc0IkyvpMhabOvGfUdXKyoGUlc0BeViW7HciEgnwYNcQ3wmCPeKIqQkkCe8Xu0zX08yXCSOMcqJ6DA9lZvpwesVO78paZSdI/E115VwmHWJFPRrJVQa065wlaY7XNBv5agdsFazOO7QWl9S2JjOgUNZj3Ke23/CsP/rFfnQEM98sCBU4l7TC+m0qRQe8e0kiBjly7uOFarFVHijqlKUGxXVizHxoubjsxIiR9C7LYWLKRwuFk/zYiTuPSih6yQTz8GfLohup5jTiHxdtAWzL8vY+UWZRNhEHi9Wip7uMGN8t098EklIT6fCVYa9rTG3DkZUL3YlVyAAQ/lY+KhojxkWtNKSVrfixeM1osjS+VBfJjZh30VzmD1gyWpnpJM4OFl4Oi/EmMBXLwdC2TGlD576ThxwEPHnS/+1sWo0A7WDRH0dqG01vZZzqOyC0p7b40E48FSTkVD2xS++U3riuRRPo6c9t/8k8oDYUxUGEwvH1nQqosQSGUuZeNRJEkLL5EOU+1I84jTPXN2jvzGn18pZljGRsXivOJu3GWzOaO1VHBwOaB0ByPWhDjIS5w8j2ohg+1rT/XxNA/OgvFApzEmbYkPQc0qFniTYvqWzsaCqDCeLDheGYxJvWU8XvDgbkVUxj9x3h0Rbtloz9tIxZ2WHhU3YCvaMABvDObM85Wte9TGuzdaFsmIqbsyGVIVhf3vMtckanbjgeN6l18rZ6U45HndxlcYkYodaLSXu3teNoHH0uxkL49ChqCryWKYVSHOS9AqqxOAzKe79sETtVnDQpnNhymLSojsUgef8tM183pfpX+IpphF+IEFJ670F85MONhKkXrUcw7UFp3f6RL0SSxA09Cynp10puqxifqPPslBSyA4s8cRgrkzZ6M85nPRY7y24c3vUTAkOD4actLrY3LDfmfDE6Q53jofYccIbv+RpTvIOT/3uJaKtJf7FjlBNdJiSLsTmEwGWRSc0M1RdR3qqKa5k5HKosH3lBO8hjSvung7otArSpOTGtU1UqTg+TUTvEgp+marI/ccsNdVmhR5HAnQtjQBo9eS6FGChWJPdEI3l774Tpl49S3wnkaCjgKTbVsTaIyecPreGH1SYtZLqLJWJgAHfq2AmPuWTyRCMZ5z0UJUi2ci4ezqgyg1pp8QMiyCW13SjgkUldKnHP/wALpXphYktZR4RtypJpU7F+3yxEJFva1DRSksu7N1lUcUUNuLW3RG+NPieJe4VVCODiRz9XkZZGazVFFnEbJ7yuks3uDkfcGocHs1imWKCq5GPnAAWhZZjRxt0z+GmsUwkUpkU2fLliaQDfOM3fiMdelzjKR7k0f/q1xv7Ew65xbUXX/iv/3B/iOsLGkl/8O//EKrXaorcmo/sYi8XjpYgaGpQoo5SVEBOlQ3+1S+hlICg7nWhqWuBZL5CA32gsJglZDvCA6+pJLUdVG2PWPYDXeQlri4oQSOTs4BkOihGFrMUDp0PF06dCUqtqyB8XKw46i4KTishMa5G2pvPEkHVFdpJ44RSI/nB1rHqSNFM4Jf7GNygIrkpdnHVWoXqVKjDtOGZxzMEEUle4objV81NI0wqxToxPZbGoqYN1Wi+SwQFrzqrzxXNVUPzwYlANF+TwkEHa8u6oF88mmFup7gE+s8FHrgXdNtFq5CouvjGSWCIrZ11Inndmt9v8pD2F4ouQX89+VA1nElJc5WitkpXzZHJJTV0ep8iv7+gdTVh8Lxf0ZQcLLYUiwset5PjpzKWN8Em0ceCsiabS6rSoI2jOm6x92tCbSm6NeVC6E2dQ0fR1xQD4VvXx1V5OWtQHFUKuqSLQK8yUpzX363qOog8O79uWGyrJgI+ygW1F/9wH7aB3ACqFhRr0LkdtkNHiY//66bkBx1BHjOZfHTuOpYbeiWsToTDf/jHPPHFOcXNLtHuknIRQ7Bhc20bIu8Vr3zgFoU1vPCxfdmPg0pG1Hd6K2u7uz1aN6T78kbOj/n94ipkipUQPBkr8o1wcm9ldD/cJj0TPQFKmof6nBOnH5mEeCPThGghgkopzCWBtJm4hGuEnF+eswc1+Rct6fUysWErNOsfNc0EyCtI5p6qJSi+V5APFQ//xaf57RsXmuJSGU+rVbLVm3G6bDMZd0jbJcWLPfGYNsIl1t2SzfUZBwcDfKX5ooduovFMyxTnFe2o5NrROr1OzvGtIdvvN9hk5dDUpIv6MHEKTZptraaLOkyu6oYVwvWykqnicteihuI+sT6YU1jDdm9GbiPaUckgzqm8xnlFoi3DRITBNxdDnFd0opLCGj529QKjzRnewxdv3ebqdJ29zpRFFXO87LLTndIyFQcBQdfKk5qK7faMjx3tslhK8dtKS+aLFDtOxGe71KSjnPXegtJplnnM4qCL6grS0u7m9FoFp9MO5WkqiGXtH98rSdsl2SxBx04Eo6cd8WvPE7xTEkLjQhCP8sRrOeVxC5+IQ413isGmJJvu9KaspwtemKxz84VNAVVaDp3JeLT2D48WSs7RrhVKziRGDUr8mTRqrBXNa/txjFkv2BjNOJ12SJKK+e0ePnFcvHTMvEiYPLuGG5bi4LOV43JDcisRR6FiFWYVzTTlusWEML5od8nmcMbtm+voVkWcVpQ3uuJ8NJNEattxUvgvFeXQN5Pd5HQFHqTHmnIghgbFSO5d0Uy0VPmmoOcmU6vzMITj+cQRnYgew7Vc40Jm6jA2LyBEfBxj9zPUSSJC0pYVGlGuQ8aIPF8CumqBqiTA0rZE7RJXaVxp+MpHnuE3futVpPtzNgczDic98lnCcH3ObNbGhia5OxTHFm8Vaa8gn8sYT5lAQZnFck0vDElakS9jXCauTSrTsFbglxGklpWvstwLBmsLpuM2fhnR3lzgvaIsDVp7ynmMaVncUSr+/aXCugU3/sY7X5ZIOsBv/uZv8hVv+BP8Cb6aVLU//RM+yfLe82F+lRGbXPVP/AF+ws/++oIu0h945w+hOq3Gdk3CUqQQLS4WkGsJzamCAKYW16ShMAwFpgk+2DWlxQfBYc09r8fjJpPiaBU85BuxTR0coyq54Cqnggd2cG0JaZ218KzmTceT8J61mAcZxTbCvJnQQKSgX40fARlLJuFGm3ii2ar4r8e6dbBS/dkkltkHyzTxdq4LUbeTk7ZLnFfkpy1Urkl2FlQ3u6THwvutpw/4EEI0MbjIk54pqhaCUI9lGpBMVk1K8Yol8TPtlWd88KHXpXyv9DiI8GpHjaJGW2hoJbYtv28fSAhOFUJxtPX3eserVeNVN3D1vnRGkcyE5uCilfAPVo49IIWXoKThfbwUqM6oEG4kyabLLdkOOIUaFvhK030yoXdTEHvlkSTOgVzgo8xz6087VKeSMaz2qIOUaBk+hIPBVY8pkeCfNIT6dATVjTLPcl2z2BOff7OQZqIYhrTEUgp0UwgtyQfKj0sk8Abkvzu3NL2bwiVPg0GALsXBJh9okrmj6Iq+IJ57TOlDY6PIRop07Ln7JsfWb8rNMB0LMm0TcY6Jl74R9erKc/u/sbK/5wa1mWMXkSBEpxJWkj4wwTnNWm/B7aubDQXn4Vfd5MbpiOVRh+6zEbqC2f1C+ygHQU1roHXLUGw4iZm3gjh2rxpxgEEaxI2PragnuvLNfq8LdoDFpmwjU9RTE3l8euabKVpzTIXvhofJfZrWKcwuyvVAl4rujdA8Gnmj1qkjH2mUlf3oteL0VYpiU1J9izUJFLt8+ZCd9ozbiz4HZ32qG13hFC/0Kvwo0FWIPXpm8Ns5r73/BpFynBUtZkXKPE9QymN/bZ1kXDcjNDqOehLhIljsetp3VWOluDoPwtSuBhDCNpg85Nl+5JCD4z4bazPyKuLhjSNc2KiRckTaktmYg0WPV4wOSHVFqivOyg4neYf7uyfcyoZ8+Ln7MIlFKc/WaMbxtIvRjq3BjGGSkRjLh5+9zHBdCuReO5drVBFhnSaNK6YnHda3p5yddVAa7DJitD3FWs30Zh/VL1lbn3Ny1Gdja8LJSY84rbiydUwnKslsxJOP3SfBpVfGVFaznKVN8+sTceDY3h0zzxP6LfkMh0d9zO2Uaqdkb/eU23fWhAbhZCToC0MyzNkczlgUMdu9GXenfRbLBHez0zRAysq12sVQ9S0+dST9gvKoRbyZUS5jTFox7C+xTjE+7XJh91QQ9FKjtEcbT7cr9I7FMsEuYhGlBu55rVtRTq4zNcXS9qVZeGk4XG2vWxePAJ0bRsKKAB97kiPT2MTWxwrhfKndpHQuQEoxsuhS6B66EPpK+/mYYiRPNkslQvdArYJwXVYePSpwVqNPY6Kpxj645P6dI569usubXv0MlTOcFS0SbTlc9PiTu8/y//7PXy489/qzlUKLidYzqpMWhEZNKS/Jopmg467UkBtp1hYG3w5uUkGMqgJFyiQWbRzdTs58IQi4tZoqN6JdCBahZk06dLuMINf42LGxN2HYWnK67OCcYpklbA5nHE+6oGB/NOaFF7dAgUktcRIsRpcxOpJ01KRdMmhnnBxonv+rP/iyLdIBdtUlDBFfpF7/X/wah/4WH+fDHI0PXrbf85OtL2i6i0s86TJwkTPxxUYHgV+hgz0UuFGFGZsmtj6aqWb8H8+gWJPf1TQTp2j4cnUB27i2zMTqUFVC44gngoRUbY8dVpiZaUZ+2UaFmUREcymkCKiaiyHbqmjfiELoTyiyF6op3mu+cNkXL944CFbNUUy1VhGNZdfXSaTZjg/fQ1AOFbx96++JU1R917g56EAV8nrFUU2eb1F2UriQYeYGlzqKWUIyVRQDKQKTUx3QeEjDRTqeBqTWgndCKUjGSigsh1KptR9rk6+vnDFqJxblVr7w8lqhMI8h33LiNz6B9oFv0GldiY2ejGx9g4rDincPYZxbI4YI6l21YHqfpntLhGfCaQyfvZ6AR0KlWa4bsdcr6wRYabySmcfmipMvFv2DTxx6afBzQcrnryrI1xM6twVFzkayT0wh/01a4bKI7fcbqpai7EnBb3JPvJDivujLMWMK4TInU7nbZGviTOOi4BJhBNEkJNbp4xgdLAe3fsdTtTU2hvHDOjjZCC0r2/Ysdz39+8/AOE4O+vQ+llAM5H1rmkoyE669nkrTEC0dvYVs460PamyiWOyH7WbkOabwVI23vFh0giU+jmS/32qh1ivcQYt4d0kUkg+dU9y6voFKLb7SmKnhuY9eJDnWdDNoH8v3HjynGb/ChomYafIDOjc09jCR6VMWjq2J7NfNxyxeq5AQSuNvri1UKbhEipTJw47dD0A+DMLogKibYtUweUVITZUCPMp9E67VuQuTByA5CxSqVDF+pdzYdz4ArRPbFMmLbU3/KnA1wsXQPtToUnOjtcb18Y4kJi4MrBeQCWWptb4kO2mjYnFScaUhWs8oJimPXb8gCGth2N47oygj8diey754qRNSE16j5DoXT1WTUWATGmtDWF376rwGoex5jHaMRguM9nTTghfGa2g89w9P0cpzdbzB6bxNVRqU8izLmEc37jCrUiqvmVQtPnpznwu7pxxOenRaBbMsJY4sr9g8ZFHFDJKMjx3t8uZHnuYg63G86HIy6VAtYl79wE0WVcx+d8LN7pCsiun2pHimXXB21MOklnRnQTst6aU5bkORFTGdngR3Hc57PDg6ZlqkJBfmDNoZSWS58eIGplVJvHtmUJkB7Tk87uOtYn6nt/IpTyDt5ZzN26IJSZ2gpJlh575TsjLieNqlXEYNIquMh8g3Nqk62MB6LQ2ensb4w5j4gblQMoYiBj65NsInjq957eMc5z1uPbkNsae1M2d5q8fkNBFRbyl+7PW9CGoKk2+sfZ0BjEcvRLRebIuANJorqp7sc1XpIJ715JuBxtIXxL16yRRUpjB+5eSiPNFUrnv5ZhDsrpdQaJkCLzXF0Iu1aKUoug5SR3Irpuq7MPkLxgcvttEAV+ZUrgN3W6zft+S1r7jOi7MRAKmpKJzhjTtXeW6+tfKP71hYavxQ3HbWBwtOFZQzmb74UlGUBpUIRSrtFeTIhIRuSCr18t9RarHLCBU70lZBniVMp4IOx3FFWUQi9Jwa6FjiTkkci6gXwBpN2il55foB16drLPOYVlKy1l9wOuuwMZiz253y0RcvkPQLLm+csN2e8ZvXLlPOEtJBjq0Mf/yBa3SinFuLISe8vHzSP9H6z8/+Cq946BXc5x+mp4a/7+c773iGx/mxn/y/f84V6PAFjqQ/+Pd/CN1uYYIzS0NfscHyLwQ6eA3xTEkww4FpqBqEEaPJgiVWEH3a4H1eo+tVCNmpua/5um88xG0rIA1awnwa3+aRw3UsehmS1SrxozUzLWP4rTDCG5T4SUw8MQ2HtR6jF4Ea4yO5kWbbHteWYkfEo8I9VyEMqHn/lzQZ9VhbV/K5xa5rNSHwkQ9ITuD0B2SnuhQssLqViGFa4hJhppp4tnLTsG1pcOKpFOdNcieCftfbzbakwbEdoSPEM3ncS3UBEka1eg4I9aV9HG4yukZXaD5rbSNYO3FIwVYnRYYpifNkaxoXK6b3ye+6N4KrTo1kBWS05jhDmHhUAVG3PvwtCF+XnoOvsKSjjDKL4Cyh97xupg0gFJGNx90qnCiCw6+wrP1O9BKahTzW5CvUNlqKm0sy9U1B5zUkU8ds39A+8Rx+mYj1XGGITiJpdBJ5j8FVeY1o6Sl7KjjYCGc+H2rOXhUmNsGWlNiBVbTuGDp3ZF8kUzkuynY4prxMAUzuG/SvaiuKnhR384swfG7F3V5sS/NhwjRo/OpSAnp2Cjp9EWPleYwxwr20i5i9SydMlimt/2PYaAtcJCj9bF+OudreshzQoOIugqovI/B4GqYFoSGO5tC/Ic2FixTZSGxDdQXpRNJflRfdgArNZ+dAEmBrz/qXUj1qLre8hxwLydRz/Kii3CoxMwNW0b2hmgmcLoS+NbzqyEaaZC7bv2rVx+6KjmVKuPsWsbH0pUIvDXpTRjzOKnzwxG91C4xxLJ8f4LdzfKkF9Q3iQjRS4FvF8ClNnVrbuCO5WnQudBeZmITtGUvw1mJLmtL6fKvaq6ni5GGZjKieZFK0+jlrPdk5F3tjHru93+yfMovwlUYnlof3D7jSE8/p3z68wOm0g3eaTkfCe8rKsD8cA9CJSh67doEosbzxvhcAuDpd5/rNDdJewSPbB3z89i6dtmyfsjIsJi3SXoF3CucUJhLXIGMcldVS8HZyXrt9i0nZahD/2/MB1z6+h+uITeZ8kQrXPXas9cUK8u7Tm0K/SFwjlCTYyJpuiQv7QEUeXymiThWcejytbsHmYIZWnjtnA4p53NinNkFrPYuamRW4kHh87FClpr83JS8ijBFevfOKYWcpnvNHcsPyqSM+ljRWr+UYi+Yy4W3cZTTNtM1HCBXmLG6a96rrJdQqkXtFY3UbMjEaamltBzywmIUmOVPka5KN4Y1vaId2s6B1NSXbl+RRnzj5N/ZEE/Fsr6+76aFumsN6Mh7PVja5ykmAoVlo7IWMdi/n1dt3udI9YmkT2qag9IaOLvj5575EaCZn4kOfDHKKWR1yoGS/FRoVgoJQkhJqIkuvI42ec4rZ1SFuUDVaIh05oZ4EeporDHGnpN0qqKwWI4CAvhN8fetzFg+mXRG3KrqtgllA4DutgvX2gjuTAUlcUZRiSxsZSdFd5jHOajnfT1ug4LWvuE4vznnqZp8P/19+7GWNpAPcpx5mwYwvVW/6fT/3hn+e6zzNWXHyGXuTv5zWFzSSXiM/MmYP6Flw7jBZ4IgvpXixLS8xyAmCOJZKiq9Q9CVj8fAmUw09It+2tO4YdA7FhhNkwAotpQwOK7XnrXdSsFZbJWoaEc00fqGbz2dy6NyqVfOQHgmVQN825JtexDwo6mwC4U6r5n1dAsmJwkdRCMwR1CJaQLZtw03Y3BN8o8sgfAyj7dpashENaQlnctqj87DNDFQ9x2C0YBZ5TGSpTrskB4Zi6BthbZ2kaoIgtOqGwChNCE4SukDtoKLLQFcpQaXBwzqEBWnEliupVONcU+/fsk+IXg8X61Ao68pjKnHikMJCCumyq5jvK5KxFBinj8D6E26FEJpaICzUKKVohKGABIa41f/rUgqsZLwq3ud70rh1n4+Ilj2GZ8JdXm6E7xrQ/P41WG5qWie+4e3v/qqhrB1Vwuu/1LFHhcK0e9eRreuGkgVgU7MKZnKQPrvyHdQWutegfWwFJTYi8lQOsg0pwJTz9G+UKBcxfjg0pqXCKcXgGZk0mcKTdxTTSysdQrQMhV0o4Kq20GlM5uksXNAdmBDSFM7HVI75sh/Q2rmh/6pTWlGFdYpFkWCXEZVVbO+fcax6HJz0SdJKztcUkiOPTZQ0JIl4U0dnRtychuHmWm/HQuwyBdGHdCrbMsrg6BsWVMetxg60dSIUnnp/eg39Fy2LLUMykSlN1ZHiqX0saLm2MrExJVSpCse0bwS33Zugr8fipd6i0SWUPWlS2kdeGhq/oi6J8F0oVcpJE7Tc1PhQT6nYo9o5rlKsb8x4YHhC5TWnWZur17Z5/SMvsFg75YkX9gDobc2xVtNpFVwennJn3ufW9Q10pcUtKiHQqF6yf7qh0Q0TJBvLY5bris6hTHWq9qrZKgby3P6FKQC7gwmV08yLlNu31jAty93jAToUk8ZI6qdDjqVnbm6jL3p6UcHxqaCA9+2ckNuI3a7w0DtRSaQcvTjjSy7f5KMffBB3SfHkyTZ5JbQEBXSiAm0ceRGTL2PW1uZ0tyYY7TmeiKDUVVoCwZJKKBPak0aWa9M1unHBwsfstqdMixS9lbOzNqWb5HzZzg1+44UHsTc6HG6JEN4PS/w8aCGi0KxmGt92uNOEaDOjOmoJimtVw2G+b/+Yt+48xfsOHubFozWc1eJm1K5wTuEPW1I4n0aNHW058HjrIYa9K0d04oLnnton3sh4ZPcuv3t9n8M7G6R7c6zy0K+4uHvK7c4QN0nYuu+E4yc3se1QsPerVcHodEDInQAwgQpT9Rxmrhs6ox1aksNI7BhLKdxrjVLVE4qiLk0zBa3BFV3KeWgy8LtOsjqCD7qZGmzfNqmnJlPhvT3bf/IW129sktxIxFs+WA2LNksKduWh2sv50is36EQFz51tcpR1OFl0uDgY88TNXdxZgh4WcNiCtZK4XVJmEXGnlONlmmISi+kWFCcSkNbpZ1wYjdnvTFhUCc+dbbAoEl752utMi5RFkbDXm7DXkRv0f3ryldy3fcLpso33Cq097ajEbi4pFjFJt6TbKjg97aJi8IVsZ++UJP8qASdIIStiri/XKJYxvtQkvYJimrJ34YR5nqCVZ3M0JatkMqaU5zjrMCsTjsfdz7Ba+qNdv330QXY39zjxd1lXnzjd8xOtypc8z8f42Z//mc/JAh2+wJH0h77nh9CdViN+QwUEu+1IjqIGvbRtoZLUgsm6KKq57HXhKii6FL/5hri3NJ7b4ebmUhE7AsQTscFLz4KNWxCYulgK+ZWwdFWMEdD4mtecnAURZSguIFzcwkTAtlfR9NFMqCDiy7xCNGpEVofCvLY6jGbCdze5FCw1XaQYENLaFNHFOfaFLrbriE/lZlRsleL3vIzw0xiz1M04vI6rz9cEaUGtXt+Gz9SERoXf1+hIMXL0n9dkG9yT7FprAmqaTy1eqxG//vVQ6JU+oNI+NGSeoqeZ3ReSTDuQ71T0n47o3XQNGlr/O7lfkO6qJe+59pQkSDpTJ836QG8JN2ALxVCq9ellQc2iiaZ/XRD2sis3o3ghhdxqOrE6XhphspNkzpoCoUvhutcC1FoAXNtIdu9YcZtZOoqBFMC18M8UMH5Q/gUR4taWlvUkoH0syHLZVY1Xe7QMzjZKmhfbdWx/UDfHZzpxTC8Gm0IjjZa2vhHtll1F2YXR87YRTtpYGibl4ehRQ++mv8dRCMQucn6lpPatRiHIr1XC8XSK0eaM6bRNt5vB+9Yay1Bn5JxbPpTDNBbbvFS66OhuIs33VJOciXajFlnXAu3s/oKoXVKNU0l0dIrRE1oaikImDtpKQ1NPNfJ10T3oAuKFwxslhfVSvud8V9G9EyY3lRxbVUthgj2mjaWor9qqaSJrVNm/JCbbGzj+Y6XY5XUrmMQyVu+UVAtxqbiwd0qsLRvtBR+/uyMiSGs4OBjyxx56gV6ccZT1ePzjl8WxotT43LB94ZSLgzFP/seHaB2tpkV1E1GLvuuU1prGUnOMddX0P/JZo9XxqQvQX3GGdYrIOMrKUOTyxDi2FIHfC1IUunksOp0Qe29Si80NVy4estuZcn26xmTZ4hWbh8CKz+68IrMxO60Jz0030cpz42zE/nDMsze2aXULHto84s6szyxLiYzj/rUT9toTfvX6gySRRWvHdNomTisurp01/tQ3DtZ43eUX2UhnbCUz/v31R3nrxae5m/U5yTtS7J2kpHtzvmjnLs+dbDCbtWRydVdcR3wigkScQvcL2t2C+UkH3apwgScet6sG1XeluNC0WyWziTTYmxtTpssWy5M28Yn41zegipPms9wvuLh/TDsqOZj1JAyrL5Z/qhRUOF7LKWcJamb4stc9x2M39mm3Sqa3+/jYMdqeohScnXRRZ8EvPYQhuZak2bpUACEJ11PYbhC2QsjgaEDnAE7RcNvrqVxypkQoOpXzqer7cG8IrmIvaapdFIwPIo/ZWeJudsRZJZaAJTzCAy+DxmbN4XuyPXVqcbmhtnNVhYJehT5JcCOZDri1Mvjha3F4c4gOZik3JFPvm1LztY/+LjcXI5452mRvOOHqnU2428Klji95zQvMyiBONhWHix6zLCGOLGcHfaKO3Fyj2LLWXXKhP+aJg216rQKtPAcnfVwhdp3ttJQ8ijJioz/naNql185px9KYls5w884a21sT8soQhWY30g7vIa9EhzHqLDmdtylnBc++44df9kg6wMPqi7nLi/xx/jTqJdfBT7We8x/jhANO3eFn/JyX2/qCRtJdCuolIq78UoGaRpi5XIjzyzlqLEVm4/aBXDCihWpi5YuROLHUftxaQzIW7jVabub5aCUGVZVqkKfakaTmaddjQrNURBmB17cq3LxZFaHRXL5DXYyKeEgeU3tg19x0s6QRwQlaEZ6nwTu5mNkIQAUvck++DumJaug7zTYIfMRkrCgO2tB1JMeGfK9k/+IJt69uUswSOsMlxe1UeIaJPNfUXN+Zagopr4FILrbe1d7mYfSpwQdUJUEzvyBpdbqkQT3r7Y4SVF3nNW0FinXH+CHN6CmPjZXQLfxqGyRzx/oTqyKfj2u8do1Ht3JQdjXpxNG56zn6UklKrbqe6SVF+0DuGunYUbYV6ViKMq9guaWaBmn4jGp+X3UAt3KEMYUU63WRHs9XwsSqLTQKF4MvpCGQ/1eNh72PhBfdOpUivnXmKLsak4mbizjNeJSXbedi6N2AbBPWnhRx6HxHk06kSCx6UpjLwSLbZb6nGD7viXJIppZ0rCn6mrKr6BxYtEWoGFNxtknGXtJRb0thn22Is02UCV/dRYp44TCFIx8ZsZ+8uypgVSh8dYW4KgFKIZQM7dGJxU0T9DSi9+CZiADPEiZnCX21mvoYJ81AfCuVaZPV6FNpwPO9Ej034hFvxMKuuFTSfiYlPZJ8g/azCctLWkbQscIvDOM/scRNE9YeM1Tt1bENgpybTJ7rFZQ9TdWB7m3fNOH1sWvKl/wuCEirtkIXYT+eOmwiugGXqJUXexCp4hRxX3ydh/0lnb2Cy/1TnFc8d7ZJKy4xyrHbmXKUdSlLw+Gkx5fu32SvN+F3bl6gGKdy/etUKO1gGROPcs5mHYz2tA9Z0SkCZSCegy5E/+BiRRXoWGgomuZLEPW6Uq/PYR0aSq0d05OeTIzWFuQO3vzws/zqsw/jKgMzLds0cSLo1564K4imXUaoyBFpx6xMmWYpb9x/gaWNOSvaXJ+NSCLLZltCZhbVBr24YKc14cnn9nn6qEPUrSiKiNO8zWZ3ztmsQ1UZPn5zj6fibfAwm7ZI2iVxWhEZeb+sinnN+i2GScZGOiNWjrv5gCyPWdiYX//oKyFxKOPYe/iQZRnz9NEW3iOiQr3iW5fD0IAZaUDKykClcIUh6RWkcYXziqKIiGILsUUrj1Ke4ZpQaA5fXKO9tSAdZRQmRZ9FwiM3DrdR4o2j3S65fTSSfRA59FZOq13gnCK/3oetjPI0Rc8Nr/ljz/P4rT3i2NJr5ZRbprGeNFqmGvU1AcJEoFvhfIRPHC7S6FJRhtRoH/lAjfLoUjeaIBcEpi4VJzXlIDnT5BuCype9lfmCyUU/U6w5KaahKdCjuTjDqOe7qEToOPFx1IBagc5N2RP9V+vynPXOglunQ6JuzmLSJukKWlHMY6KLc4rTFn4zl2v0WYJez4m6lnycipg2EmDAVVpCsYznP9+6AsDl9VMqp7mye8T1aB23iHns2Uts746ZLlPK0jDoZeRZwuI4JdlesjGYsywjzu726a6dkVURa90lk2WL7f6UV12Yc7zsUjrNbndKYiyDOOPWYsB6T5FX95ZxW5siLF2UCRd7Y27OB0yzlGE7QynIyoiDsz5KeVpp9amLpJfRenz5IdbaG9zhOntc/rSPz/2S6zzNr7//1z9nC3SQmuYLd4UbpAomDz6ka6owmktupEQzgTJ9JEVv1Q7q8lRQ1LILyZlQNWohjPJSFNcFZI1M11xuU8jfTQatYxUQ1+ATG+zuXOKpOivrRBBU3OTymlVX/lb7cNee77ULTDIW5L8WMxYjT7HmQkJosBGsz8/A1daFapwY5BeQ7TpB3js0r6UruXAWFwtxwxkUVF2PmRkOTgYM9id4q8iWSdOQCMK9wtZqzmA9lXCRiM/QUkhGS+Eo5uu+QeB1IU4CDWJnaegbDSfcS+NSBWeN1h1N+wAWO6r5ni6uA2gEpamLIq9VQzdxMRx9sQgztZXCsnXqGD4lwiUpoAUddgFNzzYUh6/VzHcVR18qhUrVroW98nnTiW+CetLTwNvugfKe1qlvGrGiJwVqvJDjzCbia151aQrCl9p/6mYKo5jtG4quYnbRkK1Lg+mMFMbJ1BHPZLunJ2FfJHUYlRTnphARqqSDyr+tY8jWNdHSCa8+oinQ69eI5+LIEs9lYpHMhKKRrcuxP3reMbhuAz9eeJfjK4J45QNN2aMJL1FOtlUy8/RueUynwnRKKdJnkRQLnYrtVx2ilKd4vg9ty8blU3Qlx0U0l2MGLzd117W0b+ogdIT+kzHpkSY9UiRjMAt57XzDk28IhawWi2vjaA1yOvszXKWJ1jLOviLj5A0Fk4ddw4Ev+qqZfJQ9QedRkj6brakVFcv5ewSV8TxMHCopbr1S5H0tDU0i3FRJM5am5/gtKyshV2racclWe86LsxHOa+Z5QqwtvbjAec0gyXl495AHt444yjo8fbhFeRb8FJ0SYemtDsReMiLGKbdvroUPKz8uWIfWTUnR041AONuA+T4N1aFucGsLRh0mcbVeJjFWRIexpZ2UtDoFH7p1mTitpGgKdnjbO2NULIhzuYyI0orh5gyTWDqRdG+LZcKvv/gAN+ZizdhLc1pRyZMH25TWcP1kjduzAf/xiS8i7hVcvv+QV+zfZXd9QjcuyCrhattKuO2X1k95zf5tNten4p1ehHj3vIXzimkl/z5+ss8sjE+McUzLFhevHOIrBacJt15cZ/LMGtlzAxZ3euiTBKYR1Sg4FRVaCkHjsWcieFXtisH6XBxnTjvkeUQUWYadDGc1RRGRlxHTaZtIO+5/UAKaNgZzHr5yG3ayMLlSqLMYdatFcbWPLTTeKcrjFvqFNvM7PfLrfQGAfB0k5Hjs2UvEsSVfxvXllDxLyMtA06m1R5FHdUs5hjPRTZlJhNssRMyZ6cZeEQK3ve0agX1NccGpBiGv2r6x73Sxp+x7XOIo+45y4ElPVunTtXjVFIgl68Bi1yp0oMUUI9cElNUT4+iLxqx3FizKhKo0tFPpIqvcUEzkXKhKg+pUrK3PMYlDr+d4KyFpKjRU2jhJ67XSUHmrMdrjnKZlKnbbUkg7q1HGsb075visR5HHeKc5OexjpzEMSmwl5yrAaGfK87e2eOZgi7unfQAOpn2eP96gn2a0oopIO564u8NJ3mE9XXI2b5MYSz/JWZQJyzLGBD1BURkKZ4i1JTIOoxwPrx2y3lkQxxVpUmF0feN8+a9Wq8W/+n/9C57jY1hvP+3jn+PjbLDLG9/4xj+ET/fZW1/QdJcr3/9D6HZKPFUsL1XouVmpzY0UytF81YHZtg9osGqK8Kor1IxoForDjmzOZLxKuyx7NAV6fcMqBsFr3K8Kk9q5pKav1D7hNVpaC1Z98Hx1kYwFy35I+WNFWyh7wTLyJZ7cgsILsmGKVTNQc4vrEaLJg/+1lfTP5Mg0VBcXregotVMFyOvUY0eQC789S4lPTcNFrAYrq65ooRrVvrIhSdVKo1N1hIJQO8skY3nfYt0TT1ZpriYTP10fe9p3VtMOGbfSaAmUVU1hprwUxy6W79g+ckFcKT7Wtad5PtCcfpE0YO0DiJe+8TqPlp67f1z8jeMpLHdFCLb5O3LcLDcV8SKM9SuPS4QbmZ6Jdd5ic+X8IUE3quFz1+LU9oEUqS6iKe46BzINqB1pQKgvJvfBEnIlhK1DruQzhEJw4ZsmpehBMg0NQR+6dzzLLdUIa2sa0eCaxRlF1VYN1SZaCtVGV572scUbFag3K8pHQ49IxbIyHwo/vrbBrEW1NlB2ooVv7DZ1RaAMKebbMskpRoK6uY6F1HJh75TTufA5dwZTbp6MJD77pM36b0dUqTQuNTXMxavvlG1IEd/48KfSmEdLOWZ0JToCHfQg+aYkGOpMEy3l3F9eqrj4wCF5GTHPE6qPD0lOZfvLeVWfq3JM1NoQXUHvukwkak572VGkE7GsTGaOsivnlsnlmKwTTVWYCngNd7/cs/E7mtPXOPxGQacnkeFKedZ7C4x2XOmfcH02YrczJQl2hid5m1vjIVkWY3ND1KrQxgs1zSuotHhiezkn2wfSOLxUBK0ruQ7aWDX6lTJM6aKlXO9qipMcozR0LF2E/fGlU7xTdNoF3sMyS9geTXlkdMBHDi7Kdh23SDolb7zvBSk0lKXyhucmG1ivWUuXfPz2LklS4T1cGI1J9OrmvahivFfcOhuy3lvQjmXqkEYVgzgn0pab8yG3jofsb4yxTnOxN+a3rt6HqwxbW2MeWjvi+nSNg7O+oOGV5o0PXiXRFbFyzG3CkyfbnDy7Li46Xuz1qoUIO4kdqtCNiBJoCtfa8tR2gl5ilFOdpZhBiavknPeLSOhZuRZuuIKoUxElFa2kbDzXtXEkkZWJktW4g5aIU400p0rX3bwcl8wiAaZC1oJPHHohdsNuVMLSYNZztJYidm19zsmLI3muQ6bCS7kGlvs55kAoPMTCHzeZuuc6btNAYczknmdb4RoeEqSrgRU731ysDsXuV5JMvZZ7maoEoU+ODcpBvmUhdXgnE3E9jgT4Ca43QrlTlOuW9rYEdrWTklvHQ0zkMGFCYK2WgtU4zl4c4hNH3Ct4ePeQJ373kmyztiXt5wLkad/wv1Uk1ppJWvGlIXn0qcMtFrd76GHBa+67xe/e3GN7bcrtZ7agX9HuZyyOJeFPtyridkUcWUYduXeeztt004KTcY8oqcTXP6loRYKqDVtLDuc9siLi0toZN85GxJFl0MpYFjFKwVZnxlneljyBuJB8ADzTIuWR9QNenI1ITcWtuwkf//P/t88JuguAc46R2WCHS9yvXvlJHzfzYz7Ef+KpZ57ioYce+kP8hH/w6wua7iLJlYps2zXojzcSsoANgkYFtYtLHZNsW56qC/FYNZSSmqPudbgAx+CDp3kTfpNAsSFFbzxb2SVGY4IiXm5wyXR1o2u8tyuIAypoW4HqoAUdbqwFi9WNMFqEizwrlNm25AKWnGqxgQtIu6rCA72IdryRi7cqFO1bIggsBz6IdCApQ3Ec3luXCm+B3RxbmFV0fSSpkzVvEA9uraT9TEK+JRSZl9J48m1LcmICxSY0IF3PYt+LFVauqTq6ucmVQ0c00ejqJZQDvypMbSoFTXJGQEYDN3GgGFz1Iv4zoMrV32qeurYweioU2ZH8XpIVhUtuMmnMZg9X6KWme10x2xdRoW0LrcO2YL6paB1KIeyMouwrBi/4xgayc+JYbhpq8WrZk8Ju8rBj+0OKqILOoYQEmSIU6TbQYJwUs4tthSlXqLEuPclYOOKzfdO4yQjVRrZdOpFCP+sr0jPhTrszTevEkq0blpuK9lHt6y6FuY9WzzeFp3O3YnJ/jLIiOF1u6FUoVAzLbWgfwnJDk555urcKykHEySMGXUA6DpMGI9/dZPKZxw9oei/Ktu/dEeS4f6P+DkFMHW/THsmxNWFA+RUFahwxek4qIduGykjxGIdmJF7Ie8Wz+nwIhXu2KiLryYaR+yWuLWP44oEMPUuJFvKc3csn7HRm3JwOpbhldR4qgPJeAWhyLAFNuiAktXpOXwVuN0edJOz9micyvtEDlJ0V5UisPxWm9KSnFhcr9n5Do5xj8LRmudPCL1ssHxIO7QP7L/LRwz0+Mr9IURmu3d0gbZU8uiPJnfODLt541namxNpyfNYj6ZTkIWDFDYUrUKSaqq3BeNJDTes4XFNCKJMpPD6IV+sGsQkmC5Q4xQqcMNkK2Ry0M6ZLGRPeNzzjqWwb6zSRsrx5/1l+4/YDLHRKftbi14sHefWl2zzUPyR3nqs3tkh7Be2NkiSpWOsuyINd5PGyy0Z7TqQdyzLhbN4mMrYRzRXW0E0KEm15oH3GY3f22RzO2WrPWUsW9KOMt75iyYuLUQhAEnGqNo713oKjcY8PXb+MrTRpq+QVW4dsd2dk98W8dvcmL0zWMdpxPd9AVwrvxImE2tv/LGqKc/Yz3O2WFMuJw0QO26mkQD9NxIrRKoiBQhPl4g8eJ1XjZDPsLFEKJosWxjjW+wsOTvpEu0uKSYIOmRjUyZKlEkewbiVFfyaK8zp/QF9v47R8Hn+3RdmX5MuTF0boSq1sF5chNMkrzGESrr0KEouemqA9CCnZTgURZ9AZRB61LyPQogiuQk7hcCirm5Rub8Sy0Xa8uC9ZRXxmmoKftkVNxeHGdZxwyCeRFPulwkYe23X4WBxVIuPIypidtSnbnRmTIsU6zcG0x2KZYCJHvJFhS0112uKJs4voNWm8RqMFJ0c9km7J3nDC9WxdjBMqjTKW7LDDC7119nsTXrd3gw9zEaVgViZsDOccnvXEOx1Y3u1ihuIg5BcRxSymGhRs96eUznBl/YQXTtfZWpvSikrmhSAf/TRjWcXcngxoxRWX1s44WXSIjKUoDZmJSSKL0Y6TrMMrRod85M5FjHYUVUQnLhi15MK2LGIKHbHWnv1+SqY/8qW15l3/3/+dr37r17Dv7ydR6Sd83LM8zgUe+Jwv0OEcScevCyVD5+FG+xIKTG0fVQ5ck+RZBw01fy9oaBSmWP2uCfQIyG7tAKKcXIDyTSl6awFd1Rb1eZ1IeE9oUXh+ja6jV6i6S2Q06DVNoE3tjrLyMg8jxkR2tQ4c6HLkSE504+JCcFaJFlLc+Ggl4NRFoGVYGq581V3ddKuOIDbJekZVGFxhUJEjvt5qrBGLSzmt59Im8KLsyzYo69RULTaQ9ShTnGbkM9duO1U9zViqxl6wDlBpgojsav8BTfhUNJfHLrdETNo6Ef647He/Emq64GkefMnr8CQVThWbCJUjWxNKyvgh+R69GwE1HUpzVQwR0V0oWEC2c+tYtnUtPqz5nXiYfdUM97zAkpuPBUeNIPCs/9tFQr/xRigGa0/65lgDoVyYTBqPdOIRuw/hOlft8LxvmJA/O2D4nGK5JWmgs/vCv5fkuO/cgckDnvXflW2y2FF0DuRYK3qKbBMGL6x85uOFTAlqJL7mJm88WbHcMOQjRfe24/QVmngm28gUnmIggtZ4Fr5jLt8zmQqnvp42mEIsIWtbRRsrencqbKw4eL0U/qNnHLqEg9drqlFFZ3vO4rQDkWtsB+dnbcxxzNrHJCm1nh6UXdlGNpVEVJDvtbxgmyTW9oGIXx/+k1c5XPR4485VfuPOA8x/c7OxEY1mNDqRKBdUvj7PNx632JamSqVRykbivNQ6Ef55Q71TK1pJvAh6iiKEGKnQpHlBsw/eZFEdsWZb7y1YlhHjox6mXdFqlXzZ7g1uzIcUNmJZxpyedCX2fhHJ+RUCZ1TspGDygkwSLO8AsQUstCCUCgbPiYBbOfm+unaNY0VniMK00QW0vTl2u1C8eiENwSxGdYU60B9J0I5SsJiluNygCg0dS9rL+eLd2zx1vMX4sEfUqbiwdcqLd9bZXBenmM3unMvdEx4/2cdox82jEbYwpF1B0PHQ6+RsdWdc7p4Sactp0eHF2Yjxok1RGda6Sw7PelzYPONKX/hgd5Z9CmtoRRUH8x7H19ZEqOsVOrK4cSKBOaVGx46vfPA5rk7XOZ13mI7bKOXhLMEPKsg0ZmIkHG8pGQsulW1sRgV2EkvKtQO/IeFm5jiW6UzqIPIkGxmj7hLrFWUlaZK9NOd0LuE2cWSprCYyjulYfLh9acA44nZFeZaieyV2HqMSizlMcLuSaKxzLcLJ01gsgDNNNNHk+yW1eFkVukHe/bBEHydSUGfBXnZxb0GengRQqO2bTA/lQG/lK1tQFFGrpAoULL2sBeieeKzJdyqiiZECv1CYAJaZhWpC/KquI9rMMJEjjSsmpx1edf9tpkVKP8n5M1tPcLsY8tR0h8xGaOXpRCU3p0MKa6isJi/l984rSQJdGr7yS57io4d7bPdmnCw7dJOCm0cjOu2CojJ80c5dnj3epNfKMdpx+3hIFFvycQvvQKcyyfDHqUzSN3O0cZTHLVSvRGnPxZ1TrNPcOR6yPpxxMu7R7WYo5ams2IpeO15nfzTmYNojMo5RZ0lRySSvqAxVadgYzuVY0o5ZltJNC+4eDdjdGjNetOi1CrpJjlae0hnifMb/7+v++ecMkl6vTbVHhx6vVK/9PX878Qc8xvu5c3ibzc3NP/wP9we8vqA56WYB6bFuxrJRCFmpek7spHIpPn3kBdEgiFiWBFqI3JyiuaC1qoJaVFNzMV8q0qwFjj6C1kGddrlqBlxMYx/n4pDY5lcFfi0ufKkTjHg5q4bSoGwQaIXC26Yh0CgVQQ5eNQV/ciIFaL7hm8K5TvCsX0+XooqvZDonjx/JxbZ1FOgyMdhhRbyWM+wuMbFDJxY/i8UKK6SDpi+kTUFadeVCXfUcg4sT3HbeFOK1SLXqCVJjW8FFJQIdYqBBtkOd+Nl4Tyc+0CVW+0Hn0mgUI1jseeI5FD35TMqGIhYpvmsRXy1sSmYuBCf55j2SaU19ERtBEQoKn9IUUoR7LUUugbseL+Rvulw1FSYP74+8zsmXrkb1LpbY97OHFdOLwWfdS9HbTEZSsRbL1gKSWQkn3OReEG8lgtLlpiYfqMZScbGtWM5TfODMxzNBsNeedCy3pVCvA6PwkK+F/WKFepONFJ0jR3omKGqNrnsl1o/J1DeFevvYk60Z8EL3ydZ1Y78ptDLVBOKUIYRKl4LCZ+uhQA+NlDfBTSXQYTqHFUVPM981dG9A/5pYEALYtqO7M2c5T0U9OonJDjosrvfZfW/M9m/5hv4jbiS+ceUxuW/cdeI5tG+aEHwUbBWP4NmjTbpJzpOTHR4aHYf8gxXNSlUr3UdyFmhIFYwfMLIN1xWzC5piIPuoaikRYtZNtQ6C17knnjnSsSDo9ec1ubjtRJmnvzMjTiuKRczBSZ/5QgodV2oWs5RbiwFHsx53T/ucnnRJO6WkInpQiUUtJXKczKDnBjOLINjgqUKj54bkukSNurUS5RSTBx3FyGGD/sMj9CJCkyv5AjTHTW0rqmsbV6+4sneEGRbisuElATRbJBKZPo9kwgewNGRnLX7row8yOe2AU9jjlBc/voufxhzeGVE6w2Y6J9UVDw0ludQuI5JOiXcKW4lbyiJLmJcJV2frpLrixdmIt+w8Qzct6LYKplnK/dvHXOqdUXnNUdblclesP58/2pAC3YHPDSwN7kxAHu8UUavCLiJ+++4FTucdjHGosxhfSVKmL0OkfCL0RGVD5HynEvpQSNT0XYtrOdRxAguD7TrsoEINSq48dIdWUjJdpmg8nUR4+csyxlpNEldkuVAetPZ0+jlr63OGW1PIDMU0EXHqOJHGU3taD03wZwlYhe1V6HFE7TrjlUx/VanpbiwYbU955atuoAKthEUkCdRWNVMUF0wAXCpjpXzdUQ5DJodDdF5ANY/wpcYcJqhJBFe7RGcR8XEkjf+oxHUsxaWcwfYMu1nCVo7dLsh3S+xGSXl/hr+U4S5m3PfKu+xvjOm2CiYnXbrDjOcONrlzMmC3PeGJ+R4OzbXxGrMipXKa37l+kZNZR4pz7em2CrJFQj5L2dqc0N+d8WuPv5JlnnDteJ1lHnP9xiY2N0xPO6RxxXHWIYkrFkWMVp4vvniL4mZXRLyFpj9cEiVBSGs87jDFXe+geiWcJrhxwvUbm9y8uY7SjpNxDx0arIuDMVp5Kqf5E/c9z/WDdfI8pt/KmWQtjHZs96dsDWakack8T5guU44nXeLIMs8TdjYnzPOEzf6cK8MT1ltLOlHJRmvB2bLz6cqkl+X6lcffy02eZ+HvnQR473mGj3KFRz4vCnT4AkfSH3jnDxH7lvh1ByV5bf9UrDt0Hi482lNbNflIlPku9sThpl0X2TUHVR4YKBcJEJDtGvl1cVCbz4XOIRdseZptr0KRGlFrEL7UY+Oa81oLRhvv8mqFuta+xvVzahsrNM1F1YRAJZcE66uhIM4mD8g68jmVFVFnWfPoCYh7CGYSlxgZ4apLC2xhxA0gdnCzRTxVUpRb1dy4ayvGsh+QulpgWokIV1tBH6tB4PKWdZG+oiW4sK11BdmVgvRa0vyutkCsI+9VpYIft+xfXdJQF2oedG0pV7YJITOrwJo6ZbKOq5ekSUXRh/l9nuHTSpDzYyno8XD6agnj8KWmfSMmPZbnmUwoM95IoqhtyUSldSo8zTtvlcJCJxZ1JDtCxLOK7Q87bn6tjJQJTjjRQig12grCXPTEZWaxrenecWRrugkSOvzmJe5WB7deYhKLs4r9d8s4dbmhyYfyOslE3EVme8KjNoUnmXomlzXJVJqcKCTqto8cswuaZOJJxxK40zp1zHdNY+voYmkGlpvy2sNrFacPRyKC7ggiL9tAToT5TiSocZiQmFwK02xNr8KBIuGyAwGFlqK1aimOvrLEtCtsJgWHMo69/08iLilOkOlalItSwaNdaEW2pchHNBMkl8j0pXOXpllMz2C5g0yJwrFStWSb1EV200hn4veenoVD0yFiZbMKd2mdSKJp1QkWnqzOfV3KBKTsCJ0onUiwUt2sn/5f5yjlyebCTzaHYi1J7ND9UsRtVbCrXAoa2R5l2Kf6YiPblobbZKtpmasF6cHByhRw9ogLdBePmWvQMHhONfz/5WawyisV8TxkA4RrVZ0QXAzkOrj5hjt04oKrBxvY0uAXEclhRHVFxvGvuXSLg0WP7c6MG9Mh6+0FL56s0UpLtPKstRc8e3VXwIBKo1PLqy7c4eZ0yNlxj/svHHLjeMTlrRNKZ7h1PKTTLtjozpnlKYUVIeD4tEPcqhj1lmjl2elOeeFsrUmCjBJLMU24cOGEm3fWSNqCfCrAudAI3+jKpK0S20Ffb6NMphI+AC7KqRBQp1danq6VQBwFSbukOGjLdbIK3Oz1XI5hkGt2v8R7aLVlOlAHExXzhKhVEkWOfLHyg1baNyE6rjBCe4kd5Aa91KjdjGoREZ1EIfQu5HYE4MO2XUjdNNC1mMNYroUdJ6mouYFW+H3icZG4uOhMuPaqkkakbrh0qUSb0ncQrsm+Z4kO5TOXm8FSVHvWL4wpK0NZGazVlJkIxqPESoDZMgKniHqyTZK0YtDJ2OtNKJwR///MYKaii/I9i4otaackG7fQrYp2p6CsDFVucPOY0f4EazXTuz1UrnEdi2nL4/qtnMPTPia2xJE47eRlRJUbvFMMRgu8V2z1Zlz96EVUCT4Gv5ETpbZx0HmpXTPI8YFDvOgzQ7KWEceWNJZMiF5a0Ety/vj6Nf73Z19LmlSstcXd52jepSgj0qSimxRMli12BxPGWZvKaRJjaUUlSnm8V5wu28wXKZc2T+lEJWkx411f9f/4nEPSAS6oK1gqXqPe0Pzutr/OszzO6eKYdrv9R/jp/uDWZxVJ/4Zv+Abuu+8+Wq0We3t7vOMd7+DWrVuf8jmz2Yzv/M7v5OLFi7TbbV71qlfxUz/1U5/wsd57vuZrvgalFO9+97t//x8woNfJJCDUbTlhqq7HtV3jZoJVDb8OVhQMoHEsaNTq9e8D1UQKz8CRbYXUPQPxXBoAk6vGESFari6SDY8zIFKNXWN4T5OtCvL6/bwJ6GpwnamTEXUplA804ARZjuYhxbIlNJts34qNZHiNelxZB0AATfiRqekuHeQ1tTQudrOUwI/Y0e7lREmF38sEcV6KraOLPcVQqixn5GYWhRRVXajGthKg2KlCERdQGC+WihCan3rKALSuJuIwk7/E190FSkkmaLz41SuJk24J8mnbwSknFe5ytiaUhbIfCqBXKqaXxWEjXnhU8P3ORkITMSWMnloFNOEF/azaitGTirUPpmz/54j0JIz7hQJKOZACrhYJxvOQ7hnD9q/E7L/XYG62cF2LHVTYjqPYKqnais3fkLCr5FRuhOlpQPBPHelphU3h6IulsSn6ivErPPMdxZ2vAHenLemBmcbfbaGOE25/JSzXhaaSzGQ7zC5BPlAsd2lcY7J1TTKRbds5kG3tjFgv1k4148thTK2hc+hIJ5507EnPPEVfmphk6hnfH7H+REk8hfZdaVyizONizfRShLaefCRce6AJQdJVXcDK5KKsg4MMgrgrcbHRiaWaibgLPOZWSramwXsm92nykeLm15cstnWgqtViWBqbzmIo22GxE+hLA5hdsSzus3QOHZ3b0njUtJ5a3F0XpHVzna+t/q3akA9lSlIMXjINCoLMeOakCI9VI27WlSeZOdk+kViCLrY0d95WcfQtS4osYjluCWJbaexWAf0K1a1YG81JugXpKAcPb37tk+jEsjxp0z4UXUD7QD5r2V9RxFSwsLPhPlel4EclPnWoQSkhN4HKop0c9507MHhe0XsRFhct08u+sdyrEdZkIu81zVJeONyg3SqJWxWqU1GsyckcpxXXxmscjXs8c7RJrB1PP79HdqfD6d0+J3cHPPfCLnGvQBlJenSzmI89f4HFMiHpFtw4HuG9Iqtibh0PSdOKVlxROsM8T3hk45AH147p9HOU9hw+u8HJtMMTd3fwXnHf9gkmchTHLbxT3HpqG6YR5Z0O+Z0Oy5M2ZS7Fs1svKNcsVc/h1wv8qMSsF4KAdyUZGkDtLhuOuI98KM4UzCN8ocknKbQdfljhNgpc2wbEW1JIdU8Epd4pskVCO5XiSynPxtYEpWCtt6Ddy+kNJFEzSi3KeHTkiLsl8SjHHIsnvUuFdx73Cvx+hhuVVBczbMfhela0We1AgepamBvsehVsURVxtwTt0aexHA9KGgmc3G985MVDvZSpQZ2yajcqSC2+ZYV3n2uqtQrbdpiJiD91t+TkoB/oT8GCMxTVttK0OwUbuxM2L5zR7WZsrs3otzOyMuKJOzs8fXubja0pqlvBxSVrD56ytXvG2vpcmivj6HZzImNpJSXdXk40zJlO20wOu5A6Opemweo1ppvKzfbS1gnbwynz0zbLLKY4aeFKcXgZH/eYTVs898Q+tl81ya1+FmNvdcJ1S+6X9fZpdAdeid1zXy543bTAKBG2ns7bvHC8zguLDYo8ZqsrybNfNLxLYiwb/XlTB1wcnXE47zFdpownHVpRST/JSYxlLfDR07Ti9tmQZw62+OidXT5X14du/AaH3GbsjwGw3vIcv8u//H/+88+bAh0+y8LRt7zlLfz9v//32dvb4+bNm/y9v/f3+HN/7s/x/ve//5M+52//7b/N+973Pv7Nv/k33H///fzyL/8y3/Ed38H+/j7f+I3feM9jf/zHf/y/zv/SSFgCrFBWZ4DUY6ZGbkJrhXgsd8SZJJqF9wvjfIkcFtvAmpbiNfiARDf+20FUZjKhXcQzAehrxBpo6C11YFI8D81DWiNqNLaOdYFa02rgJYi6CzSYhRSiwoMXYR5IMZltO7G0qgL1pFBkO5IYpxH3F12sPL3rBqTsSkFYDkV5r0ok6EELWmkXEd2NBct5io4cdhETVTWSqigGnmQs0erV0MoFPZaiOVoqijUrfMelwUxMQEulWFFaRqW1/aJtiT6gsa5biNON7TqSE4MqEQ/dUiwdbeLxiad1oMlHnmipWOzJdtCloKUQ9legDvVeDM2XC4FPlWqoCO3DEHzTkQJs/QnXeIfXiK5ywZbPyuNk6iD8+Pp1TCZiS5BicXZBU3UVw+cg+l3TIKbKa6pUbBiLSznxjZTeVYONodyGqqO5+8dF3Ns6gvEjjp0Pws4H5Rjq31TEc8fhFxuyKxUsjBy/bcvxH7dEpyLC2viYxx5K8du5BdP7pSBLQxOnC+i/KMdrvBBhpzeK1omj4yA9swElloYmnrsgxpVJRI0uF31D/1ZFPtBka5p4IQKDZCpJoXXqaTwXhFtTU4580zBVbXGeIRTauhQry7VfaVMFi9J8PYKH5swfdCQ/3yP70gVJUvHGvZtkD8ZUTnP0U/c36KaNRUw7HQoabDKY3y/6jfTI0L4L4ytBuxGardZkdfyI37mcg/GcZvJABZ27vjnnlRWefzKBfKQbr/RoWdG5WzVhR1XXEM0tSaC6lF2NTRUsDWWgjui0IkotvXbOeCIFQbebofFUhWFjbUbUn/OrT74CHVmiXomyUTPZq6l4ddNrSlDB7aZu3PVxIpQrhdAdgnajCUQLOhnlof+saWguDkjzFS/ftmByawCJw97syGTPgW87cc9AUOpyllDFhsVUCsn2ZsnX3f8xzso2NxcjIu346I197GkqYsbTmHIa4YcVvtBEvZLbh0MGwyXLPGa6TPG+RTZL+M3JFUxiUdqhA8UEJVze+SIlLyMurJ+RDeJGsHfjuW08wUmrUrBIKFUik9JS4VKHPkpRCqpu0NkYmYzajqOax9CrwpRPifOL9qTrBfntLnQrumtLcd5ZxPKYrqCr+iRGuRi/naNvC23weCmZHs6A29Zc3DhlWSYY7cVS0hmMdqT9LAgjLXvDCS8sYnnNQqie/noH13EiDE08ZlTgjoJ/fhHhYgd5JNegs4iqJ25W1d02GB+mxnIv8LXLV6ZAaVziBCgJQUZeISFkhVwPahTZLAzRTJycWGh8S9EZLRm0c+4cDMVys11IAFZsyZYJ2TIhbRUM2jnLMmKZJ2Kj2S7I8piTkx6Xd4954eYWJ6cjOXD74gVau914r5hNW+LND81xYwtNlsVwltC+MOPoqU38Rr7KaUgt2nho1XZOSINcasxagT9KcV0bznPVNGpeE2gvATxTyHGQBxqUcRSLBN1fUDjDTn/KwawHFXz0cI+ttSmjJOMkb/PkZJuH1o64PR9gtMN5xbxMxM9ee/r9Jf0kJ9KO5082GHWW9Fs50yzFe4gjj6b8TCqll+W6cOECl3mYZ/gor/N/ihs8S0TCX/7Lf/mP+qP9ga4/VLrLe97zHr7pm76JPM8/aUTro48+ytvf/nb+4T/8h83vXve61/G1X/u1/KN/9I+a3z322GP82T/7Z/mt3/ot9vb2eNe73sU3fdM3fUaf46V0Fz9MBelxCtfyRLMVKio+5YKq176vPiThKRsKgxCcU7WFe1qKvako+KuXiBvrAl7Ja5pCrYSDgQ5QJ2fmG47kTDcIfDwVFK92F1N2JbCrueTitsA9SaMuXAjKocMshQuMClZzRqzlWgea5UWxtSr7ThxcAqJdDGV71LZy9eevm4diKGhQNNWCVO9ltLsFRSG936i34OjZDbGCDDcmH8l2QXuqnRIWhvjUUA4c0UyLX27PSSKeVYHSoUiODTbx2I58l3ucaMJrulQ4s+m1hHynon0jkiCmIMx1LXG2UQ6yLUvrwIhFX1vG/FXPEo9NM7JPJoIyVu2VtWVt0RfPPeMris6BOLfU1Ib0jBXtyddUDXGSWWzpe6gfL7V0rH3ax6/wgd8uSHw8l2I/Cuiutp7luni1l8MVCjp+UJJrlzsO17G0bsb3WHsOnxNBZDx3HPwxsVnTqW1Gx26ciF9xpeDCEnfQIrkgCE1VyEjIO+H5mpmhe13Tv+6CK05I/tMhsCiHaOmCI440Vd4oFltiTdk6caG5XVk+JgE9rtpKqEA6UIGSkEjqVmLZOv1UHEM8ix0jotiOTIfax0622dJRdWR/F12xgsz+4hmJsbxy7YDf+K1XMXpCNxaUVaoaio2LFItd2Y9mCYsLjvXHNYvde+1UcUJxqW1Wq45s83gqOoR8GATgVmhByw1Jra2vE+kptI5lihBlYUoUS7cQLSXoKVp6lPOUXd2g88ev0eT3FbQHGdk8IW5V9LsZiywhTSqWeUxkHK/dvcl/fvpBTCInsc0MaE/nqVQEzKyO13pSqKyn7KvgsCHH//KLhVdrK0P3N9uNC06TpBzJfn9pgqSk/NJ4q9epxiCIes2vx8Ppf7OUkKJcyzGoQK3n7G+fcetghDIeeyLCOzoWfRZJQTnT2J64cmgj2y+fJ5iDRKaHwZ3DlwYimfDlWUycVvTaOcs8ZnGzT7KzEDpF7EjTkgujMeOszfG4yxft3+GF03Ue2jji9mzAsoyIjGM8bYvVYm6EV+6h1SvIZgmvuXKTx5+9JMU8AuSoTEOwPJQbgVBgAPxAGgu0J+4VdNoF03FbBL5ZoEgEcb3vVehJ1EwJXQAfVKGI9xf02jlZEVGWEUlSUZaGOBS2rXbB/G5XuPGxX32+togbdWKFFpOLoMdr0O0KP47F172mfnqExjIoJVU6hE811J5wf3Qt1wiT6+2AV8GKV+6nPhEgRZzTHPQrtrcmTBYtWmlJYiyTRYtRd8nxpEsxTjGdku2NKW/cucp/fOER8jym1SrJshitvWQApI4LeyfcvL0uB1pmpCCOHH4ZoXsl7U7BfNxma2vM8WkPVxmSTkExD16ywQHHDEQY7LKIwfZMCuI7PVpbC9Z6C+4cDoV2FVs5jjWi6wjaAwDXsahMmgFdKNya3P/ohJOl0JBa0oEkiw5aGbdPhnItiCzeK/ohkGi6TINQ1bMoYq6snTBKlhxlXQpnuHE6YtjJMNrRiQuWVcw0E3RgvpBGctBbMj9zPPUXf+Rzku4CMJ1O2Rxs8SCP8gwf5f947y/y1re+9Y/6Y/2Brj80C8aTkxP+7b/9t3zFV3zFJy3QAd70pjfxnve8h2/91m9lf3+fX/mVX+Hpp5/mf/lf/pfmMYvFgr/wF/4CP/mTP8nu7qcf1+R5Tp6vwj/G4zEAfpoJvSX2RGON2p2TlW3iidi82Rg6D56yeHINVYTrTECxq54nOlMs1x06VkRTRZYK+iR8cIftOZK7wY82UFVc4tEThUVujE7JBSw+EoQ0mgrlAGTErE9htl8JsrwQNwDlwDugAD2j8Qd3gQevLPgqvH4YN3ug0qAKUFlNi8kpdIqfOEqnUKcKtawpOR59JJ/TOYRbFyYCNhbkunIOb724xBzEqO05UVkQKTg77XCyVKiTQuwZnfDLsRIaY+9b4g4TdGGpPDCBIq7tIT3OyCiVaYwflGTrUtj73OCUwuQaXyrK9Yr4NMLGHhbgC09VOeKrUMQVNkw5mAGFp8oVPvXE1xVWlRR9iCeyDc0CfFlSreeYw4SqUJztyt+r0BS5UMjozBHf0fhl8PANlKRFTyYlti2/T48gKeHgTxVy08uNuBQ8ktH7cJtoDosugVbisYmFSm5iy0Qx70pT1TsU/2wfQXTgcQMtFomxIp461o4l3ZJTQXeHT5Zkm5rFlux3l3nM1EPl8QsNSzCXZvglVLMUXIWzGjMqeNXoDreiAf0442Dal4kJkN/pEm1O6O4VzE/XiFJxXUlz1xTbegGUnqyjIVrpBmykMMegck9uoGwrqpYUcYNrFXppKTZikhOLW48oe4osliK3dysEK51KEea1okyFu60XDjU2qMKD1SxGUA0FVc97wtvu3rGkZ7J9Ov80Yb4X8dRJl/VWjvIiBM0GivTYCSIWK1wKjBXay/4fHMB8IOdjfCaONPko0N0WwU2pAj0H24E8BqfB5sg5lAIJTHY80VTRuRqEvrHCHFVUicZbj8kdPlKoyjPdjnCRRfVkO0eZJ55aip4h281RdxNmU4UyBfbIkHcjXKaZJ2It0+7nvP/juxg9ozyLBTWOHEZb/LRPFq2KZpxkAbg4NEKHkhirSpjve6KPKaJJROShNJlQ7cYIFzjoIGyYItYJsV6B9fLaZQR6KX9zGnwQ7dYNSfd9Cq8tky/KhQpRaaK85PatmGpRoozDhxjJmIKqLb7uasPizlKqZzR+uyBqVbilo3fphMoa8izCnqaY0RKutZj3DKQlpVMsq5b4ei8yshOLUhXaVRSl5/lxl6oweFfx+HQNlOepRZ/FLMbZ2gHAEXWmkIJ/sYOPPPMOmPaCx57YgEkpbiybC/JxS/jIYamNHLcIQUijHHeYQuzRnZJyrDi7GURHiSM6jqThLuQ6bKlw6RJQdC4sMcahlef0qId9wZAPDK7QJIMlee6xpaFwCsgoqgpXafpbomMoK4N1iiqP0Di0c9gyZnNzxrKMyUtDcZqi4gLX9pjEkqQVy9tdyEBNFT7JoNLYrpXgqeC3DuCMRS+NWDpGHjUxkDhcrgVsiUJOhwNXKpzzEJXcuZpy5dJdplmLsyzBupyjhWKjd8QbXvUC47LNr197kJ974VWQaahE54MuuW/3mPGojVaeWzdaJMkZnVaJbyuWeUS+SDCxxVjH9Fobr3PunnRAW3QnI88V3ltMbLHzmHSQ0Y9yZlVCNuti1ubsdmY8Nb9Id3OMyQoirynLiCrX4EuUsTgrNBhVKHzLoWYKtTTNvVrdANsuofR0thdkNsYYS1RWeOfIy5KOGrPMI5bjWLj01tJPMxJbYhcOB0QU+GXGh29tMGot2e2eMlGe+STBWgmRgpw2OdZp0BmLLGacQ5+JnKufo9LEfr/Pj/+zH+M7vuM72GDn865AB8B/ltf/+D/+j77T6XjAv+ENb/BHR0ef8vF5nvu/8lf+igd8FEU+SRL/0z/90/c85r/9b/9b/9f+2l9r/h/w73rXuz7pa77zne8MeM35z/nP+c/5z/nP+c/5z/nP+U/98+KLL/5X1Xl/lKsoCn8/r/Qf//jH/6g/ymdl/b7pLt/3fd/H93//93/Kx/zWb/0Wr3/96wE4Ojri5OSEa9eu8f3f//0Mh0N+4Rd+4ZNyyX/0R3+Uf/Wv/hU/+qM/yuXLl/m1X/s1vvd7v5d3vetdvPWtb+U973kPf/fv/l1++7d/m15PgiaUUp+S7vJ/RtKdc5ycnLCxsfFfx2n/PF6TyYRLly7x4osvfk6Owc7Xp17n+/fzf53v48/vdb5/P//XZ3sfe++ZTqfs7++j9Re0I/fLdv2+i/SjoyOOjo4+5WPuv/9+Wq3W7/n9jRs3uHTpEu9///t54xvf+Hv+vlwuGQ6HvOtd7+Lrvu7rmt9/27d9Gzdu3OCXfumX+Ft/62/xEz/xE/ccUNZatNZ85Vd+Jb/yK7/y+/k65+uTrJq3/7nKVTtfn3qd79/P/3W+jz+/1/n+/fxf5/v4fP2+Oembm5v/xSbxdT/wUlT7passS8qy/D0dnTEG54SP+j3f8z1827d92z1/f81rXsOP/diP8fVf//X/RZ/rfJ2v83W+ztf5Ol/n63ydr5fT+qwJRz/0oQ/xoQ99iDe96U2sra3x/PPP8z/9T/8TDz744D0o+iOPPMIP//AP883f/M0MBgPe/OY3813f9V20220uX77Mr/7qr/LTP/3T/M//8/8MwO7u7icUi953331cuXLls/V1ztf5Ol/n63ydr/N1vs7X+fpDW5+1Ir3dbvPzP//zvPOd72Q+n7O3t8dXf/VX87M/+7Ok6coc/KmnnmrcVgB+9md/lu/93u/lL/2lv8TJyQmXL1/mB3/wB/n2b//2z9ZHPV+fYKVpyjvf+c579tX5+vxZ5/v383+d7+PP73W+fz//1/k+Pl9/qD7p5+t8na/zdb7O1/k6X+frfJ2vT7/O5bzn63ydr/N1vs7X+Tpf5+t8vczWeZF+vs7X+Tpf5+t8na/zdb7O18tsnRfp5+t8na/zdb7O1/k6X+frfL3M1nmRfr7O1/k6X+frfJ2v83W+ztfLbJ0X6Z+D6/7770cp9Xt+/vv//r8HYDab8Z3f+Z1cvHiRdrvNq171Kn7qp37qntfI85y/8Tf+Bpubm3S7Xb7hG76BGzdu3POY09NT3vGOdzAcDhkOh7zjHe/g7Ozsnsdcv36dr//6r6fb7bK5ucnf/Jt/k6Io7nnM448/zpvf/Gba7TYXLlzgB37gBzjXK3/qVVUV/+Af/AOuXLlCu93mgQce4Ad+4AeavACQ3IHv+77vY39/n3a7zZ/6U3+Kj33sY/e8zvl+fnmuT7d/y7Lku7/7u3nNa15Dt9tlf3+fv/JX/gq3bt2653XO9+/Ld30m5/BL13/33/13KKX48R//8Xt+f76PX57rM92/TzzxBN/wDd/AcDik3+/zhje8gevXrzd/P9+/5+tTLn++PufWwcGBv337dvPz3ve+1wP+fe97n/fe+2/7tm/zDz74oH/f+97nr1696v/Fv/gX3hjj3/3udzev8e3f/u3+woUL/r3vfa//yEc+4t/ylrf4L/mSL/FVVTWP+eqv/mr/6KOP+ve///3+/e9/v3/00Uf9n/2zf7b5e1VV/tFHH/Vvectb/Ec+8hH/3ve+1+/v7/vv/M7vbB4zHo/9zs6O//N//s/7xx9/3P/cz/2c7/f7/kd/9Ec/+xvqc3j943/8j/3Gxob/hV/4BX/16lX/7/7dv/O9Xs//+I//ePOYH/mRH/H9ft//3M/9nH/88cf929/+dr+3t+cnk0nzmPP9/PJcn27/np2d+be+9a3+f/vf/jf/5JNP+g984AP+y7/8y/3rXve6e17nfP++fNdncg7X613vepf/ki/5Er+/v+9/7Md+7J6/ne/jl+f6TPbvs88+69fX1/13fdd3+Y985CP+ueee87/wC7/g79692zzmfP+er0+1zov0z4P1P/wP/4N/8MEHvXPOe+/9q1/9av8DP/AD9zzmy77sy/w/+Af/wHsvBUAcx/5nf/Znm7/fvHnTa639L/3SL3nvvf/4xz/uAf/BD36wecwHPvABD/gnn3zSe+/9L/7iL3qttb9582bzmJ/5mZ/xaZr68Xjsvff+n/2zf+aHw6HPsqx5zA//8A/7/f395vOer9+7vu7rvs5/67d+6z2/+5Zv+Rb/l//yX/bee++c87u7u/5HfuRHmr9nWeaHw6H/5//8n3vvz/fzy3l9uv37idaHPvQhD/hr165578/378t9fab7+MaNG/7ChQv+d3/3d/3ly5fvKdLP9/HLd30m+/ftb3/7pzynz/fv+fp065zu8jm+iqLg3/ybf8O3fuu3opQC4E1vehPvec97uHnzJt573ve+9/H000/ztre9DYAPf/jDlGXJn/kzf6Z5nf39fR599FHe//73A/CBD3yA4XDIl3/5lzePecMb3sBwOLznMY8++ij7+/vNY972treR5zkf/vCHm8e8+c1vvieM4W1vexu3bt3ihRde+OxslM+D9aY3vYn/9J/+E08//TQAjz32GL/xG7/B137t1wJw9epV7ty5c88+TNOUN7/5zc3+Od/PL9/16fbvJ1rj8RilFKPRCDjfvy/39ZnsY+cc73jHO/iu7/ouXv3qV/+e1zjfxy/f9en2r3OO//Af/gOveMUreNvb3sb29jZf/uVfzrvf/e7mNc737/n6dOuzljh6vv5w1rvf/W7Ozs74q3/1rza/+4mf+An++l//61y8eJEoitBa87/+r/8rb3rTmwC4c+cOSZKwtrZ2z2vt7Oxw586d5jHb29u/5/22t7fveczOzs49f19bWyNJknsec//99/+e96n/duXKlf/yL/95vL77u7+b8XjMI488gjEGay0/+IM/yF/4C38BoNm+/+ftv7Ozw7Vr15rHnO/nl+f6dPv3/7yyLON7vud7+It/8S8yGAyA8/37cl+fyT7+J//knxBFEX/zb/7NT/ga5/v45bs+3f49ODhgNpvxIz/yI/zjf/yP+Sf/5J/wS7/0S3zLt3wL73vf+3jzm998vn/P16dd50X65/j61//6X/M1X/M193TQP/ETP8EHP/hB3vOe93D58mV+7dd+je/4ju9gb2+Pt771rZ/0tbz3DRoP3PPff5CP8UGo8omee77+/+3dT0gbWxQG8O/VaCaLVIhihzSktAilBm1BXFSwgl3aP7tWEbELF10Eqoi2tIu6qwstiBBEKNmUgpvZRwdKG2hooSEYNyoY0k1oisS4qOigp4vi9E3Nc/Lg8XqF7wfZZI43cD8CZ8bMmZ8WFxfx+vVrvHnzBpFIBJlMBiMjIwgGgxgaGrLrKu2t274y5z+v2nyBnzeR9vX14fDwELFYzHVt5qsGt4w/f/6M2dlZpNPpf72HzPjPc8v36AbSu3fvYnR0FABw7do1fPjwAfPz8+ju7v7HtZkvHeHPXU6xfD4P0zQxPDxsv7e7u4unT5/i5cuXuH37Ntra2hCNRnH//n1MT08DAHRdx/7+PkqlkmO9YrFon1nruo6vX78e+8xv3745ao7O0o+USiVYlnViTbFYBHD8KjD9Mj4+jidPnqCvrw+tra0YHBzE6OgoXrx4AeDnvgKouLd/33vmrCa3fI9YloV79+4hl8theXnZvooOMF/VuWWcTCZRLBYRDofh8Xjg8XiQz+cxNjZmX/Fkxupyy7exsREejwctLS2Ov7ty5Yo93YX5khs26adYPB5HU1MTent77fcsy4JlWThzxhltTU2NfWbf3t6O2tpaLC8v28cLhQJWV1fR2dkJALh+/TrK5TI+ffpk13z8+BHlctlRs7q6ikKhYNcsLS3B6/Wivb3drnn//r1jFNTS0hKCweCxf73RL9+/fz8xw4sXL0LXdUeG+/v7ePfunZ0Pc1aXW77ArwZ9Y2MDpmmioaHBUc981eaW8eDgIFZWVpDJZOxXMBjE+Pg4EokEAGasMrd86+rq0NHRgbW1NUfN+vo6Lly4AID5UhX+z7tU6b9zcHAg4XBYHj9+fOxYd3e3RCIRefv2rWxubko8HhdN0yQWi9k1Dx8+lFAoJKZpSjqdlp6enopjn9ra2iSVSkkqlZLW1taKY59u3rwp6XRaTNOUUCjkGPu0vb0t586dk/7+fslms2IYhpw9e5Zjn1wMDQ3J+fPn7fFehmFIY2OjTExM2DVTU1NSX18vhmFINpuV/v7+iiMYmbN63PK1LEvu3LkjoVBIMpmMY+Tq3t6evQ7zVVc13+Hf/T7dRYQZq6qafA3DkNraWllYWJCNjQ2Zm5uTmpoaSSaTdg3zpZOwST+lEomEAJC1tbVjxwqFgjx48ECCwaBomiaXL1+WmZkZx5il3d1diUajEggExOfzya1bt+TLly+Odba2tmRgYED8fr/4/X4ZGBiQUqnkqMnn89Lb2ys+n08CgYBEo1HHiCcRkZWVFenq6hKv1yu6rsvk5CRHPrnY2dmRR48eSTgcFk3T5NKlS/Ls2TNHg3Z4eCjPnz8XXdfF6/XKjRs3JJvNOtZhzmpyyzeXywmAiq+j5yGIMF+VVfMd/l2lJp0Zq6nafF+9eiXNzc2iaZpcvXrV8bwSEeZLJ/tLhI+bIiIiIiJSCX+TTkRERESkGDbpRERERESKYZNORERERKQYNulERERERIphk05EREREpBg26UREREREimGTTkRERESkGDbpRERERESKYZNORERERKQYNulERERERIphk05EREREpBg26UREREREivkBt+mA7rQXTW8AAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "x= f'x{t[0]}'\n",
+ "y= f'y{t[1]}'\n",
+ "\n",
+ "ndvi_path = f'file:///home/jovyan/{results}{name}/{version}/{x}/{y}/2024--P1Y/{name}_{x}{y}_2024--P1Y_final_ndvi_median.tif'\n",
+ "ndvi=rxr.open_rasterio(ndvi_path).squeeze().drop_vars('band')\n",
+ "ndvi=assign_crs(ndvi, crs='EPSG:3577')\n",
+ "\n",
+ "ndvi.plot(vmin=0, vmax=0.7, size=7, add_labels=False)\n",
+ "plt.title('Annual Median NDVI');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1f225904-1836-48af-8517-5bf3e5a7be41",
+ "metadata": {},
+ "source": [
+ "## Remove all files"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "038f4585-8dc8-4981-be95-abf67a712f79",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "!rm -r -f ~/results/"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/odc/stats/_algebra.py b/odc/stats/_algebra.py
index ef478cc1..f5345261 100644
--- a/odc/stats/_algebra.py
+++ b/odc/stats/_algebra.py
@@ -5,51 +5,7 @@
import dask.array as da
import xarray as xr
import numpy as np
-import numexpr as ne
-import functools
from dask.base import tokenize
-from typing import Any, Dict, Optional
-from odc.algo._dask import flatten_kv, unflatten_kv
-
-
-def apply_numexpr_np(
- expr: str,
- data: Optional[Dict[str, Any]] = None,
- dtype=None,
- casting="safe",
- order="K",
- **params,
-) -> np.ndarray:
- """
- Apply numexpr to numpy arrays
- """
-
- if data is None:
- data = params
- else:
- data.update(params)
-
- out = ne.evaluate(expr, local_dict=data, casting=casting, order=order)
- if dtype is None:
- return out
- else:
- return out.astype(dtype)
-
-
-def expr_eval(expr, data, dtype="float32", name="expr_eval", **kwargs):
- tk = tokenize(apply_numexpr_np, *flatten_kv(data))
- op = functools.partial(
- apply_numexpr_np, expr, dtype=dtype, casting="unsafe", order="K", **kwargs
- )
-
- return da.map_blocks(
- lambda op, *data: op(unflatten_kv(data)),
- op,
- *flatten_kv(data),
- name=f"{name}_{tk}",
- dtype=dtype,
- meta=np.array((), dtype=dtype),
- )
def _median_by_ind(a):
@@ -76,7 +32,7 @@ def median_by_ind(xr_da, dim, dtype="float32", name="median_by_ind"):
meta=np.array((), dtype=dtype),
drop_axis=0,
)
- coords = dict((dim, xr_da.coords[dim]) for dim in xr_da.dims[1:])
+ coords = {dim: xr_da.coords[dim] for dim in xr_da.dims[1:]}
return xr.DataArray(
res, dims=xr_da.dims[1:], coords=coords, attrs=xr_da.attrs.copy()
@@ -88,5 +44,5 @@ def median_ds(xr_ds, dim, dtype="float32", name="median_ds"):
for var, data in xr_ds.data_vars.items():
res[var] = median_by_ind(data, dim, dtype, name)
# pylint: disable=undefined-loop-variable
- coords = dict((dim, xr_ds.coords[dim]) for dim in data.dims[1:])
+ coords = {dim: xr_ds.coords[dim] for dim in data.dims[1:]}
return xr.Dataset(res, coords=coords, attrs=xr_ds.attrs.copy())
diff --git a/odc/stats/_cli_common.py b/odc/stats/_cli_common.py
index 80fac714..14bb39da 100644
--- a/odc/stats/_cli_common.py
+++ b/odc/stats/_cli_common.py
@@ -2,7 +2,6 @@
import logging
import sys
-from typing import List, Tuple
import click
@@ -12,7 +11,7 @@
from urllib.parse import urlparse
-TileIdx_txy = Tuple[str, int, int] # pylint: disable=invalid-name
+TileIdx_txy = tuple[str, int, int] # pylint: disable=invalid-name
def parse_task(s: str) -> TileIdx_txy:
@@ -27,8 +26,8 @@ def parse_task(s: str) -> TileIdx_txy:
def parse_all_tasks(
- inputs: List[str], all_possible_tasks: List[TileIdx_txy]
-) -> List[TileIdx_txy]:
+ inputs: list[str], all_possible_tasks: list[TileIdx_txy]
+) -> list[TileIdx_txy]:
"""
Select a subset of all possible tasks given user input on cli.
@@ -43,7 +42,7 @@ def parse_all_tasks(
x+10/y-3/2019--P1Y
"""
- out: List[TileIdx_txy] = []
+ out: list[TileIdx_txy] = []
full_set = set(all_possible_tasks)
for s in inputs:
@@ -68,7 +67,7 @@ def parse_all_tasks(
return out
-def parse_resolution(s: str, separator: str = ",") -> Tuple[float, float]:
+def parse_resolution(s: str, separator: str = ",") -> tuple[float, float]:
parts = [float(v) for v in split_and_check(s, separator, (1, 2))]
if len(parts) == 1:
diff --git a/odc/stats/_cli_publish_tasks.py b/odc/stats/_cli_publish_tasks.py
index 71e20843..794b7e24 100644
--- a/odc/stats/_cli_publish_tasks.py
+++ b/odc/stats/_cli_publish_tasks.py
@@ -1,11 +1,10 @@
import json
import sys
-from typing import List, Optional
import click
import fsspec
import toolz
-from datacube.utils.geometry import Geometry
+from odc.geo import Geometry
from odc.aws.queue import get_queue, publish_messages
from odc.dscache.tools.tiling import GRIDS
from odc.stats.model import TileIdx_txy
@@ -28,7 +27,7 @@ def get_geometry(geojson_file: str) -> Geometry:
)
-def filter_tasks(tasks: List[TileIdx_txy], geometry: Geometry, grid_name: str):
+def filter_tasks(tasks: list[TileIdx_txy], geometry: Geometry, grid_name: str):
for task in tasks:
task_geometry = GRIDS[grid_name].tile_geobox((task[1], task[2])).extent
if task_geometry.intersects(geometry):
@@ -36,7 +35,7 @@ def filter_tasks(tasks: List[TileIdx_txy], geometry: Geometry, grid_name: str):
def publish_tasks(
- db: str, task_filter: str, geojson_filter: Optional[str], dryrun: bool, queue: str
+ db: str, task_filter: str, geojson_filter: str | None, dryrun: bool, queue: str
):
reader = TaskReader(db)
if len(task_filter) == 0:
@@ -67,7 +66,7 @@ def publish_tasks(
# We assume the db files are always be the S3 uri. If they are not, there is no need to use SQS queue to process.
messages = (
- dict(Id=str(idx), MessageBody=json.dumps(render_sqs(tidx, db)))
+ {"Id": str(idx), "MessageBody": json.dumps(render_sqs(tidx, db))}
for idx, tidx in enumerate(tasks)
)
diff --git a/odc/stats/_gjson.py b/odc/stats/_gjson.py
index 33246897..9824d00b 100644
--- a/odc/stats/_gjson.py
+++ b/odc/stats/_gjson.py
@@ -1,16 +1,17 @@
import math
from copy import deepcopy
import toolz
-from typing import Tuple, Dict, Any
+from typing import Any
from datetime import timedelta
-from datacube.model import GridSpec
-from datacube.utils.geometry import polygon_from_transform, Geometry
+from odc.geo.gridspec import GridSpec
+from odc.geo import Geometry, wh_
+from odc.geo.geom import polygon_from_transform
from odc.dscache.tools import solar_offset
from .model import TileIdx_xy, TileIdx_txy
-def gs_bounds(gs: GridSpec, tiles: Tuple[Tuple[int, int], Tuple[int, int]]) -> Geometry:
+def gs_bounds(gs: GridSpec, tiles: tuple[tuple[int, int], tuple[int, int]]) -> Geometry:
"""
Compute Polygon for a selection of tiles.
@@ -20,14 +21,14 @@ def gs_bounds(gs: GridSpec, tiles: Tuple[Tuple[int, int], Tuple[int, int]]) -> G
X,Y ranges are inclusive on the left and exclusive on the right, same as numpy slicing.
"""
((x0, x1), (y0, y1)) = tiles
- if gs.resolution[0] < 0:
+ if gs.resolution.y < 0:
gb = gs.tile_geobox((x0, y1 - 1))
else:
gb = gs.tile_geobox((x0, y0))
- nx = (x1 - x0) * gb.shape[1]
- ny = (y1 - y0) * gb.shape[0]
- return polygon_from_transform(nx, ny, gb.affine, gb.crs)
+ nx = (x1 - x0) * gb.shape.x
+ ny = (y1 - y0) * gb.shape.y
+ return polygon_from_transform(wh_(nx, ny), gb.affine, gb.crs)
def timedelta_to_hours(td: timedelta) -> float:
@@ -35,8 +36,8 @@ def timedelta_to_hours(td: timedelta) -> float:
def compute_grid_info(
- cells: Dict[TileIdx_xy, Any], resolution: float = math.inf, title_width: int = 0
-) -> Dict[TileIdx_xy, Any]:
+ cells: dict[TileIdx_xy, Any], resolution: float = math.inf, title_width: int = 0
+) -> dict[TileIdx_xy, Any]:
"""
Compute geojson feature for every cell in ``cells``.
Where ``cells`` is produced by ``bin_dataset_stream``
@@ -74,8 +75,8 @@ def compute_grid_info(
def gjson_from_tasks(
- tasks: Dict[TileIdx_txy, Any], grid_info: Dict[TileIdx_xy, Any]
-) -> Dict[str, Dict[str, Any]]:
+ tasks: dict[TileIdx_txy, Any], grid_info: dict[TileIdx_xy, Any]
+) -> dict[str, dict[str, Any]]:
"""
Group tasks by time period and compute geosjon describing every tile covered by each time period.
@@ -95,14 +96,14 @@ def _get(idx):
dss = tasks[idx]
utc_offset = timedelta(hours=geo["properties"]["utc_offset"])
- ndays = len(set((ds.time + utc_offset).date() for ds in dss))
+ ndays = len({(ds.time + utc_offset).date() for ds in dss})
geo["properties"]["total"] = len(dss)
geo["properties"]["days"] = ndays
return geo
def process(idxs):
- return dict(type="FeatureCollection", features=[_get(idx) for idx in idxs])
+ return {"type": "FeatureCollection", "features": [_get(idx) for idx in idxs]}
return {
t: process(idxs)
diff --git a/odc/stats/_grouper.py b/odc/stats/_grouper.py
new file mode 100644
index 00000000..a99dcffd
--- /dev/null
+++ b/odc/stats/_grouper.py
@@ -0,0 +1,102 @@
+# This file is part of the Open Data Cube, see https://opendatacube.org for more information
+#
+# Copyright (c) 2015-2025 ODC Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Methods for grouping Datasets spatialy and otherwise."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import Any, TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+from datacube.model import Dataset
+from datacube.utils.dates import normalise_dt
+
+if TYPE_CHECKING:
+ from collections.abc import Hashable, Iterable, Iterator
+
+ from odc.geo import Geometry
+
+
+def mid_longitude(geom: Geometry) -> float:
+ """Return longitude of the middle point of the geomtry."""
+ ((lon,), _) = geom.centroid.to_crs("epsg:4326").xy
+ return lon
+
+
+def solar_offset(geom: Geometry, precision: str = "h") -> timedelta:
+ """Given a geometry compute offset to add to UTC timestamp to get solar day right.
+
+ This only work when geometry is "local enough".
+ :param precision: one of ``'h'`` or ``'s'``, defaults to hour precision
+ """
+ lon = mid_longitude(geom)
+
+ if precision == "h":
+ return timedelta(hours=int(lon * 24 / 360 + 0.5))
+
+ # 240 == (24*60*60)/360 (seconds of a day per degree of longitude)
+ return timedelta(seconds=int(lon * 240))
+
+
+def key2num(
+ objs: Iterable[Hashable], reverse_map: dict[int, Any] | None = None
+) -> Iterator[int]:
+ """Given a sequence of hashable objects return sequence of numeric ids starting from 0.
+
+ For example ``'A' 'B' 'A' 'A' 'C' -> 0 1 0 0 2``
+ """
+ o2id: dict[Any, int] = {}
+ c = 0
+ for obj in objs:
+ _c = o2id.setdefault(obj, c)
+ if _c == c:
+ c = c + 1
+ if reverse_map is not None:
+ reverse_map[_c] = obj
+ yield _c
+
+
+def group_by_nothing(
+ dss: list[Dataset], solar_day_offset: timedelta | None = None
+) -> xr.DataArray:
+ """No op grouping of datasets.
+
+ Construct "sources" just like ``.group_dataset`` but with every slice
+ containing just one Dataset object wrapped in a tuple.
+
+ Time -> (Dataset,)
+ """
+ dss = sorted(dss, key=lambda ds: (normalise_dt(ds.center_time), ds.id)) # type: ignore
+ time = [normalise_dt(ds.center_time) for ds in dss] # type: ignore
+ solar_day = None
+
+ if solar_day_offset is not None:
+ solar_day = np.asarray(
+ [(dt + solar_day_offset).date() for dt in time], dtype="datetime64[D]"
+ )
+
+ idx = np.arange(0, len(dss), dtype="uint32")
+ uuids = np.empty(len(dss), dtype="O")
+ data = np.empty(len(dss), dtype="O")
+ grid2crs: dict[int, Any] = {}
+ grid = list(key2num((ds.crs for ds in dss), grid2crs))
+
+ for i, ds in enumerate(dss):
+ data[i] = (ds,)
+ uuids[i] = ds.id
+
+ coords = [np.asarray(time, dtype="datetime64[ms]"), idx, uuids, grid]
+ names = ["time", "idx", "uuid", "grid"]
+ if solar_day is not None:
+ coords.append(solar_day)
+ names.append("solar_day")
+
+ coord = pd.MultiIndex.from_arrays(coords, names=names)
+
+ return xr.DataArray(
+ data=data, coords={"spec": coord}, attrs={"grid2crs": grid2crs}, dims=("spec",)
+ )
diff --git a/odc/stats/_sqs.py b/odc/stats/_sqs.py
index cddd9f5d..b7f04825 100644
--- a/odc/stats/_sqs.py
+++ b/odc/stats/_sqs.py
@@ -2,14 +2,13 @@
Work token for SQS based job control
"""
-from typing import Optional
from datetime import timedelta, datetime
import toolz
from .model import WorkTokenInterface
class SQSWorkToken(WorkTokenInterface):
- def __init__(self, msg, timeout: int, t0: Optional[datetime] = None):
+ def __init__(self, msg, timeout: int, t0: datetime | None = None):
super().__init__()
if t0 is None:
t0 = self.now()
diff --git a/odc/stats/_stac_fetch.py b/odc/stats/_stac_fetch.py
index badfdcc1..129921d7 100644
--- a/odc/stats/_stac_fetch.py
+++ b/odc/stats/_stac_fetch.py
@@ -1,7 +1,7 @@
import json
from odc.aio import S3Fetcher, s3_find_glob
-from odc.stac import stac2ds
+from datacube.metadata import stac2ds
from pystac.item import Item
diff --git a/odc/stats/_text.py b/odc/stats/_text.py
index c5c8191a..be3ece4b 100644
--- a/odc/stats/_text.py
+++ b/odc/stats/_text.py
@@ -1,28 +1,28 @@
from pathlib import Path
-from typing import Union, Optional, Tuple, Dict, Any
+from typing import Any
-PathLike = Union[str, Path]
+PathLike = str | Path
# Copied from odc.io.text
-def read_int(path: PathLike, default=None, base=10) -> Optional[int]:
+def read_int(path: PathLike, default=None, base=10) -> int | None:
"""
Read single integer from a text file.
Useful for things like parsing content of /sys/ or /proc.
"""
try:
- with open(path, "rt", encoding="utf8") as f:
+ with open(path, encoding="utf8") as f:
return int(f.read(), base)
except (FileNotFoundError, ValueError):
return default
def split_and_check(
- s: str, separator: str, n: Union[int, Tuple[int, ...]]
-) -> Tuple[str, ...]:
+ s: str, separator: str, n: int | tuple[int, ...]
+) -> tuple[str, ...]:
"""Turn string into tuple, checking that there are exactly as many parts as expected.
:param s: String to parse
:param separator: Separator character
@@ -44,7 +44,7 @@ def parse_slice(s: str) -> slice:
Examples "::4", "2:5", "2::10", "3:100:5"
"""
- def parse(part: str) -> Optional[int]:
+ def parse(part: str) -> int | None:
if part == "":
return None
return int(part)
@@ -57,32 +57,32 @@ def parse(part: str) -> Optional[int]:
return slice(*parts)
-def parse_yaml(s: str) -> Dict[str, Any]:
+def parse_yaml(s: str) -> dict[str, Any]:
# pylint: disable=import-outside-toplevel
import yaml
return yaml.load(s, Loader=getattr(yaml, "CSafeLoader", yaml.SafeLoader))
-def parse_yaml_file_or_inline(s: str) -> Dict[str, Any]:
+def parse_yaml_file_or_inline(s: str) -> dict[str, Any]:
"""
Accept on input either a path to yaml file or yaml text, return parsed yaml document.
"""
try:
# if file
path = Path(s)
- with open(path, "rt", encoding="utf8") as f:
+ with open(path, encoding="utf8") as f:
txt = f.read()
assert isinstance(txt, str)
- except (FileNotFoundError, IOError, ValueError):
+ except (FileNotFoundError, OSError, ValueError):
txt = s
result = parse_yaml(txt)
if isinstance(result, str):
- raise IOError(f"No such file: {s}")
+ raise OSError(f"No such file: {s}")
return result
-def load_yaml_remote(yaml_url: str) -> Dict[str, Any]:
+def load_yaml_remote(yaml_url: str) -> dict[str, Any]:
"""
Open a yaml file remotely and return the parsed yaml document
"""
@@ -97,7 +97,7 @@ def load_yaml_remote(yaml_url: str) -> Dict[str, Any]:
raise
-def parse_range2d_int(s: str) -> Tuple[Tuple[int, int], Tuple[int, int]]:
+def parse_range2d_int(s: str) -> tuple[tuple[int, int], tuple[int, int]]:
"""Parse string like "0:3,4:5" -> ((0,3), (4,5))"""
try:
return tuple(
diff --git a/odc/stats/io.py b/odc/stats/io.py
index 9fae2215..ddc13d6a 100644
--- a/odc/stats/io.py
+++ b/odc/stats/io.py
@@ -2,7 +2,13 @@
Various I/O adaptors
"""
-from typing import Any, Dict, List, Optional, Union, cast
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING, cast
+from hashlib import sha1
+from collections import namedtuple
+from collections.abc import Callable, Iterable, Sequence
+
import json
from urllib.parse import urlparse
import logging
@@ -14,16 +20,6 @@
from rasterio.crs import CRS
from numpy import datetime64
-from odc.aws.s3_client import S3Client
-from dask.distributed import get_worker
-from datacube.utils.dask import save_blob_to_file
-from datacube.utils.cog import to_cog
-from datacube.model import Dataset
-from .model import Task, EXT_TIFF
-from .plugins import StatsPluginInterface
-from hashlib import sha1
-from collections import namedtuple
-
from eodatasets3.assemble import serialise
from eodatasets3.scripts.tostac import json_fallback
from eodatasets3.model import DatasetDoc
@@ -31,18 +27,44 @@
import eodatasets3.stac as eo3stac
from importlib.metadata import version
+from datacube import Datacube
+from datacube.testutils.io import native_geobox
+from pyproj import aoi, transformer
+
+from odc.geo.geobox import GeoBox
+from odc.geo.geobox import pad as gbox_pad
+from odc.geo.xr import xr_reproject
+
+from ._grouper import group_by_nothing, solar_offset
+from odc.algo._masking import (
+ _max_fuser,
+ _nodata_fuser,
+ _or_fuser,
+ enum_to_bool,
+ mask_cleanup,
+)
+
+from odc.aws.s3_client import S3Client
+from dask.distributed import get_worker
+from datacube.utils.dask import save_blob_to_file
+from odc.geo.cog import to_cog
+
+if TYPE_CHECKING:
+ from .plugins import StatsPluginInterface
+ from .model import Task
+ from datacube.model import Dataset
WriteResult = namedtuple("WriteResult", ["path", "sha1", "error"])
_log = logging.getLogger(__name__)
-DEFAULT_COG_OPTS = dict(
- compress="deflate",
- zlevel=6,
- blocksize=512,
-)
+DEFAULT_COG_OPTS = {
+ "compress": "deflate",
+ "zlevel": 6,
+ "blocksize": 512,
+}
-def dump_json(meta: Dict[str, Any]) -> str:
+def dump_json(meta: dict[str, Any]) -> str:
return json.dumps(meta, separators=(",", ":"))
@@ -69,7 +91,7 @@ def _sha1_digest(*write_results):
lines = []
for wr in write_results:
if wr.error is not None:
- raise IOError(f"Failed to write for: {wr.path}")
+ raise OSError(f"Failed to write for: {wr.path}")
file = wr.path.split("/")[-1]
lines.append(f"{wr.sha1} {file}\n")
return "".join(lines)
@@ -94,9 +116,10 @@ def save_with_s3_client(data, url, with_deps=None, **kw):
class S3COGSink:
def __init__(
self,
- cog_opts: Optional[Dict[str, Any]] = None,
- acl: Optional[str] = None,
+ cog_opts: dict[str, Any] | None = None,
+ acl: str | None = None,
public: bool = False,
+ band_ext: str = "tif",
):
"""
:param creds: S3 write credentials
@@ -123,14 +146,14 @@ def __init__(
"""
if cog_opts is None:
- cog_opts = dict(**DEFAULT_COG_OPTS)
+ cog_opts = {**DEFAULT_COG_OPTS}
else:
- tmp = dict(**DEFAULT_COG_OPTS)
+ tmp = {**DEFAULT_COG_OPTS}
tmp.update(cog_opts)
cog_opts = tmp
cog_opts_per_band = cast(
- Dict[str, Dict[str, Any]], cog_opts.pop("overrides", {})
+ dict[str, dict[str, Any]], cog_opts.pop("overrides", {})
)
per_band_cfg = {k: v for k, v in cog_opts.items() if isinstance(v, dict)}
if per_band_cfg:
@@ -150,13 +173,13 @@ def __init__(
self._stac_meta_contentype = "application/json"
self._odc_meta_contentype = "text/yaml"
self._prod_info_meta_contentype = "text/yaml"
- self._band_ext = EXT_TIFF
+ self._band_ext = band_ext
self._acl = acl
def uri(self, task: Task) -> str:
return task.metadata_path("absolute", ext=self._stac_meta_ext)
- def verify_s3_credentials(self, test_uri: Optional[str] = None) -> bool:
+ def verify_s3_credentials(self, test_uri: str | None = None) -> bool:
if test_uri is None:
return True
rr = self._write_blob(b"verifying S3 permissions", test_uri).compute()
@@ -165,7 +188,7 @@ def verify_s3_credentials(self, test_uri: Optional[str] = None) -> bool:
# pylint: disable=invalid-name
def _write_blob(
- self, data, url: str, ContentType: Optional[str] = None, with_deps=None
+ self, data, url: str, ContentType: str | None = None, with_deps=None
) -> Delayed:
"""
Returns Delayed WriteResult[path, sha1, error=None]
@@ -194,7 +217,7 @@ def _write_blob(
raise ValueError(f"Don't know how to save to '{url}'")
# pylint: enable=invalid-name
- def _ds_to_cog(self, ds: xr.Dataset, paths: Dict[str, str]) -> List[Delayed]:
+ def _ds_to_cog(self, ds: xr.Dataset, paths: dict[str, str]) -> list[Delayed]:
out = []
for band, dv in ds.data_vars.items():
band = str(band)
@@ -235,7 +258,7 @@ def _get_thumbnail(
ContentType="image/jpeg",
)
- def _ds_to_thumbnail_cog(self, ds: xr.Dataset, task: Task) -> List[Delayed]:
+ def _ds_to_thumbnail_cog(self, ds: xr.Dataset, task: Task) -> list[Delayed]:
odc_file_path = task.metadata_path("absolute", ext=self._odc_meta_ext)
thumbnail_cogs = []
@@ -273,7 +296,7 @@ def _ds_to_thumbnail_cog(self, ds: xr.Dataset, task: Task) -> List[Delayed]:
return thumbnail_cogs
- def cog_opts(self, band_name: str = "") -> Dict[str, Any]:
+ def cog_opts(self, band_name: str = "") -> dict[str, Any]:
opts = dict(self._cog_opts)
opts.update(self._cog_opts_per_band.get(band_name, {}))
return opts
@@ -282,7 +305,7 @@ def write_cog(self, da: xr.DataArray, url: str) -> Delayed:
cog_bytes = to_cog(da, **self.cog_opts(str(da.name)))
return self._write_blob(cog_bytes, url, ContentType="image/tiff")
- def exists(self, task: Union[Task, str]) -> bool:
+ def exists(self, task: Task | str) -> bool:
if isinstance(task, str):
uri = task
else:
@@ -324,7 +347,7 @@ def get_eo3_stac_meta(
) # stac_meta is Python str, but content is 'Dict format'
def dump_with_pystac(
- self, task: Task, ds: Dataset, aux: Optional[Dataset] = None
+ self, task: Task, ds: Dataset, aux: Dataset | None = None
) -> Delayed:
"""
Dump files with STAC metadata file, which generated from PySTAC
@@ -366,7 +389,7 @@ def dump_with_eodatasets3(
self,
task: Task,
ds: Dataset,
- aux: Optional[Dataset] = None,
+ aux: Dataset | None = None,
proc: StatsPluginInterface = None,
) -> Delayed:
"""
@@ -381,7 +404,7 @@ def dump_with_eodatasets3(
)
dataset_assembler.extend_user_metadata(
- "input-products", sorted({e.type.name for e in task.datasets})
+ "input-products", sorted({e.product.name for e in task.datasets})
)
dataset_assembler.extend_user_metadata("odc-stats-config", vars(task.product))
@@ -504,15 +527,440 @@ def dump_with_eodatasets3(
with_deps=odc_meta_done,
)
+ # pylint: disable=too-many-positional-arguments
def dump(
self,
task: Task,
ds: Dataset,
- aux: Optional[Dataset] = None,
+ aux: Dataset | None = None,
proc: StatsPluginInterface = None,
- apply_eodatasets3: Optional[bool] = False,
+ apply_eodatasets3: bool | None = False,
) -> Delayed:
if apply_eodatasets3:
return self.dump_with_eodatasets3(task, ds, aux, proc)
else:
return self.dump_with_pystac(task, ds, aux)
+
+
+def compute_native_load_geobox(
+ dst_geobox: GeoBox, ds: Dataset, band: str, buffer: float | None = None
+) -> GeoBox:
+ """Compute area of interest for a given Dataset given query.
+
+ Take native projection and resolution from ``ds, band`` pair and compute
+ region in that projection that fully encloses footprint of the
+ ``dst_geobox`` with some padding. Construct GeoBox that encloses that
+ region fully with resolution/pixel alignment copied from supplied band.
+
+ :param dst_geobox:
+ :param ds: Sample dataset (only resolution and projection is used, not footprint)
+ :param band: Reference band to use
+ (resolution of output GeoBox will match resolution of this band)
+ :param buffer: Buffer in units of CRS of ``ds`` (meters usually),
+ default is 10 pixels worth
+ """
+ native: GeoBox = native_geobox(ds, basis=band)
+ if buffer is None:
+ buffer = 10 * cast(
+ float, max(map(abs, (native.resolution.y, native.resolution.x)))
+ ) # type: ignore
+
+ assert native.crs is not None
+ return GeoBox.from_geopolygon(
+ dst_geobox.extent.to_crs(native.crs).buffer(buffer),
+ crs=native.crs,
+ resolution=native.resolution,
+ align=native.alignment,
+ )
+
+
+def choose_transform_path(
+ src_crs: str,
+ dst_crs: str,
+ transform_code: str | None = None,
+ area_of_interest: Sequence[float] | None = None,
+) -> str:
+ # leave gdal to choose the best option if nothing is specified
+ if transform_code is None and area_of_interest is None:
+ return {}
+
+ if area_of_interest is not None:
+ assert len(area_of_interest) == 4
+ area_of_interest = aoi.AreaOfInterest(*area_of_interest)
+
+ transformer_group = transformer.TransformerGroup(
+ src_crs, dst_crs, area_of_interest=area_of_interest
+ )
+ if transform_code is None:
+ return {"COORDINATE_OPERATION": transformer_group.transformers[0].to_proj4()}
+ for t in transformer_group.transformers:
+ for step in json.loads(t.to_json()).get("steps", []):
+ if step.get("type", "") == "Transformation":
+ authority_code = step.get("id", {})
+ if transform_code.split(":")[0].upper() in authority_code.get(
+ "authority", ""
+ ) and transform_code.split(":")[1] == str(
+ authority_code.get("code", "")
+ ):
+ return {"COORDINATE_OPERATION": t.to_proj4()}
+ # raise error if nothing is available
+ raise ValueError(f"Not able to find transform path by {transform_code}")
+
+
+def _split_by_grid(xx: xr.DataArray) -> list[xr.DataArray]:
+ def extract(grid_id, ii):
+ yy = xx[ii]
+ crs = xx.grid2crs[grid_id]
+ yy.attrs.update(crs=crs)
+ yy.attrs.pop("grid2crs", None)
+ return yy
+
+ return [extract(grid_id, ii) for grid_id, ii in xx.groupby(xx.grid).groups.items()]
+
+
+def _native_load_1(
+ sources: xr.DataArray,
+ bands: tuple[str, ...],
+ geobox: GeoBox,
+ *,
+ optional_bands: tuple[str, ...] | None = None,
+ basis: str | None = None,
+ load_chunks: dict[str, int] | None = None,
+ pad: int | None = None,
+) -> xr.Dataset:
+ if basis is None:
+ basis = bands[0]
+ (ds,) = sources.data[0]
+ load_geobox = compute_native_load_geobox(geobox, ds, basis)
+ if pad is not None:
+ load_geobox = gbox_pad(load_geobox, pad)
+
+ mm = ds.product.lookup_measurements(bands)
+ if optional_bands is not None:
+ for ob in optional_bands:
+ try:
+ om = ds.product.lookup_measurements(ob)
+ except KeyError:
+ continue
+ else:
+ mm.update(om)
+
+ xx = Datacube.load_data(sources, load_geobox, mm, dask_chunks=load_chunks)
+ return xx
+
+
+def native_load(
+ dss: Sequence[Dataset],
+ bands: Sequence[str],
+ geobox: GeoBox,
+ *,
+ optional_bands: tuple[str, ...] | None = None,
+ basis: str | None = None,
+ load_chunks: dict[str, int] | None = None,
+ pad: int | None = None,
+):
+ sources = group_by_nothing(list(dss), solar_offset(geobox.extent))
+ for srcs in _split_by_grid(sources):
+ _xx = _native_load_1(
+ srcs,
+ tuple(bands),
+ geobox,
+ optional_bands=optional_bands,
+ basis=basis,
+ load_chunks=load_chunks,
+ pad=pad,
+ )
+ yield _xx
+
+
+def _apply_native_transform_1(
+ xx: xr.Dataset,
+ native_transform: Callable[[xr.Dataset], xr.Dataset],
+ groupby: str | None = None,
+ fuser: Callable[[xr.Dataset], xr.Dataset] | None = None,
+) -> xr.Dataset:
+ xx = native_transform(xx)
+
+ if groupby is not None:
+ if fuser is None:
+ fuser = _nodata_fuser # type: ignore
+ xx = xx.groupby(groupby).map(fuser)
+
+ return xx
+
+
+# pylint:disable=too-many-arguments,too-many-locals,too-many-branches
+def load_with_native_transform(
+ dss: Sequence[Dataset],
+ bands: Sequence[str],
+ geobox: GeoBox,
+ native_transform: Callable[[xr.Dataset], xr.Dataset],
+ *,
+ optional_bands: tuple[str, ...] | None = None,
+ basis: str | None = None,
+ groupby: str | None = None,
+ fuser: Callable[[xr.Dataset], xr.Dataset] | None = None,
+ resampling: str = "nearest",
+ chunks: dict[str, int] | None = None,
+ load_chunks: dict[str, int] | None = None,
+ pad: int | None = None,
+ **kw,
+) -> xr.Dataset:
+ """Load a bunch of datasets with native pixel transform.
+
+ :param dss: A list of datasets to load
+ :param bands: Which measurements to load
+ :param geobox: GeoBox of the final output
+ :param native_transform: ``xr.Dataset -> xr.Dataset`` transform,
+ should support Dask inputs/outputs
+ :param basis: Name of the band to use as a reference for what is "native projection"
+ :param groupby: One of 'solar_day'|'time'|'idx'|None
+ :param fuser: Optional ``xr.Dataset -> xr.Dataset`` transform
+ :param resampling: Any resampling mode supported by GDAL as a string:
+ nearest, bilinear, average, mode, cubic, etc...
+ :param chunks: If set use Dask, must be in dictionary form
+ ``{'x': 4000, 'y': 4000}``
+
+ :param load_chunks: Defaults to ``chunks`` but can be different if supplied
+ (different chunking for native read vs reproject)
+
+ :param pad: Optional padding in native pixels, if set will load extra
+ pixels beyond of what is needed to reproject to final
+ destination. This is useful when you plan to apply convolution
+ filter or morphological operators on input data.
+
+ :param kw: Used to support old names ``dask_chunks`` and ``group_by``
+ also kwargs for reproject ``tranform_code`` in the form of
+ "authority:code", e.g., "epsg:9688", and ``area_of_interest``,
+ e.g., [-180, -90, 180, 90]
+
+ 1. Partition datasets by native Projection
+ 2. For every group do
+ - Load data
+ - Apply native_transform
+ - [Optional] fuse rasters that happened on the same day/time
+ - Reproject to final geobox
+ 3. Stack output of (2)
+ 4. [Optional] fuse rasters that happened on the same day/time
+ """
+ if fuser is None:
+ fuser = _nodata_fuser
+
+ if groupby is None:
+ groupby = kw.pop("group_by", "idx")
+
+ if chunks is None:
+ chunks = kw.pop("dask_chunks", None)
+
+ if load_chunks is None:
+ load_chunks = chunks
+
+ _chunks = None
+ if chunks is not None:
+ _chunks = tuple(
+ getattr(geobox.shape, ax) if chunks.get(ax, -1) == -1 else chunks.get(ax)
+ for ax in ("y", "x")
+ )
+
+ _xx = []
+ # fail if the intended transform not available
+ # to avoid any unexpected results
+ for xx in native_load(
+ dss,
+ bands,
+ geobox,
+ optional_bands=optional_bands,
+ basis=basis,
+ load_chunks=load_chunks,
+ pad=pad,
+ ):
+ extra_args = choose_transform_path(
+ xx.crs,
+ geobox.crs,
+ kw.pop("transform_code", None),
+ kw.pop("area_of_interest", None),
+ )
+ extra_args.update(kw)
+
+ yy = _apply_native_transform_1(
+ xx,
+ native_transform,
+ groupby=groupby,
+ fuser=fuser,
+ )
+
+ vars_to_scale = False
+ if isinstance(yy, xr.DataArray):
+ vars_to_scale = True
+ if yy.dtype == "bool":
+ yy = yy.astype("uint8") << 7
+ else:
+ vars_to_scale = [var for var in yy.data_vars if yy[var].dtype == "bool"]
+ yy = yy.assign(
+ **{var: yy[var].astype("uint8") << 7 for var in vars_to_scale}
+ )
+
+ _yy = xr_reproject(
+ yy,
+ geobox,
+ resampling=resampling,
+ chunks=_chunks,
+ **extra_args,
+ )
+
+ if isinstance(_yy, xr.DataArray) and vars_to_scale:
+ _yy = _yy > 64
+ elif vars_to_scale:
+ _yy = _yy.assign(**{var: _yy[var] > 64 for var in vars_to_scale})
+
+ _xx += [_yy]
+
+ if len(_xx) == 1:
+ xx = _xx[0]
+ else:
+ xx = xr.concat(_xx, _xx[0].dims[0]) # type: ignore
+ if groupby != "idx":
+ xx = xx.groupby(groupby).map(fuser)
+ # TODO: probably want to replace spec MultiIndex with just `time` component
+ return xx
+
+
+def load_enum_mask(
+ dss: list[Dataset],
+ band: str,
+ geobox: GeoBox,
+ *,
+ categories: Iterable[str | int],
+ invert: bool = False,
+ resampling: str = "nearest",
+ groupby: str | None = None,
+ chunks: dict[str, int] | None = None,
+ **kw,
+) -> xr.DataArray:
+ """Load enumerated mask (like fmask).
+
+ 1. Load each mask time slice separately in native projection of the file
+ 2. Convert enum to Boolean (F:0, T:255)
+ 3. Optionally (groupby='solar_day') group observations on the same day
+ using OR for pixel fusing: T,F->T
+ 4. Reproject to destination GeoBox (any resampling mode is ok)
+ 5. Optionally group observations on the same day using OR for pixel fusing T,F->T
+ 6. Finally convert to real Bool
+ """
+
+ def native_op(ds):
+ return ds.map(
+ enum_to_bool,
+ categories=categories,
+ invert=invert,
+ dtype="uint8",
+ value_true=255,
+ )
+
+ xx = load_with_native_transform(
+ dss,
+ (band,),
+ geobox,
+ native_op,
+ basis=band,
+ resampling=resampling,
+ groupby=groupby,
+ chunks=chunks,
+ fuser=_max_fuser,
+ **kw,
+ )
+ return xx[band] > 127
+
+
+def load_enum_filtered(
+ dss: Sequence[Dataset],
+ band: str,
+ geobox: GeoBox,
+ *,
+ categories: Iterable[str | int],
+ filters: Iterable[tuple[str, int]] | None = None,
+ groupby: str | None = None,
+ resampling: str = "nearest",
+ chunks: dict[str, int] | None = None,
+ **kw,
+) -> xr.DataArray:
+ """Load enumerated mask (like fmask/SCL) with native pixel filtering.
+
+ The idea is to load "cloud" classes while adding some padding, then erase
+ pixels that were classified as cloud in any of the observations on a given
+ day.
+
+ This method converts enum-mask to a boolean image in the native projection
+ of the data and then reprojects boolean image to the final
+ projections/resolution. This allows one to use any resampling strategy,
+ like ``average`` or ``cubic`` and not be limited to a few resampling
+ strategies that support operations on categorical data.
+
+ :param dss: A list of datasets to load
+ :param band: Which measurement band to load
+ :param geobox: GeoBox of the final output
+ :param categories: Enum values or names
+
+ :param filters: iterable tuples of morphological operations in the order
+ you want them to perform, e.g., [("opening", 2), ("dilation", 5)]
+ :param groupby: One of 'solar_day'|'time'|'idx'|None
+ :param resampling: Any resampling mode supported by GDAL as a string:
+ nearest, bilinear, average, mode, cubic, etc...
+ :param chunks: If set use Dask, must be in dictionary form
+ ``{'x': 4000, 'y': 4000}``
+ :param kw: Passed on to ``load_with_native_transform``
+
+
+ 1. Load each mask time slice separately in native projection of the file
+ 2. Convert enum to Boolean
+ 3. Optionally (groupby='solar_day') group observations on the same day
+ using OR for pixel fusing: T,F->T
+ 4. Optionally apply ``mask_cleanup`` in native projection (after fusing)
+ 4. Reproject to destination GeoBox (any resampling mode is ok)
+ 5. Optionally group observations on the same day using OR for pixel fusing T,F->T
+ """
+
+ def native_op(xx: xr.Dataset) -> xr.Dataset:
+ _xx = enum_to_bool(xx[band], categories)
+ return xr.Dataset(
+ {band: _xx},
+ attrs={"native": True}, # <- native flag needed for fuser
+ )
+
+ def fuser(xx: xr.Dataset) -> xr.Dataset:
+ """Fuse with OR.
+
+ Fuse with OR, and when fusing in native pixel domain apply mask_cleanup if
+ requested
+ """
+ is_native = xx.attrs.get("native", False)
+ xx = xx.map(_or_fuser)
+ xx.attrs.pop("native", None)
+
+ if is_native and filters is not None:
+ _xx = xx[band]
+ assert isinstance(_xx, xr.DataArray)
+ xx[band] = mask_cleanup(_xx, mask_filters=filters)
+
+ return xx
+
+ # unless set by user to some value use largest filter radius for pad value
+ pad: int | None = kw.pop("pad", None)
+ if pad is None:
+ if filters is not None:
+ pad = max(list(zip(*filters, strict=False))[1]) # type: ignore
+
+ xx = load_with_native_transform(
+ dss,
+ (band,),
+ geobox,
+ native_op,
+ fuser=fuser,
+ groupby=groupby,
+ resampling=resampling,
+ chunks=chunks,
+ pad=pad,
+ **kw,
+ )[band]
+ assert isinstance(xx, xr.DataArray)
+ return xx
diff --git a/odc/stats/model.py b/odc/stats/model.py
index 0ad7b408..5997ea3e 100644
--- a/odc/stats/model.py
+++ b/odc/stats/model.py
@@ -3,7 +3,8 @@
from copy import deepcopy
from dataclasses import dataclass, field
from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Any
+from collections.abc import Sequence
from uuid import UUID, uuid5
from pathlib import Path
@@ -11,22 +12,23 @@
import pystac
import xarray as xr
from datacube.model import Dataset
+from datacube.model.lineage import LineageTree
from datacube.utils.dates import normalise_dt
-from datacube.utils.geometry import GeoBox
+from odc.geo.geobox import GeoBox
from ._text import split_and_check
from pystac.extensions.projection import ProjectionExtension
from toolz import dicttoolz
from rasterio.crs import CRS
import warnings
-from eodatasets3.assemble import DatasetAssembler, serialise
+from eodatasets3.assemble import DatasetAssembler, serialise, _validate_property_name
from eodatasets3.images import GridSpec
from .plugins import StatsPluginInterface
-TileIdx_xy = Tuple[int, int] # pylint:disable=invalid-name
-TileIdx_txy = Tuple[str, int, int] # pylint:disable=invalid-name
-TileIdx = Union[TileIdx_txy, TileIdx_xy]
+TileIdx_xy = tuple[int, int] # pylint:disable=invalid-name
+TileIdx_txy = tuple[str, int, int] # pylint:disable=invalid-name
+TileIdx = TileIdx_txy | TileIdx_xy
DEFAULT_HREF_PREFIX = "https://collections.dea.ga.gov.au/product"
EXT_TIFF = "tif" # because "consistency"
@@ -76,7 +78,7 @@ def format_datetime(dt: datetime, with_tz=True, timespec="microseconds") -> str:
class DateTimeRange:
__slots__ = ("start", "end", "freq")
- def __init__(self, start: Union[str, datetime], freq: Optional[str] = None):
+ def __init__(self, start: str | datetime, freq: str | None = None):
"""
DateTimeRange('2019-03--P3M')
@@ -114,9 +116,7 @@ def __str__(self):
def __repr__(self):
return f"DateTimeRange({repr(self.start)}, {repr(self.freq)})"
- def dc_query(
- self, pad: Optional[Union[timedelta, float, int]] = None
- ) -> Dict[str, Any]:
+ def dc_query(self, pad: timedelta | float | int | None = None) -> dict[str, Any]:
"""
Transform to form understood by datacube
@@ -178,19 +178,19 @@ class OutputProduct: # pylint:disable=too-many-instance-attributes
version: str
short_name: str
location: str
- properties: Dict[str, str]
- measurements: Tuple[str, ...]
+ properties: dict[str, str]
+ measurements: tuple[str, ...]
href: str = ""
region_code_format: str = "x{x:02d}y{y:02d}"
cfg: Any = None
naming_conventions_values: str = "dea_c3"
explorer_path: str = "https://explorer.dea.ga.gov.au/"
- inherit_skip_properties: Optional[List[str]] = None
- preview_image_ows_style: Optional[Dict[str, Any]] = None
+ inherit_skip_properties: list[str] | None = None
+ preview_image_ows_style: dict[str, Any] | None = None
classifier: str = "level3"
maturity: str = "final"
collection_number: int = 3
- nodata: Optional[Dict[str, int]] = None
+ nodata: dict[str, int] | None = None
def __post_init__(self):
if self.href == "":
@@ -205,7 +205,7 @@ def region_code(self, tidx: TileIdx_xy) -> str:
@staticmethod
def dummy(
- measurements: Tuple[str, ...] = ("red", "green", "blue")
+ measurements: tuple[str, ...] = ("red", "green", "blue"),
) -> "OutputProduct":
version = "0.0.0"
name = "dummy"
@@ -286,10 +286,10 @@ class Task:
tile_index: TileIdx_xy
geobox: GeoBox
time_range: DateTimeRange
- datasets: Tuple[Dataset, ...] = field(repr=False)
+ datasets: tuple[Dataset, ...] = field(repr=False)
uuid: UUID = UUID(int=0)
short_time: str = field(init=False, repr=False)
- source: Optional[WorkTokenInterface] = field(init=True, repr=False, default=None)
+ source: WorkTokenInterface | None = field(init=True, repr=False, default=None)
def __post_init__(self):
self.short_time = self.time_range.short
@@ -313,24 +313,14 @@ def location(self) -> str:
p1, p2 = rc[:mid], rc[mid:]
return "/".join([p1, p2, self.short_time])
- def _lineage(self) -> Tuple[UUID, ...]:
- ds, *_ = self.datasets
-
- # TODO: replace this and test
- # if 'fused' in ds.metadata._doc['properties'].keys():
- if "fused" in ds.type.name:
- lineage = tuple(
- set(
- x
- for ds in self.datasets
- for y in ds.metadata.sources.values()
- for x in y.values()
- )
+ def _lineage(self) -> tuple[UUID, ...]:
+ lineage = set()
+ for ds in self.datasets:
+ tree = LineageTree.from_eo3_doc(ds.metadata_doc)
+ lineage |= (
+ tree.child_datasets() if tree.child_datasets() else {tree.dataset_id}
)
- else:
- lineage = tuple(ds.id for ds in self.datasets)
-
- return lineage
+ return tuple(lineage)
def _prefix(self, relative_to: str = "dataset") -> str:
product = self.product
@@ -358,7 +348,7 @@ def _prefix(self, relative_to: str = "dataset") -> str:
def paths(
self, relative_to: str = "dataset", ext: str = EXT_TIFF
- ) -> Dict[str, str]:
+ ) -> dict[str, str]:
"""
Compute dictionary mapping band name to paths.
@@ -390,13 +380,13 @@ def render_assembler_metadata(
self,
ext: str = EXT_TIFF,
output_dataset: xr.Dataset = None,
- processing_dt: Optional[datetime] = None,
+ processing_dt: datetime | None = None,
) -> DatasetAssembler:
"""
Put together metadata document for the output of this task. It needs the source_dataset to inherit
several properties and lineages. It also needs the output_dataset to get the measurement information.
"""
- # pylint:disable=too-many-branches
+ # pylint:disable=too-many-branches,protected-access
dataset_assembler = DatasetAssembler(
naming_conventions=self.product.naming_conventions_values,
dataset_location=Path(self.product.explorer_path),
@@ -408,48 +398,30 @@ def render_assembler_metadata(
platforms, instruments = ([], [])
+ _validate_property_name(self.product.classifier)
for dataset in self.datasets:
- if "fused" in dataset.type.name:
- sources = [e["id"] for e in dataset.metadata.sources.values()]
- if dataset.metadata_doc["properties"].get("eo:platform") is not None:
- platforms.append(dataset.metadata_doc["properties"]["eo:platform"])
- if dataset.metadata_doc["properties"].get("eo:instrument") is not None:
- if isinstance(
- dataset.metadata_doc["properties"]["eo:instrument"], list
- ):
- instruments += dataset.metadata_doc["properties"][
- "eo:instrument"
- ]
- else:
- instruments += [
- dataset.metadata_doc["properties"]["eo:instrument"]
- ]
- dataset_assembler.note_source_datasets(
- self.product.classifier, *sources
- )
- else:
- dataset.metadata_doc.setdefault("$schema", "")
- source_datasetdoc = serialise.from_doc(
- dataset.metadata_doc, skip_validation=True
- )
- dataset_assembler.add_source_dataset(
- source_datasetdoc,
- classifier=self.product.classifier,
- auto_inherit_properties=True, # it will grab all useful input dataset preperties
- inherit_geometry=False,
- inherit_skip_properties=self.product.inherit_skip_properties,
- )
-
- if source_datasetdoc.properties.get("eo:platform") is not None:
- platforms.append(source_datasetdoc.properties["eo:platform"])
- if source_datasetdoc.properties.get("eo:instrument") is not None:
- if isinstance(source_datasetdoc.properties["eo:instrument"], list):
- instruments += source_datasetdoc.properties["eo:instrument"]
- else:
- instruments.append(
- source_datasetdoc.properties["eo:instrument"]
- )
+ if dataset.metadata_doc["properties"].get("eo:platform") is not None:
+ platforms.append(dataset.metadata_doc["properties"]["eo:platform"])
+ if dataset.metadata_doc["properties"].get("eo:instrument") is not None:
+ if isinstance(
+ dataset.metadata_doc["properties"]["eo:instrument"], list
+ ):
+ instruments += dataset.metadata_doc["properties"]["eo:instrument"]
+ else:
+ instruments += [dataset.metadata_doc["properties"]["eo:instrument"]]
+
+ dataset.metadata_doc.setdefault("$schema", "")
+ source_datasetdoc = serialise.from_doc(
+ dataset.metadata_doc, skip_validation=True
+ )
+ # it will grab all useful input dataset preperties
+ dataset_assembler._inherit_properties_from(
+ source_datasetdoc, self.product.inherit_skip_properties
+ )
+ dataset_assembler.note_source_datasets(
+ self.product.classifier, *self._lineage()
+ )
dataset_assembler.platform = ",".join(sorted(set(platforms)))
dataset_assembler.instrument = "_".join(sorted(set(instruments)))
@@ -492,7 +464,7 @@ def render_assembler_metadata(
path,
expand_valid_data=False,
grid=GridSpec(
- shape=self.geobox.shape,
+ shape=self.geobox.shape.yx,
transform=self.geobox.transform,
crs=CRS.from_epsg(self.geobox.crs.to_epsg()),
),
@@ -506,8 +478,8 @@ def render_assembler_metadata(
return dataset_assembler
def render_metadata(
- self, ext: str = EXT_TIFF, processing_dt: Optional[datetime] = None
- ) -> Dict[str, Any]:
+ self, ext: str = EXT_TIFF, processing_dt: datetime | None = None
+ ) -> dict[str, Any]:
"""
Put together STAC metadata document for the output of this task.
"""
@@ -519,7 +491,7 @@ def render_metadata(
region_code = product.region_code(self.tile_index)
inputs = list(map(str, self._lineage()))
- properties: Dict[str, Any] = deepcopy(product.properties)
+ properties: dict[str, Any] = deepcopy(product.properties)
properties["dtr:start_datetime"] = format_datetime(self.time_range.start)
properties["dtr:end_datetime"] = format_datetime(self.time_range.end)
@@ -544,7 +516,9 @@ def render_metadata(
)
ProjectionExtension.add_to(item)
proj_ext = ProjectionExtension.ext(item)
- proj_ext.apply(geobox.crs.epsg, transform=geobox.transform, shape=geobox.shape)
+ proj_ext.apply(
+ epsg=geobox.crs.epsg, transform=geobox.transform, shape=list(geobox.shape)
+ )
# Lineage last
item.properties["odc:lineage"] = {"inputs": inputs}
@@ -581,22 +555,23 @@ def render_metadata(
def product_for_plugin( # pylint:disable=too-many-arguments,too-many-locals
plugin: StatsPluginInterface,
location: str,
- name: Optional[str] = None,
- short_name: Optional[str] = None,
- version: Optional[str] = None,
- product_family: Optional[str] = None,
+ *,
+ name: str | None = None,
+ short_name: str | None = None,
+ version: str | None = None,
+ product_family: str | None = None,
collections_site: str = "collections.dea.ga.gov.au",
producer: str = "ga.gov.au",
- properties: Dict[str, Any] = None,
+ properties: dict[str, Any] = None,
region_code_format: str = "x{x:02d}y{y:02d}",
naming_conventions_values: str = "dea_c3",
explorer_path: str = "https://explorer.dea.ga.gov.au",
- inherit_skip_properties: Optional[List[str]] = None,
- preview_image_ows_style: Optional[Dict[str, Any]] = None,
+ inherit_skip_properties: list[str] | None = None,
+ preview_image_ows_style: dict[str, Any] | None = None,
classifier: str = "level3",
- maturity: Optional[str] = None,
+ maturity: str | None = None,
collection_number: int = 3,
- nodata: Optional[Dict[str, int]] = None,
+ nodata: dict[str, int] | None = None,
) -> OutputProduct:
"""
:param plugin: An instance of a subclass of StatsPluginInterface, used for name defaults.
@@ -674,7 +649,7 @@ class TaskResult:
task: Task
result_location: str = ""
skipped: bool = False
- error: Optional[str] = None
+ error: str | None = None
meta: Any = field(init=True, repr=False, default=None)
def __bool__(self):
@@ -699,12 +674,12 @@ def default_cog_settings():
# Plugin
plugin: str = ""
- plugin_config: Dict[str, Any] = field(init=True, repr=True, default_factory=dict)
+ plugin_config: dict[str, Any] = field(init=True, repr=True, default_factory=dict)
# Output Product
# .{name| short_name| version| product_family|
# collections_site| producer| properties: Dict[str, Any]}
- product: Dict[str, Any] = field(init=True, repr=True, default_factory=dict)
+ product: dict[str, Any] = field(init=True, repr=True, default_factory=dict)
# Dask config
threads: int = -1
@@ -712,14 +687,14 @@ def default_cog_settings():
# S3/Output config
output_location: str = ""
- s3_acl: Optional[str] = None
+ s3_acl: str | None = None
# s3_public is deprecated, use s3_acl="public-read" instead
s3_public: bool = False
- cog_opts: Dict[str, Any] = field(init=True, repr=True, default_factory=dict)
+ cog_opts: dict[str, Any] = field(init=True, repr=True, default_factory=dict)
overwrite: bool = False
# Heartbeat filepath
- heartbeat_filepath: Optional[str] = None
+ heartbeat_filepath: str | None = None
# Terminate task if running longer than this amount (seconds)
max_processing_time: int = 0
diff --git a/odc/stats/plugins/_base.py b/odc/stats/plugins/_base.py
index f6df4ac6..ebf534b5 100644
--- a/odc/stats/plugins/_base.py
+++ b/odc/stats/plugins/_base.py
@@ -1,12 +1,12 @@
from abc import ABC, abstractmethod
-from typing import Mapping, Optional, Sequence, Tuple
+from collections.abc import Mapping, Sequence
import xarray as xr
import numpy as np
from datacube.model import Dataset
-from datacube.utils.geometry import GeoBox
+from odc.geo.geobox import GeoBox
from odc.algo import to_rgba
-from odc.algo.io import load_with_native_transform
+from odc.stats.io import load_with_native_transform
from odc.algo._masking import _nodata_fuser
@@ -16,20 +16,20 @@ class StatsPluginInterface(ABC):
VERSION = "0.0.0"
PRODUCT_FAMILY = "statistics"
- # pylint:disable=too-many-arguments
+ # pylint:disable=too-many-arguments,too-many-positional-arguments
def __init__(
self,
resampling: str = "bilinear",
- input_bands: Optional[Sequence[str]] = None,
- optional_bands: Optional[Sequence[str]] = None,
- chunks: Optional[Mapping[str, int]] = None,
- basis: Optional[str] = None,
+ input_bands: Sequence[str] | None = None,
+ optional_bands: Sequence[str] | None = None,
+ chunks: Mapping[str, int] | None = None,
+ basis: str | None = None,
group_by: str = "solar_day",
- rgb_bands: Optional[Sequence[str]] = None,
- rgb_clamp: Tuple[float, float] = (1.0, 3_000.0),
- transform_code: Optional[str] = None,
- area_of_interest: Optional[Sequence[float]] = None,
- measurements: Optional[Sequence[str]] = None,
+ rgb_bands: Sequence[str] | None = None,
+ rgb_clamp: tuple[float, float] = (1.0, 3_000.0),
+ transform_code: str | None = None,
+ area_of_interest: Sequence[float] | None = None,
+ measurements: Sequence[str] | None = None,
):
self.resampling = resampling
self.input_bands = input_bands if input_bands is not None else []
@@ -45,7 +45,7 @@ def __init__(
self.dask_worker_plugin = None
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
if self._measurements is None:
raise NotImplementedError("Plugins must provide 'measurements'")
return self._measurements
@@ -84,7 +84,7 @@ def input_data(
def reduce(self, xx: xr.Dataset) -> xr.Dataset:
pass
- def rgba(self, xx: xr.Dataset) -> Optional[xr.DataArray]:
+ def rgba(self, xx: xr.Dataset) -> xr.DataArray | None:
"""
Given result of ``.reduce(..)`` optionally produce RGBA preview image
"""
diff --git a/odc/stats/plugins/_registry.py b/odc/stats/plugins/_registry.py
index f9d8c649..b6757b8d 100644
--- a/odc/stats/plugins/_registry.py
+++ b/odc/stats/plugins/_registry.py
@@ -1,5 +1,5 @@
import pydoc
-from typing import Callable, Dict, Type
+from collections.abc import Callable
from functools import partial
from ._base import StatsPluginInterface
@@ -7,7 +7,7 @@
PluginFactory = Callable[..., StatsPluginInterface]
-_plugins: Dict[str, PluginFactory] = {}
+_plugins: dict[str, PluginFactory] = {}
def _new(plugin_class, *args, **kwargs) -> StatsPluginInterface:
@@ -30,7 +30,7 @@ def resolve(name: str) -> PluginFactory:
return maker
-def register(name: str, plugin_class: Type[StatsPluginInterface]):
+def register(name: str, plugin_class: type[StatsPluginInterface]):
_plugins[name] = partial(_new, plugin_class)
diff --git a/odc/stats/plugins/cloud_proba_percentiles.py b/odc/stats/plugins/cloud_proba_percentiles.py
new file mode 100644
index 00000000..dbf5c350
--- /dev/null
+++ b/odc/stats/plugins/cloud_proba_percentiles.py
@@ -0,0 +1,94 @@
+"""
+Long-term percentiles of S2Cloudless probabilities.
+
+Useful for locating regions persistently misclassified as
+cloud by S2Cloudless, which is known to have a high false
+positive rate.
+
+"""
+
+from typing import Sequence, Tuple, Mapping
+
+import numpy as np
+import xarray as xr
+from odc.algo._percentile import xr_quantile_bands
+from odc.stats.plugins._registry import register, StatsPluginInterface
+from odc.algo._masking import erase_bad, enum_to_bool
+
+
+class S2Cloudless_percentiles(StatsPluginInterface):
+ NAME = "S2Cloudless_percentiles"
+ SHORT_NAME = NAME
+ VERSION = "0.0.1"
+ PRODUCT_FAMILY = "percentiles"
+
+ def __init__(
+ self,
+ resampling: str = "cubic",
+ bands: Sequence[str] = ["oa_s2cloudless_prob"],
+ output_bands: Sequence[str] = [
+ "oa_s2cloudless_prob_pc_5",
+ "oa_s2cloudless_prob_pc_10",
+ "oa_s2cloudless_prob_pc_25",
+ ],
+ mask_band: str = "oa_s2cloudless_mask",
+ chunks: Mapping[str, int] = {"y": 512, "x": 512},
+ group_by: str = "solar_day",
+ nodata_classes: Sequence[str] = ["nodata"],
+ output_dtype: str = "float32",
+ **kwargs,
+ ):
+
+ self.resampling = resampling
+ self.bands = bands
+ self.output_bands = output_bands
+ self.mask_band = mask_band
+ self.chunks = chunks
+ self.group_by = group_by
+ self.resampling = resampling
+ self.nodata_classes = nodata_classes
+ self.output_dtype = np.dtype(output_dtype)
+ self.output_nodata = np.nan
+
+ super().__init__(
+ input_bands=tuple(bands), resampling=resampling, chunks=chunks, **kwargs
+ )
+
+ @property
+ def measurements(self) -> Tuple[str, ...]:
+ return self.output_bands
+
+ def native_transform(self, xx: xr.Dataset) -> xr.Dataset:
+ """
+ erases nodata
+ """
+
+ # step 1-----------------
+ if self.mask_band not in xx.data_vars:
+ return xx
+
+ # Erase Data Pixels for which mask == nodata
+ mask = xx[self.mask_band]
+ bad = enum_to_bool(mask, self.nodata_classes)
+
+ # drop mask band
+ xx = xx.drop_vars([self.mask_band])
+
+ # apply the masks
+ xx = erase_bad(xx, bad)
+
+ return xx
+
+ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
+ """
+ Calculate the percentiles of long-term cloud probabilities
+
+ """
+
+ # Compute the percentiles of long-term cloud probabilities.
+ yy = xr_quantile_bands(xx, [0.05, 0.10, 0.25], nodata=np.nan)
+
+ return yy
+
+
+register("s2_gm_tools.S2Cloudless_percentiles", S2Cloudless_percentiles)
diff --git a/odc/stats/plugins/fc_percentiles.py b/odc/stats/plugins/fc_percentiles.py
index c70375dd..46e704d4 100644
--- a/odc/stats/plugins/fc_percentiles.py
+++ b/odc/stats/plugins/fc_percentiles.py
@@ -4,7 +4,7 @@
from functools import partial
from itertools import product
-from typing import Tuple, Dict, Iterable, Optional
+from collections.abc import Iterable
import numpy as np
import xarray as xr
@@ -23,15 +23,16 @@ class StatsFCP(StatsPluginInterface):
VERSION = "0.0.3"
PRODUCT_FAMILY = "fc_percentiles"
- BAD_BITS_MASK = dict(cloud=(1 << 6), cloud_shadow=(1 << 5), terrain_shadow=(1 << 3))
+ BAD_BITS_MASK = {"cloud": 1 << 6, "cloud_shadow": 1 << 5, "terrain_shadow": 1 << 3}
def __init__(
self,
- max_sum_limit: Optional[int] = None,
- clip_range: Optional[Tuple] = None,
- ue_threshold: Optional[int] = None,
- count_valid: Optional[bool] = False,
- cloud_filters: Dict[str, Iterable[Tuple[str, int]]] = None,
+ *,
+ max_sum_limit: int | None = None,
+ clip_range: tuple | None = None,
+ ue_threshold: int | None = None,
+ count_valid: bool | None = False,
+ cloud_filters: dict[str, Iterable[tuple[str, int]]] = None,
**kwargs,
):
super().__init__(input_bands=["water", "pv", "bs", "npv", "ue"], **kwargs)
@@ -43,7 +44,7 @@ def __init__(
self.cloud_filters = cloud_filters if cloud_filters is not None else {}
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
_measurements = [
f"{b}_pc_{p}" for b, p in product(["pv", "bs", "npv"], ["10", "50", "90"])
]
diff --git a/odc/stats/plugins/gm.py b/odc/stats/plugins/gm.py
index 301eae80..f12ce734 100644
--- a/odc/stats/plugins/gm.py
+++ b/odc/stats/plugins/gm.py
@@ -2,7 +2,7 @@
Geomedian
"""
-from typing import Optional, Union, Tuple, Iterable, Dict
+from collections.abc import Iterable
import xarray as xr
from odc.algo import geomedian_with_mads
from ._registry import StatsPluginInterface, register
@@ -21,16 +21,15 @@ class StatsGM(StatsPluginInterface):
def __init__(
self,
- bands: Tuple[str, ...],
+ bands: tuple[str, ...],
mask_band: str,
- contiguity_band: Optional[str] = None,
- nodata_classes: Optional[Tuple[str, ...]] = None,
- cloud_filters: Dict[
- Union[str, Tuple[str, ...]], Iterable[Tuple[str, int]]
- ] = None,
+ *,
+ contiguity_band: str | None = None,
+ nodata_classes: tuple[str, ...] | None = None,
+ cloud_filters: dict[str | tuple[str, ...], Iterable[tuple[str, int]]] = None,
basis_band=None,
- aux_names: Dict[str, str] = None,
- work_chunks: Tuple[int, int] = (400, 400),
+ aux_names: dict[str, str] = None,
+ work_chunks: tuple[int, int] = (400, 400),
**kwargs,
):
aux_names = (
@@ -71,7 +70,7 @@ def __init__(
self._work_chunks = work_chunks
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
return self.bands + self.aux_bands
def native_transform(self, xx: xr.Dataset) -> xr.Dataset:
@@ -137,13 +136,12 @@ class StatsGMS2(StatsGM):
def __init__(
self,
- bands: Optional[Tuple[str, ...]] = None,
+ *,
+ bands: tuple[str, ...] | None = None,
mask_band: str = "SCL",
- nodata_classes: Optional[Tuple[str, ...]] = ("no data",),
- cloud_filters: Dict[
- Union[str, Tuple[str, ...]], Iterable[Tuple[str, int]]
- ] = None,
- aux_names: Dict[str, str] = None,
+ nodata_classes: tuple[str, ...] | None = ("no data",),
+ cloud_filters: dict[str | tuple[str, ...], Iterable[tuple[str, int]]] = None,
+ aux_names: dict[str, str] = None,
rgb_bands=None,
**kwargs,
):
@@ -204,14 +202,13 @@ class StatsGMLS(StatsGM):
def __init__(
self,
- bands: Optional[Tuple[str, ...]] = None,
+ *,
+ bands: tuple[str, ...] | None = None,
mask_band: str = "fmask",
contiguity_band: str = "nbart_contiguity",
- nodata_classes: Optional[Tuple[str, ...]] = ("nodata",),
- cloud_filters: Dict[
- Union[str, Tuple[str, ...]], Iterable[Tuple[str, int]]
- ] = None,
- aux_names: Dict[str, str] = None,
+ nodata_classes: tuple[str, ...] | None = ("nodata",),
+ cloud_filters: dict[str | tuple[str, ...], Iterable[tuple[str, int]]] = None,
+ aux_names: dict[str, str] = None,
rgb_bands=None,
**kwargs,
):
@@ -256,7 +253,7 @@ def __init__(
)
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
return (
tuple(b for b in self.bands if b != self._contiguity_band) + self.aux_bands
)
diff --git a/odc/stats/plugins/gm_ls_bitmask.py b/odc/stats/plugins/gm_ls_bitmask.py
index 8577ca3c..5451dad8 100644
--- a/odc/stats/plugins/gm_ls_bitmask.py
+++ b/odc/stats/plugins/gm_ls_bitmask.py
@@ -3,7 +3,8 @@
"""
from functools import partial
-from typing import Iterable, Optional, Sequence, Tuple, Dict, Any
+from typing import Any
+from collections.abc import Iterable, Sequence
import xarray as xr
import numpy as np
@@ -20,16 +21,17 @@ class StatsGMLSBitmask(StatsPluginInterface):
def __init__( # pylint:disable=too-many-arguments
self,
- bands: Optional[Sequence[str]] = None,
+ *,
+ bands: Sequence[str] | None = None,
mask_band: str = "QA_PIXEL",
# provide flags with high cloud bits definition
- flags: Dict[str, Optional[Any]] = None,
- nodata_flags: Dict[str, Optional[Any]] = None,
- filters: Optional[
- Iterable[Tuple[str, int]]
- ] = None, # e.g. [("closing", 10),("opening", 2),("dilation", 2)]
+ flags: dict[str, Any | None] = None,
+ nodata_flags: dict[str, Any | None] = None,
+ filters: None | (
+ Iterable[tuple[str, int]]
+ ) = None, # e.g. [("closing", 10),("opening", 2),("dilation", 2)]
aux_names=None,
- work_chunks: Tuple[int, int] = (400, 400),
+ work_chunks: tuple[int, int] = (400, 400),
scale: float = 0.0000275,
offset: float = -0.2,
output_scale: int = 10000, # gm rescaling - making SR range match sentinel-2 gm
@@ -37,14 +39,16 @@ def __init__( # pylint:disable=too-many-arguments
**kwargs,
):
if aux_names is None:
- aux_names = dict(smad="smad", emad="emad", bcmad="bcmad", count="count")
+ aux_names = {
+ "smad": "smad",
+ "emad": "emad",
+ "bcmad": "bcmad",
+ "count": "count",
+ }
if nodata_flags is None:
- nodata_flags = dict(nodata=False)
+ nodata_flags = {"nodata": False}
if flags is None:
- flags = dict(
- cloud="high_confidence",
- cirrus="high_confidence",
- )
+ flags = {"cloud": "high_confidence", "cirrus": "high_confidence"}
if bands is None:
self.bands = (
"red",
@@ -71,7 +75,7 @@ def __init__( # pylint:disable=too-many-arguments
self.output_nodata = 0
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
return self.bands + self.aux_bands
def native_transform(self, xx):
@@ -133,17 +137,17 @@ def native_transform(self, xx):
def reduce(self, xx: xr.Dataset) -> xr.Dataset:
cloud_mask = xx["cloud_mask"]
- cfg = dict(
- maxiters=1000,
- num_threads=1,
- scale=self.scale,
- offset=self.offset,
- reshape_strategy="mem",
- out_chunks=(-1, -1, -1),
- work_chunks=self.work_chunks,
- compute_count=True,
- compute_mads=True,
- )
+ cfg = {
+ "maxiters": 1000,
+ "num_threads": 1,
+ "scale": self.scale,
+ "offset": self.offset,
+ "reshape_strategy": "mem",
+ "out_chunks": (-1, -1, -1),
+ "work_chunks": self.work_chunks,
+ "compute_count": True,
+ "compute_mads": True,
+ }
if self.filters is not None:
cloud_mask = mask_cleanup(xx["cloud_mask"], mask_filters=self.filters)
diff --git a/odc/stats/plugins/lc_fc_wo_a0.py b/odc/stats/plugins/lc_fc_wo_a0.py
index 230d064d..c30f3418 100644
--- a/odc/stats/plugins/lc_fc_wo_a0.py
+++ b/odc/stats/plugins/lc_fc_wo_a0.py
@@ -3,7 +3,7 @@
"""
from functools import partial
-from typing import Tuple, Dict, Iterable, Optional
+from collections.abc import Iterable
import numpy as np
import xarray as xr
@@ -16,7 +16,8 @@
to_float,
_nodata_fuser,
)
-from odc.stats._algebra import expr_eval, median_ds
+from odc.stats._algebra import median_ds
+from odc.algo import expr_eval
from ._registry import StatsPluginInterface, register
@@ -33,9 +34,9 @@ class StatsVegCount(StatsPluginInterface):
def __init__(
self,
- ue_threshold: Optional[int] = None,
- veg_threshold: Optional[int] = None,
- cloud_filters: Dict[str, Iterable[Tuple[str, int]]] = None,
+ ue_threshold: int | None = None,
+ veg_threshold: int | None = None,
+ cloud_filters: dict[str, Iterable[tuple[str, int]]] = None,
**kwargs,
):
super().__init__(input_bands=["water", "pv", "bs", "npv", "ue"], **kwargs)
@@ -136,7 +137,6 @@ def native_transform(self, xx):
return xx
def fuser(self, xx):
-
wet_clear = xx["wet_clear"]
wet_valid = xx["wet_valid"]
@@ -306,7 +306,6 @@ def _max_consecutive_months(self, data, nodata, normalize=False):
return max_count
def reduce(self, xx: xr.Dataset) -> xr.Dataset:
-
xx = xx.groupby("time.month").map(median_ds, dim="spec")
# consecutive observation of veg
@@ -348,7 +347,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
self.measurements, [max_count_veg, max_count_water, wet_percent]
)
}
- coords = dict((dim, xx.coords[dim]) for dim in xx["pv"].dims[1:])
+ coords = {dim: xx.coords[dim] for dim in xx["pv"].dims[1:]}
return xr.Dataset(data_vars=data_vars, coords=coords, attrs=xx.attrs)
diff --git a/odc/stats/plugins/lc_level34.py b/odc/stats/plugins/lc_level34.py
index 905f21a1..4e9dc187 100644
--- a/odc/stats/plugins/lc_level34.py
+++ b/odc/stats/plugins/lc_level34.py
@@ -2,8 +2,6 @@
Plugin of Module A3 in LandCover PipeLine
"""
-from typing import Optional, Dict, List
-
import xarray as xr
import s3fs
import os
@@ -13,7 +11,7 @@
from ._registry import StatsPluginInterface, register
from ._utils import rasterize_vector_mask, generate_numexpr_expressions
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from osgeo import gdal
NODATA = 255
@@ -28,12 +26,13 @@ class StatsLccsLevel4(StatsPluginInterface):
def __init__(
self,
+ *,
class_def_path: str = None,
- class_condition: Dict[str, List] = None,
+ class_condition: dict[str, list] = None,
urban_mask: str = None,
filter_expression: str = None,
- mask_threshold: Optional[float] = None,
- data_var_condition: Optional[Dict] = None,
+ mask_threshold: float | None = None,
+ data_var_condition: dict | None = None,
**kwargs,
):
super().__init__(**kwargs)
@@ -129,7 +128,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
# 215 -> 216 if urban_mask == 0
urban_mask = rasterize_vector_mask(
self.urban_mask,
- xx.geobox.transform,
+ xx.odc.geobox.transform,
xx.artificial_surface.shape,
filter_expression=self.filter_expression,
threshold=self.mask_threshold,
@@ -147,7 +146,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
attrs = xx.attrs.copy()
attrs["nodata"] = NODATA
dims = xx.level_3_4.dims[1:]
- coords = dict((dim, xx.coords[dim]) for dim in dims)
+ coords = {dim: xx.coords[dim] for dim in dims}
xx["level3"] = xr.DataArray(
level3.squeeze(), dims=dims, attrs=attrs, coords=coords
)
diff --git a/odc/stats/plugins/lc_ml_treelite.py b/odc/stats/plugins/lc_ml_treelite.py
index 7f2b6a06..2f2203c3 100644
--- a/odc/stats/plugins/lc_ml_treelite.py
+++ b/odc/stats/plugins/lc_ml_treelite.py
@@ -3,7 +3,7 @@
"""
from abc import abstractmethod
-from typing import Dict, Sequence, Optional
+from collections.abc import Sequence
import os
import sys
@@ -14,11 +14,11 @@
from dask.distributed import get_worker
from datacube.model import Dataset
-from datacube.utils.geometry import GeoBox
+from odc.geo.geobox import GeoBox
from odc.algo._memsink import yxbt_sink, yxt_sink
-from odc.algo.io import load_with_native_transform
+from odc.stats.io import load_with_native_transform
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from odc.stats.model import DateTimeRange
from ._registry import StatsPluginInterface
from ._worker import TreeliteModelPlugin
@@ -64,10 +64,10 @@ class StatsMLTree(StatsPluginInterface):
def __init__(
self,
- output_classes: Dict,
+ output_classes: dict,
model_path: str,
- mask_bands: Optional[Dict] = None,
- temporal_coverage: Optional[Dict] = None,
+ mask_bands: dict | None = None,
+ temporal_coverage: dict | None = None,
**kwargs,
):
super().__init__(**kwargs)
@@ -122,7 +122,7 @@ def input_data(
name=ds.type.name + "_yxt",
).squeeze("spec")
- coords = dict((dim, input_array.coords[dim]) for dim in input_array.dims)
+ coords = {dim: input_array.coords[dim] for dim in input_array.dims}
return xr.Dataset(data_vars=data_vars, coords=coords)
def impute_missing_values(self, xx: xr.Dataset, image):
diff --git a/odc/stats/plugins/lc_tf_urban.py b/odc/stats/plugins/lc_tf_urban.py
index d899ee40..fae6ba67 100644
--- a/odc/stats/plugins/lc_tf_urban.py
+++ b/odc/stats/plugins/lc_tf_urban.py
@@ -2,7 +2,7 @@
Plugin of TF urban model in LandCover PipeLine
"""
-from typing import Dict, Sequence
+from collections.abc import Sequence
import os
import numpy as np
@@ -12,11 +12,11 @@
from dask.distributed import get_worker
from datacube.model import Dataset
-from datacube.utils.geometry import GeoBox
+from odc.geo.geobox import GeoBox
from odc.algo._memsink import yxbt_sink
-from odc.algo.io import load_with_native_transform
+from odc.stats.io import load_with_native_transform
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from ._registry import StatsPluginInterface, register
from ._worker import TensorFlowLiteModelPlugin
@@ -76,7 +76,7 @@ class StatsUrbanClass(StatsPluginInterface):
def __init__(
self,
- output_classes: Dict,
+ output_classes: dict,
model_path: str,
crop_size=None,
**kwargs,
@@ -118,7 +118,7 @@ def input_data(
).squeeze("spec", drop=True)
data_vars[ds.type.name] = input_array
- coords = dict((dim, input_array.coords[dim]) for dim in input_array.dims)
+ coords = {dim: input_array.coords[dim] for dim in input_array.dims}
return xr.Dataset(data_vars=data_vars, coords=coords)
def urban_class(self, input_array):
diff --git a/odc/stats/plugins/lc_treelite_cultivated.py b/odc/stats/plugins/lc_treelite_cultivated.py
index 096b9e24..ff91b23d 100644
--- a/odc/stats/plugins/lc_treelite_cultivated.py
+++ b/odc/stats/plugins/lc_treelite_cultivated.py
@@ -7,7 +7,7 @@
import dask.array as da
import numexpr as ne
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from ._registry import register
from .lc_ml_treelite import StatsMLTree, mask_and_predict
@@ -53,6 +53,7 @@ def feature_BSI(input_block, nbart_swir_1, nbart_red, nbart_nir, nbart_blue):
).astype("float32")
+# pylint: disable=too-many-positional-arguments
def feature_TCW(
input_block,
nbart_blue,
diff --git a/odc/stats/plugins/lc_treelite_woody.py b/odc/stats/plugins/lc_treelite_woody.py
index 949e7743..78d5e3e0 100644
--- a/odc/stats/plugins/lc_treelite_woody.py
+++ b/odc/stats/plugins/lc_treelite_woody.py
@@ -5,7 +5,7 @@
import xarray as xr
import dask.array as da
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from ._registry import register
from .lc_ml_treelite import StatsMLTree, mask_and_predict
diff --git a/odc/stats/plugins/lc_veg_class_a1.py b/odc/stats/plugins/lc_veg_class_a1.py
index a0928b43..48801e53 100644
--- a/odc/stats/plugins/lc_veg_class_a1.py
+++ b/odc/stats/plugins/lc_veg_class_a1.py
@@ -2,11 +2,9 @@
Plugin of Module A1 in LandCover PipeLine
"""
-from typing import Optional, Dict
-
import numpy as np
import xarray as xr
-from odc.stats._algebra import expr_eval
+from odc.algo import expr_eval
from ._registry import StatsPluginInterface, register
from ._utils import replace_nodata_with_mode
@@ -52,12 +50,13 @@ class StatsVegClassL1(StatsPluginInterface):
def __init__(
self,
- output_classes: Dict,
- dem_threshold: Optional[int] = None,
- mudflat_threshold: Optional[int] = None,
- saltpan_threshold: Optional[int] = None,
- water_threshold: Optional[float] = None,
- veg_threshold: Optional[int] = None,
+ *,
+ output_classes: dict,
+ dem_threshold: int | None = None,
+ mudflat_threshold: int | None = None,
+ saltpan_threshold: int | None = None,
+ water_threshold: float | None = None,
+ veg_threshold: int | None = None,
**kwargs,
):
super().__init__(**kwargs)
@@ -232,7 +231,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
k: xr.DataArray(v, dims=xx["veg_frequency"].dims[1:], attrs=attrs)
for k, v in zip(self.measurements, [l3_mask])
}
- coords = dict((dim, xx.coords[dim]) for dim in xx["veg_frequency"].dims[1:])
+ coords = {dim: xx.coords[dim] for dim in xx["veg_frequency"].dims[1:]}
return xr.Dataset(data_vars=data_vars, coords=coords, attrs=xx.attrs)
diff --git a/odc/stats/plugins/ls_ndvi_median.py b/odc/stats/plugins/ls_ndvi_median.py
new file mode 100644
index 00000000..9ffd613b
--- /dev/null
+++ b/odc/stats/plugins/ls_ndvi_median.py
@@ -0,0 +1,104 @@
+"""
+Simple odc-stats plugin example, with excessive
+documentation. Creates temporal median NDVI
+from DEA Landsat Collection 3
+
+"""
+
+import xarray as xr
+from typing import Sequence, Tuple
+from datacube.utils.masking import mask_invalid_data
+from odc.stats.plugins._registry import register, StatsPluginInterface
+from odc.algo._masking import erase_bad, enum_to_bool
+
+
+class StatsNDVI(StatsPluginInterface):
+ """
+ Define a class for summarising time
+ series of NDVI using the median.
+ """
+
+ NAME = "ndvi_median"
+ SHORT_NAME = NAME
+ VERSION = "1.0"
+ PRODUCT_FAMILY = "ndvi"
+
+ def __init__(
+ self,
+ input_bands: Sequence[str] = None,
+ output_bands: Sequence[str] = None,
+ mask_band: Sequence[str] = None,
+ contiguity_band: Sequence[str] = None,
+ group_by: str = "solar_day",
+ **kwargs,
+ ):
+
+ self.input_bands = input_bands
+ self.output_bands = output_bands
+ self.mask_band = mask_band
+ self.contiguity_band = contiguity_band
+ self.group_by = group_by
+
+ # These params get passed to the upstream
+ # base StatsPluginInterface class
+ super().__init__(
+ input_bands=tuple(input_bands) + (mask_band,) + (contiguity_band,), **kwargs
+ )
+
+ @property
+ def measurements(self) -> Tuple[str, ...]:
+ """
+ Here we define the output bands, in this example we
+ will pass the names of the output bands into the config file,
+ but equally we could define the outputs ames within this function.
+ For example, by adding a suffix to the input bands.
+ """
+
+ return (self.output_bands,)
+
+ def native_transform(self, xx):
+ """
+ This function is passed to an upstream function
+ called "odc.algo.io.load_with_native_transform".
+ The function decribed here is applied on every time
+ step of data and is usually used for things like
+ masking clouds, nodata, and contiguity masking.
+ """
+ # grab the QA band from the Landsat data
+ mask = xx[self.mask_band]
+
+ # create boolean arrays from the mask for cloud
+ # and cloud shadows, and nodata
+ bad = enum_to_bool(mask, ("nodata",))
+ non_contiguent = xx.get(self.contiguity_band, 1) == 0
+ bad = bad | non_contiguent
+
+ cloud_mask = enum_to_bool(mask, ("cloud", "shadow"))
+ bad = cloud_mask | bad
+
+ # drop masking bands
+ xx = xx.drop_vars([self.mask_band] + [self.contiguity_band])
+
+ # Mask the bad data (clouds etc)
+ xx = erase_bad(xx, bad)
+
+ return xx
+
+ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
+ """
+ Calculate NDVI and summarise time series with a median.
+ """
+ # convert to float by and convert nodata to NaN
+ xx = mask_invalid_data(xx)
+
+ ndvi = (xx["nbart_nir"] - xx["nbart_red"]) / (xx["nbart_nir"] + xx["nbart_red"])
+
+ # calculate temporal median NDVI. Note that we use
+ # 'spec' and not 'time', this is an odc-stats thing
+ ndvi = ndvi.median("spec").rename(self.output_bands)
+
+ return ndvi.to_dataset()
+
+
+# now lets 'register' the function with odc-stats
+register("ndvi-median", StatsNDVI)
diff --git a/odc/stats/plugins/mangroves.py b/odc/stats/plugins/mangroves.py
index c509c27d..ef05eaea 100644
--- a/odc/stats/plugins/mangroves.py
+++ b/odc/stats/plugins/mangroves.py
@@ -2,8 +2,6 @@
Mangroves canopy cover classes
"""
-from typing import Tuple
-
import numpy as np
import xarray as xr
import dask
@@ -40,7 +38,7 @@ def __init__(
super().__init__(input_bands=["pv_pc_10", "qa", "wet_pc_10"], **kwargs)
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
_measurements = ["canopy_cover_class"]
return _measurements
@@ -57,7 +55,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
it is not a 'reduce' though
"""
extent_mask = rasterize_vector_mask(
- self.mangroves_extent, xx.geobox.transform, xx.pv_pc_10.shape
+ self.mangroves_extent, xx.odc.geobox.transform, xx.pv_pc_10.shape
)
good_data = extent_mask == 1
good_data &= xx.wet_pc_10 > self.tcw_threshold
diff --git a/odc/stats/plugins/pq.py b/odc/stats/plugins/pq.py
index da85fb05..4303fae4 100644
--- a/odc/stats/plugins/pq.py
+++ b/odc/stats/plugins/pq.py
@@ -2,7 +2,8 @@
Sentinel 2 pixel quality stats
"""
-from typing import Dict, Iterable, Optional, Tuple, cast
+from typing import cast
+from collections.abc import Iterable
import xarray as xr
from odc.algo import enum_to_bool, mask_cleanup
@@ -33,9 +34,9 @@ class StatsPQ(StatsPluginInterface):
def __init__(
self,
- filters: Optional[Dict[str, Iterable[Tuple[str, int]]]] = None,
+ filters: dict[str, Iterable[tuple[str, int]]] | None = None,
resampling: str = "nearest",
- **kwargs
+ **kwargs,
):
super().__init__(input_bands=["SCL"], resampling=resampling, **kwargs)
if filters is None:
@@ -43,7 +44,7 @@ def __init__(
self.filters = filters
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
measurements = ["total", "clear", *list(self.filters)]
return tuple(measurements)
@@ -83,7 +84,7 @@ def native_transform(self, xx: xr.Dataset) -> xr.Dataset:
valid = scl != scl.nodata
erased = enum_to_bool(scl, cloud_classes)
return xr.Dataset(
- dict(valid=valid, erased=erased),
+ {"valid": valid, "erased": erased},
attrs={"native": True}, # <- native flag needed for fuser
)
@@ -96,7 +97,7 @@ def reduce(self, xx: xr.Dataset) -> xr.Dataset:
valid = xx.valid
erased_bands = [str(n) for n in xx.data_vars if str(n).startswith("erased")]
total = valid.sum(axis=0, dtype="uint16")
- pq = xr.Dataset(dict(total=total))
+ pq = xr.Dataset({"total": total})
for band in erased_bands:
erased: xr.DataArray = cast(xr.DataArray, xx[band])
diff --git a/odc/stats/plugins/pq_bitmask.py b/odc/stats/plugins/pq_bitmask.py
index b408bf96..330bfad5 100644
--- a/odc/stats/plugins/pq_bitmask.py
+++ b/odc/stats/plugins/pq_bitmask.py
@@ -34,7 +34,7 @@
"""
from functools import partial
-from typing import Dict, Optional, Tuple, Iterable
+from collections.abc import Iterable
import dask.array as da
import xarray as xr
@@ -54,23 +54,21 @@ class StatsPQLSBitmask(StatsPluginInterface):
def __init__(
self,
+ *,
pq_band: str = "QA_PIXEL",
- aerosol_band: Optional[str] = None,
+ aerosol_band: str | None = None,
# provide flags with high cloud bits definition
flags=None,
nodata_flags=None,
- filters: Optional[Dict[str, Iterable[Tuple[str, int]]]] = None,
- aerosol_filters: Optional[Dict[str, Iterable[Tuple[str, int]]]] = None,
+ filters: dict[str, Iterable[tuple[str, int]]] | None = None,
+ aerosol_filters: dict[str, Iterable[tuple[str, int]]] | None = None,
resampling: str = "nearest",
**kwargs,
):
if nodata_flags is None:
- nodata_flags = dict(nodata=False)
+ nodata_flags = {"nodata": False}
if flags is None:
- flags = dict(
- cloud="high_confidence",
- cirrus="high_confidence",
- )
+ flags = {"cloud": "high_confidence", "cirrus": "high_confidence"}
self.pq_band = pq_band
self.aerosol_band = aerosol_band
input_bands = [self.pq_band]
@@ -83,7 +81,7 @@ def __init__(
self.aerosol_filters = aerosol_filters or {}
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
"""
Output product measurements
"""
diff --git a/odc/stats/plugins/tcw_percentiles.py b/odc/stats/plugins/tcw_percentiles.py
index c635b919..ae35511d 100644
--- a/odc/stats/plugins/tcw_percentiles.py
+++ b/odc/stats/plugins/tcw_percentiles.py
@@ -3,7 +3,7 @@
"""
from functools import partial
-from typing import Sequence, Tuple, Iterable, Dict
+from collections.abc import Sequence, Iterable
import xarray as xr
import numpy as np
import logging
@@ -29,10 +29,10 @@ class StatsTCWPC(StatsPluginInterface):
def __init__(
self,
- coefficients: Dict[str, Dict[str, float]] = None,
+ coefficients: dict[str, dict[str, float]] = None,
input_bands: Sequence[str] = None,
output_bands: Sequence[str] = None,
- cloud_filters: Dict[str, Iterable[Tuple[str, int]]] = None,
+ cloud_filters: dict[str, Iterable[tuple[str, int]]] = None,
**kwargs,
):
self.cloud_filters = cloud_filters
@@ -101,7 +101,7 @@ def __init__(
)
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
_measurments = []
for band in self.output_bands:
_measurments += [f"{band}_pc_10", f"{band}_pc_50", f"{band}_pc_90"]
diff --git a/odc/stats/plugins/wofs.py b/odc/stats/plugins/wofs.py
index bd552b8d..4753bc76 100644
--- a/odc/stats/plugins/wofs.py
+++ b/odc/stats/plugins/wofs.py
@@ -17,7 +17,7 @@
"""
-from typing import Dict, Tuple, Iterable
+from collections.abc import Iterable
import numpy as np
import xarray as xr
from odc.algo import safe_div, apply_numexpr, keep_good_only
@@ -53,13 +53,13 @@ class StatsWofs(StatsPluginInterface):
} # Cloud/Shadow + Terrain Shadow
def __init__(
- self, cloud_filters: Dict[str, Iterable[Tuple[str, int]]] = None, **kwargs
+ self, cloud_filters: dict[str, Iterable[tuple[str, int]]] = None, **kwargs
):
super().__init__(input_bands=["water"], **kwargs)
self.cloud_filters = cloud_filters if cloud_filters is not None else {}
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
return "count_wet", "count_clear", "frequency"
def native_transform(self, xx):
@@ -176,7 +176,7 @@ def __init__(self, **kwargs):
super().__init__(input_bands=["count_wet", "count_clear"])
@property
- def measurements(self) -> Tuple[str, ...]:
+ def measurements(self) -> tuple[str, ...]:
return "count_wet", "count_clear", "frequency"
def fuser(self, xx):
diff --git a/odc/stats/proc.py b/odc/stats/proc.py
index deceb182..14509c84 100644
--- a/odc/stats/proc.py
+++ b/odc/stats/proc.py
@@ -1,15 +1,8 @@
import logging
-from typing import (
- Iterable,
- Iterator,
- Optional,
- List,
- Any,
- Tuple,
- Union,
-)
+from typing import Any
+from collections.abc import Iterable, Iterator
from dask.distributed import Client, WorkerPlugin
-from datetime import datetime
+from datetime import datetime, timezone
import xarray as xr
import math
import psutil
@@ -41,8 +34,8 @@ class TaskRunner:
def __init__(
self,
cfg: TaskRunnerConfig,
- resolution: Optional[Tuple[float, float]] = None,
- from_sqs: Optional[str] = "",
+ resolution: tuple[float, float] | None = None,
+ from_sqs: str | None = "",
):
""" """
_log = logging.getLogger(__name__)
@@ -91,7 +84,7 @@ def _init_dask(self) -> Client:
if nthreads <= 0:
nthreads = get_max_cpu()
- memory_limit: Union[str, int] = cfg.memory_limit
+ memory_limit: str | int = cfg.memory_limit
if memory_limit == "":
mem_1g = 1 << 30
memory_limit = get_max_mem()
@@ -137,8 +130,8 @@ def verify_setup(self) -> bool:
# pylint: disable=import-outside-toplevel
def tasks(
self,
- tasks: List[str],
- ds_filters: Optional[str] = None,
+ tasks: list[str],
+ ds_filters: str | None = None,
) -> Iterator[Task]:
from ._cli_common import parse_all_tasks
@@ -153,9 +146,9 @@ def tasks(
# pylint: enable=import-outside-toplevel
def dry_run(
self,
- tasks: List[str],
+ tasks: list[str],
check_exists: bool = True,
- ds_filters: Optional[str] = None,
+ ds_filters: str | None = None,
) -> Iterator[TaskResult]:
sink = self.sink
overwrite = self._cfg.overwrite
@@ -176,7 +169,7 @@ def dry_run(
skipped = (overwrite is False) and (exists is True)
nds = len(task.datasets)
# TODO: take care of utc offset for day boundaries when computing ndays
- ndays = len(set(ds.center_time.date() for ds in task.datasets))
+ ndays = len({ds.center_time.date() for ds in task.datasets})
flag = flag_mapping.get(exists, "")
msg = f"{task.location} days={ndays:03} ds={nds:04} {uri}{flag}"
@@ -221,7 +214,7 @@ def _run(self, tasks: Iterable[Task], apply_eodatasets3) -> Iterator[TaskResult]
if tk is not None:
t0 = tk.start_time
else:
- t0 = datetime.utcnow()
+ t0 = datetime.now(timezone.utc)
if not cfg.overwrite:
path = sink.uri(task)
_log.debug("Checking if can skip %s", path)
@@ -241,13 +234,14 @@ def _run(self, tasks: Iterable[Task], apply_eodatasets3) -> Iterator[TaskResult]
task.geobox,
transform_code=proc.transform_code,
area_of_interest=proc.area_of_interest,
+ **{"XSCALE": None, "YSCALE": None},
)
)
_log.debug("Submitting to Dask (%s)", task.location)
ds = client.persist(ds, fifo_timeout="1ms")
- aux: Optional[xr.Dataset] = None
+ aux: xr.Dataset | None = None
# if no rgba setting in cog_ops:overrides, no rgba tif as ouput
if "overrides" in cfg.cog_opts and "rgba" in cfg.cog_opts["overrides"]:
@@ -297,10 +291,10 @@ def _run(self, tasks: Iterable[Task], apply_eodatasets3) -> Iterator[TaskResult]
# pylint: enable=too-many-locals, too-many-branches, too-many-statements
def run(
self,
- tasks: Optional[List[str]] = None,
- sqs: Optional[str] = None,
- ds_filters: Optional[str] = None,
- apply_eodatasets3: Optional[bool] = False,
+ tasks: list[str] | None = None,
+ sqs: str | None = None,
+ ds_filters: str | None = None,
+ apply_eodatasets3: bool | None = False,
) -> Iterator[TaskResult]:
cfg = self._cfg
_log = self._log
@@ -354,7 +348,7 @@ def get_max_cpu() -> int:
return psutil.cpu_count()
-def get_cpu_quota() -> Optional[float]:
+def get_cpu_quota() -> float | None:
"""
:returns: ``None`` if unconstrained or there is an error
:returns: maximum amount of CPU this pod is allowed to use
@@ -368,7 +362,7 @@ def get_cpu_quota() -> Optional[float]:
return quota / period
-def get_mem_quota() -> Optional[int]:
+def get_mem_quota() -> int | None:
"""
:returns: ``None`` if there was some error
:returns: maximum RAM, in bytes, this pod can use according to Linux cgroups
diff --git a/odc/stats/tasks.py b/odc/stats/tasks.py
index 534ad54c..ebce4f8e 100644
--- a/odc/stats/tasks.py
+++ b/odc/stats/tasks.py
@@ -1,5 +1,6 @@
import random
-from typing import Optional, Tuple, Union, Callable, Any, Dict, List, Iterable, Iterator
+from typing import Any
+from collections.abc import Callable, Iterable, Iterator
from types import SimpleNamespace
from collections import namedtuple
from datetime import datetime
@@ -18,8 +19,9 @@
from odc.dscache import DatasetCache
from datacube import Datacube
-from datacube.model import Dataset, GridSpec
-from datacube.utils.geometry import Geometry
+from datacube.model import Dataset
+from odc.geo import Geometry
+from odc.geo.gridspec import GridSpec
from datacube.utils.documents import transform_object_tree
from datacube.utils.dates import normalise_dt
@@ -43,7 +45,7 @@
)
from ._stac_fetch import s3_fetch_dss
-TilesRange2d = Tuple[Tuple[int, int], Tuple[int, int]]
+TilesRange2d = tuple[tuple[int, int], tuple[int, int]]
CompressedDataset = namedtuple("CompressedDataset", ["id", "time"])
_log = logging.getLogger(__name__)
@@ -57,7 +59,7 @@ def compress_ds(ds: Dataset) -> CompressedDataset:
return CompressedDataset(ds.id, dt)
-def is_tile_in(tidx: Tuple[int, int], tiles: TilesRange2d) -> bool:
+def is_tile_in(tidx: tuple[int, int], tiles: TilesRange2d) -> bool:
(x0, x1), (y0, y1) = tiles
x, y = tidx
return (x0 <= x < x1) and (y0 <= y < y1)
@@ -93,7 +95,7 @@ def parse_task(s: str) -> TileIdx_txy:
return (t, int(x.lstrip("x")), int(y.lstrip("y")))
-def render_sqs(tidx: TileIdx_txy, filedb: str) -> Dict[str, str]:
+def render_sqs(tidx: TileIdx_txy, filedb: str) -> dict[str, str]:
"""
Add extra layer to render task. Convert it to JSON for SQS message body.
"""
@@ -101,7 +103,7 @@ def render_sqs(tidx: TileIdx_txy, filedb: str) -> Dict[str, str]:
return {"filedb": filedb, "tile_idx": f"{period}/{xi:02d}/{yi:02d}"}
-def parse_sqs(s: str) -> Tuple[TileIdx_txy, str]:
+def parse_sqs(s: str) -> tuple[TileIdx_txy, str]:
"""
Add extra layer to parse task. Convert it from JSON for SQS message body.
"""
@@ -158,6 +160,7 @@ def __init__(
self,
output: str,
grid: str,
+ *,
frequency: str = "annual",
overwrite: bool = False,
complevel: int = 6,
@@ -182,8 +185,9 @@ def ds_align(
cls,
dss: Iterable,
group_size: int,
- dss_extra: Optional[Iterable] = None,
- optional_products: Optional[Iterable] = None,
+ *,
+ dss_extra: Iterable | None = None,
+ optional_products: Iterable | None = None,
fuse_dss: bool = True,
):
def pack_dss(grouped_dss, group_size):
@@ -281,13 +285,14 @@ def _find_dss(
cls,
dc: Datacube,
products: str,
- query: Dict[str, Any],
- cfg: Dict[str, Any],
+ query: dict[str, Any],
+ cfg: dict[str, Any],
+ *,
dataset_filter=None,
predicate=None,
fuse_dss: bool = True,
- ignore_time: Optional[Iterable] = None,
- optional_products: Optional[Iterable] = None,
+ ignore_time: Iterable | None = None,
+ optional_products: Iterable | None = None,
):
"""
query and filter the datasets with a string composed by products name
@@ -326,7 +331,7 @@ def _find_dss(
query.update({"product": indexed_products, **dataset_filter})
dss = ordered_dss(
dc,
- freq="y",
+ freq="Y",
key=lambda ds: (
(ds.center_time, ds.metadata.region_code)
if hasattr(ds.metadata, "region_code")
@@ -340,7 +345,7 @@ def _find_dss(
query.update({"product": list(ignore_time), "time": ("1970", "2038")})
dss_extra = ordered_dss(
dc,
- freq="y",
+ freq="Y",
key=lambda ds: (
(ds.center_time, ds.metadata.region_code)
if hasattr(ds.metadata, "region_code")
@@ -368,7 +373,11 @@ def _find_dss(
if group_size > 0:
dss = cls.ds_align(
- dss, group_size + 1, dss_extra, optional_products, fuse_dss
+ dss,
+ group_size + 1,
+ dss_extra=dss_extra,
+ optional_products=optional_products,
+ fuse_dss=fuse_dss,
)
if predicate is not None:
@@ -379,12 +388,11 @@ def _find_dss(
@classmethod
def create_dss_by_stac(
cls,
- s3_path: List[str],
+ s3_path: list[str],
pattern: str = "*.stac-item.json",
tiles=None,
temporal_range=None,
):
-
if tiles is not None:
glob_path = [
"x" + str(x) + "/" + "y" + str(y) + "/" + "*"
@@ -428,12 +436,13 @@ def get_dss_by_grid(
dc: Datacube,
products: str,
msg: Callable[[str], Any],
+ *,
dataset_filter=None,
predicate=None,
- temporal_range: Optional[DateTimeRange] = None,
- tiles: Optional[TilesRange2d] = None,
- ignore_time: Optional[Iterable] = None,
- optional_products: Optional[Iterable] = None,
+ temporal_range: DateTimeRange | None = None,
+ tiles: TilesRange2d | None = None,
+ ignore_time: Iterable | None = None,
+ optional_products: Iterable | None = None,
):
"""
This returns a tuple containing:
@@ -443,7 +452,7 @@ def get_dss_by_grid(
"""
# pylint:disable=too-many-locals
- cfg: Dict[str, Any] = {
+ cfg: dict[str, Any] = {
"grid": self._grid,
"freq": self._frequency,
}
@@ -468,8 +477,8 @@ def get_dss_by_grid(
products,
query,
cfg,
- dataset_filter,
- predicate,
+ dataset_filter=dataset_filter,
+ predicate=predicate,
ignore_time=ignore_time,
optional_products=optional_products,
)
@@ -484,13 +493,14 @@ def save(
self,
dc: Datacube,
products: str,
+ *,
dataset_filter=None,
- temporal_range: Union[str, DateTimeRange, None] = None,
- tiles: Optional[TilesRange2d] = None,
- predicate: Optional[Callable[[Dataset], bool]] = None,
- ignore_time: Optional[Iterable] = None,
- optional_products: Optional[Iterable] = None,
- msg: Optional[Callable[[str], Any]] = None,
+ temporal_range: str | DateTimeRange | None = None,
+ tiles: TilesRange2d | None = None,
+ predicate: Callable[[Dataset], bool] | None = None,
+ ignore_time: Iterable | None = None,
+ optional_products: Iterable | None = None,
+ msg: Callable[[str], Any] | None = None,
debug: bool = False,
) -> bool:
"""
@@ -534,12 +544,12 @@ def msg_default(msg):
dc,
products,
msg,
- dataset_filter,
- predicate,
- temporal_range,
- tiles,
- ignore_time,
- optional_products,
+ dataset_filter=dataset_filter,
+ predicate=predicate,
+ temporal_range=temporal_range,
+ tiles=tiles,
+ ignore_time=ignore_time,
+ optional_products=optional_products,
)
dss_slice = list(islice(dss, 0, 100))
@@ -566,7 +576,7 @@ def msg_default(msg):
cache.add_grid(self._gridspec, self._grid)
cache.append_info_dict("stats/", {"config": cfg})
- cells: Dict[Tuple[int, int], Any] = {}
+ cells: dict[tuple[int, int], Any] = {}
dss = cache.tee(dss)
dss = bin_dataset_stream(self._gridspec, dss, cells, persist=persist)
@@ -648,25 +658,25 @@ def _write_info(self, tasks, msg, cells, debug):
# pylint:disable=too-many-locals
csv_path = self.out_path(".csv")
msg(f"Writing summary to {csv_path}")
- with open(csv_path, "wt", encoding="utf8") as f:
+ with open(csv_path, "w", encoding="utf8") as f:
f.write('"T","X","Y","datasets","days"\n')
for p, x, y in sorted(tasks):
dss = tasks[(p, x, y)]
n_dss = len(dss)
- n_days = len(set(ds.time.date() for ds in dss))
+ n_days = len({ds.time.date() for ds in dss})
line = f'"{p}", {x:+05d}, {y:+05d}, {n_dss:4d}, {n_days:4d}\n'
f.write(line)
msg("Dumping GeoJSON(s)")
grid_info = compute_grid_info(
- cells, resolution=max(self._gridspec.tile_size) / 4
+ cells, resolution=max(self._gridspec.tile_size.xy) / 4
)
tasks_geo = gjson_from_tasks(tasks, grid_info)
for temporal_range, gjson in tasks_geo.items():
fname = self.out_path(f"-{temporal_range}.geojson")
msg(f"..writing to {fname}")
- with open(fname, "wt", encoding="utf8") as f:
+ with open(fname, "w", encoding="utf8") as f:
json.dump(gjson, f)
if debug:
@@ -686,9 +696,9 @@ def _write_info(self, tasks, msg, cells, debug):
class TaskReader:
def __init__(
self,
- cache: Union[str, DatasetCache],
- product: Optional[OutputProduct] = None,
- resolution: Optional[Tuple[float, float]] = None,
+ cache: str | DatasetCache,
+ product: OutputProduct | None = None,
+ resolution: tuple[float, float] | None = None,
):
self._cache_path = None
self.s3_client = S3Client()
@@ -716,7 +726,7 @@ def __init__(
self._dscache = cache
self._cfg = cfg
- def is_compatible_resolution(self, resolution: Tuple[float, float], tol=1e-8):
+ def is_compatible_resolution(self, resolution: tuple[float, float], tol=1e-8):
for res, sz in zip(resolution, self._gridspec.tile_size):
res = abs(res)
npix = int(sz / res)
@@ -724,7 +734,7 @@ def is_compatible_resolution(self, resolution: Tuple[float, float], tol=1e-8):
return False
return True
- def change_resolution(self, resolution: Tuple[float, float]):
+ def change_resolution(self, resolution: tuple[float, float]):
"""
Modify GridSpec to have different pixel resolution but still covering same tiles as the original.
"""
@@ -783,7 +793,7 @@ def __repr__(self) -> str:
grid, path, n = self._grid, str(self._dscache.path), len(self._all_tiles)
return f"<{path}> grid:{grid} n:{n:,d}"
- def _resolve_product(self, product: Optional[OutputProduct]) -> OutputProduct:
+ def _resolve_product(self, product: OutputProduct | None) -> OutputProduct:
if product is None:
product = self._product
@@ -804,10 +814,10 @@ def product(self) -> OutputProduct:
return self._resolve_product(None)
@property
- def all_tiles(self) -> List[TileIdx_txy]:
+ def all_tiles(self) -> list[TileIdx_txy]:
return self._all_tiles
- def datasets(self, tile_index: TileIdx_txy) -> Tuple[Dataset, ...]:
+ def datasets(self, tile_index: TileIdx_txy) -> tuple[Dataset, ...]:
return tuple(
ds for ds in self._dscache.stream_grid_tile(tile_index, self._grid)
)
@@ -815,9 +825,9 @@ def datasets(self, tile_index: TileIdx_txy) -> Tuple[Dataset, ...]:
def load_task(
self,
tile_index: TileIdx_txy,
- product: Optional[OutputProduct] = None,
+ product: OutputProduct | None = None,
source: Any = None,
- ds_filters: Optional[str] = None,
+ ds_filters: str | None = None,
) -> Task:
product = self._resolve_product(product)
@@ -839,8 +849,8 @@ def load_task(
def stream(
self,
tiles: Iterable[TileIdx_txy],
- product: Optional[OutputProduct] = None,
- ds_filters: Optional[str] = None,
+ product: OutputProduct | None = None,
+ ds_filters: str | None = None,
) -> Iterator[Task]:
product = self._resolve_product(product)
for tidx in tiles:
@@ -849,9 +859,9 @@ def stream(
def stream_from_sqs(
self,
sqs_queue,
- product: Optional[OutputProduct] = None,
+ product: OutputProduct | None = None,
visibility_timeout: int = 300,
- ds_filters: Optional[str] = None,
+ ds_filters: str | None = None,
**kw,
) -> Iterator[Task]:
from odc.aws.queue import get_messages, get_queue
diff --git a/odc/stats/utils.py b/odc/stats/utils.py
index 104ccf70..7e20caab 100644
--- a/odc/stats/utils.py
+++ b/odc/stats/utils.py
@@ -1,11 +1,12 @@
import toolz
-from typing import Dict, Tuple, List, Any, Callable, Optional
+from typing import Any
+from collections.abc import Callable
from collections import namedtuple, defaultdict
from datetime import datetime
from dateutil.relativedelta import relativedelta
from .model import DateTimeRange, odc_uuid
from datacube.storage import measurement_paths
-from datacube.model import Dataset, DatasetType
+from datacube.model import Dataset, Product
from datacube.index.eo3 import prep_eo3
@@ -14,14 +15,14 @@
def _bin_generic(
- dss: List[CompressedDataset], bins: List[DateTimeRange]
-) -> Dict[str, List[CompressedDataset]]:
+ dss: list[CompressedDataset], bins: list[DateTimeRange]
+) -> dict[str, list[CompressedDataset]]:
"""
Dumb O(NM) implementation, N number of dataset, M number of bins.
For every bin find all datasets that fall in there, and if not empty keep that bin.
"""
- out: Dict[str, List[CompressedDataset]] = {}
+ out: dict[str, list[CompressedDataset]] = {}
for b in bins:
_dss = [ds for ds in dss if ds.time in b]
if len(_dss) > 0:
@@ -31,9 +32,9 @@ def _bin_generic(
def bin_generic(
- cells: Dict[Tuple[int, int], Cell], bins: List[DateTimeRange]
-) -> Dict[Tuple[str, int, int], List[CompressedDataset]]:
- tasks: Dict[Tuple[str, int, int], List[CompressedDataset]] = {}
+ cells: dict[tuple[int, int], Cell], bins: list[DateTimeRange]
+) -> dict[tuple[str, int, int], list[CompressedDataset]]:
+ tasks: dict[tuple[str, int, int], list[CompressedDataset]] = {}
for tidx, cell in cells.items():
_bins = _bin_generic(cell.dss, bins)
for t, dss in _bins.items():
@@ -43,11 +44,11 @@ def bin_generic(
def bin_seasonal(
- cells: Dict[Tuple[int, int], Cell],
+ cells: dict[tuple[int, int], Cell],
months: int,
anchor: int,
extract_single_season=False,
-) -> Dict[Tuple[str, int, int], List[CompressedDataset]]:
+) -> dict[tuple[str, int, int], list[CompressedDataset]]:
# mk_single_season_rules is different from mk_season_rules
# because the mk_season_rules will split the whole year to 2/3/4 seasons
# but mk_single_season_rules only extract a single season from the whole year
@@ -72,11 +73,11 @@ def bin_seasonal(
def bin_rolling_seasonal(
- cells: Dict[Tuple[int, int], Cell],
+ cells: dict[tuple[int, int], Cell],
temporal_range,
months: int,
interval: int,
-) -> Dict[Tuple[str, int, int], List[CompressedDataset]]:
+) -> dict[tuple[str, int, int], list[CompressedDataset]]:
binner = rolling_season_binner(
mk_rolling_season_rules(temporal_range, months, interval)
)
@@ -102,16 +103,16 @@ def bin_rolling_seasonal(
def bin_full_history(
- cells: Dict[Tuple[int, int], Cell], start: datetime, end: datetime
-) -> Dict[Tuple[str, int, int], List[CompressedDataset]]:
+ cells: dict[tuple[int, int], Cell], start: datetime, end: datetime
+) -> dict[tuple[str, int, int], list[CompressedDataset]]:
duration = end.year - start.year + 1
temporal_key = (f"{start.year}--P{duration}Y",)
return {temporal_key + k: cell.dss for k, cell in cells.items()}
def bin_annual(
- cells: Dict[Tuple[int, int], Cell],
-) -> Dict[Tuple[str, int, int], List[CompressedDataset]]:
+ cells: dict[tuple[int, int], Cell],
+) -> dict[tuple[str, int, int], list[CompressedDataset]]:
"""
Annual binning
:param cells: (x,y) -> Cell(dss: List[CompressedDataset], geobox: GeoBox, idx: Tuple[int, int])
@@ -131,7 +132,7 @@ def bin_annual(
return tasks
-def mk_single_season_rules(months: int, anchor: int) -> Dict[int, str]:
+def mk_single_season_rules(months: int, anchor: int) -> dict[int, str]:
"""
Construct rules for a each year single season summary
:param months: Length of season in months can be one of [1, 12]
@@ -140,7 +141,7 @@ def mk_single_season_rules(months: int, anchor: int) -> Dict[int, str]:
assert 1 <= months <= 12
assert 1 <= anchor <= 12
- rules: Dict[int, str] = {}
+ rules: dict[int, str] = {}
start_month = anchor
@@ -157,7 +158,7 @@ def mk_single_season_rules(months: int, anchor: int) -> Dict[int, str]:
return rules
-def mk_season_rules(months: int, anchor: int) -> Dict[int, str]:
+def mk_season_rules(months: int, anchor: int) -> dict[int, str]:
"""
Construct rules for a regular seasons
:param months: Length of season in months can be one of (1,2,3,4,6,12)
@@ -166,7 +167,7 @@ def mk_season_rules(months: int, anchor: int) -> Dict[int, str]:
assert months in (1, 2, 3, 4, 6, 12)
assert 1 <= anchor <= 12
- rules: Dict[int, str] = {}
+ rules: dict[int, str] = {}
for i in range(12 // months):
start_month = anchor + i * months
if start_month > 12:
@@ -201,18 +202,18 @@ def mk_rolling_season_rules(temporal_range, months, interval):
rules = {}
season_start = start_date
while (
- DateTimeRange(f'{season_start.strftime("%Y-%m-%d")}--P{months}M').end
+ DateTimeRange(f"{season_start.strftime('%Y-%m-%d')}--P{months}M").end
<= end_date
):
- rules[f'{season_start.strftime("%Y-%m")}--P{months}M'] = DateTimeRange(
- f'{season_start.strftime("%Y-%m-%d")}--P{months}M'
+ rules[f"{season_start.strftime('%Y-%m')}--P{months}M"] = DateTimeRange(
+ f"{season_start.strftime('%Y-%m-%d')}--P{months}M"
)
season_start += season_start_interval
return rules
-def season_binner(rules: Dict[int, str]) -> Callable[[datetime], str]:
+def season_binner(rules: dict[int, str]) -> Callable[[datetime], str]:
"""
Construct mapping from datetime to a string in the form like 2010-06--P3M
@@ -221,7 +222,7 @@ def season_binner(rules: Dict[int, str]) -> Callable[[datetime], str]:
month of the season and ``N`` is a duration of the season in
months.
"""
- _rules: Dict[int, Tuple[str, int]] = {}
+ _rules: dict[int, tuple[str, int]] = {}
for month in range(1, 12 + 1):
season = rules.get(month, "")
@@ -241,7 +242,7 @@ def label(dt: datetime) -> str:
return label
-def rolling_season_binner(rules: Dict[int, str]) -> Callable[[datetime], list]:
+def rolling_season_binner(rules: dict[int, str]) -> Callable[[datetime], list]:
"""
Construct mapping from datetime to a string in the form like 2010-06--P3M
@@ -299,7 +300,7 @@ def dedup_s2_datasets(dss):
return out, skipped
-def fuse_products(*ds_types) -> DatasetType:
+def fuse_products(*ds_types) -> Product:
"""
Fuses two products. This function requires access to a Datacube to access the metadata type.
@@ -352,12 +353,12 @@ def fuse_products(*ds_types) -> DatasetType:
for d in def_s:
fused_def["measurements"] += d["measurements"]
- return DatasetType(ds_types[0].metadata_type, fused_def)
+ return Product(ds_types[0].metadata_type, fused_def)
def fuse_ds(
*dss,
- product: Optional[DatasetType] = None,
+ product: Product | None = None,
) -> Dataset:
"""
This function fuses two datasets. It requires that:
@@ -375,7 +376,7 @@ def fuse_ds(
doc_s = [ds.metadata_doc for ds in dss]
if product is None:
- product = fuse_products(*[ds.type for ds in dss])
+ product = fuse_products(*[ds.product for ds in dss])
fused_doc = {
"id": str(odc_uuid(product.name, "0.0.0", sources=[d["id"] for d in doc_s])),
@@ -454,6 +455,5 @@ def fuse_ds(
for key, path in {**measurement_paths(ds)}.items():
fused_doc["measurements"][key]["path"] = path
- fused_ds = Dataset(product, prep_eo3(fused_doc), uris=[""])
- fused_doc["properties"]["fused"] = "True"
+ fused_ds = Dataset(product, prep_eo3(fused_doc), uri="fake")
return fused_ds
diff --git a/scripts/patch_version.py b/scripts/patch_version.py
index f2e3ba6b..c08e2ae0 100644
--- a/scripts/patch_version.py
+++ b/scripts/patch_version.py
@@ -32,9 +32,9 @@ def patch_version_lines(lines, patch_number):
def patch_file(fname, patch_number):
- with open(fname, "rt", encoding="utf-8") as src:
+ with open(fname, encoding="utf-8") as src:
lines = list(patch_version_lines(src, patch_number))
- with open(fname, "wt", encoding="utf-8") as dst:
+ with open(fname, "w", encoding="utf-8") as dst:
dst.writelines(lines)
diff --git a/setup.cfg b/setup.cfg
index 7f7cd778..0cf9afcd 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -22,17 +22,17 @@ install_requires =
botocore
click>=8.0.0
dask
- datacube<1.9
- distributed
+ datacube>=1.9.6
+ distributed>=2025.4
numpy
odc-cloud[ASYNC]>=0.2.5
- odc_algo
- odc_dscache>=0.2.3
+ odc_algo>=1.0.1
+ odc_dscache>=1.9
odc_io
- odc_stac
+ odc-geo>=0.5.0rc1
pandas
pystac>=1.1.0
- eodatasets3>=0.22.0
+ eodatasets3>=1.9
toolz
tqdm
xarray>=2023.1.0
@@ -56,7 +56,7 @@ include =
# datacube_ows<1.8.21 has issue on function config internal over-writing
[options.extras_require]
ows =
- datacube_ows>=1.8.21
+ datacube_ows>=1.9
sentry-sdk
blinker
diff --git a/tests/__init__.py b/tests/__init__.py
index ed793e49..85f6c52f 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -8,6 +8,7 @@
import xarray as xr
import dask.array as da
import numpy as np
+from odc.geo.xr import xr_coords
from odc.stats.utils import CompressedDataset
from odc.stats.plugins import StatsPluginInterface
from odc.stats.model import DateTimeRange
@@ -119,7 +120,7 @@ def mk_dask_xx(
elif data.dtype != dtype:
data = data.astype(dtype)
- coords = geobox.xr_coords(with_crs=True)
+ coords = xr_coords(geobox, crs_coord_name="spatial_ref")
coords["time"] = mk_time_coords(timestamps)
return xr.DataArray(data=data, dims=("time", "y", "x"), coords=coords, attrs=attrs)
diff --git a/tests/conftest.py b/tests/conftest.py
index 3675c165..602ea39f 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,6 +1,6 @@
import pathlib
import pytest
-from mock import MagicMock
+from unittest.mock import MagicMock
import boto3
from moto import mock_aws
from odc.stats.plugins import register
diff --git a/tests/requirements.txt b/tests/requirements.txt
index cf18641b..5e64e91e 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,15 +1,20 @@
--extra-index-url https://packages.dea.ga.gov.au/
-datacube<1.9
+datacube>=1.9.5
+datacube-ows>=1.9
# for pytest-depends
deepdiff
+distributed>=2025.4
+eodatasets3>=1.9
future_fstrings
mock
moto
networkx
numpy<2.0
-odc-algo @ git+https://github.com/opendatacube/odc-algo@adb1856
+odc-algo>=1.0.1
odc-cloud>=0.2.5
-odc-stac @ git+https://github.com/opendatacube/odc-stac@69bdf64
+odc-dscache>=1.9
+odc-geo>=0.5.0rc1
+odc-stac>=0.4.0
# For tests
pytest
diff --git a/tests/test-env-py38.yml b/tests/test-env-py38.yml
deleted file mode 100644
index e7c3c892..00000000
--- a/tests/test-env-py38.yml
+++ /dev/null
@@ -1,76 +0,0 @@
-# Conda environment for running tests in odc-tools
-# conda env create -f test-env-py38.yml
-# conda activate odc-tests-py38
-
-name: odc-tests-py38
-channels:
- - conda-forge
-dependencies:
- - python=3.8
-
- # Datacube
- - datacube>=1.8.7
-
- # odc.{aws,aio}: aiobotocore/boto3
- # pin aiobotocore for easier resolution of dependencies
- - aiobotocore==1.3.3
- - boto3
-
- # eodatasets3 (for odc-stats)
- - boltons
- - ciso8601
- - python-rapidjson
- - requests-cache==0.7.4 # 0.8.0 broke eodatasets3
- - ruamel.yaml
- - structlog
- - url-normalize
-
- # odc-stats
- - pandas
- - pystac>=1.1.0
- - toolz
- - tqdm
- # pin xarray version since groupby bug on multi-indexed dataset in 2022.6.0
- - xarray==2022.3.0
- - gdal
- - fsspec>=2022.1.0
- - fiona
-
- # For tests
- - pytest
- - pytest-httpserver
- - pytest-cov
- - pytest-timeout
- - moto
- - mock
- - deepdiff
-
- # for pytest-depends
- - future_fstrings
- - networkx
- - colorama
-
- # for docs
- - sphinx
- - sphinx_rtd_theme
- - sphinx-autodoc-typehints
- - nbsphinx
-
- - pip=20
- - pip:
- - odc-algo
- - odc-dscache>=0.2.2
- - odc-cloud[ASYNC]
- - thredds-crawler
-
- # odc.stats
- - eodatasets3>=0.22.0
-
- # odc.algo optional dependency
- - hdstats
-
- # tests
- - pytest-depends
-
- # for odc-stats
- - datacube_ows>=1.8.21
diff --git a/tests/test_fc_percentiles.py b/tests/test_fc_percentiles.py
index f4086f2c..a5184532 100644
--- a/tests/test_fc_percentiles.py
+++ b/tests/test_fc_percentiles.py
@@ -179,9 +179,13 @@ def test_reduce(dataset):
print(result)
assert (result == expected_result).all()
- assert set(xx.data_vars.keys()) == set(
- ["band_1_pc_10", "band_1_pc_50", "band_1_pc_90", "qa", "count_valid"]
- )
+ assert set(xx.data_vars.keys()) == {
+ "band_1_pc_10",
+ "band_1_pc_50",
+ "band_1_pc_90",
+ "qa",
+ "count_valid",
+ }
for band_name in xx.data_vars.keys():
if band_name not in ["count_valid"]:
diff --git a/tests/test_gm_ls.py b/tests/test_gm_ls.py
index cc45504a..91250f87 100644
--- a/tests/test_gm_ls.py
+++ b/tests/test_gm_ls.py
@@ -115,20 +115,18 @@ def test_result_bands_to_match_inputs(dataset):
xx = stats_gmls.native_transform(dataset)
result = stats_gmls.reduce(xx)
- assert set(result.data_vars.keys()) == set(
- [
- "nbart_red",
- "nbart_green",
- "nbart_blue",
- "nbart_nir",
- "nbart_swir_1",
- "nbart_swir_2",
- "sdev",
- "edev",
- "bcdev",
- "count",
- ]
- )
+ assert set(result.data_vars.keys()) == {
+ "nbart_red",
+ "nbart_green",
+ "nbart_blue",
+ "nbart_nir",
+ "nbart_swir_1",
+ "nbart_swir_2",
+ "sdev",
+ "edev",
+ "bcdev",
+ "count",
+ }
def test_result_aux_bands_to_match_inputs(dataset):
@@ -152,20 +150,18 @@ def test_result_aux_bands_to_match_inputs(dataset):
xx = stats_gmls.native_transform(dataset)
result = stats_gmls.reduce(xx)
- assert set(result.data_vars.keys()) == set(
- [
- "nbart_red",
- "nbart_green",
- "nbart_blue",
- "nbart_nir",
- "nbart_swir_1",
- "nbart_swir_2",
- "SDEV",
- "EDEV",
- "BCDEV",
- "COUNT",
- ]
- )
+ assert set(result.data_vars.keys()) == {
+ "nbart_red",
+ "nbart_green",
+ "nbart_blue",
+ "nbart_nir",
+ "nbart_swir_1",
+ "nbart_swir_2",
+ "SDEV",
+ "EDEV",
+ "BCDEV",
+ "COUNT",
+ }
def test_resampling(dataset):
diff --git a/tests/test_gm_ls_bitmask.py b/tests/test_gm_ls_bitmask.py
index d1dba5e5..58201516 100644
--- a/tests/test_gm_ls_bitmask.py
+++ b/tests/test_gm_ls_bitmask.py
@@ -119,9 +119,7 @@ def test_reduce(dataset):
result = xx.compute()
- assert set(xx.data_vars.keys()) == set(
- ["band_red", "smad", "emad", "bcmad", "count"]
- )
+ assert set(xx.data_vars.keys()) == {"band_red", "smad", "emad", "bcmad", "count"}
assert result["band_red"].dtype == np.uint16
assert result["emad"].dtype == np.uint16
@@ -157,9 +155,7 @@ def test_reduce_with_filters(dataset):
result = xx.compute()
- assert set(xx.data_vars.keys()) == set(
- ["band_red", "smad", "emad", "bcmad", "count"]
- )
+ assert set(xx.data_vars.keys()) == {"band_red", "smad", "emad", "bcmad", "count"}
expected_result = np.array([[229, 36], [48, 58]])
band_red = result["band_red"].data
@@ -190,6 +186,4 @@ def test_aux_result_bands_to_match_inputs(dataset):
xx = gm.native_transform(dataset)
xx = gm.reduce(xx)
- assert set(xx.data_vars.keys()) == set(
- ["band_red", "SMAD", "EMAD", "BCMAD", "COUNT"]
- )
+ assert set(xx.data_vars.keys()) == {"band_red", "SMAD", "EMAD", "BCMAD", "COUNT"}
diff --git a/tests/test_grouper.py b/tests/test_grouper.py
new file mode 100644
index 00000000..644a8755
--- /dev/null
+++ b/tests/test_grouper.py
@@ -0,0 +1,70 @@
+# This file is part of the Open Data Cube, see https://opendatacube.org for more information
+#
+# Copyright (c) 2015-2025 ODC Contributors
+# SPDX-License-Identifier: Apache-2.0
+import pytest
+from datacube.testutils import mk_sample_dataset
+
+from odc.stats._grouper import group_by_nothing, key2num, mid_longitude, solar_offset
+from odc.geo.geobox import GeoBox
+from odc.geo.geom import box as geom_box
+
+
+@pytest.mark.parametrize("lon,lat", [(0, 10), (100, -10), (-120, 30)])
+def test_mid_lon(lon, lat):
+ r = 0.1
+ rect = geom_box(lon - r, lat - r, lon + r, lat + r, "epsg:4326")
+ assert rect.centroid.coords[0] == pytest.approx((lon, lat))
+
+ assert mid_longitude(rect) == pytest.approx(lon)
+ assert mid_longitude(rect.to_crs("epsg:3857")) == pytest.approx(lon)
+
+ offset = solar_offset(rect, "h")
+ assert offset.seconds % (60 * 60) == 0
+
+ offset_sec = solar_offset(rect, "s")
+ assert abs((offset - offset_sec).seconds) <= 60 * 60
+
+
+@pytest.mark.parametrize(
+ "input_,expect",
+ [
+ ("ABAAC", [0, 1, 0, 0, 2]),
+ ("B", [0]),
+ ([1, 1, 1], [0, 0, 0]),
+ ("ABCC", [0, 1, 2, 2]),
+ ],
+)
+def test_key2num(input_, expect):
+ rr = list(key2num(input_))
+ assert rr == expect
+
+ reverse = {}
+ rr = list(key2num(input_, reverse))
+ assert rr == expect
+ assert set(reverse.keys()) == set(range(len(set(input_))))
+ assert set(reverse.values()) == set(input_)
+ # first entry always gets an index of 0
+ assert reverse[0] == input_[0]
+
+
+@pytest.fixture
+def sample_geobox():
+ yield GeoBox.from_geopolygon(geom_box(-10, -20, 11, 22, "epsg:4326"), resolution=1)
+
+
+@pytest.fixture
+def sample_ds(sample_geobox):
+ yield mk_sample_dataset([{"name": "red"}], geobox=sample_geobox)
+
+
+def test_grouper(sample_ds):
+ xx = group_by_nothing([sample_ds])
+ assert xx.values[0] == (sample_ds,)
+ assert xx.uuid.values[0] == sample_ds.id
+
+ xx = group_by_nothing([sample_ds, sample_ds], solar_offset(sample_ds.extent))
+ assert xx.values[0] == (sample_ds,)
+ assert xx.values[0] == (sample_ds,)
+ assert xx.uuid.values[1] == sample_ds.id
+ assert xx.uuid.values[1] == sample_ds.id
diff --git a/tests/test_io.py b/tests/test_io.py
new file mode 100644
index 00000000..65cac9ef
--- /dev/null
+++ b/tests/test_io.py
@@ -0,0 +1,37 @@
+import pytest
+
+from odc.stats.io import choose_transform_path
+
+
+@pytest.mark.parametrize("transform_code", ["EPSG:9688", "EPSG:1150"])
+@pytest.mark.parametrize("area_of_interest", [None, [-180, -90, 180, 90]])
+def test_choose_transform_path(transform_code, area_of_interest):
+ src_crs = "EPSG:32649"
+ dst_crs = "EPSG:3577"
+ proj_str = {
+ "9688": "+proj=pipeline +step +inv +proj=utm +zone=49 +ellps=WGS84 "
+ "+step +proj=push +v_3 "
+ "+step +proj=cart +ellps=WGS84 "
+ "+step +inv +proj=helmert +x=0.06155 +y=-0.01087 +z=-0.04019 "
+ "+rx=-0.0394924 +ry=-0.0327221 +rz=-0.0328979 +s=-0.009994 "
+ "+convention=coordinate_frame "
+ "+step +inv +proj=cart +ellps=GRS80 "
+ "+step +proj=pop +v_3 "
+ "+step +proj=aea +lat_0=0 +lon_0=132 +lat_1=-18 +lat_2=-36 "
+ "+x_0=0 +y_0=0 +ellps=GRS80",
+ "1150": "+proj=pipeline +step +inv +proj=utm +zone=49 +ellps=WGS84 "
+ "+step +proj=aea +lat_0=0 +lon_0=132 +lat_1=-18 +lat_2=-36 "
+ "+x_0=0 +y_0=0 +ellps=GRS80",
+ }
+ if transform_code is None and area_of_interest is None:
+ assert (
+ choose_transform_path(src_crs, dst_crs, transform_code, area_of_interest)
+ == {}
+ )
+ elif area_of_interest is None:
+ with pytest.raises(ValueError):
+ choose_transform_path(src_crs, dst_crs, transform_code, area_of_interest)
+ else:
+ assert choose_transform_path(
+ src_crs, dst_crs, transform_code, area_of_interest
+ ) == {"COORDINATE_OPERATION": proj_str.get(transform_code.split(":")[1], "")}
diff --git a/tests/test_lc_level34.py b/tests/test_lc_level34.py
index c19536b1..06f77143 100644
--- a/tests/test_lc_level34.py
+++ b/tests/test_lc_level34.py
@@ -7,7 +7,9 @@
import pandas as pd
import xarray as xr
import dask.array as da
-from datacube.utils.geometry import GeoBox
+from odc.geo import wh_
+from odc.geo.geobox import GeoBox
+from odc.geo.xr import xr_coords
from affine import Affine
from unittest.mock import patch
@@ -125,9 +127,9 @@ def image_groups():
(20 - 10) / l34.shape[2], (5 - 0) / l34.shape[1]
)
geobox = GeoBox(
- crs="epsg:3577", affine=affine, width=l34.shape[2], height=l34.shape[1]
+ crs="epsg:3577", affine=affine, shape=wh_(l34.shape[2], l34.shape[1])
)
- coords = geobox.xr_coords()
+ coords = xr_coords(geobox)
data_vars = {
"level_3_4": xr.DataArray(
@@ -401,10 +403,9 @@ def test_level4(urban_shape):
geobox = GeoBox(
crs="epsg:3577",
affine=affine,
- width=level_3_4.shape[2],
- height=level_3_4.shape[1],
+ shape=wh_(level_3_4.shape[2], level_3_4.shape[1]),
)
- coords = geobox.xr_coords()
+ coords = xr_coords(geobox)
data_vars = {
"level_3_4": xr.DataArray(
diff --git a/tests/test_mangroves.py b/tests/test_mangroves.py
index 87a99e5b..b18b9cae 100644
--- a/tests/test_mangroves.py
+++ b/tests/test_mangroves.py
@@ -7,7 +7,9 @@
import json
import fiona
from fiona.crs import CRS
-from datacube.utils.geometry import GeoBox
+from odc.geo import wh_
+from odc.geo.geobox import GeoBox
+from odc.geo.xr import xr_coords
from affine import Affine
import pytest
@@ -117,9 +119,9 @@ def dataset():
(20 - 10) / band_1.shape[2], (5 - 0) / band_1.shape[1]
)
geobox = GeoBox(
- crs="epsg:3577", affine=affine, width=band_1.shape[2], height=band_1.shape[1]
+ crs="epsg:3577", affine=affine, shape=wh_(band_1.shape[2], band_1.shape[1])
)
- coords = geobox.xr_coords()
+ coords = xr_coords(geobox)
coords.update({"time": index})
data_vars = {
diff --git a/tests/test_pq_bitmask.py b/tests/test_pq_bitmask.py
index 3e74f7eb..a73ca579 100644
--- a/tests/test_pq_bitmask.py
+++ b/tests/test_pq_bitmask.py
@@ -179,7 +179,7 @@ def test_reduce(dataset):
xx = pq.reduce(xx)
reduce_result = xx.compute()
- assert set(reduce_result.data_vars.keys()) == set(["total", "clear"])
+ assert set(reduce_result.data_vars.keys()) == {"total", "clear"}
expected_result = np.array([[2, 3], [3, 2]])
total = reduce_result["total"].data
@@ -201,9 +201,12 @@ def test_reduce_with_filter(dataset):
xx = pq.reduce(xx)
reduce_result = xx.compute()
- assert set(reduce_result.data_vars.keys()) == set(
- ["total", "clear", "clear_1_1", "clear_2_1_1"]
- )
+ assert set(reduce_result.data_vars.keys()) == {
+ "total",
+ "clear",
+ "clear_1_1",
+ "clear_2_1_1",
+ }
expected_result = np.array([[2, 3], [3, 2]])
total = reduce_result["total"].data
@@ -265,9 +268,7 @@ def test_reduce_for_aerosol(dataset_with_aerosol_band):
xx = pq.reduce(xx)
reduce_result = xx.compute()
- assert set(reduce_result.data_vars.keys()) == set(
- ["total", "clear", "clear_aerosol"]
- )
+ assert set(reduce_result.data_vars.keys()) == {"total", "clear", "clear_aerosol"}
expected_result = np.array([[2, 2], [1, 2]])
clear = reduce_result["clear"].data
@@ -294,9 +295,13 @@ def test_reduce_for_aerosol_with_filter(dataset_with_aerosol_band):
xx = pq.reduce(xx)
reduce_result = xx.compute()
- assert set(reduce_result.data_vars.keys()) == set(
- ["total", "clear", "clear_0_1_1", "clear_aerosol", "clear_0_1_1_aerosol"]
- )
+ assert set(reduce_result.data_vars.keys()) == {
+ "total",
+ "clear",
+ "clear_0_1_1",
+ "clear_aerosol",
+ "clear_0_1_1_aerosol",
+ }
expected_result = np.array([[2, 3], [3, 2]])
clear_1_1_0 = reduce_result["clear_0_1_1"].data
@@ -350,9 +355,7 @@ def test_reduce_for_atmos_opacity(dataset_with_atmos_opacity_band):
xx = pq.reduce(xx)
reduce_result = xx.compute()
- assert set(reduce_result.data_vars.keys()) == set(
- ["total", "clear", "clear_aerosol"]
- )
+ assert set(reduce_result.data_vars.keys()) == {"total", "clear", "clear_aerosol"}
expected_result = np.array([[2, 2], [1, 2]])
clear = reduce_result["clear"].data
diff --git a/tests/test_save_tasks.py b/tests/test_save_tasks.py
index 1e116565..72f7d2ca 100644
--- a/tests/test_save_tasks.py
+++ b/tests/test_save_tasks.py
@@ -143,12 +143,12 @@ def test_create_dss_by_stac(s3_path):
)
dss = list(dss)
assert len(dss) == 4 * 2 * len(s3_path)
- products = list(set([d.product for d in dss]))
+ products = list({d.product for d in dss})
assert len(products) == len(s3_path)
for d in dss:
with_uris = False
for key in s3_path:
- with_uris |= "/".join(key.split("/")[-2:]) in d.uris[0]
+ with_uris |= "/".join(key.split("/")[-2:]) in d.uri
assert with_uris
diff --git a/tests/test_sqs.py b/tests/test_sqs.py
index 2113ad2f..524ba3db 100644
--- a/tests/test_sqs.py
+++ b/tests/test_sqs.py
@@ -3,7 +3,7 @@
import boto3
import moto
-from datacube.utils.geometry import Geometry
+from odc.geo import Geometry
from odc.aws.queue import get_queue, publish_message
from odc.stats._cli_publish_tasks import filter_tasks, get_geometry, publish_tasks
from odc.stats._sqs import SQSWorkToken
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 8b8034b2..4541733e 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -5,7 +5,7 @@
import pystac
import pytest
from datacube import Datacube
-from datacube.model import Dataset, DatasetType, metadata_from_doc
+from datacube.model import Dataset, Product, metadata_from_doc
from datacube.index.eo3 import prep_eo3
from datacube.index.abstract import default_metadata_type_docs
from odc.stats.model import DateTimeRange
@@ -72,7 +72,7 @@ def verify(task):
dss1 = tasks[k]
dss2 = tasks_y[k]
- assert set(ds.id for ds in dss1) == set(ds.id for ds in dss2)
+ assert {ds.id for ds in dss1} == {ds.id for ds in dss2}
tasks = bin_seasonal(cells, 6, 1)
verify(tasks)
@@ -292,19 +292,19 @@ def test_fuse_products(wo_definition, fc_definition):
}
eo3 = standard_metadata_types["eo3"]
- wo_product = DatasetType(eo3, wo_definition)
- fc_product = DatasetType(eo3, fc_definition)
+ wo_product = Product(eo3, wo_definition)
+ fc_product = Product(eo3, fc_definition)
fuse_products(wo_product, fc_product)
bad_definition = deepcopy(wo_definition)
bad_definition["metadata"]["properties"]["odc:file_format"] = "bad"
- bad_product = DatasetType(eo3, bad_definition)
+ bad_product = Product(eo3, bad_definition)
with pytest.raises(ValueError):
fuse_products(bad_product, fc_product)
bad_definition = deepcopy(wo_definition)
bad_definition["measurements"].append(fc_definition["measurements"][1])
- bad_product = DatasetType(eo3, bad_definition)
+ bad_product = Product(eo3, bad_definition)
with pytest.raises(ValueError):
fuse_products(bad_product, fc_product)
@@ -314,13 +314,13 @@ def test_fuse_products(wo_definition, fc_definition):
fc_no_ff = deepcopy(fc_definition)
del fc_no_ff["metadata"]["properties"]["odc:file_format"]
- wo_product = DatasetType(eo3, wo_no_ff)
- fc_product = DatasetType(eo3, fc_no_ff)
+ wo_product = Product(eo3, wo_no_ff)
+ fc_product = Product(eo3, fc_no_ff)
fuse_products(wo_product, fc_product)
def _get_msr_paths(ds):
- return set(m["path"] for m in ds.metadata_doc["measurements"].values())
+ return {m["path"] for m in ds.metadata_doc["measurements"].values()}
def test_fuse_dss(wo_definition, fc_definition):
@@ -329,8 +329,8 @@ def test_fuse_dss(wo_definition, fc_definition):
}
eo3 = standard_metadata_types["eo3"]
- wo_product = DatasetType(eo3, wo_definition)
- fc_product = DatasetType(eo3, fc_definition)
+ wo_product = Product(eo3, wo_definition)
+ fc_product = Product(eo3, fc_definition)
fused_product = fuse_products(wo_product, fc_product)
wo_metadata = {
@@ -477,16 +477,12 @@ def test_fuse_dss(wo_definition, fc_definition):
# paths get made absolute here
# TODO: force paths to stay relative
- wo_uris = [
- "s3://dea-public-data/derivative/ga_ls_wo_3/1-6-0/091/086/2020/04/04/\
- ga_ls_wo_3_091086_2020-04-04_final.stac-item.json"
- ]
- wo_ds = Dataset(wo_product, prep_eo3(wo_metadata), uris=wo_uris)
- fc_uris = [
- "s3://dea-public-data/derivative/ga_ls_fc_3/2-5-0/091/086/2020/04/04/\
- ga_ls_fc_3_091086_2020-04-04_final.stac-item.json"
- ]
- fc_ds = Dataset(fc_product, prep_eo3(fc_metadata), uris=fc_uris)
+ wo_uri = "s3://dea-public-data/derivative/ga_ls_wo_3/1-6-0/091/086/2020/04/04/\
+ ga_ls_wo_3_091086_2020-04-04_final.stac-item.json"
+ wo_ds = Dataset(wo_product, prep_eo3(wo_metadata), uri=wo_uri)
+ fc_uri = "s3://dea-public-data/derivative/ga_ls_fc_3/2-5-0/091/086/2020/04/04/\
+ ga_ls_fc_3_091086_2020-04-04_final.stac-item.json"
+ fc_ds = Dataset(fc_product, prep_eo3(fc_metadata), uri=fc_uri)
fused_ds = fuse_ds(wo_ds, fc_ds, product=fused_product)
assert _get_msr_paths(fused_ds) == _get_msr_paths(fc_ds).union(
@@ -499,25 +495,25 @@ def test_fuse_dss(wo_definition, fc_definition):
bad_metadata = deepcopy(fc_metadata)
bad_metadata["properties"]["datetime"] = "2020-04-03T23:33:10.644420Z"
- bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uris=fc_uris)
+ bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uri=fc_uri)
with pytest.raises(ValueError):
fused_ds = fuse_ds(wo_ds, bad_ds, product=fused_product)
bad_metadata = deepcopy(fc_metadata)
bad_metadata["crs"] = "epsg:32656"
- bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uris=fc_uris)
+ bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uri=fc_uri)
with pytest.raises(ValueError):
fused_ds = fuse_ds(wo_ds, bad_ds, product=fused_product)
bad_metadata = deepcopy(fc_metadata)
bad_metadata["grids"]["default"]["shape"] = [7212, 8311]
- bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uris=fc_uris)
+ bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uri=fc_uri)
with pytest.raises(ValueError):
fused_ds = fuse_ds(wo_ds, bad_ds, product=fused_product)
bad_metadata = deepcopy(fc_metadata)
bad_metadata["label"] += "a"
- bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uris=fc_uris)
+ bad_ds = Dataset(fc_product, prep_eo3(bad_metadata), uri=fc_uri)
with pytest.raises(ValueError):
fused_ds = fuse_ds(wo_ds, bad_ds, product=fused_product)
@@ -526,6 +522,6 @@ def test_fuse_dss(wo_definition, fc_definition):
fc_no_ff = deepcopy(fc_metadata)
del wo_no_ff["properties"]["odc:file_format"]
del fc_no_ff["properties"]["odc:file_format"]
- wo_ds = Dataset(wo_product, prep_eo3(wo_no_ff), uris=wo_uris)
- fc_ds = Dataset(fc_product, prep_eo3(fc_no_ff), uris=fc_uris)
+ wo_ds = Dataset(wo_product, prep_eo3(wo_no_ff), uri=wo_uri)
+ fc_ds = Dataset(fc_product, prep_eo3(fc_no_ff), uri=fc_uri)
fuse_ds(wo_ds, fc_ds, product=fused_product)